@quillsql/node 0.5.9 → 0.6.0

package/dist/db/BigQuery.js

@@ -164,6 +164,7 @@ function convertBigQueryTypeToPostgresOID(type) {
         FLOAT: 700,
         TIMESTAMP: 1114,
         DATE: 1082,
+        BOOL: 16,
     };
     const postgresType = typeToOidMap[type.toUpperCase()] || "VARCHAR"; // Default to 'text' if the type is not recognized
     return typeToOidMap[postgresType] || 1043; // Default to OID for 'text' if the type is not recognized

package/dist/db/CachedConnection.d.ts

@@ -7,8 +7,10 @@ export declare class CachedConnection {
     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>);
-    query(text: string, values?: any[]): Promise<any>;
+    query(text: string): Promise<any>;
     /**
      * Configures and returns a cache instance or null if none could be created.
      */

package/dist/db/CachedConnection.js

@@ -13,29 +13,23 @@ exports.CachedConnection = void 0;
 const redis_1 = require("redis");
 const Error_1 = require("../utils/Error");
 const DatabaseHelper_1 = require("./DatabaseHelper");
-class PgError extends Error {
-    // Add other properties if needed
-    constructor(detail, hint, position) {
-        super();
-        this.detail = detail;
-        this.hint = hint;
-        this.position = position;
-    }
-}
 /** The TTL for new cache entries (default: 1h) */
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
 class CachedConnection {
     constructor(databaseType, config, cacheConfig = {}) {
         var _a;
+        this.activeQueries = 0;
+        this.MAX_ACTIVE_QUERIES = 0;
         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, values) {
+    query(text) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                this.activeQueries++;
                 this.pool = this.getPool();
                 if (!this.cache) {
                     return yield (0, DatabaseHelper_1.runQueryByDatabase)(this.databaseType, this.pool, text);
@@ -53,16 +47,19 @@ class CachedConnection {
                 }
             }
             catch (err) {
-                if ((0, Error_1.isSuperset)(err, PgError)) {
-                    throw new PgError(err.detail, err.hint, err.position);
+                if ((0, Error_1.isSuperset)(err, Error_1.PgError)) {
+                    throw new Error_1.PgError(err.message, err.detail, err.hint, err.position);
                 }
                 else if (err instanceof Error) {
                     throw new Error(err.message);
                 }
             }
             finally {
-                if (this.databaseType.toLowerCase() === "mysql") {
-                    this.close();
+                this.activeQueries--;
+                if (this.activeQueries <= this.MAX_ACTIVE_QUERIES) {
+                    if (this.databaseType.toLowerCase() === "mysql") {
+                        this.close();
+                    }
                 }
             }
         });

package/dist/db/Postgres.js

@@ -138,24 +138,31 @@ function formatPostgresConfig(connectionString) {
 }
 exports.formatPostgresConfig = formatPostgresConfig;
 // CURRENTLY UNUSED BUT MAYBE USEFUL IN THE FUTURE
-function getSslConfig(client) {
-    if (!client.useSsl) {
-        return undefined;
-    }
-    if (client.serverCa && client.clientKey && client.clientCert) {
-        return {
-            rejectUnauthorized: false,
-            ca: client.serverCa,
-            key: client.clientKey,
-            cert: client.clientCert,
-        };
-    }
-    if (client.serverCa) {
-        return {
-            rejectUnauthorized: false,
-            ca: client.serverCa,
-        };
-    }
-    // if using ssl with no certificates
-    return { rejectUnauthorized: false };
-}
+// function getSslConfig(client: Client):
+//   | {
+//       rejectUnauthorized: false;
+//       ca?: string;
+//       key?: string;
+//       cert?: string;
+//     }
+//   | undefined {
+//   if (!client.useSsl) {
+//     return undefined;
+//   }
+//   if (client.serverCa && client.clientKey && client.clientCert) {
+//     return {
+//       rejectUnauthorized: false,
+//       ca: client.serverCa,
+//       key: client.clientKey,
+//       cert: client.clientCert,
+//     };
+//   }
+//   if (client.serverCa) {
+//     return {
+//       rejectUnauthorized: false,
+//       ca: client.serverCa,
+//     };
+//   }
+//   // if using ssl with no certificates
+//   return { rejectUnauthorized: false };
+// }

package/dist/db/Snowflake.js

@@ -116,7 +116,7 @@ function connectToSnowflake(config) {
 exports.connectToSnowflake = connectToSnowflake;
 function disconnectFromSnowflake(connection) {
     return __awaiter(this, void 0, void 0, function* () {
-        connection.destroy((err, conn) => {
+        connection.destroy((err) => {
             if (err) {
                 console.error(`Failed to disconnect from Snowflake: ${err.message}`);
             }
@@ -126,7 +126,7 @@ function disconnectFromSnowflake(connection) {
 exports.disconnectFromSnowflake = disconnectFromSnowflake;
 function getForeignKeysSnowflake(connection, schemaName, tableName, primaryKey) {
     return __awaiter(this, void 0, void 0, function* () {
-        let depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
+        const depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
         let sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
     WHERE TABLE_SCHEMA = '${schemaName}' 
     AND TABLE_NAME = '${schemaName}' 

package/dist/index.js

@@ -41,10 +41,13 @@ class Quill {
         this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, credentials, cache || {});
     }
     query({ orgId, metadata, }) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             this.targetConnection.orgId = orgId;
             let responseMetadata = {};
+            if (!metadata.task) {
+                return { error: "Missing task.", status: "error", data: {} };
+            }
             try {
                 const preQueryResults = metadata.preQueries
                     ? yield this.runQueries(metadata.preQueries, this.targetConnection.databaseType, metadata.databaseType, metadata.runQueryConfig)
@@ -57,7 +60,11 @@ class Quill {
                 }
                 const response = yield this.postQuill(metadata.task, Object.assign(Object.assign(Object.assign({}, metadata), preQueryResults), { orgId, viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined }));
                 if (response.error) {
-                    return { status: "error", error: response.error };
+                    return {
+                        status: "error",
+                        error: response.error,
+                        data: response.metadata || {},
+                    };
                 }
                 // if there is no metadata object in the response, create one
                 if (response.metadata) {
@@ -92,8 +99,8 @@ class Quill {
             catch (err) {
                 return {
                     status: "error",
-                    error: err.message,
-                    data: responseMetadata,
+                    error: (_e = (_d = (_c = err.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.error) !== null && _e !== void 0 ? _e : err.message,
+                    data: responseMetadata || {},
                 };
             }
         });
@@ -152,7 +159,9 @@ class Quill {
                         return Object.assign(Object.assign({}, table), { columns: columns, rows: queryResult.rows });
                     }
                     catch (err) {
-                        return Object.assign(Object.assign({}, table), { error: "Error fetching columns" });
+                        return Object.assign(Object.assign({}, table), { error: err.message
+                                ? `Error fetching columns: ${err.message}`
+                                : "Error fetching columns" });
                     }
                 })));
                 results = Object.assign(Object.assign({}, results), { queryResults });

package/dist/utils/Error.d.ts

@@ -3,5 +3,6 @@ export declare class PgError extends Error {
     detail?: string;
     hint?: string;
     position?: string;
+    constructor(message: string, detail?: string, hint?: string, position?: string, code?: string);
 }
 export declare function isSuperset(obj: any, baseClass: any): boolean;

package/dist/utils/Error.js

@@ -2,14 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSuperset = exports.PgError = void 0;
 class PgError extends Error {
+    // Add other properties if needed
+    constructor(message, detail, hint, position, code) {
+        super(message);
+        this.code = code;
+        this.detail = detail;
+        this.hint = hint;
+        this.position = position;
+    }
 }
 exports.PgError = PgError;
 function isSuperset(obj, baseClass) {
-    // Get the property names of the base class
-    const baseProps = Object.getOwnPropertyNames(baseClass.prototype);
+    // Get the property names of the base class instance
+    const baseInstance = new baseClass();
+    const baseProps = Object.keys(baseInstance);
     // Check if the object has all the properties of the base class
     for (const prop of baseProps) {
-        if (!obj.hasOwnProperty(prop)) {
+        if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
             return false;
         }
     }

package/dist/utils/RunQueryProcesses.d.ts

@@ -1,3 +1,9 @@
 import { CachedConnection } from "../db/CachedConnection";
+export interface TableSchemaInfo {
+    fieldType: string;
+    name: string;
+    displayName: string;
+    isVisible: boolean;
+}
 export declare function removeFields(queryResults: any, fieldsToRemove: string[]): any;
 export declare function mapQueries(queries: string[], targetConnection: CachedConnection): Promise<any[]>;

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  { files: ["**/*.{js,mjs,cjs,ts,jsx,tsx}"] },
+  { languageOptions: { globals: globals.node } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-require-imports": "off",
+    },
+  },
+];

package/examples/mysql-node/app.ts

@@ -0,0 +1,62 @@
+// Write a simple node server to test the SDK
+
+import express from "express";
+import cors from "cors";
+import requireQuill from "../../src/index";
+
+const app = express();
+const port = 3005;
+
+// postgresqlConfigExample {
+//   connectionString: process.env.DB_URL,
+//   ssl: {
+//     rejectUnauthorized: false,
+//   },
+// };
+
+// bigqueryConfigExample {
+//   projectId: process.env.PROJECT_ID,
+//   credentials: serviceAccount // You need to make the serviceAccount JSON
+// }
+
+// snowflakeConfigExample {
+//   account: process.env.ACCOUNT,
+//   username: process.env.USERNAME,
+//   password: process.env.PASSWORD,
+//   warehouse: process.env.WAREHOUSE,
+//   database: process.env.DATABASE,
+// }
+
+// mysqlConfigExample {
+//   host: process.env.HOST,
+//   user: process.env.USER,
+//   password: process.env.PASSWORD,
+//   database: process.env.DATABASE,
+// }
+
+app.use(cors());
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+const quill = requireQuill({
+  privateKey: process.env.MYSQL_PRIVATE_KEY ?? "",
+  databaseConnectionString: process.env.MYSQL_DB_URL ?? "",
+  databaseConfig: {}, // TODO: Add database config
+  databaseType: "mysql",
+});
+
+app.post("/quill", async (req, res) => {
+  const { orgId, metadata } = req.body;
+  const result = await quill.query({
+    orgId: orgId ?? metadata.orgId,
+    metadata,
+  });
+  res.send(result);
+});
+
+app.listen(port, () => {
+  console.log(`Example app listening at http://localhost:${port}`);
+});

package/examples/node-server/app.ts

@@ -34,15 +34,14 @@ const port = 3001;
 // }
 
 const quill = require("../../src/index")({
-  privateKey: process.env.PRIVATE_KEY,
-  databaseConnectionString: process.env.DB_URL,
-  // databaseConfig: {
-  //   connectionString: process.env.DB_URL,
-  //   ssl: {
-  //     rejectUnauthorized: false,
-  //   },
-  // },
-  databaseType: process.env.DB_TYPE,
+  privateKey: process.env.PRIVATE_KEY ?? "",
+  databaseConnectionString: process.env.DB_URL ?? "",
+  databaseConfig: {}, // TODO: Add database config
+  databaseType: process.env.DB_TYPE as
+    | "postgresql"
+    | "snowflake"
+    | "bigquery"
+    | "mysql",
 });
 
 app.use(cors());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "description": "Quill Server SDK for Node.js",
   "main": "dist/index.js",
   "module": "./dist/index.js",
@@ -8,12 +8,18 @@
   "scripts": {
     "build": "tsc --outDir dist",
     "start:dev": "nodemon ./examples/node-server/app.ts",
+    "mysql:dev": "nodemon ./examples/mysql-node/app.ts",
     "integration-tests": "jest '.*\\.ispec\\.ts$'",
-    "test": "tsc src && jest --detectOpenHandles"
+    "test": "tsc src && jest --detectOpenHandles",
+    "style-check": "prettier --check \"**/*.{ts,tsx,md}\"",
+    "style-fix": "prettier --write \"**/*.{ts,tsx,md}\"",
+    "lint-check": "eslint \"**/*.{ts,tsx}\"",
+    "lint-fix": "eslint '**/*.{ts,tsx}' --fix"
   },
   "author": "lagambino",
   "license": "ISC",
   "devDependencies": {
+    "@eslint/js": "^9.9.0",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.11",
@@ -21,11 +27,18 @@
     "@types/pg": "^8.10.9",
     "@types/snowflake-sdk": "^1.6.20",
     "cors": "^2.8.5",
+    "eslint": "^9.9.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-react": "^7.35.0",
     "express": "^4.18.2",
+    "globals": "^15.9.0",
     "jest": "^29.7.0",
     "nodemon": "^3.0.2",
+    "prettier": "^3.3.3",
     "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.1.0"
   },
   "dependencies": {
     "@google-cloud/bigquery": "^7.4.0",