@quillsql/node 0.6.8 → 0.6.10

package/src/index.ts

@@ -1,392 +0,0 @@
-import { CacheCredentials } from "./models/Cache";
-import {
-  AdditionalProcessing,
-  QuillClientResponse,
-  QuillQueryParams,
-} from "./models/Quill";
-import { CachedConnection } from "./db/CachedConnection";
-import axios from "axios";
-import "dotenv/config";
-import { mapQueries, removeFields } from "./utils/RunQueryProcesses";
-import {
-  connectToDatabase,
-  connectAndRunQuery,
-  getColumnInfoBySchemaByDatabase,
-  getColumnsByTableByDatabase,
-  getDatabaseCredentials,
-  getForiegnKeysByDatabase,
-  getSchemasByDatabase,
-  getTablesBySchemaByDatabase,
-  runQueryByDatabase,
-  withConnection,
-} from "./db/DatabaseHelper";
-import { convertTypeToPostgres } from "./utils/schemaConversion";
-
-const HOST =
-  process.env.ENV === "development"
-    ? "http://localhost:8080"
-    : "https://quill-344421.uc.r.appspot.com";
-
-/**
- * Quill - Fullstack API Platform for Dashboards and Reporting.
- */
-
-export interface QuillQueryResult {
-  data?: any;
-  status: string;
-  error?: string;
-  queries?: { rows: any[]; fields: any[] };
-}
-
-export enum DatabaseType {
-  postgresql = "postgresql",
-  snowflake = "snowflake",
-  bigquery = "bigquery",
-  mysql = "mysql",
-}
-
-export class Quill implements AsyncDisposable {
-  // Configure cached connection pools with the given config.
-  private targetConnection;
-  private baseUrl: string;
-  private config: {
-    headers: {
-      Authorization: string;
-    };
-  };
-
-  constructor(data: {
-    privateKey: string;
-    databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-    databaseConnectionString?: string;
-    databaseConfig?: any;
-    cache?: Partial<CacheCredentials>;
-    metadataServerURL?: string;
-  }) {
-    const {
-      privateKey,
-      databaseType,
-      databaseConnectionString,
-      databaseConfig,
-      cache,
-      metadataServerURL,
-    } = data;
-    this.baseUrl = metadataServerURL ? metadataServerURL : HOST;
-    this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
-    let credentials = databaseConfig;
-    if (databaseConnectionString) {
-      credentials = getDatabaseCredentials(
-        databaseType,
-        databaseConnectionString,
-      );
-    }
-    this.targetConnection = new CachedConnection(
-      databaseType,
-      credentials,
-      cache || {},
-    );
-  }
-
-  public async query({
-    orgId,
-    metadata,
-    filters,
-  }: QuillQueryParams): Promise<QuillQueryResult> {
-    this.targetConnection.orgId = orgId;
-    let responseMetadata: any = {};
-
-    if (!metadata.task) {
-      return { error: "Missing task.", status: "error", data: {} };
-    }
-
-    try {
-      const preQueryResults = metadata.preQueries
-        ? await this.runQueries(
-            metadata.preQueries,
-            this.targetConnection.databaseType,
-            metadata.databaseType,
-            metadata.runQueryConfig,
-          )
-        : {};
-      if (metadata.runQueryConfig?.overridePost) {
-        return {
-          data: { queryResults: preQueryResults },
-          status: "success",
-        };
-      }
-      const response = await this.postQuill(metadata.task, {
-        ...metadata,
-        sdkFilters: filters,
-        ...preQueryResults,
-        orgId,
-        viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined,
-      });
-      if (response.error) {
-        return {
-          status: "error",
-          error: response.error,
-          data: response.metadata || {},
-        };
-      }
-      // if there is no metadata object in the response, create one
-      if (response.metadata) {
-        responseMetadata = response.metadata;
-      }
-      const results = await this.runQueries(
-        response.queries,
-        this.targetConnection.databaseType,
-        metadata.databaseType,
-        responseMetadata.runQueryConfig,
-      );
-      // QUICK JANKY FIX TO UPDATE METADATA AFTER GETTING MAPPED ARRAYS
-      if (results.mappedArray && responseMetadata.runQueryConfig?.arrayToMap) {
-        const arrayToMap = responseMetadata.runQueryConfig.arrayToMap;
-        results.mappedArray.forEach((array: any, index: number) => {
-          responseMetadata[arrayToMap.arrayName][index][arrayToMap.field] =
-            array;
-        });
-        delete results.mappedArray;
-      }
-      // if there is a single query array in queryResults and the rows and field objects to metadata
-      if (results?.queryResults.length === 1) {
-        const queryResults = results.queryResults[0];
-        if (queryResults.rows) {
-          responseMetadata.rows = queryResults.rows;
-        }
-        if (queryResults.fields) {
-          responseMetadata.fields = queryResults.fields;
-        }
-      }
-      return {
-        data: responseMetadata,
-        queries: results,
-        status: "success",
-      };
-    } catch (err) {
-      if (metadata.task === "update-view") {
-        this.postQuill("set-broken-view", {
-          table: metadata.name,
-          clientId: metadata.clientId,
-          error: (err as any).message,
-        });
-      }
-      return {
-        status: "error",
-        error: (err as any).message,
-        data: responseMetadata || {},
-      };
-    }
-  }
-
-  private async runQueries(
-    queries: any[] | undefined,
-    pkDatabaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-    databaseType?: string,
-    runQueryConfig?: AdditionalProcessing,
-  ) {
-    let results: any;
-    if (!queries) return { ...results, queryResults: [] };
-    if (
-      databaseType &&
-      databaseType.toLowerCase() !== pkDatabaseType.toLowerCase()
-    ) {
-      return {
-        dbMismatched: true,
-        backendDatabaseType: pkDatabaseType,
-        queryResults: [],
-      };
-    }
-
-    if (runQueryConfig?.arrayToMap) {
-      const mappedArray = await mapQueries(queries, this.targetConnection);
-      return { ...results, queryResults: [], mappedArray };
-    } else if (runQueryConfig?.getColumns) {
-      const queryResult = await this.targetConnection.query(
-        `${queries[0].replace(/;/, "")} limit 1000`,
-      );
-      const columns = queryResult.fields.map((field: any) => {
-        return {
-          fieldType: convertTypeToPostgres(field.dataTypeID),
-          name: field.name,
-          displayName: field.name,
-          isVisible: true,
-          field: field.name,
-        };
-      });
-      return { columns };
-    } else if (runQueryConfig?.getColumnsForSchema) {
-      const queryResults = await Promise.all(
-        queries.map(async (table) => {
-          if (
-            !table.viewQuery ||
-            (!table.isSelectStar && !table.customFieldInfo)
-          ) {
-            return table;
-          }
-          let limit = "";
-          if (runQueryConfig.limitBy) {
-            limit = ` limit ${runQueryConfig.limitBy}`;
-          }
-          try {
-            const queryResult = await this.targetConnection.query(
-              `${table.viewQuery.replace(/;/, "")} ${limit}`,
-            );
-            const columns = queryResult.fields.map((field: any) => {
-              return {
-                fieldType: convertTypeToPostgres(field.dataTypeID),
-                name: field.name,
-                displayName: field.name,
-                isVisible: true,
-                field: field.name,
-              };
-            });
-            return { ...table, columns: columns, rows: queryResult.rows };
-          } catch (err: any) {
-            return {
-              ...table,
-              error: err.message
-                ? `Error fetching columns: ${err.message}`
-                : "Error fetching columns",
-            };
-          }
-        }),
-      );
-      results = { ...results, queryResults };
-      if (runQueryConfig?.fieldsToRemove) {
-        results = {
-          ...results,
-          queryResults: queryResults.map((table: any) => {
-            const removedColumns = table.columns.filter((column: any) => {
-              return !runQueryConfig.fieldsToRemove?.includes(column.name);
-            });
-            return { ...table, columns: removedColumns };
-          }),
-        };
-      }
-    } else if (runQueryConfig?.getTables) {
-      const queryResult = await getTablesBySchemaByDatabase(
-        this.targetConnection.databaseType,
-        this.targetConnection.getPool(),
-        runQueryConfig.schemaNames! || runQueryConfig.schema,
-      );
-      const schemaInfo = await getColumnInfoBySchemaByDatabase(
-        this.targetConnection.databaseType,
-        this.targetConnection.getPool(),
-        runQueryConfig.schema!,
-        queryResult!,
-      );
-      return schemaInfo;
-    } else {
-      if (runQueryConfig?.limitThousand) {
-        queries = queries.map((query) => {
-          return query.replace(/;/, "") + " limit 1000;";
-        });
-      } else if (runQueryConfig?.limitBy) {
-        queries = queries.map((query) => {
-          return query.replace(/;/, "") + " limit " + runQueryConfig.limitBy;
-        });
-      }
-      const queryResults = await Promise.all(
-        queries.map(async (query) => {
-          return await this.targetConnection.query(query);
-        }),
-      );
-      results = { ...results, queryResults };
-      if (runQueryConfig?.fieldsToRemove) {
-        results = {
-          ...results,
-          queryResults: queryResults.map((queryResult) => {
-            return removeFields(queryResult, runQueryConfig.fieldsToRemove!);
-          }),
-        };
-      }
-      if (runQueryConfig?.convertDatatypes) {
-        results = queryResults.map((result) => {
-          return {
-            fields: result.fields.map((field: any) => {
-              return {
-                ...field,
-                fieldType: convertTypeToPostgres(field.dataTypeID),
-                isVisible: true,
-                field: field.name,
-                displayName: field.name,
-                name: field.name,
-              };
-            }),
-            rows: result.rows,
-          };
-        });
-      }
-    }
-    return results;
-  }
-
-  private async postQuill(
-    path: string,
-    payload: any,
-  ): Promise<QuillClientResponse> {
-    try {
-      const response = await axios.post(
-        `${this.baseUrl}/sdk/${path}`,
-        payload,
-        this.config,
-      );
-      return response.data;
-    } catch (e: any) {
-      return new Promise((_, reject) =>
-        reject({ message: e?.response?.data?.error || e.message || e }),
-      );
-    }
-  }
-
-  public async [Symbol.asyncDispose](): Promise<void> {
-    await this.close();
-  }
-
-  public async close() {
-    await this.targetConnection.close();
-  }
-}
-
-const requireQuill = ({
-  privateKey,
-  databaseConnectionString,
-  databaseConfig,
-  cache,
-  databaseType,
-  metadataServerURL,
-}: {
-  privateKey: string;
-  databaseConnectionString: string;
-  cache?: Partial<CacheCredentials>;
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-  databaseConfig: any;
-  metadataServerURL?: string;
-}) => {
-  return new Quill({
-    privateKey,
-    databaseType,
-    databaseConnectionString,
-    databaseConfig,
-    cache,
-    metadataServerURL,
-  });
-};
-
-module.exports = requireQuill;
-module.exports.default = requireQuill;
-module.exports.withConnection = withConnection;
-module.exports.connectToDatabase = connectToDatabase;
-module.exports.connectAndRunQuery = connectAndRunQuery;
-module.exports.Quill = 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.runQueryByDatabase = runQueryByDatabase;
-module.exports.DatabaseType = DatabaseType;
-
-export { QuillQueryParams as QuillRequest } from "./models/Quill";

