prostgles-server 4.2.187 → 4.2.188

package/lib/DboBuilder/TableHandler/delete.ts

@@ -18,7 +18,7 @@ export async function _delete(
   params?: DeleteParams,
   param3_unused?: undefined,
   tableRules?: TableRule,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ): Promise<any> {
   const start = Date.now();
   try {
@@ -39,11 +39,10 @@ export async function _delete(
       returningFields = tableRules.delete.returningFields;
       validate = tableRules.delete.validate;
 
-      if (!returningFields) returningFields = tableRules?.select?.fields;
-      if (!returningFields) returningFields = tableRules?.delete?.filterFields;
+      if (!returningFields) returningFields = tableRules.select?.fields;
+      if (!returningFields) returningFields = tableRules.delete.filterFields;
 
-      if (!filterFields)
-        throw ` Invalid delete rule for ${this.name}. filterFields missing `;
+      if (!filterFields) throw ` Invalid delete rule for ${this.name}. filterFields missing `;
 
       /* Safely test publish rules */
       if (testRule) {
@@ -63,15 +62,10 @@ export async function _delete(
         returnType: 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)
+      const bad_params = Object.keys(params).filter((k) => !good_params.includes(k));
+      if (bad_params.length)
         throw (
-          "Invalid params: " +
-          bad_params.join(", ") +
-          " \n Expecting: " +
-          good_params.join(", ")
+          "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ")
         );
     }
 
@@ -98,10 +92,7 @@ export async function _delete(
         throw "Returning dissallowed";
       }
       returningQuery = this.makeReturnQuery(
-        await this.prepareReturning(
-          returning,
-          this.parseFieldFilter(returningFields),
-        ),
+        await this.prepareReturning(returning, this.parseFieldFilter(returningFields))
       );
       queryWithoutRLS += returningQuery;
     }
@@ -124,7 +115,7 @@ export async function _delete(
       const result = await onDeleteFromFileTable.bind(this)({
         localParams,
         queryType,
-        returningQuery: returnQuery ? returnQuery : undefined,
+        returningQuery: undefined,
         filterOpts,
       });
       await this._log({

package/lib/DboBuilder/TableHandler/insert.ts

@@ -18,7 +18,7 @@ export async function insert(
   insertParams?: InsertParams,
   param3_unused?: undefined,
   tableRules?: TableRule,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ): Promise<any | any[] | boolean> {
   const ACTION = "insert";
   const start = Date.now();
@@ -28,8 +28,7 @@ export async function insert(
 
     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) {
@@ -40,14 +39,16 @@ export async function insert(
             insertParams,
             param3_unused,
             tableRules,
-            localParams,
-          ),
+            localParams
+          )
         );
       }
     }
 
-    const { testOnly, fields, forcedData, returningFields } =
-      await insertTest.bind(this)({ tableRules, localParams });
+    const { testOnly, fields, forcedData, returningFields } = await insertTest.bind(this)({
+      tableRules,
+      localParams,
+    });
     if (testOnly) {
       return true;
     }
@@ -57,8 +58,7 @@ export async function insert(
         !nestedInsert ||
         !allowedNestedInserts.some(
           (ai) =>
-            ai.table === nestedInsert?.previousTable &&
-            ai.column === nestedInsert.referencingColumn,
+            ai.table === nestedInsert.previousTable && ai.column === nestedInsert.referencingColumn
         )
       ) {
         throw `Direct inserts not allowed. Only nested inserts from these tables: ${JSON.stringify(allowedNestedInserts)} `;
@@ -88,11 +88,9 @@ export async function insert(
         }
 
         return row;
-      }),
+      })
     );
