prostgles-server 4.2.183 → 4.2.184

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -1,9 +1,24 @@
 import pgPromise from "pg-promise";
-import { AnyObject, asName, DeleteParams, FieldFilter, InsertParams, Select, UpdateParams } from "prostgles-types";
+import {
+  AnyObject,
+  asName,
+  DeleteParams,
+  FieldFilter,
+  InsertParams,
+  Select,
+  UpdateParams,
+} from "prostgles-types";
 import { DB } from "../../Prostgles";
 import { SyncRule, TableRule } from "../../PublishParser/PublishParser";
 import TableConfigurator from "../../TableConfig/TableConfig";
-import { DboBuilder, Filter, getErrorAsObject, getSerializedClientErrorFromPGError, LocalParams, TableHandlers } from "../DboBuilder";
+import {
+  DboBuilder,
+  Filter,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  LocalParams,
+  TableHandlers,
+} from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
 import { parseUpdateRules } from "../parseUpdateRules";
 import { COMPUTED_FIELDS, FUNCTIONS } from "../QueryBuilder/Functions";
@@ -16,7 +31,6 @@ import { update } from "./update";
 import { updateBatch } from "./updateBatch";
 import { upsert } from "./upsert";
 
-
 export type ValidatedParams = {
   row: AnyObject;
   forcedData?: AnyObject;
@@ -25,44 +39,58 @@ export type ValidatedParams = {
   removeDisallowedFields: boolean;
   tableConfigurator: TableConfigurator | undefined;
   tableHandler: TableHandler;
-}
-
-export class TableHandler extends ViewHandler { 
+};
 
+export class TableHandler extends ViewHandler {
   dataValidator: DataValidator;
-  constructor(db: DB, tableOrViewInfo: TableSchema, dboBuilder: DboBuilder, tx?: {t: pgPromise.ITask<{}>, dbTX: TableHandlers}, joinPaths?: JoinPaths) {
+  constructor(
+    db: DB,
+    tableOrViewInfo: TableSchema,
+    dboBuilder: DboBuilder,
+    tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
+    joinPaths?: JoinPaths,
+  ) {
     super(db, tableOrViewInfo, dboBuilder, tx, joinPaths);
 
     this.remove = this.delete;
 
     this.dataValidator = new DataValidator(this);
     this.is_view = false;
-    this.is_media = dboBuilder.prostgles.isMedia(this.name)
+    this.is_media = dboBuilder.prostgles.isMedia(this.name);
   }
 
   getFinalDBtx = (localParams: LocalParams | undefined) => {
     return localParams?.tx?.dbTX ?? this.tx?.dbTX;
-  }
+  };
   getFinalDbo = (localParams: LocalParams | undefined) => {
     return this.getFinalDBtx(localParams) ?? this.dboBuilder.dbo;
-  }
+  };
 
   parseUpdateRules = parseUpdateRules.bind(this);
-  
+
   update = update.bind(this);
   updateBatch = updateBatch.bind(this);
-  
+
   async insert(
-    rowOrRows: AnyObject | AnyObject[], 
-    param2?: InsertParams, 
-    param3_unused?: undefined, 
-    tableRules?: TableRule, 
-    _localParams?: LocalParams
-    ): Promise<any | any[] | boolean> {
-    return insert.bind(this)(rowOrRows, param2, param3_unused, tableRules, _localParams)
+    rowOrRows: AnyObject | AnyObject[],
+    param2?: InsertParams,
+    param3_unused?: undefined,
+    tableRules?: TableRule,
+    _localParams?: LocalParams,
+  ): Promise<any | any[] | boolean> {
+    return insert.bind(this)(
+      rowOrRows,
+      param2,
+      param3_unused,
+      tableRules,
+      _localParams,
+    );
   }
 
-  prepareReturning = async (returning: Select | undefined, allowedFields: string[]): Promise<SelectItem[]> => {
+  prepareReturning = async (
+    returning: Select | undefined,
+    allowedFields: string[],
+  ): Promise<SelectItem[]> => {
     const result: SelectItem[] = [];
     if (returning) {
       const sBuilder = new SelectItemBuilder({
@@ -70,7 +98,9 @@ export class TableHandler extends ViewHandler {
         allowedFields,
         allowedOrderByFields: allowedFields,
         computedFields: COMPUTED_FIELDS,
-        functions: FUNCTIONS.filter(f => f.type === "function" && f.singleColArg),
+        functions: FUNCTIONS.filter(
+          (f) => f.type === "function" && f.singleColArg,
+        ),
         isView: this.is_view,
         columns: this.columns,
       });
@@ -80,97 +110,162 @@ export class TableHandler extends ViewHandler {
     }
 
     return result;
-  }
+  };
 
   makeReturnQuery(items?: SelectItem[]) {
     if (items?.length) return " RETURNING " + getSelectItemQuery(items);
     return "";
   }
 
-  async delete(filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any> {
-    return _delete.bind(this)(filter, params, param3_unused, table_rules, localParams);
+  async delete(
+    filter?: Filter,
+    params?: DeleteParams,
+    param3_unused?: undefined,
+    table_rules?: TableRule,
+    localParams?: LocalParams,
+  ): Promise<any> {
+    return _delete.bind(this)(
+      filter,
+      params,
+      param3_unused,
+      table_rules,
+      localParams,
+    );
   }
 
-  remove(filter: Filter, params?: UpdateParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams) {
+  remove(
+    filter: Filter,
+    params?: UpdateParams,
+    param3_unused?: undefined,
+    tableRules?: TableRule,
+    localParams?: LocalParams,
+  ) {
     return this.delete(filter, params, param3_unused, tableRules, localParams);
   }
 
-  upsert = upsert.bind(this); 
+  upsert = upsert.bind(this);
 
   /* External request. Cannot sync from server */
-  async sync(filter: Filter, params: { select?: FieldFilter }, param3_unused: undefined, table_rules: TableRule, localParams: LocalParams) {
+  async sync(
+    filter: Filter,
+    params: { select?: FieldFilter },
+    param3_unused: undefined,
+    table_rules: TableRule,
+    localParams: LocalParams,
+  ) {
     const start = Date.now();
     try {
-      
-      if(!this.dboBuilder.canSubscribe){
+      if (!this.dboBuilder.canSubscribe) {
         throw "Cannot subscribe. PubSubManager not initiated";
       }
 
       if (!localParams) throw "Sync not allowed within the server code";
       const { socket } = localParams;
       if (!socket) throw "socket missing";
-  
-  
-      if (!table_rules || !table_rules.sync || !table_rules.select) throw "sync or select table rules missing";
-  
+
+      if (!table_rules || !table_rules.sync || !table_rules.select)
+        throw "sync or select table rules missing";
+
       if (this.tx) throw "Sync not allowed within transactions";
-  
+
       const ALLOWED_PARAMS = ["select"];
-      const invalidParams = Object.keys(params || {}).filter(k => !ALLOWED_PARAMS.includes(k));
-      if (invalidParams.length) throw "Invalid or dissallowed params found: " + invalidParams.join(", ");
-  
+      const invalidParams = Object.keys(params || {}).filter(
+        (k) => !ALLOWED_PARAMS.includes(k),
+      );
+      if (invalidParams.length)
+        throw (
+          "Invalid or dissallowed params found: " + invalidParams.join(", ")
+        );
+
       const { synced_field, allow_delete }: SyncRule = table_rules.sync;
 
       if (!table_rules.sync.id_fields.length || !synced_field) {
-        const err = "INTERNAL ERROR: id_fields OR synced_field missing from publish";
+        const err =
+          "INTERNAL ERROR: id_fields OR synced_field missing from publish";
         console.error(err);
         throw err;
       }
 
-      const id_fields = this.parseFieldFilter(table_rules.sync.id_fields, false);
+      const id_fields = this.parseFieldFilter(
+        table_rules.sync.id_fields,
+        false,
+      );
       const syncFields = [...id_fields, synced_field];
 
-      const allowedSelect = this.parseFieldFilter(table_rules?.select.fields ?? false);
-      if (syncFields.find(f => !allowedSelect.includes(f))) {
+      const allowedSelect = this.parseFieldFilter(
+        table_rules?.select.fields ?? false,
+      );
+      if (syncFields.find((f) => !allowedSelect.includes(f))) {
         throw `INTERNAL ERROR: sync field missing from publish.${this.name}.select.fields`;
       }
       const select = this.getAllowedSelectFields(
         params?.select ?? "*",
         allowedSelect,
-        false
+        false,
       );
       if (!select.length) throw "Empty select not allowed";
 
       /* Add sync fields if missing */
-      syncFields.map(sf => {
+      syncFields.map((sf) => {
         if (!select.includes(sf)) select.push(sf);
       });
 
       /* Step 1: parse command and params */
-      const result = await this.find(filter, { select, limit: 0 }, undefined, table_rules, localParams)
-        .then(async _isValid => {
-
-          const { filterFields, forcedFilter } = table_rules?.select || {};
-          const condition = (await this.prepareWhere({ select: undefined, filter, forcedFilter, filterFields, addWhere: false, localParams, tableRule: table_rules })).where;
-
-          const pubSubManager = await this.dboBuilder.getPubSubManager();
-          return pubSubManager.addSync({
+      const result = await this.find(
+        filter,
+        { select, limit: 0 },
+        undefined,
+        table_rules,
+        localParams,
+      ).then(async (_isValid) => {
+        const { filterFields, forcedFilter } = table_rules?.select || {};
+        const condition = (
+          await this.prepareWhere({
+            select: undefined,
+            filter,
+            forcedFilter,
+            filterFields,
+            addWhere: false,
+            localParams,
+            tableRule: table_rules,
+          })
+        ).where;
+
+        const pubSubManager = await this.dboBuilder.getPubSubManager();
+        return pubSubManager
+          .addSync({
             table_info: this.tableOrViewInfo,
             condition,
-            id_fields, 
+            id_fields,
             synced_field,
             allow_delete,
             socket,
             table_rules,
             filter: { ...filter },
-            params: { select }
-          }).then(channelName => ({ channelName, id_fields, synced_field }));
-        });
-      await this._log({ command: "sync", localParams, data: { filter, params }, duration: Date.now() - start });
+            params: { select },
+          })
+          .then((channelName) => ({ channelName, id_fields, synced_field }));
+      });
+      await this._log({
+        command: "sync",
+        localParams,
+        data: { filter, params },
+        duration: Date.now() - start,
+      });
       return result;
     } catch (e) {
-      await this._log({ command: "sync", localParams, data: { filter, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
-      throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+      await this._log({
+        command: "sync",
+        localParams,
+        data: { filter, params },
+        duration: Date.now() - start,
+        error: getErrorAsObject(e),
+      });
+      throw getSerializedClientErrorFromPGError(e, {
+        type: "tableMethod",
+        localParams,
+        view: this,
+      });
     }
 
     /*
@@ -199,7 +294,7 @@ export class TableHandler extends ViewHandler {
                     { data } -> WHERE synced >= from_synced
         */
   }
-
 }
 
-export const getSelectItemQuery = (items: SelectItem[]) => items.map(s => s.getQuery() + " AS " + asName(s.alias)).join(", ")
+export const getSelectItemQuery = (items: SelectItem[]) =>
+  items.map((s) => s.getQuery() + " AS " + asName(s.alias)).join(", ");

package/lib/DboBuilder/TableHandler/delete.ts

@@ -1,12 +1,25 @@
 import pgPromise from "pg-promise";
 import { AnyObject, DeleteParams, FieldFilter } from "prostgles-types";
 import { DeleteRule, TableRule } from "../../PublishParser/PublishParser";
-import { Filter, LocalParams, getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import {
+  Filter,
+  LocalParams,
+  getErrorAsObject,
+  getSerializedClientErrorFromPGError,
+  withUserRLS,
+} from "../DboBuilder";
 import { runQueryReturnType } from "../ViewHandler/find";
 import { TableHandler } from "./TableHandler";
 import { onDeleteFromFileTable } from "./onDeleteFromFileTable";
 
-export async function _delete(this: TableHandler, filter?: Filter, params?: DeleteParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any> {
+export async function _delete(
+  this: TableHandler,
+  filter?: Filter,
+  params?: DeleteParams,
+  param3_unused?: undefined,
+  tableRules?: TableRule,
+  localParams?: LocalParams,
+): Promise<any> {
   const start = Date.now();
   try {
     const { returning } = params || {};
@@ -29,32 +42,49 @@ export async function _delete(this: TableHandler, filter?: Filter, params?: Dele
       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) {
-        await this.validateViewRules({ filterFields, returningFields, forcedFilter, rule: "delete" });
+        await this.validateViewRules({
+          filterFields,
+          returningFields,
+          forcedFilter,
+          rule: "delete",
+        });
         return true;
       }
     }
 
     if (params) {
-      const good_paramsObj: Record<keyof DeleteParams, 1> = { returning: 1, returnType: 1 };
+      const good_paramsObj: Record<keyof DeleteParams, 1> = {
+        returning: 1,
+        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) 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(", ")
+        );
     }
 
-    let queryType: keyof pgPromise.ITask<{}> = 'none';
+    let queryType: keyof pgPromise.ITask<{}> = "none";
     let queryWithoutRLS = `DELETE FROM ${this.escapedName} `;
-    const filterOpts = (await this.prepareWhere({
+    const filterOpts = await this.prepareWhere({
       select: undefined,
       filter,
       forcedFilter,
       filterFields,
       localParams,
-      tableRule: tableRules
-    }))
+      tableRule: tableRules,
+    });
     queryWithoutRLS += filterOpts.where;
     if (validate) {
       const _filter = filterOpts.filter;
@@ -67,8 +97,13 @@ export async function _delete(this: TableHandler, filter?: Filter, params?: Dele
       if (!returningFields) {
         throw "Returning dissallowed";
       }
-      returningQuery = this.makeReturnQuery(await this.prepareReturning(returning, this.parseFieldFilter(returningFields)));
-      queryWithoutRLS += returningQuery
+      returningQuery = this.makeReturnQuery(
+        await this.prepareReturning(
+          returning,
+          this.parseFieldFilter(returningFields),
+        ),
+      );
+      queryWithoutRLS += returningQuery;
     }
 
     // TODO - delete orphaned files
@@ -86,30 +121,48 @@ export async function _delete(this: TableHandler, filter?: Filter, params?: Dele
      * Delete file
      */
     if (this.is_media) {
-      const result = await onDeleteFromFileTable.bind(this)({ 
-        localParams, 
-        queryType, 
-        returningQuery: returnQuery? returnQuery : undefined,
+      const result = await onDeleteFromFileTable.bind(this)({
+        localParams,
+        queryType,
+        returningQuery: returnQuery ? returnQuery : undefined,
         filterOpts,
       });
-      await this._log({ command: "delete", localParams, data: { filter, params }, duration: Date.now() - start });
+      await this._log({
+        command: "delete",
+        localParams,
+        data: { filter, params },
+        duration: Date.now() - start,
+      });
       return result;
     }
 
-    const result = await runQueryReturnType({ 
+    const result = await runQueryReturnType({
       queryWithoutRLS,
       queryWithRLS,
-      newQuery: undefined, 
-      returnType: params?.returnType, 
-      handler: this, 
-      localParams
+      newQuery: undefined,
+      returnType: params?.returnType,
+      handler: this,
+      localParams,
+    });
+    await this._log({
+      command: "delete",
+      localParams,
+      data: { filter, params },
+      duration: Date.now() - start,
     });
-    await this._log({ command: "delete", localParams, data: { filter, params }, duration: Date.now() - start });
     return result;
-
   } catch (e) {
-    await this._log({ command: "delete", localParams, data: { filter, params }, duration: Date.now() - start, error: getErrorAsObject(e) });
-    throw getSerializedClientErrorFromPGError(e, { type: "tableMethod", localParams, view: this });
+    await this._log({
+      command: "delete",
+      localParams,
+      data: { filter, params },
+      duration: Date.now() - start,
+      error: getErrorAsObject(e),
+    });
+    throw getSerializedClientErrorFromPGError(e, {
+      type: "tableMethod",
+      localParams,
+      view: this,
+    });
   }
-} 
-
+}