@quillsql/node 0.6.0 → 0.6.2

package/dist/db/CachedConnection.d.ts

@@ -1,15 +1,18 @@
-import { Mapable, CacheCredentials } from "../models/Cache";
+import { Mappable, CacheCredentials } from "../models/Cache";
 import { DatabaseConnection } from "./DatabaseHelper";
+import { PostgresConnectionConfig } from "./Postgres";
+import { SnowflakeConnectionConfig } from "./Snowflake";
+import { BigQueryConfig } from "./BigQuery";
+import { MysqlConnectionConfig } from "./Mysql";
 export declare class CachedConnection {
     databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-    pool: DatabaseConnection | null;
+    readonly pool: DatabaseConnection;
     orgId: any;
     ttl: number;
-    cache: Mapable | null;
-    private config;
-    private activeQueries;
-    private readonly MAX_ACTIVE_QUERIES;
-    constructor(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", config: any, cacheConfig?: Partial<CacheCredentials>);
+    cache: Mappable | null;
+    private _isClosed;
+    get isClosed(): boolean;
+    constructor(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig, cacheConfig?: Partial<CacheCredentials>);
     query(text: string): Promise<any>;
     /**
      * Configures and returns a cache instance or null if none could be created.

package/dist/db/CachedConnection.js

@@ -16,21 +16,23 @@ const DatabaseHelper_1 = require("./DatabaseHelper");
 /** The TTL for new cache entries (default: 1h) */
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
 class CachedConnection {
+    get isClosed() {
+        return this._isClosed;
+    }
     constructor(databaseType, config, cacheConfig = {}) {
         var _a;
-        this.activeQueries = 0;
-        this.MAX_ACTIVE_QUERIES = 0;
+        this._isClosed = false;
         this.databaseType = databaseType;
         this.pool = (0, DatabaseHelper_1.connectToDatabase)(databaseType, config);
-        this.config = config;
         this.ttl = (_a = cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.ttl) !== null && _a !== void 0 ? _a : DEFAULT_CACHE_TTL;
         this.cache = this.getCache(cacheConfig);
     }
     query(text) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.activeQueries++;
-                this.pool = this.getPool();
+                if (this.isClosed) {
+                    throw new Error("Connection is closed");
+                }
                 if (!this.cache) {
                     return yield (0, DatabaseHelper_1.runQueryByDatabase)(this.databaseType, this.pool, text);
                 }
@@ -54,14 +56,6 @@ class CachedConnection {
                     throw new Error(err.message);
                 }
             }
-            finally {
-                this.activeQueries--;
-                if (this.activeQueries <= this.MAX_ACTIVE_QUERIES) {
-                    if (this.databaseType.toLowerCase() === "mysql") {
-                        this.close();
-                    }
-                }
-            }
         });
     }
     /**
@@ -77,17 +71,12 @@ class CachedConnection {
         return null;
     }
     getPool() {
-        if (!this.pool) {
-            this.pool = (0, DatabaseHelper_1.connectToDatabase)(this.databaseType, this.config);
-        }
         return this.pool;
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.pool) {
-                (0, DatabaseHelper_1.disconnectFromDatabase)(this.databaseType, this.pool);
-                this.pool = null;
-            }
+            (0, DatabaseHelper_1.disconnectFromDatabase)(this.databaseType, this.pool);
+            this._isClosed = true;
         });
     }
 }

package/dist/db/DatabaseHelper.d.ts

@@ -16,9 +16,12 @@ export interface QuillQueryResults {
         [fieldName: string]: any;
     }[];
 }
-export declare function getDatabaseCredentials(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig | undefined;
+export declare function getDatabaseCredentials(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig;
 export declare function connectToDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig): DatabaseConnection;
+export declare function withConnection<T>(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string, callback: (connection: DatabaseConnection) => T): Promise<T>;
+export declare function withPool<T>(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", pool: DatabaseConnection, callback: (connection: DatabaseConnection) => T): Promise<T>;
 export declare function runQueryByDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connection: DatabaseConnection, sql: string): Promise<QuillQueryResults> | undefined;
+export declare function connectAndRunQuery(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connectionString: string, sql: string): Promise<QuillQueryResults | undefined>;
 export declare function disconnectFromDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", database: DatabaseConnection): void | Promise<void>;
 export declare function getSchemasByDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connection: DatabaseConnection): Promise<string[] | undefined>;
 export declare function getTablesBySchemaByDatabase(databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql", connection: DatabaseConnection, schemaName: string | string[]): Promise<string[] | {

package/dist/db/DatabaseHelper.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColumnInfoBySchemaByDatabase = exports.getForiegnKeysByDatabase = exports.getColumnsByTableByDatabase = exports.getTablesBySchemaByDatabase = exports.getSchemasByDatabase = exports.disconnectFromDatabase = exports.runQueryByDatabase = exports.connectToDatabase = exports.getDatabaseCredentials = void 0;
+exports.getColumnInfoBySchemaByDatabase = exports.getForiegnKeysByDatabase = exports.getColumnsByTableByDatabase = exports.getTablesBySchemaByDatabase = exports.getSchemasByDatabase = exports.disconnectFromDatabase = exports.connectAndRunQuery = exports.runQueryByDatabase = exports.withPool = exports.withConnection = exports.connectToDatabase = exports.getDatabaseCredentials = void 0;
 const Postgres_1 = require("./Postgres");
 const Snowflake_1 = require("./Snowflake");
 const BigQuery_1 = require("./BigQuery");
@@ -27,7 +27,7 @@ function getDatabaseCredentials(databaseType, connectionString) {
         case "mysql":
             return (0, Mysql_1.formatMysqlConfig)(connectionString);
         default:
-            return undefined;
+            throw new Error("Invalid database type");
     }
 }
 exports.getDatabaseCredentials = getDatabaseCredentials;
@@ -48,6 +48,30 @@ function connectToDatabase(databaseType, config) {
     }
 }
 exports.connectToDatabase = connectToDatabase;
+function withConnection(databaseType, connectionString, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = getDatabaseCredentials(databaseType, connectionString);
+        const connection = connectToDatabase(databaseType, config);
+        try {
+            return yield callback(connection);
+        }
+        finally {
+            yield disconnectFromDatabase(databaseType, connection);
+        }
+    });
+}
+exports.withConnection = withConnection;
+function withPool(databaseType, pool, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield callback(pool);
+        }
+        finally {
+            yield disconnectFromDatabase(databaseType, pool);
+        }
+    });
+}
+exports.withPool = withPool;
 function runQueryByDatabase(databaseType, connection, sql) {
     switch (databaseType.toLowerCase()) {
         case "postgres":
@@ -65,6 +89,12 @@ function runQueryByDatabase(databaseType, connection, sql) {
     }
 }
 exports.runQueryByDatabase = runQueryByDatabase;
+function connectAndRunQuery(databaseType, connectionString, sql) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return withConnection(databaseType, connectionString, (connection) => __awaiter(this, void 0, void 0, function* () { return yield runQueryByDatabase(databaseType, connection, sql); }));
+    });
+}
+exports.connectAndRunQuery = connectAndRunQuery;
 function disconnectFromDatabase(databaseType, database) {
     switch (databaseType.toLowerCase()) {
         case "postgres":

package/dist/index.d.ts

@@ -1,6 +1,6 @@
+/// <reference types="node" />
 import { CacheCredentials } from "./models/Cache";
 import { QuillQueryParams } from "./models/Quill";
-import { CachedConnection } from "./db/CachedConnection";
 import "dotenv/config";
 /**
  * Quill - Fullstack API Platform for Dashboards and Reporting.
@@ -20,8 +20,8 @@ export declare enum DatabaseType {
     bigquery = "bigquery",
     mysql = "mysql"
 }
-export declare class Quill {
-    targetConnection: CachedConnection;
+export declare class Quill implements AsyncDisposable {
+    private targetConnection;
     private baseUrl;
     private config;
     constructor(data: {
@@ -35,6 +35,7 @@ export declare class Quill {
     query({ orgId, metadata, }: QuillQueryParams): Promise<QuillQueryResult>;
     private runQueries;
     private postQuill;
+    [Symbol.asyncDispose](): Promise<void>;
     close(): Promise<void>;
 }
 export { QuillQueryParams as QuillRequest } from "./models/Quill";

package/dist/index.ispec.js

@@ -13,6 +13,9 @@
 //       process.env.DB_URL as string
 //     );
 //   });
+// afterEach(async () => {
+//   await quill.close();
+// });
 //   afterAll(() => {
 //     jest.restoreAllMocks();
 //   });

package/dist/index.js

@@ -178,7 +178,6 @@ class Quill {
             else if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getTables) {
                 const queryResult = yield (0, DatabaseHelper_1.getTablesBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.getPool(), runQueryConfig.schemaNames || runQueryConfig.schema);
                 const schemaInfo = yield (0, DatabaseHelper_1.getColumnInfoBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.getPool(), runQueryConfig.schema, queryResult);
-                this.targetConnection.close();
                 return schemaInfo;
             }
             else {
@@ -221,6 +220,11 @@ class Quill {
             return response.data;
         });
     }
+    [Symbol.asyncDispose]() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.close();
+        });
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.targetConnection.close();
@@ -240,6 +244,10 @@ const requireQuill = ({ privateKey, databaseConnectionString, databaseConfig, ca
 };
 module.exports = requireQuill;
 module.exports.default = requireQuill;
+module.exports.withConnection = DatabaseHelper_1.withConnection;
+module.exports.withPool = DatabaseHelper_1.withPool;
+module.exports.connectToDatabase = DatabaseHelper_1.connectToDatabase;
+module.exports.connectAndRunQuery = DatabaseHelper_1.connectAndRunQuery;
 module.exports.Quill = Quill;
 module.exports.getTablesBySchemaByDatabase = DatabaseHelper_1.getTablesBySchemaByDatabase;
 module.exports.getDatabaseCredentials = DatabaseHelper_1.getDatabaseCredentials;
@@ -248,6 +256,5 @@ module.exports.getForiegnKeysByDatabase = DatabaseHelper_1.getForiegnKeysByDatab
 module.exports.getSchemasByDatabase = DatabaseHelper_1.getSchemasByDatabase;
 module.exports.getColumnInfoBySchemaByDatabase =
     DatabaseHelper_1.getColumnInfoBySchemaByDatabase;
-module.exports.connectToDatabase = DatabaseHelper_1.connectToDatabase;
 module.exports.runQueryByDatabase = DatabaseHelper_1.runQueryByDatabase;
 module.exports.DatabaseType = DatabaseType;

package/dist/index.uspec.js

@@ -14,6 +14,9 @@
 //     );
 //     quill.targetConnection.query = jest.fn().mockResolvedValue([]);
 //   });
+// afterEach(async () => {
+//   await quill.close();
+// });
 //   describe("query", () => {
 //     it("return nothing when suppling no queries", () => {
 //       const metadata = {

package/dist/models/Cache.d.ts

@@ -1,4 +1,4 @@
-export interface Mapable {
+export interface Mappable {
     get(key: string): Promise<string | null>;
     set(key: string, value: string, type?: string, ttl?: number): Promise<string | null>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Quill Server SDK for Node.js",
   "main": "dist/index.js",
   "module": "./dist/index.js",

package/src/db/CachedConnection.ts

@@ -1,4 +1,4 @@
-import { Mapable, CacheCredentials } from "../models/Cache";
+import { Mappable, CacheCredentials } from "../models/Cache";
 import { QuillConfig } from "../models/Quill";
 import { createClient } from "redis";
 import { isSuperset, PgError } from "../utils/Error";
@@ -8,36 +8,46 @@ import {
   disconnectFromDatabase,
   runQueryByDatabase,
 } from "./DatabaseHelper";
+import { PostgresConnectionConfig } from "./Postgres";
+import { SnowflakeConnectionConfig } from "./Snowflake";
+import { BigQueryConfig } from "./BigQuery";
+import { MysqlConnectionConfig } from "./Mysql";
 
 /** The TTL for new cache entries (default: 1h) */
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
 
 export class CachedConnection {
   public databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-  public pool: DatabaseConnection | null;
+  public readonly pool: DatabaseConnection;
   public orgId: any;
   public ttl: number;
-  public cache: Mapable | null;
-  private config: any;
-  private activeQueries: number = 0;
-  private readonly MAX_ACTIVE_QUERIES: number = 0;
+  public cache: Mappable | null;
+
+  private _isClosed: boolean = false;
+  public get isClosed(): boolean {
+    return this._isClosed;
+  }
 
   constructor(
     databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-    config: any,
+    config:
+      | PostgresConnectionConfig
+      | SnowflakeConnectionConfig
+      | BigQueryConfig
+      | MysqlConnectionConfig,
     cacheConfig: Partial<CacheCredentials> = {},
   ) {
     this.databaseType = databaseType;
     this.pool = connectToDatabase(databaseType, config);
-    this.config = config;
     this.ttl = cacheConfig?.ttl ?? DEFAULT_CACHE_TTL;
     this.cache = this.getCache(cacheConfig);
   }
 
   public async query(text: string): Promise<any> {
     try {
-      this.activeQueries++;
-      this.pool = this.getPool();
+      if (this.isClosed) {
+        throw new Error("Connection is closed");
+      }
       if (!this.cache) {
         return await runQueryByDatabase(this.databaseType, this.pool, text);
       }
@@ -66,13 +76,6 @@ export class CachedConnection {
       } else if (err instanceof Error) {
         throw new Error(err.message);
       }
-    } finally {
-      this.activeQueries--;
-      if (this.activeQueries <= this.MAX_ACTIVE_QUERIES) {
-        if (this.databaseType.toLowerCase() === "mysql") {
-          this.close();
-        }
-      }
     }
   }
 
@@ -85,27 +88,22 @@ export class CachedConnection {
     host,
     port,
     cacheType,
-  }: QuillConfig["cache"]): Mapable | null {
+  }: QuillConfig["cache"]): Mappable | null {
     if (cacheType === "redis" || cacheType === "rediss") {
       const redisURL = `${cacheType}://${username}:${password}@${host}:${port}`;
       const client = createClient({ url: redisURL });
       client.connect();
-      return client as Mapable;
+      return client as Mappable;
     }
     return null;
   }
 
   public getPool() {
-    if (!this.pool) {
-      this.pool = connectToDatabase(this.databaseType, this.config);
-    }
     return this.pool;
   }
 
   async close() {
-    if (this.pool) {
-      disconnectFromDatabase(this.databaseType, this.pool);
-      this.pool = null;
-    }
+    disconnectFromDatabase(this.databaseType, this.pool);
+    this._isClosed = true;
   }
 }

