blixify-server 0.1.68 → 0.1.69

package/dist/apis/crypto.d.ts

@@ -0,0 +1,9 @@
+export declare class CryptoMiddleware {
+    secretKey: string;
+    forceDecryption: boolean;
+    constructor(secretKey: string, forceDecryption: boolean);
+    handleEncryption: (data: any) => any;
+    handleDecryption: (data: string) => any;
+    init(): (req: any, res: any, next?: any) => Promise<any>;
+}
+//# sourceMappingURL=crypto.d.ts.map

package/dist/apis/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/apis/crypto.ts"],"names":[],"mappings":"AAEA,qBAAa,gBAAgB;IAC3B,SAAS,SAAM;IACf,eAAe,UAAS;gBAEZ,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO;IAKvD,gBAAgB,SAAU,GAAG,SAS3B;IAEF,gBAAgB,SAAU,MAAM,SAO9B;IAEF,IAAI,UAG4C,GAAG,OAAO,GAAG,SAAS,GAAG;CAW1E"}

package/dist/apis/crypto.js

@@ -0,0 +1,56 @@
+"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.CryptoMiddleware = void 0;
+const CryptoJS = require("crypto-js");
+class CryptoMiddleware {
+    constructor(secretKey, forceDecryption) {
+        this.secretKey = "";
+        this.forceDecryption = false;
+        this.handleEncryption = (data) => {
+            try {
+                // Encrypt the data
+                const encrypted = CryptoJS.AES.encrypt(JSON.stringify(data), this.secretKey).toString();
+                return encrypted;
+            }
+            catch (err) { }
+        };
+        this.handleDecryption = (data) => {
+            try {
+                // Decrypt the data
+                const bytes = CryptoJS.AES.decrypt(data, this.secretKey);
+                const decrypted = JSON.parse(bytes.toString(CryptoJS.enc.Utf8));
+                return decrypted;
+            }
+            catch (err) { }
+        };
+        this.secretKey = secretKey;
+        this.forceDecryption = forceDecryption;
+    }
+    init() {
+        // eslint-disable-next-line
+        const wrapper = this;
+        const cryptoMiddleware = function (req, res, next) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (wrapper.forceDecryption && !req.body.sign)
+                    return res.status(400).json({ error: "Missing signature for signing" });
+                if ((_a = req.body) === null || _a === void 0 ? void 0 : _a.sign)
+                    req.body = wrapper.handleDecryption(req.body.sign);
+                if (next) {
+                    next();
+                }
+            });
+        };
+        return cryptoMiddleware;
+    }
+}
+exports.CryptoMiddleware = CryptoMiddleware;

package/dist/apis/postgresqlWrapper.d.ts

@@ -0,0 +1,35 @@
+import SecurityConfig from "../model/SecurityConfig";
+export interface WrapperLib {
+    express?: any;
+}
+/**
+ * @Wrapper
+ * collection - PostgreSQL Collection
+ *
+ */
+export declare class PostgreSQLWrapper {
+    pgDB: any;
+    collection: string;
+    isProd: boolean;
+    config: SecurityConfig;
+    lib: WrapperLib;
+    debug: any;
+    modelChecker: (obj: any) => boolean;
+    constructor(pgDB: any, collection: string, isProd: boolean, config: SecurityConfig, modelChecker: (obj: any, ignore?: boolean) => boolean, lib: WrapperLib, debug?: (reqBody: any, curBody: any, errMsg: any) => void);
+    buildUpdateQuery(pgData: any): string;
+    initCreate: (req: any, res: any, workflow?: ((data: any) => Promise<any>) | undefined) => Promise<{
+        success: boolean;
+    } | undefined>;
+    initGet: (req: any, res: any) => Promise<{
+        data: null;
+    } | undefined>;
+    initUpdate: (req: any, res: any, workflow?: ((data: any) => Promise<any>) | undefined) => Promise<{
+        success: boolean;
+    } | undefined>;
+    initDelete: (req: any, res: any, workflow?: ((data: any) => Promise<any>) | undefined) => Promise<{
+        success: boolean;
+    } | undefined>;
+    initList: (req: any, res: any) => Promise<void>;
+    init: () => any;
+}
+//# sourceMappingURL=postgresqlWrapper.d.ts.map

