@quillsql/node 0.2.7 → 0.2.9

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/dist/clients/QuillServerClient.js

@@ -0,0 +1,28 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+/** This client is currently not used but is a good design pratice */
+class QuillServerClient {
+    constructor(privateKey) {
+        this.baseUrl = "";
+        this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
+    }
+    postQuill(route, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return axios_1.default.post(`${this.baseUrl}/${route}`, payload, this.config);
+        });
+    }
+}
+exports.default = QuillServerClient;

package/dist/db/CachedPools.js

@@ -0,0 +1,91 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedPool = void 0;
+const pg_1 = require("pg");
+const redis_1 = require("redis");
+const Error_1 = require("../utils/Error");
+class PgError extends Error {
+    // Add other properties if needed
+    constructor(detail, hint, position) {
+        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;
+class CachedPool {
+    constructor(config, cacheConfig = {}) {
+        var _a;
+        this.pool = new pg_1.Pool(config);
+        this.ttl = (_a = cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.ttl) !== null && _a !== void 0 ? _a : DEFAULT_CACHE_TTL;
+        this.cache = this.getCache(cacheConfig);
+    }
+    query(text, values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.cache) {
+                    const results = yield this.pool.query(text, values);
+                    return {
+                        fields: results.fields.map((field) => ({
+                            name: field.name,
+                            dataTypeID: field.dataTypeID,
+                        })),
+                        rows: results.rows,
+                    };
+                }
+                const key = `${this.orgId}:${text}`;
+                const cachedResult = yield this.cache.get(key);
+                if (cachedResult) {
+                    return JSON.parse(cachedResult);
+                }
+                else {
+                    const newResult = yield this.pool.query(text, values);
+                    const newResultString = JSON.stringify(newResult);
+                    yield this.cache.set(key, newResultString, "EX", DEFAULT_CACHE_TTL);
+                    return {
+                        fields: newResult.fields.map((field) => ({
+                            name: field.name,
+                            dataTypeID: field.dataTypeID,
+                        })),
+                        rows: newResult.rows,
+                    };
+                }
+            }
+            catch (err) {
+                if ((0, Error_1.isSuperset)(err, PgError)) {
+                    throw new PgError(err.detail, err.hint, err.position);
+                }
+                else if (err instanceof Error) {
+                    throw new Error(err.message);
+                }
+            }
+        });
+    }
+    /**
+     * Configures and returns a cache instance or null if none could be created.
+     */
+    getCache({ username, password, host, port, cacheType, }) {
+        if (cacheType === "redis" || cacheType === "rediss") {
+            const redisURL = `${cacheType}://${username}:${password}@${host}:${port}`;
+            return (0, redis_1.createClient)({ url: redisURL });
+        }
+        return null;
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pool.end();
+        });
+    }
+}
+exports.CachedPool = CachedPool;

package/dist/index.ispec.js

@@ -0,0 +1,41 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("."));
+require("dotenv/config");
+const HOST = process.env.ENV === "development"
+    ? "http://localhost:8080"
+    : "https://quill-344421.uc.r.appspot.com";
+describe("Quill", () => {
+    let quill;
+    beforeEach(() => {
+        quill = new _1.default(process.env.QUILL_PRIVATE_KEY, process.env.DB_URL);
+    });
+    afterAll(() => {
+        jest.restoreAllMocks();
+    });
+    describe("query", () => {
+        it("org - should return ", () => __awaiter(void 0, void 0, void 0, function* () {
+            const metadata = {
+                task: "orgs",
+                clientId: "62cda15d7c9fcca7bc0a3689",
+            };
+            const result = yield quill.query({
+                orgId: "2",
+                metadata,
+            });
+            // TODO - add assertions
+        }));
+    });
+});

package/dist/index.js

