@dascompany/database 4.0.2 → 4.0.4

package/dist/Connection.d.ts

@@ -1,11 +1,11 @@
-import { Client } from 'pg';
+import pg from 'pg';
 import Query from './query/Query';
 export default class Connection {
-    private pgClient;
-    constructor(pgClient: Client);
+    private pgPool;
+    constructor(pgPool: pg.Pool);
     createQuery(queryString: string): Query;
-    beginTransaction(): Promise<void>;
-    commitTransaction(): Promise<void>;
-    rollBackTransaction(): Promise<void>;
+    beginTransaction(): Promise<pg.PoolClient>;
+    commitTransaction(client: pg.PoolClient): Promise<void>;
+    rollBackTransaction(client: pg.PoolClient): Promise<void>;
     end(): Promise<void>;
 }

package/dist/Connection.js

@@ -1,22 +1,26 @@
 import Query from './query/Query';
 export default class Connection {
-    pgClient;
-    constructor(pgClient) {
-        this.pgClient = pgClient;
+    pgPool;
+    constructor(pgPool) {
+        this.pgPool = pgPool;
     }
     createQuery(queryString) {
-        return new Query(this.pgClient, queryString);
+        return new Query(this.pgPool, queryString);
     }
     async beginTransaction() {
-        await this.pgClient.query('BEGIN');
+        const client = await this.pgPool.connect();
+        await client.query('BEGIN');
+        return client;
     }
-    async commitTransaction() {
-        await this.pgClient.query('COMMIT');
+    async commitTransaction(client) {
+        await client.query('COMMIT');
+        client.release();
     }
-    async rollBackTransaction() {
-        await this.pgClient.query('ROLLBACK');
+    async rollBackTransaction(client) {
+        await client.query('ROLLBACK');
+        client.release();
     }
     async end() {
-        this.pgClient.end();
+        await this.pgPool.end();
     }
 }

package/dist/ConnectionFactory.js

@@ -9,39 +9,35 @@ export default class ConnectionFactory {
     static defaultDatabaseName = 'defaultDatabaseName';
     static async create(name) {
         name = name || this.defaultDatabaseName;
-        let connection = this.connections.get(name);
-        if (!connection) {
-            connection = await this.createConnection();
-            this.connections.set(name, connection);
+        if (this.connections.has(name)) {
+            throw new Error(`Connection for name: ${name} is already created!`);
         }
-        else
-            throw new Error(`Connection for name: ${name} is already created! `);
+        const connection = await this.createConnection();
+        this.connections.set(name, connection);
         return connection;
     }
     static isCreated(name) {
         name = name || this.defaultDatabaseName;
-        let connection = this.connections.get(name);
-        if (!connection)
-            return false;
-        else
-            return true;
+        return this.connections.has(name);
     }
     static get(name) {
         name = name || this.defaultDatabaseName;
         const connection = this.connections.get(name);
-        if (!connection)
-            throw new Error(`Connection with name: ${name} is not create! `);
+        if (!connection) {
+            throw new Error(`Connection with name: ${name} is not created!`);
+        }
         return connection;
     }
     static async createConnection() {
         const databaseConfig = await this.getDatabaseConfig();
-        const pgClient = await Database.connect(databaseConfig);
-        return new Connection(pgClient);
+        const pgPool = await Database.connect(databaseConfig);
+        return new Connection(pgPool);
     }
     static async getDatabaseConfig() {
         let config = JSON.parse(await readFile(`${this.configPath}${this.configName}`, "utf8"));
-        if (this.configField)
+        if (this.configField) {
             config = config[this.configField];
+        }
         return config;
     }
 }

package/dist/Database.d.ts

@@ -1,4 +1,4 @@
-import { Client, type ConnectionConfig } from 'pg';
+import pg from 'pg';
 export default class Database {
-    static connect(connectionConfig: ConnectionConfig): Promise<Client>;
+    static connect(connectionConfig: pg.PoolConfig): Promise<pg.Pool>;
 }

package/dist/Database.js

@@ -2,12 +2,12 @@ import pg from 'pg';
 export default class Database {
     static async connect(connectionConfig) {
         try {
-            const pgClient = new pg.Client(connectionConfig);
-            await pgClient.connect();
-            return pgClient;
+            const pool = new pg.Pool(connectionConfig);
+            await pool.query('SELECT 1');
+            return pool;
         }
         catch (error) {
-            error.message = `Database connection failed!\n ${error.message}`;
+            error.message = `Database connection failed!\n${error.message}`;
             throw error;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dascompany/database",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "main": "dist/index.js",
   "scripts": {
     "test": "vitest",