prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/TableHandler/insert.ts

@@ -1,123 +1,186 @@
 import { AnyObject, InsertParams, asName, isObject } from "prostgles-types";
 import { TableRule, ValidateRowBasic } from "../../PublishParser/PublishParser";
-import { LocalParams, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import {
+  LocalParams,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  withUserRLS,
+} from "../DboBuilder";
 import { insertNestedRecords } from "../insertNestedRecords";
 import { prepareNewData } from "./DataValidator";
 import { TableHandler } from "./TableHandler";
 import { insertTest } from "./insertTest";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 
-export async function insert(this: TableHandler, rowOrRows: AnyObject | AnyObject[] = {}, insertParams?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any | any[] | boolean> {
-  
+export async function insert(
+  this: TableHandler,
+  rowOrRows: AnyObject | AnyObject[] = {},
+  insertParams?: InsertParams,
+  param3_unused?: undefined,
+  tableRules?: TableRule,
+  localParams?: LocalParams,
+): Promise<any | any[] | boolean> {
   const ACTION = "insert";
   const start = Date.now();
   try {
-
     const { removeDisallowedFields = false } = insertParams || {};
     const { returnQuery = false, nestedInsert } = localParams || {};
- 
+
     const finalDBtx = this.getFinalDBtx(localParams);
     const rule = tableRules?.[ACTION];
-    const { postValidate, checkFilter, validate, allowedNestedInserts } = rule ?? {};
+    const { postValidate, checkFilter, validate, allowedNestedInserts } =
+      rule ?? {};
 
     /** Post validate and checkFilter require a transaction dbo handler because they happen after the insert */
-    if(postValidate || checkFilter){
-      if(!finalDBtx){
-        return this.dboBuilder.getTX(_dbtx => _dbtx[this.name]?.[ACTION]?.(rowOrRows, insertParams, param3_unused, tableRules, localParams))
+    if (postValidate || checkFilter) {
+      if (!finalDBtx) {
+        return this.dboBuilder.getTX((_dbtx) =>
+          _dbtx[this.name]?.[ACTION]?.(
+            rowOrRows,
+            insertParams,
+            param3_unused,
+            tableRules,
+            localParams,
+          ),
+        );
       }
     }
 
-    const { testOnly, fields, forcedData, returningFields } = await insertTest.bind(this)({ tableRules, localParams });
-    if(testOnly){
+    const { testOnly, fields, forcedData, returningFields } =
+      await insertTest.bind(this)({ tableRules, localParams });
+    if (testOnly) {
       return true;
     }
 
-    if(allowedNestedInserts){
-      if(!nestedInsert || !allowedNestedInserts.some(ai => ai.table === nestedInsert?.previousTable && ai.column === nestedInsert.referencingColumn)){
-        throw `Direct inserts not allowed. Only nested inserts from these tables: ${JSON.stringify(allowedNestedInserts)} `
+    if (allowedNestedInserts) {
+      if (
+        !nestedInsert ||
+        !allowedNestedInserts.some(
+          (ai) =>
+            ai.table === nestedInsert?.previousTable &&
+            ai.column === nestedInsert.referencingColumn,
+        )
+      ) {
+        throw `Direct inserts not allowed. Only nested inserts from these tables: ${JSON.stringify(allowedNestedInserts)} `;
       }
     }
     validateInsertParams(insertParams);
 
     const isMultiInsert = Array.isArray(rowOrRows);
-    const preValidatedRows = await Promise.all((isMultiInsert? rowOrRows : [rowOrRows]).map(async nonValidated => {
-      const { preValidate, validate } = tableRules?.insert ?? {};
-      const { tableConfigurator } = this.dboBuilder.prostgles;
-      if(!tableConfigurator) throw "tableConfigurator missing";
-      let row = await tableConfigurator.getPreInsertRow(this, { dbx: this.getFinalDbo(localParams), validate, localParams, row: nonValidated })
-      if (preValidate) {
-        if(!localParams) throw "localParams missing for insert preValidate";
-        row = await preValidate({ row, dbx: (this.tx?.dbTX || this.dboBuilder.dbo) as any, localParams });
-      }
+    const preValidatedRows = await Promise.all(
+      (isMultiInsert ? rowOrRows : [rowOrRows]).map(async (nonValidated) => {
+        const { preValidate, validate } = tableRules?.insert ?? {};
+        const { tableConfigurator } = this.dboBuilder.prostgles;
+        if (!tableConfigurator) throw "tableConfigurator missing";
+        let row = await tableConfigurator.getPreInsertRow(this, {
+          dbx: this.getFinalDbo(localParams),
+          validate,
+          localParams,
+          row: nonValidated,
+        });
+        if (preValidate) {
+          if (!localParams) throw "localParams missing for insert preValidate";
+          row = await preValidate({
+            row,
+            dbx: (this.tx?.dbTX || this.dboBuilder.dbo) as any,
+            localParams,
+          });
+        }
 
-      return row;
-    }));
-    const preValidatedrowOrRows = isMultiInsert? preValidatedRows : preValidatedRows[0]!;
+        return row;
+      }),
+    );
+    const preValidatedrowOrRows = isMultiInsert
+      ? preValidatedRows
+      : preValidatedRows[0]!;
 
     /**
      * If media it will: upload file and continue insert
      * If nested insert it will: make separate inserts and not continue main insert
      */
-    const mediaOrNestedInsert = await insertNestedRecords.bind(this)({ data: preValidatedrowOrRows, param2: insertParams, tableRules, localParams });
+    const mediaOrNestedInsert = await insertNestedRecords.bind(this)({
+      data: preValidatedrowOrRows,
+      param2: insertParams,
+      tableRules,
+      localParams,
+    });
     const { data, insertResult } = mediaOrNestedInsert;
     if ("insertResult" in mediaOrNestedInsert) {
       return insertResult;
     }
 
-    const pkeyNames = this.columns.filter(c => c.is_pkey).map(c => c.name);
+    const pkeyNames = this.columns.filter((c) => c.is_pkey).map((c) => c.name);
     const getInsertQuery = async (_rows: AnyObject[]) => {
-      const validatedData = await Promise.all(_rows.map(async _row => {
+      const validatedData = await Promise.all(
+        _rows.map(async (_row) => {
+          const row = { ..._row };
 
-        const row = { ..._row };
+          if (!isObject(row)) {
+            throw (
+              "\nInvalid insert data provided. Expected an object but received: " +
+              JSON.stringify(row)
+            );
+          }
 
-        if (!isObject(row)) {
-          throw "\nInvalid insert data provided. Expected an object but received: " + JSON.stringify(row);
-        }
-  
-        const { data: validatedRow, allowedCols } = await 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 { data: validatedRow, allowedCols } = await 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 || this.dboBuilder.dbo;
-      const validationOptions = { validate: validate as ValidateRowBasic, localParams };
+      const validationOptions = {
+        validate: validate as ValidateRowBasic,
+        localParams,
+      };
       // const query = await this.colSet.getInsertQuery(validatedRows, allowedCols, dbTx, validate, localParams);
-      const query = (await this.dataValidator.parse({ command: "insert", rows: validatedRows, allowedCols, dbTx, validationOptions })).getQuery();
+      const query = (
+        await this.dataValidator.parse({
+          command: "insert",
+          rows: validatedRows,
+          allowedCols,
+          dbTx,
+          validationOptions,
+        })
+      ).getQuery();
       const { onConflict } = insertParams ?? {};
       let conflict_query = "";
       if (onConflict === "DoNothing") {
         conflict_query = " ON CONFLICT DO NOTHING ";
-      } else if(onConflict === "DoUpdate"){
-        if(!pkeyNames.length) {
+      } else if (onConflict === "DoUpdate") {
+        if (!pkeyNames.length) {
           throw "Cannot do DoUpdate on a table without a primary key";
         }
-        const nonPkeyCols = allowedCols.filter(c => !pkeyNames.includes(c)).map(v => asName(v));
-        if(!nonPkeyCols.length){
+        const nonPkeyCols = allowedCols
+          .filter((c) => !pkeyNames.includes(c))
+          .map((v) => asName(v));
+        if (!nonPkeyCols.length) {
           throw "Cannot on conflict DoUpdate on a table with only primary key columns";
         }
-        conflict_query = ` ON CONFLICT (${pkeyNames.join(", ")}) DO UPDATE SET ${nonPkeyCols.map(k => `${k} = EXCLUDED.${k}`).join(", ")}`;
+        conflict_query = ` ON CONFLICT (${pkeyNames.join(", ")}) DO UPDATE SET ${nonPkeyCols.map((k) => `${k} = EXCLUDED.${k}`).join(", ")}`;
       }
       return query + conflict_query;
     };
-    
-    let query = ""; 
-    if (Array.isArray(data)) {
 
-      if(!data.length){
+    let query = "";
+    if (Array.isArray(data)) {
+      if (!data.length) {
         throw "Empty insert. Provide data";
       }
 
-      query = await getInsertQuery(data); 
+      query = await getInsertQuery(data);
     } else {
-      query = await getInsertQuery([data ?? {}]); 
+      query = await getInsertQuery([data ?? {}]);
     }
 
     const queryWithoutUserRLS = query;
@@ -129,55 +192,88 @@ export async function insert(this: TableHandler, rowOrRows: AnyObject | AnyObjec
     }
 
     const result = await runInsertUpdateQuery({
-      rule, 
-      localParams, 
-      queryWithoutUserRLS, 
-      tableHandler: this, 
-      returningFields, 
+      rule,
+      localParams,
+      queryWithoutUserRLS,
+      tableHandler: this,
+      returningFields,
       data: preValidatedrowOrRows,
       fields,
       params: insertParams,
       type: "insert",
       isMultiInsert,
     });
-    await this._log({ command: "insert", localParams, data: { rowOrRows, param2: insertParams }, duration: Date.now() - start });
+    await this._log({
+      command: "insert",
+      localParams,
+      data: { rowOrRows, param2: insertParams },
+      duration: Date.now() - start,
+    });
     return result;
   } catch (e) {
-    await this._log({ command: "insert", localParams, data: { rowOrRows, param2: insertParams }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    await this._log({
+      command: "insert",
+      localParams,
+      data: { rowOrRows, param2: insertParams },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-} 
+}
 
 const validateInsertParams = (params: InsertParams | undefined) => {
-
   const { onConflict, returnType, returning } = params ?? {};
-  if(![undefined, "DoNothing", "DoUpdate"].includes(onConflict)){
+  if (![undefined, "DoNothing", "DoUpdate"].includes(onConflict)) {
     throw `Invalid onConflict: ${onConflict}. Expecting one of: DoNothing, DoUpdate`;
   }
 
-  const allowedReturnTypes: InsertParams["returnType"][] = ["row", "value", "values", "statement", undefined]
-  if(!allowedReturnTypes.includes(returnType)){
-    throw `Invalid return type ${returnType}. Expecting one of: ${allowedReturnTypes}`
+  const allowedReturnTypes: InsertParams["returnType"][] = [
+    "row",
+    "value",
+    "values",
+    "statement",
+    undefined,
+  ];
+  if (!allowedReturnTypes.includes(returnType)) {
+    throw `Invalid return type ${returnType}. Expecting one of: ${allowedReturnTypes}`;
   }
 
-  if(returnType && returnType !== "statement" && !returning){
+  if (returnType && returnType !== "statement" && !returning) {
     throw `Must specify returning when using a non statement returnType: ${returnType}`;
   }
 
   if (params) {
-    const good_paramsObj: Record<keyof InsertParams, 1> = { returning: 1, returnType: 1, removeDisallowedFields: 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(", ");
+    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 removeBuffers = (o: any) => {
 //   if(isPlainObject(o)){
 //     return JSON.stringify(getKeys(o).reduce((a, k) => {
 //       const value = o[k]
-//       return { ...a, [k]: Buffer.isBuffer(value)? `Buffer[${value.byteLength}][...REMOVED]` : value 
+//       return { ...a, [k]: Buffer.isBuffer(value)? `Buffer[${value.byteLength}][...REMOVED]` : value
 //     }
 //   }, {}));
 //   }
-// }
+// }

package/lib/DboBuilder/TableHandler/insertTest.ts

@@ -8,7 +8,10 @@ type InsertTestArgs = {
   tableRules: TableRule | undefined;
   localParams: LocalParams | undefined;
 };
-export async function insertTest(this: TableHandler, { localParams, tableRules }: InsertTestArgs) {
+export async function insertTest(
+  this: TableHandler,
+  { localParams, tableRules }: InsertTestArgs,
+) {
   const { testRule } = localParams || {};
 
   const ACTION = "insert";
@@ -27,9 +30,11 @@ export async function insertTest(this: TableHandler, { localParams, tableRules }
     fields = tableRules[ACTION].fields;
 
     /* If no returning fields specified then take select fields as returning or the allowed insert fields */
-    if (!returningFields) returningFields = tableRules?.select?.fields || tableRules?.insert.fields;
+    if (!returningFields)
+      returningFields = tableRules?.select?.fields || tableRules?.insert.fields;
 
-    if (!fields) throw ` invalid insert rule for ${this.name} -> fields missing `;
+    if (!fields)
+      throw ` invalid insert rule for ${this.name} -> fields missing `;
 
     /* Safely test publish rules */
     if (testRule) {
@@ -51,13 +56,14 @@ export async function insertTest(this: TableHandler, { localParams, tableRules }
         if (keys.length) {
           const dataCols = keys.filter((k) => this.column_names.includes(k));
           const nestedInsertCols = keys.filter(
-            (k) => !this.column_names.includes(k) && this.dboBuilder.dbo[k]?.insert
+            (k) =>
+              !this.column_names.includes(k) && this.dboBuilder.dbo[k]?.insert,
           );
           if (nestedInsertCols.length) {
             throw `Nested insert not supported for forcedData rule: ${nestedInsertCols}`;
           }
           const badCols = keys.filter(
-            (k) => !dataCols.includes(k) && !nestedInsertCols.includes(k)
+            (k) => !dataCols.includes(k) && !nestedInsertCols.includes(k),
           );
           if (badCols.length) {
             throw `Invalid columns found in forced filter: ${badCols.join(", ")}`;
@@ -70,7 +76,7 @@ export async function insertTest(this: TableHandler, { localParams, tableRules }
                     (k) =>
                       asValue(forcedData![k]) +
                       "::" +
-                      this.columns.find((c) => c.name === k)!.udt_name
+                      this.columns.find((c) => c.name === k)!.udt_name,
                   )
                   .join(", ") +
                 ")",
@@ -79,7 +85,7 @@ export async function insertTest(this: TableHandler, { localParams, tableRules }
               "EXPLAIN INSERT INTO " +
                 this.escapedName +
                 " (${colNames:raw}) SELECT * FROM ( VALUES ${values:raw} ) t WHERE FALSE;",
-              { colNames, values }
+              { colNames, values },
             );
             await this.db.any(query);
           } catch (e) {

package/lib/DboBuilder/TableHandler/onDeleteFromFileTable.ts

@@ -10,29 +10,44 @@ type OnDeleteFromFileTableArgs = {
   filterOpts: {
     where: string;
     filter: AnyObject;
-  }
-}
-export async function onDeleteFromFileTable(this: TableHandler, { localParams, queryType, returningQuery, filterOpts }: OnDeleteFromFileTableArgs){
-
-  if (!this.dboBuilder.prostgles.fileManager) throw new Error("fileManager missing")
+  };
+};
+export async function onDeleteFromFileTable(
+  this: TableHandler,
+  {
+    localParams,
+    queryType,
+    returningQuery,
+    filterOpts,
+  }: OnDeleteFromFileTableArgs,
+) {
+  if (!this.dboBuilder.prostgles.fileManager)
+    throw new Error("fileManager missing");
   if (this.dboBuilder.prostgles.opts.fileTable?.delayedDelete) {
-    return this.dbHandler[queryType](`UPDATE ${asName(this.name)} SET deleted = now() ${filterOpts.where} ${returningQuery ?? ""};`)
+    return this.dbHandler[queryType](
+      `UPDATE ${asName(this.name)} SET deleted = now() ${filterOpts.where} ${returningQuery ?? ""};`,
+    );
   } else {
-
     const txDelete = async (tbl: TableHandler) => {
       if (!tbl.tx) throw new Error("Missing transaction object tx");
       let files: { id: string; name: string }[] = [];
       const totalFiles = await tbl.count(filterOpts.filter);
       do {
-        const batch = await tbl.find(filterOpts.filter, { limit: 100, offset: files.length });
+        const batch = await tbl.find(filterOpts.filter, {
+          limit: 100,
+          offset: files.length,
+        });
         files = files.concat(batch);
-      } while(files.length < totalFiles)
-      
-      const fileManager = tbl.dboBuilder.prostgles.fileManager
+      } while (files.length < totalFiles);
+
+      const fileManager = tbl.dboBuilder.prostgles.fileManager;
       if (!fileManager) throw new Error("fileManager missing");
 
       for await (const file of files) {
-        await tbl.tx.t.any(`DELETE FROM ${asName(this.name)} WHERE id = \${id}`, file);
+        await tbl.tx.t.any(
+          `DELETE FROM ${asName(this.name)} WHERE id = \${id}`,
+          file,
+        );
       }
       /** If any table delete fails then do not delete files */
       for await (const file of files) {
@@ -42,21 +57,20 @@ export async function onDeleteFromFileTable(this: TableHandler, { localParams, q
       }
 
       if (returningQuery) {
-        return files.map(f => pickKeys(f, ["id", "name"]));
+        return files.map((f) => pickKeys(f, ["id", "name"]));
       }
 
       return undefined;
-    }
+    };
 
     if (localParams?.tx?.dbTX) {
-      return txDelete(localParams.tx.dbTX[this.name] as TableHandler)
+      return txDelete(localParams.tx.dbTX[this.name] as TableHandler);
     } else if (this.tx) {
-      return txDelete(this)
+      return txDelete(this);
     } else {
-
-      return this.dboBuilder.getTX(tx => {
-        return txDelete(tx[this.name] as TableHandler)
-      })
+      return this.dboBuilder.getTX((tx) => {
+        return txDelete(tx[this.name] as TableHandler);
+      });
     }
   }
-}
+}