package/dist/apis/postgresqlWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgresqlWrapper.d.ts","sourceRoot":"","sources":["../../src/apis/postgresqlWrapper.ts"],"names":[],"mappings":"AAQA,OAAO,cAAc,MAAM,yBAAyB,CAAC;AAGrD,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B,IAAI,EAAE,GAAG,CAAM;IACf,UAAU,SAAM;IAChB,MAAM,UAAS;IACf,MAAM,EAAE,cAAc,CAQpB;IACF,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC;IAEX,YAAY,QAAS,GAAG,aAEtB;gBAGA,IAAI,EAAE,GAAG,EACT,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,cAAc,EACtB,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,EACrD,GAAG,EAAE,UAAU,EACf,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI;IAoB3D,gBAAgB,CAAC,MAAM,EAAE,GAAG;IAM5B,UAAU,QACH,GAAG,OACH,GAAG,qBACU,GAAG,KAAK,QAAQ,GAAG,CAAC;;mBAuDtC;IAEF,OAAO,QAAe,GAAG,OAAO,GAAG;;mBAiCjC;IAEF,UAAU,QACH,GAAG,OACH,GAAG,qBACU,GAAG,KAAK,QAAQ,GAAG,CAAC;;mBAgFtC;IAEF,UAAU,QACH,GAAG,OACH,GAAG,qBACU,GAAG,KAAK,QAAQ,GAAG,CAAC;;mBAmCtC;IAEF,QAAQ,QAAe,GAAG,OAAO,GAAG,mBAgPlC;IAEF,IAAI,YA+EF;CACH"}

package/dist/apis/postgresqlWrapper.js

