@quillsql/node 0.2.7 → 0.2.9

package/src/index.ispec.ts

@@ -0,0 +1,36 @@
+import Quill from ".";
+import "dotenv/config";
+
+const HOST =
+  process.env.ENV === "development"
+    ? "http://localhost:8080"
+    : "https://quill-344421.uc.r.appspot.com";
+
+describe("Quill", () => {
+  let quill: Quill;
+
+  beforeEach(() => {
+    quill = new Quill(
+      process.env.QUILL_PRIVATE_KEY as string,
+      process.env.DB_URL as string
+    );
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("query", () => {
+    it("org - should return ", async () => {
+      const metadata = {
+        task: "orgs",
+        clientId: "62cda15d7c9fcca7bc0a3689",
+      };
+      const result = await quill.query({
+        orgId: "2",
+        metadata,
+      });
+      // TODO - add assertions
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,144 @@
+import QuillServerClient from "./clients/QuillServerClient";
+import { CacheCredentials } from "./models/Cache";
+import {
+  AdditionalProcessing,
+  QuillClientResponse,
+  QuillQueryParams,
+} from "./models/Quill";
+import { CachedPool } from "./db/CachedPools";
+import axios from "axios";
+import "dotenv/config";
+import {
+  getTableSchema,
+  mapQueries,
+  removeFields,
+} from "./utils/RunQueryProcesses";
+
+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 default class Quill {
+  // Configure cached connection pools with the given config.
+  private connectionString;
+  private ssl = { rejectUnauthorized: false };
+  public targetPool;
+  private baseUrl: string;
+  private config: {
+    headers: {
+      Authorization: string;
+    };
+  };
+
+  constructor(
+    privateKey: string,
+    databaseConnectionString: string,
+    cache: Partial<CacheCredentials> = {}
+  ) {
+    this.baseUrl = HOST;
+    this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
+    this.connectionString = databaseConnectionString;
+    this.ssl = { rejectUnauthorized: false };
+    this.targetPool = new CachedPool(
+      { connectionString: this.connectionString, ssl: this.ssl },
+      cache
+    );
+  }
+
+  public async query({ orgId, metadata }: QuillQueryParams): Promise<any> {
+    this.targetPool.orgId = orgId;
+
+    try {
+      // Initial Query Request
+      const preQueryResults = await this.runQueries(metadata.preQueries);
+      const response = await this.postQuill(metadata.task, {
+        ...metadata,
+        orgId,
+        preQueryResults,
+      });
+      const results = await this.runQueries(
+        response.queries,
+        response.runQueryConfig
+      );
+      // if there is no metadata object in the response, create one
+      if (!response.metadata) {
+        response.metadata = {};
+      }
+      // 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) {
+          response.metadata.rows = queryResults.rows;
+        }
+        if (queryResults.fields) {
+          response.metadata.fields = queryResults.fields;
+        }
+      }
+      return {
+        data: response.metadata || null,
+        queries: results,
+        status: "success",
+      };
+    } catch (err) {
+      return { status: "error", error: (err as any).message };
+    }
+  }
+
+  private async runQueries(
+    queries: string[] | undefined,
+    runQueryConfig?: AdditionalProcessing
+  ) {
+    let results: any;
+    if (!queries) return { ...results, queryResults: [] };
+    if (runQueryConfig?.arrayToMap) {
+      return {
+        ...results,
+        mappedQueries: await mapQueries(
+          queries,
+          runQueryConfig.arrayToMap,
+          this.targetPool
+        ),
+      };
+    } else {
+      const queryResults = await Promise.all(
+        queries.map(async (query) => {
+          return await this.targetPool.query(query);
+        })
+      );
+      results = { ...results, queryResults };
+      if (runQueryConfig?.getSchema) {
+        results = {
+          ...results,
+          columns: await getTableSchema(queryResults[0], this.targetPool),
+        };
+      }
+      if (runQueryConfig?.removeFields) {
+        results = {
+          ...results,
+          queryResults: removeFields(queryResults, runQueryConfig.removeFields),
+        };
+      }
+    }
+    return results;
+  }
+
+  private async postQuill(
+    path: string,
+    payload: any
+  ): Promise<QuillClientResponse> {
+    const response = await axios.post(
+      `${this.baseUrl}/sdk/${path}`,
+      payload,
+      this.config
+    );
+    return response.data;
+  }
+
+  public async close() {
+    await this.targetPool.close();
+  }
+}

package/src/index.uspec.ts

@@ -0,0 +1,38 @@
+import Quill from ".";
+
+jest.mock(".");
+
+describe("Quill", () => {
+  let quill: Quill;
+
+  beforeEach(() => {
+    quill = new Quill("dummy_private_key", "dummy_db_url");
+    quill.targetPool.query = jest.fn().mockResolvedValue([]);
+  });
+
+  describe("query", () => {
+    it("return nothing when suppling no queries", () => {
+      const metadata = {
+        task: "test",
+        queries: [],
+      };
+      const result = quill.query({
+        orgId: "dummy",
+        metadata,
+      });
+      expect(result).resolves.toEqual([]);
+    });
+    it("returns an error for the improper query", () => {
+      const metadata = {
+        task: "test",
+        queries: ["SELECT * FROM test"],
+      };
+      const result = quill.query({
+        orgId: "dummy",
+        metadata,
+      });
+    });
+  });
+
+  // Add more test cases as needed
+});

package/src/models/Cache.ts

@@ -0,0 +1,18 @@
+export interface Mapable {
+  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/Database.ts

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

package/src/models/Formats.ts

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,68 @@
+import { CachedPool } from "../db/CachedPools";
+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[];
+  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;
+}
+
+export interface QuillQueryParams {
+  orgId: string;
+  metadata: QuillRequestMetadata;
+  environment?: string;
+}
+
+export interface QuillTaskHandlerParams extends QuillQueryParams {
+  privateKey: string;
+  targetPool: CachedPool;
+}
+
+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;
+  removeFields?: string[];
+  arrayToMap?: { arr: any; field: string };
+}
+
+export interface QuillClientResponse {
+  queries: string[];
+  metadata: any;
+  runQueryConfig: AdditionalProcessing;
+}

package/src/utils/Error.ts

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

package/src/utils/RunQueryProcesses.ts

@@ -0,0 +1,58 @@
+import { CachedPool } from "../db/CachedPools";
+
+interface TableSchemaInfo {
+  fieldType: string;
+  name: string;
+  displayName: string;
+  isVisible: boolean;
+}
+
+export async function getTableSchema(
+  queryResults: any,
+  targetPool: CachedPool
+) {
+  const typesQuery = await targetPool.query(
+    "select typname, oid, typarray from pg_type order by oid;"
+  );
+  const schema: TableSchemaInfo[] = queryResults[0].fields.map(
+    (field: { dataTypeID: any; name: any }) => {
+      return {
+        fieldType: typesQuery.rows.filter(
+          (type: { oid: any }) => field.dataTypeID === type.oid
+        )[0].typname,
+        name: field.name,
+        displayName: field.name,
+        isVisible: true,
+      };
+    }
+  );
+  return schema;
+}
+
+export function removeFields(queryResults: any, fieldsToRemove: string[]): any {
+  const fields = queryResults.fields.filter((field: { name: any }) =>
+    fieldsToRemove.includes(field.name)
+  );
+  const rows = queryResults.map((row: any) => {
+    fieldsToRemove.forEach((field) => {
+      delete row[field];
+    });
+    return { fields, rows };
+  });
+}
+
+export async function mapQueries(
+  queries: string[],
+  arrayToMap: { arr: any; field: string },
+  targetPool: CachedPool
+) {
+  let arrayToMapResult = [];
+  for (let i = 0; i < queries.length; i++) {
+    const queryResult = await targetPool.query(queries[i]);
+    arrayToMapResult.push({
+      ...arrayToMap.arr[i],
+      [arrayToMap.field]: queryResult.rows,
+    });
+  }
+  return arrayToMapResult;
+}

package/tsconfig.json

@@ -1,109 +1,14 @@
 {
   "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-    /* Language and Environment */
-    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
-    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
-    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
-    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
-    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
-    /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
-    /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
+    "target": "es2016",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "**/*.spec.ts"]
 }

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 stryvedev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.