prostgles-server 3.0.38 → 3.0.40

package/lib/DboBuilder/delete.d.ts

@@ -1,5 +1,6 @@
 import { DeleteParams } from "prostgles-types";
-import { Filter, LocalParams, TableHandler } from "../DboBuilder";
+import { Filter, LocalParams } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
 export declare function _delete(this: TableHandler, filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any>;
 //# sourceMappingURL=delete.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["delete.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,YAAY,EAAe,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,MAAM,EAAE,WAAW,EAAuB,YAAY,EAAE,MAAM,eAAe,CAAC;AACvF,OAAO,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGzD,wBAAsB,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CA6HrL"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["delete.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,YAAY,EAAe,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAE,MAAM,EAAE,WAAW,EAAuB,MAAM,eAAe,CAAC;AACzE,OAAO,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAsB,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CA6HrL"}

package/lib/DboBuilder/delete.ts

@@ -1,8 +1,9 @@
 import pgPromise from "pg-promise";
 import { AnyObject, asName, DeleteParams, FieldFilter } from "prostgles-types";
-import { Filter, LocalParams, makeErr, parseError, TableHandler } from "../DboBuilder";
+import { Filter, LocalParams, makeErr, parseError } from "../DboBuilder";
 import { DeleteRule, TableRule } from "../PublishParser";
 import { pickKeys } from "../PubSubManager";
+import { TableHandler } from "./TableHandler";
 
 export async function _delete(this: TableHandler, filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
   try {

package/lib/DboBuilder/getColumns.d.ts

@@ -0,0 +1,12 @@
+import { AnyObject, ValidatedColumnInfo } from "prostgles-types";
+import { LocalParams } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
+import { ViewHandler } from "./ViewHandler";
+export declare const isTableHandler: (v: any) => v is TableHandler;
+export declare function getColumns(this: ViewHandler, lang?: string, params?: {
+    rule: "update";
+    filter: AnyObject;
+    data: AnyObject;
+}, _param3?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<ValidatedColumnInfo[]>;
+//# sourceMappingURL=getColumns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getColumns.d.ts","sourceRoot":"","sources":["getColumns.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAiB,WAAW,EAAgC,MAAM,eAAe,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,eAAO,MAAM,cAAc,MAAO,GAAG,sBAA+C,CAAC;AAErF,wBAAsB,UAAU,CAC9B,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,EAC/D,OAAO,CAAC,EAAE,SAAS,EACnB,UAAU,CAAC,EAAE,SAAS,EACtB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAuGhC"}

package/lib/DboBuilder/getColumns.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumns = exports.isTableHandler = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const DboBuilder_1 = require("../DboBuilder");
+const isTableHandler = (v) => "parseUpdateRules" in v;
+exports.isTableHandler = isTableHandler;
+async function getColumns(lang, params, _param3, tableRules, localParams) {
+    try {
+        const p = this.getValidatedRules(tableRules, localParams);
+        if (!p.getColumns)
+            throw "Not allowed";
+        // console.log("getColumns", this.name, this.columns.map(c => c.name))
+        let dynamicUpdateFields;
+        if (params && tableRules && (0, exports.isTableHandler)(this)) {
+            if (!(0, DboBuilder_1.isPlainObject)(params) ||
+                (params.data && !(0, DboBuilder_1.isPlainObject)(params.data)) ||
+                !(0, DboBuilder_1.isPlainObject)(params.filter) ||
+                params.rule !== "update") {
+                throw "params must be { rule: 'update', filter: object, data?: object } but got: " + JSON.stringify(params);
+            }
+            if (!tableRules?.update) {
+                dynamicUpdateFields = [];
+            }
+            else {
+                const { data, filter } = params;
+                const updateRules = await this.parseUpdateRules(filter, data, undefined, tableRules, { ...localParams, testRule: true });
+                dynamicUpdateFields = updateRules.fields;
+            }
+        }
+        let columns = this.columns
+            .filter(c => {
+            const { insert, select, update } = p || {};
+            return [
+                ...(insert?.fields || []),
+                ...(select?.fields || []),
+                ...(update?.fields || []),
+            ].includes(c.name);
+        })
+            .map(_c => {
+            let c = { ..._c };
+            let label = c.comment || capitalizeFirstLetter(c.name, " ");
+            let select = c.privileges.some(p => p.privilege_type === "SELECT"), insert = c.privileges.some(p => p.privilege_type === "INSERT"), update = c.privileges.some(p => p.privilege_type === "UPDATE"), _delete = this.tableOrViewInfo.privileges.delete; // c.privileges.some(p => p.privilege_type === "DELETE");
+            delete c.privileges;
+            const prostgles = this.dboBuilder?.prostgles;
+            const fileConfig = prostgles.fileManager?.getColInfo({ colName: c.name, tableName: this.name });
+            /** Do not allow updates to file table unless it's to delete fields */
+            if (prostgles.fileManager?.config && prostgles.fileManager.tableName === this.name) {
+                update = false;
+            }
+            const nonOrderableUD_Types = [...prostgles_types_1._PG_geometric, "xml"];
+            let result = {
+                ...c,
+                label,
+                tsDataType: (0, DboBuilder_1.postgresToTsType)(c.udt_name),
+                insert: insert && Boolean(p.insert?.fields?.includes(c.name)) && tableRules?.insert?.forcedData?.[c.name] === undefined,
+                select: select && Boolean(p.select?.fields?.includes(c.name)),
+                orderBy: select && Boolean(p.select?.fields && p.select.orderByFields.includes(c.name)) && !nonOrderableUD_Types.includes(c.udt_name),
+                filter: Boolean(p.select?.filterFields?.includes(c.name)),
+                update: update && Boolean(p.update?.fields?.includes(c.name)) && tableRules?.update?.forcedData?.[c.name] === undefined,
+                delete: _delete && Boolean(p.delete && p.delete.filterFields && p.delete.filterFields.includes(c.name)),
+                ...(prostgles?.tableConfigurator?.getColInfo({ table: this.name, col: c.name, lang }) || {}),
+                ...(fileConfig && { file: fileConfig })
+            };
+            if (dynamicUpdateFields) {
+                result.update = dynamicUpdateFields.includes(c.name);
+            }
+            return result;
+        }).filter(c => c.select || c.update || c.delete || c.insert);
+        //.sort((a, b) => a.ordinal_position - b.ordinal_position);
+        // const tblInfo = await this.getInfo();
+        // if(tblInfo && tblInfo.media_table_name && tblInfo.has_media){
+        //     const mediaRules = this.dboBuilder.dbo[tblInfo.media_table_name]?.
+        //     return columns.concat({
+        //         comment: "",
+        //         data_type: "file",
+        //         delete: false,
+        //     });
+        // }
+        return columns;
+    }
+    catch (e) {
+        throw (0, DboBuilder_1.parseError)(e, `db.${this.name}.getColumns()`);
+        // throw "Something went wrong in " + `db.${this.name}.getColumns()`;
+    }
+}
+exports.getColumns = getColumns;
+function replaceNonAlphaNumeric(string, replacement = "_") {
+    return string.replace(/[\W_]+/g, replacement);
+}
+function capitalizeFirstLetter(string, nonalpha_replacement) {
+    const str = replaceNonAlphaNumeric(string, nonalpha_replacement);
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/lib/DboBuilder/getColumns.ts

@@ -0,0 +1,133 @@
+import { 
+  AnyObject, PG_COLUMN_UDT_DATA_TYPE, 
+  ValidatedColumnInfo, _PG_geometric 
+} from "prostgles-types";
+import { isPlainObject, LocalParams, parseError, postgresToTsType } from "../DboBuilder";
+import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
+import { ViewHandler } from "./ViewHandler";
+
+export const isTableHandler = (v: any): v is TableHandler => "parseUpdateRules" in v;
+
+export async function getColumns(
+  this: ViewHandler,
+  lang?: string,
+  params?: { rule: "update", filter: AnyObject, data: AnyObject },
+  _param3?: undefined,
+  tableRules?: TableRule,
+  localParams?: LocalParams
+): Promise<ValidatedColumnInfo[]> {
+
+  try {
+    const p = this.getValidatedRules(tableRules, localParams);
+
+    if (!p.getColumns) throw "Not allowed";
+
+    // console.log("getColumns", this.name, this.columns.map(c => c.name))
+
+
+    let dynamicUpdateFields: string[] | undefined;
+
+    if (params && tableRules && isTableHandler(this)) {
+      if (
+        !isPlainObject(params) || 
+        (params.data && !isPlainObject(params.data)) || 
+        !isPlainObject(params.filter) || 
+        params.rule !== "update"
+      ) {
+        throw "params must be { rule: 'update', filter: object, data?: object } but got: " + JSON.stringify(params);
+      }
+
+      if (!tableRules?.update) {
+        dynamicUpdateFields = [];
+      } else {
+        const { data, filter } = params;
+        const updateRules = await this.parseUpdateRules(filter, data, undefined, tableRules, { ...localParams, testRule: true });
+        dynamicUpdateFields = updateRules.fields;
+      }
+    }
+
+    const columns = this.columns
+      .filter(c => {
+        const { insert, select, update } = p || {};
+
+        return [
+          ...(insert?.fields || []),
+          ...(select?.fields || []),
+          ...(update?.fields || []),
+        ].includes(c.name)
+      })
+      .map(_c => {
+        let c = { ..._c };
+
+        let label = c.comment || capitalizeFirstLetter(c.name, " ");
+
+        let select = c.privileges.some(p => p.privilege_type === "SELECT"),
+          insert = c.privileges.some(p => p.privilege_type === "INSERT"),
+          update = c.privileges.some(p => p.privilege_type === "UPDATE"),
+          _delete = this.tableOrViewInfo.privileges.delete;// c.privileges.some(p => p.privilege_type === "DELETE");
+
+        delete (c as any).privileges;
+
+        const prostgles = this.dboBuilder?.prostgles;
+        const fileConfig = prostgles.fileManager?.getColInfo({ colName: c.name, tableName: this.name });
+
+        /** Do not allow updates to file table unless it's to delete fields */
+        if (prostgles.fileManager?.config && prostgles.fileManager.tableName === this.name) {
+          update = false;
+        }
+
+        const nonOrderableUD_Types: PG_COLUMN_UDT_DATA_TYPE[] = [..._PG_geometric, "xml" as any];
+
+        let result: ValidatedColumnInfo = {
+          ...c,
+          label,
+          tsDataType: postgresToTsType(c.udt_name),
+          insert: insert && Boolean(p.insert?.fields?.includes(c.name)) && tableRules?.insert?.forcedData?.[c.name] === undefined,
+          select: select && Boolean(p.select?.fields?.includes(c.name)),
+          orderBy: select && Boolean(p.select?.fields && p.select.orderByFields.includes(c.name)) && !nonOrderableUD_Types.includes(c.udt_name),
+          filter: Boolean(p.select?.filterFields?.includes(c.name)),
+          update: update && Boolean(p.update?.fields?.includes(c.name)) && tableRules?.update?.forcedData?.[c.name] === undefined,
+          delete: _delete && Boolean(p.delete && p.delete.filterFields && p.delete.filterFields.includes(c.name)),
+          ...(prostgles?.tableConfigurator?.getColInfo({ table: this.name, col: c.name, lang }) || {}),
+          ...(fileConfig && { file: fileConfig })
+        }
+
+        if (dynamicUpdateFields) {
+          result.update = dynamicUpdateFields.includes(c.name);
+        }
+
+        return result;
+      }).filter(c => c.select || c.update || c.delete || c.insert)
+
+    //.sort((a, b) => a.ordinal_position - b.ordinal_position);
+
+    // const tblInfo = await this.getInfo();
+
+    // if(tblInfo && tblInfo.media_table_name && tblInfo.has_media){
+    //     const mediaRules = this.dboBuilder.dbo[tblInfo.media_table_name]?.
+    //     return columns.concat({
+    //         comment: "",
+    //         data_type: "file",
+    //         delete: false,
+    //     });
+    // }
+
+    return columns;
+
+  } catch (e) {
+    throw parseError(e, `db.${this.name}.getColumns()`);
+    // throw "Something went wrong in " + `db.${this.name}.getColumns()`;
+  }
+}
+
+
+
+
+function replaceNonAlphaNumeric(string: string, replacement = "_"): string {
+  return string.replace(/[\W_]+/g, replacement);
+}
+function capitalizeFirstLetter(string: string, nonalpha_replacement?: string) : string {
+  const str = replaceNonAlphaNumeric(string, nonalpha_replacement);
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/lib/DboBuilder/insert.d.ts

@@ -1,5 +1,6 @@
 import { AnyObject, InsertParams } from "prostgles-types";
-import { LocalParams, TableHandler } from "../DboBuilder";
+import { LocalParams } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
 export declare function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any | any[] | boolean>;
 //# sourceMappingURL=insert.d.ts.map

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,EAA+B,WAAW,EAA4B,YAAY,EAAE,MAAM,eAAe,CAAC;AACjH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C,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,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"}

package/lib/DboBuilder/insert.js

@@ -79,7 +79,7 @@ async function insert(rowOrRows, param2, param3_unused, tableRules, localParams)
         let returningSelect = this.makeReturnQuery(finalSelect);
         const makeQuery = async (_row, isOne = false) => {
             let row = { ..._row };
-            if (!(0, DboBuilder_1.isPojoObject)(row)) {
+            if (!(0, prostgles_types_1.isObject)(row)) {
                 console.trace(row);
                 throw "\ninvalid insert data provided -> " + JSON.stringify(row);
             }

package/lib/DboBuilder/insert.ts

@@ -1,8 +1,9 @@
 import pgPromise from "pg-promise";
 import { AnyObject, asName, FieldFilter, get, getKeys, InsertParams, isObject } from "prostgles-types";
-import { isPlainObject, isPojoObject, LocalParams, makeErr, parseError, pgp, TableHandler } from "../DboBuilder";
+import { isPlainObject, LocalParams, makeErr, parseError, pgp } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
 import { asValue, omitKeys, pickKeys } from "../PubSubManager";
+import { TableHandler } from "./TableHandler";
 
 export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any | any[] | boolean> {
   // const localParams = _localParams || {};
@@ -93,7 +94,7 @@ export async function insert(this: TableHandler, rowOrRows: (AnyObject | AnyObje
     const makeQuery = async (_row: AnyObject | undefined, isOne = false) => {
       let row = { ..._row };
 
-      if (!isPojoObject(row)) {
+      if (!isObject(row)) {
         console.trace(row)
         throw "\ninvalid insert data provided -> " + JSON.stringify(row);
       }

package/lib/DboBuilder/insertDataParse.d.ts

@@ -1,6 +1,7 @@
 import { AnyObject, InsertParams } from "prostgles-types";
-import { LocalParams, TableHandler } from "../DboBuilder";
+import { LocalParams } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
 /**
  * Used for doing referenced inserts within a single transaction
  */

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

@@ -1 +1 @@
-{"version":3,"file":"insertDataParse.d.ts","sourceRoot":"","sources":["insertDataParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAqC,YAAY,EAAgD,MAAM,iBAAiB,CAAC;AAC3I,OAAO,EAA4B,WAAW,EAAmC,YAAY,EAAiB,MAAM,eAAe,CAAC;AACpI,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C;;GAEG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAC/B,MAAM,CAAC,EAAE,YAAY,EACrB,aAAa,CAAC,EAAE,SAAS,EACzB,UAAU,CAAC,EAAE,SAAS,EACtB,YAAY,CAAC,EAAE,WAAW,GACzB,OAAO,CAAC;IACT,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;IAC/B,YAAY,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;CACxC,CAAC,CAoQD"}
+{"version":3,"file":"insertDataParse.d.ts","sourceRoot":"","sources":["insertDataParse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAW,YAAY,EAAgD,MAAM,iBAAiB,CAAC;AACjH,OAAO,EAAE,WAAW,EAAiB,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;GAEG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAC/B,MAAM,CAAC,EAAE,YAAY,EACrB,aAAa,CAAC,EAAE,SAAS,EACzB,UAAU,CAAC,EAAE,SAAS,EACtB,YAAY,CAAC,EAAE,WAAW,GACzB,OAAO,CAAC;IACT,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;IAC/B,YAAY,CAAC,EAAE,SAAS,GAAG,SAAS,EAAE,CAAC;CACxC,CAAC,CAoQD"}

package/lib/DboBuilder/insertDataParse.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertDataParse = void 0;
 const prostgles_types_1 = require("prostgles-types");
-const DboBuilder_1 = require("../DboBuilder");
 const PubSubManager_1 = require("../PubSubManager");
 const uploadFile_1 = require("./uploadFile");
 /**
@@ -18,7 +17,7 @@ async function insertDataParse(data, param2, param3_unused, tableRules, _localPa
             return !this.column_names.concat(MEDIA_COL_NAMES).includes(k);
         }
         else if (!this.columns.find(c => c.name === k)) {
-            if (!(0, DboBuilder_1.isPojoObject)(d[k]) && !Array.isArray(d[k])) {
+            if (!(0, prostgles_types_1.isObject)(d[k]) && !Array.isArray(d[k])) {
                 throw new Error("Invalid/Dissalowed field in data: " + k);
             }
             else if (!this.dboBuilder.dbo[k]) {
@@ -30,7 +29,7 @@ async function insertDataParse(data, param2, param3_unused, tableRules, _localPa
     });
     const ALLOWED_COL_TYPES = ["int2", "int4", "int8", "numeric", "uuid", "text", "varchar", "char"];
     const getColumnInserts = (d) => (0, prostgles_types_1.getKeys)(d)
-        .filter(k => d[k] && (0, DboBuilder_1.isPojoObject)(d[k]))
+        .filter(k => d[k] && (0, prostgles_types_1.isObject)(d[k]))
         .map(k => {
         const insertedCol = this.columns.find(c => c.name === k &&
             ALLOWED_COL_TYPES.includes(c.udt_name));

package/lib/DboBuilder/insertDataParse.ts

@@ -1,8 +1,9 @@
-import { AnyObject, asName, FieldFilter, get, getKeys, InsertParams, isDefined, isObject, PG_COLUMN_UDT_DATA_TYPE } from "prostgles-types";
-import { DboBuilder, isPojoObject, LocalParams, makeErr, Media, parseError, pgp, TableHandler, TableHandlers } from "../DboBuilder";
+import { AnyObject, getKeys, InsertParams, isDefined, isObject, PG_COLUMN_UDT_DATA_TYPE } from "prostgles-types";
+import { LocalParams, TableHandlers } from "../DboBuilder";
 import { TableRule } from "../PublishParser";
 import { omitKeys } from "../PubSubManager";
-import { isFile, uploadFile } from "./uploadFile";
+import { TableHandler } from "./TableHandler";
+import { uploadFile } from "./uploadFile";
 
 /**
  * Used for doing referenced inserts within a single transaction
@@ -27,7 +28,7 @@ export async function insertDataParse(
     if(this.is_media){
       return !this.column_names.concat(MEDIA_COL_NAMES).includes(k)
     } else if(!this.columns.find(c => c.name === k)){
-      if(!isPojoObject(d[k]) && !Array.isArray(d[k])){
+      if(!isObject(d[k]) && !Array.isArray(d[k])){
         throw new Error("Invalid/Dissalowed field in data: " + k)
       } else if(!this.dboBuilder.dbo[k]){
         throw new Error("Invalid/Dissalowed nested insert table name in data: " + k)
@@ -38,7 +39,7 @@ export async function insertDataParse(
   });
   const ALLOWED_COL_TYPES: PG_COLUMN_UDT_DATA_TYPE[] = ["int2", "int4", "int8", "numeric", "uuid", "text", "varchar", "char"];
   const getColumnInserts = (d: AnyObject) => getKeys(d)
-    .filter(k => d[k] && isPojoObject(d[k]))
+    .filter(k => d[k] && isObject(d[k]))
     .map(k => {
       const insertedCol = this.columns.find(c => 
         c.name === k && 

package/lib/DboBuilder/parseUpdateRules.d.ts

@@ -0,0 +1,18 @@
+import { AnyObject, FieldFilter, UpdateParams } from "prostgles-types";
+import { Filter, LocalParams } from "../DboBuilder";
+import { TableRule, ValidateRow } from "../PublishParser";
+import { TableHandler } from "./TableHandler";
+/**
+ * 1) Check if publish is valid
+ * 2) Retrieve allowed update cols for a specific request
+ */
+export declare function parseUpdateRules(this: TableHandler, filter: Filter, newData: AnyObject, params?: UpdateParams, tableRules?: TableRule, localParams?: LocalParams): Promise<{
+    fields: string[];
+    validateRow?: ValidateRow;
+    finalUpdateFilter: AnyObject;
+    forcedData?: AnyObject;
+    forcedFilter?: AnyObject;
+    returningFields: FieldFilter;
+    filterFields?: FieldFilter;
+}>;
+//# sourceMappingURL=parseUpdateRules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseUpdateRules.d.ts","sourceRoot":"","sources":["parseUpdateRules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAa,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,SAAS,EAAc,WAAW,EAAqB,MAAM,kBAAkB,CAAC;AACzF,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,SAAS,EAClB,MAAM,CAAC,EAAE,YAAY,EACrB,UAAU,CAAC,EAAE,SAAS,EACtB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC;IACT,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,iBAAiB,EAAE,SAAS,CAAC;IAC7B,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,eAAe,EAAE,WAAW,CAAC;IAC7B,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B,CAAC,CAmID"}

package/lib/DboBuilder/parseUpdateRules.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUpdateRules = void 0;
+const prostgles_types_1 = require("prostgles-types");
+/**
+ * 1) Check if publish is valid
+ * 2) Retrieve allowed update cols for a specific request
+ */
+async function parseUpdateRules(filter, newData, params, tableRules, localParams) {
+    const { testRule = false } = localParams ?? {};
+    if (!testRule) {
+        if (!newData || !Object.keys(newData).length) {
+            throw "no update data provided\nEXPECTING db.table.update(filter, updateData, options)";
+        }
+        this.checkFilter(filter);
+    }
+    let forcedFilter = {}, forcedData = {}, validate, returningFields = "*", filterFields = "*", fields = "*";
+    let finalUpdateFilter = { ...filter };
+    if (tableRules) {
+        if (!tableRules.update)
+            throw "update rules missing for " + this.name;
+        ({ forcedFilter, forcedData, fields, filterFields, validate } = tableRules.update);
+        returningFields = tableRules.update.returningFields ?? tableRules?.select?.fields ?? "";
+        if (!returningFields && params?.returning) {
+            throw "You are not allowed to return any fields from the update";
+        }
+        if (!fields) {
+            throw ` Invalid update rule fo r ${this.name}. fields missing `;
+        }
+        finalUpdateFilter = (await this.prepareWhere({ filter, forcedFilter, filterFields, localParams, tableRule: tableRules })).filter;
+        if (forcedFilter) {
+            const match = await this.findOne(finalUpdateFilter);
+            if (!match) {
+                fields = [];
+            }
+        }
+        if (tableRules.update.dynamicFields?.length) {
+            /**
+             * dynamicFields.fields used to allow a custom list of fields for specific records
+             * dynamicFields.filter cannot overlap each other
+             * updates must target records from a specific dynamicFields.filter or not match any dynamicFields.filter
+             */
+            if (testRule) {
+                for await (const [dfIndex, dfRule] of tableRules.update.dynamicFields.entries()) {
+                    const condition = await this.getCondition({ allowed_colnames: this.column_names, filter: dfRule.filter });
+                    if (!condition)
+                        throw "dynamicFields.filter cannot be empty: " + JSON.stringify(dfRule);
+                    await this.find(dfRule.filter, { limit: 0 });
+                    /** Ensure dynamicFields filters do not overlap */
+                    for await (const [_dfIndex, _dfRule] of tableRules.update.dynamicFields.entries()) {
+                        if (dfIndex !== _dfIndex) {
+                            if (await this.findOne({ $and: [dfRule.filter, _dfRule.filter] }, { select: "" })) {
+                                throw `dynamicFields.filter cannot overlap each other. \n
+                                Overlapping dynamicFields rules:
+                                    ${JSON.stringify(dfRule)} 
+                                    AND
+                                    ${JSON.stringify(_dfRule)} 
+                                `;
+                            }
+                        }
+                    }
+                }
+            }
+            /** Pick dynamicFields.fields if matching filter */
+            let matchedRule;
+            for await (const dfRule of tableRules.update.dynamicFields) {
+                const match = await this.findOne({ $and: [finalUpdateFilter, dfRule.filter].filter(prostgles_types_1.isDefined) });
+                if (match) {
+                    /** Ensure it doesn't overlap with other dynamicFields.filter */
+                    if (matchedRule) {
+                        throw "Your update is targeting multiple tableRules.update.dynamicFields. Restrict update filter to only target one rule";
+                    }
+                    matchedRule = dfRule;
+                    fields = dfRule.fields;
+                }
+            }
+        }
+        /* Safely test publish rules */
+        if (testRule) {
+            await this.validateViewRules({ fields, filterFields, returningFields, forcedFilter, dynamicFields: tableRules.update.dynamicFields, rule: "update" });
+            if (forcedData) {
+                try {
+                    const { data, allowedCols } = this.validateNewData({ row: forcedData, forcedData: undefined, allowedFields: "*", tableRules, fixIssues: false });
+                    const updateQ = await this.colSet.getUpdateQuery(data, allowedCols, this.dbTX || this.dboBuilder.dbo, validate ? ((row) => validate({ update: row, filter: {} }, this.dbTX || this.dboBuilder.dbo)) : undefined); //pgp.helpers.update(data, columnSet)
+                    let query = updateQ + " WHERE FALSE ";
+                    await this.db.any("EXPLAIN " + query);
+                }
+                catch (e) {
+                    throw " issue with forcedData: \nVALUE: " + JSON.stringify(forcedData, null, 2) + "\nERROR: " + e;
+                }
+            }
+            return true;
+        }
+    }
+    /* Update all allowed fields (fields) except the forcedFilter (so that the user cannot change the forced filter values) */
+    let _fields = this.parseFieldFilter(fields);
+    /**
+     * A forced filter must be basic
+     */
+    if (forcedFilter) {
+        const _forcedFilterKeys = Object.keys(forcedFilter);
+        const nonFields = _forcedFilterKeys.filter(key => !this.column_names.includes(key));
+        if (nonFields.length)
+            throw "forcedFilter must be a basic filter ( { col_name: 'value' } ). Invalid filter keys: " + nonFields;
+        // const clashingFields = _forcedFilterKeys.filter(key => _fields.includes(key));
+    }
+    const validateRow = validate ? (row) => validate({ update: row, filter: finalUpdateFilter }, this.dbTX || this.dboBuilder.dbo) : undefined;
+    return {
+        fields: _fields,
+        validateRow,
+        finalUpdateFilter,
+        forcedData,
+        forcedFilter,
+        returningFields,
+        filterFields,
+    };
+}
+exports.parseUpdateRules = parseUpdateRules;