@quillsql/node 0.2.6 → 0.2.8

package/README.md

@@ -0,0 +1,55 @@
+# Quill Node SDK
+
+## Installation
+
+```shell
+$ npm install @quillsql/node
+
+# Or, if you prefer yarn
+$ yarn add @quillsql/node
+```
+
+## Usage
+
+Instantiate quill with your credentials and add the below POST endpoint.
+
+Note that we assume you have an organization id on the user returned by your auth middleware. Queries will not work properly without the organization id.
+
+```js
+const quill = require("@quillsql/node")({
+  privateKey: process.env.QULL_PRIVATE_KEY,
+  databaseConnectionString: process.env.POSTGRES_READ,
+});
+
+// "authenticateJWT" is your own pre-existing auth middleware
+app.post("/quill", authenticateJWT, async (req, res) => {
+  // assuming user fetched via auth middleware has an organizationId
+  const { organizationId } = req.user;
+  const { metadata } = req.body;
+  const result = await quill.query({
+    orgId: organizationId,
+    metadata,
+  });
+  res.send(result);
+});
+```
+
+## For local testing (dev purposes only)
+
+Create an .env file with the following key-value pairs:
+
+```
+QUILL_PRIVATE_KEY=
+DB_URL=
+ENV=development
+BACKEND_URL=
+```
+
+Use the following commands to start a locally hosted dev server.
+
+```
+npm install
+npm run dev-server
+```
+
+You should be able to ping your local server at `http://localhost:3000`.

package/examples/node-server/app.ts

@@ -0,0 +1,35 @@
+// Write a simple node server to test the SDK
+
+import express from "express";
+import Quill from "../../src/index";
+import cors from "cors";
+
+const app = express();
+const port = 3000;
+
+const quill = new Quill(
+  process.env.QUILL_PRIVATE_KEY as string,
+  process.env.DB_URL as string,
+  {}
+);
+
+app.use(cors());
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+app.post("/quill", async (req, res) => {
+  const organizationId = req.body.orgId;
+  const { metadata } = req.body;
+  const result = await quill.query({
+    orgId: organizationId,
+    metadata,
+  });
+  res.send(result);
+});
+
+app.listen(port, () => {
+  console.log(`Example app listening at http://localhost:${port}`);
+});

package/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  "browser": false,
+  "automock": false,
+  "testEnvironment": "node",
+  "collectCoverage": false,
+  "transform": {
+    ".(ts|tsx)": "ts-jest"
+  },
+  "transformIgnorePatterns": ['^.+\\.(js|json)$'],
+  "testRegex": "(/__tests__/.*|src.*?\\.(ispec|uspec))\\.(ts)$",
+  "testPathIgnorePatterns": [
+    "//node_modules/"
+  ],
+  "moduleFileExtensions": [
+    "ts",
+    "js",
+    "json"
+  ]
+};

package/package.json

@@ -1,23 +1,34 @@
 {
   "name": "@quillsql/node",
-  "version": "0.2.6",
-  "description": "Quill SDK for Node.js",
-  "main": "dist/index.js",
+  "version": "0.2.8",
+  "description": "Quill's client SDK for node backends.",
+  "main": "dist/index.ts",
   "scripts": {
-    "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc --outDir dist",
+    "start:dev": "nodemon ./examples/node-server/app.ts",
+    "integration-tests": "jest '.*\\.ispec\\.ts$'",
+    "test": "tsc src && jest --detectOpenHandles"
+  },
+  "author": "lagambino",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.7",
+    "@types/pg": "^8.10.9",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "jest": "^29.7.0",
+    "nodemon": "^3.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
   },
-  "author": "Quill",
-  "license": "MIT",
   "dependencies": {
-    "axios": "^0.21.4",
+    "axios": "^1.6.5",
     "dotenv": "^16.3.1",
-    "pg": "^8.11.1",
-    "pg-error": "^1.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.4.2",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.1.6"
+    "pg": "^8.11.3",
+    "redis": "^4.6.12",
+    "ts-jest": "^29.1.1"
   }
 }

