@quillsql/node 0.3.8 → 0.4.1

package/dist/db/BigQuery.js

@@ -9,9 +9,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemaColumnInfoBigQuery = exports.getForeignKeysBigQuery = exports.formatBigQueryConfig = exports.getColumnsByTableBigQuery = exports.getTablesBySchemaBigQuery = exports.getSchemaBigQuery = exports.runQueryBigQuery = exports.connectToBigQuery = void 0;
+exports.getSchemaColumnInfoBigQuery = exports.getForeignKeysBigQuery = exports.getColumnsByTableBigQuery = exports.getTablesBySchemaBigQuery = exports.getSchemaBigQuery = exports.runQueryBigQuery = exports.connectToBigQuery = exports.formatBigQueryConfig = void 0;
 const bigquery_1 = require("@google-cloud/bigquery");
 const textProcessing_1 = require("../utils/textProcessing");
+function formatBigQueryConfig(connectionString) {
+    const jsonStartIndex = connectionString.indexOf("{");
+    if (jsonStartIndex === -1) {
+        throw new Error("Invalid input string. No JSON data found.");
+    }
+    const datasetName = connectionString.substring(0, jsonStartIndex).trim();
+    const jsonString = connectionString.substring(jsonStartIndex);
+    try {
+        const serviceAccount = JSON.parse(jsonString);
+        // Validate if required fields are present
+        if (!serviceAccount.project_id || !serviceAccount.private_key) {
+            throw new Error("Invalid service account JSON. Required fields are missing.");
+        }
+        return {
+            datasetName,
+            projectId: serviceAccount.project_id,
+            credentials: serviceAccount,
+        };
+    }
+    catch (error) {
+        throw new Error("Failed to parse JSON string: " + error);
+    }
+}
+exports.formatBigQueryConfig = formatBigQueryConfig;
 function connectToBigQuery(config) {
     return new bigquery_1.BigQuery(config);
 }
@@ -55,11 +79,16 @@ function getSchemaBigQuery(bigQuery) {
     });
 }
 exports.getSchemaBigQuery = getSchemaBigQuery;
-function getTablesBySchemaBigQuery(bigQuery, schemaName) {
+function getTablesBySchemaBigQuery(bigQuery, schemaNames) {
     return __awaiter(this, void 0, void 0, function* () {
-        const sql = `SELECT table_name FROM ${schemaName}.INFORMATION_SCHEMA.TABLES WHERE table_type = 'BASE TABLE'`;
-        const rows = yield bigQuery.query(sql);
-        return rows[0].map((row) => row.table_name);
+        const allColumns = yield Promise.all(schemaNames.map((schema) => __awaiter(this, void 0, void 0, function* () {
+            const sql = `SELECT table_name FROM ${schema}.INFORMATION_SCHEMA.TABLES WHERE table_type = 'BASE TABLE'`;
+            const rows = yield bigQuery.query(sql);
+            return rows[0].map((row) => {
+                return { tableName: row.table_name, schemaName: schema };
+            });
+        })));
+        return allColumns.flat();
     });
 }
 exports.getTablesBySchemaBigQuery = getTablesBySchemaBigQuery;
@@ -71,30 +100,6 @@ function getColumnsByTableBigQuery(bigQuery, schemaName, tableName) {
     });
 }
 exports.getColumnsByTableBigQuery = getColumnsByTableBigQuery;
