prostgles-server 4.2.556 → 4.2.558

package/lib/DboBuilder/TableHandler/insert/insert.ts

@@ -1,20 +1,17 @@
 import type { AnyObject, InsertParams } from "prostgles-types";
-import {
-  asName,
-  getJSONBSchemaValidationError,
-  getSerialisableError,
-  isObject,
-} from "prostgles-types";
-import type { ParsedTableRule, ValidateRowBasic } from "../../../PublishParser/PublishParser";
+import { getJSONBSchemaValidationError, getSerialisableError, isObject } from "prostgles-types";
+import type { ParsedTableRule } from "../../../PublishParser/PublishParser";
+import { isArray } from "../../../utils/utils";
 import type { LocalParams } from "../../DboBuilder";
 import { getSerializedClientErrorFromPGError, withUserRLS } from "../../DboBuilder";
-import { prepareNewData } from "../DataValidator";
+import { getReturnTypeQuery } from "../../ViewHandler/getReturnTypeQuery";
 import type { TableHandler } from "../TableHandler";
 import { insertTest } from "../insertTest";
 import { runInsertUpdateQuery } from "../runInsertUpdateQuery";
+import { getInsertQuery } from "./getInsertQuery";
 import { insertNestedRecords } from "./insertNestedRecords";
-import { getReturnTypeQuery } from "../../ViewHandler/getReturnTypeQuery";
-import { isArray } from "../../../utils/utils";
+
+export type InsertedRowWithInfo = { row: AnyObject; columnsAddedFromBeforeHooks: string[] };
 
 export async function insert(
   this: TableHandler,
@@ -27,13 +24,11 @@ export async function insert(
   const ACTION = "insert";
   const start = Date.now();
   try {
-    const { removeDisallowedFields = false } = insertParams ?? {};
     const { nestedInsert } = localParams ?? {};
 
     const rule = tableRules?.[ACTION];
-    const { validate, allowedNestedInserts, requiredNestedInserts } = rule ?? {};
+    const { allowedNestedInserts, requiredNestedInserts, validate } = rule ?? {};
 
-    const finalDBtx = this.getTransaction(localParams);
     /** Post validate and checkFilter require a transaction dbo handler because they need the action result */
     if (
       this.shouldWrapInTx(
@@ -96,7 +91,7 @@ export async function insert(
     const tx = transaction?.t || this.db;
 
     const successCallbacks: (() => void)[] = [];
-    const preValidatedRows = await Promise.all(
+    const preValidatedRows: InsertedRowWithInfo[] = await Promise.all(
       rows.map(async (nonValidated) => {
         const { preValidate, validate } = rule ?? {};
         const { tableConfigurator } = this.dboBuilder.prostgles;
@@ -131,7 +126,7 @@ export async function insert(
           });
         }
 
-        return row;
+        return { row, columnsAddedFromBeforeHooks: beforeResult.columnsAdded };
       }),
     );
     const preValidatedRowOrRows = isMultiInsert ? preValidatedRows : preValidatedRows[0]!;
@@ -146,103 +141,35 @@ export async function insert(
       tableRules,
       localParams,
     });
-    const { data, insertResult } = mediaOrNestedInsert;
-    if ("insertResult" in mediaOrNestedInsert) {
-      return insertResult;
+    if (mediaOrNestedInsert.type === "nestedInserts") {
+      return mediaOrNestedInsert.insertResult;
     }
-
-    const getInsertQuery = async (_rows: AnyObject[]) => {
-      const validatedData = _rows.map((_row) => {
-        const row = { ..._row };
-
-        if (!isObject(row)) {
-          throw (
-            "\nInvalid insert data provided. Expected an object but received: " +
-            JSON.stringify(row)
-          );
-        }
-
-        const { data: validatedRow, allowedCols } = prepareNewData({
-          row,
-          forcedData,
-          allowedFields: fields,
-          tableRules,
-          removeDisallowedFields,
-          tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
-          tableHandler: this,
-        });
-        return { validatedRow, allowedCols };
-      });
-
-      const validatedRows = validatedData.map((d) => d.validatedRow);
-      const allowedCols = Array.from(new Set(validatedData.flatMap((d) => d.allowedCols)));
-      const dbTx = finalDBtx?.dbTX || this.dboBuilder.dbo;
-      const validationOptions = {
-        validate: validate as ValidateRowBasic,
-        localParams,
-      };
-
-      const query = (
-        await this.dataValidator.parse({
-          command: "insert",
-          rows: validatedRows,
-          allowedCols,
-          dbTx,
-          validationOptions,
-          tx,
-        })
-      ).getQuery();
-      const { onConflict } = insertParams ?? {};
-      let conflict_query = "";
-      if (onConflict) {
-        const onConflictAction = typeof onConflict === "string" ? onConflict : onConflict.action;
-        const onConflictColumns =
-          typeof onConflict === "string" ? undefined : onConflict.conflictColumns;
-        if (onConflictAction === "DoNothing") {
-          conflict_query = " ON CONFLICT DO NOTHING ";
-        } else {
-          const firstRowKeys = Object.keys(validatedData[0]?.validatedRow ?? {});
-          const pkeyNames = this.columns.filter((c) => c.is_pkey).map((c) => c.name);
-          const conflictColumns =
-            onConflictColumns ??
-            this.tableOrViewInfo.uniqueColumnGroups?.find((colGroup) => {
-              if (!firstRowKeys.length)
-                throw "Cannot determine conflict columns for onConflict DoUpdate";
-              return colGroup.some((col) => {
-                return firstRowKeys.includes(col);
-              });
-            }) ??
-            pkeyNames;
-
-          /**
-           * Table might have multiple constraint types in which case it is mandatory to specify the conflict columns.
-           * */
-          if (!conflictColumns.length) {
-            throw "Cannot on conflict DoUpdate. No conflict columns could be determined. Please specify conflictColumns in onConflict param.";
-          }
-
-          const nonConflictColumns = allowedCols
-            .filter((c) => !conflictColumns.includes(c))
-            .map((v) => asName(v));
-
-          if (nonConflictColumns.length === 0) {
-            throw "No non conflict columns to update for onConflict=DoUpdate";
-          }
-          conflict_query = ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${nonConflictColumns.map((k) => `${k} = EXCLUDED.${k}`).join(", ")}`;
-        }
-      }
-      return query + conflict_query;
-    };
+    const { data } = mediaOrNestedInsert;
 
     let query = "";
-    if (Array.isArray(data)) {
+    const commonArgs = {
+      fields,
+      forcedData,
+      tableHandler: this,
+      insertParams,
+      localParams,
+      tableRules,
+      validate,
+    };
+    if (isArray(data)) {
       if (!data.length) {
         throw "Empty insert. Provide data";
       }
 
-      query = await getInsertQuery(data);
+      query = await getInsertQuery({
+        ...commonArgs,
+        rows: data,
+      });
     } else {
-      query = await getInsertQuery([data ?? {}]);
+      query = await getInsertQuery({
+        ...commonArgs,
+        rows: [data],
+      });
     }
 
     const queryWithoutUserRLS = query;
@@ -270,7 +197,10 @@ export async function insert(
       queryWithoutUserRLS,
       tableHandler: this,
       returningFields,
-      data: preValidatedRowOrRows,
+      data:
+        isArray(preValidatedRowOrRows) ?
+          preValidatedRowOrRows.map((d) => d.row)
+        : preValidatedRowOrRows.row,
       fields,
       params: insertParams,
       command: "insert",

package/lib/DboBuilder/TableHandler/insert/insertNestedRecords.ts

@@ -5,9 +5,13 @@ import type { LocalParams } from "../../DboBuilder";
 import type { TableHandler } from "../TableHandler";
 import { getReferenceColumnInserts } from "./getReferenceColumnInserts";
 import { insertRowWithNestedRecords } from "./insertRowWithNestedRecords";
+import { isArray } from "../../../utils/utils";
+import type { InsertedRowWithInfo } from "./insert";
+
+type MaybeArray<T> = T | T[];
 
 type InsertNestedRecordsArgs = {
-  data: AnyObject | AnyObject[];
+  data: MaybeArray<InsertedRowWithInfo>;
   insertParams?: InsertParams;
   tableRules: ParsedTableRule | undefined;
   localParams: LocalParams | undefined;
@@ -19,10 +23,7 @@ type InsertNestedRecordsArgs = {
 export async function insertNestedRecords(
   this: TableHandler,
   { data, insertParams, tableRules, localParams }: InsertNestedRecordsArgs,
-): Promise<{
-  data?: AnyObject | AnyObject[];
-  insertResult?: AnyObject | AnyObject[];
-}> {
+) {
   const MEDIA_COL_NAMES = ["data", "name"];
 
   const getExtraKeys = (row: AnyObject) =>
@@ -36,7 +37,7 @@ export async function insertNestedRecords(
           !Array.isArray(row[fieldName]) &&
           row[fieldName] !== undefined
         ) {
-          throw new Error("Invalid/Dissalowed field in data: " + fieldName);
+          throw new Error("Invalid/Disallowed field in data: " + fieldName);
         } else if (!this.dboBuilder.dbo[fieldName]) {
           return false;
         }
@@ -53,13 +54,14 @@ export async function insertNestedRecords(
    * If true then will do the full insert within this function
    * Nested insert is not allowed for the file table
    * */
-  const isMultiInsert = Array.isArray(data);
-  const insertedRows = (isMultiInsert ? data : [data]) as AnyObject[];
-  const insertedRowsWithNestedData = insertedRows.map((row) => {
+  const isMultiInsert = isArray(data);
+  const insertedRows = isMultiInsert ? data : [data];
+  const insertedRowsWithNestedData = insertedRows.map((rowWithInfo) => {
+    const row = { ...rowWithInfo.row };
     const extraKeys = this.is_media ? [] : getExtraKeys(row);
     const colInserts = this.is_media ? [] : getReferenceColumnInserts(this, row);
     return {
-      row,
+      ...rowWithInfo,
       hasNestedData: !!(extraKeys.length || colInserts.length),
       extraKeys,
       colInserts,
@@ -67,29 +69,35 @@ export async function insertNestedRecords(
   });
   const hasNestedInserts = insertedRowsWithNestedData.some((d) => d.hasNestedData);
 
+  const rowOrRows =
+    isMultiInsert ?
+      insertedRowsWithNestedData.map((d) => d.row)
+    : insertedRowsWithNestedData[0]!.row;
   /**
    * Make sure nested insert uses a transaction
    */
-  const { dbTX, t } = this.getTransaction(localParams) ?? {};
-  if (hasNestedInserts && (!dbTX || !t)) {
+  const transaction = this.getTransaction(localParams);
+  if (hasNestedInserts && !transaction) {
     return {
-      insertResult: await this.dboBuilder.getTX((dbTX, _t) =>
-        (dbTX[this.name] as TableHandler).insert(data, insertParams, undefined, tableRules, {
+      type: "nestedInserts" as const,
+      insertResult: (await this.dboBuilder.getTX((dbTX, _t) =>
+        (dbTX[this.name] as TableHandler).insert(rowOrRows, insertParams, undefined, tableRules, {
           tx: { dbTX, t: _t },
           ...localParams,
         }),
-      ),
+      )) as MaybeArray<AnyObject>,
     };
   }
+  const { dbTX } = transaction ?? {};
   const { onConflict } = insertParams || {};
   const rootOnConflict = isObject(onConflict) ? onConflict.action : onConflict;
 
-  const _data: (AnyObject | undefined)[] = [];
-  for (const { row, colInserts, extraKeys } of insertedRowsWithNestedData) {
-    if (hasNestedInserts) {
-      if (!dbTX) {
-        throw new Error("dbTX missing for nested insert");
-      }
+  if (hasNestedInserts) {
+    if (!dbTX) {
+      throw new Error("dbTX missing for nested insert");
+    }
+    const insertResult: (AnyObject | undefined)[] = [];
+    for (const { row, colInserts, extraKeys } of insertedRowsWithNestedData) {
       const nestedInsertResult = await insertRowWithNestedRecords.bind(this)(
         {
           row,
@@ -104,14 +112,21 @@ export async function insertNestedRecords(
           insertParams,
         },
       );
-      _data.push(nestedInsertResult);
-    } else {
-      _data.push(row);
+      insertResult.push(nestedInsertResult);
     }
+
+    return {
+      type: "nestedInserts" as const,
+      insertResult: isMultiInsert ? insertResult : insertResult[0],
+    };
   }
 
+  const _data = insertedRowsWithNestedData.map(({ row, columnsAddedFromBeforeHooks }) => ({
+    row,
+    columnsAddedFromBeforeHooks,
+  }));
+
   const result = isMultiInsert ? _data : _data[0];
-  const res = hasNestedInserts ? { insertResult: result } : { data: result };
 
-  return res;
+  return { type: "normal" as const, data: result };
 }

package/lib/DboBuilder/TableHandler/insert/insertRowWithNestedRecords.ts

@@ -36,9 +36,9 @@ export async function insertRowWithNestedRecords(
   /* Ensure we're using the same transaction */
   const tableHandler = this.tx ? this : (dbTX[this.name] as TableHandler);
 
-  const omitedKeys = extraKeys.concat(colInserts.map((c) => c.insertedFieldName));
+  const omittedKeys = extraKeys.concat(colInserts.map((c) => c.insertedFieldName));
 
-  const rootData: AnyObject = omitKeys(row, omitedKeys);
+  const rootData: AnyObject = omitKeys(row, omittedKeys);
 
   let insertedChildren: AnyObject[];
   let targetTableRules: ParsedTableRule;
@@ -193,12 +193,10 @@ export async function insertRowWithNestedRecords(
       }
 
       /* We expect tbl2 to have only 2 columns (media_id and foreign_id) */
-      if (
-        !(
-          cols2.filter((c) => c.references?.[0]?.ftable === fileTable).length === 1 &&
-          cols2.filter((c) => c.references?.[0]?.ftable === tableHandler.name).length === 1
-        )
-      ) {
+      if (!(
+        cols2.filter((c) => c.references?.[0]?.ftable === fileTable).length === 1 &&
+        cols2.filter((c) => c.references?.[0]?.ftable === tableHandler.name).length === 1
+      )) {
         console.log({
           tbl1,
           tbl2,

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -27,7 +27,7 @@ type RunInsertUpdateQueryArgs = {
       nestedInsertsResultsObj: Record<string, any>;
       params: UpdateParams | undefined;
       rule: UpdateRule | undefined;
-      data: Record<string, any>;
+      data: AnyObject;
     }
 );
 

package/lib/DboBuilder/TableHandler/update.ts

@@ -87,6 +87,7 @@ export async function update(
       removeDisallowedFields,
       tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
       tableHandler: this,
+      columnsAddedFromBeforeHooks: beforeResult.columnsAdded,
     });
 
     const updateFilter = await this.prepareWhere({

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -337,13 +337,12 @@ export class ViewHandler {
 /**
  * Throw error if illegal keys found in object
  */
-export const validateObj = <T extends Record<string, any>>(obj: T, allowedKeys: string[]): T => {
-  if (Object.keys(obj).length) {
-    const invalid_keys = Object.keys(obj).filter((k) => !allowedKeys.includes(k));
-    if (invalid_keys.length) {
-      throw "Invalid/Illegal fields found: " + invalid_keys.join(", ");
+export const validateKeys = <T extends Record<string, any>>(obj: T, allowedKeys: string[]) => {
+  const keys = Object.keys(obj);
+  if (keys.length) {
+    const invalidKeys = keys.filter((k) => !allowedKeys.includes(k));
+    if (invalidKeys.length) {
+      throw "Invalid/Illegal fields found: " + invalidKeys.join(", ");
     }
   }
-
-  return obj;
 };

package/lib/DboBuilder/parseUpdateRules.ts

@@ -153,6 +153,7 @@ export async function parseUpdateRules(
             removeDisallowedFields: false,
             tableConfigurator: this.dboBuilder.prostgles.tableConfigurator,
             tableHandler: this,
+            columnsAddedFromBeforeHooks: [],
           });
           let updateValidate: ValidateRowBasic | undefined;
           if (validate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.556",
+  "version": "4.2.558",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "pg": "^8.21.0",
     "pg-cursor": "^2.21.0",
     "pg-promise": "^12.7.0",
-    "prostgles-types": "^4.0.264"
+    "prostgles-types": "^4.0.265"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",