package/src/clients/QuillServerClient.ts

@@ -0,0 +1,23 @@
+import axios from "axios";
+
+/** This client is currently not used but is a good design pratice */
+
+class QuillServerClient {
+  private baseUrl: string;
+  private config: {
+    headers: {
+      Authorization: string;
+    };
+  };
+
+  constructor(privateKey: string) {
+    this.baseUrl = "";
+    this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
+  }
+
+  public async postQuill(route: string, payload: any): Promise<any> {
+    return axios.post(`${this.baseUrl}/${route}`, payload, this.config);
+  }
+}
+
+export default QuillServerClient;

package/src/db/CachedPools.ts

@@ -0,0 +1,97 @@
+import { Pool } from "pg";
+import { Mapable, CacheCredentials } from "../models/Cache";
+import { QuillConfig } from "../models/Quill";
+import { createClient } from "redis";
+import { isSuperset } from "../utils/Error";
+
+class PgError extends Error {
+  code?: string;
+  detail?: string;
+  hint?: string;
+  position?: string;
+  // Add other properties if needed
+  constructor(detail?: string, hint?: string, position?: string) {
+    super();
+    this.detail = detail;
+    this.hint = hint;
+    this.position = position;
+  }
+}
+
+/** The TTL for new cache entries (default: 1h) */
+const DEFAULT_CACHE_TTL = 24 * 60 * 60;
+
+export class CachedPool {
+  public pool: Pool;
+  public orgId: any;
+  public ttl: number;
+  public cache: Mapable | null;
+
+  constructor(config: any, cacheConfig: Partial<CacheCredentials> = {}) {
+    this.pool = new Pool(config);
+    this.ttl = cacheConfig?.ttl ?? DEFAULT_CACHE_TTL;
+    this.cache = this.getCache(cacheConfig);
+  }
+
+  public async query(text: string, values?: any[]): Promise<any> {
+    try {
+      if (!this.cache) {
+        const results = await this.pool.query(text, values);
+        return {
+          fields: results.fields.map((field: any) => ({
+            name: field.name,
+            dataTypeID: field.dataTypeID,
+          })),
+          rows: results.rows,
+        };
+      }
+      const key: string = `${this.orgId}:${text}`;
+      const cachedResult: string | null = await this.cache.get(key);
+      if (cachedResult) {
+        return JSON.parse(cachedResult);
+      } else {
+        const newResult: any = await this.pool.query(text, values);
+        const newResultString: string = JSON.stringify(newResult);
+        await this.cache.set(key, newResultString, "EX", DEFAULT_CACHE_TTL);
+        return {
+          fields: newResult.fields.map((field: any) => ({
+            name: field.name,
+            dataTypeID: field.dataTypeID,
+          })),
+          rows: newResult.rows,
+        };
+      }
+    } catch (err) {
+      if (isSuperset(err, PgError)) {
+        throw new PgError(
+          (err as any).detail,
+          (err as any).hint,
+          (err as any).position
+        );
+      } else if (err instanceof Error) {
+        throw new Error(err.message);
+      }
+    }
+  }
+
+  /**
+   * Configures and returns a cache instance or null if none could be created.
+   */
+  private getCache({
+    username,
+    password,
+    host,
+    port,
+    cacheType,
+  }: QuillConfig["cache"]): Mapable | null {
+    if (cacheType === "redis" || cacheType === "rediss") {
+      const redisURL = `${cacheType}://${username}:${password}@${host}:${port}`;
+      return createClient({ url: redisURL }) as Mapable;
+    }
+    return null;
+  }
+
+  async close() {
+    await this.pool.end();
+  }
+}

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.

package/index.js

