@quillsql/node 0.3.7 → 0.3.8

package/dist/db/Postgres.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPostgresConfig = exports.getSchemaColumnInfoPostgress = exports.getForeignKeysPostgres = exports.getColumnsByTablePostgres = exports.getTablesBySchemaPostgres = exports.getSchemasPostgres = exports.runQueryPostgres = exports.disconnectFromPostgres = exports.connectToPostgres = void 0;
+const pg_1 = require("pg");
+const textProcessing_1 = require("../utils/textProcessing");
+const pgtypes_1 = require("../assets/pgtypes");
+function connectToPostgres(config) {
+    return new pg_1.Pool(config);
+}
+exports.connectToPostgres = connectToPostgres;
+function disconnectFromPostgres(pool) {
+    pool.end();
+}
+exports.disconnectFromPostgres = disconnectFromPostgres;
+function runQueryPostgres(sql, pool) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield pool.query(sql);
+        return {
+            fields: results.fields.map((field) => ({
+                name: field.name,
+                dataTypeID: field.dataTypeID,
+            })),
+            rows: results.rows,
+        };
+    });
+}
+exports.runQueryPostgres = runQueryPostgres;
+function getSchemasPostgres(pool) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT schema_name FROM information_schema.schemata 
+    WHERE schema_name NOT LIKE 'pg_%' AND schema_name != 'information_schema';`;
+        const results = yield runQueryPostgres(sql, pool);
+        return results.rows.map((row) => row.schema_name);
+    });
+}
+exports.getSchemasPostgres = getSchemasPostgres;
+function getTablesBySchemaPostgres(pool, schemaName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT table_name FROM information_schema.tables WHERE table_schema = '${schemaName}'`;
+        const results = yield runQueryPostgres(sql, pool);
+        return results.rows.map((row) => row.table_name);
+    });
+}
+exports.getTablesBySchemaPostgres = getTablesBySchemaPostgres;
+function getColumnsByTablePostgres(pool, schemaName, tableName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT column_name FROM information_schema.columns WHERE table_schema = '${schemaName}' and table_name = '${tableName}'`;
+        const results = yield runQueryPostgres(sql, pool);
+        return results.rows.map((row) => row.column_name);
+    });
+}
+exports.getColumnsByTablePostgres = getColumnsByTablePostgres;
+function getForeignKeysPostgres(pool, schemaName, tableName, primaryKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
+        let sql = `SELECT column_name FROM information_schema.columns 
+  WHERE table_schema = '${schemaName}' 
+  and table_name != '${tableName}' 
+  and (column_name = '${primaryKey}' 
+    or column_name = '${depluralizedTableName}_${primaryKey}' 
+    or column_name = '${depluralizedTableName}${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+        const results = yield runQueryPostgres(sql, pool);
+        let foreignKeysString = results.rows.map((key) => {
+            return key.column_name;
+        });
+        foreignKeysString = foreignKeysString.filter((key) => key !== "id" && key !== "_id_");
+        foreignKeysString = [...new Set(foreignKeysString)];
+        if (foreignKeysString.length === 0) {
+            sql = `SELECT column_name FROM information_schema.columns 
+      WHERE table_schema = '${schemaName}' 
+      and table_name != '${tableName}' 
+      and (column_name like '${tableName}%' 
+      or column_name like '%\\_id' 
+      or column_name like '%Id' 
+      or column_name like '%\\_${primaryKey}' 
+      or column_name like '%${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+            const results = yield runQueryPostgres(sql, pool);
+            foreignKeysString = results.rows.map((key) => {
+                return key.column_name;
+            });
+            foreignKeysString = [...new Set(foreignKeysString)];
+        }
+        return foreignKeysString;
+    });
+}
+exports.getForeignKeysPostgres = getForeignKeysPostgres;
+function getSchemaColumnInfoPostgress(pool, schemaName, tableNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(tableNames.map((tableName) => __awaiter(this, void 0, void 0, function* () {
+            const query = `
+      SELECT column_name as "columnName", udt_name as "fieldType"
+      FROM information_schema.columns
+      WHERE table_schema = '${schemaName}' 
+      AND table_name = '${tableName}'
+      ORDER BY ordinal_position;
+    `;
+            const results = yield runQueryPostgres(query, pool);
+            return {
+                tableName,
+                displayName: tableName,
+                columns: results.rows.map((row) => {
+                    var _a;
+                    let pgType = (_a = pgtypes_1.PG_TYPES.find((pgType) => {
+                        return pgType.typname === row.fieldType;
+                    })) === null || _a === void 0 ? void 0 : _a.oid;
+                    if (!pgType) {
+                        pgType = 1043;
+                    }
+                    return {
+                        columnName: row.columnName,
+                        displayName: row.columnName,
+                        dataTypeId: pgType,
+                        fieldType: row.fieldType,
+                    };
+                }),
+            };
+        })));
+        return allColumns;
+    });
+}
+exports.getSchemaColumnInfoPostgress = getSchemaColumnInfoPostgress;
+function formatPostgresConfig(connectionString) {
+    return { connectionString, ssl: { rejectUnauthorized: false } };
+}
+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 };
+}

package/dist/db/Snowflake.js

@@ -0,0 +1,179 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaColumnInfoSnowflake = exports.getForeignKeysSnowflake = exports.disconnectFromSnowflake = exports.connectToSnowflake = exports.formatSnowflakeConfig = exports.getColumnsByTableSnowflake = exports.getTablesBySchemaSnowflake = exports.getSchemasSnowflake = exports.runQuerySnowflake = void 0;
+const snowflake_sdk_1 = __importDefault(require("snowflake-sdk"));
+const textProcessing_1 = require("../utils/textProcessing");
+const POSTGRES_SNOWFLAKE_MAP = {
+    BOOLEAN: 16,
+    FIXED: 1700, // DECIMAL or NUMERIC
+    REAL: 700, // FLOAT4
+    DOUBLE: 701, // FLOAT8
+    TEXT: 25, // TEXT in PostgreSQL
+    DATE: 1082,
+    DATETIME: 1184, // TIMESTAMP in PostgreSQL
+    TIME: 1083,
+    TIMESTAMP_LTZ: 1184,
+    TIMESTAMP_NTZ: 1184,
+    TIMESTAMP_TZ: 1184,
+    VARIANT: 114, // JSONB in PostgreSQL
+    OBJECT: 114, // JSONB, as an equivalent for structured JSON
+    ARRAY: 1009, // TEXT[], assuming most common case
+    BINARY: 17, // BYTEA
+};
+function runQuerySnowflake(sql, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = yield new Promise((resolve, reject) => {
+            connection.execute({
+                sqlText: sql,
+                complete: (err, stmt, rows) => {
+                    if (err) {
+                        reject(err);
+                        return { success: false, message: err.message };
+                    }
+                    else {
+                        resolve({
+                            rows,
+                            fields: stmt.getColumns().map((col) => ({
+                                name: col.getName(),
+                                dataTypeID: POSTGRES_SNOWFLAKE_MAP[col.getType().toUpperCase()],
+                            })),
+                        });
+                    }
+                },
+            });
+        });
+        return results;
+    });
+}
+exports.runQuerySnowflake = runQuerySnowflake;
+function getSchemasSnowflake(connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA
+    WHERE SCHEMA_NAME != 'INFORMATION_SCHEMA'`;
+        const results = yield runQuerySnowflake(sql, connection);
+        return results.rows.map((row) => row.SCHEMA_NAME);
+    });
+}
+exports.getSchemasSnowflake = getSchemasSnowflake;
+function getTablesBySchemaSnowflake(connection, schema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${schema}'`;
+        const results = yield runQuerySnowflake(sql, connection);
+        return results.rows.map((row) => row.TABLE_NAME);
+    });
+}
+exports.getTablesBySchemaSnowflake = getTablesBySchemaSnowflake;
+function getColumnsByTableSnowflake(connection, schemaName, tableName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_NAME = '${tableName}'`;
+        const results = yield runQuerySnowflake(sql, connection);
+        return results.rows.map((row) => row.COLUMN_NAME);
+    });
+}
+exports.getColumnsByTableSnowflake = getColumnsByTableSnowflake;
+function formatSnowflakeConfig(connectionString) {
+    const parsed = new URL(connectionString);
+    return {
+        account: parsed.hostname,
+        username: parsed.username,
+        password: parsed.password,
+        database: parsed.pathname.split("/")[1],
+        warehouse: parsed.pathname.split("/")[2],
+    };
+}
+exports.formatSnowflakeConfig = formatSnowflakeConfig;
+function connectToSnowflake(config) {
+    const connection = snowflake_sdk_1.default.createConnection(config);
+    connection.connect((err) => {
+        if (err) {
+            console.error(`Failed to connect to Snowflake: ${err.message}`);
+        }
+    });
+    return connection;
+}
+exports.connectToSnowflake = connectToSnowflake;
+function disconnectFromSnowflake(connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        connection.destroy((err, conn) => {
+            if (err) {
+                console.error(`Failed to disconnect from Snowflake: ${err.message}`);
+            }
+        });
+    });
+}
+exports.disconnectFromSnowflake = disconnectFromSnowflake;
+function getForeignKeysSnowflake(connection, schemaName, tableName, primaryKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
+        let sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
+    WHERE TABLE_SCHEMA = '${schemaName}' 
+    AND TABLE_NAME = '${schemaName}' 
+    and TABLE_NAME != '${tableName}' 
+    and (COLUMN_NAME = '${primaryKey}' 
+    or COLUMN_NAME = '${depluralizedTableName}_${primaryKey}' 
+    or COLUMN_NAME = '${depluralizedTableName}${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+        const results = yield runQuerySnowflake(sql, connection);
+        let foreignKeysString = results.rows.map((key) => {
+            return key.COLUMN_NAME;
+        });
+        foreignKeysString = foreignKeysString.filter((key) => key !== "id" && key !== "_id_");
+        foreignKeysString = [...new Set(foreignKeysString)];
+        if (foreignKeysString.length === 0) {
+            sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
+      WHERE TABLE_SCHEMA = '${schemaName}' 
+      AND TABLE_NAME = '${schemaName}' 
+      and TABLE_NAME != '${tableName}' 
+      and (COLUMN_NAME like '${depluralizedTableName}%' 
+        or column_name like '%\\_id' 
+        or column_name like '%Id'
+        or COLUMN_NAME like '%\\_${primaryKey}' 
+        or COLUMN_NAME like '%${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+            const results = yield runQuerySnowflake(sql, connection);
+            foreignKeysString = results.rows.map((key) => {
+                return key.COLUMN_NAME;
+            });
+            foreignKeysString = [...new Set(foreignKeysString)];
+        }
+        return foreignKeysString;
+    });
+}
+exports.getForeignKeysSnowflake = getForeignKeysSnowflake;
+function getSchemaColumnInfoSnowflake(connection, schemaName, tableNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(tableNames.map((tableName) => __awaiter(this, void 0, void 0, function* () {
+            const query = `SELECT 
+      COLUMN_NAME as "columnName", DATA_TYPE as "dataType"
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_NAME = '${tableName}';
+    `;
+            const results = yield runQuerySnowflake(query, connection);
+            return {
+                tableName,
+                displayName: tableName,
+                columns: results.rows.map((row) => {
+                    const postgresType = POSTGRES_SNOWFLAKE_MAP[row.dataType];
+                    return {
+                        columnName: row.columnName,
+                        displayName: row.columnName,
+                        dataTypeId: postgresType,
+                        fieldType: row.dataType,
+                    };
+                }),
+            };
+        })));
+        return allColumns;
+    });
+}
+exports.getSchemaColumnInfoSnowflake = getSchemaColumnInfoSnowflake;

package/dist/index.js

@@ -12,10 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const CachedPools_1 = require("./db/CachedPools");
+const CachedConnection_1 = require("./db/CachedConnection");
 const axios_1 = __importDefault(require("axios"));
 require("dotenv/config");
 const RunQueryProcesses_1 = require("./utils/RunQueryProcesses");
+const pgtypes_1 = require("./assets/pgtypes");
+const DatabaseHelper_1 = require("./db/DatabaseHelper");
 const HOST = process.env.ENV === "development"
     ? "http://localhost:8080"
     : "https://quill-344421.uc.r.appspot.com";
@@ -23,23 +25,39 @@ const HOST = process.env.ENV === "development"
  * Quill - Fullstack API Platform for Dashboards and Reporting.
  */
 class QuillClass {
-    constructor(privateKey, databaseConnectionString, cache = {}) {
-        this.ssl = { rejectUnauthorized: false };
-        this.baseUrl = HOST;
+    constructor(privateKey, databaseConnectionString, cache = {}, databaseType, metadataServerURL) {
+        this.baseUrl = metadataServerURL ? metadataServerURL : HOST;
         this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-        this.connectionString = databaseConnectionString;
-        this.ssl = { rejectUnauthorized: false };
-        this.targetPool = new CachedPools_1.CachedPool({ connectionString: this.connectionString, ssl: this.ssl }, cache);
+        this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, (0, DatabaseHelper_1.getDatabaseCredentials)(databaseType, databaseConnectionString), cache);
     }
     query({ orgId, metadata }) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            this.targetPool.orgId = orgId;
+            this.targetConnection.orgId = orgId;
             try {
                 // Initial Query Request
-                const preQueryResults = yield this.runQueries(metadata.preQueries);
+                const limitedQueries = metadata.preQueries
+                    ? (_a = metadata.preQueries) === null || _a === void 0 ? void 0 : _a.map((query) => query + " limit 1")
+                    : [];
+                const preQueryResults = metadata.preQueries
+                    ? yield this.runQueries(limitedQueries)
+                    : [];
+                const columns = metadata.preQueries
+                    ? preQueryResults.queryResults[0].fields.map((field) => {
+                        var _a;
+                        return {
+                            fieldType: pgtypes_1.PG_TYPES.find((type) => field.dataTypeID === type.oid)
+                                ? (_a = pgtypes_1.PG_TYPES.find((type) => field.dataTypeID === type.oid)) === null || _a === void 0 ? void 0 : _a.typname
+                                : field.dataTypeID,
+                            name: field.name,
+                            displayName: field.name,
+                            isVisible: true,
+                            field: field.name,
+                        };
+                    })
+                    : metadata.columns;
                 const response = yield this.postQuill(metadata.task, Object.assign(Object.assign({}, metadata), { orgId,
-                    preQueryResults }));
+                    columns, viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined }));
                 // if there is no metadata object in the response, create one
                 if (!response.metadata) {
                     response.metadata = {};
@@ -47,7 +65,7 @@ class QuillClass {
                 const results = yield this.runQueries(response.queries, response.metadata.runQueryConfig);
                 // QUICK JANKY FIX TO UPDATE METADATA AFTER GETTING MAPPED ARRAYS
                 if (results.mappedArray &&
-                    ((_b = (_a = response.metadata) === null || _a === void 0 ? void 0 : _a.runQueryConfig) === null || _b === void 0 ? void 0 : _b.arrayToMap)) {
+                    ((_c = (_b = response.metadata) === null || _b === void 0 ? void 0 : _b.runQueryConfig) === null || _c === void 0 ? void 0 : _c.arrayToMap)) {
                     const arrayToMap = response.metadata.runQueryConfig.arrayToMap;
                     results.mappedArray.forEach((array, index) => {
                         response.metadata[arrayToMap.arrayName][index][arrayToMap.field] =
@@ -79,19 +97,21 @@ class QuillClass {
     runQueries(queries, runQueryConfig) {
         return __awaiter(this, void 0, void 0, function* () {
             let results;
+            if (!queries)
+                return Object.assign(Object.assign({}, results), { queryResults: [] });
             if (!queries)
                 return Object.assign(Object.assign({}, results), { queryResults: [] });
             if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.arrayToMap) {
-                const mappedArray = yield (0, RunQueryProcesses_1.mapQueries)(queries, runQueryConfig.arrayToMap, this.targetPool);
+                const mappedArray = yield (0, RunQueryProcesses_1.mapQueries)(queries, runQueryConfig.arrayToMap, this.targetConnection);
                 return Object.assign(Object.assign({}, results), { queryResults: [], mappedArray });
             }
             else {
                 const queryResults = yield Promise.all(queries.map((query) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.targetPool.query(query);
+                    return yield this.targetConnection.query(query);
                 })));
                 results = Object.assign(Object.assign({}, results), { queryResults });
                 if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getSchema) {
-                    results = Object.assign(Object.assign({}, results), { columns: yield (0, RunQueryProcesses_1.getTableSchema)(queryResults[0], this.targetPool) });
+                    results = Object.assign(Object.assign({}, results), { columns: yield (0, RunQueryProcesses_1.getTableSchema)(queryResults[0], this.targetConnection) });
                 }
                 if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.removeFields) {
                     results = Object.assign(Object.assign({}, results), { queryResults: (0, RunQueryProcesses_1.removeFields)(queryResults, runQueryConfig.removeFields) });
@@ -108,14 +128,23 @@ class QuillClass {
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.targetPool.close();
+            yield this.targetConnection.close();
         });
     }
 }
 exports.default = QuillClass;
-const Quill = ({ privateKey, databaseConnectionString, cache, }) => {
-    return new QuillClass(privateKey, databaseConnectionString, cache);
+const Quill = ({ privateKey, databaseConnectionString, cache, databaseType, metadataServerURL, }) => {
+    return new QuillClass(privateKey, databaseConnectionString, cache, databaseType, metadataServerURL);
 };
 module.exports = Quill;
 module.exports.Quill = Quill;
 module.exports.default = Quill;
+module.exports.getTablesBySchemaByDatabase = DatabaseHelper_1.getTablesBySchemaByDatabase;
+module.exports.getDatabaseCredentials = DatabaseHelper_1.getDatabaseCredentials;
+module.exports.getColumnsByTableByDatabase = DatabaseHelper_1.getColumnsByTableByDatabase;
+module.exports.getForiegnKeysByDatabase = DatabaseHelper_1.getForiegnKeysByDatabase;
+module.exports.getSchemasByDatabase = DatabaseHelper_1.getSchemasByDatabase;
+module.exports.getColumnInfoBySchemaByDatabase =
+    DatabaseHelper_1.getColumnInfoBySchemaByDatabase;
+module.exports.connectToDatabase = DatabaseHelper_1.connectToDatabase;
+module.exports.runQueryByDatabase = DatabaseHelper_1.runQueryByDatabase;

package/dist/index.uspec.js

@@ -4,12 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (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", "dummy_db_url");
-        quill.targetPool.query = jest.fn().mockResolvedValue([]);
+        quill = new _1.default("dummy_private_key", "dummy_db_url", {}, DatabaseHelper_1.DatabaseType.postgres, undefined);
+        quill.targetConnection.query = jest.fn().mockResolvedValue([]);
     });
     describe("query", () => {
         it("return nothing when suppling no queries", () => {

package/dist/models/Client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/RunQueryProcesses.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapQueries = exports.removeFields = exports.getTableSchema = void 0;
-function getTableSchema(queryResults, targetPool) {
+function getTableSchema(queryResults, targetConnection) {
     return __awaiter(this, void 0, void 0, function* () {
-        const typesQuery = yield targetPool.query("select typname, oid, typarray from pg_type order by oid;");
+        const typesQuery = yield targetConnection.query("select typname, oid, typarray from pg_type order by oid;");
         const schema = queryResults[0].fields.map((field) => {
             return {
                 fieldType: typesQuery.rows.filter((type) => field.dataTypeID === type.oid)[0].typname,
@@ -35,11 +35,11 @@ function removeFields(queryResults, fieldsToRemove) {
     });
 }
 exports.removeFields = removeFields;
-function mapQueries(queries, arrayToMap, targetPool) {
+function mapQueries(queries, arrayToMap, targetConnection) {
     return __awaiter(this, void 0, void 0, function* () {
         const mappedArray = [];
         for (let i = 0; i < queries.length; i++) {
-            const queryResult = yield targetPool.query(queries[i]);
+            const queryResult = yield targetConnection.query(queries[i]);
             mappedArray.push(queryResult.rows);
         }
         return mappedArray;

package/dist/utils/textProcessing.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depluralize = exports.capitalize = void 0;
+function capitalize(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+exports.capitalize = capitalize;
+function depluralize(text) {
+    if (text.endsWith("ies")) {
+        return text.slice(0, -3) + "y";
+    }
+    if (text.endsWith("s")) {
+        return text.slice(0, -1);
+    }
+    return text;
+}
+exports.depluralize = depluralize;

package/examples/node-server/app.ts

@@ -1,17 +1,15 @@
 // Write a simple node server to test the SDK
 
 import express from "express";
-import Quill from "../../src/index";
 import cors from "cors";
 
 const app = express();
-const port = 3000;
+const port = 3001;
 
-const quill = new Quill(
-  process.env.QUILL_PRIVATE_KEY as string,
-  process.env.DB_URL as string,
-  {}
-);
+const quill = require("../../src/index")({
+  privateKey: process.env.QUILL_PRIVATE_KEY,
+  databaseConnectionString: process.env.DB_URL,
+});
 
 app.use(cors());
 app.use(express.json());
@@ -24,7 +22,7 @@ app.post("/quill", async (req, res) => {
   const organizationId = req.body.orgId;
   const { metadata } = req.body;
   const result = await quill.query({
-    orgId: organizationId,
+    orgId: metadata.orgId,
     metadata,
   });
   res.send(result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "Quill's client SDK for node backends.",
   "main": "dist/index.js",
   "module": "./dist/index.js",
@@ -18,6 +18,7 @@
     "@types/jest": "^29.5.11",
     "@types/node": "^20.10.7",
     "@types/pg": "^8.10.9",
+    "@types/snowflake-sdk": "^1.6.20",
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "jest": "^29.7.0",
@@ -26,10 +27,13 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@google-cloud/bigquery": "^7.4.0",
     "axios": "^1.6.5",
     "dotenv": "^16.3.1",
+    "mysql2": "^3.9.1",
     "pg": "^8.11.3",
     "redis": "^4.6.12",
+    "snowflake-sdk": "^1.9.3",
     "ts-jest": "^29.1.1"
   }
 }