@@ -0,0 +1,513 @@
+"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 });
+exports.PostgreSQLWrapper = void 0;
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+const QueryModel_1 = require("../model/QueryModel");
+const utils_1 = require("./utils");
+/**
+ * @Wrapper
+ * collection - PostgreSQL Collection
+ *
+ */
+class PostgreSQLWrapper {
+    constructor(pgDB, collection, isProd, config, modelChecker, lib, debug) {
+        this.pgDB = "";
+        this.collection = "";
+        this.isProd = false;
+        this.config = {
+            baseConfig: [],
+            opsConfig: {
+                read: [],
+                create: [],
+                update: [],
+                delete: [],
+            },
+        };
+        // eslint-disable-next-line
+        this.modelChecker = (obj) => {
+            return false;
+        };
+        this.initCreate = (req, res, workflow) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const valid = this.modelChecker(req.body.data);
+                if (valid) {
+                    //INFO : Security Checker
+                    const validBaseConfig = (0, QueryModel_1.checkBaseConfig)(this.config, req);
+                    const validOpsConfig = (0, QueryModel_1.checkOpsConfig)(this.config, "create", req, req.body.data);
+                    if (!validBaseConfig || !validOpsConfig) {
+                        res.status(400).json({ err: "Invalid Security Configuration" });
+                        return;
+                    }
+                    // req.body.data["baseUpdatedAt"] = moment().toDate();
+                    if (req.body.unique && ((_a = req.body.data) === null || _a === void 0 ? void 0 : _a[req.body.unique])) {
+                        const uniqueField = req.body.unique;
+                        const uniqueValue = req.body.data[uniqueField];
+                        const { rowCount } = yield this.pgDB.query(`SELECT * FROM ${this.collection} WHERE ${uniqueField} = $1 LIMIT 1`, [uniqueValue]);
+                        if (rowCount > 0) {
+                            res
+                                .status(400)
+                                .json({ err: `Unique:${req.body.data[req.body.unique]} exists` });
+                            return;
+                        }
+                    }
+                    if (workflow)
+                        yield workflow(req.body.data);
+                    const columns = Object.keys(req.body.data).join(", ");
+                    const values = Object.values(req.body.data);
+                    const placeholders = values
+                        .map((_, index) => `$${index + 1}`)
+                        .join(", ");
+                    yield this.pgDB.query(`INSERT INTO ${this.collection} (${columns}) VALUES (${placeholders})`, values);
+                    const resBody = { success: true };
+                    if ((_b = req.body) === null || _b === void 0 ? void 0 : _b.stopRes)
+                        return resBody;
+                    res.send(resBody);
+                }
+                else {
+                    res.status(400).json({ err: "Invalid Model Structure" });
+                }
+            }
+            catch (err) {
+                res.status(400).json({ err: err });
+            }
+        });
+        this.initGet = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _c;
+            try {
+                const valid = req.body.id;
+                if (valid) {
+                    //INFO : Security Checker
+                    const pgResult = yield this.pgDB.query(`SELECT * FROM ${this.collection} WHERE id = $1 LIMIT 1`, [valid]);
+                    const resBody = { data: null };
+                    if (pgResult.rowCount > 0) {
+                        const pgData = pgResult.rows[0];
+                        const validBaseConfig = (0, QueryModel_1.checkBaseConfig)(this.config, req);
+                        const validOpsConfig = (0, QueryModel_1.checkOpsConfig)(this.config, "read", req, pgData);
+                        if (!validBaseConfig || !validOpsConfig) {
+                            res.status(400).json({ err: "Invalid Security Configuration" });
+                            return;
+                        }
+                        resBody["data"] = pgData;
+                    }
+                    if ((_c = req.body) === null || _c === void 0 ? void 0 : _c.stopRes)
+                        return resBody;
+                    res.send(resBody);
+                }
+                else {
+                    res.status(400).json({ err: "Invalid Fields" });
+                }
+            }
+            catch (err) {
+                res.status(400).json({ err: err });
+            }
+        });
+        this.initUpdate = (req, res, workflow) => __awaiter(this, void 0, void 0, function* () {
+            var _d, _e, _f;
+            try {
+                const valid = this.modelChecker(req.body.data) && req.body.id;
+                if (valid) {
+                    const pgResult = yield this.pgDB.query(`SELECT * FROM ${this.collection} WHERE id = $1`, [valid]);
+                    if (pgResult.rowCount > 0) {
+                        const pgData = pgResult.rows[0];
+                        if (this.debug)
+                            this.debug(req.body, pgData);
+                        const validBaseConfig = (0, QueryModel_1.checkBaseConfig)(this.config, req);
+                        const validOpsConfig = (0, QueryModel_1.checkOpsConfig)(this.config, "update", req, pgData);
+                        if (!validBaseConfig || !validOpsConfig) {
+                            res.status(400).json({ err: "Invalid Security Configuration" });
+                            return;
+                        }
+                        if (req.body.unique && ((_d = req.body.data) === null || _d === void 0 ? void 0 : _d[req.body.unique])) {
+                            const uniqueField = req.body.unique;
+                            const uniqueValue = req.body.data[uniqueField];
+                            const { rowCount } = yield this.pgDB.query(`SELECT * FROM ${this.collection} WHERE ${uniqueField} = $1 LIMIT 1`, [uniqueValue]);
+                            if (rowCount > 0) {
+                                res.status(400).json({
+                                    err: `Unique:${req.body.data[req.body.unique]} exists`,
+                                });
+                                return;
+                            }
+                        }
+                        const { updatedFields } = (0, utils_1.compareUpdatedFields)(pgData, req.body.data);
+                        const resBody = { success: true };
+                        if (workflow)
+                            yield workflow(updatedFields);
+                        // const data = this.parseModel(updatedFields);
+                        //INFO : Security Checker
+                        const updateQuery = this.buildUpdateQuery(updatedFields);
+                        const sqlQuery = `UPDATE ${this.collection} SET ${updateQuery} WHERE id = $${Object.keys(updatedFields).length + 1}`;
+                        const values = [...Object.values(updatedFields), valid];
+                        if (req.body.sensitive) {
+                            if ((0, moment_timezone_1.default)(req.body.data.baseUpdatedAt).isAfter((0, moment_timezone_1.default)(pgData.baseUpdatedAt))) {
+                                yield this.pgDB.query(sqlQuery, values);
+                                if ((_e = req.body) === null || _e === void 0 ? void 0 : _e.stopRes)
+                                    return resBody;
+                                res.send(resBody);
+                            }
+                            else {
+                                res.status(400).json({ err: "Refresh Sensitive Model" });
+                            }
+                        }
+                        else {
+                            yield this.pgDB.query(sqlQuery, values);
+                            if ((_f = req.body) === null || _f === void 0 ? void 0 : _f.stopRes)
+                                return resBody;
+                            res.send(resBody);
+                        }
+                    }
+                    else
+                        throw "No Data Found";
+                }
+                else {
+                    throw "Invalid Model Structure";
+                }
+            }
+            catch (err) {
+                if (this.debug)
+                    this.debug(null, null, err);
+                res.status(400).json({ err: err });
+            }
+        });
+        this.initDelete = (req, res, workflow) => __awaiter(this, void 0, void 0, function* () {
+            var _g;
+            try {
+                const valid = req.body.id;
+                if (valid) {
+                    const pgResult = yield this.pgDB.query(`SELECT * FROM ${this.collection} WHERE id = $1 LIMIT 1`, [valid]);
+                    if (pgResult.rowCount > 0) {
+                        const pgData = pgResult.rows[0];
+                        const validBaseConfig = (0, QueryModel_1.checkBaseConfig)(this.config, req);
+                        const validOpsConfig = (0, QueryModel_1.checkOpsConfig)(this.config, "read", req, pgData);
+                        if (!validBaseConfig || !validOpsConfig) {
+                            res.status(400).json({ err: "Invalid Security Configuration" });
+                            return;
+                        }
+                        if (workflow)
+                            yield workflow(pgData);
+                        yield this.pgDB.query(`DELETE FROM ${this.collection} WHERE id = $1`, [valid]);
+                        const resBody = { success: true };
+                        if ((_g = req.body) === null || _g === void 0 ? void 0 : _g.stopRes)
+                            return resBody;
+                        res.send(resBody);
+                    }
+                    else
+                        throw "No Data Found";
+                }
+                else
+                    throw "Invalid Fields";
+            }
+            catch (err) {
+                res.status(400).json({ err: err });
+            }
+        });
+        this.initList = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _h, _j, _k, _l, _m;
+            try {
+                //INFO : Security Checker
+                const validBaseConfig = (0, QueryModel_1.checkBaseConfig)(this.config, req);
+                if (validBaseConfig) {
+                    const aggregate = req.body.aggregate;
+                    const queryList = (_h = req.body.query) !== null && _h !== void 0 ? _h : [];
+                    if (aggregate) {
+                        const queryId = (_j = aggregate.queryId) !== null && _j !== void 0 ? _j : "";
+                        const dateId = (_k = aggregate.dateId) !== null && _k !== void 0 ? _k : "baseUpdatedAt";
+                        const dateRanges = (_l = aggregate.range) !== null && _l !== void 0 ? _l : [];
+                        const dataList = [];
+                        for (const dateRange of dateRanges) {
+                            //INFO : Step 1 - Query
+                            let query = `SELECT * FROM ${this.collection}`;
+                            const whereClauses = [];
+                            if (queryList && queryList.length > 0) {
+                                queryList.map((eachQuery) => {
+                                    var _a;
+                                    const queryId = (_a = eachQuery.queryId) !== null && _a !== void 0 ? _a : "";
+                                    const value = eachQuery.value;
+                                    switch (eachQuery.type) {
+                                        case "=":
+                                            whereClauses.push(`${queryId} = ${value}`);
+                                            break;
+                                        case "!=":
+                                            whereClauses.push(`${queryId} != ${value}`);
+                                            break;
+                                        case ">":
+                                            whereClauses.push(`${queryId} > ${value}`);
+                                            break;
+                                        case "<":
+                                            whereClauses.push(`${queryId} < ${value}`);
+                                            break;
+                                        case "><":
+                                            if (Array.isArray(value) && value.length >= 2) {
+                                                whereClauses.push(`${queryId} BETWEEN ${value[0]} AND ${value[1]}`);
+                                            }
+                                            break;
+                                        case "in":
+                                            whereClauses.push(`${queryId} IN (${value
+                                                .map((eachValue) => `'${eachValue}'`)
+                                                .join(", ")})`);
+                                            break;
+                                        default:
+                                            break;
+                                    }
+                                });
+                            }
+                            const date = dateRange.split("-");
+                            const [startDate, endDate = (0, moment_timezone_1.default)().format("DD/MM/YYYY HH:mm:ss"),] = date;
+                            const isDuration = date.length === 2;
+                            const isValidStartDate = (0, moment_timezone_1.default)(startDate, "DD/MM/YYYY").isValid();
+                            const isValidEndDate = (0, moment_timezone_1.default)(endDate, "DD/MM/YYYY").isValid();
+                            const startMoment = (0, moment_timezone_1.default)(startDate, "DD/MM/YYYY HH:mm:ss").tz("Asia/Kuala_lumpur");
+                            const endMoment = (0, moment_timezone_1.default)(endDate, "DD/MM/YYYY HH:mm:ss").tz("Asia/Kuala_lumpur");
+                            const isoStartDate = startMoment.toDate();
+                            const queryStartDate = startMoment.toISOString();
+                            const queryEndDate = endMoment.toISOString();
+                            if (!isValidStartDate || !isValidEndDate) {
+                                res
+                                    .status(400)
+                                    .json({ err: "Invalid Aggregate Range Configuration" });
+                                return;
+                            }
+                            const id = isDuration
+                                ? dateRange
+                                : `Begining until ${(0, moment_timezone_1.default)(isoStartDate).format("DD/MM/YYYY")}`;
+                            if (isDuration) {
+                                whereClauses.push(`${dateId} BETWEEN '${queryStartDate}' AND '${queryEndDate}'`);
+                            }
+                            else {
+                                whereClauses.push(`${dateId} < '${queryStartDate}'`);
+                            }
+                            const allWhereClauses = `${whereClauses.length > 0
+                                ? "WHERE " + whereClauses.join(" AND ")
+                                : ""}`;
+                            let value = 0;
+                            switch (aggregate.type) {
+                                case "count":
+                                    query = `SELECT COUNT(*) as count FROM ${this.collection} ${allWhereClauses}`;
+                                    const countResult = yield this.pgDB.query(query);
+                                    value = parseInt(countResult.rows[0].count, 10);
+                                    break;
+                                case "sum":
+                                    query = `SELECT SUM(${queryId}) as sum FROM ${this.collection} ${allWhereClauses}`;
+                                    const sumResult = yield this.pgDB.query(query);
+                                    value = parseFloat(sumResult.rows[0].sum);
+                                    break;
+                                case "avg":
+                                    query = `SELECT AVG(${queryId}) as avg FROM ${this.collection} ${allWhereClauses}`;
+                                    const avgResult = yield this.pgDB.query(query);
+                                    value = parseFloat(avgResult.rows[0].avg);
+                                    break;
+                                case "value":
+                                    query = `SELECT * FROM ${this.collection} ${allWhereClauses} ORDER BY ${dateId} DESC LIMIT 1`;
+                                    const valueResult = yield this.pgDB.query(query);
+                                    if (valueResult.rows.length > 0)
+                                        value = valueResult.rows[0][queryId];
+                                    break;
+                                default:
+                                    break;
+                            }
+                            dataList.push({
+                                _id: id,
+                                value: value,
+                            });
+                        }
+                        res.send({
+                            data: dataList,
+                        });
+                    }
+                    else {
+                        //INFO : Step 1 - Query
+                        let query = `SELECT * FROM ${this.collection}`;
+                        const whereClauses = [];
+                        if (queryList && queryList.length > 0) {
+                            queryList.map((eachQuery) => {
+                                var _a;
+                                const queryId = (_a = eachQuery.queryId) !== null && _a !== void 0 ? _a : "";
+                                const value = eachQuery.value;
+                                switch (eachQuery.type) {
+                                    case "search":
+                                        if (eachQuery.searchIds && eachQuery.searchIds.length > 0) {
+                                            whereClauses.push(`${eachQuery.searchIds[0]} ILIKE '${value}%'`);
+                                        }
+                                        break;
+                                    case "=":
+                                        whereClauses.push(`${queryId} = '${value}'`);
+                                        break;
+                                    case "!=":
+                                        whereClauses.push(`${queryId} != '${value}'`);
+                                        break;
+                                    case ">":
+                                        whereClauses.push(`${queryId} > '${value}'`);
+                                        break;
+                                    case "<":
+                                        whereClauses.push(`${queryId} < '${value}'`);
+                                        break;
+                                    case "><":
+                                        if (Array.isArray(value) && value.length >= 2) {
+                                            whereClauses.push(`${queryId} BETWEEN '${value[0]}' AND '${value[1]}'`);
+                                        }
+                                        break;
+                                    case "in":
+                                        whereClauses.push(`${queryId} IN (${value
+                                            .map((eachValue) => `'${eachValue}'`)
+                                            .join(", ")})`);
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            });
+                        }
+                        const allWhereClauses = `${whereClauses.length > 0 ? "WHERE " + whereClauses.join(" AND ") : ""}`;
+                        query += ` ${allWhereClauses}`;
+                        //INFO : Step 2 - Sort
+                        if (req.body.sort) {
+                            const sortReq = req.body.sort;
+                            query += ` ORDER BY ${sortReq.sortId} ${sortReq.type === "asc" ? "ASC" : "DESC"}`;
+                        }
+                        //INFO : Step 3 - Pagination
+                        if (req.body.cursor) {
+                            query += ` OFFSET ${req.body.cursor}`;
+                        }
+                        //INFO : Step 4 - Limit
+                        if (!req.body.stopLimit) {
+                            const limit = (_m = req.body.limit) !== null && _m !== void 0 ? _m : 10;
+                            query += ` LIMIT ${limit}`;
+                        }
+                        const { rows, rowCount } = yield this.pgDB.query(query);
+                        //INFO : Security Checker
+                        let validOpsConfig = true;
+                        const dataList = [];
+                        if (rows) {
+                            rows.forEach((eachData) => {
+                                dataList.push(eachData);
+                                if (!(0, QueryModel_1.checkOpsConfig)(this.config, "read", req, eachData)) {
+                                    validOpsConfig = false;
+                                }
+                            });
+                        }
+                        if (!validBaseConfig || !validOpsConfig) {
+                            res.status(400).json({ err: "Invalid Security Configuration" });
+                            return;
+                        }
+                        res.send({
+                            data: dataList,
+                            count: rowCount,
+                        });
+                    }
+                }
+                else {
+                    res.status(400).json({ err: "Invalid Security Configuration" });
+                }
+            }
+            catch (err) {
+                if (err.message)
+                    res.status(400).json({ err: err.message });
+                else
+                    res.status(400).json({ err: err });
+            }
+        });
+        this.init = () => {
+            const router = this.lib.express.Router();
+            /**
+             * @Input :
+             * data - Model
+             * unique - string (Optional)
+             */
+            router.post("/create", (req, res) => {
+                this.initCreate(req, res);
+            });
+            /**
+             * @Input :
+             * data - Model
+             * unique - string (Optional)
+             */
+            // router.post("/batchCreate", (req: any, res: any) => {
+            //   this.initBatchCreate(req, res);
+            // });
+            /**
+             * @Input :
+             * id - string
+             */
+            router.post("/get", (req, res) => {
+                this.initGet(req, res);
+            });
+            /**
+             * @Input :
+             * data - Model
+             * id - string
+             * unique - string (Optional)
+             */
+            router.post("/update", (req, res) => {
+                this.initUpdate(req, res);
+            });
+            /**
+             * @Input :
+             * data - Model
+             * query - Query[]
+             * unsetData - string[] (Unset Attribute Id) (Optional)
+             * isOr - boolean (Optional)
+             */
+            // router.post("/batchUpdate", (req: any, res: any) => {
+            //   this.initBatchUpdate(req, res);
+            // });
+            /**
+             * @Input :
+             * id - string
+             */
+            router.post("/delete", (req, res) => {
+                this.initDelete(req, res);
+            });
+            /**
+             * @Input :
+             * id - string[]
+             */
+            // router.post("/batchDelete", (req: any, res: any) => {
+            //   this.initBatchDelete(req, res);
+            // });
+            /**
+             * @Input
+             * query - Query interface (Optional)
+             * cursor - any (Optional)
+             * limit - number (Optional)
+             * sort - Sort interface (Optional)
+             * stopLimit - boolean to retreive all data (Optional)
+             */
+            router.post("/list", (req, res) => {
+                this.initList(req, res);
+            });
+            return router;
+        };
+        this.pgDB = pgDB;
+        this.collection = collection;
+        this.isProd = isProd;
+        this.config = config;
+        this.modelChecker = modelChecker;
+        this.lib = lib;
+        this.debug = debug;
+    }
+    //TODO: Parse Model
+    //TODO: Batch Create & Update
+    //TODO: Change table schema dynanically
+    // parseModel = (data: any) => {
+    //   delete data["_id"];
+    //   data["baseUpdatedAt"] = moment().toDate();
+    //   return data;
+    // };
+    buildUpdateQuery(pgData) {
+        return Object.keys(pgData)
+            .map((key, index) => `${key} = $${index + 1}`)
+            .join(", ");
+    }
+}
+exports.PostgreSQLWrapper = PostgreSQLWrapper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blixify-server",
-  "version": "0.1.68",
+  "version": "0.1.69",
   "license": "MIT",
   "main": "dist/apis/index.js",
   "private": false,
@@ -21,6 +21,7 @@
     "build": "yarn run lint && tsc --build \"./tsconfig.json\"",
     "deploy": "yarn run lint && tsc --build \"./buildtsconfig.json\"",
     "lint": "eslint . --max-warnings=0",
+    "start:postgres": "cd dist && node postgresServer.js",
     "start:mongo": "cd dist && node mongoServer.js",
     "start:fb": "cd dist && node firebaseServer.js",
     "start:aws": "cd dist && node awsServer.js",
@@ -37,9 +38,11 @@
   "dependencies": {
     "@types/uuid": "^9.0.7",
     "axios": "^1.4.0",
+    "crypto-js": "^4.2.0",
     "mime": "^3.0.0",
     "moment": "^2.29.4",
     "moment-timezone": "^0.5.43",
+    "pg": "^8.12.0",
     "uuid": "^9.0.1"
   },
   "devDependencies": {