package/src/db/DatabaseHelper.ts

@@ -69,8 +69,7 @@ export function getDatabaseCredentials(
   | PostgresConnectionConfig
   | SnowflakeConnectionConfig
   | BigQueryConfig
-  | MysqlConnectionConfig
-  | undefined {
+  | MysqlConnectionConfig {
   switch (databaseType.toLowerCase()) {
     case "postgres":
       return formatPostgresConfig(connectionString);
@@ -83,7 +82,7 @@ export function getDatabaseCredentials(
     case "mysql":
       return formatMysqlConfig(connectionString);
     default:
-      return undefined;
+      throw new Error("Invalid database type");
   }
 }
 
@@ -111,6 +110,32 @@ export function connectToDatabase(
   }
 }
 
+export async function withConnection<T>(
+  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
+  connectionString: string,
+  callback: (connection: DatabaseConnection) => T,
+): Promise<T> {
+  const config = getDatabaseCredentials(databaseType, connectionString);
+  const connection = connectToDatabase(databaseType, config);
+  try {
+    return await callback(connection);
+  } finally {
+    await disconnectFromDatabase(databaseType, connection);
+  }
+}
+
+export async function withPool<T>(
+  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
+  pool: DatabaseConnection,
+  callback: (connection: DatabaseConnection) => T,
+): Promise<T> {
+  try {
+    return await callback(pool);
+  } finally {
+    await disconnectFromDatabase(databaseType, pool);
+  }
+}
+
 export function runQueryByDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
   connection: DatabaseConnection,
@@ -132,6 +157,19 @@ export function runQueryByDatabase(
   }
 }
 
+export async function connectAndRunQuery(
+  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
+  connectionString: string,
+  sql: string,
+): Promise<QuillQueryResults | undefined> {
+  return withConnection(
+    databaseType,
+    connectionString,
+    async (connection) =>
+      await runQueryByDatabase(databaseType, connection, sql),
+  );
+}
+
 export function disconnectFromDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
   database: DatabaseConnection,

package/src/index.ispec.ts

@@ -16,6 +16,10 @@
 //     );
 //   });
 
+// afterEach(async () => {
+//   await quill.close();
+// });
+
 //   afterAll(() => {
 //     jest.restoreAllMocks();
 //   });

package/src/index.ts

@@ -10,6 +10,7 @@ import "dotenv/config";
 import { mapQueries, removeFields } from "./utils/RunQueryProcesses";
 import {
   connectToDatabase,
+  connectAndRunQuery,
   getColumnInfoBySchemaByDatabase,
   getColumnsByTableByDatabase,
   getDatabaseCredentials,
@@ -17,6 +18,8 @@ import {
   getSchemasByDatabase,
   getTablesBySchemaByDatabase,
   runQueryByDatabase,
+  withConnection,
+  withPool,
 } from "./db/DatabaseHelper";
 import { convertTypeToPostgres } from "./utils/schemaConversion";
 
@@ -43,9 +46,9 @@ export enum DatabaseType {
   mysql = "mysql",
 }
 
-export class Quill {
+export class Quill implements AsyncDisposable {
   // Configure cached connection pools with the given config.
-  public targetConnection;
+  private targetConnection;
   private baseUrl: string;
   private config: {
     headers: {
@@ -264,7 +267,6 @@ export class Quill {
         runQueryConfig.schema!,
         queryResult!,
       );
-      this.targetConnection.close();
       return schemaInfo;
     } else {
       if (runQueryConfig?.limitThousand) {
@@ -323,6 +325,10 @@ export class Quill {
     return response.data;
   }
 
+  public async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
+  }
+
   public async close() {
     await this.targetConnection.close();
   }
@@ -355,6 +361,10 @@ const requireQuill = ({
 
 module.exports = requireQuill;
 module.exports.default = requireQuill;
+module.exports.withConnection = withConnection;
+module.exports.withPool = withPool;
+module.exports.connectToDatabase = connectToDatabase;
+module.exports.connectAndRunQuery = connectAndRunQuery;
 module.exports.Quill = Quill;
 module.exports.getTablesBySchemaByDatabase = getTablesBySchemaByDatabase;
 module.exports.getDatabaseCredentials = getDatabaseCredentials;
@@ -363,7 +373,6 @@ module.exports.getForiegnKeysByDatabase = getForiegnKeysByDatabase;
 module.exports.getSchemasByDatabase = getSchemasByDatabase;
 module.exports.getColumnInfoBySchemaByDatabase =
   getColumnInfoBySchemaByDatabase;
-module.exports.connectToDatabase = connectToDatabase;
 module.exports.runQueryByDatabase = runQueryByDatabase;
 module.exports.DatabaseType = DatabaseType;
 

package/src/index.uspec.ts

@@ -17,6 +17,10 @@
 //     quill.targetConnection.query = jest.fn().mockResolvedValue([]);
 //   });
 
+// afterEach(async () => {
+//   await quill.close();
+// });
+
 //   describe("query", () => {
 //     it("return nothing when suppling no queries", () => {
 //       const metadata = {

package/src/models/Cache.ts

@@ -1,4 +1,4 @@
-export interface Mapable {
+export interface Mappable {
   get(key: string): Promise<string | null>;
   set(
     key: string,