prostgles-server 4.2.506 → 4.2.508

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -6,12 +6,20 @@ import type {
   EXISTS_KEY,
   RawJoinPath,
   SQLHandler,
+  SyncTableInfo,
   TableInfo as TInfo,
   UserLike,
 } from "prostgles-types";
 import type { AuthClientRequest, BasicSession, SessionUser } from "../Auth/AuthTypes";
 import type { BasicCallback } from "../PubSubManager/PubSubManager";
-import type { PermissionScope, PublishAllOrNothing } from "../PublishParser/PublishParser";
+import type {
+  DeleteRule,
+  InsertRule,
+  PermissionScope,
+  PublishAllOrNothing,
+  SelectRule,
+  UpdateRule,
+} from "../PublishParser/PublishParser";
 import type { FieldSpec } from "./QueryBuilder/Functions/Functions";
 import type { TableHandler } from "./TableHandler/TableHandler";
 import type { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
@@ -107,10 +115,10 @@ export type TX<TH = TableHandlers> = {
 };
 
 export type TableHandlers = {
-  [key: string]: Partial<TableHandler>;
+  [key: string]: TableHandler;
 };
 export type DbTxTableHandlers = {
-  [key: string]: Omit<Partial<TableHandler>, "dbTx"> | Omit<TableHandler, "dbTx">;
+  [key: string]: Omit<TableHandler, "dbTx">;
 };
 
 export type SQLHandlerServer = SQLHandler<LocalParams>;
@@ -264,75 +272,78 @@ export type JoinInfo = {
     target: string;
   }[];
 };
+type MergeOverwrite<T, U> = Omit<T, keyof U> & U;
 