-function formatBigQueryConfig(connectionString) {
-    const jsonStartIndex = connectionString.indexOf("{");
-    if (jsonStartIndex === -1) {
-        throw new Error("Invalid input string. No JSON data found.");
-    }
-    const datasetName = connectionString.substring(0, jsonStartIndex).trim();
-    const jsonString = connectionString.substring(jsonStartIndex);
-    try {
-        const serviceAccount = JSON.parse(jsonString);
-        // Validate if required fields are present
-        if (!serviceAccount.project_id || !serviceAccount.private_key) {
-            throw new Error("Invalid service account JSON. Required fields are missing.");
-        }
-        return {
-            datasetName,
-            projectId: serviceAccount.project_id,
-            credentials: serviceAccount,
-        };
-    }
-    catch (error) {
-        throw new Error("Failed to parse JSON string: " + error);
-    }
-}
-exports.formatBigQueryConfig = formatBigQueryConfig;
 function getForeignKeysBigQuery(connection, schemaName, tableName, primaryKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
@@ -132,18 +137,18 @@ function getSchemaColumnInfoBigQuery(connection, schemaName, tableNames) {
         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 ${schemaName}.INFORMATION_SCHEMA.COLUMNS
-      WHERE table_name = '${tableName}'
+      FROM ${tableName.schemaName}.INFORMATION_SCHEMA.COLUMNS
+      WHERE table_name = '${tableName.tableName}'
       ORDER BY ordinal_position;
     `;
             const results = yield runQueryBigQuery(query, connection);
             return {
-                tableName,
-                displayName: tableName,
+                tableName: `${tableName.schemaName}.${tableName.tableName}`,
+                displayName: `${tableName.schemaName}.${tableName.tableName}`,
                 columns: results.rows.map((row) => ({
                     columnName: row.columnName,
                     displayName: row.columnName,
-                    dataTypeId: inferType(convertBigQueryTypeToPostgresOID(row.dataType)),
+                    dataTypeID: convertBigQueryTypeToPostgresOID(row.dataType),
                     fieldType: row.dataType,
                 })),
             };
@@ -168,11 +173,18 @@ function inferType(elem) {
         // Check if the number is a float or an integer
         return Number.isInteger(elem) ? 23 : 700; // 23: integer, 700: real
     }
+    if (typeof elem === "object") {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(elem.value))
+            return 1082; // date
+    }
     if (typeof elem === "string") {
         // Attempt to infer date, time, and timestamp formats
         // Date in YYYY-MM-DD format
         if (/^\d{4}-\d{2}-\d{2}$/.test(elem))
             return 1082; // date
+        // Date in MM\DD\YYYY or MM\DD\YY format
+        if (/^\d{2}\/\d{2}\/\d{2,4}$/.test(elem))
+            return 1082; // date
         // Timestamp in YYYY-MM-DDTHH:MM:SS[.fraction] format
         if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/.test(elem))
             return 1114; // timestamp without timezone

package/dist/db/DatabaseHelper.js

@@ -17,22 +17,22 @@ 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["postgresql"] = "postgresql";
+    DatabaseType["snowflake"] = "snowflake";
+    DatabaseType["bigquery"] = "bigquery";
+    DatabaseType["mysql"] = "mysql";
 })(DatabaseType || (exports.DatabaseType = DatabaseType = {}));
 function getDatabaseCredentials(databaseType, connectionString) {
-    switch (databaseType) {
+    switch (databaseType.toLowerCase()) {
         case "postgres":
             return (0, Postgres_1.formatPostgresConfig)(connectionString);
-        case "PostgreSQL":
+        case "postgresql":
             return (0, Postgres_1.formatPostgresConfig)(connectionString);
-        case "Snowflake":
+        case "snowflake":
             return (0, Snowflake_1.formatSnowflakeConfig)(connectionString);
-        case "BigQuery":
+        case "bigquery":
             return (0, BigQuery_1.formatBigQueryConfig)(connectionString);
-        case "MySQL":
+        case "mysql":
             return (0, Mysql_1.formatMysqlConfig)(connectionString);
         default:
             return undefined;
@@ -40,16 +40,16 @@ function getDatabaseCredentials(databaseType, connectionString) {
 }
 exports.getDatabaseCredentials = getDatabaseCredentials;
 function connectToDatabase(databaseType, config) {
-    switch (databaseType) {
+    switch (databaseType.toLowerCase()) {
         case "postgres":
             return (0, Postgres_1.connectToPostgres)(config);
-        case "PostgreSQL":
+        case "postgresql":
             return (0, Postgres_1.connectToPostgres)(config);
-        case "Snowflake":
+        case "snowflake":
             return (0, Snowflake_1.connectToSnowflake)(config);
-        case "BigQuery":
+        case "bigquery":
             return (0, BigQuery_1.connectToBigQuery)(config);
-        case "MySQL":
+        case "mysql":
             return (0, Mysql_1.connectToMysql)(config);
         default:
             return (0, Postgres_1.connectToPostgres)(config);
@@ -57,16 +57,16 @@ function connectToDatabase(databaseType, config) {
 }
 exports.connectToDatabase = connectToDatabase;
 function runQueryByDatabase(databaseType, connection, sql) {
-    switch (databaseType) {
+    switch (databaseType.toLowerCase()) {
         case "postgres":
             return (0, Postgres_1.runQueryPostgres)(sql, connection);
-        case "PostgreSQL":
+        case "postgresql":
             return (0, Postgres_1.runQueryPostgres)(sql, connection);
-        case "Snowflake":
+        case "snowflake":
             return (0, Snowflake_1.runQuerySnowflake)(sql, connection);
-        case "BigQuery":
+        case "bigquery":
             return (0, BigQuery_1.runQueryBigQuery)(sql, connection);
-        case "MySQL":
+        case "mysql":
             return (0, Mysql_1.runQueryMysql)(sql, connection);
         default:
             return undefined;
@@ -74,16 +74,16 @@ function runQueryByDatabase(databaseType, connection, sql) {
 }
 exports.runQueryByDatabase = runQueryByDatabase;
 function disconnectFromDatabase(databaseType, database) {
-    switch (databaseType) {
+    switch (databaseType.toLowerCase()) {
         case "postgres":
             return (0, Postgres_1.disconnectFromPostgres)(database);
-        case "PostgreSQL":
+        case "postgresql":
             return (0, Postgres_1.disconnectFromPostgres)(database);
-        case "Snowflake":
+        case "snowflake":
             return (0, Snowflake_1.disconnectFromSnowflake)(database);
-        case "BigQuery":
+        case "bigquery":
             return; // BigQuery does not need to be disconnected
-        case "MySQL":
+        case "mysql":
             return (0, Mysql_1.disconnectFromMysql)(database);
         default:
             return undefined;
@@ -92,16 +92,16 @@ function disconnectFromDatabase(databaseType, database) {
 exports.disconnectFromDatabase = disconnectFromDatabase;
 function getSchemasByDatabase(databaseType, connection) {
     return __awaiter(this, void 0, void 0, function* () {
-        switch (databaseType) {
+        switch (databaseType.toLowerCase()) {
             case "postgres":
                 return (0, Postgres_1.getSchemasPostgres)(connection);
-            case "PostgreSQL":
+            case "postgresql":
                 return (0, Postgres_1.getSchemasPostgres)(connection);
-            case "Snowflake":
+            case "snowflake":
                 return (0, Snowflake_1.getSchemasSnowflake)(connection);
-            case "BigQuery":
+            case "bigquery":
                 return (0, BigQuery_1.getSchemaBigQuery)(connection);
-            case "MySQL":
+            case "mysql":
                 return (0, Mysql_1.getSchemasMysql)(connection);
             default:
                 return undefined;
@@ -112,16 +112,16 @@ exports.getSchemasByDatabase = getSchemasByDatabase;
 // INFORMATION SCHEMA SELECTS
 function getTablesBySchemaByDatabase(databaseType, connection, schemaName) {
     return __awaiter(this, void 0, void 0, function* () {
-        switch (databaseType) {
+        switch (databaseType.toLowerCase()) {
             case "postgres":
                 return (0, Postgres_1.getTablesBySchemaPostgres)(connection, schemaName);
-            case "PostgreSQL":
+            case "postgresql":
                 return (0, Postgres_1.getTablesBySchemaPostgres)(connection, schemaName);
-            case "Snowflake":
+            case "snowflake":
                 return (0, Snowflake_1.getTablesBySchemaSnowflake)(connection, schemaName);
-            case "BigQuery":
+            case "bigquery":
                 return (0, BigQuery_1.getTablesBySchemaBigQuery)(connection, schemaName);
-            case "MySQL":
+            case "mysql":
                 return (0, Mysql_1.getTablesBySchemaMysql)(connection, schemaName);
             default:
                 return undefined;
@@ -132,16 +132,16 @@ exports.getTablesBySchemaByDatabase = getTablesBySchemaByDatabase;
 // INFORMATION SCHEMA SELECTS
 function getColumnsByTableByDatabase(databaseType, connection, schemaName, tableName) {
     return __awaiter(this, void 0, void 0, function* () {
-        switch (databaseType) {
+        switch (databaseType.toLowerCase()) {
             case "postgres":
                 return (0, Postgres_1.getColumnsByTablePostgres)(connection, schemaName, tableName);
-            case "PostgreSQL":
+            case "postgresql":
                 return (0, Postgres_1.getColumnsByTablePostgres)(connection, schemaName, tableName);
-            case "Snowflake":
+            case "snowflake":
                 return (0, Snowflake_1.getColumnsByTableSnowflake)(connection, schemaName, tableName);
-            case "BigQuery":
+            case "bigquery":
                 return (0, BigQuery_1.getColumnsByTableBigQuery)(connection, schemaName, tableName);
-            case "MySQL":
+            case "mysql":
                 return (0, Mysql_1.getColumnsByTableMysql)(connection, schemaName, tableName);
             default:
                 return undefined;
@@ -151,16 +151,16 @@ function getColumnsByTableByDatabase(databaseType, connection, schemaName, table
 exports.getColumnsByTableByDatabase = getColumnsByTableByDatabase;
 function getForiegnKeysByDatabase(databaseType, connection, schemaName, tableName, primaryKey) {
     return __awaiter(this, void 0, void 0, function* () {
-        switch (databaseType) {
+        switch (databaseType.toLowerCase()) {
             case "postgres":
                 return (0, Postgres_1.getForeignKeysPostgres)(connection, schemaName, tableName, primaryKey);
-            case "PostgreSQL":
+            case "postgresql":
                 return (0, Postgres_1.getForeignKeysPostgres)(connection, schemaName, tableName, primaryKey);
-            case "Snowflake":
+            case "snowflake":
                 return (0, Snowflake_1.getForeignKeysSnowflake)(connection, schemaName, tableName, primaryKey);
-            case "BigQuery":
+            case "bigquery":
                 return (0, BigQuery_1.getForeignKeysBigQuery)(connection, schemaName, tableName, primaryKey);
-            case "MySQL":
+            case "mysql":
                 return (0, Mysql_1.getForeignKeysMysql)(connection, schemaName, tableName, primaryKey);
             default:
                 return undefined;
@@ -169,16 +169,16 @@ function getForiegnKeysByDatabase(databaseType, connection, schemaName, tableNam
 }
 exports.getForiegnKeysByDatabase = getForiegnKeysByDatabase;
 function getColumnInfoBySchemaByDatabase(databaseType, connection, schemaName, tables) {
-    switch (databaseType) {
+    switch (databaseType.toLowerCase()) {
         case "postgres":
             return (0, Postgres_1.getSchemaColumnInfoPostgress)(connection, schemaName, tables);
-        case "PostgreSQL":
+        case "postgresql":
             return (0, Postgres_1.getSchemaColumnInfoPostgress)(connection, schemaName, tables);
-        case "Snowflake":
+        case "snowflake":
             return (0, Snowflake_1.getSchemaColumnInfoSnowflake)(connection, schemaName, tables);
-        case "BigQuery":
+        case "bigquery":
             return (0, BigQuery_1.getSchemaColumnInfoBigQuery)(connection, schemaName, tables);
-        case "MySQL":
+        case "mysql":
             return (0, Mysql_1.getSchemaColumnInfoMysql)(connection, schemaName, tables);
         default:
             return undefined;

package/dist/db/Mysql.js

@@ -73,11 +73,16 @@ function getSchemasMysql(connection) {
     });
 }
 exports.getSchemasMysql = getSchemasMysql;
-function getTablesBySchemaMysql(connection, schemaName) {
+function getTablesBySchemaMysql(connection, schemaNames) {
     return __awaiter(this, void 0, void 0, function* () {
-        const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${schemaName}'`;
-        const results = yield runQueryMysql(sql, connection);
-        return results.rows.map((row) => row.TABLE_NAME);
+        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 runQueryMysql(sql, connection);
+            return results.rows.map((row) => {
+                return { tableName: row.TABLE_NAME, schemaName: row.TABLE_SCHEMA };
+            });
+        })));
+        return allColumns.flat();
     });
 }
 exports.getTablesBySchemaMysql = getTablesBySchemaMysql;