@@ -1,172 +0,0 @@
-"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());
-    });
-};
-const { Pool, Connection } = require("pg");
-const axios = require("axios");
-var PgError = require("pg-error");
-Connection.prototype.parseE = PgError.parse;
-Connection.prototype.parseN = PgError.parse;
-const cache = {}; //set the cache
-function setCache(key, value) {
-    cache[key] = value;
-}
-function getCache(key) {
-    return cache[key];
-}
-module.exports = ({ privateKey, databaseConnectionString, stagingDatabaseConnectionString, }) => {
-    const pool = new Pool({
-        connectionString: databaseConnectionString,
-        ssl: { rejectUnauthorized: false }
-    });
-    const stagingPool = new Pool({
-        connectionString: stagingDatabaseConnectionString,
-    });
-    return {
-        query: ({ orgId, metadata, environment }) => __awaiter(void 0, void 0, void 0, function* () {
-            const targetPool = environment === "STAGING" ? stagingPool : pool;
-            const { task, query, id } = metadata;
-            if (task === "query") {
-                try {
-                    const response = yield axios.post("https://quill-344421.uc.r.appspot.com/validate", { query: query }, {
-                        params: {
-                            orgId,
-                        },
-                        headers: {
-                            Authorization: `Bearer ${privateKey}`,
-                        },
-                    });
-                    const { fieldToRemove } = response.data;
-                    const queryResult = yield targetPool.query(response.data.query);
-                    return Object.assign(Object.assign({}, queryResult), { fields: queryResult.fields.filter(
-                        // @ts-ignore
-                        (field) => field.name !== fieldToRemove), 
-                        // @ts-ignore
-                        rows: queryResult.rows.map((row) => {
-                            delete row[fieldToRemove];
-                            return row;
-                        }) });
-                }
-                catch (err) {
-                    return Object.assign(Object.assign({}, err), { 
-                        // @ts-ignore
-                        errorMessage: err && err.message ? err.message : "" });
-                }
-            }
-            if (task === "config") {
-                try {
-                    const response = yield axios.get("https://quill-344421.uc.r.appspot.com/config", {
-                        params: {
-                            orgId,
-                            // @ts-ignore
-                            name: metadata === null || metadata === void 0 ? void 0 : metadata.name,
-                        },
-                        headers: {
-                            Authorization: `Bearer ${privateKey}`,
-                        },
-                    });
-                    let dashConfig = response.data;
-                    let newFilters = [];
-                    if (dashConfig.filters && dashConfig.filters.length) {
-                        for (let i = 0; i < dashConfig.filters.length; i++) {
-                            const queryResult = yield targetPool.query(dashConfig.filters[i].query);
-                            const { rows } = queryResult;
-                            newFilters.push(Object.assign(Object.assign({}, dashConfig.filters[i]), { options: rows }));
-                            dashConfig.filters[i].options = rows;
-                        }
-                    }
-                    dashConfig = Object.assign(Object.assign({}, dashConfig), { filters: newFilters });
-                    const { fieldToRemove, newQueries } = response.data;
-                    if (newQueries) {
-                        for (const newQuery of newQueries) {
-                            const { query } = newQuery;
-                            const cacheKey = `config:${orgId}:${newQuery._id}}`;
-                            setCache(cacheKey, { fieldToRemove, query });
-                        }
-                        ;
-                    }
-                    return Object.assign({}, dashConfig);
-                }
-                catch (_a) {
-                    return Object.assign(Object.assign({}, err), { 
-                        // @ts-ignore
-                        errorMessage: err && err.message ? err.message : "" });
-                }
-            }
-            if (task === "create") {
-                try {
-                    const response = yield axios.post("https://quill-344421.uc.r.appspot.com/item", Object.assign({}, metadata), {
-                        params: {
-                            orgId,
-                            query
-                        },
-                        headers: {
-                            Authorization: `Bearer ${privateKey}`,
-                        },
-                    });
-                    return response.data;
-                }
-                catch (_b) {
-                    return Object.assign(Object.assign({}, err), { 
-                        // @ts-ignore
-                        errorMessage: err && err.message ? err.message : "" });
-                }
-            }
-            if (task === "item") {
-                try {
-                    const { filters } = metadata;
-                    const resp = yield axios.get("https://quill-344421.uc.r.appspot.com/selfhostitem", {
-                        params: {
-                            id,
-                            orgId,
-                        },
-                        headers: {
-                            Authorization: `Bearer ${privateKey}`,
-                        },
-                    });
-                    let fieldToRemove, query;
-                    if (false && getCache(`config:${orgId}:${id}:${JSON.stringify(filters)}`)) {
-                        ({ fieldToRemove, query } = getCache(`config:${orgId}:${id}:${JSON.stringify(filters)}`));
-                    }
-                    else {
-                        const response = yield axios.post("https://quill-344421.uc.r.appspot.com/validate", {
-                            dashboardItemId: id,
-                            query: resp.data.queryString,
-                            filters: filters,
-                            orgId: orgId
-                        }, {
-                            headers: {
-                                Authorization: `Bearer ${privateKey}`
-                            }
-                        });
-                        ({ fieldToRemove, query } = response.data);
-                        const cacheKey = `config:${orgId}:${id}:${JSON.stringify(filters)}`;
-                        setCache(cacheKey, { fieldToRemove, query });
-                    }
-                    ;
-                    const queryResult = yield targetPool.query(query);
-                    return Object.assign(Object.assign({}, resp.data), { fields: queryResult.fields
-                            .filter(
-                        // @ts-ignore
-                        (field) => field.name !== fieldToRemove), 
-                        // @ts-ignore
-                        rows: queryResult.rows.map((row) => {
-                            delete row[fieldToRemove];
-                            return row;
-                        }) });
-                }
-                catch (err) {
-                    return Object.assign(Object.assign({}, err), { 
-                        // @ts-ignore
-                        errorMessage: err && err.message ? err.message : "" });
-                }
-            }
-        }),
-    };
-};

