prostgles-server 4.2.178 → 4.2.180

package/lib/DboBuilder/TableHandler/DataValidator.ts

@@ -82,7 +82,7 @@ type PrepareFieldValuesArgs = {
   row: AnyObject | undefined; 
   forcedData: AnyObject | undefined; 
   allowedCols: FieldFilter | undefined;
-  removeDisallowedColumns?: boolean;
+  removeDisallowedFields?: boolean;
   tableHandler: TableHandler;
 }
 /** 
@@ -94,7 +94,7 @@ type PrepareFieldValuesArgs = {
 * @param {Object} forcedData - set/override property
 * @param {string[]} allowed_cols - allowed columns (excluding forcedData) from table rules
 */
-const getValidatedRow = ({ row = {}, forcedData = {}, allowedCols, removeDisallowedColumns = false, tableHandler }: PrepareFieldValuesArgs): AnyObject => {
+const getValidatedRow = ({ row = {}, forcedData = {}, allowedCols, removeDisallowedFields = false, tableHandler }: PrepareFieldValuesArgs): AnyObject => {
   const column_names = tableHandler.column_names.slice(0);
   if (!column_names.length) {
     throw "table column_names mising";
@@ -102,7 +102,7 @@ const getValidatedRow = ({ row = {}, forcedData = {}, allowedCols, removeDisallo
   const validatedAllowedColumns = tableHandler.parseFieldFilter(allowedCols, false);
  
   let finalRow = { ...row };
-  if (removeDisallowedColumns && !isEmpty(finalRow)) {
+  if (removeDisallowedFields && !isEmpty(finalRow)) {
     finalRow = pickKeys(finalRow, validatedAllowedColumns);
   }
 
@@ -124,7 +124,7 @@ const getValidatedRow = ({ row = {}, forcedData = {}, allowedCols, removeDisallo
  * prepareFieldValues(): Apply forcedData, remove disallowed columns, validate against allowed columns
  * tableConfigurator?.checkColVal(): Validate column min/max/isText/lowerCased/trimmed values
  */
-export const prepareNewData = async ({ row, forcedData, allowedFields, tableRules, fixIssues = false, tableConfigurator, tableHandler }: ValidatedParams) => {
+export const prepareNewData = async ({ row, forcedData, allowedFields, tableRules, removeDisallowedFields = false, tableConfigurator, tableHandler }: ValidatedParams) => {
   const synced_field = (tableRules ?? {})?.sync?.synced_field;
 
   /* Update synced_field if sync is on and missing */
@@ -132,7 +132,7 @@ export const prepareNewData = async ({ row, forcedData, allowedFields, tableRule
     row[synced_field] = Date.now();
   }
 
-  const data = getValidatedRow({ tableHandler, row, forcedData, allowedCols: allowedFields , removeDisallowedColumns: fixIssues });
+  const data = getValidatedRow({ tableHandler, row, forcedData, allowedCols: allowedFields, removeDisallowedFields });
   const dataKeys = getKeys(data);
 
   dataKeys.forEach(col => {

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -22,7 +22,7 @@ export type ValidatedParams = {
   forcedData?: AnyObject;
   allowedFields?: FieldFilter;
   tableRules?: TableRule;
-  fixIssues: boolean;
+  removeDisallowedFields: boolean;
   tableConfigurator: TableConfigurator | undefined;
   tableHandler: TableHandler;
 }

package/lib/DboBuilder/TableHandler/insert.ts

@@ -13,7 +13,7 @@ export async function insert(this: TableHandler, rowOrRows: AnyObject | AnyObjec
   const start = Date.now();
   try {
 
-    const { fixIssues = false } = insertParams || {};
+    const { removeDisallowedFields = false } = insertParams || {};
     const { returnQuery = false, nestedInsert } = localParams || {};
  
     const finalDBtx = this.getFinalDBtx(localParams);
@@ -79,7 +79,7 @@ export async function insert(this: TableHandler, rowOrRows: AnyObject | AnyObjec
           forcedData, 
           allowedFields: fields, 
           tableRules, 
-          fixIssues, 
+          removeDisallowedFields, 
           tableConfigurator: this.dboBuilder.prostgles.tableConfigurator, 
           tableHandler: this, 
         });
@@ -165,7 +165,7 @@ const validateInsertParams = (params: InsertParams | undefined) => {
   }
 
   if (params) {
-    const good_paramsObj: Record<keyof InsertParams, 1> = { returning: 1, returnType: 1, fixIssues: 1, onConflict: 1 };
+    const good_paramsObj: Record<keyof InsertParams, 1> = { returning: 1, returnType: 1, removeDisallowedFields: 1, onConflict: 1 };
     const good_params = Object.keys(good_paramsObj);
     const bad_params = Object.keys(params).filter(k => !good_params.includes(k));
     if (bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");

package/lib/DboBuilder/TableHandler/update.ts

@@ -1,30 +1,46 @@
 import { AnyObject, UpdateParams } from "prostgles-types";
 import { TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import {
+  Filter,
+  LocalParams,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  withUserRLS,
+} from "../DboBuilder";
 import { getInsertTableRules, getReferenceColumnInserts } from "../insertNestedRecords";
 import { prepareNewData } from "./DataValidator";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 import { TableHandler } from "./TableHandler";
 import { updateFile } from "./updateFile";
 
-export async function update(this: TableHandler, filter: Filter, _newData: AnyObject, params?: UpdateParams, tableRules?: TableRule, localParams?: LocalParams): Promise<AnyObject | void> {
+export async function update(
+  this: TableHandler,
+  filter: Filter,
+  _newData: AnyObject,
+  params?: UpdateParams,
+  tableRules?: TableRule,
+  localParams?: LocalParams
+): Promise<AnyObject | void> {
   const ACTION = "update";
   const start = Date.now();
   try {
     /** postValidate */
     const finalDBtx = this.getFinalDBtx(localParams);
-    const wrapInTx = () => this.dboBuilder.getTX(_dbtx => _dbtx[this.name]?.[ACTION]?.(filter, _newData, params, tableRules, localParams))
-    const rule = tableRules?.[ACTION]
-    if(rule?.postValidate && !finalDBtx){
+    const wrapInTx = () =>
+      this.dboBuilder.getTX((_dbtx) =>
+        _dbtx[this.name]?.[ACTION]?.(filter, _newData, params, tableRules, localParams)
+      );
+    const rule = tableRules?.[ACTION];
+    if (rule?.postValidate && !finalDBtx) {
       return wrapInTx();
     }
 
     let newData = _newData;
-    if(this.is_media){
+    if (this.is_media) {
       ({ newData } = await updateFile.bind(this)({ newData, filter, localParams, tableRules }));
     }
 
-    const parsedRules = await this.parseUpdateRules(filter, params, tableRules, localParams)
+    const parsedRules = await this.parseUpdateRules(filter, params, tableRules, localParams);
     if (localParams?.testRule) {
       return parsedRules;
     }
@@ -33,25 +49,34 @@ export async function update(this: TableHandler, filter: Filter, _newData: AnyOb
       throw "no update data provided\nEXPECTING db.table.update(filter, updateData, options)";
     }
 
-    const { fields, validateRow, forcedData,  returningFields, forcedFilter, filterFields } = parsedRules;
-    const { onConflict, fixIssues = false } = params || {};
+    const { fields, validateRow, forcedData, returningFields, forcedFilter, filterFields } =
+      parsedRules;
+    const { removeDisallowedFields = false } = params || {};
     const { returnQuery = false } = localParams ?? {};
 
     if (params) {
-      const good_paramsObj: Record<keyof UpdateParams, 1> = { returning: 1, returnType: 1, fixIssues: 1, onConflict: 1, multi: 1 };
+      const good_paramsObj: Record<keyof UpdateParams, 1> = {
+        returning: 1,
+        returnType: 1,
+        removeDisallowedFields: 1,
+        multi: 1,
+      };
       const good_params = Object.keys(good_paramsObj);
-      const bad_params = Object.keys(params).filter(k => !good_params.includes(k));
-      if (bad_params && bad_params.length) throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
+      const bad_params = Object.keys(params).filter((k) => !good_params.includes(k));
+      if (bad_params && bad_params.length)
+        throw (
+          "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ")
+        );
     }
 
-    const { data, allowedCols } = await prepareNewData({ 
-      row: newData, 
-      forcedData, 
-      allowedFields: fields, 
-      tableRules, 
-      fixIssues,
+    const { data, allowedCols } = await prepareNewData({
+      row: newData,
+      forcedData,
+      allowedFields: fields,
+      tableRules,
+      removeDisallowedFields,
       tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
-      tableHandler: this, 
+      tableHandler: this,
     });
 
     const updateFilter = await this.prepareWhere({
@@ -60,46 +85,68 @@ export async function update(this: TableHandler, filter: Filter, _newData: AnyOb
       forcedFilter,
       filterFields,
       localParams,
-      tableRule: tableRules
-    })
-    
+      tableRule: tableRules,
+    });
+
     /**
      * Nested inserts
      */
     const nData = { ...data };
     const nestedInserts = getReferenceColumnInserts(this, nData, true);
     const nestedInsertsResultsObj: Record<string, any> = {};
-    if(nestedInserts.length){
+    if (nestedInserts.length) {
       const updateCount = await this.count(updateFilter.filter);
-      if(+updateCount > 1){
+      if (+updateCount > 1) {
         throw "Cannot do a nestedInsert from an update that targets more than 1 row";
       }
-      if(!finalDBtx){
+      if (!finalDBtx) {
         return wrapInTx();
       }
-      await Promise.all(nestedInserts.map(async nestedInsert => {
-        const nesedTableHandler = finalDBtx[nestedInsert.tableName] as TableHandler | undefined;
-        if(!nesedTableHandler) throw `nestedInsert Tablehandler not found for ${nestedInsert.tableName}`;
-        const refTableRules = !localParams? undefined : await getInsertTableRules(this, nestedInsert.tableName, localParams);
-        const nestedLocalParams: LocalParams = { ...localParams, nestedInsert: { depth: 1, previousData: nData, previousTable: this.name, referencingColumn: nestedInsert.col } }
-        const nestedInsertResult = await nesedTableHandler.insert(nestedInsert.data, { returning: "*" }, undefined, refTableRules, nestedLocalParams);
-        nestedInsertsResultsObj[nestedInsert.col] = nestedInsertResult;
+      await Promise.all(
+        nestedInserts.map(async (nestedInsert) => {
+          const nesedTableHandler = finalDBtx[nestedInsert.tableName] as TableHandler | undefined;
+          if (!nesedTableHandler)
+            throw `nestedInsert Tablehandler not found for ${nestedInsert.tableName}`;
+          const refTableRules = !localParams
+            ? undefined
+            : await getInsertTableRules(this, nestedInsert.tableName, localParams);
+          const nestedLocalParams: LocalParams = {
+            ...localParams,
+            nestedInsert: {
+              depth: 1,
+              previousData: nData,
+              previousTable: this.name,
+              referencingColumn: nestedInsert.col,
+            },
+          };
+          const nestedInsertResult = await nesedTableHandler.insert(
+            nestedInsert.data,
+            { returning: "*" },
+            undefined,
+            refTableRules,
+            nestedLocalParams
+          );
+          nestedInsertsResultsObj[nestedInsert.col] = nestedInsertResult;
 
-        nData[nestedInsert.col] = nestedInsertResult[nestedInsert.fcol];
-        return {
-          ...nestedInsert,
-          result: nestedInsertResult,
-        }
-      }));
+          nData[nestedInsert.col] = nestedInsertResult[nestedInsert.fcol];
+          return {
+            ...nestedInsert,
+            result: nestedInsertResult,
+          };
+        })
+      );
     }
 
-    // let query = await this.colSet.getUpdateQuery(nData, allowedCols, this.getFinalDbo(localParams), validateRow, localParams)
-    let query = (await this.dataValidator.parse({ command: "update", rows: [nData], allowedCols, dbTx: this.getFinalDbo(localParams), validationOptions: { validate: validateRow, localParams }})).getQuery()
+    let query = (
+      await this.dataValidator.parse({
+        command: "update",
+        rows: [nData],
+        allowedCols,
+        dbTx: this.getFinalDbo(localParams),
+        validationOptions: { validate: validateRow, localParams },
+      })
+    ).getQuery();
     query += "\n" + updateFilter.where;
-    if (onConflict === "DoNothing") query += " ON CONFLICT DO NOTHING ";
-    if(onConflict === "DoUpdate"){
-      throw "onConflict 'DoUpdate' not possible for an update";
-    }
     const queryWithoutUserRLS = query;
     query = withUserRLS(localParams, query);
 
@@ -115,12 +162,23 @@ export async function update(this: TableHandler, filter: Filter, _newData: AnyOb
       returningFields,
       rule,
       type: "update",
-      nestedInsertsResultsObj
+      nestedInsertsResultsObj,
+    });
+    await this._log({
+      command: "update",
+      localParams,
+      data: { filter, _newData, params },
+      duration: Date.now() - start,
     });
-    await this._log({ command: "update", localParams, data: { filter, _newData, params }, duration: Date.now() - start });
     return result;
   } catch (e) {
-    await this._log({ command: "update", localParams, data: { filter, _newData, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
+    await this._log({
+      command: "update",
+      localParams,
+      data: { filter, _newData, params },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
     throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
   }
-} 
+}

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -353,7 +353,7 @@ export class ViewHandler {
    */
   prepareWhere = prepareWhere.bind(this); 
 
-  intersectColumns(allowedFields: FieldFilter, dissallowedFields: FieldFilter, fixIssues = false): string[] {
+  intersectColumns(allowedFields: FieldFilter, dissallowedFields: FieldFilter, removeDisallowedFields = false): string[] {
     let result: string[] = [];
     if (allowedFields) {
       result = this.parseFieldFilter(allowedFields);
@@ -361,7 +361,7 @@ export class ViewHandler {
     if (dissallowedFields) {
       const _dissalowed = this.parseFieldFilter(dissallowedFields);
 
-      if (!fixIssues) {
+      if (!removeDisallowedFields) {
 
         throw `dissallowed/invalid field found for ${this.name}: `
       }

package/lib/DboBuilder/parseUpdateRules.ts

@@ -136,7 +136,7 @@ export async function parseUpdateRules(
             forcedData: undefined, 
             allowedFields: "*", 
             tableRules, 
-            fixIssues: false, 
+            removeDisallowedFields: false, 
             tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
             tableHandler: this,
           });

package/lib/Logging.ts

@@ -1,4 +1,4 @@
-import { AnyObject } from "prostgles-types";
+import { AnyObject, ClientSchema } from "prostgles-types";
 import { LocalParams } from "./DboBuilder/DboBuilder";
 import { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
 
@@ -93,7 +93,7 @@ export namespace EventTypes {
   | { command: "login"; } 
   );
 
-  export type Debug = DebugInfo & {
+  export type Debug = DebugInfo & ({
     type: "debug";
     command: 
     | "initFileTable" 
@@ -112,7 +112,11 @@ export namespace EventTypes {
     | "DboBuilder.getTablesForSchemaPostgresSQL"
     | "PubSubManager.create"
     data?: AnyObject;
-  }
+  } | {
+    type: "debug";
+    command: "pushSocketSchema";
+    data: { socketId: string, clientSchema: ClientSchema; }
+  })
 }
 
 export type EventInfo =