-export type CommonTableRules = {
-  /**
-   * True by default. Allows clients to get column information on any columns that are allowed in (select, insert, update) field rules.
-   */
-  getColumns?: PublishAllOrNothing;
-
-  /**
-   * True by default. Allows clients to get table information (oid, comment, label, has_media).
-   */
-  getInfo?: PublishAllOrNothing;
-};
-
-export type ValidatedTableRules = CommonTableRules & {
+export type ValidatedTableRules = {
   /* All columns of the view/table. Includes computed fields as well */
   allColumns: FieldSpec[];
 
-  select?: {
-    /* Fields you can select */
-    fields: string[];
+  select?: MergeOverwrite<
+    SelectRule,
+    {
+      /* Fields you can select */
+      fields: string[];
 
-    /* Fields you can select */
-    orderByFields: string[];
+      /* Fields you can select */
+      orderByFields: string[];
 
-    /* Filter applied to every select */
-    filterFields: string[];
+      /* Filter applied to every select */
+      filterFields: string[];
 
-    /* Filter applied to every select */
-    forcedFilter: AnyObject | undefined;
-
-    /* Max limit allowed for each select. 1000 by default. If null then an unlimited select is allowed when providing { limit: null } */
-    maxLimit: number | null;
-  };
-  update?: {
-    /* Fields you can update */
-    fields: string[];
+      /* Filter applied to every select */
+      forcedFilter: AnyObject | undefined;
 
-    /* Fields you can return after updating */
-    returningFields: string[];
+      /* Max limit allowed for each select. 1000 by default. If null then an unlimited select is allowed when providing { limit: null } */
+      maxLimit: number | null;
 
-    /* Fields you can use in filtering when updating */
-    filterFields: string[];
-
-    /* Filter applied to every update. Filter fields cannot be updated */
-    forcedFilter: AnyObject | undefined;
-
-    /* Data applied to every update */
-    forcedData: AnyObject;
-  };
-  insert?: {
-    /* Fields you can insert */
-    fields: string[];
+      syncConfig: SyncTableInfo | undefined;
+    }
+  >;
+  update?: MergeOverwrite<
+    UpdateRule,
+    {
+      /* Fields you can update */
+      fields: string[];
 
-    /* Fields you can return after inserting. Will return select.fields by default */
-    returningFields: string[];
+      /* Fields you can return after updating */
+      returningFields: string[];
 
-    /* Data applied to every insert */
-    forcedData: AnyObject;
-  };
-  delete?: {
-    /* Fields to filter by when deleting */
-    filterFields: string[];
+      /* Fields you can use in filtering when updating */
+      filterFields: string[];
 
-    /* Filter applied to every deletes */
-    forcedFilter: AnyObject | undefined;
+      /* Filter applied to every update. Filter fields cannot be updated */
+      forcedFilter: AnyObject | undefined;
 
-    /* Fields you can return after deleting */
-    returningFields: string[];
-  };
+      /* Data applied to every update */
+      forcedData: AnyObject;
+    }
+  >;
+  insert?: MergeOverwrite<
+    InsertRule,
+    {
+      /* Fields you can insert */
+      fields: string[];
+
+      /* Fields you can return after inserting. Will return select.fields by default */
+      returningFields: string[];
+
+      /* Data applied to every insert */
+      forcedData: AnyObject;
+    }
+  >;
+  delete?: MergeOverwrite<
+    DeleteRule,
+    {
+      /* Fields to filter by when deleting */
+      filterFields: string[];
+
+      /* Filter applied to every deletes */
+      forcedFilter: AnyObject | undefined;
+
+      /* Fields you can return after deleting */
+      returningFields: string[];
+    }
+  >;
 };
 
 export type ExistsFilterConfig = {

package/lib/DboBuilder/TableHandler/DataValidator.ts

@@ -159,7 +159,7 @@ export const prepareNewData = ({
   tableConfigurator,
   tableHandler,
 }: ValidatedParams) => {
-  const synced_field = (tableRules ?? {}).sync?.synced_field;
+  const synced_field = tableHandler.config?.syncConfig?.synced_field;
 
   /* Update synced_field if sync is on and missing */
   if (synced_field && !row[synced_field]) {

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -9,12 +9,7 @@ import type {
 } from "prostgles-types";
 import { asName, isDefined } from "prostgles-types";
 import type { DB } from "../../Prostgles";
-import type {
-  InsertRule,
-  ParsedTableRule,
-  SyncRule,
-  UpdateRule,
-} from "../../PublishParser/PublishParser";
+import type { InsertRule, ParsedTableRule, UpdateRule } from "../../PublishParser/PublishParser";
 import type TableConfigurator from "../../TableConfig/TableConfig";
 import type { TableDefinition } from "../../TableConfig/TableConfig";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
@@ -214,31 +209,33 @@ export class TableHandler extends ViewHandler {
         throw "Cannot subscribe. PubSubManager not initiated";
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (!localParams.clientReq) throw "Sync not allowed within the server code";
       const { socket } = localParams.clientReq;
       if (!socket) throw "socket missing";
 
+      const syncConfig = this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(this.name);
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (!table_rules || !table_rules.sync || !table_rules.select)
+      if (!table_rules || !table_rules.select || !syncConfig) {
         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)
+      if (invalidParams.length) {
         throw "Invalid or dissallowed params found: " + invalidParams.join(", ");
+      }
 
-      const { synced_field }: SyncRule = table_rules.sync;
+      const { synced_field } = syncConfig;
 
-      if (!table_rules.sync.id_fields.length || !synced_field) {
+      if (!syncConfig.id_fields.length || !synced_field) {
         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(syncConfig.id_fields, false);
       const syncFields = [...id_fields, synced_field];
 
       const allowedSelect = this.parseFieldFilter(table_rules.select.fields);
@@ -279,8 +276,7 @@ export class TableHandler extends ViewHandler {
           .addSync({
             table_info: this.tableOrViewInfo,
             condition,
-            id_fields,
-            synced_field,
+            ...syncConfig,
             socket,
             table_rules,
             filter: { ...filter },

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

@@ -35,13 +35,7 @@ export async function insert(
     /** Post validate and checkFilter require a transaction dbo handler because they happen after the insert */
     if (this.shouldWrapInTx({ name: ACTION, rule }, localParams)) {
       return this.dboBuilder.getTX((_dbtx) =>
-        _dbtx[this.name]?.[ACTION]?.(
-          rowOrRows,
-          insertParams,
-          param3_unused,
-          tableRules,
-          localParams,
-        ),
+        _dbtx[this.name]?.[ACTION](rowOrRows, insertParams, param3_unused, tableRules, localParams),
       );
     }
 

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

@@ -154,8 +154,8 @@ export async function insertRowWithNestedRecords(
       localParams?.scope,
     );
 
-    const cols2 = this.dboBuilder.dbo[tbl2!]!.columns || [];
-    if (!this.dboBuilder.dbo[tbl2!]) throw "Invalid/disallowed table: " + tbl2;
+    const cols2 = this.dboBuilder.dboMap.get(tbl2!)?.columns || [];
+    if (!this.dboBuilder.dboMap.get(tbl2!)) throw "Invalid/disallowed table: " + tbl2;
     const colsRefT1 = cols2.filter((c) =>
       c.references?.some((rc) => rc.cols.length === 1 && rc.ftable === tbl1),
     );
@@ -299,7 +299,7 @@ const referencedInsert = async (
 
   const results: AnyObject[] = [];
   for (const dataItem of (Array.isArray(targetData) ? targetData : [targetData]) as AnyObject[]) {
-    const result: AnyObject = await (dbTX[targetTable] as TableHandler)
+    const result: AnyObject = await dbTX[targetTable]
       .insert(dataItem, { returning: "*", onConflict }, undefined, childRules, localParams)
       .catch((e) => {
         return Promise.reject(e);

package/lib/DboBuilder/TableHandler/insertTest.ts

@@ -1,6 +1,6 @@
 import type { AnyObject, FieldFilter, FullFilter } from "prostgles-types";
 import { asName } from "prostgles-types";
-import type { LocalParams} from "../DboBuilder";
+import type { LocalParams } from "../DboBuilder";
 import { pgp } from "../DboBuilder";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import { asValue } from "../../PubSubManager/PubSubManagerUtils";
@@ -53,13 +53,13 @@ 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.dboMap.has(k),
           );
           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(", ")}`;
@@ -72,7 +72,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(", ") +
                 ")",
@@ -81,7 +81,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: any) {

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -57,7 +57,7 @@ export const updateFile = async function (
     : undefined;
 
   const existingFile: Media | undefined = await (
-    (localParams?.tx?.dbTX[this.name] as TableHandler | undefined) || this
+    (localParams?.tx?.dbTX[this.name]) || this
   ).findOne({ id: existingMediaId });
 
   if (!existingFile?.name) throw new Error("Existing file record not found");

package/lib/DboBuilder/TableRules/{getValidatedRules.ts → getValidatedTableRules.ts}

@@ -6,7 +6,7 @@ import type { ViewHandler } from "../ViewHandler/ViewHandler";
 import { COMPUTED_FIELDS } from "../QueryBuilder/Functions/COMPUTED_FIELDS";
 import { asNameAlias } from "../../utils/asNameAlias";
 
-export function getValidatedRules(
+export function getValidatedTableRules(
   this: ViewHandler,
   tableRules?: ParsedTableRule,
   localParams?: LocalParams,
@@ -61,8 +61,6 @@ export function getValidatedRules(
 
     const res: ValidatedTableRules = {
       allColumns,
-      getColumns: tableRules.getColumns ?? true,
-      getInfo: tableRules.getColumns ?? true,
     };
 
     if (tableRules.select) {
@@ -93,6 +91,7 @@ export function getValidatedRules(
         forcedFilter: { ...tableRules.select.forcedFilter },
         filterFields: this.parseFieldFilter(tableRules.select.filterFields),
         maxLimit,
+        syncConfig: this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(this.name),
       };
     }
 
@@ -136,24 +135,18 @@ export function getValidatedRules(
       };
     }
 
-    if (!tableRules.select && !tableRules.update && !tableRules.delete && !tableRules.insert) {
-      if ([null, false].includes(tableRules.getInfo as any)) res.getInfo = false;
-      if ([null, false].includes(tableRules.getColumns as any)) res.getColumns = false;
-    }
-
     return res;
   }
   const allCols = this.column_names.slice(0);
   return {
     allColumns,
-    getColumns: true,
-    getInfo: true,
     select: {
       fields: allCols,
       filterFields: allCols,
       orderByFields: allCols,
       forcedFilter: {},
       maxLimit: null,
+      syncConfig: this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(this.name),
     },
     update: {
       fields: allCols,

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -6,6 +6,7 @@ import type {
   SelectParams,
   SubscribeParams,
   SubscriptionChannels,
+  SubscriptionHandler,
 } from "prostgles-types";
 import { asName, isObject, postgresToTsType } from "prostgles-types";
 import type { TableEvent } from "../../Logging";
@@ -16,7 +17,7 @@ import type { Graph } from "../../shortestPath";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
 import { getSerializedClientErrorFromPGError } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
-import { getValidatedRules } from "../TableRules/getValidatedRules";
+import { getValidatedTableRules } from "../TableRules/getValidatedTableRules";
 import { getColumns } from "../getColumns";
 import { count } from "./count";
 import { find } from "./find";
@@ -151,41 +152,6 @@ export class ViewHandler {
 
   validateViewRules = validateViewRules.bind(this);
 
-  // DEAD CODE?!
-  // getShortestJoin(
-  //   table1: string,
-  //   table2: string,
-  //   startAlias: number,
-  //   isInner = false
-  // ): { query: string; toOne: boolean } {
-  //   const getJoinCondition = (
-  //     on: Record<string, string>[],
-  //     leftTable: string,
-  //     rightTable: string
-  //   ) => {
-  //     return on
-  //       .map((cond) =>
-  //         Object.keys(cond)
-  //           .map((lKey) => `${leftTable}.${lKey} = ${rightTable}.${cond[lKey]}`)
-  //           .join("\nAND ")
-  //       )
-  //       .join(" OR ");
-  //   };
-
-  //   // let toOne = true;
-  //   const query = this.joins
-  //     .map(({ tables, on, type }, i) => {
-  //       if (type.split("-")[1] === "many") {
-  //         // toOne = false;
-  //       }
-  //       const tl = `tl${startAlias + i}`,
-  //         tr = `tr${startAlias + i}`;
-  //       return `FROM ${tables[0]} ${tl} ${isInner ? "INNER" : "LEFT"} JOIN ${tables[1]} ${tr} ON ${getJoinCondition(on, tl, tr)}`;
-  //     })
-  //     .join("\n");
-  //   return { query, toOne: false };
-  // }
-
   checkFilter(filter: any) {
     if (filter === null || (filter && !isObject(filter)))
       throw `invalid filter -> ${JSON.stringify(filter)} \nExpecting:    undefined | {} | { field_name: "value" } | { field: { $gt: 22 } } ... `;
@@ -195,7 +161,7 @@ export class ViewHandler {
 
   getColumns = getColumns.bind(this);
 
-  getValidatedRules = getValidatedRules.bind(this);
+  getValidatedRules = getValidatedTableRules.bind(this);
 
   find = find.bind(this);
 
@@ -239,7 +205,7 @@ export class ViewHandler {
     filter: Filter,
     params: SubscribeParams,
     onData: OnData,
-  ): Promise<{ unsubscribe: () => any }>;
+  ): Promise<SubscriptionHandler>;
 
   async subscribe(
     filter: Filter,
@@ -255,7 +221,7 @@ export class ViewHandler {
     onData?: OnData,
     table_rules?: ParsedTableRule,
     localParams?: LocalParams,
-  ): Promise<{ unsubscribe: () => any } | SubscriptionChannels> {
+  ): Promise<SubscriptionHandler | SubscriptionChannels> {
     const result = await subscribe.bind(this)(
       filter,
       params,
@@ -272,7 +238,7 @@ export class ViewHandler {
     filter: Filter,
     params: SubscribeParams,
     onData: (item: AnyObject | undefined, error?: unknown) => any,
-  ): Promise<{ unsubscribe: () => any }>;
+  ): Promise<SubscriptionHandler>;
   subscribeOne(
     filter: Filter,
     params: SubscribeParams,
@@ -286,7 +252,7 @@ export class ViewHandler {
     onData?: (item: AnyObject | undefined, error?: unknown) => void,
     table_rules?: ParsedTableRule,
     localParams?: LocalParams,
-  ): Promise<SubscriptionChannels | { unsubscribe: () => any }> {
+  ): Promise<SubscriptionChannels | SubscriptionHandler> {
     const func =
       localParams || !onData ? undefined : (
         (rows: AnyObject[], error?: unknown) => onData(rows[0], error)

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -9,19 +9,9 @@ export async function getInfo(
   param2?: any,
   param3?: any,
   tableRules?: ParsedTableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): Promise<TInfo> {
-  const p = this.getValidatedRules(tableRules, localParams);
-  if (!p.getInfo) {
-    await this._log({
-      command: "getInfo",
-      localParams,
-      data: { lang },
-      duration: 0,
-      error: "Not allowed",
-    });
-    throw "Not allowed";
-  }
+  const validatedTableRules = this.getValidatedRules(tableRules, localParams);
 
   const fileTableName = this.dboBuilder.prostgles.opts.fileTable?.tableName;
 
@@ -33,13 +23,14 @@ export async function getInfo(
   });
   const allowedFieldsToSelect = this.parseFieldFilter(tableRules?.select?.fields);
   const { requiredNestedInserts, allowedNestedInserts } = tableRules?.insert ?? {};
+  const label = this.dboBuilder.prostgles.tableConfigurator?.getTableLabel({
+    tableName: this.name,
+    lang,
+  });
   return {
     oid: this.tableOrViewInfo.oid,
     comment: this.tableOrViewInfo.comment,
-    info: this.dboBuilder.prostgles.tableConfigurator?.getTableInfo({
-      tableName: this.name,
-      lang,
-    }),
+    label,
     isFileTable:
       !this.is_media ? undefined : (
         {
@@ -49,8 +40,8 @@ export async function getInfo(
     isView: this.is_view,
     hasFiles: Boolean(
       !this.is_media &&
-        fileTableName &&
-        this.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName))
+      fileTableName &&
+      this.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
     ),
     fileTableName,
     dynamicRules: {
@@ -60,8 +51,21 @@ export async function getInfo(
      * Only show column groups that are fully allowed to be selected by the user
      */
     uniqueColumnGroups: this.tableOrViewInfo.uniqueColumnGroups?.filter(
-      (g) => !localParams || g.every((c) => allowedFieldsToSelect.includes(c))
+      (g) => !localParams || g.every((c) => allowedFieldsToSelect.includes(c)),
     ),
-    ...(requiredNestedInserts && { requiredNestedInserts }),
+    publishInfo: {
+      select: validatedTableRules.select && {
+        disabledMethods: validatedTableRules.select.disableMethods,
+        syncConfig: this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(this.name),
+      },
+      insert: validatedTableRules.insert && {
+        requiredNestedInserts,
+        allowedNestedInserts: allowedNestedInserts?.map((t) => t.table),
+      },
+      update: validatedTableRules.update && {
+        disabledMethods: tableRules?.update?.disableMethods,
+      },
+      delete: validatedTableRules.delete && {},
+    },
   };
 }

package/lib/DboBuilder/ViewHandler/getValidatedSubscribeOptions.ts

@@ -4,11 +4,11 @@ import {
   isEmpty,
   type SubscribeOptions,
 } from "prostgles-types";
-import { type Required_ish, type SubscribeRule } from "../../PublishParser/PublishParser";
+import { type Required_ish, type SelectRule } from "../../PublishParser/PublishParser";
 
 export const getValidatedSubscribeOptions = (
   rawVal: Required_ish<SubscribeOptions>,
-  subscribeRule: SubscribeRule | undefined
+  selectRule: SelectRule | undefined,
 ): Required_ish<SubscribeOptions> => {
   const { data, error } = getJSONBObjectSchemaValidationError(
     {
@@ -46,13 +46,13 @@ export const getValidatedSubscribeOptions = (
       },
     } as const,
     rawVal,
-    "subscribeParams"
+    "subscribeParams",
   );
   if (error !== undefined) {
     throw error;
   }
 
-  const publishedThrottle = subscribeRule?.throttle || 0;
+  const publishedThrottle = selectRule?.subscribeThrottle || 0;
   const {
     actions,
     throttleOpts,

package/lib/DboBuilder/ViewHandler/subscribe.ts

@@ -90,7 +90,7 @@ async function subscribe(
       selectParams: { ...selectParams },
       subscribeOptions: getValidatedSubscribeOptions(
         { actions, skipFirst, throttle, throttleOpts, skipChangedColumnsCheck },
-        table_rules?.subscribe,
+        table_rules?.select,
       ),
       lastPushed: 0,
       tracked_columns: !firstField ? undefined : [firstField, ...otherFields],

package/lib/DboBuilder/getColumns.ts

@@ -1,15 +1,7 @@
-import type {
-  AnyObject,
-  ValidatedColumnInfo} from "prostgles-types";
-import {
-  _PG_geometric,
-  isDefined,
-  isObject,
-  omitKeys,
-  postgresToTsType,
-} from "prostgles-types";
+import type { AnyObject, ValidatedColumnInfo } from "prostgles-types";
+import { _PG_geometric, isDefined, isObject, omitKeys, postgresToTsType } from "prostgles-types";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
-import type { LocalParams} from "./DboBuilder";
+import type { LocalParams } from "./DboBuilder";
 import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./DboBuilder";
 import type { TableHandler } from "./TableHandler/TableHandler";
 import type { ViewHandler } from "./ViewHandler/ViewHandler";
@@ -22,14 +14,12 @@ export async function getColumns(
   params?: { rule: "update"; filter: AnyObject },
   _param3?: undefined,
   tableRules?: ParsedTableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): Promise<ValidatedColumnInfo[]> {
   const start = Date.now();
   try {
     const rules = this.getValidatedRules(tableRules, localParams);
 
-    if (!rules.getColumns) throw "Not allowed";
-
     let dynamicUpdateFields = this.column_names;
 
     if (params && tableRules && isTableHandler(this)) {

package/lib/FileManager/FileManager.ts

@@ -138,11 +138,10 @@ export class FileManager {
             const fileTable = fullConfig.tableName;
             const daysDelay = fullConfig.delayedDelete?.deleteAfterNDays ?? 0;
             if (fileTable && this.dbo[fileTable]?.delete && daysDelay) {
-              const filesToDelete =
-                (await this.dbo[fileTable].find?.({
-                  deleted_from_storage: null,
-                  deleted: { ">": Date.now() - daysDelay * HOUR * 24 },
-                })) ?? [];
+              const filesToDelete = await this.dbo[fileTable].find({
+                deleted_from_storage: null,
+                deleted: { ">": Date.now() - daysDelay * HOUR * 24 },
+              });
               for (const file of filesToDelete) {
                 await this.deleteFile(file.name);
               }
@@ -278,7 +277,7 @@ export class FileManager {
   }): ValidatedColumnInfo["file"] | undefined => {
     const { colName, tableName } = args;
     const tableConfig = this.prostgles?.opts.fileTable?.referencedTables?.[tableName];
-    const isReferencingFileTable = this.dbo[tableName]?.columns?.some(
+    const isReferencingFileTable = this.dbo[tableName]?.columns.some(
       (c) =>
         c.name === colName &&
         c.references &&