@@ -0,0 +1,103 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CachedPools_1 = require("./db/CachedPools");
+const axios_1 = __importDefault(require("axios"));
+require("dotenv/config");
+const RunQueryProcesses_1 = require("./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.
+ */
+class Quill {
+    constructor(privateKey, databaseConnectionString, cache = {}) {
+        this.ssl = { rejectUnauthorized: false };
+        this.baseUrl = HOST;
+        this.config = { headers: { Authorization: `Bearer ${privateKey}` } };
+        this.connectionString = databaseConnectionString;
+        this.ssl = { rejectUnauthorized: false };
+        this.targetPool = new CachedPools_1.CachedPool({ connectionString: this.connectionString, ssl: this.ssl }, cache);
+    }
+    query({ orgId, metadata }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.targetPool.orgId = orgId;
+            try {
+                // Initial Query Request
+                const preQueryResults = yield this.runQueries(metadata.preQueries);
+                const response = yield this.postQuill(metadata.task, Object.assign(Object.assign({}, metadata), { orgId,
+                    preQueryResults }));
+                const results = yield 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 === null || results === void 0 ? void 0 : 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.message };
+            }
+        });
+    }
+    runQueries(queries, runQueryConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let results;
+            if (!queries)
+                return Object.assign(Object.assign({}, results), { queryResults: [] });
+            if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.arrayToMap) {
+                return Object.assign(Object.assign({}, results), { mappedQueries: yield (0, RunQueryProcesses_1.mapQueries)(queries, runQueryConfig.arrayToMap, this.targetPool) });
+            }
+            else {
+                const queryResults = yield Promise.all(queries.map((query) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.targetPool.query(query);
+                })));
+                results = Object.assign(Object.assign({}, results), { queryResults });
+                if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getSchema) {
+                    results = Object.assign(Object.assign({}, results), { columns: yield (0, RunQueryProcesses_1.getTableSchema)(queryResults[0], this.targetPool) });
+                }
+                if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.removeFields) {
+                    results = Object.assign(Object.assign({}, results), { queryResults: (0, RunQueryProcesses_1.removeFields)(queryResults, runQueryConfig.removeFields) });
+                }
+            }
+            return results;
+        });
+    }
+    postQuill(path, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${this.baseUrl}/sdk/${path}`, payload, this.config);
+            return response.data;
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.targetPool.close();
+        });
+    }
+}
+exports.default = Quill;

package/dist/index.uspec.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("."));
+jest.mock(".");
+describe("Quill", () => {
+    let quill;
+    beforeEach(() => {
+        quill = new _1.default("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/dist/models/Cache.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Database.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Formats.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Quill.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/Error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSuperset = exports.PgError = void 0;
+class PgError extends Error {
+}
+exports.PgError = PgError;
+function isSuperset(obj, baseClass) {
+    // 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;
+}
+exports.isSuperset = isSuperset;

package/dist/utils/RunQueryProcesses.js

@@ -0,0 +1,48 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapQueries = exports.removeFields = exports.getTableSchema = void 0;
+function getTableSchema(queryResults, targetPool) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const typesQuery = yield targetPool.query("select typname, oid, typarray from pg_type order by oid;");
+        const schema = queryResults[0].fields.map((field) => {
+            return {
+                fieldType: typesQuery.rows.filter((type) => field.dataTypeID === type.oid)[0].typname,
+                name: field.name,
+                displayName: field.name,
+                isVisible: true,
+            };
+        });
+        return schema;
+    });
+}
+exports.getTableSchema = getTableSchema;
+function removeFields(queryResults, fieldsToRemove) {
+    const fields = queryResults.fields.filter((field) => fieldsToRemove.includes(field.name));
+    const rows = queryResults.map((row) => {
+        fieldsToRemove.forEach((field) => {
+            delete row[field];
+        });
+        return { fields, rows };
+    });
+}
+exports.removeFields = removeFields;
+function mapQueries(queries, arrayToMap, targetPool) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let arrayToMapResult = [];
+        for (let i = 0; i < queries.length; i++) {
+            const queryResult = yield targetPool.query(queries[i]);
+            arrayToMapResult.push(Object.assign(Object.assign({}, arrayToMap.arr[i]), { [arrayToMap.field]: queryResult.rows }));
+        }
+        return arrayToMapResult;
+    });
+}
+exports.mapQueries = mapQueries;

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.7",
-  "description": "Quill SDK for Node.js",
-  "main": "dist/index.js",
+  "version": "0.2.9",
+  "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();
+  }
+}