@@ -130,17 +135,17 @@ function getSchemaColumnInfoMysql(connection, schemaName, tableNames) {
             const query = `
       SELECT COLUMN_NAME as columnName, 
       DATA_TYPE as dataType FROM INFORMATION_SCHEMA.COLUMNS 
-      WHERE TABLE_SCHEMA = '${schemaName}' 
-      AND TABLE_NAME = '${tableName}'
+      WHERE TABLE_SCHEMA = '${tableName.schemaName}' 
+      AND TABLE_NAME = '${tableName.tableName}'
     `;
             const results = yield runQueryMysql(query, connection);
             return {
-                tableName,
-                displayName: tableName,
+                tableName: `${tableName.schemaName}.${tableName.tableName}`,
+                displayName: `${tableName.schemaName}.${tableName.tableName}`,
                 columns: results.rows.map((row) => ({
                     columnName: row.columnName,
                     displayName: row.columnName,
-                    dataTypeId: mysqlTextDataTypeToPostgresOID(row.dataType),
+                    dataTypeID: mysqlTextDataTypeToPostgresOID(row.dataType),
                     fieldType: row.dataType,
                 })),
             };

package/dist/db/Postgres.js

@@ -43,11 +43,16 @@ function getSchemasPostgres(pool) {
     });
 }
 exports.getSchemasPostgres = getSchemasPostgres;
