prostgles-server 4.2.182 → 4.2.184

package/dist/DboBuilder/QueryBuilder/Functions.js

@@ -9,7 +9,7 @@ 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);
+        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;
@@ -19,16 +19,20 @@ const parseFunction = (funcData) => {
         return `Issue with function ${JSON.stringify({ [funcName]: args })}: \n${msg}`;
     };
     /* Find function */
-    const funcDef = functions.find(f => f.name === funcName);
+    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;
+        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 => {
+        fields.forEach((fieldKey) => {
             if (typeof fieldKey !== "string" || !allowedFields.includes(fieldKey)) {
                 throw makeErr(`getFields() => field name ${JSON.stringify(fieldKey)} is invalid or disallowed`);
             }
@@ -37,7 +41,11 @@ const parseFunction = (funcData) => {
             throw makeErr(`Less columns provided than necessary (minCols=${funcDef.minCols})`);
         }
     }
-    if (funcDef.numArgs && funcDef.minCols !== 0 && fields !== "*" && Array.isArray(fields) && !fields.length) {
+    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;
@@ -49,7 +57,9 @@ const parseUnix = (colName, tableAlias, allColumns, opts) => {
     let tz = "";
     if (opts) {
         const { timeZone } = opts ?? {};
-        if (timeZone && typeof timeZone !== "string" && typeof timeZone !== "boolean") {
+        if (timeZone &&
+            typeof timeZone !== "string" &&
+            typeof timeZone !== "boolean") {
             throw `Bad timeZone value. timeZone can be boolean or string`;
         }
         if (timeZone === true) {
@@ -59,7 +69,7 @@ const parseUnix = (colName, tableAlias, allColumns, opts) => {
             tz = ` AT TIME ZONE ${asValue(timeZone)}`;
         }
     }
-    const col = allColumns.find(c => c.name === colName);
+    const col = allColumns.find((c) => c.name === colName);
     if (!col)
         throw `Unexpected: column ${colName} not found`;
     const escapedName = (0, QueryBuilder_1.asNameAlias)(colName, tableAlias);
@@ -76,16 +86,18 @@ const JSON_Funcs = [
         numArgs: 4,
         type: "function",
         getFields: ([column]) => column,
-        getQuery: ({ args: [colName, path = [], new_value, create_missing = true], tableAlias, allowedFields }) => {
+        getQuery: ({ args: [colName, path = [], new_value, create_missing = true], tableAlias, allowedFields, }) => {
             if (!allowedFields.includes(colName)) {
                 throw `Unexpected: column ${colName} not found`;
             }
-            if (!path || !Array.isArray(path) || !path.every(v => ["number", "string"].includes(typeof v))) {
+            if (!path ||
+                !Array.isArray(path) ||
+                !path.every((v) => ["number", "string"].includes(typeof v))) {
                 throw "Expecting: [columnName: string, path: (string | number)[], new_value?: any, create_missing?: boolean ]";
             }
             const escapedName = (0, QueryBuilder_1.asNameAlias)(colName, tableAlias);
             return `jsonb_set(${escapedName}, ${asValue(path)}, ${asValue(new_value)}, ${create_missing})`;
-        }
+        },
     },
     {
         name: "$jsonb_path_query",
@@ -94,7 +106,7 @@ const JSON_Funcs = [
         numArgs: 4,
         type: "function",
         getFields: ([column]) => column,
-        getQuery: ({ args: [colName, jsonPath, ...otherArgs], tableAlias, allowedFields }) => {
+        getQuery: ({ args: [colName, jsonPath, ...otherArgs], tableAlias, allowedFields, }) => {
             if (!allowedFields.includes(colName)) {
                 throw `Unexpected: column ${colName} not found`;
             }
@@ -102,20 +114,38 @@ const JSON_Funcs = [
                 throw "Expecting: [columnName: string, jsonPath: string, vars?: object, silent?: boolean]";
             }
             const escapedName = (0, QueryBuilder_1.asNameAlias)(colName, tableAlias);
-            return `jsonb_path_query(${escapedName}, ${[jsonPath, ...otherArgs].map(v => asValue(v)).join(", ")})`;
-        }
+            return `jsonb_path_query(${escapedName}, ${[jsonPath, ...otherArgs].map((v) => asValue(v)).join(", ")})`;
+        },
     },
     ...[
-        ["jsonb_array_length", "Returns the number of elements in the outermost JSON array"],
-        ["jsonb_each", "Expands the outermost JSON object into a set of key/value pairs"],
-        ["jsonb_each_text", "Expands the outermost JSON object into a set of key/value pairs. The returned values will be of type text"],
+        [
+            "jsonb_array_length",
+            "Returns the number of elements in the outermost JSON array",
+        ],
+        [
+            "jsonb_each",
+            "Expands the outermost JSON object into a set of key/value pairs",
+        ],
+        [
+            "jsonb_each_text",
+            "Expands the outermost JSON object into a set of key/value pairs. The returned values will be of type text",
+        ],
         ["jsonb_object_keys", "Returns set of keys in the outermost JSON object"],
-        ["jsonb_strip_nulls", "Returns from_json with all object fields that have null values omitted. Other null values are untouched"],
+        [
+            "jsonb_strip_nulls",
+            "Returns from_json with all object fields that have null values omitted. Other null values are untouched",
+        ],
         ["jsonb_pretty", "Returns from_json as indented JSON text "],
         ["jsonb_to_record", "Builds an arbitrary record from a JSON object"],
         ["jsonb_array_elements", "Expands a JSON array to a set of JSON values"],
-        ["jsonb_array_elements_text", "Expands a JSON array to a set of text values "],
-        ["jsonb_typeof", "Returns the type of the outermost JSON value as a text string. Possible types are object, array, string, number, boolean, and null "],
+        [
+            "jsonb_array_elements_text",
+            "Expands a JSON array to a set of text values ",
+        ],
+        [
+            "jsonb_typeof",
+            "Returns the type of the outermost JSON value as a text string. Possible types are object, array, string, number, boolean, and null ",
+        ],
     ].map(([name, description]) => ({
         name: "$" + name,
         description,
@@ -126,8 +156,8 @@ const JSON_Funcs = [
         getQuery: ({ args: [colName], tableAlias }) => {
             const escapedName = (0, QueryBuilder_1.asNameAlias)(colName, tableAlias);
             return `${name}(${escapedName})`;
-        }
-    }))
+        },
+    })),
 ];
 const FTS_Funcs = 
 /* Full text search
@@ -138,10 +168,10 @@ const FTS_Funcs =
     // "synonym", // replace word with a synonym
     "english",
     // "english_stem",
-    // "english_hunspell", 
-    ""
-].map(type => ({
-    name: "$ts_headline" + (type ? ("_" + type) : ""),
+    // "english_hunspell",
+    "",
+].map((type) => ({
+    name: "$ts_headline" + (type ? "_" + type : ""),
     description: ` :[column_name <string>, search_term: <string | { to_tsquery: string } > ] -> sha512 hash of the of column content`,
     type: "function",
     singleColArg: true,
@@ -150,7 +180,7 @@ const FTS_Funcs =
     getQuery: ({ args }) => {
         const col = (0, prostgles_types_1.asName)(args[0]);
         let qVal = args[1], qType = "to_tsquery";
-        const _type = type ? (asValue(type) + ",") : "";
+        const _type = type ? asValue(type) + "," : "";
         const searchTypes = prostgles_types_1.TextFilter_FullTextSearchFilterKeys;
         /* { to_tsquery: 'search term' } */
         if ((0, DboBuilder_1.isPlainObject)(qVal)) {
@@ -158,7 +188,8 @@ const FTS_Funcs =
             if (!keys.length)
                 throw "Bad arg";
             if (keys.length !== 1 || !searchTypes.includes(keys[0]))
-                throw "Expecting a an object with a single key named one of: " + searchTypes.join(", ");
+                throw ("Expecting a an object with a single key named one of: " +
+                    searchTypes.join(", "));
             qType = keys[0];
             qVal = asValue(qVal[qType]);
             /* 'search term' */
@@ -171,7 +202,7 @@ const FTS_Funcs =
         const res = `ts_headline(${_type} ${col}::text, ${qVal}, 'ShortWord=1 ' )`;
         // console.log(res)
         return res;
-    }
+    },
 }));
 let PostGIS_Funcs = [
     {
@@ -180,12 +211,12 @@ let PostGIS_Funcs = [
         -> Returns true if the geometries are within a given distance
         For geometry: The distance is specified in units defined by the spatial reference system of the geometries. For this function to make sense, the source geometries must be in the same coordinate system (have the same SRID).
         For geography: units are in meters and distance measurement defaults to use_spheroid=true. For faster evaluation use use_spheroid=false to measure on the sphere.
-      `
+      `,
     },
     {
         fname: "<->",
         description: `:[column_name, { lat?: number; lng?: number; geojson?: object; srid?: number; use_spheroid?: boolean }] 
-        -> The <-> operator returns the 2D distance between two geometries. Used in the "ORDER BY" clause provides index-assisted nearest-neighbor result sets. For PostgreSQL below 9.5 only gives centroid distance of bounding boxes and for PostgreSQL 9.5+, does true KNN distance search giving true distance between geometries, and distance sphere for geographies.`
+        -> The <-> operator returns the 2D distance between two geometries. Used in the "ORDER BY" clause provides index-assisted nearest-neighbor result sets. For PostgreSQL below 9.5 only gives centroid distance of bounding boxes and for PostgreSQL 9.5+, does true KNN distance search giving true distance between geometries, and distance sphere for geographies.`,
     },
     {
         fname: "ST_Distance",
@@ -193,15 +224,17 @@ let PostGIS_Funcs = [
         -> For geometry types returns the minimum 2D Cartesian (planar) distance between two geometries, in projected units (spatial ref units).
         -> For geography types defaults to return the minimum geodesic distance between two geographies in meters, compute on the spheroid determined by the SRID. If use_spheroid is false, a faster spherical calculation is used.
       `,
-    }, {
+    },
+    {
         fname: "ST_DistanceSpheroid",
         description: ` :[column_name, { lat?: number; lng?: number; geojson?: object; srid?: number; spheroid?: string; }] -> Returns minimum distance in meters between two lon/lat geometries given a particular spheroid. See the explanation of spheroids given for ST_LengthSpheroid.
 
       `,
-    }, {
+    },
+    {
         fname: "ST_DistanceSphere",
         description: ` :[column_name, { lat?: number; lng?: number; geojson?: object; srid?: number }] -> Returns linear distance in meters between two lon/lat points. Uses a spherical earth and radius of 6370986 meters. Faster than ST_DistanceSpheroid, but less accurate. Only implemented for points.`,
-    }
+    },
 ].map(({ fname, description }) => ({
     name: "$" + fname,
     description,
@@ -211,20 +244,22 @@ let PostGIS_Funcs = [
     canBeUsedForFilter: fname === "ST_DWithin",
     getFields: (args) => [args[0]],
     getQuery: ({ allColumns, args: [columnName, arg2], tableAlias }) => {
-        const mErr = () => { throw `${fname}: Expecting a second argument like: { lat?: number; lng?: number; geojson?: object; srid?: number; use_spheroid?: boolean }`; };
+        const mErr = () => {
+            throw `${fname}: Expecting a second argument like: { lat?: number; lng?: number; geojson?: object; srid?: number; use_spheroid?: boolean }`;
+        };
         if (!(0, prostgles_types_1.isObject)(arg2)) {
             mErr();
         }
-        const col = allColumns.find(c => c.name === columnName);
+        const col = allColumns.find((c) => c.name === columnName);
         if (!col) {
             throw new Error("Col not found: " + columnName);
         }
-        const { lat, lng, srid = 4326, geojson, text, use_spheroid, distance, spheroid = 'SPHEROID["WGS 84", 6378137, 298.257223563]', unit, debug } = arg2;
+        const { lat, lng, srid = 4326, geojson, text, use_spheroid, distance, spheroid = 'SPHEROID["WGS 84", 6378137, 298.257223563]', unit, debug, } = arg2;
         let geomQ = "", extraParams = "";
         if (typeof text === "string") {
             geomQ = `ST_GeomFromText(${asValue(text)})`;
         }
-        else if ([lat, lng].every(v => Number.isFinite(v))) {
+        else if ([lat, lng].every((v) => Number.isFinite(v))) {
             geomQ = `ST_Point(${asValue(lng)}, ${asValue(lat)})`;
         }
         else if ((0, DboBuilder_1.isPlainObject)(geojson)) {
@@ -246,8 +281,8 @@ let PostGIS_Funcs = [
             if (typeof use_spheroid === "boolean") {
                 extraParams = ", " + asValue(use_spheroid);
             }
-            colCast = (colIsGeog || use_spheroid) ? "::geography" : "::geometry";
-            geomQCast = (colIsGeog || use_spheroid) ? "::geography" : "::geometry";
+            colCast = colIsGeog || use_spheroid ? "::geography" : "::geometry";
+            geomQCast = colIsGeog || use_spheroid ? "::geography" : "::geometry";
             /**
              * boolean ST_DWithin(geometry g1, geometry g2, double precision distance_of_srid);
              * boolean ST_DWithin(geography gg1, geography gg2, double precision distance_meters, boolean use_spheroid = true);
@@ -300,15 +335,21 @@ let PostGIS_Funcs = [
             throw query;
         }
         return query;
-    }
+    },
 }));
 PostGIS_Funcs = PostGIS_Funcs.concat([
-    "ST_AsText", "ST_AsEWKT", "ST_AsEWKB", "ST_AsBinary", "ST_AsMVT", "ST_AsMVTGeom",
-    "ST_AsGeoJSON", "ST_Simplify",
-    "ST_SnapToGrid", "ST_Centroid",
+    "ST_AsText",
+    "ST_AsEWKT",
+    "ST_AsEWKB",
+    "ST_AsBinary",
+    "ST_AsMVT",
+    "ST_AsMVTGeom",
+    "ST_AsGeoJSON",
+    "ST_Simplify",
+    "ST_SnapToGrid",
+    "ST_Centroid",
     "st_aslatlontext",
-]
-    .map(fname => {
+].map((fname) => {
     const res = {
         name: "$" + fname,
         description: ` :[column_name, precision?] -> json GeoJSON output of a geometry column`,
@@ -319,20 +360,32 @@ PostGIS_Funcs = PostGIS_Funcs.concat([
         getQuery: ({ args: [colName, ...otherArgs], tableAlias }) => {
             let secondArg = "";
             if (otherArgs.length)
-                secondArg = ", " + otherArgs.map(arg => asValue(arg)).join(", ");
+                secondArg = ", " + otherArgs.map((arg) => asValue(arg)).join(", ");
             const escTabelName = (0, QueryBuilder_1.asNameAlias)(colName, tableAlias) + "::geometry";
-            const result = DboBuilder_1.pgp.as.format(fname + "(" + escTabelName + secondArg + (fname === "ST_AsGeoJSON" ? ")::jsonb" : ")"));
+            const result = DboBuilder_1.pgp.as.format(fname +
+                "(" +
+                escTabelName +
+                secondArg +
+                (fname === "ST_AsGeoJSON" ? ")::jsonb" : ")"));
             if (["ST_Centroid", "ST_SnapToGrid", "ST_Simplify"].includes(fname)) {
                 const r = `ST_AsGeoJSON(${result})::jsonb`;
                 return r;
             }
             return result;
-        }
+        },
     };
     return res;
 }));
-PostGIS_Funcs = PostGIS_Funcs.concat(["ST_Extent", "ST_3DExtent", "ST_XMin_Agg", "ST_XMax_Agg", "ST_YMin_Agg", "ST_YMax_Agg", "ST_ZMin_Agg", "ST_ZMax_Agg"]
-    .map(fname => {
+PostGIS_Funcs = PostGIS_Funcs.concat([
+    "ST_Extent",
+    "ST_3DExtent",
+    "ST_XMin_Agg",
+    "ST_XMax_Agg",
+    "ST_YMin_Agg",
+    "ST_YMax_Agg",
+    "ST_ZMin_Agg",
+    "ST_ZMax_Agg",
+].map((fname) => {
     const res = {
         name: "$" + fname,
         description: ` :[column_name] -> ST_Extent returns a bounding box that encloses a set of geometries. 
@@ -348,11 +401,11 @@ PostGIS_Funcs = PostGIS_Funcs.concat(["ST_Extent", "ST_3DExtent", "ST_XMin_Agg",
                 return `${fname}(${escTabelName})`;
             }
             return `${fname.endsWith("_Agg") ? fname.slice(0, -4) : fname}(ST_Collect(${escTabelName}))`;
-        }
+        },
     };
     return res;
 }));
-PostGIS_Funcs = PostGIS_Funcs.concat(["ST_Length", "ST_X", "ST_Y", "ST_Z"].map(fname => ({
+PostGIS_Funcs = PostGIS_Funcs.concat(["ST_Length", "ST_X", "ST_Y", "ST_Z"].map((fname) => ({
     name: "$" + fname,
     type: "function",
     singleColArg: true,
@@ -361,15 +414,15 @@ PostGIS_Funcs = PostGIS_Funcs.concat(["ST_Length", "ST_X", "ST_Y", "ST_Z"].map(f
     getQuery: ({ allColumns, args, tableAlias }) => {
         const colName = args[0];
         const escapedColName = (0, QueryBuilder_1.asNameAlias)(colName, tableAlias);
-        const col = allColumns.find(c => c.name === colName);
+        const col = allColumns.find((c) => c.name === colName);
         if (!col)
             throw new Error("Col not found: " + colName);
         return `${fname}(${escapedColName})`;
-    }
+    },
 })));
 /**
-* Each function expects a column at the very least
-*/
+ * Each function expects a column at the very least
+ */
 exports.FUNCTIONS = [
     // Hashing
     {
@@ -380,9 +433,13 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("md5(" + args.map(fname => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + "::text, '' )").join(" || ") + ")");
+            const q = DboBuilder_1.pgp.as.format("md5(" +
+                args
+                    .map((fname) => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + "::text, '' )")
+                    .join(" || ") +
+                ")");
             return q;
-        }
+        },
     },
     {
         name: "$md5_multi_agg",
@@ -392,9 +449,13 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("md5(string_agg(" + args.map(fname => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + "::text, '' )").join(" || ") + ", ','))");
+            const q = DboBuilder_1.pgp.as.format("md5(string_agg(" +
+                args
+                    .map((fname) => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + "::text, '' )")
+                    .join(" || ") +
+                ", ','))");
             return q;
-        }
+        },
     },
     {
         name: "$sha256_multi",
@@ -404,9 +465,13 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha256((" + args.map(fname => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ")::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha256((" +
+                args
+                    .map((fname) => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )")
+                    .join(" || ") +
+                ")::text::bytea), 'hex')");
             return q;
-        }
+        },
     },
     {
         name: "$sha256_multi_agg",
@@ -416,9 +481,13 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha256(string_agg(" + args.map(fname => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ", ',')::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha256(string_agg(" +
+                args
+                    .map((fname) => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )")
+                    .join(" || ") +
+                ", ',')::text::bytea), 'hex')");
             return q;
-        }
+        },
     },
     {
         name: "$sha512_multi",
@@ -428,9 +497,13 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha512((" + args.map(fname => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ")::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha512((" +
+                args
+                    .map((fname) => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )")
+                    .join(" || ") +
+                ")::text::bytea), 'hex')");
             return q;
-        }
+        },
     },
     {
         name: "$sha512_multi_agg",
@@ -440,9 +513,13 @@ exports.FUNCTIONS = [
         numArgs: MAX_COL_NUM,
         getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            const q = DboBuilder_1.pgp.as.format("encode(sha512(string_agg(" + args.map(fname => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )").join(" || ") + ", ',')::text::bytea), 'hex')");
+            const q = DboBuilder_1.pgp.as.format("encode(sha512(string_agg(" +
+                args
+                    .map((fname) => "COALESCE( " + (0, QueryBuilder_1.asNameAlias)(fname, tableAlias) + ", '' )")
+                    .join(" || ") +
+                ", ',')::text::bytea), 'hex')");
             return q;
-        }
+        },
     },
     ...FTS_Funcs,
     ...JSON_Funcs,
@@ -456,7 +533,7 @@ exports.FUNCTIONS = [
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
             return DboBuilder_1.pgp.as.format("LEFT(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + ", $1)", [args[1]]);
-        }
+        },
     },
     {
         name: "$unnest_words",
@@ -466,8 +543,10 @@ exports.FUNCTIONS = [
         singleColArg: true,
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
-            return DboBuilder_1.pgp.as.format("unnest(string_to_array(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + "::TEXT , ' '))"); //, [args[1]]
-        }
+            return DboBuilder_1.pgp.as.format("unnest(string_to_array(" +
+                (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) +
+                "::TEXT , ' '))"); //, [args[1]]
+        },
     },
     {
         name: "$right",
@@ -478,7 +557,7 @@ exports.FUNCTIONS = [
         getFields: (args) => [args[0]],
         getQuery: ({ allowedFields, args, tableAlias }) => {
             return DboBuilder_1.pgp.as.format("RIGHT(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + ", $1)", [args[1]]);
-        }
+        },
     },
     {
         name: "$to_char",
@@ -492,7 +571,7 @@ exports.FUNCTIONS = [
                 return DboBuilder_1.pgp.as.format("to_char(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + ", $2, $3)", [args[0], args[1], args[2]]);
             }
             return DboBuilder_1.pgp.as.format("to_char(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + ", $2)", [args[0], args[1]]);
-        }
+        },
     },
     /**
      * Date trunc utils
@@ -510,40 +589,42 @@ exports.FUNCTIONS = [
         "year",
         "decade",
         "century",
-        "millennium"
-    ].map(k => ({ val: 0, unit: k }))
+        "millennium",
+    ]
+        .map((k) => ({ val: 0, unit: k }))
         .concat([
-        { val: 6, unit: 'month' },
-        { val: 4, unit: 'month' },
-        { val: 2, unit: 'month' },
-        { val: 8, unit: 'hour' },
-        { val: 4, unit: 'hour' },
-        { val: 2, unit: 'hour' },
-        { val: 30, unit: 'minute' },
-        { val: 15, unit: 'minute' },
-        { val: 6, unit: 'minute' },
-        { val: 5, unit: 'minute' },
-        { val: 4, unit: 'minute' },
-        { val: 3, unit: 'minute' },
-        { val: 2, unit: 'minute' },
-        { val: 30, unit: 'second' },
-        { val: 15, unit: 'second' },
-        { val: 10, unit: 'second' },
-        { val: 8, unit: 'second' },
-        { val: 6, unit: 'second' },
-        { val: 5, unit: 'second' },
-        { val: 4, unit: 'second' },
-        { val: 3, unit: 'second' },
-        { val: 2, unit: 'second' },
-        { val: 500, unit: 'millisecond' },
-        { val: 250, unit: 'millisecond' },
-        { val: 100, unit: 'millisecond' },
-        { val: 50, unit: 'millisecond' },
-        { val: 25, unit: 'millisecond' },
-        { val: 10, unit: 'millisecond' },
-        { val: 5, unit: 'millisecond' },
-        { val: 2, unit: 'millisecond' },
-    ]).map(({ val, unit }) => ({
+        { val: 6, unit: "month" },
+        { val: 4, unit: "month" },
+        { val: 2, unit: "month" },
+        { val: 8, unit: "hour" },
+        { val: 4, unit: "hour" },
+        { val: 2, unit: "hour" },
+        { val: 30, unit: "minute" },
+        { val: 15, unit: "minute" },
+        { val: 6, unit: "minute" },
+        { val: 5, unit: "minute" },
+        { val: 4, unit: "minute" },
+        { val: 3, unit: "minute" },
+        { val: 2, unit: "minute" },
+        { val: 30, unit: "second" },
+        { val: 15, unit: "second" },
+        { val: 10, unit: "second" },
+        { val: 8, unit: "second" },
+        { val: 6, unit: "second" },
+        { val: 5, unit: "second" },
+        { val: 4, unit: "second" },
+        { val: 3, unit: "second" },
+        { val: 2, unit: "second" },
+        { val: 500, unit: "millisecond" },
+        { val: 250, unit: "millisecond" },
+        { val: 100, unit: "millisecond" },
+        { val: 50, unit: "millisecond" },
+        { val: 25, unit: "millisecond" },
+        { val: 10, unit: "millisecond" },
+        { val: 5, unit: "millisecond" },
+        { val: 2, unit: "millisecond" },
+    ])
+        .map(({ val, unit }) => ({
         name: "$date_trunc_" + (val || "") + unit,
         type: "function",
         description: ` :[column_name, opts?: { timeZone: true | 'TZ Name' }] -> round down timestamp to closest ${val || ""} ${unit} `,
@@ -575,19 +656,23 @@ exports.FUNCTIONS = [
             const res = `(date_trunc(${asValue(prevUnit)}, ${col}) + floor(${extractedUnit} / ${val}) * interval ${asValue(val + " " + unit)})`;
             // console.log(res);
             return res;
-        }
+        },
     })),
     /* Date funcs date_part */