package/index.ts

@@ -1,278 +0,0 @@
-const { Pool, Connection } = require("pg");
-const axios = require("axios");
-var PgError = require("pg-error");
-Connection.prototype.parseE = PgError.parse;
-Connection.prototype.parseN = PgError.parse;
-
-const cache : any = {}; //set the cache
-
-function setCache(key : any, value : any) {
-  cache[key] = value;
-}
-
-function getCache(key : any) {
-  return cache[key];
-}
-
-interface QuillConfig {
-  privateKey: string;
-  databaseConnectionString: string;
-  stagingDatabaseConnectionString?: string;
-}
-
-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";
-interface FormattedColumn {
-  label: string;
-  field: string;
-  chartType: string;
-  format: FieldFormat;
-}
-interface QuillRequestMetadata {
-  task: string;
-  // a query to be run
-  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;
-}
-interface QuillQueryParams {
-  orgId: string;
-  metadata: QuillRequestMetadata;
-  environment?: string;
-}
-module.exports = ({
-  privateKey,
-  databaseConnectionString,
-  stagingDatabaseConnectionString,
-}: QuillConfig) => {
-  const pool = new Pool({
-    connectionString: databaseConnectionString,
-    ssl: {rejectUnauthorized: false}
-  });
-  const stagingPool = new Pool({
-    connectionString: stagingDatabaseConnectionString,
-  });
-  return {
-    query: async ({ orgId, metadata, environment }: QuillQueryParams) => {
-      const targetPool = environment === "STAGING" ? stagingPool : pool;
-      const { task, query, id } = metadata;
-
-      if (task === "query") {
-        try {
-        const response = await axios.post(
-          "https://quill-344421.uc.r.appspot.com/validate",
-          { query: query },
-          {
-            params: {
-              orgId,
-            },
-            headers: {
-              Authorization: `Bearer ${privateKey}`,
-            },
-          } 
-        );
-        const { fieldToRemove } = response.data;
-          const queryResult = await targetPool.query(response.data.query);
-          return {
-            ...queryResult,
-            fields: queryResult.fields.filter(
-              // @ts-ignore
-              (field) => field.name !== fieldToRemove
-            ),
-            // @ts-ignore
-            rows: queryResult.rows.map((row) => {
-              delete row[fieldToRemove];
-              return row;
-            }),
-          };
-        } catch (err) {
-          return {
-            // @ts-ignore
-            ...err,
-            // @ts-ignore
-            errorMessage: err && err.message ? err.message : "",
-          };
-        }
-      }
-      if (task === "config") {
-        try {
-        const response = await axios.get(
-          "https://quill-344421.uc.r.appspot.com/config",
-          {
-            params: {
-              orgId,
-              // @ts-ignore
-              name: metadata?.name,
-            },
-            headers: {
-              Authorization: `Bearer ${privateKey}`,
-            },
-          }
-        );
-        let dashConfig = response.data;
-        let newFilters = [];
-        
-       
-        if (dashConfig.filters && dashConfig.filters.length) {
-          for (let i = 0; i < dashConfig.filters.length; i++) {
-            const queryResult = await targetPool.query(
-              dashConfig.filters[i].query
-            );
-            const { rows } = queryResult;
-            newFilters.push({ ...dashConfig.filters[i], options: rows });
-            dashConfig.filters[i].options = rows
-          }
-          
-        }
-
-        dashConfig = { ...dashConfig, filters: newFilters };
-
-        const { fieldToRemove, newQueries } = response.data;
-        
-        if (newQueries) {
-        for (const newQuery of newQueries) { 
-          const { query } = newQuery
-          const cacheKey = `config:${orgId}:${newQuery._id}}`;
-          setCache(cacheKey, {fieldToRemove, query});
-        };
-        }
-    
-        return {
-            ...dashConfig
-          };
-
-        }
-         catch {
-        return {
-          // @ts-ignore
-          ...err,
-          // @ts-ignore
-          errorMessage: err && err.message ? err.message : "",
-        };
-      }
-    }
-      
-      if (task === "create") {
-        try {
-        const response = await axios.post(
-          "https://quill-344421.uc.r.appspot.com/item",
-          { ...metadata },
-          {
-            params: {
-              orgId,
-              query
-            },
-            headers: {
-              Authorization: `Bearer ${privateKey}`,
-            },
-          }
-        );
-        return response.data;
-      }
-      catch {
-        return {
-          // @ts-ignore
-          ...err,
-          // @ts-ignore
-          errorMessage: err && err.message ? err.message : "",
-        };
-      }
-    }
-
-      if (task === "item") {
-        try {
-
-          const {filters } = metadata;
-          const resp = await axios.get(
-            "https://quill-344421.uc.r.appspot.com/selfhostitem",
-            {
-              params: {
-                id,
-                orgId,
-              },
-              headers: {
-                Authorization: `Bearer ${privateKey}`,
-              },
-            }
-          );
-          let fieldToRemove : any, query;
-
-
-          if (false && getCache(`config:${orgId}:${id}:${JSON.stringify(filters)}`)) {             
-            ({fieldToRemove, query} = getCache(`config:${orgId}:${id}:${JSON.stringify(filters)}`)); 
-          }
-          else {
-            const response = await axios.post(
-              "https://quill-344421.uc.r.appspot.com/validate",
-              { 
-                dashboardItemId: id,
-                query: resp.data.queryString,
-                filters: filters,
-                orgId: orgId
-              },
-              {
-                headers: {
-                  Authorization: `Bearer ${privateKey}`
-                }
-              }
-            );
-
-            
-
-          ({ fieldToRemove, query } = response.data);
-
-            const cacheKey = `config:${orgId}:${id}:${JSON.stringify(filters)}`; 
-            setCache(cacheKey, {fieldToRemove, query});
-          };
-          
-          const queryResult = await targetPool.query(query);
-         
-          return {
-            ...resp.data,
-            fields: queryResult.fields
-            .filter(
-              // @ts-ignore
-              (field) => field.name !== fieldToRemove
-            ),
-            // @ts-ignore
-            rows: queryResult.rows.map((row) => {
-              delete row[fieldToRemove];
-              return row;
-            }),
-          };
-
-        } catch (err) {
-          return {
-            // @ts-ignore
-            ...err,
-            // @ts-ignore
-            errorMessage: err && err.message ? err.message : "",
-          };
-        }
-      }
-    },
-  };
-};