prostgles-server 4.2.183 → 4.2.185

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -1,37 +1,62 @@
-import { AnyObject, asName, FieldFilter, InsertParams, UpdateParams } from "prostgles-types";
+import {
+  AnyObject,
+  asName,
+  FieldFilter,
+  InsertParams,
+  UpdateParams,
+} from "prostgles-types";
 import { InsertRule, UpdateRule } from "../../PublishParser/PublishParser";
-import { getClientErrorFromPGError, LocalParams, withUserRLS } from "../DboBuilder";
+import {
+  getClientErrorFromPGError,
+  LocalParams,
+  withUserRLS,
+} from "../DboBuilder";
 import { getSelectItemQuery, TableHandler } from "./TableHandler";
 
 type RunInsertUpdateQueryArgs = {
   tableHandler: TableHandler;
-  queryWithoutUserRLS: string; 
+  queryWithoutUserRLS: string;
   localParams: LocalParams | undefined;
   fields: FieldFilter | undefined;
   returningFields: FieldFilter | undefined;
-} & ({
-  type: "insert";
-  params: InsertParams | undefined
-  rule: InsertRule | undefined;
-  data: AnyObject | AnyObject[];
-  isMultiInsert: boolean;
-  nestedInsertsResultsObj?: undefined;
-} | {
-  type: "update";
-  nestedInsertsResultsObj: Record<string, any>;
-  params: UpdateParams | undefined
-  rule: UpdateRule | undefined;
-  data: undefined;
-});
+} & (
+  | {
+      type: "insert";
+      params: InsertParams | undefined;
+      rule: InsertRule | undefined;
+      data: AnyObject | AnyObject[];
+      isMultiInsert: boolean;
+      nestedInsertsResultsObj?: undefined;
+    }
+  | {
+      type: "update";
+      nestedInsertsResultsObj: Record<string, any>;
+      params: UpdateParams | undefined;
+      rule: UpdateRule | undefined;
+      data: undefined;
+    }
+);
 
 export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
-  const { tableHandler, queryWithoutUserRLS, rule, localParams, fields, returningFields, params, nestedInsertsResultsObj } = args;
+  const {
+    tableHandler,
+    queryWithoutUserRLS,
+    rule,
+    localParams,
+    fields,
+    returningFields,
+    params,
+    nestedInsertsResultsObj,
+  } = args;
   const { name } = tableHandler;
 
-  const returningSelectItems = await tableHandler.prepareReturning(params?.returning, tableHandler.parseFieldFilter(returningFields))
+  const returningSelectItems = await tableHandler.prepareReturning(
+    params?.returning,
+    tableHandler.parseFieldFilter(returningFields),
+  );
   const { checkFilter, postValidate } = rule ?? {};
   let checkCondition = "WHERE FALSE";