-function getTablesBySchemaPostgres(pool, schemaName) {
+function getTablesBySchemaPostgres(pool, schemaNames) {
     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);
+        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;
@@ -99,14 +104,14 @@ function getSchemaColumnInfoPostgress(pool, schemaName, tableNames) {
             const query = `
       SELECT column_name as "columnName", udt_name as "fieldType"
       FROM information_schema.columns
-      WHERE table_schema = '${schemaName}' 
-      AND table_name = '${tableName}'
+      WHERE table_schema = '${tableName.schemaName}' 
+      AND table_name = '${tableName.tableName}'
       ORDER BY ordinal_position;
     `;
             const results = yield runQueryPostgres(query, pool);
             return {
-                tableName,
-                displayName: tableName,
+                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) => {
@@ -118,7 +123,7 @@ function getSchemaColumnInfoPostgress(pool, schemaName, tableNames) {
                     return {
                         columnName: row.columnName,
                         displayName: row.columnName,
-                        dataTypeId: pgType,
+                        dataTypeID: pgType,
                         fieldType: row.fieldType,
                     };
                 }),

package/dist/db/Snowflake.js

@@ -67,11 +67,21 @@ function getSchemasSnowflake(connection) {
     });
 }
 exports.getSchemasSnowflake = getSchemasSnowflake;
