@quillsql/node 0.2.8 → 0.2.9

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Quill's client SDK for node backends.",
   "main": "dist/index.ts",
   "scripts": {