@quillsql/node 0.4.3 → 0.4.5

package/dist/db/CachedConnection.d.ts

@@ -1,12 +1,12 @@
 import { Mapable, CacheCredentials } from "../models/Cache";
-import { DatabaseConnection, DatabaseType } from "./DatabaseHelper";
+import { DatabaseConnection, QuillDatabaseType } from "./DatabaseHelper";
 export declare class CachedConnection {
-    databaseType: DatabaseType;
+    databaseType: QuillDatabaseType;
     pool: DatabaseConnection;
     orgId: any;
     ttl: number;
     cache: Mapable | null;
-    constructor(databaseType: DatabaseType, config: any, cacheConfig?: Partial<CacheCredentials>);
+    constructor(databaseType: QuillDatabaseType, config: any, cacheConfig?: Partial<CacheCredentials>);
     query(text: string, values?: any[]): Promise<any>;
     /**
      * Configures and returns a cache instance or null if none could be created.

package/dist/db/DatabaseHelper.d.ts

@@ -6,8 +6,7 @@ import { PostgresConnectionConfig } from "./Postgres";
 import { SnowflakeConnectionConfig } from "./Snowflake";
 import { BigQueryConfig } from "./BigQuery";
 import { MysqlConnectionConfig } from "./Mysql";
-export declare enum DatabaseType {
-    postgres = "postgres",
+export declare enum QuillDatabaseType {
     postgresql = "postgresql",
     snowflake = "snowflake",
     bigquery = "bigquery",
@@ -23,18 +22,18 @@ export interface QuillQueryResults {
         [fieldName: string]: any;
     }[];
 }
-export declare function getDatabaseCredentials(databaseType: DatabaseType, connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig | undefined;
-export declare function connectToDatabase(databaseType: DatabaseType, config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig): DatabaseConnection;
-export declare function runQueryByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, sql: string): Promise<QuillQueryResults> | undefined;
-export declare function disconnectFromDatabase(databaseType: DatabaseType, database: DatabaseConnection): void | Promise<void>;
-export declare function getSchemasByDatabase(databaseType: DatabaseType, connection: DatabaseConnection): Promise<string[] | undefined>;
-export declare function getTablesBySchemaByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string | string[]): Promise<string[] | {
+export declare function getDatabaseCredentials(databaseType: QuillDatabaseType, connectionString: string): PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig | undefined;
+export declare function connectToDatabase(databaseType: QuillDatabaseType, config: PostgresConnectionConfig | SnowflakeConnectionConfig | BigQueryConfig | MysqlConnectionConfig): DatabaseConnection;
+export declare function runQueryByDatabase(databaseType: QuillDatabaseType, connection: DatabaseConnection, sql: string): Promise<QuillQueryResults> | undefined;
+export declare function disconnectFromDatabase(databaseType: QuillDatabaseType, database: DatabaseConnection): void | Promise<void>;
+export declare function getSchemasByDatabase(databaseType: QuillDatabaseType, connection: DatabaseConnection): Promise<string[] | undefined>;
+export declare function getTablesBySchemaByDatabase(databaseType: QuillDatabaseType, connection: DatabaseConnection, schemaName: string | string[]): Promise<string[] | {
     tableName: string;
     schemaName: string;
 }[] | undefined>;
-export declare function getColumnsByTableByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string, tableName: string): Promise<string[] | undefined>;
-export declare function getForiegnKeysByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string, tableName: string, primaryKey: string): Promise<string[] | undefined>;
-export declare function getColumnInfoBySchemaByDatabase(databaseType: DatabaseType, connection: DatabaseConnection, schemaName: string, tables: string[] | {
+export declare function getColumnsByTableByDatabase(databaseType: QuillDatabaseType, connection: DatabaseConnection, schemaName: string, tableName: string): Promise<string[] | undefined>;
+export declare function getForiegnKeysByDatabase(databaseType: QuillDatabaseType, connection: DatabaseConnection, schemaName: string, tableName: string, primaryKey: string): Promise<string[] | undefined>;
+export declare function getColumnInfoBySchemaByDatabase(databaseType: QuillDatabaseType, connection: DatabaseConnection, schemaName: string, tables: string[] | {
     tableName: string;
     schemaName: string;
 }[]): Promise<{

package/dist/db/DatabaseHelper.js

@@ -9,19 +9,18 @@ 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 = exports.DatabaseType = void 0;
+exports.getColumnInfoBySchemaByDatabase = exports.getForiegnKeysByDatabase = exports.getColumnsByTableByDatabase = exports.getTablesBySchemaByDatabase = exports.getSchemasByDatabase = exports.disconnectFromDatabase = exports.runQueryByDatabase = exports.connectToDatabase = exports.getDatabaseCredentials = exports.QuillDatabaseType = void 0;
 const Postgres_1 = require("./Postgres");
 const Snowflake_1 = require("./Snowflake");
 const BigQuery_1 = require("./BigQuery");
 const Mysql_1 = require("./Mysql");
-var DatabaseType;
-(function (DatabaseType) {
-    DatabaseType["postgres"] = "postgres";
-    DatabaseType["postgresql"] = "postgresql";
-    DatabaseType["snowflake"] = "snowflake";
-    DatabaseType["bigquery"] = "bigquery";
-    DatabaseType["mysql"] = "mysql";
-})(DatabaseType || (exports.DatabaseType = DatabaseType = {}));
+var QuillDatabaseType;
+(function (QuillDatabaseType) {
+    QuillDatabaseType["postgresql"] = "postgresql";
+    QuillDatabaseType["snowflake"] = "snowflake";
+    QuillDatabaseType["bigquery"] = "bigquery";
+    QuillDatabaseType["mysql"] = "mysql";
+})(QuillDatabaseType || (exports.QuillDatabaseType = QuillDatabaseType = {}));
 function getDatabaseCredentials(databaseType, connectionString) {
     switch (databaseType.toLowerCase()) {
         case "postgres":

package/dist/index.d.ts

@@ -2,16 +2,33 @@ import { CacheCredentials } from "./models/Cache";
 import { QuillQueryParams } from "./models/Quill";
 import { CachedConnection } from "./db/CachedConnection";
 import "dotenv/config";
-import { DatabaseType } from "./db/DatabaseHelper";
+import { QuillDatabaseType } from "./db/DatabaseHelper";
 /**
  * Quill - Fullstack API Platform for Dashboards and Reporting.
  */
+export interface QuillQueryResult {
+    data?: any;
+    status: string;
+    error?: string;
+    queries?: {
+        rows: any[];
+        fields: any[];
+    };
+}
+export type DatabaseType = QuillDatabaseType;
 export default class QuillClass {
     targetConnection: CachedConnection;
     private baseUrl;
     private config;
-    constructor(privateKey: string, databaseType: DatabaseType, databaseConnectionString?: string, databaseCredentials?: any, cache?: Partial<CacheCredentials>, metadataServerURL?: string);
-    query({ orgId, metadata }: QuillQueryParams): Promise<any>;
+    constructor(data: {
+        privateKey: string;
+        databaseType: DatabaseType;
+        databaseConnectionString?: string;
+        databaseConfig?: any;
+        cache?: Partial<CacheCredentials>;
+        metadataServerURL?: string;
+    });
+    query({ orgId, metadata, }: QuillQueryParams): Promise<QuillQueryResult>;
     private runQueries;
     private postQuill;
     close(): Promise<void>;

package/dist/index.js

@@ -21,20 +21,18 @@ const schemaConversion_1 = require("./utils/schemaConversion");
 const HOST = process.env.ENV === "development"
     ? "http://localhost:8080"
     : "https://quill-344421.uc.r.appspot.com";
-/**
- * Quill - Fullstack API Platform for Dashboards and Reporting.
- */
 class QuillClass {
-    constructor(privateKey, databaseType, databaseConnectionString, databaseCredentials, cache = {}, metadataServerURL) {
+    constructor(data) {
+        const { privateKey, databaseType, databaseConnectionString, databaseConfig, cache, metadataServerURL, } = data;
         this.baseUrl = metadataServerURL ? metadataServerURL : HOST;
         this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-        let credentials = databaseCredentials;
+        let credentials = databaseConfig;
         if (databaseConnectionString) {
             credentials = (0, DatabaseHelper_1.getDatabaseCredentials)(databaseType, databaseConnectionString);
         }
-        this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, credentials, cache);
+        this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, credentials, cache || {});
     }
-    query({ orgId, metadata }) {
+    query({ orgId, metadata, }) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             this.targetConnection.orgId = orgId;
@@ -169,7 +167,14 @@ class QuillClass {
 }
 exports.default = QuillClass;
 const Quill = ({ privateKey, databaseConnectionString, databaseConfig, cache, databaseType, metadataServerURL, }) => {
-    return new QuillClass(privateKey, databaseType, databaseConnectionString, databaseConfig, cache, metadataServerURL);
+    return new QuillClass({
+        privateKey,
+        databaseType,
+        databaseConnectionString,
+        databaseConfig,
+        cache,
+        metadataServerURL,
+    });
 };
 module.exports = Quill;
 module.exports.Quill = Quill;
@@ -183,3 +188,4 @@ module.exports.getColumnInfoBySchemaByDatabase =
     DatabaseHelper_1.getColumnInfoBySchemaByDatabase;
 module.exports.connectToDatabase = DatabaseHelper_1.connectToDatabase;
 module.exports.runQueryByDatabase = DatabaseHelper_1.runQueryByDatabase;
+module.exports.DatabaseType = DatabaseHelper_1.QuillDatabaseType;

package/dist/index.uspec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.uspec.js

@@ -1,39 +1,41 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = __importDefault(require("."));
-const DatabaseHelper_1 = require("./db/DatabaseHelper");
-jest.mock(".");
-describe("Quill", () => {
-    let quill;
-    beforeEach(() => {
-        quill = new _1.default("dummy_private_key", DatabaseHelper_1.DatabaseType.postgres, "dummy_db_url", {}, undefined);
-        quill.targetConnection.query = jest.fn().mockResolvedValue([]);
-    });
-    describe("query", () => {
-        it("return nothing when suppling no queries", () => {
-            const metadata = {
-                task: "test",
-                queries: [],
-            };
-            const result = quill.query({
-                orgId: "dummy",
-                metadata,
-            });
-            expect(result).resolves.toEqual([]);
-        });
-        it("returns an error for the improper query", () => {
-            const metadata = {
-                task: "test",
-                queries: ["SELECT * FROM test"],
-            };
-            const result = quill.query({
-                orgId: "dummy",
-                metadata,
-            });
-        });
-    });
-    // Add more test cases as needed
-});
+// import Quill from ".";
+// import { DatabaseType } from "./db/DatabaseHelper";
+// jest.mock(".");
+// describe("Quill", () => {
+//   let quill: Quill;
+//   beforeEach(() => {
+//     quill = new Quill(
+//       "dummy_private_key",
+//       DatabaseType.postgres,
+//       "dummy_db_url",
+//       {},
+//       undefined
+//     );
+//     quill.targetConnection.query = jest.fn().mockResolvedValue([]);
+//   });
+//   describe("query", () => {
+//     it("return nothing when suppling no queries", () => {
+//       const metadata = {
+//         task: "test",
+//         queries: [],
+//       };
+//       const result = quill.query({
+//         orgId: "dummy",
+//         metadata,
+//       });
+//       expect(result).resolves.toEqual([]);
+//     });
+//     it("returns an error for the improper query", () => {
+//       const metadata = {
+//         task: "test",
+//         queries: ["SELECT * FROM test"],
+//       };
+//       const result = quill.query({
+//         orgId: "dummy",
+//         metadata,
+//       });
+//     });
+//   });
+//   // Add more test cases as needed
+// });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Quill's client SDK for node backends.",
   "main": "dist/index.js",
   "module": "./dist/index.js",

package/src/db/CachedConnection.ts

@@ -5,7 +5,7 @@ import { createClient } from "redis";
 import { isSuperset } from "../utils/Error";
 import {
   DatabaseConnection,
-  DatabaseType,
+  QuillDatabaseType,
   connectToDatabase,
   disconnectFromDatabase,
   runQueryByDatabase,
@@ -29,14 +29,14 @@ class PgError extends Error {
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
 
 export class CachedConnection {
-  public databaseType: DatabaseType;
+  public databaseType: QuillDatabaseType;
   public pool: DatabaseConnection;
   public orgId: any;
   public ttl: number;
   public cache: Mapable | null;
 
   constructor(
-    databaseType: DatabaseType,
+    databaseType: QuillDatabaseType,
     config: any,
     cacheConfig: Partial<CacheCredentials> = {}
   ) {

package/src/db/DatabaseHelper.ts

@@ -51,8 +51,7 @@ import {
   getSchemasMysql,
 } from "./Mysql";
 
-export enum DatabaseType {
-  postgres = "postgres",
+export enum QuillDatabaseType {
   postgresql = "postgresql",
   snowflake = "snowflake",
   bigquery = "bigquery",
@@ -72,7 +71,7 @@ export interface QuillQueryResults {
 }
 
 export function getDatabaseCredentials(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connectionString: string
 ):
   | PostgresConnectionConfig
@@ -97,7 +96,7 @@ export function getDatabaseCredentials(
 }
 
 export function connectToDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   config:
     | PostgresConnectionConfig
     | SnowflakeConnectionConfig
@@ -121,7 +120,7 @@ export function connectToDatabase(
 }
 
 export function runQueryByDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connection: DatabaseConnection,
   sql: string
 ): Promise<QuillQueryResults> | undefined {
@@ -142,7 +141,7 @@ export function runQueryByDatabase(
 }
 
 export function disconnectFromDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   database: DatabaseConnection
 ) {
   switch (databaseType.toLowerCase()) {
@@ -162,7 +161,7 @@ export function disconnectFromDatabase(
 }
 
 export async function getSchemasByDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connection: DatabaseConnection
 ): Promise<string[] | undefined> {
   switch (databaseType.toLowerCase()) {
@@ -183,7 +182,7 @@ export async function getSchemasByDatabase(
 
 // INFORMATION SCHEMA SELECTS
 export async function getTablesBySchemaByDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connection: DatabaseConnection,
   schemaName: string | string[]
 ): Promise<string[] | { tableName: string; schemaName: string }[] | undefined> {
@@ -220,7 +219,7 @@ export async function getTablesBySchemaByDatabase(
 
 // INFORMATION SCHEMA SELECTS
 export async function getColumnsByTableByDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connection: DatabaseConnection,
   schemaName: string,
   tableName: string
@@ -262,7 +261,7 @@ export async function getColumnsByTableByDatabase(
 }
 
 export async function getForiegnKeysByDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connection: DatabaseConnection,
   schemaName: string,
   tableName: string,
@@ -310,7 +309,7 @@ export async function getForiegnKeysByDatabase(
 }
 
 export function getColumnInfoBySchemaByDatabase(
-  databaseType: DatabaseType,
+  databaseType: QuillDatabaseType,
   connection: DatabaseConnection,
   schemaName: string,
   tables: string[] | { tableName: string; schemaName: string }[]

package/src/index.ts

@@ -10,7 +10,7 @@ import axios from "axios";
 import "dotenv/config";
 import { mapQueries, removeFields } from "./utils/RunQueryProcesses";
 import {
-  DatabaseType,
+  QuillDatabaseType,
   connectToDatabase,
   getColumnInfoBySchemaByDatabase,
   getColumnsByTableByDatabase,
@@ -31,6 +31,14 @@ const HOST =
  * Quill - Fullstack API Platform for Dashboards and Reporting.
  */
 
+export interface QuillQueryResult {
+  data?: any;
+  status: string;
+  error?: string;
+  queries?: { rows: any[]; fields: any[] };
+}
+
+export type DatabaseType = QuillDatabaseType;
 export default class QuillClass {
   // Configure cached connection pools with the given config.
   public targetConnection;
@@ -41,17 +49,25 @@ export default class QuillClass {
     };
   };
 
-  constructor(
-    privateKey: string,
-    databaseType: DatabaseType,
-    databaseConnectionString?: string,
-    databaseCredentials?: any,
-    cache: Partial<CacheCredentials> = {},
-    metadataServerURL?: string
-  ) {
+  constructor(data: {
+    privateKey: string;
+    databaseType: DatabaseType;
+    databaseConnectionString?: string;
+    databaseConfig?: any;
+    cache?: Partial<CacheCredentials>;
+    metadataServerURL?: string;
+  }) {
+    const {
+      privateKey,
+      databaseType,
+      databaseConnectionString,
+      databaseConfig,
+      cache,
+      metadataServerURL,
+    } = data;
     this.baseUrl = metadataServerURL ? metadataServerURL : HOST;
     this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-    let credentials = databaseCredentials;
+    let credentials = databaseConfig;
     if (databaseConnectionString) {
       credentials = getDatabaseCredentials(
         databaseType,
@@ -61,11 +77,14 @@ export default class QuillClass {
     this.targetConnection = new CachedConnection(
       databaseType,
       credentials,
-      cache
+      cache || {}
     );
   }
 
-  public async query({ orgId, metadata }: QuillQueryParams): Promise<any> {
+  public async query({
+    orgId,
+    metadata,
+  }: QuillQueryParams): Promise<QuillQueryResult> {
     this.targetConnection.orgId = orgId;
     try {
       const preQueryResults = metadata.preQueries
@@ -256,14 +275,14 @@ const Quill = ({
   databaseConfig: any;
   metadataServerURL?: string;
 }) => {
-  return new QuillClass(
+  return new QuillClass({
     privateKey,
     databaseType,
     databaseConnectionString,
     databaseConfig,
     cache,
-    metadataServerURL
-  );
+    metadataServerURL,
+  });
 };
 
 module.exports = Quill;
@@ -278,3 +297,4 @@ module.exports.getColumnInfoBySchemaByDatabase =
   getColumnInfoBySchemaByDatabase;
 module.exports.connectToDatabase = connectToDatabase;
 module.exports.runQueryByDatabase = runQueryByDatabase;
+module.exports.DatabaseType = QuillDatabaseType;

package/src/index.uspec.ts

@@ -1,45 +1,45 @@
-import Quill from ".";
-import { DatabaseType } from "./db/DatabaseHelper";
+// import Quill from ".";
+// import { DatabaseType } from "./db/DatabaseHelper";
 
-jest.mock(".");
+// jest.mock(".");
 
-describe("Quill", () => {
-  let quill: Quill;
+// describe("Quill", () => {
+//   let quill: Quill;
 
-  beforeEach(() => {
-    quill = new Quill(
-      "dummy_private_key",
-      DatabaseType.postgres,
-      "dummy_db_url",
-      {},
-      undefined
-    );
-    quill.targetConnection.query = jest.fn().mockResolvedValue([]);
-  });
+//   beforeEach(() => {
+//     quill = new Quill(
+//       "dummy_private_key",
+//       DatabaseType.postgres,
+//       "dummy_db_url",
+//       {},
+//       undefined
+//     );
+//     quill.targetConnection.query = jest.fn().mockResolvedValue([]);
+//   });
 
-  describe("query", () => {
-    it("return nothing when suppling no queries", () => {
-      const metadata = {
-        task: "test",
-        queries: [],
-      };
-      const result = quill.query({
-        orgId: "dummy",
-        metadata,
-      });
-      expect(result).resolves.toEqual([]);
-    });
-    it("returns an error for the improper query", () => {
-      const metadata = {
-        task: "test",
-        queries: ["SELECT * FROM test"],
-      };
-      const result = quill.query({
-        orgId: "dummy",
-        metadata,
-      });
-    });
-  });
+//   describe("query", () => {
+//     it("return nothing when suppling no queries", () => {
+//       const metadata = {
+//         task: "test",
+//         queries: [],
+//       };
+//       const result = quill.query({
+//         orgId: "dummy",
+//         metadata,
+//       });
+//       expect(result).resolves.toEqual([]);
+//     });
+//     it("returns an error for the improper query", () => {
+//       const metadata = {
+//         task: "test",
+//         queries: ["SELECT * FROM test"],
+//       };
+//       const result = quill.query({
+//         orgId: "dummy",
+//         metadata,
+//       });
+//     });
+//   });
 
-  // Add more test cases as needed
-});
+//   // Add more test cases as needed
+// });