prostgles-server 4.2.179 → 4.2.181

package/lib/DBSchemaBuilder.ts

@@ -1,112 +1,144 @@
-import { AnyObject, DbJoinMaker, DBSchema, isObject, JSONB, SQLHandler, TableHandler, ViewHandler } from "prostgles-types";
+import {
+  AnyObject,
+  DbJoinMaker,
+  DBSchema,
+  isObject,
+  JSONB,
+  SQLHandler,
+  TableHandler,
+  ViewHandler,
+} from "prostgles-types";
 import prostgles from ".";
 import { Auth } from "./Auth/AuthTypes";
 import { DboBuilder, escapeTSNames, postgresToTsType } from "./DboBuilder/DboBuilder";
-import { PublishAllOrNothing, PublishParams, PublishTableRule, PublishViewRule,  } from "./PublishParser/PublishParser";
+import {
+  PublishAllOrNothing,
+  PublishParams,
+  PublishTableRule,
+  PublishViewRule,
+} from "./PublishParser/PublishParser";
 import { getJSONBSchemaTSTypes } from "./JSONBValidation/validation";
 import { DBHandlerServer, TableSchemaColumn, TX } from "./DboBuilder/DboBuilderTypes";
 
-
 export const getDBSchema = (dboBuilder: DboBuilder): string => {
   const tables: string[] = [];
 
   const getColTypeForDBSchema = (udt_name: TableSchemaColumn["udt_name"]): string => {
-    if(udt_name === "interval"){
-      const units = [ "years", "months", "days", "hours", "minutes", "seconds", "milliseconds"];
-      
-      return `{ ${units.map(u => `${u}?: number;`).join(" ")} }`;
+    if (udt_name === "interval") {
+      const units = ["years", "months", "days", "hours", "minutes", "seconds", "milliseconds"];
+
+      return `{ ${units.map((u) => `${u}?: number;`).join(" ")} }`;
     }
 
     return postgresToTsType(udt_name);
-  }
-  
+  };
+
   /** Tables and columns are sorted to avoid infinite loops due to changing order */
-  dboBuilder.tablesOrViews?.slice(0).sort((a, b) => a.name.localeCompare(b.name)).forEach(tov => {
-    const cols = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
-    const getColType = (c: typeof cols[number]) => {
-
-      let type: string = (c.is_nullable? "null | " : "") + getColTypeForDBSchema(c.udt_name) + ";"
-      const colConf = dboBuilder.prostgles.tableConfigurator?.getColumnConfig(tov.name, c.name);
-      if(colConf){
-        if(isObject(colConf) && (colConf.jsonbSchema || colConf.jsonbSchemaType)){
-          const schema: JSONB.JSONBSchema = colConf.jsonbSchema || { ...colConf, type: colConf.jsonbSchemaType };
-          
-          type = getJSONBSchemaTSTypes(schema, { nullable: colConf.nullable }, "      ", dboBuilder.tablesOrViews ?? []);
-        } else if(isObject(colConf) && "enum" in colConf){
-          if(!colConf.enum) throw "colConf.enum missing"
-          const types = colConf.enum.map(t => typeof t === "number"? t : JSON.stringify(t));
-          if(colConf.nullable){
-            types.unshift("null")
+  dboBuilder.tablesOrViews
+    ?.slice(0)
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .forEach((tov) => {
+      const cols = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
+      const getColType = (c: (typeof cols)[number]) => {
+        let type: string =
+          (c.is_nullable ? "null | " : "") + getColTypeForDBSchema(c.udt_name) + ";";
+        const colConf = dboBuilder.prostgles.tableConfigurator?.getColumnConfig(tov.name, c.name);
+        if (colConf) {
+          if (isObject(colConf) && (colConf.jsonbSchema || colConf.jsonbSchemaType)) {
+            const schema: JSONB.JSONBSchema = colConf.jsonbSchema || {
+              ...colConf,
+              type: colConf.jsonbSchemaType,
+            };
+
+            type = getJSONBSchemaTSTypes(
+              schema,
+              { nullable: colConf.nullable },
+              "      ",
+              dboBuilder.tablesOrViews ?? []
+            );
+          } else if (isObject(colConf) && "enum" in colConf) {
+            if (!colConf.enum) throw "colConf.enum missing";
+            const types = colConf.enum.map((t) => (typeof t === "number" ? t : JSON.stringify(t)));
+            if (colConf.nullable) {
+              types.unshift("null");
+            }
+            type = types.join(" | ");
           }
-          type = types.join(" | ");
         }
-      }
-      /**
-       * Columns that are nullable or have default values can be ommitted from an insert
-       * Non nullable columns with default values cannot containt null values in an insert so they must contain a valid value or be omitted
-       */
-      return `${escapeTSNames(c.name)}${c.is_nullable || c.has_default? "?" : ""}: ${type}`
-    }
-tables.push(`${escapeTSNames(tov.name)}: {
+        /**
+         * Columns that are nullable or have default values can be ommitted from an insert
+         * Non nullable columns with default values cannot containt null values in an insert so they must contain a valid value or be omitted
+         */
+        return `${escapeTSNames(c.name)}${c.is_nullable || c.has_default ? "?" : ""}: ${type}`;
+      };
+      tables.push(`${escapeTSNames(tov.name)}: {
     is_view: ${tov.is_view};
     select: ${tov.privileges.select};
     insert: ${tov.privileges.insert};
     update: ${tov.privileges.update};
     delete: ${tov.privileges.delete};
-    columns: {${cols.map(c => `
-      ${getColType(c)}`).join("")}
+    columns: {${cols
+      .map(
+        (c) => `
+      ${getColType(c)}`
+      )
+      .join("")}
     };
-  };\n  `)
-  })
-return `
-export type DBSchemaGenerated = {
+  };\n  `);
+    });
+  return `
+export type DBGeneratedSchema = {
   ${tables.join("")}
 }
 `;
-}
-
-type ServerViewHandler<T extends AnyObject = AnyObject, Schema extends DBSchema | void = void> = ViewHandler<T, Schema> & { is_view: boolean; }
-type ServerTableHandler<T extends AnyObject = AnyObject, Schema extends DBSchema | void = void> = TableHandler<T, Schema> & { is_view: boolean; }
-
-export type DBTableHandlersFromSchema<Schema = void> = Schema extends DBSchema? { 
-  [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true? 
-    ServerViewHandler<Schema[tov_name]["columns"], Schema> : 
-    ServerTableHandler<Schema[tov_name]["columns"], Schema>
-} : Record<string, Partial<ServerTableHandler>>;
+};
+
+type ServerViewHandler<
+  T extends AnyObject = AnyObject,
+  Schema extends DBSchema | void = void,
+> = ViewHandler<T, Schema> & { is_view: boolean };
+type ServerTableHandler<
+  T extends AnyObject = AnyObject,
+  Schema extends DBSchema | void = void,
+> = TableHandler<T, Schema> & { is_view: boolean };
+
+export type DBTableHandlersFromSchema<Schema = void> =
+  Schema extends DBSchema ?
+    {
+      [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true ?
+        ServerViewHandler<Schema[tov_name]["columns"], Schema>
+      : ServerTableHandler<Schema[tov_name]["columns"], Schema>;
+    }
+  : Record<string, Partial<ServerTableHandler>>;
 
-export type DBHandlerServerExtra<TH = Record<string, Partial<ServerTableHandler>>, WithTransactions = true> = {
+export type DBHandlerServerExtra<
+  TH = Record<string, Partial<ServerTableHandler>>,
+  WithTransactions = true,
+> = {
   sql: SQLHandler;
-} & Partial<DbJoinMaker> & (
-  WithTransactions extends true? { tx: TX<TH> } :
-  Record<string, never>
-);
+} & Partial<DbJoinMaker> &
+  (WithTransactions extends true ? { tx: TX<TH> } : Record<string, never>);
 // export type DBOFullyTyped<Schema = void> = Schema extends DBSchema? (
 //     DBTableHandlersFromSchema<Schema> & DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>
-//   ) : 
+//   ) :
 //   DBHandlerServer;
-export type DBOFullyTyped<Schema = void> = DBTableHandlersFromSchema<Schema> & DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>
-
-export type PublishFullyTyped<Schema = void> = Schema extends DBSchema? (
-  | PublishAllOrNothing 
-  | { 
-    [tov_name in keyof Partial<Schema>]: 
-      | PublishAllOrNothing 
-      | (
-        Schema[tov_name]["is_view"] extends true? 
-          PublishViewRule<Schema[tov_name]["columns"], Schema> : 
-          PublishTableRule<Schema[tov_name]["columns"], Schema>
-      );
-  }
-) : (
-  | PublishAllOrNothing 
-  | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>
-);
-
-
+export type DBOFullyTyped<Schema = void> = DBTableHandlersFromSchema<Schema> &
+  DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>;
+
+export type PublishFullyTyped<Schema = void> =
+  Schema extends DBSchema ?
+    | PublishAllOrNothing
+    | {
+        [tov_name in keyof Partial<Schema>]:
+          | PublishAllOrNothing
+          | (Schema[tov_name]["is_view"] extends true ?
+              PublishViewRule<Schema[tov_name]["columns"], Schema>
+            : PublishTableRule<Schema[tov_name]["columns"], Schema>);
+      }
+  : PublishAllOrNothing | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>;
 
 /** Type checks */
-(() => {
-
+() => {
   const ddb: DBOFullyTyped = 1 as any;
   ddb.dwad?.insert;
   ddb.dwad?.delete;
@@ -124,102 +156,100 @@ export type PublishFullyTyped<Schema = void> = Schema extends DBSchema? (
     dbConnection: 1 as any,
     publish: async (params) => {
       const _rows = await params.dbo.dwadwa?.find?.({});
-      
-      return "*" as const
+
+      return "*" as const;
     },
     transactions: true,
     onReady: ({ dbo }) => {
       dbo.tdwa?.find!();
-      dbo.tx?.(t => {
+      dbo.tx?.((t) => {
         t.dwa?.find!();
-      })
-    }
+      });
+    },
   });
 
-
   const _auth: Auth = {
     sidKeyName: "sid_token",
     getUser: async (sid, db, _db) => {
       db.dwadaw?.find;
       return 1 as any;
-    }
-  }
-
+    },
+  };
 
   type S = {
     tbl1: {
       columns: {
         col1: number | null;
-        col2: string; 
-      }
-    },
+        col2: string;
+      };
+    };
     tbl2: {
       columns: {
         col1: number | null;
-        col2: string; 
-      }
-    }
-  }
+        col2: string;
+      };
+    };
+  };
 
   /** Test the created schema */
   const c: S = 1 as any;
   const _test: DBSchema = c;
   const dbt: DBOFullyTyped<S> = 1 as any;
 
-  dbt.tx!(t => {
+  dbt.tx!((t) => {
     t.tbl1.delete();
   });
 
   const db: DBHandlerServer = 1 as any;
-  db.tx!(t => {
-    t.wadwa?.find!()
+  db.tx!((t) => {
+    t.wadwa?.find!();
   });
-  
+
   const _publish = (): PublishFullyTyped<S> => {
     const r = {
       tbl1: {
         select: {
-          fields: "*" as const, 
-          forcedFilter: { col1: 32, col2: "" }
+          fields: "*" as const,
+          forcedFilter: { col1: 32, col2: "" },
         },
         getColumns: true,
         getInfo: true,
         delete: {
-          filterFields: {col1: 1}
-        }
+          filterFields: { col1: 1 },
+        },
       },
       tbl2: {
         delete: {
           filterFields: "*" as const,
-          forcedFilter: {col1: 2}
-        }
-      }
-    }
+          forcedFilter: { col1: 2 },
+        },
+      },
+    };
     const res: PublishFullyTyped<S> = {
       tbl1: {
         select: {
           fields: "*",
-          forcedFilter: { col1: 32, col2: "" }
+          forcedFilter: { col1: 32, col2: "" },
         },
         getColumns: true,
         getInfo: true,
         delete: {
-          filterFields: { col1: 1 }
-        }
+          filterFields: { col1: 1 },
+        },
       },
       tbl2: {
         delete: {
           filterFields: "*" as const,
-          forcedFilter: { col1: 2 }
-        }
-      }
-    }
-    const _res1: PublishFullyTyped = r
-  
+          forcedFilter: { col1: 2 },
+        },
+      },
+    };
+    const _res1: PublishFullyTyped = r;
+
     const p: PublishParams<undefined> = 1 as any;
-  
+
     p.dbo.dwadaw?.find?.();
-  
+
     return res;
-  }
-})
+  };
+};

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 });
   }
-} 
+}