prostgles-server 2.0.178 → 2.0.179

package/lib/TableConfig.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prostgles_types_1 = require("prostgles-types");
+const PubSubManager_1 = require("./PubSubManager");
+/**
+ * Will be run between initSQL and fileTable
+ */
+class TableConfigurator {
+    constructor(prostgles) {
+        this.getColumnConfig = (tableName, colName) => {
+            const tconf = this.config?.[tableName];
+            if (tconf && "columns" in tconf) {
+                return tconf.columns[colName];
+            }
+            return undefined;
+        };
+        this.getColInfo = (params) => {
+            const colConf = this.getColumnConfig(params.table, params.col);
+            let result = undefined;
+            if (colConf) {
+                if ("info" in colConf) {
+                    result = {
+                        ...(result ?? {}),
+                        ...colConf?.info
+                    };
+                }
+                /**
+                 * Get labels from TableConfig if specified
+                 */
+                if (colConf.label) {
+                    const { lang } = params;
+                    const lbl = colConf?.label;
+                    if (["string", "object"].includes(typeof lbl)) {
+                        if (typeof lbl === "string") {
+                            result ?? (result = {});
+                            result.label = lbl;
+                        }
+                        else if (lang && (lbl?.[lang] || lbl?.en)) {
+                            result ?? (result = {});
+                            result.label = (lbl?.[lang]) || lbl?.en;
+                        }
+                    }
+                }
+            }
+            return result;
+        };
+        this.checkColVal = (params) => {
+            const conf = this.getColInfo(params);
+            if (conf) {
+                const { value } = params;
+                const { min, max } = conf;
+                if (min !== undefined && value !== undefined && value < min)
+                    throw `${params.col} must be less than ${min}`;
+                if (max !== undefined && value !== undefined && value > max)
+                    throw `${params.col} must be greater than ${max}`;
+            }
+        };
+        this.getJoinInfo = (sourceTable, targetTable) => {
+            if (this.config &&
+                sourceTable in this.config &&
+                this.config[sourceTable] &&
+                "columns" in this.config[sourceTable]) {
+                const td = this.config[sourceTable];
+                if ("columns" in td && td.columns[targetTable]) {
+                    const cd = td.columns[targetTable];
+                    if ("joinDef" in cd) {
+                        const { joinDef } = cd;
+                        const res = {
+                            expectOne: false,
+                            paths: joinDef.map(({ sourceTable, targetTable: table, on }) => ({
+                                source: sourceTable,
+                                target: targetTable,
+                                table,
+                                on
+                            })),
+                        };
+                        return res;
+                    }
+                }
+            }
+            return undefined;
+        };
+        this.config = prostgles.opts.tableConfig;
+        this.prostgles = prostgles;
+    }
+    get dbo() {
+        if (!this.prostgles.dbo)
+            throw "this.prostgles.dbo missing";
+        return this.prostgles.dbo;
+    }
+    ;
+    get db() {
+        if (!this.prostgles.db)
+            throw "this.prostgles.db missing";
+        return this.prostgles.db;
+    }
+    ;
+    async init() {
+        let queries = [];
+        if (!this.config || !this.prostgles.pgp)
+            throw "config or pgp missing";
+        /* Create lookup tables */
+        Object.keys(this.config).map(tableName => {
+            const tableConf = this.config[tableName];
+            const { dropIfExists = false, dropIfExistsCascade = false } = tableConf;
+            if (dropIfExistsCascade) {
+                queries.push(`DROP TABLE IF EXISTS ${tableName} CASCADE;`);
+            }
+            else if (dropIfExists) {
+                queries.push(`DROP TABLE IF EXISTS ${tableName} ;`);
+            }
+            if ("isLookupTable" in tableConf && Object.keys(tableConf.isLookupTable?.values).length) {
+                const rows = Object.keys(tableConf.isLookupTable?.values).map(id => ({ id, ...(tableConf.isLookupTable?.values[id]) }));
+                if (dropIfExists || dropIfExistsCascade || !this.dbo?.[tableName]) {
+                    const keys = Object.keys(rows[0]).filter(k => k !== "id");
+                    queries.push(`CREATE TABLE IF NOT EXISTS ${tableName} (
+                        id  TEXT PRIMARY KEY
+                        ${keys.length ? (", " + keys.map(k => (0, prostgles_types_1.asName)(k) + " TEXT ").join(", ")) : ""}
+                    );`);
+                    rows.map(row => {
+                        const values = this.prostgles.pgp.helpers.values(row);
+                        queries.push(this.prostgles.pgp.as.format(`INSERT INTO ${tableName}  (${["id", ...keys].map(t => (0, prostgles_types_1.asName)(t)).join(", ")})  ` + " VALUES ${values:raw} ;", { values }));
+                    });
+                    // console.log("Created lookup table " + tableName)
+                }
+            }
+        });
+        if (queries.length) {
+            const q = queries.join("\n");
+            console.log("TableConfig: \n", q);
+            await this.db.multi(q);
+            await this.prostgles.refreshDBO();
+        }
+        queries = [];
+        /* Create referenced columns */
+        await Promise.all(Object.keys(this.config).map(async (tableName) => {
+            const tableConf = this.config[tableName];
+            if ("columns" in tableConf) {
+                const getColDef = (name, colConf) => {
+                    const colNameEsc = (0, prostgles_types_1.asName)(name);
+                    const getTextDef = (colConf) => {
+                        const { nullable, defaultValue } = colConf;
+                        return ` TEXT ${!nullable ? " NOT NULL " : ""} ${defaultValue ? ` DEFAULT ${(0, PubSubManager_1.asValue)(defaultValue)} ` : ""}`;
+                    };
+                    if ("references" in colConf && colConf.references) {
+                        const { tableName: lookupTable, columnName: lookupCol = "id" } = colConf.references;
+                        return ` ${colNameEsc} ${getTextDef(colConf.references)} REFERENCES ${lookupTable} (${lookupCol}) `;
+                    }
+                    else if ("sqlDefinition" in colConf && colConf.sqlDefinition) {
+                        return ` ${colNameEsc} ${colConf.sqlDefinition} `;
+                    }
+                    else if ("isText" in colConf && colConf.isText) {
+                        let checks = "", cArr = [];
+                        if (colConf.lowerCased) {
+                            cArr.push(`${colNameEsc} = LOWER(${colNameEsc})`);
+                        }
+                        if (colConf.trimmed) {
+                            cArr.push(`${colNameEsc} = BTRIM(${colNameEsc})`);
+                        }
+                        if (cArr.length) {
+                            checks = `CHECK (${cArr.join(" AND ")})`;
+                        }
+                        return ` ${colNameEsc} ${getTextDef(colConf)} ${checks}`;
+                    }
+                    else {
+                        throw "Unknown column config: " + JSON.stringify(colConf);
+                    }
+                };
+                const colDefs = [];
+                Object.keys(tableConf.columns).filter(c => !("joinDef" in tableConf.columns[c])).map(colName => {
+                    const colConf = tableConf.columns[colName];
+                    if (!this.dbo[tableName]) {
+                        colDefs.push(getColDef(colName, colConf));
+                    }
+                    else if (!colDefs.length && !this.dbo[tableName].columns?.find(c => colName === c.name)) {
+                        if ("references" in colConf && colConf.references) {
+                            const { tableName: lookupTable, } = colConf.references;
+                            queries.push(`
+                                ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} 
+                                ADD COLUMN ${getColDef(colName, colConf)};
+                            `);
+                            console.log(`TableConfigurator: ${tableName}(${colName})` + " referenced lookup table " + lookupTable);
+                        }
+                        else if ("sqlDefinition" in colConf && colConf.sqlDefinition) {
+                            queries.push(`
+                                ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} 
+                                ADD COLUMN ${getColDef(colName, colConf)};
+                            `);
+                            console.log(`TableConfigurator: created/added column ${tableName}(${colName}) ` + colConf.sqlDefinition);
+                        }
+                    }
+                });
+                if (colDefs.length) {
+                    queries.push(`CREATE TABLE ${(0, prostgles_types_1.asName)(tableName)} (
+                        ${colDefs.join(", \n")}
+                    );`);
+                    console.error("TableConfigurator: Created table: \n" + queries[0]);
+                }
+            }
+            if ("constraints" in tableConf && tableConf.constraints) {
+                (0, prostgles_types_1.getKeys)(tableConf.constraints).map(constraintName => {
+                    queries.push(`ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} ADD CONSTRAINT ${(0, prostgles_types_1.asName)(constraintName)} ${tableConf.constraints[constraintName]} ;`);
+                });
+            }
+            if ("indexes" in tableConf && tableConf.indexes) {
+                (0, prostgles_types_1.getKeys)(tableConf.indexes).map(indexName => {
+                    const { concurrently, unique, using, definition, replace } = tableConf.indexes[indexName];
+                    if (replace || typeof replace !== "boolean" && tableConf.replaceUniqueIndexes) {
+                        queries.push(`DROP INDEX IF EXISTS ${(0, prostgles_types_1.asName)(indexName)}  ;`);
+                    }
+                    queries.push(`CREATE ${unique ? "UNIQUE" : ""} ${!concurrently ? "" : "CONCURRENTLY"} INDEX ${(0, prostgles_types_1.asName)(indexName)} ON ${(0, prostgles_types_1.asName)(tableName)} ${!using ? "" : ("USING " + using)} (${definition}) ;`);
+                });
+            }
+        }));
+        if (queries.length) {
+            const q = queries.join("\n");
+            console.log("TableConfig: \n", q);
+            await this.db.multi(q);
+        }
+    }
+}
+exports.default = TableConfigurator;
+async function columnExists(args) {
+    const { db, tableName, colName } = args;
+    return Boolean((await db.oneOrNone(`
+        SELECT column_name, table_name
+        FROM information_schema.columns 
+        WHERE table_name=${(0, PubSubManager_1.asValue)(tableName)} and column_name=${(0, PubSubManager_1.asValue)(colName)}
+        LIMIT 1;
+    `))?.column_name);
+}

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import { ProstglesInitOptions } from "./Prostgles";
+declare function prostgles<S = void>(params: ProstglesInitOptions<S>): Promise<{
+    db: import("./DboBuilder").DBHandlerServer;
+    _db: import("./Prostgles").DB;
+    pgp: import("./Prostgles").PGP;
+    io?: any;
+    destroy: () => Promise<boolean>;
+}>;
+export = prostgles;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAE9D,iBAAS,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;;;;;;GAI3D;AACD,SAAS,SAAS,CAAC"}