-  if(checkFilter){
+  if (checkFilter) {
     const checkCond = await tableHandler.prepareWhere({
       select: undefined,
       localParams: undefined,
@@ -43,7 +68,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
   }
   const hasReturning = !!returningSelectItems.length;
   const userRLS = withUserRLS(localParams, "");
-  const escapedTableName = asName(name)
+  const escapedTableName = asName(name);
   const query = ` 
     ${userRLS}
     WITH ${escapedTableName} AS (
@@ -62,9 +87,9 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
       (
         SELECT json_agg(item)
         FROM (
-          SELECT ${!hasReturning? "1" : getSelectItemQuery(returningSelectItems)}
+          SELECT ${!hasReturning ? "1" : getSelectItemQuery(returningSelectItems)}
           FROM ${escapedTableName}
-          WHERE ${hasReturning? "TRUE" : "FALSE"}
+          WHERE ${hasReturning ? "TRUE" : "FALSE"}
         ) item
       ) as modified_returning,
       ( 
@@ -80,55 +105,80 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
   `;
 
   const allowedFieldKeys = tableHandler.parseFieldFilter(fields);
-  let result: { 
-    row_count: number | null; 
-    modified: AnyObject[] | null; 
+  let result: {
+    row_count: number | null;
+    modified: AnyObject[] | null;
     failed_check: AnyObject[] | null;
     modified_returning: AnyObject[] | null;
   };
-  
+
   const queryType = "one";
 
   const tx = localParams?.tx?.t || tableHandler.tx?.t;
   if (tx) {
-    result = await tx[queryType](query).catch((err: any) => getClientErrorFromPGError(err, { type: "tableMethod", localParams, view: tableHandler, allowedKeys: allowedFieldKeys }));
+    result = await tx[queryType](query).catch((err: any) =>
+      getClientErrorFromPGError(err, {
+        type: "tableMethod",
+        localParams,
+        view: tableHandler,
+        allowedKeys: allowedFieldKeys,
+      }),
+    );
   } else {
-    result = await tableHandler.db.tx(t => (t as any)[queryType](query)).catch(err => getClientErrorFromPGError(err, { type: "tableMethod", localParams, view: tableHandler, allowedKeys: allowedFieldKeys }));
+    result = await tableHandler.db
+      .tx((t) => (t as any)[queryType](query))
+      .catch((err) =>
+        getClientErrorFromPGError(err, {
+          type: "tableMethod",
+          localParams,
+          view: tableHandler,
+          allowedKeys: allowedFieldKeys,
+        }),
+      );
   }
 
-  if(checkFilter && result.failed_check?.length){
-    throw new Error(`Insert ${name} records failed the check condition: ${JSON.stringify(checkFilter, null, 2)}`);
+  if (checkFilter && result.failed_check?.length) {
+    throw new Error(
+      `Insert ${name} records failed the check condition: ${JSON.stringify(checkFilter, null, 2)}`,
+    );
   }
 
   const finalDBtx = tableHandler.getFinalDBtx(localParams);
-  if(postValidate){
-    if(!finalDBtx) throw new Error("Unexpected: no dbTX for postValidate");
-    if(!localParams) throw new Error("Unexpected: no localParams for postValidate");
+  if (postValidate) {
+    if (!finalDBtx) throw new Error("Unexpected: no dbTX for postValidate");
+    if (!localParams)
+      throw new Error("Unexpected: no localParams for postValidate");
 
     const rows = result.modified ?? [];
-    for await (const row of rows){
-      await postValidate({ row: row ?? {}, dbx: finalDBtx as any, localParams })
+    for await (const row of rows) {
+      await postValidate({
+        row: row ?? {},
+        dbx: finalDBtx as any,
+        localParams,
+      });
     }
   }
 
   let returnMany = false;
-  if(args.type === "update"){
+  if (args.type === "update") {
     const { multi = true } = args.params || {};
-    if(!multi && result.row_count && +result.row_count > 1){
+    if (!multi && result.row_count && +result.row_count > 1) {
       throw `More than 1 row modified: ${result.row_count} rows affected`;
     }
 
-    if(hasReturning){
+    if (hasReturning) {
       returnMany = multi;
     }
-
   } else {
-    returnMany = args.isMultiInsert
+    returnMany = args.isMultiInsert;
   }
 
-  if(!hasReturning) return undefined;
+  if (!hasReturning) return undefined;
 
-  const modified_returning = result.modified_returning?.map(d => ({ ...d, ...nestedInsertsResultsObj }))
+  const modified_returning = result.modified_returning?.map((d) => ({
+    ...d,
+    ...nestedInsertsResultsObj,
+  }));
 
-  return returnMany? modified_returning : modified_returning?.[0];
-}
+  return returnMany ? modified_returning : modified_returning?.[0];
+};

package/lib/DboBuilder/TableHandler/update.ts

@@ -7,7 +7,10 @@ import {
   getSerializedClientErrorFromPGError,
   withUserRLS,
 } from "../DboBuilder";
-import { getInsertTableRules, getReferenceColumnInserts } from "../insertNestedRecords";
+import {
+  getInsertTableRules,
+  getReferenceColumnInserts,
+} from "../insertNestedRecords";
 import { prepareNewData } from "./DataValidator";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 import { TableHandler } from "./TableHandler";
@@ -19,7 +22,7 @@ export async function update(
   _newData: AnyObject,
   params?: UpdateParams,
   tableRules?: TableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): Promise<AnyObject | void> {
   const ACTION = "update";
   const start = Date.now();
@@ -28,7 +31,13 @@ export async function update(
     const finalDBtx = this.getFinalDBtx(localParams);
     const wrapInTx = () =>
       this.dboBuilder.getTX((_dbtx) =>
-        _dbtx[this.name]?.[ACTION]?.(filter, _newData, params, tableRules, localParams)
+        _dbtx[this.name]?.[ACTION]?.(
+          filter,
+          _newData,
+          params,
+          tableRules,
+          localParams,
+        ),
       );
     const rule = tableRules?.[ACTION];
     if (rule?.postValidate && !finalDBtx) {
@@ -37,10 +46,20 @@ export async function update(
 
     let newData = _newData;
     if (this.is_media) {
-      ({ newData } = await updateFile.bind(this)({ newData, filter, localParams, tableRules }));
+      ({ 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;
     }
@@ -49,8 +68,14 @@ export async function update(
       throw "no update data provided\nEXPECTING db.table.update(filter, updateData, options)";
     }
 
-    const { fields, validateRow, forcedData, returningFields, forcedFilter, filterFields } =
-      parsedRules;
+    const {
+      fields,
+      validateRow,
+      forcedData,
+      returningFields,
+      forcedFilter,
+      filterFields,
+    } = parsedRules;
     const { removeDisallowedFields = false } = params || {};
     const { returnQuery = false } = localParams ?? {};
 
@@ -62,10 +87,15 @@ export async function update(
         multi: 1,
       };
       const good_params = Object.keys(good_paramsObj);
-      const bad_params = Object.keys(params).filter((k) => !good_params.includes(k));
+      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(", ")
+          "Invalid params: " +
+          bad_params.join(", ") +
+          " \n Expecting: " +
+          good_params.join(", ")
         );
     }
 
@@ -104,12 +134,18 @@ export async function update(
       }
       await Promise.all(
         nestedInserts.map(async (nestedInsert) => {
-          const nesedTableHandler = finalDBtx[nestedInsert.tableName] as TableHandler | undefined;
+          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);
+            : await getInsertTableRules(
+                this,
+                nestedInsert.tableName,
+                localParams,
+              );
           const nestedLocalParams: LocalParams = {
             ...localParams,
             nestedInsert: {
@@ -124,7 +160,7 @@ export async function update(
             { returning: "*" },
             undefined,
             refTableRules,
-            nestedLocalParams
+            nestedLocalParams,
           );
           nestedInsertsResultsObj[nestedInsert.col] = nestedInsertResult;
 
@@ -133,7 +169,7 @@ export async function update(
             ...nestedInsert,
             result: nestedInsertResult,
           };
-        })
+        }),
       );
     }
 
@@ -179,6 +215,10 @@ export async function update(
       duration: Date.now() - start,
       error: getErrorAsObject(e),
     });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
 }

package/lib/DboBuilder/TableHandler/updateBatch.ts

@@ -1,49 +1,87 @@
 import { AnyObject, UpdateParams } from "prostgles-types";
 import { TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, getClientErrorFromPGError, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import {
+  Filter,
+  LocalParams,
+  getClientErrorFromPGError,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  withUserRLS,
+} from "../DboBuilder";
 import { TableHandler } from "./TableHandler";
 
-
-export async function updateBatch(this: TableHandler, updates: [Filter, AnyObject][], params?: UpdateParams, _?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any> {
+export async function updateBatch(
+  this: TableHandler,
+  updates: [Filter, AnyObject][],
+  params?: UpdateParams,
+  _?: undefined,
+  tableRules?: TableRule,
+  localParams?: LocalParams,
+): Promise<any> {
   const start = Date.now();
   try {
     const { checkFilter, postValidate } = tableRules?.update ?? {};
-    if(checkFilter || postValidate){
-      throw `updateBatch not allowed for tables with checkFilter or postValidate rules`
+    if (checkFilter || postValidate) {
+      throw `updateBatch not allowed for tables with checkFilter or postValidate rules`;
     }
     const updateQueries: string[] = await Promise.all(
-      updates.map(async ([filter, data]) => { 
+      updates.map(async ([filter, data]) => {
         const query = (await this.update(
           filter,
           data,
           { ...(params ?? {}), returning: undefined },
           tableRules,
-          { ...(localParams ?? {}), returnQuery: "noRLS" }
+          { ...(localParams ?? {}), returnQuery: "noRLS" },
         )) as unknown as string;
 
         return query;
-      })
+      }),
     );
-    const queries = [
-      withUserRLS(localParams, ""),
-      ...updateQueries
-    ];
-    
+    const queries = [withUserRLS(localParams, ""), ...updateQueries];
+
     const t = localParams?.tx?.t ?? this.tx?.t;
-    if(t){
+    if (t) {
       const result = await t.none(queries.join(";\n"));
-      await this._log({ command: "updateBatch", localParams, data: { data: updates, params }, duration: Date.now() - start });
+      await this._log({
+        command: "updateBatch",
+        localParams,
+        data: { data: updates, params },
+        duration: Date.now() - start,
+      });
       return result;
     }
-    const result = await this.db.tx(t => {
+    const result = await this.db
+      .tx((t) => {
         return t.none(queries.join(";\n"));
       })
-      .catch(err => getClientErrorFromPGError(err, { type: "tableMethod", localParams, view: this, allowedKeys: [] }));
+      .catch((err) =>
+        getClientErrorFromPGError(err, {
+          type: "tableMethod",
+          localParams,
+          view: this,
+          allowedKeys: [],
+        }),
+      );
 
-    await this._log({ command: "updateBatch", localParams, data: { data: updates, params }, duration: Date.now() - start });
+    await this._log({
+      command: "updateBatch",
+      localParams,
+      data: { data: updates, params },
+      duration: Date.now() - start,
+    });
     return result;
   } catch (e) {
-    await this._log({ command: "updateBatch", localParams, data: { data: updates, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    await this._log({
+      command: "updateBatch",
+      localParams,
+      data: { data: updates, params },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-}
+}

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -1,48 +1,79 @@
 import { AnyObject, getKeys, isObject } from "prostgles-types";
 import { LocalParams, Media } from "../DboBuilder";
-import { TableRule, ValidateRow, ValidateRowBasic } from "../../PublishParser/PublishParser";
+import {
+  TableRule,
+  ValidateRow,
+  ValidateRowBasic,
+} from "../../PublishParser/PublishParser";
 import { omitKeys } from "../../PubSubManager/PubSubManager";
 import { isFile, uploadFile } from "../uploadFile";
 import { TableHandler } from "./TableHandler";
 import { DBOFullyTyped } from "../../DBSchemaBuilder";
 
 type Args = {
-  newData: AnyObject; 
+  newData: AnyObject;
   filter: AnyObject;
-  tableRules: TableRule | undefined; 
+  tableRules: TableRule | undefined;
   localParams: LocalParams | undefined;
-}
-export const updateFile = async function(this: TableHandler, { filter, newData, tableRules, localParams }: Args): Promise<{ newData: AnyObject }> {
-
+};
+export const updateFile = async function (
+  this: TableHandler,
+  { filter, newData, tableRules, localParams }: Args,
+): Promise<{ newData: AnyObject }> {
   const rule = tableRules?.update;
 
-  if(tableRules && !tableRules.update){
-    throw "Not allowed"
+  if (tableRules && !tableRules.update) {
+    throw "Not allowed";
   }
-  if(localParams?.testRule){
+  if (localParams?.testRule) {
     return { newData: {} };
   }
-  const existingMediaId: string = !(!filter || !isObject(filter) || getKeys(filter).join() !== "id" || typeof (filter as any).id !== "string")? (filter as any).id : undefined
-  if(!existingMediaId){
-    throw new Error(`Updating the file table with file data can only be done by providing a single id filter. E.g. { id: "9ea4e23c-2b1a-4e33-8ec0-c15919bb45ec" } `);
+  const existingMediaId: string = !(
+    !filter ||
+    !isObject(filter) ||
+    getKeys(filter).join() !== "id" ||
+    typeof (filter as any).id !== "string"
+  )
+    ? (filter as any).id
+    : undefined;
+  if (!existingMediaId) {
+    throw new Error(
+      `Updating the file table with file data can only be done by providing a single id filter. E.g. { id: "9ea4e23c-2b1a-4e33-8ec0-c15919bb45ec" } `,
+    );
   }
-  if(!isFile(newData)){
-    throw new Error("Expecting { data: Buffer, name: string } but received " + JSON.stringify(newData))
+  if (!isFile(newData)) {
+    throw new Error(
+      "Expecting { data: Buffer, name: string } but received " +
+        JSON.stringify(newData),
+    );
   }
 
-  const fileManager = this.dboBuilder.prostgles.fileManager
-  if(!fileManager) throw new Error("fileManager missing");
-  if(rule?.validate && !localParams) throw new Error("localParams missing");
-  const validate: ValidateRowBasic | undefined = rule?.validate? async (row) => {
-    return rule.validate!({ update: row, filter, dbx:  (this.tx?.dbTX || this.dboBuilder.dbo) as any, localParams: localParams! })
-  } : undefined;
+  const fileManager = this.dboBuilder.prostgles.fileManager;
+  if (!fileManager) throw new Error("fileManager missing");
+  if (rule?.validate && !localParams) throw new Error("localParams missing");
+  const validate: ValidateRowBasic | undefined = rule?.validate
+    ? async (row) => {
+        return rule.validate!({
+          update: row,
+          filter,
+          dbx: (this.tx?.dbTX || this.dboBuilder.dbo) as any,
+          localParams: localParams!,
+        });
+      }
+    : undefined;
+
+  const existingFile: Media | undefined = await (
+    (localParams?.tx?.dbTX?.[this.name] as TableHandler) || this
+  ).findOne({ id: existingMediaId });
 
-  const existingFile: Media | undefined = await (localParams?.tx?.dbTX?.[this.name] as TableHandler || this).findOne({ id: existingMediaId });
-    
-  if(!existingFile?.name) throw new Error("Existing file record not found");
+  if (!existingFile?.name) throw new Error("Existing file record not found");
 
   await fileManager.deleteFile(existingFile.name);
-  const newFile = await uploadFile.bind(this)({ row: newData, validate, localParams, mediaId: existingFile.id })
+  const newFile = await uploadFile.bind(this)({
+    row: newData,
+    validate,
+    localParams,
+    mediaId: existingFile.id,
+  });
   return { newData: omitKeys(newFile, ["id"]) };
-
-}
+};

package/lib/DboBuilder/TableHandler/upsert.ts

@@ -1,33 +1,78 @@
 import { AnyObject, UpdateParams } from "prostgles-types";
 import { TableRule } from "../../PublishParser/publishTypesAndUtils";
 import { Filter, LocalParams } from "../DboBuilderTypes";
-import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../dboBuilderUtils";
+import {
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+} from "../dboBuilderUtils";
 import { TableHandler } from "./TableHandler";
 
-export const upsert = async function(this: TableHandler, filter: Filter, newData: AnyObject, params?: UpdateParams, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
+export const upsert = async function (
+  this: TableHandler,
+  filter: Filter,
+  newData: AnyObject,
+  params?: UpdateParams,
+  table_rules?: TableRule,
+  localParams?: LocalParams,
+): Promise<any> {
   const start = Date.now();
   try {
     const _upsert = async function (tblH: TableHandler) {
-      return tblH.find(filter, { select: "", limit: 1 }, undefined, table_rules, localParams)
-        .then(exists => {
+      return tblH
+        .find(
+          filter,
+          { select: "", limit: 1 },
+          undefined,
+          table_rules,
+          localParams,
+        )
+        .then((exists) => {
           if (exists && exists.length) {
-            return tblH.update(filter, newData, params, table_rules, localParams);
+            return tblH.update(
+              filter,
+              newData,
+              params,
+              table_rules,
+              localParams,
+            );
           } else {
-            return tblH.insert({ ...newData, ...filter }, params, undefined, table_rules, localParams);
+            return tblH.insert(
+              { ...newData, ...filter },
+              params,
+              undefined,
+              table_rules,
+              localParams,
+            );
           }
         });
-    }
+    };
 
     /* Do it within a transaction to ensure consisency */
     if (!this.tx) {
-      return this.dboBuilder.getTX(dbTX => _upsert(dbTX[this.name] as TableHandler))
+      return this.dboBuilder.getTX((dbTX) =>
+        _upsert(dbTX[this.name] as TableHandler),
+      );
     }
     const result = await _upsert(this);
-    await this._log({ command: "upsert", localParams, data: { filter, newData, params }, duration: Date.now() - start });
+    await this._log({
+      command: "upsert",
+      localParams,
+      data: { filter, newData, params },
+      duration: Date.now() - start,
+    });
     return result;
-
   } catch (e) {
-    await this._log({ command: "upsert", localParams, data: { filter, newData, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    await this._log({
+      command: "upsert",
+      localParams,
+      data: { filter, newData, params },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-}
+};