package/src/models/Cache.ts

@@ -1,18 +0,0 @@
-export interface Mappable {
-  get(key: string): Promise<string | null>;
-  set(
-    key: string,
-    value: string,
-    type?: string,
-    ttl?: number,
-  ): Promise<string | null>;
-}
-
-export interface CacheCredentials {
-  username: string;
-  password: string;
-  host: string;
-  port: string;
-  cacheType: string;
-  ttl?: number;
-}

package/src/models/Client.ts

@@ -1,29 +0,0 @@
-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/Database.ts

@@ -1,5 +0,0 @@
-export interface DatabaseCredentials {
-  databaseConnectionString: string;
-  stagingDatabaseConnectionString: string;
-  databaseType: string;
-}

package/src/models/Formats.ts

@@ -1,19 +0,0 @@
-export type FieldFormat =
-  | "whole_number"
-  | "one_decimal_place"
-  | "two_decimal_places"
-  | "dollar_amount"
-  | "MMM_yyyy"
-  | "MMM_dd_yyyy"
-  | "MMM_dd-MMM_dd"
-  | "MMM_dd_hh:mm_ap_pm"
-  | "hh_ap_pm"
-  | "percent"
-  | "string";
-
-export interface FormattedColumn {
-  label: string;
-  field: string;
-  chartType: string;
-  format: FieldFormat;
-}