-    const preValidatedrowOrRows = isMultiInsert
-      ? preValidatedRows
-      : preValidatedRows[0]!;
+    const preValidatedrowOrRows = isMultiInsert ? preValidatedRows : preValidatedRows[0]!;
 
     /**
      * If media it will: upload file and continue insert
@@ -132,12 +130,10 @@ export async function insert(
             tableHandler: this,
           });
           return { validatedRow, allowedCols };
-        }),
+        })
       );
       const validatedRows = validatedData.map((d) => d.validatedRow);
-      const allowedCols = Array.from(
-        new Set(validatedData.flatMap((d) => d.allowedCols)),
-      );
+      const allowedCols = Array.from(new Set(validatedData.flatMap((d) => d.allowedCols)));
       const dbTx = finalDBtx || this.dboBuilder.dbo;
       const validationOptions = {
         validate: validate as ValidateRowBasic,
@@ -161,9 +157,7 @@ export async function insert(
         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));
+        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";
         }
@@ -188,7 +182,7 @@ export async function insert(
     if (returnQuery) return queryWithRLS;
 
     if (this.dboBuilder.prostgles.opts.DEBUG_MODE) {
-      console.log(this.tx?.t.ctx?.start, "insert in " + this.name, data);
+      console.log(this.tx?.t.ctx.start, "insert in " + this.name, data);
     }
 
     const result = await runInsertUpdateQuery({
@@ -255,16 +249,9 @@ const validateInsertParams = (params: InsertParams | undefined) => {
       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.length)
+      throw "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ");
   }
 };
 

package/lib/DboBuilder/TableHandler/insertTest.ts

@@ -31,7 +31,7 @@ export async function insertTest(
 
     /* 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;
+      returningFields = tableRules.select?.fields || tableRules.insert.fields;
 
     if (!fields)
       throw ` invalid insert rule for ${this.name} -> fields missing `;

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -1,16 +1,6 @@
-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 = {
@@ -52,7 +42,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
 
   const returningSelectItems = await tableHandler.prepareReturning(
     params?.returning,
-    tableHandler.parseFieldFilter(returningFields),
+    tableHandler.parseFieldFilter(returningFields)
   );
   const { checkFilter, postValidate } = rule ?? {};
   let checkCondition = "WHERE FALSE";
@@ -122,7 +112,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
         localParams,
         view: tableHandler,
         allowedKeys: allowedFieldKeys,
-      }),
+      })
     );
   } else {
     result = await tableHandler.db
@@ -133,26 +123,25 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
           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)}`,
+      `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 (!localParams) throw new Error("Unexpected: no localParams for postValidate");
 
     const rows = result.modified ?? [];
     for await (const row of rows) {
       await postValidate({
-        row: row ?? {},
+        row: row,
         dbx: finalDBtx as any,
         localParams,
       });

package/lib/DboBuilder/TableHandler/update.ts

@@ -7,10 +7,7 @@ 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";
@@ -22,7 +19,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();
@@ -31,13 +28,7 @@ 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) {
@@ -54,28 +45,18 @@ export async function update(
       }));
     }
 
-    const parsedRules = await this.parseUpdateRules(
-      filter,
-      params,
-      tableRules,
-      localParams,
-    );
+    const parsedRules = await this.parseUpdateRules(filter, params, tableRules, localParams);
     if (localParams?.testRule) {
       return parsedRules;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!newData || !Object.keys(newData).length) {
       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 ?? {};
 
@@ -87,15 +68,10 @@ 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),
-      );
-      if (bad_params && bad_params.length)
+      const bad_params = Object.keys(params).filter((k) => !good_params.includes(k));
+      if (bad_params.length)
         throw (
-          "Invalid params: " +
-          bad_params.join(", ") +
-          " \n Expecting: " +
-          good_params.join(", ")
+          "Invalid params: " + bad_params.join(", ") + " \n Expecting: " + good_params.join(", ")
         );
     }
 
@@ -134,18 +110,13 @@ 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,
-              );
+          const refTableRules =
+            !localParams ? undefined : (
+              await getInsertTableRules(this, nestedInsert.tableName, localParams)
+            );
           const nestedLocalParams: LocalParams = {
             ...localParams,
             nestedInsert: {
@@ -160,7 +131,7 @@ export async function update(
             { returning: "*" },
             undefined,
             refTableRules,
-            nestedLocalParams,
+            nestedLocalParams
           );
           nestedInsertsResultsObj[nestedInsert.col] = nestedInsertResult;
 
@@ -169,7 +140,7 @@ export async function update(
             ...nestedInsert,
             result: nestedInsertResult,
           };
-        }),
+        })
       );
     }
 

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -1,14 +1,9 @@
 import { AnyObject, getKeys, isObject } from "prostgles-types";
-import { LocalParams, Media } from "../DboBuilder";
-import {
-  TableRule,
-  ValidateRow,
-  ValidateRowBasic,
-} from "../../PublishParser/PublishParser";
+import { TableRule, ValidateRowBasic } from "../../PublishParser/PublishParser";
 import { omitKeys } from "../../PubSubManager/PubSubManager";
+import { LocalParams, Media } from "../DboBuilder";
 import { isFile, uploadFile } from "../uploadFile";
 import { TableHandler } from "./TableHandler";
-import { DBOFullyTyped } from "../../DBSchemaBuilder";
 
 type Args = {
   newData: AnyObject;
@@ -18,7 +13,7 @@ type Args = {
 };
 export const updateFile = async function (
   this: TableHandler,
-  { filter, newData, tableRules, localParams }: Args,
+  { filter, newData, tableRules, localParams }: Args
 ): Promise<{ newData: AnyObject }> {
   const rule = tableRules?.update;
 
@@ -28,31 +23,33 @@ export const updateFile = async function (
   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
+  const existingMediaId: string =
+    (
+      !(
+        !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" } `,
+      `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),
+      "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) => {
+  const validate: ValidateRowBasic | undefined =
+    rule?.validate ?
+      async (row) => {
         return rule.validate!({
           update: row,
           filter,
@@ -63,7 +60,7 @@ export const updateFile = async function (
     : undefined;
 
   const existingFile: Media | undefined = await (
-    (localParams?.tx?.dbTX?.[this.name] as TableHandler) || this
+    (localParams?.tx?.dbTX[this.name] as TableHandler | undefined) || this
   ).findOne({ id: existingMediaId });
 
   if (!existingFile?.name) throw new Error("Existing file record not found");

package/lib/DboBuilder/TableHandler/upsert.ts

@@ -1,10 +1,7 @@
 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 (
@@ -13,35 +10,23 @@ export const upsert = async function (
   newData: AnyObject,
   params?: UpdateParams,
   table_rules?: TableRule,
-  localParams?: LocalParams,
+  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,
-        )
+        .find(filter, { select: "", limit: 1 }, undefined, table_rules, localParams)
         .then((exists) => {
-          if (exists && exists.length) {
-            return tblH.update(
-              filter,
-              newData,
-              params,
-              table_rules,
-              localParams,
-            );
+          if (exists.length) {
+            return tblH.update(filter, newData, params, table_rules, localParams);
           } else {
             return tblH.insert(
               { ...newData, ...filter },
               params,
               undefined,
               table_rules,
-              localParams,
+              localParams
             );
           }
         });
@@ -49,9 +34,7 @@ export const upsert = async function (
 
     /* 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({

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -75,8 +75,6 @@ export class ViewHandler {
     tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
     joinPaths?: JoinPaths
   ) {
-    if (!db || !tableOrViewInfo) throw "";
-
     this.db = db;
     this.tx = tx;
     this.joinPaths = joinPaths;
@@ -92,7 +90,7 @@ export class ViewHandler {
     this.column_names = tableOrViewInfo.columns.map((c) => c.name);
 
     this.dboBuilder = dboBuilder;
-    this.joins = this.dboBuilder.joins ?? [];
+    this.joins = this.dboBuilder.joins;
     this.columnsForTypes.map(({ name, udt_name, is_nullable }) => {
       this.tsColumnDefs.push(
         `${escapeTSNames(name)}?: ${postgresToTsType(udt_name) as string} ${is_nullable ? " | null " : ""};`
@@ -111,7 +109,7 @@ export class ViewHandler {
     error?: any;
   }) => {
     if (localParams?.noLog) {
-      if (localParams?.socket || localParams.httpReq) {
+      if (localParams.socket || localParams.httpReq) {
         throw new Error("noLog option is not allowed from a remote client");
       }
       return;
@@ -244,9 +242,9 @@ export class ViewHandler {
 
       const res: ValidatedTableRules = {
         allColumns,
-        getColumns: tableRules?.getColumns ?? true,
-        getInfo: tableRules?.getColumns ?? true,
-      } as ValidatedTableRules;
+        getColumns: tableRules.getColumns ?? true,
+        getInfo: tableRules.getColumns ?? true,
+      };
 
       if (tableRules.select) {
         if (!tableRules.select.fields) return throwFieldsErr("select");
@@ -258,7 +256,7 @@ export class ViewHandler {
           tableRules.select.maxLimit !== maxLimit
         ) {
           const ml = tableRules.select.maxLimit;
-          if (ml !== null && (!Number.isInteger(ml) || ml < 0))
+          if (!Number.isInteger(ml) || ml < 0)
             throw (
               ` Invalid publish.${this.name}.select.maxLimit -> expecting   a positive integer OR null    but got ` +
               ml
@@ -287,8 +285,8 @@ export class ViewHandler {
           forcedData: { ...tableRules.update.forcedData },
           forcedFilter: { ...tableRules.update.forcedFilter },
           returningFields: getFirstSpecified(
-            tableRules.update?.returningFields,
-            tableRules?.select?.fields,
+            tableRules.update.returningFields,
+            tableRules.select?.fields,
             tableRules.update.fields
           ),
           filterFields: this.parseFieldFilter(tableRules.update.filterFields),
@@ -303,7 +301,7 @@ export class ViewHandler {
           forcedData: { ...tableRules.insert.forcedData },
           returningFields: getFirstSpecified(
             tableRules.insert.returningFields,
-            tableRules?.select?.fields,
+            tableRules.select?.fields,
             tableRules.insert.fields
           ),
         };
@@ -317,7 +315,7 @@ export class ViewHandler {
           filterFields: this.parseFieldFilter(tableRules.delete.filterFields),
           returningFields: getFirstSpecified(
             tableRules.delete.returningFields,
-            tableRules?.select?.fields,
+            tableRules.select?.fields,
             tableRules.delete.filterFields
           ),
         };
@@ -476,10 +474,10 @@ export class ViewHandler {
     if (allowed_cols) {
       allowedFields = this.parseFieldFilter(allowed_cols, allow_empty);
     }
-    let col_names = (resultFields || []).filter((f) => !allowedFields || allowedFields.includes(f));
+    let col_names = resultFields.filter((f) => allowedFields.includes(f));
 
     /* Maintain allowed cols order */
-    if (selectParams === "*" && allowedFields && allowedFields.length) {
+    if (selectParams === "*" && allowedFields.length) {
       col_names = allowedFields;
     }
 
@@ -525,7 +523,7 @@ 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 (obj && Object.keys(obj).length) {
+  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(", ");

package/lib/DboBuilder/ViewHandler/count.ts

@@ -22,7 +22,7 @@ export async function count(
   try {
     const result = await this.find(
       filter,
-      { select: selectParamsWithoutLimit?.select ?? "", limit: 0 },
+      { select: selectParamsWithoutLimit.select ?? "", limit: 0 },
       undefined,
       table_rules,
       localParams,