prostgles-server 3.0.78 → 3.0.79

package/lib/DboBuilder/getCondition.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCondition = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const DboBuilder_1 = require("../DboBuilder");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
+const Functions_1 = require("./QueryBuilder/Functions");
+const QueryBuilder_1 = require("./QueryBuilder/QueryBuilder");
+const Filtering_1 = require("../Filtering");
+const FILTER_FUNCS = Functions_1.FUNCTIONS.filter(f => f.canBeUsedForFilter);
+/**
+ * parses a single filter
+ * @example
+ *  { fff: 2 } => "fff" = 2
+ *  { fff: { $ilike: 'abc' } } => "fff" ilike 'abc'
+ */
+async function getCondition(params) {
+    const { filter, select, allowed_colnames, tableAlias, localParams, tableRules } = params;
+    let data = { ...filter };
+    /* Exists join filter */
+    const ERR = "Invalid exists filter. \nExpecting somethibng like: \n | { $exists: { tableName.tableName2: Filter } } \n  | { $exists: { \"**.tableName3\": Filter } }\n | { path: string[]; filter: AnyObject }";
+    const SP_WILDCARD = "**";
+    let existsKeys = (0, prostgles_types_1.getKeys)(data)
+        .filter(k => prostgles_types_1.EXISTS_KEYS.includes(k) && Object.keys(data[k] ?? {}).length)
+        .map(key => {
+        const isJoined = key.toLowerCase().includes("join");
+        const filterValue = data[key];
+        /**
+         * type ExistsJoined =
+         *   | { "table1.table2": { column: filterValue }  }
+         *   | { path: string[]; filter: AnyObject }
+         */
+        const dataKeys = Object.keys(filterValue);
+        const isDetailed = dataKeys.length === 2 && dataKeys.every(key => ["path", "filter"].includes(key));
+        const firstKey = dataKeys[0];
+        /**
+         * Prevent some errors with table names that contain "."
+         */
+        const firstKeyIsATable = !!this.dboBuilder.dbo[firstKey];
+        let tables = isDetailed ? filterValue.path : (firstKeyIsATable ? [firstKey] : firstKey.split("."));
+        let f2 = isDetailed ? filterValue.filter : filterValue[firstKey];
+        let shortestJoin = false;
+        if (!isJoined) {
+            if (tables.length !== 1)
+                throw "Expecting single table in exists filter. Example: { $exists: { tableName: Filter } }";
+        }
+        else {
+            /* First part can be the ** param meaning shortest join. Will be overriden by anything in tableConfig */
+            if (!tables.length) {
+                throw ERR + "\nBut got: " + filterValue;
+            }
+            if (tables[0] === SP_WILDCARD) {
+                tables = tables.slice(1);
+                shortestJoin = true;
+            }
+        }
+        return {
+            key,
+            existType: key,
+            isJoined,
+            shortestJoin,
+            f2,
+            tables
+        };
+    });
+    /* Exists with exact path */
+    // Object.keys(data).map(k => {
+    //     let isthis = isPlainObject(data[k]) && !this.column_names.includes(k) && !k.split(".").find(kt => !this.dboBuilder.dbo[kt]);
+    //     if(isthis) {
+    //         existsKeys.push({
+    //             key: k,
+    //             notJoined: false,
+    //             exactPaths: k.split(".")
+    //         });
+    //     }
+    // });
+    let funcConds = [];
+    const funcFilterkeys = FILTER_FUNCS.filter(f => {
+        return f.name in data;
+    });
+    funcFilterkeys.map(f => {
+        const funcArgs = data[f.name];
+        if (!Array.isArray(funcArgs))
+            throw `A function filter must contain an array. E.g: { $funcFilterName: ["col1"] } \n but got: ${JSON.stringify((0, prostgles_types_1.pickKeys)(data, [f.name]))} `;
+        const fields = this.parseFieldFilter(f.getFields(funcArgs), true, allowed_colnames);
+        const dissallowedCols = fields.filter(fname => !allowed_colnames.includes(fname));
+        if (dissallowedCols.length) {
+            throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`;
+        }
+        funcConds.push(f.getQuery({ args: funcArgs, allColumns: this.columns, allowedFields: allowed_colnames, tableAlias }));
+    });
+    let existsCond = "";
+    if (existsKeys.length) {
+        existsCond = (await Promise.all(existsKeys.map(async (k) => await this.prepareExistCondition(k, localParams)))).join(" AND ");
+    }
+    /* Computed field queries */
+    const p = this.getValidatedRules(tableRules, localParams);
+    const computedFields = p.allColumns.filter(c => c.type === "computed");
+    let computedColConditions = [];
+    Object.keys(data || {}).map(key => {
+        const compCol = computedFields.find(cf => cf.name === key);
+        if (compCol) {
+            computedColConditions.push(compCol.getQuery({
+                tableAlias,
+                allowedFields: p.select.fields,
+                allColumns: this.columns,
+                /* CTID not available in AFTER trigger */
+                // ctidField: this.is_view? undefined : "ctid"
+                ctidField: undefined,
+            }) + ` = ${DboBuilder_1.pgp.as.format("$1", [data[key]])}`);
+            delete data[key];
+        }
+    });
+    let allowedSelect = [];
+    /* Select aliases take precedence over col names. This is to ensure filters work correctly and even on computed cols*/
+    if (select) {
+        /* Allow filtering by selected fields/funcs */
+        allowedSelect = select.filter(s => {
+            /*  */
+            if (["function", "computed", "column"].includes(s.type)) {
+                if (s.type !== "column" || allowed_colnames.includes(s.alias)) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /* Add remaining allowed fields */
+    allowedSelect = allowedSelect.concat(p.allColumns.filter(c => allowed_colnames.includes(c.name) &&
+        !allowedSelect.find(s => s.alias === c.name)).map(f => ({
+        type: f.type,
+        alias: f.name,
+        getQuery: (tableAlias) => f.getQuery({
+            tableAlias,
+            allColumns: this.columns,
+            allowedFields: allowed_colnames
+        }),
+        selected: false,
+        getFields: () => [f.name],
+        column_udt_type: f.type === "column" ? this.columns.find(c => c.name === f.name)?.udt_name : undefined
+    })));
+    /* Parse complex filters
+      {
+        $filter: [
+          { $func: [...] },
+          "=",
+          value | { $func: [..] }
+        ]
+      }
+    */
+    const complexFilters = [];
+    const complexFilterKey = "$filter";
+    const allowedComparators = [">", "<", "=", "<=", ">=", "<>", "!="];
+    if (complexFilterKey in data) {
+        /**
+         * { $funcName: [arg1, arg2] }
+         * { $column: "column_name" }
+         */
+        const getFuncQuery = (funcData) => {
+            if ((0, prostgles_types_1.isObject)(funcData) && "$column" in funcData) {
+                const column = funcData["$column"];
+                if (typeof column !== "string") {
+                    throw `expecting: \n  { $column: "column_name" } received:\n ${JSON.stringify(funcData)}`;
+                }
+                if (!allowed_colnames.includes(column)) {
+                    throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
+                }
+                return (0, QueryBuilder_1.asNameAlias)(column, tableAlias);
+            }
+            const { funcName, args } = (0, QueryBuilder_1.parseFunctionObject)(funcData);
+            const funcDef = (0, Functions_1.parseFunction)({ func: funcName, args, functions: Functions_1.FUNCTIONS, allowedFields: allowed_colnames });
+            return funcDef.getQuery({ args, tableAlias, allColumns: this.columns, allowedFields: allowed_colnames });
+        };
+        const complexFilter = data[complexFilterKey];
+        if (!Array.isArray(complexFilter)) {
+            throw `Invalid $filter. Must contain an array of at least element but got: ${JSON.stringify(complexFilter)} `;
+        }
+        const [leftFilter, comparator, rightFilterOrValue] = complexFilter;
+        const leftVal = getFuncQuery(leftFilter);
+        let result = leftVal;
+        if (comparator) {
+            if (!allowedComparators.includes(comparator)) {
+                throw `Invalid $filter. comparator ${JSON.stringify(comparator)} is not valid. Expecting one of: ${allowedComparators}`;
+            }
+            if (!rightFilterOrValue) {
+                throw "Invalid $filter. Expecting a value or function after the comparator";
+            }
+            const rightVal = (0, prostgles_types_1.isObject)(rightFilterOrValue) ? getFuncQuery(rightFilterOrValue) : (0, PubSubManager_1.asValue)(rightFilterOrValue);
+            if (leftVal === rightVal) {
+                throw "Invalid $filter. Cannot compare two identical function signatures: " + JSON.stringify(leftFilter);
+            }
+            result += ` ${comparator} ${rightVal}`;
+        }
+        complexFilters.push(result);
+    }
+    /* Parse join filters
+        { $joinFilter: { $ST_DWithin: [table.col, foreignTable.col, distance] }
+        will make an exists filter
+    */
+    let filterKeys = Object.keys(data).filter(k => k !== complexFilterKey && !funcFilterkeys.find(ek => ek.name === k) && !computedFields.find(cf => cf.name === k) && !existsKeys.find(ek => ek.key === k));
+    // if(allowed_colnames){
+    //     const aliasedColumns = (select || []).filter(s => 
+    //         ["function", "computed", "column"].includes(s.type) && allowed_colnames.includes(s.alias) ||  
+    //         s.getFields().find(f => allowed_colnames.includes(f))
+    //     ).map(s => s.alias);
+    //     const validCols = [...allowed_colnames, ...aliasedColumns];
+    // }
+    const validFieldNames = allowedSelect.map(s => s.alias);
+    const invalidColumn = filterKeys
+        .find(fName => !validFieldNames.find(c => c === fName ||
+        (fName.startsWith(c) && (fName.slice(c.length).includes("->") ||
+            fName.slice(c.length).includes(".")))));
+    if (invalidColumn) {
+        throw `Table: ${this.name} -> disallowed/inexistent columns in filter: ${invalidColumn} \n  Expecting one of: ${allowedSelect.map(s => s.type === "column" ? s.getQuery() : s.alias).join(", ")}`;
+    }
+    /* TODO: Allow filter funcs */
+    // const singleFuncs = FUNCTIONS.filter(f => f.singleColArg);
+    const f = (0, prostgles_types_1.pickKeys)(data, filterKeys);
+    const q = (0, Filtering_1.parseFilterItem)({
+        filter: f,
+        tableAlias,
+        pgp: DboBuilder_1.pgp,
+        select: allowedSelect
+    });
+    let templates = [q].filter(q => q);
+    if (existsCond)
+        templates.push(existsCond);
+    templates = templates.concat(funcConds);
+    templates = templates.concat(computedColConditions);
+    templates = templates.concat(complexFilters);
+    /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
+    return templates.sort()
+        .join(" AND \n");
+}
+exports.getCondition = getCondition;

package/lib/DboBuilder/getCondition.ts

@@ -0,0 +1,279 @@
+import { AnyObject, EXISTS_KEY, EXISTS_KEYS, getKeys, isObject, pickKeys } from "prostgles-types";
+import { ExistsFilterConfig, LocalParams, makeErrorFromPGError, pgp } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+import { asValue } from "../PubSubManager/PubSubManager";
+import { FUNCTIONS, parseFunction } from "./QueryBuilder/Functions";
+import { asNameAlias, parseFunctionObject, SelectItem } from "./QueryBuilder/QueryBuilder";
+import { ViewHandler } from "./ViewHandler";
+import { parseFilterItem } from "../Filtering";
+
+
+const FILTER_FUNCS = FUNCTIONS.filter(f => f.canBeUsedForFilter);
+
+  /**
+   * parses a single filter
+   * @example
+   *  { fff: 2 } => "fff" = 2
+   *  { fff: { $ilike: 'abc' } } => "fff" ilike 'abc'
+   */
+  export async function getCondition(this: ViewHandler, params: { filter: any, select?: SelectItem[], allowed_colnames: string[], tableAlias?: string, localParams?: LocalParams, tableRules?: TableRule }) {
+    const { filter, select, allowed_colnames, tableAlias, localParams, tableRules } = params;
+
+
+    let data = { ... (filter as any) } as any;
+
+    /* Exists join filter */
+    const ERR = "Invalid exists filter. \nExpecting somethibng like: \n | { $exists: { tableName.tableName2: Filter } } \n  | { $exists: { \"**.tableName3\": Filter } }\n | { path: string[]; filter: AnyObject }"
+    const SP_WILDCARD = "**";
+    let existsKeys: ExistsFilterConfig[] = getKeys(data)
+      .filter(k => EXISTS_KEYS.includes(k as EXISTS_KEY) && Object.keys(data[k] ?? {}).length)
+      .map(key => {
+
+        const isJoined = key.toLowerCase().includes("join");
+
+        const filterValue = data[key];
+        /**
+         * type ExistsJoined = 
+         *   | { "table1.table2": { column: filterValue }  }
+         *   | { path: string[]; filter: AnyObject }
+         */
+        const dataKeys = Object.keys(filterValue);
+        const isDetailed = dataKeys.length === 2 && dataKeys.every(key => ["path", "filter"].includes(key));
+
+        const firstKey = dataKeys[0];
+
+        /**
+         * Prevent some errors with table names that contain "."
+         */
+        const firstKeyIsATable = !!this.dboBuilder.dbo[firstKey];
+        let tables = isDetailed? filterValue.path : (firstKeyIsATable? [firstKey] : firstKey.split("."));
+        let f2 = isDetailed? filterValue.filter : filterValue[firstKey];
+        let shortestJoin = false;
+
+        if (!isJoined) {
+          if (tables.length !== 1) throw "Expecting single table in exists filter. Example: { $exists: { tableName: Filter } }"
+        } else {
+          /* First part can be the ** param meaning shortest join. Will be overriden by anything in tableConfig */
+
+          if (!tables.length) {
+            throw ERR + "\nBut got: " + filterValue;
+          }
+
+          if (tables[0] === SP_WILDCARD) {
+            tables = tables.slice(1);
+            shortestJoin = true;
+          }
+        }
+
+        return {
+          key,
+          existType: key as EXISTS_KEY,
+          isJoined,
+          shortestJoin,
+          f2,
+          tables
+        }
+      });
+    /* Exists with exact path */
+    // Object.keys(data).map(k => {
+    //     let isthis = isPlainObject(data[k]) && !this.column_names.includes(k) && !k.split(".").find(kt => !this.dboBuilder.dbo[kt]);
+    //     if(isthis) {
+    //         existsKeys.push({
+    //             key: k,
+    //             notJoined: false,
+    //             exactPaths: k.split(".")
+    //         });
+    //     }
+    // });
+    let funcConds: string[] = [];
+    const funcFilterkeys = FILTER_FUNCS.filter(f => {
+      return f.name in data;
+    });
+    funcFilterkeys.map(f => {
+      const funcArgs = data[f.name];
+      if (!Array.isArray(funcArgs)) throw `A function filter must contain an array. E.g: { $funcFilterName: ["col1"] } \n but got: ${JSON.stringify(pickKeys(data, [f.name]))} `;
+      const fields = this.parseFieldFilter(f.getFields(funcArgs), true, allowed_colnames);
+
+      const dissallowedCols = fields.filter(fname => !allowed_colnames.includes(fname))
+      if (dissallowedCols.length) {
+        throw `Invalid/disallowed columns found in function filter: ${dissallowedCols}`
+      }
+      funcConds.push(f.getQuery({ args: funcArgs, allColumns: this.columns, allowedFields: allowed_colnames, tableAlias }));
+    })
+
+
+    let existsCond = "";
+    if (existsKeys.length) {
+      existsCond = (await Promise.all(existsKeys.map(async k => await this.prepareExistCondition(k, localParams)))).join(" AND ");
+    }
+
+    /* Computed field queries */
+    const p = this.getValidatedRules(tableRules, localParams);
+    const computedFields = p.allColumns.filter(c => c.type === "computed");
+    let computedColConditions: string[] = [];
+    Object.keys(data || {}).map(key => {
+      const compCol = computedFields.find(cf => cf.name === key);
+      if (compCol) {
+        computedColConditions.push(
+          compCol.getQuery({
+            tableAlias,
+            allowedFields: p.select.fields,
+            allColumns: this.columns,
+
+            /* CTID not available in AFTER trigger */
+            // ctidField: this.is_view? undefined : "ctid"
+
+            ctidField: undefined,
+          }) + ` = ${pgp.as.format("$1", [(data as any)[key]])}`
+        );
+        delete (data as any)[key];
+      }
+    });
+
+    let allowedSelect: SelectItem[] = [];
+    /* Select aliases take precedence over col names. This is to ensure filters work correctly and even on computed cols*/
+    if (select) {
+      /* Allow filtering by selected fields/funcs */
+      allowedSelect = select.filter(s => {
+        /*  */
+        if (["function", "computed", "column"].includes(s.type)) {
+          if (s.type !== "column" || allowed_colnames.includes(s.alias)) {
+            return true;
+          }
+        }
+        return false;
+      })
+    }
+
+    /* Add remaining allowed fields */
+    allowedSelect = allowedSelect.concat(
+      p.allColumns.filter(c =>
+        allowed_colnames.includes(c.name) &&
+        !allowedSelect.find(s => s.alias === c.name)
+      ).map(f => ({
+        type: f.type,
+        alias: f.name,
+        getQuery: (tableAlias) => f.getQuery({
+          tableAlias,
+          allColumns: this.columns,
+          allowedFields: allowed_colnames
+        }),
+        selected: false,
+        getFields: () => [f.name],
+        column_udt_type: f.type === "column" ? this.columns.find(c => c.name === f.name)?.udt_name : undefined
+      }))
+    );
+
+    /* Parse complex filters
+      { 
+        $filter: [
+          { $func: [...] }, 
+          "=", 
+          value | { $func: [..] }
+        ] 
+      } 
+    */
+    const complexFilters: string[] = [];
+    const complexFilterKey = "$filter";
+    const allowedComparators = [">", "<", "=", "<=", ">=", "<>", "!="]
+    if (complexFilterKey in data) {
+
+      /**
+       * { $funcName: [arg1, arg2] }
+       * { $column: "column_name" }
+       */
+      const getFuncQuery = (funcData: AnyObject): string => {
+        if(isObject(funcData) && "$column" in funcData){
+          const column = funcData["$column"]
+          if(typeof column !== "string"){
+            throw `expecting: \n  { $column: "column_name" } received:\n ${JSON.stringify(funcData)}`;
+          }
+          if(!allowed_colnames.includes(column)){
+            throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
+          }
+          return asNameAlias(column, tableAlias)
+        }
+        const { funcName, args } = parseFunctionObject(funcData);
+        const funcDef = parseFunction({ func: funcName, args, functions: FUNCTIONS, allowedFields: allowed_colnames });
+        return funcDef.getQuery({ args, tableAlias, allColumns: this.columns, allowedFields: allowed_colnames });
+      }
+
+      const complexFilter = data[complexFilterKey];
+      if (!Array.isArray(complexFilter)) {
+        throw `Invalid $filter. Must contain an array of at least element but got: ${JSON.stringify(complexFilter)} `
+      } 
+
+      const [leftFilter, comparator, rightFilterOrValue] = complexFilter;
+
+      const leftVal = getFuncQuery(leftFilter);
+      let result = leftVal;
+      if (comparator) {
+        if (!allowedComparators.includes(comparator)) {
+          throw `Invalid $filter. comparator ${JSON.stringify(comparator)} is not valid. Expecting one of: ${allowedComparators}`;
+        }
+        if (!rightFilterOrValue) {
+          throw "Invalid $filter. Expecting a value or function after the comparator";
+        }
+        const rightVal = isObject(rightFilterOrValue) ? getFuncQuery(rightFilterOrValue) : asValue(rightFilterOrValue);
+        if (leftVal === rightVal){ 
+          throw "Invalid $filter. Cannot compare two identical function signatures: " + JSON.stringify(leftFilter);
+        }
+        result += ` ${comparator} ${rightVal}`;
+      }
+      complexFilters.push(result);
+    }
+
+
+    /* Parse join filters
+        { $joinFilter: { $ST_DWithin: [table.col, foreignTable.col, distance] } 
+        will make an exists filter
+    */
+
+    let filterKeys = Object.keys(data).filter(k => k !== complexFilterKey && !funcFilterkeys.find(ek => ek.name === k) && !computedFields.find(cf => cf.name === k) && !existsKeys.find(ek => ek.key === k));
+    // if(allowed_colnames){
+    //     const aliasedColumns = (select || []).filter(s => 
+    //         ["function", "computed", "column"].includes(s.type) && allowed_colnames.includes(s.alias) ||  
+    //         s.getFields().find(f => allowed_colnames.includes(f))
+    //     ).map(s => s.alias);
+    //     const validCols = [...allowed_colnames, ...aliasedColumns];
+
+    // }
+    const validFieldNames = allowedSelect.map(s => s.alias);
+    const invalidColumn = filterKeys
+      .find(fName => !validFieldNames.find(c =>
+        c === fName ||
+        (
+          fName.startsWith(c) && (
+            fName.slice(c.length).includes("->") ||
+            fName.slice(c.length).includes(".")
+          )
+        )
+      ));
+
+    if (invalidColumn) {
+      throw `Table: ${this.name} -> disallowed/inexistent columns in filter: ${invalidColumn} \n  Expecting one of: ${allowedSelect.map(s => s.type === "column" ? s.getQuery() : s.alias).join(", ")}`;
+    }
+
+    /* TODO: Allow filter funcs */
+    // const singleFuncs = FUNCTIONS.filter(f => f.singleColArg);
+
+    const f = pickKeys(data, filterKeys);
+    const q = parseFilterItem({
+      filter: f,
+      tableAlias,
+      pgp,
+      select: allowedSelect
+    });
+
+    let templates: string[] = [q].filter(q => q);
+
+    if (existsCond) templates.push(existsCond);
+    templates = templates.concat(funcConds);
+    templates = templates.concat(computedColConditions);
+    templates = templates.concat(complexFilters);
+
+    /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
+    return templates.sort()
+      .join(" AND \n");
+
+  }

package/lib/DboBuilder/insert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["insert.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAqC,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAiB,WAAW,EAA4B,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,CAiL1N"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["insert.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAqC,YAAY,EAAY,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAiB,WAAW,EAAyC,MAAM,eAAe,CAAC;AAClG,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,CAiL1N"}

package/lib/DboBuilder/insert.js

@@ -129,10 +129,10 @@ async function insert(rowOrRows, param2, param3_unused, tableRules, localParams)
         const tx = localParams?.tx?.t || this.t;
         const allowedFieldKeys = this.parseFieldFilter(fields);
         if (tx) {
-            result = await tx[queryType](query).catch((err) => (0, DboBuilder_1.makeErr)(err, localParams, this, allowedFieldKeys));
+            result = await tx[queryType](query).catch((err) => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this, allowedFieldKeys));
         }
         else {
-            result = await this.db.tx(t => t[queryType](query)).catch(err => (0, DboBuilder_1.makeErr)(err, localParams, this, allowedFieldKeys));
+            result = await this.db.tx(t => t[queryType](query)).catch(err => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this, allowedFieldKeys));
         }
         if (tableRules?.[ACTION]?.postValidate) {
             if (!finalDBtx)

package/lib/DboBuilder/insert.ts

@@ -1,6 +1,6 @@
 import pgPromise from "pg-promise";
 import { AnyObject, asName, FieldFilter, get, getKeys, InsertParams, isObject } from "prostgles-types";
-import { isPlainObject, LocalParams, makeErr, parseError, pgp } from "../DboBuilder";
+import { isPlainObject, LocalParams, makeErrorFromPGError, parseError, pgp } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
 import { asValue, omitKeys, pickKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
@@ -149,9 +149,9 @@ export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObje
 
     const allowedFieldKeys = this.parseFieldFilter(fields);
     if (tx) {
-      result = await (tx as any)[queryType](query).catch((err: any) => makeErr(err, localParams, this, allowedFieldKeys));
+      result = await (tx as any)[queryType](query).catch((err: any) => makeErrorFromPGError(err, localParams, this, allowedFieldKeys));
     } else {
-      result = await this.db.tx(t => (t as any)[queryType](query)).catch(err => makeErr(err, localParams, this, allowedFieldKeys));
+      result = await this.db.tx(t => (t as any)[queryType](query)).catch(err => makeErrorFromPGError(err, localParams, this, allowedFieldKeys));
     }
 
     if(tableRules?.[ACTION]?.postValidate){

package/lib/DboBuilder/subscribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["subscribe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,oBAAY,SAAS,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,GAAG,CAAC;AAEpD,iBAAe,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,GAAG,CAAA;CAAE,CAAC,CAAA;AAC/I,iBAAe,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,GAAG,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AA4NzL,OAAO,EAAE,SAAS,EAAE,CAAA"}
+{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["subscribe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAoC,MAAM,eAAe,CAAC;AACtF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,oBAAY,SAAS,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,GAAG,CAAC;AAEpD,iBAAe,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,GAAG,CAAA;CAAE,CAAC,CAAA;AAC/I,iBAAe,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,GAAG,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AA4NzL,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/lib/DboBuilder/subscribe.js

@@ -43,7 +43,7 @@ async function subscribe(filter, params, localFunc, table_rules, localParams) {
                         def = def.slice(0, -1);
                     }
                     if (!def || typeof def !== "string") {
-                        throw (0, DboBuilder_1.makeErr)("Could get view definition");
+                        throw (0, DboBuilder_1.makeErrorFromPGError)("Could get view definition");
                     }
                     const { fields } = await this.dboBuilder.dbo.sql(`SELECT * FROM ( \n ${def} \n ) prostgles_subscribe_view_definition LIMIT 0`, {});
                     const tableColumns = fields.filter(f => f.tableName && f.columnName);

package/lib/DboBuilder/subscribe.ts

@@ -1,5 +1,5 @@
 import { AnyObject, asName, SubscribeParams } from "prostgles-types";
-import { Filter, LocalParams, makeErr, parseError } from "../DboBuilder";
+import { Filter, LocalParams, makeErrorFromPGError, parseError } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
 import { log, omitKeys, ViewSubscriptionOptions } from "../PubSubManager/PubSubManager";
 import { ViewHandler } from "./ViewHandler";
@@ -62,7 +62,7 @@ async function subscribe(this: ViewHandler, filter: Filter, params: SubscribePar
               def = def.slice(0, -1);
             }
             if (!def || typeof def !== "string") {
-              throw makeErr("Could get view definition");
+              throw makeErrorFromPGError("Could get view definition");
             }
             const { fields } = await this.dboBuilder.dbo.sql!(`SELECT * FROM ( \n ${def} \n ) prostgles_subscribe_view_definition LIMIT 0`, {});
             const tableColumns = fields.filter(f => f.tableName && f.columnName);

package/lib/DboBuilder/update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAiB,WAAW,EAA8B,MAAM,eAAe,CAAC;AAC/F,OAAO,EAAE,SAAS,EAAe,MAAM,kBAAkB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA+JzL"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAiB,WAAW,EAA2C,MAAM,eAAe,CAAC;AAC5G,OAAO,EAAE,SAAS,EAAe,MAAM,kBAAkB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,wBAAsB,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA+JzL"}

package/lib/DboBuilder/update.js

@@ -108,10 +108,10 @@ async function update(filter, _newData, params, tableRules, localParams) {
             return query;
         let result;
         if (this.t) {
-            result = await (this.t)[qType](query).catch((err) => (0, DboBuilder_1.makeErr)(err, localParams, this, fields));
+            result = await (this.t)[qType](query).catch((err) => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this, fields));
         }
         else {
-            result = await this.db.tx(t => t[qType](query)).catch(err => (0, DboBuilder_1.makeErr)(err, localParams, this, fields));
+            result = await this.db.tx(t => t[qType](query)).catch(err => (0, DboBuilder_1.makeErrorFromPGError)(err, localParams, this, fields));
         }
         /** TODO: Delete old file at the end in case new file update fails */
         // await oldFileDelete();

package/lib/DboBuilder/update.ts

@@ -1,5 +1,5 @@
 import { AnyObject, getKeys, isObject, unpatchText, UpdateParams } from "prostgles-types";
-import { Filter, isPlainObject, LocalParams, makeErr, Media, parseError } from "../DboBuilder";
+import { Filter, isPlainObject, LocalParams, makeErrorFromPGError, Media, parseError } from "../DboBuilder";
 import { TableRule, ValidateRow } from "../PublishParser";
 import { omitKeys, pickKeys } from "../PubSubManager/PubSubManager";
 import { TableHandler } from "./TableHandler";
@@ -129,9 +129,9 @@ export async function update(this: TableHandler, filter: Filter, _newData: AnyOb
 
     let result;
     if (this.t) {
-      result = await (this.t)[qType](query).catch((err: any) => makeErr(err, localParams, this, fields));
+      result = await (this.t)[qType](query).catch((err: any) => makeErrorFromPGError(err, localParams, this, fields));
     } else {
-      result = await this.db.tx(t => (t as any)[qType](query)).catch(err => makeErr(err, localParams, this, fields));
+      result = await this.db.tx(t => (t as any)[qType](query)).catch(err => makeErrorFromPGError(err, localParams, this, fields));
     }
     
     /** TODO: Delete old file at the end in case new file update fails */

package/lib/DboBuilder.d.ts

@@ -1,6 +1,6 @@
 import * as pgPromise from 'pg-promise';
 import pg = require('pg-promise/typescript/pg-subset');
-import { ColumnInfo, SQLOptions, DbJoinMaker, PG_COLUMN_UDT_DATA_TYPE, TS_PG_Types, TableInfo as TInfo, SQLHandler, AnyObject, ProstglesError } from "prostgles-types";
+import { ColumnInfo, SQLOptions, DbJoinMaker, PG_COLUMN_UDT_DATA_TYPE, TS_PG_Types, TableInfo as TInfo, SQLHandler, AnyObject, ProstglesError, EXISTS_KEY } from "prostgles-types";
 export declare type SortItem = {
     asc: boolean;
     nulls?: "first" | "last";
@@ -181,9 +181,7 @@ export declare type ValidatedTableRules = CommonTableRules & {
         returningFields: string[];
     };
 };
-export declare function makeErr(err: any, localParams?: LocalParams, view?: ViewHandler, allowedKeys?: string[]): Promise<never>;
-export declare const EXISTS_KEYS: readonly ["$exists", "$notExists", "$existsJoined", "$notExistsJoined"];
-export declare type EXISTS_KEY = typeof EXISTS_KEYS[number];
+export declare function makeErrorFromPGError(err: any, localParams?: LocalParams, view?: ViewHandler, allowedKeys?: string[]): Promise<never>;
 /**
  * Ensure the error is an Object and has
  */