-function getTablesBySchemaSnowflake(connection, schema) {
+function getTablesBySchemaSnowflake(connection, schemaNames) {
     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);
+        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;
@@ -156,18 +166,18 @@ function getSchemaColumnInfoSnowflake(connection, schemaName, tableNames) {
             const query = `SELECT 
       COLUMN_NAME as "columnName", DATA_TYPE as "dataType"
       FROM INFORMATION_SCHEMA.COLUMNS
-      WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_NAME = '${tableName}';
+      WHERE TABLE_SCHEMA = '${tableName.schemaName}' AND TABLE_NAME = '${tableName.tableName}';
     `;
             const results = yield runQuerySnowflake(query, connection);
             return {
-                tableName,
-                displayName: tableName,
+                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,
+                        dataTypeID: postgresType,
                         fieldType: row.dataType,
                     };
                 }),

package/dist/index.js

@@ -16,8 +16,8 @@ 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 schemaConversion_1 = require("./utils/schemaConversion");
 const HOST = process.env.ENV === "development"
     ? "http://localhost:8080"
     : "https://quill-344421.uc.r.appspot.com";
@@ -25,44 +25,35 @@ const HOST = process.env.ENV === "development"
  * Quill - Fullstack API Platform for Dashboards and Reporting.
  */
 class QuillClass {
-    constructor(privateKey, databaseConnectionString, cache = {}, databaseType, metadataServerURL) {
+    constructor(privateKey, databaseType, databaseConnectionString, databaseCredentials, cache = {}, metadataServerURL) {
         this.baseUrl = metadataServerURL ? metadataServerURL : HOST;
         this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-        this.targetConnection = new CachedConnection_1.CachedConnection(databaseType, (0, DatabaseHelper_1.getDatabaseCredentials)(databaseType, databaseConnectionString), 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, _c;
         return __awaiter(this, void 0, void 0, function* () {
             this.targetConnection.orgId = orgId;
             try {
-                // Initial Query Request
-                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,
-                    columns, viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined }));
+                    ? 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 &&
                     ((_c = (_b = response.metadata) === null || _b === void 0 ? void 0 : _b.runQueryConfig) === null || _c === void 0 ? void 0 : _c.arrayToMap)) {
@@ -94,28 +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 (!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.targetConnection);
+                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.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.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) });
                 }
+                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;
         });
@@ -133,8 +160,8 @@ class QuillClass {
     }
 }
 exports.default = QuillClass;
-const Quill = ({ privateKey, databaseConnectionString, cache, databaseType, metadataServerURL, }) => {
-    return new QuillClass(privateKey, databaseConnectionString, cache, databaseType, metadataServerURL);
+const Quill = ({ privateKey, databaseConnectionString, databaseConfig, cache, databaseType, metadataServerURL, }) => {
+    return new QuillClass(privateKey, databaseType, databaseConnectionString, databaseConfig, cache, metadataServerURL);
 };
 module.exports = Quill;
 module.exports.Quill = Quill;

package/dist/index.uspec.js

@@ -9,7 +9,7 @@ jest.mock(".");
 describe("Quill", () => {
     let quill;
     beforeEach(() => {
-        quill = new _1.default("dummy_private_key", "dummy_db_url", {}, DatabaseHelper_1.DatabaseType.postgres, undefined);
+        quill = new _1.default("dummy_private_key", DatabaseHelper_1.DatabaseType.postgres, "dummy_db_url", {}, undefined);
         quill.targetConnection.query = jest.fn().mockResolvedValue([]);
     });
     describe("query", () => {