@dascompany/database 3.1.4 → 4.0.0

package/dist/Connection.d.ts

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

package/dist/Connection.js

@@ -1,22 +1,37 @@
 import Query from './query/Query';
 export default class Connection {
-    pgClient;
-    constructor(pgClient) {
-        this.pgClient = pgClient;
-    }
-    createQuery(queryString) {
-        return new Query(this.pgClient, queryString);
+    client;
+    inTransaction = false;
+    constructor(client) {
+        this.client = client;
     }
     async beginTransaction() {
-        await this.pgClient.query('BEGIN');
+        await this.client.query('BEGIN');
+        this.inTransaction = true;
     }
     async commitTransaction() {
-        await this.pgClient.query('COMMIT');
+        if (!this.inTransaction)
+            throw new Error('Transaction has not been started.');
+        await this.client.query('COMMIT');
+        this.inTransaction = false;
+        this.client.release();
     }
     async rollBackTransaction() {
-        await this.pgClient.query('ROLLBACK');
+        if (!this.inTransaction)
+            throw new Error('Transaction has not been started.');
+        await this.client.query('ROLLBACK');
+        this.inTransaction = false;
+        this.client.release();
+    }
+    createQuery(queryString) {
+        return new Query(this.client, queryString);
     }
     async end() {
-        this.pgClient.end();
+        if (!this.inTransaction) {
+            this.client.release();
+        }
+        else {
+            throw new Error('Cannot release client while transaction is active.');
+        }
     }
 }

package/dist/ConnectionFactory.d.ts

@@ -1,14 +1,11 @@
 import DatabaseConfig from "./DatabaseConfig";
 import Connection from "./Connection";
 export default class ConnectionFactory {
-    private static connections;
+    private static pool;
     private static configName;
     private static configField;
     private static configPath;
     private static defaultDatabaseName;
     static create(name?: string): Promise<Connection>;
-    static isCreated(name?: string): boolean;
-    static get(name?: string): Connection;
-    private static createConnection;
     protected static getDatabaseConfig(): Promise<DatabaseConfig>;
 }

package/dist/ConnectionFactory.js

@@ -2,41 +2,18 @@ import Database from "./Database";
 import Connection from "./Connection";
 import { readFile } from 'fs/promises';
 export default class ConnectionFactory {
-    static connections = new Map();
+    static pool = null;
     static configName = 'config.json';
     static configField = 'database';
     static configPath = './server/';
     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.pool) {
+            const config = await this.getDatabaseConfig();
+            this.pool = Database.connect(config);
         }
-        else
-            throw new Error(`Connection for name: ${name} is already created! `);
-        return connection;
-    }
-    static isCreated(name) {
-        name = name || this.defaultDatabaseName;
-        let connection = this.connections.get(name);
-        if (!connection)
-            return false;
-        else
-            return true;
-    }
-    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! `);
-        return connection;
-    }
-    static async createConnection() {
-        const databaseConfig = await this.getDatabaseConfig();
-        const pgClient = await Database.connect(databaseConfig);
-        return new Connection(pgClient);
+        const client = await this.pool.connect();
+        return new Connection(client);
     }
     static async getDatabaseConfig() {
         let config = JSON.parse(await readFile(`${this.configPath}${this.configName}`, "utf8"));

package/dist/Database.d.ts

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

package/dist/Database.js

@@ -1,14 +1,11 @@
-import pg from 'pg';
+import { Pool } from 'pg';
 export default class Database {
-    static async connect(connectionConfig) {
-        try {
-            const pgClient = new pg.Client(connectionConfig);
-            await pgClient.connect();
-            return pgClient;
-        }
-        catch (error) {
-            error.message = `Database connection failed!\n ${error.message}`;
-            throw error;
+    static pool = null;
+    static connect(connectionConfig) {
+        if (!this.pool) {
+            this.pool = new Pool(connectionConfig);
+            console.log('Database pool created');
         }
+        return this.pool;
     }
 }

package/dist/query/QueryParamCreator.js

@@ -18,7 +18,10 @@ export default class QueryParamCreator {
         }
     }
     static isArrayType(type) {
-        if (type == ParameterType.arrayString || type == ParameterType.arrayNumber || type == ParameterType.arrayBoolean)
+        if (type == ParameterType.arrayString ||
+            type == ParameterType.arrayNumber ||
+            type == ParameterType.arrayBoolean ||
+            type == ParameterType.arrayBigint)
             return true;
         else
             return false;

package/dist/query/ResultsCorrector.d.ts

@@ -0,0 +1,4 @@
+export default class ResultsCorrector {
+    static correctRows(rows: Array<any>): Array<any>;
+    private static isNumber;
+}

package/dist/query/ResultsCorrector.js

@@ -0,0 +1,14 @@
+export default class ResultsCorrector {
+    static correctRows(rows) {
+        rows.forEach((row) => {
+            Object.keys(row).forEach((key) => {
+                if (this.isNumber(row[key]))
+                    row[key] = Number(row[key]);
+            });
+        });
+        return rows;
+    }
+    static isNumber(n) {
+        return !isNaN(parseFloat(n)) && !isNaN(n - 0);
+    }
+}

package/dist/types/StockObject.d.ts

@@ -2,8 +2,8 @@ import StockObjectMapper from "./StockObjectMapper";
 export default abstract class StockObject {
     private id;
     protected abstract getMapper(): StockObjectMapper;
-    getId(): number | null;
-    setId(clientId: number): void;
+    getId(): string | null;
+    setId(id: string): void;
     save(): Promise<void>;
     delete(): Promise<void>;
 }

package/dist/types/StockObject.js

@@ -3,8 +3,8 @@ export default class StockObject {
     getId() {
         return this.id;
     }
-    setId(clientId) {
-        this.id = clientId;
+    setId(id) {
+        this.id = id;
     }
     async save() {
         await this.getMapper().save();

package/package.json

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