@quillsql/node 0.3.7 → 0.4.0

package/dist/db/Postgres.js

@@ -0,0 +1,161 @@
+"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, schemaNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(schemaNames.map((schema) => __awaiter(this, void 0, void 0, function* () {
+            const sql = `SELECT table_name, table_schema FROM information_schema.tables WHERE table_schema = '${schema}'`;
+            const results = yield runQueryPostgres(sql, pool);
+            return results.rows.map((row) => {
+                return { tableName: row.table_name, schemaName: row.table_schema };
+            });
+        })));
+        return allColumns.flat();
+    });
+}
+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 = '${tableName.schemaName}' 
+      AND table_name = '${tableName.tableName}'
+      ORDER BY ordinal_position;
+    `;
+            const results = yield runQueryPostgres(query, pool);
+            return {
+                tableName: `${tableName.schemaName}.${tableName.tableName}`,
+                displayName: `${tableName.schemaName}.${tableName.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,189 @@
+"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, schemaNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(schemaNames.map((schema) => __awaiter(this, void 0, void 0, function* () {
+            const query = `SELECT 
+      TABLE_NAME as "tableName",
+      TABLE_SCHEMA as "schemaName"
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE  TABLE_SCHEMA = '${schema}';
+    `;
+            const results = yield runQuerySnowflake(query, connection);
+            return results.rows.map((row) => {
+                return { tableName: row.tableName, schemaName: row.schemaName };
+            });
+        })));
+        return allColumns.flat();
+    });
+}
+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 = '${tableName.schemaName}' AND TABLE_NAME = '${tableName.tableName}';
+    `;
+            const results = yield runQuerySnowflake(query, connection);
+            return {
+                tableName: `${tableName.schemaName}.${tableName.tableName}`,
+                displayName: `${tableName.schemaName}.${tableName.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 DatabaseHelper_1 = require("./db/DatabaseHelper");
+const schemaConversion_1 = require("./utils/schemaConversion");
 const HOST = process.env.ENV === "development"
     ? "http://localhost:8080"
     : "https://quill-344421.uc.r.appspot.com";
@@ -23,31 +25,38 @@ 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, databaseType, databaseConnectionString, databaseCredentials, cache = {}, 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);
+        let credentials = databaseCredentials;
+        if (databaseConnectionString) {
+            credentials = (0, DatabaseHelper_1.getDatabaseCredentials)(databaseType, databaseConnectionString);
+        }
+        this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, credentials, 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 response = yield this.postQuill(metadata.task, Object.assign(Object.assign({}, metadata), { orgId,
-                    preQueryResults }));
+                const preQueryResults = metadata.preQueries
+                    ? yield this.runQueries(metadata.preQueries, this.targetConnection.databaseType, metadata.databaseType, metadata.runQueryConfig)
+                    : {};
+                if ((_a = metadata.runQueryConfig) === null || _a === void 0 ? void 0 : _a.overridePost) {
+                    return {
+                        data: { queryResults: preQueryResults },
+                        status: "success",
+                    };
+                }
+                const response = yield this.postQuill(metadata.task, Object.assign(Object.assign(Object.assign({}, metadata), preQueryResults), { orgId, viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined }));
                 // if there is no metadata object in the response, create one
                 if (!response.metadata) {
                     response.metadata = {};
                 }
-                const results = yield this.runQueries(response.queries, response.metadata.runQueryConfig);
+                const results = yield this.runQueries(response.queries, this.targetConnection.databaseType, metadata.databaseType, 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] =
@@ -76,26 +85,64 @@ class QuillClass {
             }
         });
     }
-    runQueries(queries, runQueryConfig) {
+    runQueries(queries, pkDatabaseType, databaseType, runQueryConfig) {
         return __awaiter(this, void 0, void 0, function* () {
             let results;
             if (!queries)
                 return Object.assign(Object.assign({}, results), { queryResults: [] });
+            if (databaseType &&
+                databaseType.toLowerCase() !== pkDatabaseType.toLowerCase()) {
+                return {
+                    dbMismatched: true,
+                    backendDatbaseType: pkDatabaseType,
+                    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, this.targetConnection);
                 return Object.assign(Object.assign({}, results), { queryResults: [], mappedArray });
             }
+            else if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getColumns) {
+                const queryResult = yield this.targetConnection.query(`${queries[0]} limit 1`);
+                const columns = queryResult.fields.map((field) => {
+                    return {
+                        fieldType: (0, schemaConversion_1.convertTypeToPostgres)(field.dataTypeID),
+                        name: field.name,
+                        displayName: field.name,
+                        isVisible: true,
+                        field: field.name,
+                    };
+                });
+                return { columns };
+            }
+            else if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getTables) {
+                const queryResult = yield (0, DatabaseHelper_1.getTablesBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.pool, runQueryConfig.schemaNames || runQueryConfig.schema);
+                const schemaInfo = yield (0, DatabaseHelper_1.getColumnInfoBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.pool, runQueryConfig.schema, queryResult);
+                return schemaInfo;
+            }
             else {
+                if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.limitThousand) {
+                    queries = queries.map((query) => {
+                        return query.replace(/;/, "") + " limit 1000;";
+                    });
+                }
                 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) });
-                }
                 if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.removeFields) {
                     results = Object.assign(Object.assign({}, results), { queryResults: (0, RunQueryProcesses_1.removeFields)(queryResults, runQueryConfig.removeFields) });
                 }
+                if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.convertDatatypes) {
+                    results = queryResults.map((result) => {
+                        return {
+                            fields: result.fields.map((field) => {
+                                return Object.assign(Object.assign({}, field), { fieldType: (0, schemaConversion_1.convertTypeToPostgres)(field.dataTypeID), isVisible: true, field: field.name, displayName: field.name, name: field.name });
+                            }),
+                            rows: result.rows,
+                        };
+                    });
+                }
             }
             return results;
         });
@@ -108,14 +155,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, databaseConfig, cache, databaseType, metadataServerURL, }) => {
+    return new QuillClass(privateKey, databaseType, databaseConnectionString, databaseConfig, cache, 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", DatabaseHelper_1.DatabaseType.postgres, "dummy_db_url", {}, 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

@@ -9,22 +9,7 @@ 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) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const typesQuery = yield targetPool.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,
-                name: field.name,
-                displayName: field.name,
-                isVisible: true,
-            };
-        });
-        return schema;
-    });
-}
-exports.getTableSchema = getTableSchema;
+exports.mapQueries = exports.removeFields = void 0;
 function removeFields(queryResults, fieldsToRemove) {
     const fields = queryResults.fields.filter((field) => fieldsToRemove.includes(field.name));
     const rows = queryResults.map((row) => {
@@ -35,11 +20,11 @@ function removeFields(queryResults, fieldsToRemove) {
     });
 }
 exports.removeFields = removeFields;
-function mapQueries(queries, arrayToMap, targetPool) {
+function mapQueries(queries, 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/schemaConversion.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTypeToPostgres = void 0;
+const pgtypes_1 = require("../assets/pgtypes");
+function convertTypeToPostgres(data_type_id) {
+    var _a;
+    const type = pgtypes_1.PG_TYPES.find((type) => data_type_id === type.oid)
+        ? (_a = pgtypes_1.PG_TYPES.find((type) => data_type_id === type.oid)) === null || _a === void 0 ? void 0 : _a.typname
+        : undefined;
+    if (!type) {
+        return "varchar";
+    }
+    return type;
+}
+exports.convertTypeToPostgres = convertTypeToPostgres;

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;