package/src/models/Quill.ts

@@ -1,82 +0,0 @@
-import { CacheCredentials } from "./Cache";
-import { DatabaseCredentials } from "./Database";
-import { FieldFormat, FormattedColumn } from "./Formats";
-
-export interface QuillRequestMetadata {
-  task: string;
-  // a query to be run
-  queries?: string[];
-  preQueries?: string[];
-  runQueryConfig?: AdditionalProcessing;
-  query?: string;
-  // a report to be fetched
-  id?: string;
-  filters?: any[];
-  // dashboard item fields
-  name?: string;
-  xAxisField?: string;
-  yAxisFields?: FormattedColumn[];
-  xAxisLabel?: string;
-  xAxisFormat?: FieldFormat;
-  yAxisLabel?: string;
-  chartType?: string;
-  dashboardName?: string;
-  columns?: FormattedColumn[];
-  dateField?: { table: string; field: string };
-  template?: boolean;
-  clientId?: string;
-  deleted?: boolean;
-  databaseType?: string;
-}
-
-export interface QuillQueryParams {
-  orgId: string;
-  metadata: QuillRequestMetadata;
-  environment?: string;
-  filters?: QuillFilter[];
-}
-
-export interface QuillFilter {
-  table: string;
-  field: string;
-  selectedValue: string;
-}
-
-export interface QuillConfig {
-  privateKey: string;
-  db: Partial<DatabaseCredentials>;
-  cache: Partial<CacheCredentials>;
-
-  /**
-   * @deprecated Use db credential object instead
-   */
-  databaseConnectionString?: string;
-
-  /**
-   * @deprecated Use db credential object instead
-   */
-  stagingDatabaseConnectionString?: string;
-}
-
-export interface AdditionalProcessing {
-  getSchema?: boolean;
-  getColumns?: boolean;
-  getColumnsForSchema?: boolean;
-  getTables?: boolean;
-  schema?: string;
-  schemaNames?: string[];
-  table?: string;
-  fieldsToRemove?: string[];
-  arrayToMap?: { arrayName: string; field: string };
-  overridePost?: boolean;
-  convertDatatypes?: boolean;
-  limitThousand?: boolean;
-  limitBy?: number;
-}
-
-export interface QuillClientResponse {
-  queries: string[];
-  metadata: any;
-  runQueryConfig: AdditionalProcessing;
-  error?: string;
-}