package/lib/index.js

@@ -0,0 +1,45 @@
+"use strict";
+const Prostgles_1 = require("./Prostgles");
+function prostgles(params) {
+    let prgl = new Prostgles_1.Prostgles(params);
+    return prgl.init(params.onReady);
+}
+module.exports = prostgles;
+// declare const init (params: InitOptions) => {
+//     let prgl = new Prostgles(params);
+//     prgl.init(params.isReady);
+// }
+// module.exports = {
+//     pgp,
+//     init,
+//     Prostgles
+// }
+// module.exports = prostgles;
+// module.exports = init;
+// declare module "ProstglesServer" {
+//     function iinit(params: InitOptions): void ;
+//     // namespace iinit {
+//     //     interface ReduxLoggerOptions {
+//     //       actionTransformer?: (action: any) => any;
+//     //       collapsed?: boolean;
+//     //       duration?: boolean;
+//     //       level?: string;
+//     //       logger?: any;
+//     //       predicate?: (getState: Function, action: any) => boolean;
+//     //       timestamp?: boolean;
+//     //       transformer?: (state:any) => any;
+//     //     }
+//     //   }
+//     export = iinit;
+//     // export = init;
+// }
+//var init =
+// export function init(params: InitOptions){
+//     let prgl = new Prostgles(params);
+//     prgl.init(params.isReady);
+// }
+// declare const init (params: InitOptions) => {
+//         let prgl = new Prostgles(params);
+//         prgl.init(params.isReady);
+// }
+// export = init;

