@quillsql/node 0.3.6 → 0.3.8

package/src/index.ts

@@ -5,7 +5,7 @@ import {
   QuillClientResponse,
   QuillQueryParams,
 } from "./models/Quill";
-import { CachedPool } from "./db/CachedPools";
+import { CachedConnection } from "./db/CachedConnection";
 import axios from "axios";
 import "dotenv/config";
 import {
@@ -13,6 +13,18 @@ import {
   mapQueries,
   removeFields,
 } from "./utils/RunQueryProcesses";
+import { PG_TYPES } from "./assets/pgtypes";
+import {
+  DatabaseType,
+  connectToDatabase,
+  getColumnInfoBySchemaByDatabase,
+  getColumnsByTableByDatabase,
+  getDatabaseCredentials,
+  getForiegnKeysByDatabase,
+  getSchemasByDatabase,
+  getTablesBySchemaByDatabase,
+  runQueryByDatabase,
+} from "./db/DatabaseHelper";
 
 const HOST =
   process.env.ENV === "development"
@@ -25,9 +37,7 @@ const HOST =
 
 export default class QuillClass {
   // Configure cached connection pools with the given config.
-  private connectionString;
-  private ssl = { rejectUnauthorized: false };
-  public targetPool;
+  public targetConnection;
   private baseUrl: string;
   private config: {
     headers: {
@@ -38,28 +48,49 @@ export default class QuillClass {
   constructor(
     privateKey: string,
     databaseConnectionString: string,
-    cache: Partial<CacheCredentials> = {}
+    cache: Partial<CacheCredentials> = {},
+    databaseType: DatabaseType,
+    metadataServerURL?: string
   ) {
-    this.baseUrl = HOST;
+    this.baseUrl = metadataServerURL ? metadataServerURL : HOST;
     this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-    this.connectionString = databaseConnectionString;
-    this.ssl = { rejectUnauthorized: false };
-    this.targetPool = new CachedPool(
-      { connectionString: this.connectionString, ssl: this.ssl },
+    this.targetConnection = new CachedConnection(
+      databaseType,
+      getDatabaseCredentials(databaseType, databaseConnectionString),
       cache
     );
   }
 
   public async query({ orgId, metadata }: QuillQueryParams): Promise<any> {
-    this.targetPool.orgId = orgId;
+    this.targetConnection.orgId = orgId;
 
     try {
       // Initial Query Request
-      const preQueryResults = await this.runQueries(metadata.preQueries);
+      const limitedQueries = metadata.preQueries
+        ? metadata.preQueries?.map((query) => query + " limit 1")
+        : [];
+      const preQueryResults = metadata.preQueries
+        ? await this.runQueries(limitedQueries)
+        : [];
+      const columns = metadata.preQueries
+        ? preQueryResults.queryResults[0].fields.map((field: any) => {
+            return {
+              fieldType: PG_TYPES.find((type) => field.dataTypeID === type.oid)
+                ? PG_TYPES.find((type) => field.dataTypeID === type.oid)
+                    ?.typname
+                : field.dataTypeID,
+              name: field.name,
+              displayName: field.name,
+              isVisible: true,
+              field: field.name,
+            };
+          })
+        : metadata.columns;
       const response = await this.postQuill(metadata.task, {
         ...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) {
@@ -107,24 +138,25 @@ export default class QuillClass {
   ) {
     let results: any;
     if (!queries) return { ...results, queryResults: [] };
+    if (!queries) return { ...results, queryResults: [] };
     if (runQueryConfig?.arrayToMap) {
       const mappedArray = await mapQueries(
         queries,
         runQueryConfig.arrayToMap,
-        this.targetPool
+        this.targetConnection
       );
       return { ...results, queryResults: [], mappedArray };
     } else {
       const queryResults = await Promise.all(
         queries.map(async (query) => {
-          return await this.targetPool.query(query);
+          return await this.targetConnection.query(query);
         })
       );
       results = { ...results, queryResults };
       if (runQueryConfig?.getSchema) {
         results = {
           ...results,
-          columns: await getTableSchema(queryResults[0], this.targetPool),
+          columns: await getTableSchema(queryResults[0], this.targetConnection),
         };
       }
       if (runQueryConfig?.removeFields) {
@@ -150,7 +182,7 @@ export default class QuillClass {
   }
 
   public async close() {
-    await this.targetPool.close();
+    await this.targetConnection.close();
   }
 }
 
@@ -158,14 +190,33 @@ const Quill = ({
   privateKey,
   databaseConnectionString,
   cache,
+  databaseType,
+  metadataServerURL,
 }: {
   privateKey: string;
   databaseConnectionString: string;
   cache?: Partial<CacheCredentials>;
+  databaseType: DatabaseType;
+  metadataServerURL?: string;
 }) => {
-  return new QuillClass(privateKey, databaseConnectionString, cache);
+  return new QuillClass(
+    privateKey,
+    databaseConnectionString,
+    cache,
+    databaseType,
+    metadataServerURL
+  );
 };
 
 module.exports = Quill;
 module.exports.Quill = Quill;
 module.exports.default = Quill;
+module.exports.getTablesBySchemaByDatabase = getTablesBySchemaByDatabase;
+module.exports.getDatabaseCredentials = getDatabaseCredentials;
+module.exports.getColumnsByTableByDatabase = getColumnsByTableByDatabase;
+module.exports.getForiegnKeysByDatabase = getForiegnKeysByDatabase;
+module.exports.getSchemasByDatabase = getSchemasByDatabase;
+module.exports.getColumnInfoBySchemaByDatabase =
+  getColumnInfoBySchemaByDatabase;
+module.exports.connectToDatabase = connectToDatabase;
+module.exports.runQueryByDatabase = runQueryByDatabase;

package/src/index.uspec.ts

@@ -1,4 +1,5 @@
 import Quill from ".";
+import { DatabaseType } from "./db/DatabaseHelper";
 
 jest.mock(".");
 
@@ -6,8 +7,14 @@ describe("Quill", () => {
   let quill: Quill;
 
   beforeEach(() => {
-    quill = new Quill("dummy_private_key", "dummy_db_url");
-    quill.targetPool.query = jest.fn().mockResolvedValue([]);
+    quill = new Quill(
+      "dummy_private_key",
+      "dummy_db_url",
+      {},
+      DatabaseType.postgres,
+      undefined
+    );
+    quill.targetConnection.query = jest.fn().mockResolvedValue([]);
   });
 
   describe("query", () => {

package/src/models/Client.ts

@@ -0,0 +1,29 @@
+export interface Client {
+  name: string;
+  databaseConnectionString: string;
+  etlDatabaseConnectionString: string;
+  stagingDatabaseConnectionString: string;
+  customerTableTitleFieldName: string;
+  databaseType: string;
+  // foreign key
+  customerFieldName: string;
+  // native key, ex: uuid
+  customerTableFieldName: string;
+  // table with all customers, ex: company_company
+  customerTableName: string;
+  customerView: string;
+  // sql type. ex: INT
+  customerFieldType: string;
+  // does db use ssl
+  useSsl: boolean;
+  serverCa: string;
+  clientCert: string;
+  clientKey: string;
+  defaultQuery: string;
+  ignoreDarkMode: boolean;
+  domainName: string;
+  hideSqlEditor: boolean;
+  adminCustomerId: string;
+  stagingAdminCustomerId: string;
+  cacheCloudConfig: { type: { cacheQueries: boolean }; default: null };
+}

package/src/models/Quill.ts

@@ -1,4 +1,3 @@
-import { CachedPool } from "../db/CachedPools";
 import { CacheCredentials } from "./Cache";
 import { DatabaseCredentials } from "./Database";
 import { FieldFormat, FormattedColumn } from "./Formats";
@@ -34,11 +33,6 @@ export interface QuillQueryParams {
   environment?: string;
 }
 
-export interface QuillTaskHandlerParams extends QuillQueryParams {
-  privateKey: string;
-  targetPool: CachedPool;
-}
-
 export interface QuillConfig {
   privateKey: string;
   db: Partial<DatabaseCredentials>;

package/src/utils/RunQueryProcesses.ts

@@ -1,4 +1,4 @@
-import { CachedPool } from "../db/CachedPools";
+import { CachedConnection } from "../db/CachedConnection";
 
 interface TableSchemaInfo {
   fieldType: string;
@@ -9,9 +9,9 @@ interface TableSchemaInfo {
 
 export async function getTableSchema(
   queryResults: any,
-  targetPool: CachedPool
+  targetConnection: CachedConnection
 ) {
-  const typesQuery = await targetPool.query(
+  const typesQuery = await targetConnection.query(
     "select typname, oid, typarray from pg_type order by oid;"
   );
   const schema: TableSchemaInfo[] = queryResults[0].fields.map(
@@ -44,11 +44,11 @@ export function removeFields(queryResults: any, fieldsToRemove: string[]): any {
 export async function mapQueries(
   queries: string[],
   arrayToMap: { arrayName: string; field: string },
-  targetPool: CachedPool
+  targetConnection: CachedConnection
 ): Promise<any[]> {
   const mappedArray = [];
   for (let i = 0; i < queries.length; i++) {
-    const queryResult = await targetPool.query(queries[i]);
+    const queryResult = await targetConnection.query(queries[i]);
     mappedArray.push(queryResult.rows);
   }
   return mappedArray;

package/src/utils/textProcessing.ts

@@ -0,0 +1,13 @@
+export function capitalize(text: string): string {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+export function depluralize(text: string): string {
+  if (text.endsWith("ies")) {
+    return text.slice(0, -3) + "y";
+  }
+  if (text.endsWith("s")) {
+    return text.slice(0, -1);
+  }
+  return text;
+}