package/src/utils/Error.ts

@@ -1,35 +0,0 @@
-export class PgError extends Error {
-  code?: string;
-  detail?: string;
-  hint?: string;
-  position?: string;
-  // Add other properties if needed
-  constructor(
-    message: string,
-    detail?: string,
-    hint?: string,
-    position?: string,
-    code?: string,
-  ) {
-    super(message);
-    this.code = code;
-    this.detail = detail;
-    this.hint = hint;
-    this.position = position;
-  }
-}
-
-export function isSuperset(obj: any, baseClass: any): boolean {
-  // Get the property names of the base class instance
-  const baseInstance = new baseClass();
-  const baseProps = Object.keys(baseInstance);
-
-  // Check if the object has all the properties of the base class
-  for (const prop of baseProps) {
-    if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/utils/RunQueryProcesses.ts

@@ -1,33 +0,0 @@
-import { CachedConnection } from "../db/CachedConnection";
-
-export interface TableSchemaInfo {
-  fieldType: string;
-  name: string;
-  displayName: string;
-  isVisible: boolean;
-}
-
-export function removeFields(queryResults: any, fieldsToRemove: string[]): any {
-  const fields = queryResults.fields.filter(
-    (field: { name: any }) => !fieldsToRemove.includes(field.name),
-  );
-  const rows = queryResults.rows.map((row: any) => {
-    fieldsToRemove.forEach((field) => {
-      delete row[field];
-    });
-    return row;
-  });
-  return { fields, rows };
-}
-
-export async function mapQueries(
-  queries: string[],
-  targetConnection: CachedConnection,
-): Promise<any[]> {
-  const mappedArray = [];
-  for (let i = 0; i < queries.length; i++) {
-    const queryResult = await targetConnection.query(queries[i]);
-    mappedArray.push(queryResult.rows);
-  }
-  return mappedArray;
-}

package/src/utils/schemaConversion.ts

@@ -1,11 +0,0 @@
-import { PG_TYPES } from "../assets/pgtypes";
-
-export function convertTypeToPostgres(data_type_id: number): string {
-  const type = PG_TYPES.find((type) => data_type_id === type.oid)
-    ? PG_TYPES.find((type) => data_type_id === type.oid)?.typname
-    : undefined;
-  if (!type) {
-    return "varchar";
-  }
-  return type;
-}

package/src/utils/textProcessing.ts

@@ -1,13 +0,0 @@
-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;
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2016",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "**/*.spec.ts"]
-}