@dascompany/database 4.1.0 → 4.2.0

package/dist/Connection.d.ts

@@ -1,13 +1,11 @@
-import pg from 'pg';
+import { PoolClient } from 'pg';
 import Query from './query/Query';
-import TransactionClient from './TransactionClient';
 export default class Connection {
-    private pgPool;
-    private transactionClient;
-    constructor(pgPool: pg.Pool);
-    createQuery(queryString: string, client?: pg.PoolClient): Query;
-    getTransaction(): TransactionClient;
-    createTransaction(): Promise<TransactionClient>;
-    getClient(): Promise<pg.PoolClient>;
-    end(): Promise<void>;
+    private poolClient;
+    private activeTransaction;
+    constructor(poolClient: PoolClient);
+    createQuery(queryString: string): Query;
+    beginTransaction(): Promise<void>;
+    commitTransaction(): Promise<void>;
+    rollBackTransaction(): Promise<void>;
 }

package/dist/Connection.js

@@ -1,30 +1,30 @@
 import Query from './query/Query';
-import TransactionClient from './TransactionClient';
 export default class Connection {
-    pgPool;
-    transactionClient;
-    constructor(pgPool) {
-        this.pgPool = pgPool;
+    poolClient;
+    activeTransaction = false;
+    constructor(poolClient) {
+        this.poolClient = poolClient;
     }
-    createQuery(queryString, client) {
-        if (this.transactionClient && this.transactionClient.pending())
-            return new Query(this.transactionClient.getClient(), queryString);
-        else
-            return new Query(client ?? this.pgPool, queryString);
+    createQuery(queryString) {
+        return new Query(this.poolClient, queryString);
     }
-    getTransaction() {
-        return this.transactionClient;
+    async beginTransaction() {
+        await this.poolClient.query('BEGIN');
     }
-    async createTransaction() {
-        if (!!this.transactionClient && this.transactionClient.pending())
-            throw new Error("there is no free client ");
-        this.transactionClient = new TransactionClient(await this.getClient());
-        return this.transactionClient;
+    async commitTransaction() {
+        if (!this.activeTransaction) {
+            throw new Error('No active transaction to commit');
+        }
+        await this.poolClient.query('COMMIT');
+        this.poolClient.release();
+        this.activeTransaction = false;
     }
-    async getClient() {
-        return this.pgPool.connect();
-    }
-    async end() {
-        await this.pgPool.end();
+    async rollBackTransaction() {
+        if (!this.activeTransaction) {
+            throw new Error('No active transaction to roll back');
+        }
+        await this.poolClient.query('ROLLBACK');
+        this.poolClient.release();
+        this.activeTransaction = false;
     }
 }

package/dist/ConnectionFactory.d.ts

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

package/dist/ConnectionFactory.js

@@ -2,57 +2,16 @@ import Database from "./Database";
 import Connection from "./Connection";
 import { readFile } from 'fs/promises';
 export default class ConnectionFactory {
-    static numberOfAttemptsAllowed = 3;
-    static connections = new Map();
     static configName = 'config.json';
     static configField = 'database';
     static configPath = './server/';
-    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!`);
-        }
-        const connection = await this.createConnection();
-        this.connections.set(name, connection);
-        return connection;
-    }
-    static async test(name, attempt = 1) {
-        name = name || this.defaultDatabaseName;
-        let connection = this.connections.get(name);
-        if (!connection) {
-            connection = await this.createConnection();
-            this.connections.set(name, connection);
-        }
-        try {
-            const client = await connection.getClient();
-            connection?.createQuery("SELECT 1", client);
-            return connection;
-        }
-        catch (err) {
-            this.connections.delete(name);
-            if (this.numberOfAttemptsAllowed >= attempt)
-                return this.test('', attempt + 1);
-            else
-                throw new Error("Testing connection failed. Could not re-establish connection. Message: " + err);
-        }
-    }
-    static isCreated(name) {
-        name = name || this.defaultDatabaseName;
-        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 created!`);
-        }
-        return connection;
-    }
+    static pool;
     static async createConnection() {
         const databaseConfig = await this.getDatabaseConfig();
-        const pgPool = await Database.connect(databaseConfig);
-        return new Connection(pgPool);
+        if (!this.pool || await this.pool.query('SELECT 1').catch(() => false))
+            this.pool = await Database.connect(databaseConfig);
+        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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dascompany/database",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/dist/TESTConnection.d.ts

@@ -1,12 +0,0 @@
-import pg from 'pg';
-import Query from './query/Query';
-import TESTTransactionClient from './TESTTransactionClient';
-export default class TESTConnection {
-    private pgPool;
-    private TESTtransactionClient;
-    constructor(pgPool: pg.Pool);
-    createTransaction(): Promise<TESTTransactionClient>;
-    createQuery(queryString: string, client: pg.PoolClient): Query;
-    getClient(): Promise<pg.PoolClient>;
-    end(): Promise<void>;
-}

package/dist/TESTConnection.js

@@ -1,25 +0,0 @@
-import Query from './query/Query';
-import TESTTransactionClient from './TESTTransactionClient';
-export default class TESTConnection {
-    pgPool;
-    TESTtransactionClient;
-    constructor(pgPool) {
-        this.pgPool = pgPool;
-    }
-    async createTransaction() {
-        this.TESTtransactionClient = new TESTTransactionClient(await this.getClient());
-        return this.TESTtransactionClient;
-    }
-    createQuery(queryString, client) {
-        if (this.TESTtransactionClient.pending())
-            return new Query(this.TESTtransactionClient.getClient(), queryString);
-        else
-            return new Query(client ?? this.pgPool, queryString);
-    }
-    async getClient() {
-        return this.pgPool.connect();
-    }
-    async end() {
-        await this.pgPool.end();
-    }
-}

package/dist/TESTConnectionFactory.d.ts

@@ -1,16 +0,0 @@
-import DatabaseConfig from "./DatabaseConfig";
-import TESTConnection from "./TESTConnection";
-export default class TESTConnectionFactory {
-    private static numberOfAttemptsAllowed;
-    private static TESTConnections;
-    private static configName;
-    private static configField;
-    private static configPath;
-    private static defaultDatabaseName;
-    static create(name?: string): Promise<TESTConnection>;
-    static test(name?: string, attempt?: number): Promise<TESTConnection>;
-    static isCreated(name?: string): boolean;
-    static get(name?: string): TESTConnection;
-    private static createTESTConnection;
-    protected static getDatabaseConfig(): Promise<DatabaseConfig>;
-}

package/dist/TESTConnectionFactory.js

@@ -1,64 +0,0 @@
-import Database from "./Database";
-import TESTConnection from "./TESTConnection";
-import { readFile } from 'fs/promises';
-export default class TESTConnectionFactory {
-    static numberOfAttemptsAllowed = 3;
-    static TESTConnections = new Map();
-    static configName = 'config.json';
-    static configField = 'database';
-    static configPath = './server/';
-    static defaultDatabaseName = 'defaultDatabaseName';
-    static async create(name) {
-        name = name || this.defaultDatabaseName;
-        if (this.TESTConnections.has(name)) {
-            throw new Error(`TESTConnection for name: ${name} is already created!`);
-        }
-        const TESTConnection = await this.createTESTConnection();
-        this.TESTConnections.set(name, TESTConnection);
-        return TESTConnection;
-    }
-    static async test(name, attempt = 1) {
-        name = name || this.defaultDatabaseName;
-        const TESTConnection = this.TESTConnections.get(name);
-        if (!TESTConnection) {
-            const TESTConnection = await this.create(name);
-            return TESTConnection;
-        }
-        try {
-            const client = await TESTConnection.getClient();
-            TESTConnection?.createQuery("SELECT 1", client);
-            return TESTConnection;
-        }
-        catch (err) {
-            this.TESTConnections.delete(name);
-            if (this.numberOfAttemptsAllowed >= attempt)
-                return this.test('', attempt + 1);
-            else
-                throw new Error("Testing TESTConnection failed. Could not re-establish TESTConnection.");
-        }
-    }
-    static isCreated(name) {
-        name = name || this.defaultDatabaseName;
-        return this.TESTConnections.has(name);
-    }
-    static get(name) {
-        name = name || this.defaultDatabaseName;
-        const TESTConnection = this.TESTConnections.get(name);
-        if (!TESTConnection) {
-            throw new Error(`TESTConnection with name: ${name} is not created!`);
-        }
-        return TESTConnection;
-    }
-    static async createTESTConnection() {
-        const databaseConfig = await this.getDatabaseConfig();
-        const pgPool = await Database.connect(databaseConfig);
-        return new TESTConnection(pgPool);
-    }
-    static async getDatabaseConfig() {
-        let config = JSON.parse(await readFile(`${this.configPath}${this.configName}`, "utf8"));
-        if (this.configField) {
-            config = config[this.configField];
-        }
-        return config;
-    }
-}

package/dist/TESTTransactionClient.d.ts

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

package/dist/TESTTransactionClient.js

@@ -1,36 +0,0 @@
-export default class TESTTransactionClient {
-    client;
-    active = false;
-    constructor(client) {
-        this.client = client;
-    }
-    pending() {
-        return this.active;
-    }
-    getClient() {
-        return this.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/TransactionClient.d.ts

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

package/dist/TransactionClient.js

@@ -1,36 +0,0 @@
-export default class TransactionClient {
-    client;
-    active = false;
-    constructor(client) {
-        this.client = client;
-    }
-    pending() {
-        return this.active;
-    }
-    getClient() {
-        return this.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;
-    }
-}