package/lib/index.ts

@@ -1,10 +1,9 @@
 import { Prostgles, ProstglesInitOptions } from "./Prostgles";
-import { DBSchema } from "prostgles-types";
 
-function prostgles<S extends DBSchema | undefined = undefined>(params: ProstglesInitOptions<S>){
+function prostgles<S = void>(params: ProstglesInitOptions<S>){
 
-    let prgl = new Prostgles<S>(params as any);
-    return prgl.init(params.onReady);
+    let prgl = new Prostgles(params as any);
+    return prgl.init(params.onReady as any);
 }
 export = prostgles;//{ , TableHandler, ViewHandler };
 

package/lib/shortestPath.d.ts

@@ -0,0 +1,10 @@
+export declare type Graph = {
+    [key: string]: {
+        [key: string]: number;
+    };
+};
+export declare const findShortestPath: (graph: Graph, startNode: string, endNode: string) => {
+    distance: number;
+    path: string[];
+};
+//# sourceMappingURL=shortestPath.d.ts.map

package/lib/shortestPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortestPath.d.ts","sourceRoot":"","sources":["shortestPath.ts"],"names":[],"mappings":"AAcA,oBAAY,KAAK,GAAG;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;CACxC,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAW,KAAK,aAAa,MAAM,WAAW,MAAM,KAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAgErH,CAAC"}

package/lib/shortestPath.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findShortestPath = void 0;
+const shortestDistanceNode = (distances, visited) => {
+    let shortest = null;
+    for (let node in distances) {
+        let currentIsShortest = shortest === null || distances[node] < distances[shortest];
+        if (currentIsShortest && !visited.includes(node)) {
+            shortest = node;
+        }
+    }
+    return shortest;
+};
+const findShortestPath = (graph, startNode, endNode) => {
+    // establish object for recording distances from the start node
+    let distances = {};
+    distances[endNode] = "Infinity";
+    distances = Object.assign(distances, graph[startNode]);
+    // track paths
+    let parents = { endNode: null };
+    for (let child in graph[startNode]) {
+        parents[child] = startNode;
+    }
+    // track nodes that have already been visited
+    let visited = [];
+    // find the nearest node
+    let node = shortestDistanceNode(distances, visited);
+    // for that node
+    while (node) {
+        // find its distance from the start node & its child nodes
+        let distance = distances[node];
+        let children = graph[node];
+        // for each of those child nodes
+        for (let child in children) {
+            // make sure each child node is not the start node
+            if (String(child) === String(startNode)) {
+                continue;
+            }
+            else {
+                // save the distance from the start node to the child node
+                let newdistance = distance + children[child];
+                // if there's no recorded distance from the start node to the child node in the distances object
+                // or if the recorded distance is shorter than the previously stored distance from the start node to the child node
+                // save the distance to the object
+                // record the path
+                if (!distances[child] || distances[child] > newdistance) {
+                    distances[child] = newdistance;
+                    parents[child] = node;
+                }
+            }
+        }
+        // move the node to the visited set
+        visited.push(node);
+        // move to the nearest neighbor node
+        node = shortestDistanceNode(distances, visited);
+    }
+    // using the stored paths from start node to end node
+    // record the shortest path
+    let shortestPath = [endNode];
+    let parent = parents[endNode];
+    while (parent) {
+        shortestPath.push(parent);
+        parent = parents[parent];
+    }
+    shortestPath.reverse();
+    // return the shortest path from start node to end node & its distance
+    let results = {
+        distance: distances[endNode],
+        path: shortestPath,
+    };
+    return results;
+};
+exports.findShortestPath = findShortestPath;
+/* Usage:
+
+const graph = {
+    start: { A: 5, B: 2 },
+    A: { start: 1, C: 4, D: 2 },
+    B: { A: 8, D: 7 },
+    C: { D: 6, end: 3 },
+    D: { end: 1 },
+    end: {},
+};
+
+findShortestPath(graph, 'start', 'end');
+
+{
+  "distance": 8,
+  "path": [
+    "start",
+    "A",
+    "D",
+    "end"
+  ]
+}
+
+
+
+
+// The graph is unidirectional
+
+const graph = {
+    start: { A: 5 },
+    end: { A: 1 },
+    A: { start: 1, end: 1 },
+};
+
+findShortestPath(graph, 'start', 'end');
+
+
+*/ 

package/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export { get } from "prostgles-types";
+//# sourceMappingURL=utils.d.ts.map

package/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC"}

package/lib/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get = void 0;
+var prostgles_types_1 = require("prostgles-types");
+Object.defineProperty(exports, "get", { enumerable: true, get: function () { return prostgles_types_1.get; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "2.0.178",
+  "version": "2.0.179",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,7 +29,7 @@
     "bluebird": "^3.7.2",
     "file-type": "^16.5.3",
     "pg-promise": "^10.11.1",
-    "prostgles-types": "^1.5.153",
+    "prostgles-types": "^1.5.155",
     "sharp": "^0.30.5"
   },
   "devDependencies": {
@@ -37,6 +37,6 @@
     "@types/bluebird": "^3.5.36",
     "@types/node": "^14.14.35",
     "@types/sharp": "^0.30.2",
-    "typescript": "^4.7.2"
+    "typescript": "^4.7.3"
   }
 }

package/tests/client/PID.txt

@@ -1 +1 @@
-85322
+14775

package/tests/client/index.d.ts

@@ -1,2 +1,2 @@
-export { DBHandlerClient } from "prostgles-client/dist/prostgles";
+export { DBHandlerClient, Auth } from "prostgles-client/dist/prostgles";
 //# sourceMappingURL=index.d.ts.map

package/tests/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC"}

package/tests/client_only_queries.d.ts

@@ -0,0 +1,4 @@
+import { DBHandlerClient, Auth } from "./client/index";
+import { DBSchemaTable } from "./client/node_modules/prostgles-types/dist";
+export default function client_only(db: DBHandlerClient, auth: Auth, log: (...args: any[]) => any, methods: any, tableSchema: DBSchemaTable[]): Promise<void>;
+//# sourceMappingURL=client_only_queries.d.ts.map

package/tests/client_only_queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client_only_queries.d.ts","sourceRoot":"","sources":["client_only_queries.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAa,MAAM,4CAA4C,CAAC;AAGtF,wBAA8B,WAAW,CAAC,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO,KAAA,EAAE,WAAW,EAAE,aAAa,EAAE,iBA6S7I"}

package/tests/isomorphic_queries.d.ts

@@ -0,0 +1,6 @@
+import { DBHandlerServer } from "../dist/Prostgles";
+import { DBHandlerClient } from "./client/index";
+export declare function tryRun(desc: string, func: () => any, log?: Function): Promise<void>;
+export declare function tryRunP(desc: string, func: (resolve: any, reject: any) => any, log?: Function): Promise<unknown>;
+export default function isomorphic(db: Partial<DBHandlerServer> | Partial<DBHandlerClient>): Promise<void>;
+//# sourceMappingURL=isomorphic_queries.d.ts.map

package/tests/isomorphic_queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isomorphic_queries.d.ts","sourceRoot":"","sources":["isomorphic_queries.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,iBAWzE;AACD,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,oBAW7F;AAED,wBAA8B,UAAU,CAAC,EAAE,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,iBAurB/F"}