-    ...["date_trunc", "date_part"].map(funcName => ({
+    ...["date_trunc", "date_part"].map((funcName) => ({
         name: "$" + funcName,
         type: "function",
         numArgs: 3,
-        description: ` :[unit<string>, column_name, opts?: { timeZone: true | string }] -> ` + (funcName === "date_trunc" ? ` round down timestamp to closest unit value. ` : ` extract date unit as float8. `) + ` E.g. ['hour', col] `,
+        description: ` :[unit<string>, column_name, opts?: { timeZone: true | string }] -> ` +
+            (funcName === "date_trunc"
+                ? ` round down timestamp to closest unit value. `
+                : ` extract date unit as float8. `) +
+            ` E.g. ['hour', col] `,
         singleColArg: false,
         getFields: (args) => [args[1]],
         getQuery: ({ allColumns, args, tableAlias }) => {
             return `${funcName}(${asValue(args[0])}, ${parseUnix(args[1], tableAlias, allColumns, args[2])})`;
-        }
+        },
     })),
     /* Handy date funcs */
     ...[
@@ -621,22 +706,24 @@ exports.FUNCTIONS = [
     ].map(([funcName, txt]) => ({
         name: "$" + funcName,
         type: "function",
-        description: ` :[column_name, opts?: { timeZone: true | string }] -> get timestamp formated as ` + txt,
+        description: ` :[column_name, opts?: { timeZone: true | string }] -> get timestamp formated as ` +
+            txt,
         singleColArg: true,
         numArgs: 1,
         getFields: (args) => [args[0]],
         getQuery: ({ allColumns, args, tableAlias }) => {
-            return DboBuilder_1.pgp.as.format("trim(to_char(" + parseUnix(args[0], tableAlias, allColumns, args[1]) + ", $2))", [args[0], txt]);
-        }
+            return DboBuilder_1.pgp.as.format("trim(to_char(" +
+                parseUnix(args[0], tableAlias, allColumns, args[1]) +
+                ", $2))", [args[0], txt]);
+        },
     })),
     /* Basic 1 arg col funcs */
     ...[
-        ...["TEXT"].flatMap(cast => [
-            "upper", "lower", "length", "reverse", "trim", "initcap"
-        ].map(funcName => ({ cast, funcName }))),
-        ...[""].flatMap(cast => [
-            "round", "ceil", "floor", "sign", "md5"
-        ].map(funcName => ({ cast, funcName }))),
+        ...["TEXT"].flatMap((cast) => ["upper", "lower", "length", "reverse", "trim", "initcap"].map((funcName) => ({ cast, funcName }))),
+        ...[""].flatMap((cast) => ["round", "ceil", "floor", "sign", "md5"].map((funcName) => ({
+            cast,
+            funcName,
+        }))),
     ].map(({ funcName, cast }) => ({
         name: "$" + funcName,
         type: "function",
@@ -645,22 +732,31 @@ exports.FUNCTIONS = [
         getFields: (args) => [args[0]],
         getQuery: ({ args, tableAlias }) => {
             return `${funcName}(${(0, QueryBuilder_1.asNameAlias)(args[0], tableAlias)}${cast ? `::${cast}` : ""})`;
-        }
+        },
     })),
     /**
      * Interval funcs
      * (col1, col2?, trunc )
      * */
-    ...["age", "ageNow", "difference"].map(funcName => ({
+    ...["age", "ageNow", "difference"].map((funcName) => ({
         name: "$" + funcName,
         type: "function",
         numArgs: 2,
         singleColArg: true,
-        getFields: (args) => args.slice(0, 2).filter(a => typeof a === "string"), // Filtered because the second arg is optional
+        getFields: (args) => args.slice(0, 2).filter((a) => typeof a === "string"), // Filtered because the second arg is optional
         getQuery: ({ allowedFields, args, tableAlias, allColumns }) => {
-            const validColCount = args.slice(0, 2).filter(a => typeof a === "string").length;
+            const validColCount = args
+                .slice(0, 2)
+                .filter((a) => typeof a === "string").length;
             const trunc = args[2];
-            const allowedTruncs = ["second", "minute", "hour", "day", "month", "year"];
+            const allowedTruncs = [
+                "second",
+                "minute",
+                "hour",
+                "day",
+                "month",
+                "year",
+            ];
             if (trunc && !allowedTruncs.includes(trunc))
                 throw new Error("Incorrect trunc provided. Allowed values: " + allowedTruncs);
             if (funcName === "difference" && validColCount !== 2)
@@ -670,7 +766,9 @@ exports.FUNCTIONS = [
             const [leftField, rightField] = args;
             const tzOpts = args[2];
             const leftQ = parseUnix(leftField, tableAlias, allColumns, tzOpts);
-            let rightQ = rightField ? parseUnix(rightField, tableAlias, allColumns, tzOpts) : "";
+            let rightQ = rightField
+                ? parseUnix(rightField, tableAlias, allColumns, tzOpts)
+                : "";
             let query = "";
             if (funcName === "ageNow" && validColCount === 1) {
                 query = `age(now(), ${leftQ})`;
@@ -684,10 +782,10 @@ exports.FUNCTIONS = [
                 query = `${leftQ} - ${rightQ}`;
             }
             return trunc ? `date_trunc(${asValue(trunc)}, ${query})` : query;
-        }
+        },
     })),
     /* pgcrypto funcs */
-    ...["crypt"].map(funcName => ({
+    ...["crypt"].map((funcName) => ({
         name: "$" + funcName,
         type: "function",
         numArgs: 1,
@@ -696,10 +794,10 @@ exports.FUNCTIONS = [
         getQuery: ({ allowedFields, args, tableAlias }) => {
             const value = asValue(args[0]) + "", seedColumnName = (0, QueryBuilder_1.asNameAlias)(args[1], tableAlias);
             return `crypt(${value}, ${seedColumnName}::text)`;
-        }
+        },
     })),
     /* Text col and value funcs */
-    ...["position", "position_lower"].map(funcName => ({
+    ...["position", "position_lower"].map((funcName) => ({
         name: "$" + funcName,
         type: "function",
         numArgs: 1,
@@ -712,9 +810,9 @@ exports.FUNCTIONS = [
                 a2 = `LOWER(${a2}::text)`;
             }
             return `position( ${a1} IN ${a2} )`;
-        }
+        },
     })),
-    ...["template_string"].map(funcName => ({
+    ...["template_string"].map((funcName) => ({
         name: "$" + funcName,
         type: "function",
         numArgs: 1,
@@ -726,16 +824,16 @@ exports.FUNCTIONS = [
                 throw "First argument must be a string. E.g.: '{col1} ..text {col2} ...' ";
             const rawValue = args[0];
             let finalValue = rawValue;
-            const usedColumns = allowedFields.filter(fName => rawValue.includes(`{${fName}}`));
+            const usedColumns = allowedFields.filter((fName) => rawValue.includes(`{${fName}}`));
             usedColumns.forEach((colName, idx) => {
                 finalValue = finalValue.split(`{${colName}}`).join(`%${idx + 1}$s`);
             });
             finalValue = asValue(finalValue);
             if (usedColumns.length) {
-                return `format(${finalValue}, ${usedColumns.map(c => `${(0, QueryBuilder_1.asNameAlias)(c, tableAlias)}::TEXT`).join(", ")})`;
+                return `format(${finalValue}, ${usedColumns.map((c) => `${(0, QueryBuilder_1.asNameAlias)(c, tableAlias)}::TEXT`).join(", ")})`;
             }
             return `format(${finalValue})`;
-        }
+        },
     })),
     /** Custom highlight -> myterm => ['some text and', ['myterm'], ' and some other text']
      * (fields: "*" | string[], term: string, { edgeTruncate: number = -1; noFields: boolean = false }) => string | (string | [string])[]
@@ -743,7 +841,7 @@ exports.FUNCTIONS = [
      * noFields = exclude field names in search
      * */
     {
-        name: "$term_highlight", /* */
+        name: "$term_highlight" /* */,
         description: ` :[column_names<string[] | "*">, search_term<string>, opts?<{ returnIndex?: number; edgeTruncate?: number; noFields?: boolean }>] -> get case-insensitive text match highlight`,
         type: "function",
         numArgs: 1,
@@ -754,19 +852,26 @@ exports.FUNCTIONS = [
             const cols = (0, parseFieldFilter_1.parseFieldFilter)(args[0], false, allowedFields);
             let term = args[1];
             const rawTerm = args[1];
-            const { edgeTruncate, noFields = false, returnType, matchCase = false } = args[2] || {};
+            const { edgeTruncate, noFields = false, returnType, matchCase = false, } = 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));
+                const validKeys = [
+                    "edgeTruncate",
+                    "noFields",
+                    "returnType",
+                    "matchCase",
+                ];
+                const bad_keys = keys.filter((k) => !validKeys.includes(k));
                 if (bad_keys.length)
-                    throw "Invalid options provided for $term_highlight. Expecting one of: " + validKeys.join(", ");
+                    throw ("Invalid options provided for $term_highlight. Expecting one of: " +
+                        validKeys.join(", "));
             }
             if (!cols.length)
                 throw "Cols are empty/invalid";
             if (typeof term !== "string")
                 throw "Non string term provided: " + term;
-            if (edgeTruncate !== undefined && (!Number.isInteger(edgeTruncate) || edgeTruncate < -1))
+            if (edgeTruncate !== undefined &&
+                (!Number.isInteger(edgeTruncate) || edgeTruncate < -1))
                 throw "Invalid edgeTruncate. expecting a positive integer";
             if (typeof noFields !== "boolean")
                 throw "Invalid noFields. expecting boolean";
@@ -799,7 +904,11 @@ exports.FUNCTIONS = [
           END
         `;
             };
-            const colRaw = "( " + cols.map(c => `${noFields ? "" : (asValue(c + ": ") + " || ")} COALESCE(${(0, QueryBuilder_1.asNameAlias)(c, tableAlias)}::TEXT, '')`).join(" || ', ' || ") + " )";
+            const colRaw = "( " +
+                cols
+                    .map((c) => `${noFields ? "" : asValue(c + ": ") + " || "} COALESCE(${(0, QueryBuilder_1.asNameAlias)(c, tableAlias)}::TEXT, '')`)
+                    .join(" || ', ' || ") +
+                " )";
             let col = colRaw;
             term = asValue(term);
             if (!matchCase) {
@@ -820,27 +929,27 @@ exports.FUNCTIONS = [
             }
             else if (returnType === "object" || returnType === "boolean") {
                 const hasChars = Boolean(rawTerm && /[a-z]/i.test(rawTerm));
-                const validCols = cols.map(c => {
-                    const colInfo = allColumns.find(ac => ac.name === c);
+                const validCols = cols
+                    .map((c) => {
+                    const colInfo = allColumns.find((ac) => ac.name === c);
                     return {
                         key: c,
-                        colInfo
+                        colInfo,
                     };
                 })
-                    .filter(c => c.colInfo && c.colInfo.udt_name !== "bytea");
-                const _cols = validCols.filter(c => 
+                    .filter((c) => c.colInfo && c.colInfo.udt_name !== "bytea");
+                const _cols = validCols.filter((c) => 
                 /** Exclude numeric columns when the search tern contains a character */
-                !hasChars ||
-                    (0, DboBuilder_1.postgresToTsType)(c.colInfo.udt_name) !== "number");
+                !hasChars || (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)
                         throw `You're searching the impossible: characters in numeric fields. Use this to prevent making such a request in future: /[a-z]/i.test(your_term) `;
-                    return (returnType === "boolean") ? "FALSE" : "NULL";
+                    return returnType === "boolean" ? "FALSE" : "NULL";
                 }
                 res = `CASE 
           ${_cols
-                    .map(c => {
+                    .map((c) => {
                     const colNameEscaped = (0, QueryBuilder_1.asNameAlias)(c.key, tableAlias);
                     let colSelect = `${colNameEscaped}::TEXT`;
                     const isTstamp = c.colInfo?.udt_name.startsWith("timestamp");
@@ -856,19 +965,20 @@ exports.FUNCTIONS = [
                     const colTxt = `COALESCE(${colSelect}, '')`; //  position(${term} IN ${colTxt}) > 0
                     if (returnType === "boolean") {
                         return ` 
-                WHEN  ${colTxt} ${matchCase ? "LIKE" : "ILIKE"} ${asValue('%' + rawTerm + '%')}
+                WHEN  ${colTxt} ${matchCase ? "LIKE" : "ILIKE"} ${asValue("%" + rawTerm + "%")}
                   THEN TRUE
                 `;
                     }
                     return ` 
-              WHEN  ${colTxt} ${matchCase ? "LIKE" : "ILIKE"} ${asValue('%' + rawTerm + '%')}
+              WHEN  ${colTxt} ${matchCase ? "LIKE" : "ILIKE"} ${asValue("%" + rawTerm + "%")}
                 THEN json_build_object(
                   ${asValue(c.key)}, 
                   ${makeTextMatcherArray(colTxt, term)}
                 )::jsonb
               `;
-                }).join(" ")}
-          ELSE ${(returnType === "boolean") ? "FALSE" : "NULL"}
+                })
+                    .join(" ")}
+          ELSE ${returnType === "boolean" ? "FALSE" : "NULL"}
 
         END`;
                 // console.log(res)
@@ -884,10 +994,20 @@ exports.FUNCTIONS = [
         ]) ELSE array_to_json(ARRAY[(${colRaw})::TEXT]) END`;
             }
             return res;
-        }
+        },
     },
     /* Aggs */
-    ...["max", "min", "count", "avg", "json_agg", "jsonb_agg", "string_agg", "array_agg", "sum"].map(aggName => ({
+    ...[
+        "max",
+        "min",
+        "count",
+        "avg",
+        "json_agg",
+        "jsonb_agg",
+        "string_agg",
+        "array_agg",
+        "sum",
+    ].map((aggName) => ({
         name: "$" + aggName,
         type: "aggregation",
         numArgs: 1,
@@ -898,8 +1018,8 @@ exports.FUNCTIONS = [
             if (args.length > 1) {
                 extraArgs = DboBuilder_1.pgp.as.format(", $1:csv", args.slice(1));
             }
-            return aggName + "(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + `${extraArgs})`;
-        }
+            return (aggName + "(" + (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias) + `${extraArgs})`);
+        },
     })),
     {
         name: "$jsonb_build_object",
@@ -907,10 +1027,10 @@ exports.FUNCTIONS = [
         numArgs: 22,
         minCols: 1,
         singleColArg: false,
-        getFields: args => args,
+        getFields: (args) => args,
         getQuery: ({ args, tableAlias }) => {
-            return `jsonb_build_object(${args.flatMap(arg => [asValue(arg), (0, QueryBuilder_1.asNameAlias)(arg, tableAlias)]).join(", ")})`;
-        }
+            return `jsonb_build_object(${args.flatMap((arg) => [asValue(arg), (0, QueryBuilder_1.asNameAlias)(arg, tableAlias)]).join(", ")})`;
+        },
     },
     /* More aggs */
     {
@@ -922,7 +1042,7 @@ exports.FUNCTIONS = [
         getFields: (args) => [],
         getQuery: ({ allowedFields, args, tableAlias }) => {
             return "COUNT(*)";
-        }
+        },
     },
     {
         name: "$diff_perc",
@@ -933,8 +1053,8 @@ exports.FUNCTIONS = [
         getQuery: ({ allowedFields, args, tableAlias }) => {
             const col = (0, QueryBuilder_1.asNameAlias)(args[0], tableAlias);
             return `round( ( ( MAX(${col}) - MIN(${col}) )::float/MIN(${col}) ) * 100, 2)`;
-        }
-    }
+        },
+    },
 ];
 /* The difference between a function and computed field is that the computed field does not require any arguments */
 exports.COMPUTED_FIELDS = [
@@ -946,17 +1066,17 @@ exports.COMPUTED_FIELDS = [
         type: "computed",
         // description: ` order hash of row content  `,
         getQuery: ({ allowedFields, tableAlias, ctidField }) => {
-            return "md5(" +
+            return ("md5(" +
                 allowedFields
                     /* CTID not available in AFTER trigger */
                     // .concat(ctidField? [ctidField] : [])
                     .sort()
-                    .map(f => (0, QueryBuilder_1.asNameAlias)(f, tableAlias))
-                    .map(f => `md5(coalesce(${f}::text, 'dd'))`)
+                    .map((f) => (0, QueryBuilder_1.asNameAlias)(f, tableAlias))
+                    .map((f) => `md5(coalesce(${f}::text, 'dd'))`)
                     .join(" || ") +
-                `)`;
-        }
-    }
+                `)`);
+        },
+    },
     // ,{
     //   name: "ctid",
     //   type: "computed",
@@ -1007,5 +1127,5 @@ WHERE NOT EXISTS ( --Keep only leaf values
   AND starts_with(t2.path, t1.path)
 );
 
-*/ 
+*/
 //# sourceMappingURL=Functions.js.map