prostgles-server 2.0.145 → 2.0.148

package/dist/QueryBuilder.js

@@ -4,17 +4,70 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeQuery = exports.getNewQuery = exports.SelectItemBuilder = exports.COMPUTED_FIELDS = exports.FUNCTIONS = exports.asNameAlias = void 0;
+exports.makeQuery = exports.getNewQuery = exports.SelectItemBuilder = exports.COMPUTED_FIELDS = exports.FUNCTIONS = exports.parseFunction = exports.parseFunctionObject = exports.asNameAlias = void 0;
 const DboBuilder_1 = require("./DboBuilder");
-const Prostgles_1 = require("./Prostgles");
 const prostgles_types_1 = require("prostgles-types");
 const utils_1 = require("./utils");
-exports.asNameAlias = (field, tableAlias) => {
-    let result = prostgles_types_1.asName(field);
+const asNameAlias = (field, tableAlias) => {
+    let result = (0, prostgles_types_1.asName)(field);
     if (tableAlias)
-        return prostgles_types_1.asName(tableAlias) + "." + result;
+        return (0, prostgles_types_1.asName)(tableAlias) + "." + result;
     return result;
 };
+exports.asNameAlias = asNameAlias;
+const parseFunctionObject = (funcData) => {
+    const makeErr = (msg) => `Function not specified correctly. Expecting { $funcName: ["columnName",...] } object but got: ${JSON.stringify(funcData)} \n ${msg}`;
+    if (!(0, utils_1.isObject)(funcData))
+        throw makeErr("");
+    const keys = Object.keys(funcData);
+    if (keys.length !== 1)
+        throw makeErr("");
+    const funcName = keys[0];
+    const args = funcData[funcName];
+    if (!args || !Array.isArray(args)) {
+        throw makeErr("Arguments missing or invalid");
+    }
+    return { funcName, args };
+};
+exports.parseFunctionObject = parseFunctionObject;
+const parseFunction = (funcData) => {
+    const { func, args, functions, allowedFields } = funcData;
+    /* Function is computed column. No checks needed */
+    if (typeof func !== "string") {
+        const computedCol = exports.COMPUTED_FIELDS.find(c => c.name === func.name);
+        if (!computedCol)
+            throw `Unexpected function: computed column spec not found for ${JSON.stringify(func.name)}`;
+        return func;
+    }
+    const funcName = func;
+    const makeErr = (msg) => {
+        return `Issue with function ${JSON.stringify({ [funcName]: args })}: \n${msg}`;
+    };
+    /* Find function */
+    const funcDef = functions.find(f => f.name === funcName);
+    if (!funcDef) {
+        const sf = functions.filter(f => f.name.toLowerCase().slice(1).startsWith(funcName.toLowerCase())).sort((a, b) => (a.name.length - b.name.length));
+        const hint = (sf.length ? `. \n Maybe you meant: \n | ${sf.map(s => s.name + " " + (s.description || "")).join("    \n | ")}  ?` : "");
+        throw "\n Function " + funcName + " does not exist or is not allowed " + hint;
+    }
+    /* Validate fields */
+    const fields = funcDef.getFields(args);
+    if (fields !== "*") {
+        fields.forEach(fieldKey => {
+            if (typeof fieldKey !== "string" || !allowedFields.includes(fieldKey)) {
+                throw makeErr(`getFields() => field name ${JSON.stringify(fieldKey)} is invalid or disallowed`);
+            }
+        });
+        if ((funcDef.minCols ?? 0) > fields.length) {
+            throw makeErr(`Less columns provided than necessary (minCols=${funcDef.minCols})`);
+        }
+    }
+    if (funcDef.numArgs && funcDef.minCols !== 0 && fields !== "*" && Array.isArray(fields) && !fields.length) {
+        throw `\n Function "${funcDef.name}" expects at least a field name but has not been provided with one`;
+    }
+    return funcDef;
+};
+exports.parseFunction = parseFunction;
 const MAX_COL_NUM = 1600;
 const asValue = (v, castAs = "") => DboBuilder_1.pgp.as.format("$1" + castAs, [v]);
 const FTS_Funcs = 
@@ -36,12 +89,12 @@ const FTS_Funcs =
     numArgs: 2,
     getFields: (args) => [args[0]],
     getQuery: ({ allColumns, args, tableAlias }) => {
-        const col = prostgles_types_1.asName(args[0]);
+        const col = (0, prostgles_types_1.asName)(args[0]);
         let qVal = args[1], qType = "to_tsquery";
         let _type = type ? (asValue(type) + ",") : "";
         const searchTypes = prostgles_types_1.TextFilter_FullTextSearchFilterKeys;
         /* { to_tsquery: 'search term' } */
-        if (DboBuilder_1.isPlainObject(qVal)) {
+        if ((0, DboBuilder_1.isPlainObject)(qVal)) {
             const keys = Object.keys(qVal);
             if (!keys.length)
                 throw "Bad arg";
@@ -99,9 +152,11 @@ let PostGIS_Funcs = [
     getFields: (args) => [args[0]],
     getQuery: ({ allColumns, args, tableAlias }) => {
         const arg2 = args[1], mErr = () => { throw `${fname}: Expecting a second argument like: { lat?: number; lng?: number; geojson?: object; srid?: number; use_spheroid?: boolean }`; };
-        if (!DboBuilder_1.isPlainObject(arg2))
+        if (!(0, DboBuilder_1.isPlainObject)(arg2))
             mErr();
         const col = allColumns.find(c => c.name === args[0]);
+        if (!col)
+            throw new Error("Col not found: " + args[0]);
         const { lat, lng, srid = 4326, geojson, text, use_spheroid, distance, spheroid = 'SPHEROID["WGS 84",6378137,298.257223563]', debug } = arg2;
         let geomQ = "", extraParams = "";
         if (typeof text === "string") {
@@ -110,7 +165,7 @@ let PostGIS_Funcs = [
         else if ([lat, lng].every(v => Number.isFinite(v))) {
             geomQ = `ST_Point(${asValue(lng)}, ${asValue(lat)})`;
         }
-        else if (DboBuilder_1.isPlainObject(geojson)) {
+        else if ((0, DboBuilder_1.isPlainObject)(geojson)) {
             geomQ = `ST_GeomFromGeoJSON(${geojson})`;
         }
         else
@@ -168,12 +223,12 @@ let PostGIS_Funcs = [
         else if (fname === "<->") {
             colCast = colIsGeog ? "::geography" : "::geometry";
             geomQCast = colIsGeog ? "::geography" : "::geometry";
-            const q = DboBuilder_1.pgp.as.format(`${exports.asNameAlias(args[0], tableAlias)}${colCast} <-> ${geomQ}${geomQCast}`);
+            const q = DboBuilder_1.pgp.as.format(`${(0, exports.asNameAlias)(args[0], tableAlias)}${colCast} <-> ${geomQ}${geomQCast}`);
             if (debug)
                 throw q;
             return q;
         }
-        const q = DboBuilder_1.pgp.as.format(`${fname}(${exports.asNameAlias(args[0], tableAlias)}${colCast} , ${geomQ}${geomQCast} ${extraParams})`);
+        const q = DboBuilder_1.pgp.as.format(`${fname}(${(0, exports.asNameAlias)(args[0], tableAlias)}${colCast} , ${geomQ}${geomQCast} ${extraParams})`);
         if (debug)
             throw q;
         return q;
@@ -197,7 +252,7 @@ PostGIS_Funcs = PostGIS_Funcs.concat([
             const otherArgs = args.slice(1);
             if (otherArgs.length)
                 secondArg = ", " + otherArgs.map(arg => asValue(arg)).join(", ");
-            const escTabelName = exports.asNameAlias(args[0], tableAlias) + "::geometry";
+            const escTabelName = (0, exports.asNameAlias)(args[0], tableAlias) + "::geometry";
             let result = DboBuilder_1.pgp.as.format(fname + "(" + escTabelName + secondArg + (fname === "ST_AsGeoJSON" ? ")::jsonb" : ")"));
             if (fname.startsWith("ST_SnapToGrid") || fname.startsWith("ST_Simplify")) {
                 let r = `ST_AsGeoJSON(${result})::jsonb`;
@@ -220,7 +275,7 @@ PostGIS_Funcs = PostGIS_Funcs.concat(["ST_Extent", "ST_3DExtent", "ST_XMin_Agg",
         numArgs: 1,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const escTabelName = exports.asNameAlias(args[0], tableAlias) + "::geometry";
+            const escTabelName = (0, exports.asNameAlias)(args[0], tableAlias) + "::geometry";
             if (fname.includes("Extent")) {
                 return `${fname}(${escTabelName})`;
             }
@@ -242,7 +297,7 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("md5(" + args.map(fname => "COALESCE( " + exports.asNameAlias(fname, tableAlias) + "::text, '' )").join(" || ") + ")");
+            const q = DboBuilder_1.pgp.as.format("md5(" + args.map(fname => "COALESCE( " + (0, exports.asNameAlias)(fname, tableAlias) + "::text, '' )").join(" || ") + ")");
             return q;
         }
     },
@@ -254,7 +309,7 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("md5(string_agg(" + args.map(fname => "COALESCE( " + exports.asNameAlias(fname, tableAlias) + "::text, '' )").join(" || ") + ", ','))");
+            const q = DboBuilder_1.pgp.as.format("md5(string_agg(" + args.map(fname => "COALESCE( " + (0, exports.asNameAlias)(fname, tableAlias) + "::text, '' )").join(" || ") + ", ','))");
             return q;
         }
     },
@@ -266,7 +321,7 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha256((" + args.map(fname => "COALESCE( " + exports.asNameAlias(fname, tableAlias) + ", '' )").join(" || ") + ")::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha256((" + args.map(fname => "COALESCE( " + (0, exports.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ")::text::bytea), 'hex')");
             return q;
         }
     },
@@ -278,7 +333,7 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha256(string_agg(" + args.map(fname => "COALESCE( " + exports.asNameAlias(fname, tableAlias) + ", '' )").join(" || ") + ", ',')::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha256(string_agg(" + args.map(fname => "COALESCE( " + (0, exports.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ", ',')::text::bytea), 'hex')");
             return q;
         }
     },
@@ -290,7 +345,7 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha512((" + args.map(fname => "COALESCE( " + exports.asNameAlias(fname, tableAlias) + ", '' )").join(" || ") + ")::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha512((" + args.map(fname => "COALESCE( " + (0, exports.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ")::text::bytea), 'hex')");
             return q;
         }
     },
@@ -302,7 +357,7 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha512(string_agg(" + args.map(fname => "COALESCE( " + exports.asNameAlias(fname, tableAlias) + ", '' )").join(" || ") + ", ',')::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha512(string_agg(" + args.map(fname => "COALESCE( " + (0, exports.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ", ',')::text::bytea), 'hex')");
             return q;
         }
     },
@@ -316,7 +371,7 @@ exports.FUNCTIONS = [
         singleColArg: false,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return DboBuilder_1.pgp.as.format("LEFT(" + exports.asNameAlias(args[0], tableAlias) + ", $1)", [args[1]]);
+            return DboBuilder_1.pgp.as.format("LEFT(" + (0, exports.asNameAlias)(args[0], tableAlias) + ", $1)", [args[1]]);
         }
     },
     {
@@ -327,7 +382,7 @@ exports.FUNCTIONS = [
         singleColArg: true,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return DboBuilder_1.pgp.as.format("unnest(string_to_array(" + exports.asNameAlias(args[0], tableAlias) + "::TEXT , ' '))"); //, [args[1]]
+            return DboBuilder_1.pgp.as.format("unnest(string_to_array(" + (0, exports.asNameAlias)(args[0], tableAlias) + "::TEXT , ' '))"); //, [args[1]]
         }
     },
     {
@@ -338,7 +393,7 @@ exports.FUNCTIONS = [
         singleColArg: false,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return DboBuilder_1.pgp.as.format("RIGHT(" + exports.asNameAlias(args[0], tableAlias) + ", $1)", [args[1]]);
+            return DboBuilder_1.pgp.as.format("RIGHT(" + (0, exports.asNameAlias)(args[0], tableAlias) + ", $1)", [args[1]]);
         }
     },
     {
@@ -350,9 +405,9 @@ exports.FUNCTIONS = [
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
             if (args.length === 3) {
-                return DboBuilder_1.pgp.as.format("to_char(" + exports.asNameAlias(args[0], tableAlias) + ", $2, $3)", [args[0], args[1], args[2]]);
+                return DboBuilder_1.pgp.as.format("to_char(" + (0, exports.asNameAlias)(args[0], tableAlias) + ", $2, $3)", [args[0], args[1], args[2]]);
             }
-            return DboBuilder_1.pgp.as.format("to_char(" + exports.asNameAlias(args[0], tableAlias) + ", $2)", [args[0], args[1]]);
+            return DboBuilder_1.pgp.as.format("to_char(" + (0, exports.asNameAlias)(args[0], tableAlias) + ", $2)", [args[0], args[1]]);
         }
     },
     /**
@@ -412,7 +467,7 @@ exports.FUNCTIONS = [
         numArgs: 1,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const col = exports.asNameAlias(args[0], tableAlias);
+            const col = (0, exports.asNameAlias)(args[0], tableAlias);
             if (!val)
                 return `date_trunc(${asValue(unit)}, ${col})`;
             const prevInt = {
@@ -435,7 +490,7 @@ exports.FUNCTIONS = [
         singleColArg: false,
         getFields: (args) => [args[1]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return `${funcName}(${asValue(args[0])}, ${exports.asNameAlias(args[1], tableAlias)})`;
+            return `${funcName}(${asValue(args[0])}, ${(0, exports.asNameAlias)(args[1], tableAlias)})`;
         }
     })),
     /* Handy date funcs */
@@ -474,18 +529,42 @@ exports.FUNCTIONS = [
         numArgs: 1,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return DboBuilder_1.pgp.as.format("trim(to_char(" + exports.asNameAlias(args[0], tableAlias) + ", $2))", [args[0], txt]);
+            return DboBuilder_1.pgp.as.format("trim(to_char(" + (0, exports.asNameAlias)(args[0], tableAlias) + ", $2))", [args[0], txt]);
         }
     })),
     /* Basic 1 arg col funcs */
-    ...["upper", "lower", "length", "reverse", "trim", "initcap", "round", "ceil", "floor", "sign", "age", "md5"].map(funcName => ({
+    ...["upper", "lower", "length", "reverse", "trim", "initcap", "round", "ceil", "floor", "sign", "md5"].map(funcName => ({
         name: "$" + funcName,
         type: "function",
         numArgs: 1,
         singleColArg: true,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return funcName + "(" + exports.asNameAlias(args[0], tableAlias) + ")";
+            return funcName + "(" + (0, exports.asNameAlias)(args[0], tableAlias) + ")";
+        }
+    })),
+    /* Interval funcs */
+    ...["age", "difference"].map(funcName => ({
+        name: "$" + funcName,
+        type: "function",
+        numArgs: 1,
+        singleColArg: true,
+        getFields: (args) => args,
+        getQuery: ({ allowedFields, args, tableAlias }) => {
+            const validCols = args.filter(a => typeof a === "string").length;
+            if (funcName === "difference" && validCols !== 2)
+                throw new Error("Must have two column names");
+            if (![1, 2].includes(validCols))
+                throw new Error("Must have one or two column names");
+            const [leftField, rightField] = args;
+            const leftQ = (0, exports.asNameAlias)(leftField, tableAlias);
+            const rightQ = rightField ? ("," + (0, exports.asNameAlias)(rightField, tableAlias)) : "";
+            if (funcName === "age") {
+                return `${funcName}(${leftQ}, ${rightQ})`;
+            }
+            else {
+                return `${leftQ} - ${rightQ}`;
+            }
         }
     })),
     /* pgcrypto funcs */
@@ -496,7 +575,7 @@ exports.FUNCTIONS = [
         singleColArg: false,
         getFields: (args) => [args[1]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const value = asValue(args[0]) + "", seedColumnName = exports.asNameAlias(args[1], tableAlias);
+            const value = asValue(args[0]) + "", seedColumnName = (0, exports.asNameAlias)(args[1], tableAlias);
             return `crypt(${value}, ${seedColumnName}::text)`;
         }
     })),
@@ -508,7 +587,7 @@ exports.FUNCTIONS = [
         singleColArg: false,
         getFields: (args) => [args[1]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            let a1 = asValue(args[0]), a2 = exports.asNameAlias(args[1], tableAlias);
+            let a1 = asValue(args[0]), a2 = (0, exports.asNameAlias)(args[1], tableAlias);
             if (funcName === "position_lower") {
                 a1 = `LOWER(${a1}::text)`;
                 a2 = `LOWER(${a2}::text)`;
@@ -522,7 +601,7 @@ exports.FUNCTIONS = [
         numArgs: 1,
         minCols: 0,
         singleColArg: false,
-        getFields: (args, allowedFields) => allowedFields.filter(fName => { var _a; return (_a = args === null || args === void 0 ? void 0 : args[0]) === null || _a === void 0 ? void 0 : _a.includes(`{${fName}}`); }),
+        getFields: (args) => [],
         getQuery: ({ allowedFields, args, tableAlias }) => {
             let value = asValue(args[0]);
             if (typeof value !== "string")
@@ -533,7 +612,7 @@ exports.FUNCTIONS = [
             });
             value = asValue(value);
             if (usedColumns.length) {
-                return `format(${value}, ${usedColumns.map(c => `${exports.asNameAlias(c, tableAlias)}::TEXT`).join(", ")})`;
+                return `format(${value}, ${usedColumns.map(c => `${(0, exports.asNameAlias)(c, tableAlias)}::TEXT`).join(", ")})`;
             }
             return `format(${value})`;
         }
@@ -556,7 +635,7 @@ exports.FUNCTIONS = [
             let term = args[1];
             const rawTerm = args[1];
             let { edgeTruncate, noFields = false, returnType, matchCase = false } = args[2] || {};
-            if (!prostgles_types_1.isEmpty(args[2])) {
+            if (!(0, prostgles_types_1.isEmpty)(args[2])) {
                 const keys = Object.keys(args[2]);
                 const validKeys = ["edgeTruncate", "noFields", "returnType", "matchCase"];
                 const bad_keys = keys.filter(k => !validKeys.includes(k));
@@ -600,7 +679,7 @@ exports.FUNCTIONS = [
           END
         `;
             };
-            let colRaw = "( " + cols.map(c => `${noFields ? "" : (asValue(c + ": ") + " || ")} COALESCE(${exports.asNameAlias(c, tableAlias)}::TEXT, '')`).join(" || ', ' || ") + " )";
+            let colRaw = "( " + cols.map(c => `${noFields ? "" : (asValue(c + ": ") + " || ")} COALESCE(${(0, exports.asNameAlias)(c, tableAlias)}::TEXT, '')`).join(" || ', ' || ") + " )";
             let col = colRaw;
             term = asValue(term);
             if (!matchCase) {
@@ -632,7 +711,7 @@ exports.FUNCTIONS = [
                 let _cols = validCols.filter(c => 
                 /** Exclude numeric columns when the search tern contains a character */
                 !hasChars ||
-                    DboBuilder_1.postgresToTsType(c.colInfo.udt_name) !== "number");
+                    (0, DboBuilder_1.postgresToTsType)(c.colInfo.udt_name) !== "number");
                 /** This will break GROUP BY (non-integer constant in GROUP BY) */
                 if (!_cols.length) {
                     if (validCols.length && hasChars)
@@ -642,11 +721,10 @@ exports.FUNCTIONS = [
                 res = `CASE 
           ${_cols
                     .map(c => {
-                    var _a, _b;
-                    const colNameEscaped = exports.asNameAlias(c.key, tableAlias);
+                    const colNameEscaped = (0, exports.asNameAlias)(c.key, tableAlias);
                     let colSelect = `${colNameEscaped}::TEXT`;
-                    const isTstamp = (_a = c.colInfo) === null || _a === void 0 ? void 0 : _a.udt_name.startsWith("timestamp");
-                    if (isTstamp || ((_b = c.colInfo) === null || _b === void 0 ? void 0 : _b.udt_name) === "date") {
+                    const isTstamp = c.colInfo?.udt_name.startsWith("timestamp");
+                    if (isTstamp || c.colInfo?.udt_name === "date") {
                         colSelect = `( CASE WHEN ${colNameEscaped} IS NULL THEN '' 
               ELSE concat_ws(' ', 
               ${colNameEscaped}::TEXT, 
@@ -701,7 +779,7 @@ exports.FUNCTIONS = [
             if (args.length > 1) {
                 extraArgs = DboBuilder_1.pgp.as.format(", $1:csv", args.slice(1));
             }
-            return aggName + "(" + exports.asNameAlias(args[0], tableAlias) + `${extraArgs})`;
+            return aggName + "(" + (0, exports.asNameAlias)(args[0], tableAlias) + `${extraArgs})`;
         }
     })),
     /* More aggs */
@@ -723,7 +801,7 @@ exports.FUNCTIONS = [
         singleColArg: true,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            const col = exports.asNameAlias(args[0], tableAlias);
+            const col = (0, exports.asNameAlias)(args[0], tableAlias);
             return `round( ( ( MAX(${col}) - MIN(${col}) )::float/MIN(${col}) ) * 100, 2)`;
         }
     }
@@ -743,7 +821,7 @@ exports.COMPUTED_FIELDS = [
                     /* CTID not available in AFTER trigger */
                     // .concat(ctidField? [ctidField] : [])
                     .sort()
-                    .map(f => exports.asNameAlias(f, tableAlias))
+                    .map(f => (0, exports.asNameAlias)(f, tableAlias))
                     .map(f => `md5(coalesce(${f}::text, 'dd'))`)
                     .join(" || ") +
                 `)`;
@@ -778,29 +856,19 @@ class SelectItemBuilder {
                 throw `Cannot specify duplicate columns ( ${item.alias} ). Perhaps you're using "*" with column names?`;
             this.select.push(item);
         };
-        this.addFunctionByName = (funcName, args, alias) => {
-            const funcDef = this.functions.find(f => f.name === funcName);
-            if (!funcDef) {
-                const sf = this.functions.filter(f => f.name.toLowerCase().slice(1).startsWith(funcName.toLowerCase())).sort((a, b) => (a.name.length - b.name.length));
-                const hint = (sf.length ? `. \n Maybe you meant: \n | ${sf.map(s => s.name + " " + (s.description || "")).join("    \n | ")}  ?` : "");
-                throw "\n Function " + funcName + " does not exist or is not allowed " + hint;
-            }
-            this.addFunction(funcDef, args, alias);
-        };
-        this.addFunction = (funcDef, args, alias) => {
-            if (funcDef.numArgs) {
-                const fields = funcDef.getFields(args, this.allowedFields);
-                if (funcDef.minCols !== 0 && fields !== "*" && Array.isArray(fields) && !fields.length) {
-                    console.log(fields);
-                    throw `\n Function "${funcDef.name}" expects at least a field name but has not been provided with one`;
-                }
-            }
+        this.addFunction = (func, args, alias) => {
+            const funcDef = (0, exports.parseFunction)({
+                func, args, functions: this.functions,
+                allowedFields: this.allowedFieldsIncludingComputed,
+            });
             this.addItem({
                 type: funcDef.type,
                 alias,
-                getFields: () => funcDef.getFields(args, this.allowedFields),
+                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
             });
@@ -810,7 +878,13 @@ class SelectItemBuilder {
             if (selected) {
                 const compCol = exports.COMPUTED_FIELDS.find(cf => cf.name === fieldName);
                 if (compCol && !this.select.find(s => s.alias === fieldName)) {
-                    const cf = Object.assign(Object.assign({}, compCol), { type: "computed", numArgs: 0, singleColArg: false, getFields: (args) => [] });
+                    const cf = {
+                        ...compCol,
+                        type: "computed",
+                        numArgs: 0,
+                        singleColArg: false,
+                        getFields: (args) => []
+                    };
                     this.addFunction(cf, [], compCol.name);
                     return;
                 }
@@ -819,10 +893,10 @@ class SelectItemBuilder {
             let alias = selected ? fieldName : ("not_selected_" + fieldName);
             this.addItem({
                 type: "column",
-                columnPGDataType: colDef === null || colDef === void 0 ? void 0 : colDef.data_type,
-                column_udt_type: colDef === null || colDef === void 0 ? void 0 : colDef.udt_name,
+                columnPGDataType: colDef?.data_type,
+                column_udt_type: colDef?.udt_name,
                 alias,
-                getQuery: () => prostgles_types_1.asName(fieldName),
+                getQuery: () => (0, prostgles_types_1.asName)(fieldName),
                 getFields: () => [fieldName],
                 selected
             });
@@ -847,7 +921,7 @@ class SelectItemBuilder {
             else if (userSelect === "*") {
                 this.allowedFields.map(key => this.addColumn(key, true));
             }
-            else if (DboBuilder_1.isPlainObject(userSelect) && !prostgles_types_1.isEmpty(userSelect)) {
+            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) {
@@ -873,12 +947,12 @@ class SelectItemBuilder {
                             }
                             /* Aggs and functions */
                         }
-                        else if (typeof val === "string" || DboBuilder_1.isPlainObject(val)) {
+                        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 !== "*") ||
-                                DboBuilder_1.isPlainObject(val) && Object.keys(val).length === 1 && Array.isArray(Object.values(val)[0]) // !isPlainObject(Object.values(val)[0])
+                                (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`;
@@ -894,15 +968,12 @@ class SelectItemBuilder {
                                     }
                                     funcName = val;
                                     args = [key];
+                                    /** Function full notation { $funcName: ["colName", ...args] } */
                                 }
                                 else {
-                                    const callKeys = Object.keys(val);
-                                    if (callKeys.length !== 1 || !Array.isArray(val[callKeys[0]]))
-                                        throw "\nIssue with select. \nUnexpected function definition. \nExpecting { field_name: func_name } OR { result_key: { func_name: [arg1, arg2 ...] } } \nBut got -> " + JSON.stringify({ [key]: val });
-                                    funcName = callKeys[0];
-                                    args = val[funcName];
+                                    ({ funcName, args } = (0, exports.parseFunctionObject)(val));
                                 }
-                                this.addFunctionByName(funcName, args, key);
+                                this.addFunction(funcName, args, key);
                                 /* Join */
                             }
                             else {
@@ -937,8 +1008,8 @@ class SelectItemBuilder {
     }
 }
 exports.SelectItemBuilder = SelectItemBuilder;
-async function getNewQuery(_this, filter, selectParams, param3_unused = null, tableRules, localParams, columns) {
-    if (((localParams === null || localParams === void 0 ? void 0 : localParams.socket) || (localParams === null || localParams === void 0 ? void 0 : localParams.httpReq)) && !utils_1.get(tableRules, "select.fields")) {
+async function getNewQuery(_this, filter, selectParams = {}, param3_unused = null, tableRules, localParams, columns) {
+    if ((localParams?.socket || localParams?.httpReq) && !(0, utils_1.get)(tableRules, "select.fields")) {
         throw `INTERNAL ERROR: publish.${_this.name}.select.fields rule missing`;
     }
     // const all_columns: SelectItem[] = _this.column_names.slice(0).map(fieldName => ({
@@ -958,11 +1029,10 @@ async function getNewQuery(_this, filter, selectParams, param3_unused = null, ta
     // let select: SelectItem[] = [],
     let joinQueries = [];
     // const all_colnames = _this.column_names.slice(0).concat(COMPUTED_FIELDS.map(c => c.name));
-    selectParams = selectParams || {};
     const { select: userSelect = "*" } = selectParams, 
     // allCols = _this.column_names.slice(0),
     // allFieldsIncludingComputed = allCols.concat(COMPUTED_FIELDS.map(c => c.name)),
-    allowedFields = _this.parseFieldFilter(utils_1.get(tableRules, "select.fields")) || _this.column_names.slice(0), 
+    allowedFields = _this.parseFieldFilter((0, utils_1.get)(tableRules, "select.fields")) || _this.column_names.slice(0), 
     // allowedFieldsIncludingComputed = _this.parseFieldFilter(get(tableRules, "select.fields"), true, allFieldsIncludingComputed) || allFieldsIncludingComputed,
     sBuilder = new SelectItemBuilder({ allowedFields, computedFields: exports.COMPUTED_FIELDS, isView: _this.is_view, functions: exports.FUNCTIONS, allFields: _this.column_names.slice(0), columns });
     await sBuilder.parseUserSelect(userSelect, async (key, val, throwErr) => {
@@ -1003,6 +1073,8 @@ async function getNewQuery(_this, filter, selectParams, param3_unused = null, ta
                 j_table = key;
             }
         }
+        if (!j_table)
+            throw "j_table missing";
         const _thisJoinedTable = _this.dboBuilder.dbo[j_table];
         if (!_thisJoinedTable) {
             throw `Joined table ${JSON.stringify(j_table)} is disallowed or inexistent \nOr you've forgot to put the function arguments into an array`;
@@ -1010,10 +1082,10 @@ async function getNewQuery(_this, filter, selectParams, param3_unused = null, ta
         let isLocal = true;
         if (localParams && (localParams.socket || localParams.httpReq)) {
             isLocal = false;
-            j_tableRules = await _this.dboBuilder.publishParser.getValidatedRequestRuleWusr({ tableName: j_table, command: "find", localParams });
+            j_tableRules = await _this.dboBuilder.publishParser?.getValidatedRequestRuleWusr({ tableName: j_table, command: "find", localParams });
         }
         if (isLocal || j_tableRules) {
-            const joinQuery = await getNewQuery(_thisJoinedTable, j_filter, Object.assign(Object.assign({}, j_selectParams), { alias: j_alias }), param3_unused, j_tableRules, localParams, columns);
+            const joinQuery = await getNewQuery(_thisJoinedTable, j_filter, { ...j_selectParams, alias: j_alias }, param3_unused, j_tableRules, localParams, columns);
             joinQuery.isLeftJoin = j_isLeftJoin;
             joinQuery.tableAlias = j_alias;
             joinQuery.$path = j_path;
@@ -1035,8 +1107,8 @@ async function getNewQuery(_this, filter, selectParams, param3_unused = null, ta
     const where = await _this.prepareWhere({
         filter,
         select,
-        forcedFilter: utils_1.get(tableRules, "select.forcedFilter"),
-        filterFields: utils_1.get(tableRules, "select.filterFields"),
+        forcedFilter: (0, utils_1.get)(tableRules, "select.forcedFilter"),
+        filterFields: (0, utils_1.get)(tableRules, "select.filterFields"),
         tableAlias: selectParams.alias,
         localParams,
         tableRule: tableRules
@@ -1050,7 +1122,7 @@ async function getNewQuery(_this, filter, selectParams, param3_unused = null, ta
         where,
         // having: cond.having,
         limit: _this.prepareLimitQuery(selectParams.limit, p),
-        orderBy: [_this.prepareSort(selectParams.orderBy, allowedFields, selectParams.alias, null, select)],
+        orderBy: [_this.prepareSort(selectParams.orderBy, allowedFields, selectParams.alias, undefined, select)],
         offset: _this.prepareOffsetQuery(selectParams.offset)
     };
     // console.log(resQuery);
@@ -1059,24 +1131,24 @@ async function getNewQuery(_this, filter, selectParams, param3_unused = null, ta
 }
 exports.getNewQuery = getNewQuery;
 /* No validation/authorisation at this point */
-function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
+function makeQuery(_this, q, depth = 0, joinFields = [], selectParams = {}) {
     const PREF = `prostgles`, joins = q.joins || [], 
     // aggs = q.aggs || [],
-    makePref = (q) => !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`, makePrefANON = (joinAlias, table) => prostgles_types_1.asName(!joinAlias ? table : `${joinAlias || ""}_${table}`), makePrefAN = (q) => prostgles_types_1.asName(makePref(q));
+    makePref = (q) => !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`, makePrefANON = (joinAlias, table) => (0, prostgles_types_1.asName)(!joinAlias ? table : `${joinAlias || ""}_${table}`), makePrefAN = (q) => (0, prostgles_types_1.asName)(makePref(q));
     const indentLine = (numInd, str, indentStr = "    ") => new Array(numInd).fill(indentStr).join("") + str;
     const indStr = (numInd, str) => str.split("\n").map(s => indentLine(numInd, s)).join("\n");
     const indjArr = (numInd, strArr, indentStr = "    ") => strArr.map(str => indentLine(numInd, str));
     const indJ = (numInd, strArr, separator = " \n ", indentStr = "    ") => indjArr(numInd, strArr, indentStr).join(separator);
     const selectArrComma = (strArr) => strArr.map((s, i, arr) => s + (i < arr.length - 1 ? " , " : " "));
-    const prefJCAN = (q, str) => prostgles_types_1.asName(`${q.tableAlias || q.table}_${PREF}_${str}`);
+    const prefJCAN = (q, str) => (0, prostgles_types_1.asName)(`${q.tableAlias || q.table}_${PREF}_${str}`);
     // const indent = (a, b) => a;
     const joinTables = (q1, q2) => {
         const joinInfo = _this.getJoins(q1.table, q2.table, q2.$path, true);
         const paths = joinInfo.paths;
-        return Prostgles_1.flat(paths.map(({ table, on }, i) => {
+        return paths.flatMap(({ table, on }, i) => {
             const getColName = (col, q) => {
                 if (table === q.table) {
-                    const colFromSelect = q.select.find(s => s.getQuery() === prostgles_types_1.asName(col));
+                    const colFromSelect = q.select.find(s => s.getQuery() === (0, prostgles_types_1.asName)(col));
                     if (!colFromSelect) {
                         console.error(`${col} column might be missing in user publish `);
                         throw `Could not find join column (${col}) in allowe select. Some join tables and columns might be invalid/dissallowed`;
@@ -1098,7 +1170,7 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
             const prevAlias = i === 0 ? makePrefAN(q1) : makePrefANON(q2.tableAlias, prevTable);
             // If root then prev table is aliased from root query. Alias from join otherwise
             let iQ = [
-                prostgles_types_1.asName(table) + ` ${thisAlias}`
+                (0, prostgles_types_1.asName)(table) + ` ${thisAlias}`
             ];
             /* If target table then add filters, options, etc */
             if (i === paths.length - 1) {
@@ -1112,10 +1184,10 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
                 const targetSelect = q2.select.filter(s => s.selected).map(s => {
                     /* Rename aggs to avoid collision with join cols */
                     if (s.type === "aggregation")
-                        return prostgles_types_1.asName(`agg_${s.alias}`) + " AS " + prostgles_types_1.asName(s.alias);
-                    return prostgles_types_1.asName(s.alias);
-                }).concat(q2.joins.map(j => prostgles_types_1.asName(j.table))).join(", ");
-                const _iiQ = makeQuery(_this, q2, depth + 1, on.map(([c1, c2]) => prostgles_types_1.asName(c2)), selectParams);
+                        return (0, prostgles_types_1.asName)(`agg_${s.alias}`) + " AS " + (0, prostgles_types_1.asName)(s.alias);
+                    return (0, prostgles_types_1.asName)(s.alias);
+                }).concat(q2.joins?.map(j => (0, prostgles_types_1.asName)(j.table)) ?? []).join(", ");
+                const _iiQ = makeQuery(_this, q2, depth + 1, on.map(([c1, c2]) => (0, prostgles_types_1.asName)(c2)), selectParams);
                 // const iiQ = flat(_iiQ.split("\n")); // prettify for debugging
                 // console.log(_iiQ)
                 const iiQ = [_iiQ];
@@ -1128,7 +1200,7 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
                         `row_to_json((select x from (SELECT ${targetSelect}) as x)) AS ${prefJCAN(q2, `json`)}`,
                         `FROM (`,
                         ...iiQ,
-                        `) ${prostgles_types_1.asName(q2.table)}    `
+                        `) ${(0, prostgles_types_1.asName)(q2.table)}    `
                     ]),
                     `) ${thisAlias}`
                 ];
@@ -1136,10 +1208,10 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
             let jres = [
                 `${q2.isLeftJoin ? "LEFT" : "INNER"} JOIN `,
                 ...iQ,
-                `ON ${on.map(([c1, c2]) => `${prevAlias}.${prostgles_types_1.asName(getPrevColName(c1))} = ${thisAlias}.${prostgles_types_1.asName(getThisColName(c2))} `).join(" AND ")}`
+                `ON ${on.map(([c1, c2]) => `${prevAlias}.${(0, prostgles_types_1.asName)(getPrevColName(c1))} = ${thisAlias}.${(0, prostgles_types_1.asName)(getThisColName(c2))} `).join(" AND ")}`
             ];
             return jres;
-        }));
+        });
     };
     const getGroupBy = (rootSelectItems, groupByItems) => {
         if (groupByItems.length) {
@@ -1161,7 +1233,7 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
         let groupBy = "";
         const rootSelectItems = q.select.filter(s => joinFields.includes(s.getQuery()) || s.selected);
         /* If aggs exist need to set groupBy add joinFields into select */
-        if (aggs.length || (selectParams === null || selectParams === void 0 ? void 0 : selectParams.groupBy)) {
+        if (aggs.length || selectParams?.groupBy) {
             // const missingFields = joinFields.filter(jf => !q.select.find(s => s.type === "column" && s.alias === jf));
             // if(depth && missingFields.length){
             //     // select = Array.from(new Set(missingFields.concat(select)));
@@ -1183,11 +1255,11 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
                 // return s.getQuery() + ((s.type !== "column")? (" AS " + s.alias) : "")
                 if (s.type === "aggregation") {
                     /* Rename aggs to avoid collision with join cols */
-                    return s.getQuery() + " AS " + prostgles_types_1.asName((depth ? "agg_" : "") + s.alias);
+                    return s.getQuery() + " AS " + (0, prostgles_types_1.asName)((depth ? "agg_" : "") + s.alias);
                 }
-                return s.getQuery() + " AS " + prostgles_types_1.asName(s.alias);
+                return s.getQuery() + " AS " + (0, prostgles_types_1.asName)(s.alias);
             }).join(", "),
-            `FROM ${prostgles_types_1.asName(q.table)} `,
+            `FROM ${(0, prostgles_types_1.asName)(q.table)} `,
             q.where,
             groupBy //!aggs.length? "" : `GROUP BY ${nonAggs.map(sf => asName(sf.alias)).join(", ")}`,
             ,
@@ -1214,8 +1286,8 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
         // console.log({ aggs, nonAggs, joins: q.joins })
         // rootGroupBy = getGroupBy(rootSelectItems, depth? rootSelectItems : nonAggs) + (aggs?.length? "" : ", ctid")
         rootGroupBy = `GROUP BY ${(depth ?
-            q.allFields.map(f => prostgles_types_1.asName(f)) :
-            nonAggs.map(s => s.type === "function" ? s.getQuery() : prostgles_types_1.asName(s.alias))).concat((aggs && aggs.length) ?
+            q.allFields.map(f => (0, prostgles_types_1.asName)(f)) :
+            nonAggs.map(s => s.type === "function" ? s.getQuery() : (0, prostgles_types_1.asName)(s.alias))).concat((aggs && aggs.length) ?
             [] :
             [`ctid`]).filter(s => s).join(", ")} `;
     }
@@ -1224,10 +1296,10 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
         " \n",
         `-- 0. [joined root]  `,
         "SELECT    ",
-        ...selectArrComma(rootSelectItems.map(s => s.getQuery() + " AS " + prostgles_types_1.asName(s.alias)).concat(joins.map((j, i) => {
+        ...selectArrComma(rootSelectItems.map(s => s.getQuery() + " AS " + (0, prostgles_types_1.asName)(s.alias)).concat(joins.map((j, i) => {
             /** Apply LIMIT to joined items */
             const jsq = `json_agg(${prefJCAN(j, `json`)}::jsonb ORDER BY ${prefJCAN(j, `rowid_sorted`)}) FILTER (WHERE ${prefJCAN(j, `limit`)} <= ${j.limit} AND ${prefJCAN(j, `dupes_rowid`)} = 1 AND ${prefJCAN(j, `json`)} IS NOT NULL)`;
-            const resAlias = prostgles_types_1.asName(j.tableAlias || j.table);
+            const resAlias = (0, prostgles_types_1.asName)(j.tableAlias || j.table);
             // If limit = 1 then return a single json object (first one)
             return (j.limit === 1 ? `${jsq}->0 ` : `COALESCE(${jsq}, '[]') `) + `  AS ${resAlias}`;
         }))),
@@ -1244,18 +1316,18 @@ function makeQuery(_this, q, depth = 0, joinFields = [], selectParams) {
                 "-- 2. [source full select + ctid to group by] ",
                 "SELECT ",
                 ...selectArrComma(q.allFields.concat(["ctid"])
-                    .map(field => `${makePrefAN(q)}.${prostgles_types_1.asName(field)}  `)
+                    .map(field => `${makePrefAN(q)}.${(0, prostgles_types_1.asName)(field)}  `)
                     .concat(joins.map((j, i) => makePrefAN(j) + "." + prefJCAN(j, `json`) + ", " + makePrefAN(j) + "." + prefJCAN(j, `rowid_sorted`)).concat(joins.map(j => `row_number() over(partition by ${makePrefAN(j)}.${prefJCAN(j, `rowid_sorted`)}, ${makePrefAN(q)}.ctid ) AS ${prefJCAN(j, `dupes_rowid`)}`)))),
                 `FROM ( `,
                 ...indjArr(depth + 1, [
                     "-- 3. [source table] ",
                     "SELECT ",
                     "*, row_number() over() as ctid ",
-                    `FROM ${prostgles_types_1.asName(q.table)} `,
+                    `FROM ${(0, prostgles_types_1.asName)(q.table)} `,
                     `${q.where} `
                 ]),
                 `) ${makePrefAN(q)} `,
-                ...Prostgles_1.flat(joins.map((j, i) => joinTables(q, j)))
+                ...joins.flatMap((j, i) => joinTables(q, j))
             ]),
             ") t1"
         ]),