prostgles-server 4.2.507 → 4.2.509

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -1,16 +1,10 @@
-import { getKeys, includes, isObject } from "prostgles-types";
+import { getObjectEntries, isObject } from "prostgles-types";
 import type { AuthResultWithSID } from "../Auth/AuthTypes";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import type { ViewHandler } from "../DboBuilder/ViewHandler/ViewHandler";
-import { DEFAULT_SYNC_BATCH_SIZE } from "../PubSubManager/PubSubManagerUtils";
 import type { PublishParser } from "./PublishParser";
-import type {
-  DboTable,
-  ParsedPublishTable,
-  PublishTableRule,
-  PublishViewRule,
-} from "./publishTypesAndUtils";
-import { type PublishObject, RULE_TO_METHODS } from "./publishTypesAndUtils";
+import type { DboTable, ParsedPublishTable } from "./publishTypesAndUtils";
+import { TABLE_RULE_NO_LIMITS, type PublishObject } from "./publishTypesAndUtils";
 
 export async function getTableRulesWithoutFileTable(
   this: PublishParser,
@@ -18,182 +12,100 @@ export async function getTableRulesWithoutFileTable(
   clientInfo: AuthResultWithSID | undefined,
   overridenPublish?: PublishObject,
 ): Promise<ParsedPublishTable | undefined> {
-  if (!tableName) throw new Error("tableName is missing in getTableRules");
+  if (!tableName) {
+    throw new Error("tableName is missing in getTableRules");
+  }
 
   const publish =
-    overridenPublish ?? (clientReq && (await this.getPublishAsObject(clientReq, clientInfo)));
+    overridenPublish ?? (clientReq && (await this.getPublishObject(clientReq, clientInfo)));
 
   const rawTableRule = publish?.[tableName];
   if (!rawTableRule || (isObject(rawTableRule) && Object.values(rawTableRule).every((v) => !v))) {
     return undefined;
   }
 
-  let parsedTableRule: ParsedPublishTable = {};
-
   /* Get view or table specific rules */
-  const tHandler = this.dbo[tableName] as TableHandler | ViewHandler | undefined;
-  if (!tHandler) {
+  const tableHandler = this.dbo[tableName] as TableHandler | ViewHandler | undefined;
+  if (!tableHandler) {
     throw {
       stack: ["getTableRules()"],
       message: `${tableName} could not be found in dbo`,
     };
   }
-  const is_view = tHandler.is_view;
+
+  const is_view = tableHandler.is_view;
+
   /**
    * Allow subscribing to a view if it has primary key columns from other tables
    */
-  const canSubscribe = !is_view || tHandler.columns.some((c) => c.references);
+  const canSubscribe = !is_view || tableHandler.columns.some((c) => c.references);
+
+  const isStarOrTrue = (value: any): value is "*" | true => value === "*" || value === true;
+  const { privileges } = tableHandler.tableOrViewInfo;
+  const tableRulesObject =
+    isStarOrTrue(rawTableRule) ?
+      {
+        select: privileges.select ? TABLE_RULE_NO_LIMITS.select : undefined,
+        insert: privileges.insert ? TABLE_RULE_NO_LIMITS.insert : undefined,
+        update: privileges.update ? TABLE_RULE_NO_LIMITS.update : undefined,
+        delete: privileges.delete ? TABLE_RULE_NO_LIMITS.delete : undefined,
+      }
+    : rawTableRule;
+
+  const selectRule =
+    !tableRulesObject.select ? undefined
+    : isStarOrTrue(tableRulesObject.select) ? TABLE_RULE_NO_LIMITS.select
+    : tableRulesObject.select;
+  const insertRule =
+    !tableRulesObject.insert ? undefined
+    : isStarOrTrue(tableRulesObject.insert) ? TABLE_RULE_NO_LIMITS.insert
+    : tableRulesObject.insert;
+  const updateRule =
+    !tableRulesObject.update ? undefined
+    : isStarOrTrue(tableRulesObject.update) ? TABLE_RULE_NO_LIMITS.update
+    : tableRulesObject.update;
+  const deleteRule =
+    !tableRulesObject.delete ? undefined
+    : isStarOrTrue(tableRulesObject.delete) ? TABLE_RULE_NO_LIMITS.delete
+    : tableRulesObject.delete;
+
+  const parsedTableRule: ParsedPublishTable = {
+    select: selectRule && {
+      ...selectRule,
+      disableMethods:
+        canSubscribe ?
+          selectRule.disableMethods
+        : {
+            ...selectRule.disableMethods,
+            subscribe: 1,
+          },
+      subscribeThrottle: selectRule.subscribeThrottle ?? 0,
+    },
+    insert: insertRule,
+    update: updateRule,
+    delete: deleteRule,
+  };
 
-  const MY_RULES = RULE_TO_METHODS.filter((r) => {
-    /** Check PG User privileges */
-    const pgUserIsAllowedThis = tHandler.tableOrViewInfo.privileges[r.sqlRule];
-    let result = (!is_view || !r.table_only) && pgUserIsAllowedThis;
+  const cannotBatchUpdate =
+    !parsedTableRule.update ||
+    parsedTableRule.update.checkFilter ||
+    parsedTableRule.update.postValidate;
 
-    if (
-      !pgUserIsAllowedThis &&
-      isObject(rawTableRule) &&
-      (rawTableRule as PublishTableRule)[r.sqlRule]
-    ) {
-      throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
+  if (cannotBatchUpdate && parsedTableRule.update) {
+    parsedTableRule.update.disableMethods = {
+      updateBatch: 1,
+    };
+  }
+  getObjectEntries(parsedTableRule).forEach(([publishCommand, publishValue]) => {
+    if (!publishValue) {
+      return;
     }
 
-    // TODO: Implement comprehensive canSubscribe check
-    // if ((r.rule === "subscribe" || r.rule === "sync") && !this.prostgles.isSuperUser) {
-    //   result = false;
-    //   if (isObject(raw_table_rules) && (raw_table_rules as PublishTableRule)[r.rule]) {
-    //     throw `Cannot publish realtime rule ${tableName}.${r.rule}. Superuser is required for this`
-    //   }
-    // }
-
-    if (r.rule === "subscribe" && !canSubscribe) {
-      result = false;
+    const pgUserIsAllowedThisCommand = tableHandler.tableOrViewInfo.privileges[publishCommand];
+    if (!pgUserIsAllowedThisCommand) {
+      throw `Current postgres user is not allowed ${publishCommand} on table ${tableName}`;
     }
-
-    return result;
   });
 
-  /* All methods allowed. Add no limits for table rules */
-  if (includes([true, "*"], rawTableRule)) {
-    parsedTableRule = {};
-    MY_RULES.filter((r) => r.no_limits).forEach((r) => {
-      parsedTableRule[r.rule] = { ...(r.no_limits as object) } as any;
-    });
-
-    /** Specific rules allowed */
-  } else if (isObject(rawTableRule) && getKeys(rawTableRule).length) {
-    const allRuleKeys: (keyof PublishViewRule | keyof PublishTableRule)[] = getKeys(rawTableRule);
-    const dissallowedRuleKeys = allRuleKeys.filter((m) => !(rawTableRule as PublishTableRule)[m]);
-
-    MY_RULES.map((r) => {
-      /** Unless specifically disabled these are allowed */
-      if (
-        ["getInfo", "getColumns"].includes(r.rule) &&
-        !dissallowedRuleKeys.includes(r.rule as any)
-      ) {
-        parsedTableRule[r.rule] = r.no_limits as any;
-        return;
-      }
-
-      /** Add no_limit values for implied/ fully allowed methods */
-      if ([true, "*"].includes((rawTableRule as PublishTableRule)[r.rule] as any) && r.no_limits) {
-        parsedTableRule[r.rule] = Object.assign({}, r.no_limits) as any;
-
-        /** Carry over detailed config */
-      } else if (isObject((rawTableRule as any)[r.rule])) {
-        parsedTableRule[r.rule] = (rawTableRule as any)[r.rule];
-      }
-    });
-
-    allRuleKeys
-      .filter((m) => parsedTableRule[m])
-      .forEach((method) => {
-        const rule = parsedTableRule[method];
-
-        const ruleInfo = MY_RULES.find(
-          (r) => r.rule === method || (r.methods as readonly string[]).includes(method),
-        );
-        if (!ruleInfo) {
-          let extraInfo = "";
-          if (
-            is_view &&
-            RULE_TO_METHODS.find(
-              (r) =>
-                r.table_only &&
-                (r.rule === method || (r.methods as readonly string[]).includes(method)),
-            )
-          ) {
-            extraInfo = "You've specified table rules to a view\n";
-          }
-          throw `Invalid rule in publish.${tableName} -> ${method} \n${extraInfo}Expecting any of: ${MY_RULES.flatMap((r) => [r.rule, ...r.methods]).join(", ")}`;
-        }
-
-        /* Check RULES for invalid params */
-        /* Methods do not have params -> They use them from rules */
-        if (method === ruleInfo.rule && isObject(rule)) {
-          const method_params = Object.keys(rule);
-          const allowed_params = Object.keys(ruleInfo.allowed_params);
-          const iparam = method_params.find((p) => !allowed_params.includes(p));
-          if (iparam) {
-            throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${allowed_params.join(", ")}`;
-          }
-        }
-
-        /* Add default params (if missing) */
-        if (method === "sync") {
-          if ([true, "*"].includes(parsedTableRule[method] as any)) {
-            throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
-          }
-
-          if (typeof parsedTableRule[method]?.throttle !== "number") {
-            parsedTableRule[method]!.throttle = 100;
-          }
-          if (typeof parsedTableRule[method]?.batch_size !== "number") {
-            parsedTableRule[method]!.batch_size = DEFAULT_SYNC_BATCH_SIZE;
-          }
-        }
-
-        /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
-        const subKey = "subscribe";
-
-        if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
-          const sr = MY_RULES.find((r) => r.rule === subKey);
-          if (sr && canSubscribe) {
-            parsedTableRule[subKey] = { ...sr.no_limits };
-            parsedTableRule.subscribeOne = { ...sr.no_limits };
-          }
-        }
-      });
-  } else {
-    throw "Unexpected publish";
-  }
-
-  const getImpliedMethods = (tableRules: ParsedPublishTable): ParsedPublishTable => {
-    const res = { ...tableRules };
-
-    /* Add implied methods if not specifically dissallowed */
-    MY_RULES.map((r) => {
-      /** THIS IS A MESS -> some methods cannot be dissallowed (unsync, unsubscribe...) */
-      r.methods.forEach((method) => {
-        const isAllowed = tableRules[r.rule] && (tableRules as any)[method] === undefined;
-        if (isAllowed) {
-          if (
-            method === "updateBatch" &&
-            (!tableRules.update || tableRules.update.checkFilter || tableRules.update.postValidate)
-          ) {
-            // not allowed
-          } else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
-            // not allowed
-          } else {
-            (res as any)[method] ??= true;
-          }
-        }
-      });
-    });
-
-    return res;
-  };
-
-  parsedTableRule = getImpliedMethods(parsedTableRule);
-
   return parsedTableRule;
 }

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -1,11 +1,5 @@
-import { RULE_METHODS } from "prostgles-types";
 import type { DBOFullyTyped, PublishFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
-import type {
-  CommonTableRules,
-  Filter,
-  LocalParams,
-  TableOrViewInfo,
-} from "../DboBuilder/DboBuilder";
+import type { Filter, LocalParams, TableOrViewInfo } from "../DboBuilder/DboBuilder";
 import type { DB, DBHandlerServer } from "../Prostgles";
 
 export type Awaitable<T> = T | Promise<T>;
@@ -18,132 +12,16 @@ export type DboTableCommand = DboTable & {
   command: string;
 };
 
-export const RULE_TO_METHODS = [
-  {
-    rule: "getColumns",
-    sqlRule: "select",
-    methods: RULE_METHODS.getColumns,
-    no_limits: true,
-    allowed_params: [],
-    table_only: false,
-    hint: ` expecting false | true | undefined`,
-  },
-  {
-    rule: "getInfo",
-    sqlRule: "select",
-    methods: RULE_METHODS.getInfo,
-    no_limits: true,
-    allowed_params: [],
-    table_only: false,
-    hint: ` expecting false | true | undefined`,
-  },
-  {
-    rule: "insert",
-    sqlRule: "insert",
-    methods: RULE_METHODS.insert,
-    no_limits: <SelectRule>{ fields: "*" },
-    table_only: true,
-    allowed_params: {
-      checkFilter: 1,
-      fields: 1,
-      forcedData: 1,
-      postValidate: 1,
-      preValidate: 1,
-      returningFields: 1,
-      validate: 1,
-      allowedNestedInserts: 1,
-      requiredNestedInserts: 1,
-    } satisfies Record<keyof InsertRule, 1>,
-    hint: ` expecting "*" | true | { fields: string | string[] | {}  }`,
-  },
-  {
-    rule: "update",
-    sqlRule: "update",
-    methods: RULE_METHODS.update,
-    no_limits: <UpdateRule>{
-      fields: "*",
-      filterFields: "*",
-      returningFields: "*",
-    },
-    table_only: true,
-    allowed_params: {
-      checkFilter: 1,
-      dynamicFields: 1,
-      fields: 1,
-      filterFields: 1,
-      forcedData: 1,
-      forcedFilter: 1,
-      postValidate: 1,
-      returningFields: 1,
-      validate: 1,
-    } satisfies Record<keyof UpdateRule, 1>,
-    hint: ` expecting "*" | true | { fields: string | string[] | {}  }`,
-  },
-  {
-    rule: "select",
-    sqlRule: "select",
-    methods: RULE_METHODS.select,
-    no_limits: <SelectRule>{ fields: "*" },
-    table_only: false,
-    allowed_params: {
-      fields: 1,
-      filterFields: 1,
-      forcedFilter: 1,
-      maxLimit: 1,
-      orderByFields: 1,
-      validate: 1,
-    } satisfies Record<keyof SelectRule, 1>,
-    hint: ` expecting "*" | true | { fields: ( string | string[] | {} )  }`,
-  },
-  {
-    rule: "delete",
-    sqlRule: "delete",
-    methods: RULE_METHODS.delete,
-    no_limits: <DeleteRule>{ filterFields: "*" },
-    table_only: true,
-    allowed_params: {
-      returningFields: 1,
-      validate: 1,
-      filterFields: 1,
-      forcedFilter: 1,
-    } satisfies Record<keyof DeleteRule, 1>,
-    hint: ` expecting "*" | true | { filterFields: ( string | string[] | {} ) } \n Will use "select", "update", "delete" and "insert" rules`,
-  },
-  {
-    rule: "sync",
-    sqlRule: "select",
-    methods: RULE_METHODS.sync,
-    no_limits: null,
-    table_only: true,
-    allowed_params: {
-      // allow_delete: 1,
-      batch_size: 1,
-      id_fields: 1,
-      synced_field: 1,
-      throttle: 1,
-    } satisfies Record<keyof SyncRule, 1>,
-    hint: ` expecting "*" | true | { id_fields: string[], synced_field: string }`,
-  },
-  {
-    rule: "subscribe",
-    sqlRule: "select",
-    methods: RULE_METHODS.subscribe,
-    no_limits: <SubscribeRule>{ throttle: 0 },
-    table_only: false,
-    allowed_params: { throttle: 1 } satisfies Record<keyof SubscribeRule, 1>,
-    hint: ` expecting "*" | true | { throttle: number; throttleOpts?: { skipFirst?: boolean; } } \n Will use "select" rules`,
-  },
-] as const;
-
 import type pgPromise from "pg-promise";
 import type {
   AnyObject,
   DBSchema,
   FieldFilter,
   FullFilter,
+  RequiredNestedInsert,
   SelectParams,
   SQLHandler,
-  TableInfo,
+  TableSchema,
 } from "prostgles-types";
 import type { AuthClientRequest, LoginClientInfo, SessionUser } from "../Auth/AuthTypes";
 import type { TableSchemaColumn } from "../DboBuilder/DboBuilderTypes";
@@ -266,6 +144,10 @@ export type SelectRule<Cols extends AnyObject = AnyObject, S extends DBSchema |
    * Validation logic to check/update data for each request
    */
   validate?(args: SelectRequestData): SelectRequestData | Promise<SelectRequestData>;
+
+  subscribeThrottle?: number;
+
+  disableMethods?: Partial<Record<"sync" | "subscribe", 1>>;
 };
 
 export type CommonInsertUpdateRule<
@@ -324,7 +206,7 @@ export type InsertRule<
     column: string;
   }[];
 
-  requiredNestedInserts?: TableInfo["requiredNestedInserts"];
+  requiredNestedInserts?: RequiredNestedInsert[];
 };
 
 export type UpdateRule<
@@ -374,6 +256,8 @@ export type UpdateRule<
    * Happens in the same transaction so upon throwing an error the record will be deleted (not committed)
    */
   postValidate?: S extends DBSchema ? PostValidateRow<Required<Cols>, S> : PostValidateRowBasic;
+
+  disableMethods?: Partial<Record<"updateBatch", 1>>;
 };
 
 export type DeleteRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
@@ -395,9 +279,10 @@ export type DeleteRule<Cols extends AnyObject = AnyObject, S extends DBSchema |
   /**
    * Validation logic to check/update data for each request
    */
-  validate?(filter: FullFilter<Cols, S>): Awaitable<void>; // UpdateRequestData<Cols>;
+  validate?(filter: FullFilter<Cols, S>): Awaitable<void>;
 };
-export type SyncRule<Cols extends AnyObject = AnyObject> = {
+
+export type SyncConfig<Cols extends AnyObject = AnyObject> = {
   /**
    * Primary keys used in updating data
    */
@@ -423,9 +308,7 @@ export type SyncRule<Cols extends AnyObject = AnyObject> = {
    */
   batch_size?: number;
 };
-export type SubscribeRule = {
-  throttle?: number;
-};
+
 /**
  * Required but possibly undefined type
  * */
@@ -433,24 +316,16 @@ export type Required_ish<T> = {
   [K in keyof Required<T>]: T[K];
 };
 export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: NonNullable<T[P]> };
-export type ViewRule<S extends AnyObject = AnyObject> = CommonTableRules & {
-  /**
-   * What can be read from the table
-   */
-  select?: SelectRule<S>;
-};
-export type TableRule<
-  RowType extends AnyObject = AnyObject,
-  S extends DBSchema | void = void,
-> = ViewRule<RowType> & {
+
+export type TableRule<RowType extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+  select?: SelectRule<RowType, S>;
   insert?: InsertRule<RowType, S>;
   update?: UpdateRule<RowType, S>;
   delete?: DeleteRule<RowType, S>;
-  sync?: SyncRule<RowType>;
-  subscribe?: SubscribeRule;
+  sync?: SyncConfig<RowType>;
 };
 
-export type ParsedViewRule<S extends AnyObject = AnyObject> = CommonTableRules & {
+export type ParsedViewRule<S extends AnyObject = AnyObject> = {
   /**
    * What can be read from the table
    */
@@ -463,8 +338,6 @@ export type ParsedTableRule<
   insert?: WithRequired<InsertRule<RowType, S>, "returningFields">;
   update?: WithRequired<UpdateRule<RowType, S>, "filterFields" | "returningFields">;
   delete?: WithRequired<DeleteRule<RowType, S>, "returningFields">;
-  sync?: SyncRule<RowType>;
-  subscribe?: SubscribeRule;
 };
 
 export const parsePublishTableRule = <R extends ParsedPublishTable>(tableRules: R | undefined) => {
@@ -500,36 +373,40 @@ export const parsePublishTableRule = <R extends ParsedPublishTable>(tableRules:
   return parsedTableRules;
 };
 
-export type PublishViewRule<Col extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
-  select?: SelectRule<Col, S> | PublishAllOrNothing;
-  getColumns?: PublishAllOrNothing;
-  getInfo?: PublishAllOrNothing;
-};
 export type PublishTableRule<
   Col extends AnyObject = AnyObject,
   S extends DBSchema | void = void,
-> = PublishViewRule<Col, S> & {
+> = {
+  select?: SelectRule<Col, S> | PublishAllOrNothing;
   insert?: InsertRule<Col, S> | PublishAllOrNothing;
   update?: UpdateRule<Col, S> | PublishAllOrNothing;
   delete?: DeleteRule<Col, S> | PublishAllOrNothing;
-  /**
-   * TODO: move to tableConfig
-   */
-  sync?: SyncRule<Col>;
-  subscribe?: SubscribeRule | PublishAllOrNothing;
 };
 
+export const TABLE_RULE_NO_LIMITS = {
+  select: {
+    fields: "*",
+    disableMethods: undefined,
+    subscribeThrottle: 0,
+  },
+  insert: {
+    fields: "*",
+  },
+  update: {
+    fields: "*",
+    filterFields: "*",
+  },
+  delete: {
+    filterFields: "*",
+  },
+} as const satisfies PublishTableRule;
+
 export type ParsedPublishTable = {
   select?: SelectRule;
-  getColumns?: true;
-  getInfo?: true;
 
   insert?: InsertRule;
   update?: UpdateRule;
   delete?: DeleteRule;
-  sync?: SyncRule;
-  subscribe?: SubscribeRule;
-  subscribeOne?: SubscribeRule;
 };
 export type DbTableInfo = {
   name: string;
@@ -575,7 +452,7 @@ export type PublishParams<S = void, SUser extends SessionUser = SessionUser> = {
   user?: SUser["user"];
   clientReq: AuthClientRequest;
   clientInfo: LoginClientInfo;
-  tables: DbTableInfo[];
+  tables: TableSchema[];
   getClientDBHandlers: (
     /**
      * Used to filter permissions
@@ -585,10 +462,7 @@ export type PublishParams<S = void, SUser extends SessionUser = SessionUser> = {
 };
 export type RequestParams = { dbo?: DBHandlerServer; socket?: any };
 export type PublishAllOrNothing = boolean | "*" | null;
-export type PublishObject = Record<
-  string,
-  PublishTableRule | PublishViewRule | PublishAllOrNothing
->;
+export type PublishObject = Record<string, PublishTableRule | PublishAllOrNothing>;
 export type ParsedPublishTables = {
   [table_name: string]: ParsedPublishTable;
 };

package/lib/SyncReplication.ts

@@ -87,8 +87,8 @@ export async function syncData(
     return;
   }
   const tableHandler = this.dbo[table_name];
-  if (!tableHandler?.find || !tableHandler.count) {
-    throw `dbo.${table_name}.find or .count are missing or not allowed`;
+  if (!tableHandler?.find) {
+    throw `dbo.${table_name}.find missing or not allowed`;
   }
 
   const sync_fields = [synced_field, ...id_fields.sort()],
@@ -110,7 +110,7 @@ export async function syncData(
         };
       }
 
-      const first_rows = await tableHandler.find!(
+      const first_rows = await tableHandler.find(
         _filter,
         { orderBy: orderByAsc, select: sync_fields, limit, offset },
         undefined,
@@ -119,7 +119,7 @@ export async function syncData(
       );
       const last_rows = first_rows.slice(-1); // Why not logic below?
       // const last_rows = await _this?.dbo[table_name]?.find?.(_filter, { orderBy: (orderByDesc as OrderBy), select: sync_fields, limit: 1, offset: -offset || 0 }, null, table_rules);
-      const count = await tableHandler.count!(_filter, undefined, undefined, table_rules);
+      const count = await tableHandler.count(_filter, undefined, undefined, table_rules);
 
       return {
         s_fr: first_rows[0] || null,
@@ -189,7 +189,7 @@ export async function syncData(
       };
 
       try {
-        const res = await tableHandler.find?.(
+        const res = await tableHandler.find(
           _filter,
           {
             select: params.select,
@@ -202,8 +202,6 @@ export async function syncData(
           { clientReq: { socket } },
         );
 
-        if (!res) throw "_this?.dbo?.[table_name]?.find is missing";
-
         return res;
       } catch (e) {
         console.error("Sync getServerData failed: ", e);
@@ -418,7 +416,7 @@ export async function syncData(
             sync_fields.map((key) => {
               _filter[key] = c_lr[key];
             });
-            server_row = await this.dbo[table_name]?.find?.(
+            server_row = await this.dbo[table_name]?.find(
               _filter,
               { select: sync_fields, limit: 1 },
               undefined,