@dascompany/database 4.0.7 → 4.0.8

package/dist/Connection.d.ts

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

package/dist/Connection.js

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

package/dist/ConnectionFactory.js

@@ -9,35 +9,39 @@ export default class ConnectionFactory {
     static defaultDatabaseName = 'defaultDatabaseName';
     static async create(name) {
         name = name || this.defaultDatabaseName;
-        if (this.connections.has(name)) {
-            throw new Error(`Connection for name: ${name} is already created!`);
+        let connection = this.connections.get(name);
+        if (!connection) {
+            connection = await this.createConnection();
+            this.connections.set(name, connection);
         }
-        const connection = await this.createConnection();
-        this.connections.set(name, connection);
+        else
+            throw new Error(`Connection for name: ${name} is already created! `);
         return connection;
     }
     static isCreated(name) {
         name = name || this.defaultDatabaseName;
-        return this.connections.has(name);
+        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 created!`);
-        }
+        if (!connection)
+            throw new Error(`Connection with name: ${name} is not create! `);
         return connection;
     }
     static async createConnection() {
         const databaseConfig = await this.getDatabaseConfig();
-        const pgPool = await Database.connect(databaseConfig);
-        return new Connection(pgPool);
+        const pgClient = await Database.connect(databaseConfig);
+        return new Connection(pgClient);
     }
     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 pg from 'pg';
+import { Client, type ConnectionConfig } from 'pg';
 export default class Database {
-    static connect(connectionConfig: pg.PoolConfig): Promise<pg.Pool>;
+    static connect(connectionConfig: ConnectionConfig): Promise<Client>;
 }

package/dist/Database.js

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

package/dist/Table.d.ts

@@ -1,10 +1,8 @@
 import Connection from './Connection';
 import Query from './query/Query';
 import QueryOptions from './query/QueryOptions';
-import type { PoolClient } from 'pg';
 export default abstract class Table {
     private connection;
-    private client;
-    constructor(connection: Connection, client: PoolClient);
+    constructor(connection: Connection);
     createQuery(queryString: string, options?: QueryOptions): Query;
 }

package/dist/Table.js

@@ -2,17 +2,15 @@ import QueryParams from './query/QueryParams';
 import BindParams from './query/BindParams';
 export default class Table {
     connection;
-    client;
-    constructor(connection, client) {
+    constructor(connection) {
         this.connection = connection;
-        this.client = client;
     }
     createQuery(queryString, options) {
         if (!queryString)
             throw new Error('Nie podano queryString');
         if (options)
             queryString = QueryParams.createParams(queryString, options);
-        const query = this.connection.createQuery(queryString, this.client);
+        const query = this.connection.createQuery(queryString);
         if (options)
             BindParams.bindParams(query, options);
         return query;

package/dist/index.d.ts

@@ -13,5 +13,4 @@ import OrderByI from "./types/OrderByI";
 import QueryOptions from './query/QueryOptions';
 import ConnectorE from "./types/ConnectorE";
 import Connection from "./Connection";
-import TransactionClient from "./TransactionClient";
-export { ConnectionFactory, StockObject, StockObjectMapper, Table, Query, ParameterType, ParameterFilter, ConnectorE, ParameterI, QueryOptionsI, ResultLimitationI, Parameters, OrderByI, QueryOptions, Connection, TransactionClient };
+export { ConnectionFactory, StockObject, StockObjectMapper, Table, Query, ParameterType, ParameterFilter, ConnectorE, ParameterI, QueryOptionsI, ResultLimitationI, Parameters, OrderByI, QueryOptions, Connection };

package/dist/index.js

@@ -7,5 +7,4 @@ import Parameters from './utils/Parameters';
 import QueryOptions from './query/QueryOptions';
 import ConnectorE from "./types/ConnectorE";
 import Connection from "./Connection";
-import TransactionClient from "./TransactionClient";
-export { ConnectionFactory, StockObject, Table, Query, ParameterType, ConnectorE, Parameters, QueryOptions, Connection, TransactionClient };
+export { ConnectionFactory, StockObject, Table, Query, ParameterType, ConnectorE, Parameters, QueryOptions, Connection };

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(): string | null;
-    setId(id: string): void;
+    getId(): number | null;
+    setId(clientId: number): 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(id) {
-        this.id = id;
+    setId(clientId) {
+        this.id = clientId;
     }
     async save() {
         await this.getMapper().save();

package/package.json

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

package/dist/TransactionClient.d.ts

@@ -1,9 +0,0 @@
-import pg from 'pg';
-export default class TransactionClient {
-    private client;
-    private active;
-    constructor(client: pg.PoolClient);
-    beginTransaction(): Promise<void>;
-    commitTransaction(): Promise<void>;
-    rollBackTransaction(): Promise<void>;
-}

package/dist/TransactionClient.js

@@ -1,30 +0,0 @@
-export default class TransactionClient {
-    client;
-    active = false;
-    constructor(client) {
-        this.client = client;
-    }
-    async beginTransaction() {
-        if (this.active) {
-            throw new Error('Transaction already active');
-        }
-        await this.client.query('BEGIN');
-        this.active = true;
-    }
-    async commitTransaction() {
-        if (!this.active) {
-            throw new Error('No active transaction to commit');
-        }
-        await this.client.query('COMMIT');
-        this.client.release();
-        this.active = false;
-    }
-    async rollBackTransaction() {
-        if (!this.active) {
-            throw new Error('No active transaction to roll back');
-        }
-        await this.client.query('ROLLBACK');
-        this.client.release();
-        this.active = false;
-    }
-}

package/dist/query/ResultsCorrector.d.ts

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

package/dist/query/ResultsCorrector.js

@@ -1,14 +0,0 @@
-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);
-    }
-}