@dascompany/database 4.2.7 → 5.0.0

package/dist/ConnectionFactory.d.ts

@@ -1,4 +1,4 @@
 import Connection from './Connection';
 export default class ConnectionFactory {
-    static createConnection(): Promise<Connection>;
+    static createConnection(tenantName?: string): Promise<Connection>;
 }

package/dist/ConnectionFactory.js

@@ -1,8 +1,8 @@
 import Connection from './Connection';
 import PoolConnection from './PoolConnection';
 export default class ConnectionFactory {
-    static async createConnection() {
-        const client = await PoolConnection.getClient();
+    static async createConnection(tenantName) {
+        const client = await PoolConnection.getClient(tenantName);
         return new Connection(client);
     }
 }

package/dist/PoolConnection.d.ts

@@ -1,11 +1,12 @@
 import { PoolClient } from 'pg';
 export default class PoolConnection {
-    private static pool;
-    private static poolPromise;
+    private static poolMap;
+    private static poolPromiseMap;
     private static readonly configName;
     private static readonly configField;
     private static readonly configPath;
-    static getClient(): Promise<PoolClient>;
+    private static readonly defaultName;
+    static getClient(tenantName?: string): Promise<PoolClient>;
     private static getPool;
     private static ensurePool;
     private static init;

package/dist/PoolConnection.js

@@ -1,36 +1,42 @@
 import { readFile } from 'fs/promises';
 import Database from './Database';
 export default class PoolConnection {
-    static pool;
-    static poolPromise;
+    static poolMap = new Map();
+    static poolPromiseMap = new Map();
     static configName = 'config.json';
     static configField = 'database';
     static configPath = './server/';
-    static async getClient() {
-        const pool = await this.getPool();
+    static defaultName = 'default';
+    static async getClient(tenantName = this.defaultName) {
+        const pool = await this.getPool(tenantName);
         return pool.connect();
     }
-    static async getPool() {
-        if (this.pool) {
-            return this.pool;
+    static async getPool(tenantName) {
+        if (this.poolMap.has(tenantName)) {
+            return this.poolMap.get(tenantName);
         }
-        return this.pool = await this.ensurePool();
+        const pool = await this.ensurePool(tenantName);
+        this.poolMap.set(tenantName, pool);
+        return pool;
     }
-    static async ensurePool() {
-        if (!this.poolPromise) {
-            this.poolPromise = this.init();
+    static async ensurePool(tenantName) {
+        if (!this.poolPromiseMap.has(tenantName)) {
+            this.poolPromiseMap.set(tenantName, this.init(tenantName));
         }
-        return this.poolPromise;
+        return this.poolPromiseMap.get(tenantName);
     }
-    static async init() {
-        const config = await this.getDatabaseConfig();
+    static async init(tenantName) {
+        const config = await this.getDatabaseConfig(tenantName);
         return Database.connect(config);
     }
-    static async getDatabaseConfig() {
+    static async getDatabaseConfig(tenantName) {
         let config = JSON.parse(await readFile(`${this.configPath}${this.configName}`, "utf8"));
         if (this.configField) {
             config = config[this.configField];
         }
+        if (tenantName != this.defaultName) {
+            config = config[tenantName];
+        }
         return config;
     }
 }

package/dist/query/QueryParams.js

@@ -24,7 +24,7 @@ export default class QueryParams {
         let sqlParams = [];
         parameters.forEach((parameter) => {
             if ((Array.isArray(parameter.value) && parameter.value.length > 0) ||
-                (!Array.isArray(parameter.value) && parameter.value))
+                (!Array.isArray(parameter.value) && (parameter.value || parameter.value === false)))
                 sqlParams.push(QueryParamsCreator.createParam(parameter));
         });
         return sqlParams;

package/package.json

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

package/dist/Pool.d.ts

@@ -1,2 +0,0 @@
-import pg from 'pg';
-export declare function getPool(): Promise<pg.Pool>;

package/dist/Pool.js

@@ -1,17 +0,0 @@
-import Database from './Database';
-import { readFile } from 'fs/promises';
-let pool = null;
-let poolPromise = null;
-export async function getPool() {
-    if (pool)
-        return pool;
-    if (!poolPromise) {
-        poolPromise = (async () => {
-            const raw = await readFile('./server/config.json', 'utf8');
-            const config = JSON.parse(raw).database;
-            return Database.connect(config);
-        })();
-    }
-    pool = await poolPromise;
-    return pool;
-}