prostgles-server 3.0.70 → 3.0.72

package/lib/DboBuilder/QueryBuilder/QueryBuilder.js

@@ -32,162 +32,16 @@ const parseFunctionObject = (funcData) => {
 };
 exports.parseFunctionObject = parseFunctionObject;
 class SelectItemBuilder {
+    select = [];
+    allFields;
+    allowedFields;
+    allowedOrderByFields;
+    computedFields;
+    functions;
+    allowedFieldsIncludingComputed;
+    isView;
+    columns;
     constructor(params) {
-        this.select = [];
-        this.checkField = (f, isSelected) => {
-            const allowedSelectedFields = this.allowedFieldsIncludingComputed;
-            const allowedNonSelectedFields = [...this.allowedFieldsIncludingComputed, ...this.allowedOrderByFields];
-            /** Not selected items can be part of the orderBy fields */
-            if (!(isSelected ? allowedSelectedFields : allowedNonSelectedFields).includes(f)) {
-                throw "Field " + f + " is invalid or dissallowed";
-            }
-            return f;
-        };
-        this.addItem = (item) => {
-            let fields = item.getFields();
-            // console.trace(fields)
-            if (fields === "*")
-                fields = this.allowedFields.slice(0);
-            fields.map(f => this.checkField(f, item.selected));
-            if (this.select.find(s => s.alias === item.alias)) {
-                throw `Cannot specify duplicate columns ( ${item.alias} ). Perhaps you're using "*" with column names?`;
-            }
-            this.select.push({ ...item, fields });
-        };
-        this.addFunction = (func, args, alias) => {
-            const funcDef = (0, Functions_1.parseFunction)({
-                func, args, functions: this.functions,
-                allowedFields: this.allowedFieldsIncludingComputed,
-            });
-            this.addItem({
-                type: funcDef.type,
-                alias,
-                getFields: () => funcDef.getFields(args),
-                getQuery: (tableAlias) => funcDef.getQuery({ allColumns: this.columns, allowedFields: this.allowedFields, args, tableAlias,
-                    ctidField: undefined,
-                    /* CTID not available in AFTER trigger */
-                    // ctidField: this.isView? undefined : "ctid" 
-                }),
-                selected: true
-            });
-        };
-        this.addColumn = (fieldName, selected) => {
-            /* Check if computed col */
-            if (selected) {
-                const compCol = Functions_1.COMPUTED_FIELDS.find(cf => cf.name === fieldName);
-                if (compCol && !this.select.find(s => s.alias === fieldName)) {
-                    const cf = {
-                        ...compCol,
-                        type: "computed",
-                        numArgs: 0,
-                        singleColArg: false,
-                        getFields: (args) => []
-                    };
-                    this.addFunction(cf, [], compCol.name);
-                    return;
-                }
-            }
-            const colDef = this.columns.find(c => c.name === fieldName);
-            let alias = selected ? fieldName : ("not_selected_" + fieldName);
-            this.addItem({
-                type: "column",
-                columnPGDataType: colDef?.data_type,
-                column_udt_type: colDef?.udt_name,
-                alias,
-                getQuery: () => (0, prostgles_types_1.asName)(fieldName),
-                getFields: () => [fieldName],
-                selected
-            });
-        };
-        this.parseUserSelect = async (userSelect, joinParse) => {
-            /* Array select */
-            if (Array.isArray(userSelect)) {
-                if (userSelect.find(key => typeof key !== "string"))
-                    throw "Invalid array select. Expecting an array of strings";
-                userSelect.map(key => this.addColumn(key, true));
-                /* Empty select */
-            }
-            else if (userSelect === "") {
-                // select.push({
-                //   type: "function",
-                //   alias: "",
-                //   getFields: () => [],
-                //   getQuery: () => ""
-                // })
-                return [];
-            }
-            else if (userSelect === "*") {
-                this.allowedFields.map(key => this.addColumn(key, true));
-            }
-            else if ((0, DboBuilder_1.isPlainObject)(userSelect) && !(0, prostgles_types_1.isEmpty)(userSelect)) {
-                const selectKeys = Object.keys(userSelect), selectValues = Object.values(userSelect);
-                /* Cannot include and exclude at the same time */
-                if (selectValues.filter(v => [0, false].includes(v)).length) {
-                    if (selectValues.filter(v => ![0, false].includes(v)).length) {
-                        throw "\nCannot include and exclude fields at the same time";
-                    }
-                    /* Exclude only */
-                    this.allowedFields.filter(f => !selectKeys.includes(f)).map(key => this.addColumn(key, true));
-                }
-                else {
-                    await Promise.all(selectKeys.map(async (key) => {
-                        const val = userSelect[key], throwErr = (extraErr = "") => {
-                            console.trace(extraErr);
-                            throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + extraErr;
-                        };
-                        /* Included fields */
-                        if ([1, true].includes(val)) {
-                            if (key === "*") {
-                                this.allowedFields.map(key => this.addColumn(key, true));
-                            }
-                            else {
-                                this.addColumn(key, true);
-                            }
-                            /* Aggs and functions */
-                        }
-                        else if (typeof val === "string" || (0, DboBuilder_1.isPlainObject)(val)) {
-                            /* Function shorthand notation
-                                { id: "$max" } === { id: { $max: ["id"] } } === SELECT MAX(id) AS id
-                            */
-                            if ((typeof val === "string" && val !== "*") ||
-                                (0, DboBuilder_1.isPlainObject)(val) && Object.keys(val).length === 1 && Array.isArray(Object.values(val)[0]) // !isPlainObject(Object.values(val)[0])
-                            ) {
-                                // if(!Array.isArray(Object.values(val)[0])){
-                                //   throw `Could not parse selected item: ${JSON.stringify(val)}\nFunction arguments must be in an array`;
-                                // }
-                                let funcName, args;
-                                if (typeof val === "string") {
-                                    /* Shorthand notation -> it is expected that the key is the column name used as the only argument */
-                                    try {
-                                        this.checkField(key, true);
-                                    }
-                                    catch (err) {
-                                        throwErr(` Shorthand function notation error: the specifield column ( ${key} ) is invalid or dissallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `);
-                                    }
-                                    funcName = val;
-                                    args = [key];
-                                    /** Function full notation { $funcName: ["colName", ...args] } */
-                                }
-                                else {
-                                    ({ funcName, args } = (0, exports.parseFunctionObject)(val));
-                                }
-                                this.addFunction(funcName, args, key);
-                                /* Join */
-                            }
-                            else {
-                                if (!joinParse)
-                                    throw "Joins dissalowed";
-                                await joinParse(key, val, throwErr);
-                            }
-                        }
-                        else
-                            throwErr();
-                    }));
-                }
-            }
-            else
-                throw "Unexpected select -> " + JSON.stringify(userSelect);
-        };
         this.allFields = params.allFields;
         this.allowedFields = params.allowedFields;
         this.allowedOrderByFields = params.allowedOrderByFields;
@@ -205,6 +59,160 @@ class SelectItemBuilder {
             throw "INTERNAL ERROR: Cannot have duplicate column names ( " + conflictingCol + " ). One or more computed column names are colliding with table columns ones";
         }
     }
+    checkField = (f, isSelected) => {
+        const allowedSelectedFields = this.allowedFieldsIncludingComputed;
+        const allowedNonSelectedFields = [...this.allowedFieldsIncludingComputed, ...this.allowedOrderByFields];
+        /** Not selected items can be part of the orderBy fields */
+        if (!(isSelected ? allowedSelectedFields : allowedNonSelectedFields).includes(f)) {
+            throw "Field " + f + " is invalid or dissallowed";
+        }
+        return f;
+    };
+    addItem = (item) => {
+        let fields = item.getFields();
+        // console.trace(fields)
+        if (fields === "*")
+            fields = this.allowedFields.slice(0);
+        fields.map(f => this.checkField(f, item.selected));
+        if (this.select.find(s => s.alias === item.alias)) {
+            throw `Cannot specify duplicate columns ( ${item.alias} ). Perhaps you're using "*" with column names?`;
+        }
+        this.select.push({ ...item, fields });
+    };
+    addFunction = (func, args, alias) => {
+        const funcDef = (0, Functions_1.parseFunction)({
+            func, args, functions: this.functions,
+            allowedFields: this.allowedFieldsIncludingComputed,
+        });
+        this.addItem({
+            type: funcDef.type,
+            alias,
+            getFields: () => funcDef.getFields(args),
+            getQuery: (tableAlias) => funcDef.getQuery({ allColumns: this.columns, allowedFields: this.allowedFields, args, tableAlias,
+                ctidField: undefined,
+                /* CTID not available in AFTER trigger */
+                // ctidField: this.isView? undefined : "ctid" 
+            }),
+            selected: true
+        });
+    };
+    addColumn = (fieldName, selected) => {
+        /* Check if computed col */
+        if (selected) {
+            const compCol = Functions_1.COMPUTED_FIELDS.find(cf => cf.name === fieldName);
+            if (compCol && !this.select.find(s => s.alias === fieldName)) {
+                const cf = {
+                    ...compCol,
+                    type: "computed",
+                    numArgs: 0,
+                    singleColArg: false,
+                    getFields: (args) => []
+                };
+                this.addFunction(cf, [], compCol.name);
+                return;
+            }
+        }
+        const colDef = this.columns.find(c => c.name === fieldName);
+        let alias = selected ? fieldName : ("not_selected_" + fieldName);
+        this.addItem({
+            type: "column",
+            columnPGDataType: colDef?.data_type,
+            column_udt_type: colDef?.udt_name,
+            alias,
+            getQuery: () => (0, prostgles_types_1.asName)(fieldName),
+            getFields: () => [fieldName],
+            selected
+        });
+    };
+    parseUserSelect = async (userSelect, joinParse) => {
+        /* Array select */
+        if (Array.isArray(userSelect)) {
+            if (userSelect.find(key => typeof key !== "string"))
+                throw "Invalid array select. Expecting an array of strings";
+            userSelect.map(key => this.addColumn(key, true));
+            /* Empty select */
+        }
+        else if (userSelect === "") {
+            // select.push({
+            //   type: "function",
+            //   alias: "",
+            //   getFields: () => [],
+            //   getQuery: () => ""
+            // })
+            return [];
+        }
+        else if (userSelect === "*") {
+            this.allowedFields.map(key => this.addColumn(key, true));
+        }
+        else if ((0, DboBuilder_1.isPlainObject)(userSelect) && !(0, prostgles_types_1.isEmpty)(userSelect)) {
+            const selectKeys = Object.keys(userSelect), selectValues = Object.values(userSelect);
+            /* Cannot include and exclude at the same time */
+            if (selectValues.filter(v => [0, false].includes(v)).length) {
+                if (selectValues.filter(v => ![0, false].includes(v)).length) {
+                    throw "\nCannot include and exclude fields at the same time";
+                }
+                /* Exclude only */
+                this.allowedFields.filter(f => !selectKeys.includes(f)).map(key => this.addColumn(key, true));
+            }
+            else {
+                await Promise.all(selectKeys.map(async (key) => {
+                    const val = userSelect[key], throwErr = (extraErr = "") => {
+                        console.trace(extraErr);
+                        throw "Unexpected select -> " + JSON.stringify({ [key]: val }) + "\n" + extraErr;
+                    };
+                    /* Included fields */
+                    if ([1, true].includes(val)) {
+                        if (key === "*") {
+                            this.allowedFields.map(key => this.addColumn(key, true));
+                        }
+                        else {
+                            this.addColumn(key, true);
+                        }
+                        /* Aggs and functions */
+                    }
+                    else if (typeof val === "string" || (0, DboBuilder_1.isPlainObject)(val)) {
+                        /* Function shorthand notation
+                            { id: "$max" } === { id: { $max: ["id"] } } === SELECT MAX(id) AS id
+                        */
+                        if ((typeof val === "string" && val !== "*") ||
+                            (0, DboBuilder_1.isPlainObject)(val) && Object.keys(val).length === 1 && Array.isArray(Object.values(val)[0]) // !isPlainObject(Object.values(val)[0])
+                        ) {
+                            // if(!Array.isArray(Object.values(val)[0])){
+                            //   throw `Could not parse selected item: ${JSON.stringify(val)}\nFunction arguments must be in an array`;
+                            // }
+                            let funcName, args;
+                            if (typeof val === "string") {
+                                /* Shorthand notation -> it is expected that the key is the column name used as the only argument */
+                                try {
+                                    this.checkField(key, true);
+                                }
+                                catch (err) {
+                                    throwErr(` Shorthand function notation error: the specifield column ( ${key} ) is invalid or dissallowed. \n Use correct column name or full aliased function notation, e.g.: -> { alias: { $func_name: ["column_name"] } } `);
+                                }
+                                funcName = val;
+                                args = [key];
+                                /** Function full notation { $funcName: ["colName", ...args] } */
+                            }
+                            else {
+                                ({ funcName, args } = (0, exports.parseFunctionObject)(val));
+                            }
+                            this.addFunction(funcName, args, key);
+                            /* Join */
+                        }
+                        else {
+                            if (!joinParse)
+                                throw "Joins dissalowed";
+                            await joinParse(key, val, throwErr);
+                        }
+                    }
+                    else
+                        throwErr();
+                }));
+            }
+        }
+        else
+            throw "Unexpected select -> " + JSON.stringify(userSelect);
+    };
 }
 exports.SelectItemBuilder = SelectItemBuilder;
 async function getNewQuery(_this, filter, selectParams = {}, param3_unused = null, tableRules, localParams, columns) {

package/lib/DboBuilder/TableHandler.js

@@ -12,28 +12,9 @@ const ViewHandler_1 = require("./ViewHandler");
 const parseUpdateRules_1 = require("./parseUpdateRules");
 const Functions_1 = require("./QueryBuilder/Functions");
 class TableHandler extends ViewHandler_1.ViewHandler {
+    io_stats;
     constructor(db, tableOrViewInfo, dboBuilder, t, dbTX, joinPaths) {
         super(db, tableOrViewInfo, dboBuilder, t, dbTX, joinPaths);
-        this.parseUpdateRules = parseUpdateRules_1.parseUpdateRules.bind(this);
-        this.update = update_1.update.bind(this);
-        this.insertDataParse = insertDataParse_1.insertDataParse;
-        this.prepareReturning = async (returning, allowedFields) => {
-            let result = [];
-            if (returning) {
-                let sBuilder = new QueryBuilder_1.SelectItemBuilder({
-                    allFields: this.column_names.slice(0),
-                    allowedFields,
-                    allowedOrderByFields: allowedFields,
-                    computedFields: Functions_1.COMPUTED_FIELDS,
-                    functions: Functions_1.FUNCTIONS.filter(f => f.type === "function" && f.singleColArg),
-                    isView: this.is_view,
-                    columns: this.columns,
-                });
-                await sBuilder.parseUserSelect(returning);
-                return sBuilder.select;
-            }
-            return result;
-        };
         this.remove = this.delete;
         this.io_stats = {
             since: Date.now(),
@@ -73,6 +54,8 @@ class TableHandler extends ViewHandler_1.ViewHandler {
             throw (0, DboBuilder_1.parseError)(e, `dbo.${this.name}.update()`);
         }
     }
+    parseUpdateRules = parseUpdateRules_1.parseUpdateRules.bind(this);
+    update = update_1.update.bind(this);
     validateNewData({ row, forcedData, allowedFields, tableRules, fixIssues = false }) {
         const synced_field = (tableRules ?? {})?.sync?.synced_field;
         /* Update synced_field if sync is on and missing */
@@ -95,9 +78,27 @@ class TableHandler extends ViewHandler_1.ViewHandler {
         });
         return { data, allowedCols: this.columns.filter(c => dataKeys.includes(c.name)).map(c => c.name) };
     }
+    insertDataParse = insertDataParse_1.insertDataParse;
     async insert(rowOrRows, param2, param3_unused, tableRules, _localParams) {
         return insert_1.insert.bind(this)(rowOrRows, param2, param3_unused, tableRules, _localParams);
     }
+    prepareReturning = async (returning, allowedFields) => {
+        let result = [];
+        if (returning) {
+            let sBuilder = new QueryBuilder_1.SelectItemBuilder({
+                allFields: this.column_names.slice(0),
+                allowedFields,
+                allowedOrderByFields: allowedFields,
+                computedFields: Functions_1.COMPUTED_FIELDS,
+                functions: Functions_1.FUNCTIONS.filter(f => f.type === "function" && f.singleColArg),
+                isView: this.is_view,
+                columns: this.columns,
+            });
+            await sBuilder.parseUserSelect(returning);
+            return sBuilder.select;
+        }
+        return result;
+    };
     makeReturnQuery(items) {
         if (items?.length)
             return " RETURNING " + items.map(s => s.getQuery() + " AS " + (0, prostgles_types_1.asName)(s.alias)).join(", ");

package/lib/DboBuilder/ViewHandler.js

@@ -13,6 +13,7 @@ const getColumns_1 = require("./getColumns");
 const subscribe_1 = require("./subscribe");
 const FILTER_FUNCS = Functions_1.FUNCTIONS.filter(f => f.canBeUsedForFilter);
 class ColSet {
+    opts;
     constructor(columns, tableName) {
         this.opts = { columns, tableName, colNames: columns.map(c => c.name) };
     }
@@ -99,14 +100,26 @@ class ColSet {
     }
 }
 class ViewHandler {
+    db;
+    name;
+    escapedName;
+    columns;
+    columnsForTypes;
+    column_names;
+    tableOrViewInfo; // TableOrViewInfo;
+    colSet;
+    tsColumnDefs = [];
+    joins;
+    joinGraph;
+    joinPaths;
+    dboBuilder;
+    t;
+    dbTX;
+    is_view = true;
+    filterDef = "";
+    // pubSubManager: PubSubManager;
+    is_media = false;
     constructor(db, tableOrViewInfo, dboBuilder, t, dbTX, joinPaths) {
-        this.tsColumnDefs = [];
-        this.is_view = true;
-        this.filterDef = "";
-        // pubSubManager: PubSubManager;
-        this.is_media = false;
-        // TODO: fix renamed table trigger problem
-        this.getColumns = getColumns_1.getColumns.bind(this);
         if (!db || !tableOrViewInfo)
             throw "";
         this.db = db;
@@ -282,7 +295,7 @@ class ViewHandler {
         /* Make the join chain info excluding root table */
         paths = (path || jp.path).slice(1).map((t2, i, arr) => {
             const t1 = i === 0 ? source : arr[i - 1];
-            this.joins ?? (this.joins = this.dboBuilder.joins);
+            this.joins ??= this.dboBuilder.joins;
             /* Get join options */
             const jo = this.joins.find(j => j.tables.includes(t1) && j.tables.includes(t2));
             if (!jo)
@@ -378,6 +391,8 @@ class ViewHandler {
             }
         };
     }
+    // TODO: fix renamed table trigger problem
+    getColumns = getColumns_1.getColumns.bind(this);
     getValidatedRules(tableRules, localParams) {
         if (localParams?.socket && !tableRules) {
             throw "INTERNAL ERROR: Unexpected case -> localParams && !tableRules";

package/lib/DboBuilder/runSQL.js

@@ -13,8 +13,8 @@ async function runSQL(query, params, options, localParams) {
         }
     }
     /** Cache types */
-    this.DATA_TYPES ?? (this.DATA_TYPES = await this.db.any("SELECT oid, typname FROM pg_type") ?? []);
-    this.USER_TABLES ?? (this.USER_TABLES = await this.db.any(`
+    this.DATA_TYPES ??= await this.db.any("SELECT oid, typname FROM pg_type") ?? [];
+    this.USER_TABLES ??= await this.db.any(`
     SELECT relid, relname, schemaname, array_to_json(array_agg(c.column_name) FILTER (WHERE c.column_name IS NOT NULL)) as pkey_columns
     FROM pg_catalog.pg_statio_user_tables t
     LEFT JOIN (
@@ -26,13 +26,13 @@ async function runSQL(query, params, options, localParams) {
     ) c
     ON t.relid = c.table_oid
     GROUP BY relid, relname, schemaname
-  `) ?? []);
-    this.USER_TABLE_COLUMNS ?? (this.USER_TABLE_COLUMNS = await this.db.any(`
+  `) ?? [];
+    this.USER_TABLE_COLUMNS ??= await this.db.any(`
     SELECT t.relid, t.schemaname,t.relname, c.column_name, c.udt_name, c.ordinal_position
     FROM information_schema.columns c
     INNER JOIN pg_catalog.pg_statio_user_tables t
     ON  c.table_schema = t.schemaname AND c.table_name = t.relname 
-  `));
+  `);
     if (!(await (0, exports.canRunSQL)(this.prostgles, localParams)))
         throw "Not allowed to run SQL";
     const { returnType, allowListen, hasParams = true } = options || {};