prostgles-server 4.2.187 → 4.2.188

package/lib/SyncReplication.ts

@@ -1,10 +1,4 @@
-import {
-  PubSubManager,
-  SyncParams,
-  pickKeys,
-  omitKeys,
-  log,
-} from "./PubSubManager/PubSubManager";
+import { PubSubManager, SyncParams, pickKeys, omitKeys, log } from "./PubSubManager/PubSubManager";
 import { OrderBy, WAL, AnyObject, SyncBatchParams } from "prostgles-types";
 import { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
 
@@ -45,12 +39,8 @@ export type ClientExpressData = ClientSyncInfo & {
   deleted?: AnyObject[];
 };
 
-function getNumbers(
-  numberArr: (null | undefined | string | number)[],
-): number[] {
-  return numberArr.filter(
-    (v) => v !== null && v !== undefined && Number.isFinite(+v),
-  ) as any;
+function getNumbers(numberArr: (null | undefined | string | number)[]): number[] {
+  return numberArr.filter((v) => v !== null && v !== undefined && Number.isFinite(+v)) as any;
 }
 
 /**
@@ -60,7 +50,7 @@ export async function syncData(
   this: PubSubManager,
   sync: SyncParams,
   clientData: ClientExpressData | undefined,
-  source: "trigger" | "client",
+  source: "trigger" | "client"
 ) {
   await this._log({
     type: "sync",
@@ -70,9 +60,7 @@ export async function syncData(
     source,
     ...pickKeys(sync, ["socket_id", "condition", "last_synced", "is_syncing"]),
     lr: JSON.stringify(sync.lr),
-    connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map(
-      (s) => s.id,
-    ),
+    connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
     localParams: undefined,
     duration: -1,
     socketId: sync.socket_id,
@@ -99,26 +87,14 @@ export async function syncData(
   }
 
   const sync_fields = [synced_field, ...id_fields.sort()],
-    orderByAsc: OrderBy = sync_fields.reduce(
-      (a, v) => ({ ...a, [v]: true }),
-      {},
-    ),
+    orderByAsc: OrderBy = sync_fields.reduce((a, v) => ({ ...a, [v]: true }), {}),
     rowsIdsMatch = (a?: AnyObject, b?: AnyObject) => {
-      return (
-        a &&
-        b &&
-        !id_fields.find((key) => a[key].toString() !== b[key].toString())
-      );
+      return a && b && !id_fields.find((key) => a[key].toString() !== b[key].toString());
     },
     rowsFullyMatch = (a?: AnyObject, b?: AnyObject) => {
-      return (
-        rowsIdsMatch(a, b) &&
-        a?.[synced_field].toString() === b?.[synced_field].toString()
-      );
+      return rowsIdsMatch(a, b) && a?.[synced_field].toString() === b?.[synced_field].toString();
     },
-    getServerRowInfo = async (
-      args: SyncBatchParams = {},
-    ): Promise<ServerSyncInfo> => {
+    getServerRowInfo = async (args: SyncBatchParams = {}): Promise<ServerSyncInfo> => {
       const { from_synced = null, to_synced = null, offset = 0, limit } = args;
       const _filter: AnyObject = { ...filter };
 
@@ -128,27 +104,19 @@ export async function syncData(
           ...(to_synced ? { $lte: to_synced } : {}),
         };
       }
-      if (
-        this.dbo?.[table_name]?.find === undefined ||
-        this?.dbo?.[table_name]?.count === undefined
-      ) {
+      if (this.dbo[table_name]?.find === undefined || this.dbo[table_name]?.count === undefined) {
         throw `dbo.${table_name}.find or .count are missing or not allowed`;
       }
 
-      const first_rows = await this.dbo?.[table_name]?.find?.(
+      const first_rows = await this.dbo[table_name]?.find?.(
         _filter,
         { orderBy: orderByAsc, select: sync_fields, limit, offset },
         undefined,
-        table_rules,
+        table_rules
       );
       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 this.dbo?.[table_name]?.count?.(
-        _filter,
-        undefined,
-        undefined,
-        table_rules,
-      );
+      const count = await this.dbo[table_name]?.count?.(_filter, undefined, undefined, table_rules);
 
       return {
         s_fr: first_rows?.[0] || null,
@@ -160,22 +128,18 @@ export async function syncData(
       const { from_synced = null, to_synced = null, end_offset = null } = args;
       const res = new Promise<any>((resolve, reject) => {
         const onSyncRequest = { from_synced, to_synced, end_offset }; //, forReal: true };
-        socket.emit(
-          channel_name,
-          { onSyncRequest },
-          (resp?: onSyncRequestResponse) => {
-            if (resp && "onSyncRequest" in resp && resp?.onSyncRequest) {
-              const c_fr = resp.onSyncRequest.c_fr,
-                c_lr = resp.onSyncRequest.c_lr,
-                c_count = resp.onSyncRequest.c_count;
-
-              // console.log(onSyncRequest, { c_fr, c_lr, c_count }, socket._user);
-              return resolve({ c_fr, c_lr, c_count });
-            } else if (resp && "err" in resp && resp?.err) {
-              reject(resp.err);
-            }
-          },
-        );
+        socket.emit(channel_name, { onSyncRequest }, (resp?: onSyncRequestResponse) => {
+          if (resp && "onSyncRequest" in resp && resp.onSyncRequest) {
+            const c_fr = resp.onSyncRequest.c_fr,
+              c_lr = resp.onSyncRequest.c_lr,
+              c_count = resp.onSyncRequest.c_count;
+
+            // console.log(onSyncRequest, { c_fr, c_lr, c_count }, socket._user);
+            return resolve({ c_fr, c_lr, c_count });
+          } else if (resp && "err" in resp && resp.err) {
+            reject(resp.err);
+          }
+        });
       });
 
       return res;
@@ -187,20 +151,14 @@ export async function syncData(
           offset: offset || 0,
           limit: batch_size,
         };
-        socket.emit(
-          channel_name,
-          { onPullRequest },
-          async (resp?: { data?: AnyObject[] }) => {
-            if (resp && resp.data && Array.isArray(resp.data)) {
-              // console.log({ onPullRequest, resp }, socket._user)
-              resolve(sortClientData(resp.data));
-            } else {
-              reject(
-                "unexpected onPullRequest response: " + JSON.stringify(resp),
-              );
-            }
-          },
-        );
+        socket.emit(channel_name, { onPullRequest }, async (resp?: { data?: AnyObject[] }) => {
+          if (resp && resp.data && Array.isArray(resp.data)) {
+            // console.log({ onPullRequest, resp }, socket._user)
+            resolve(sortClientData(resp.data));
+          } else {
+            reject("unexpected onPullRequest response: " + JSON.stringify(resp));
+          }
+        });
       });
 
       function sortClientData(data: AnyObject[]) {
@@ -211,7 +169,9 @@ export async function syncData(
             id_fields
               .sort()
               .map((idKey) =>
-                a[idKey] < b[idKey] ? -1 : a[idKey] > b[idKey] ? 1 : 0,
+                a[idKey] < b[idKey] ? -1
+                : a[idKey] > b[idKey] ? 1
+                : 0
               )
               .find((v) => v) ||
             0
@@ -219,20 +179,16 @@ export async function syncData(
         });
       }
     },
-    getServerData = async (
-      from_synced = 0,
-      offset = 0,
-    ): Promise<AnyObject[]> => {
+    getServerData = async (from_synced = 0, offset = 0): Promise<AnyObject[]> => {
       const _filter = {
         ...filter,
         [synced_field]: { $gte: from_synced || 0 },
       };
 
-      if (!this?.dbo?.[table_name]?.find)
-        throw "_this?.dbo?.[table_name]?.find is missing";
+      if (!this.dbo[table_name]?.find) throw "_this?.dbo?.[table_name]?.find is missing";
 
       try {
-        const res = this?.dbo?.[table_name]?.find?.(
+        const res = this.dbo[table_name]?.find?.(
           _filter,
           {
             select: params.select,
@@ -241,7 +197,7 @@ export async function syncData(
             limit: batch_size,
           },
           undefined,
-          table_rules,
+          table_rules
         );
 
         if (!res) throw "_this?.dbo?.[table_name]?.find is missing";
@@ -263,19 +219,17 @@ export async function syncData(
                 id_filter,
                 undefined,
                 undefined,
-                table_rules,
+                table_rules
               );
               return 1;
             } catch (e) {
               console.error(e);
             }
             return 0;
-          }),
+          })
         );
       } else {
-        console.warn(
-          "client tried to delete data without permission (allow_delete is false)",
-        );
+        console.warn("client tried to delete data without permission (allow_delete is false)");
       }
       return false;
     },
@@ -294,16 +248,11 @@ export async function syncData(
               orderBy: orderByAsc as OrderBy,
             },
             undefined,
-            table_rules,
-          );
-          let inserts = data.filter(
-            (d) => !existingData.find((ed) => rowsIdsMatch(ed, d)),
+            table_rules
           );
+          let inserts = data.filter((d) => !existingData.find((ed) => rowsIdsMatch(ed, d)));
           let updates = data.filter((d) =>
-            existingData.find(
-              (ed) =>
-                rowsIdsMatch(ed, d) && +ed[synced_field] < +d[synced_field],
-            ),
+            existingData.find((ed) => rowsIdsMatch(ed, d) && +ed[synced_field] < +d[synced_field])
           );
           try {
             if (!table_rules) throw "table_rules missing";
@@ -314,32 +263,24 @@ export async function syncData(
                 updates.map((upd) => {
                   const id_filter = pickKeys(upd, id_fields);
                   const syncSafeFilter = {
-                    $and: [
-                      id_filter,
-                      { [synced_field]: { "<": upd[synced_field] } },
-                    ],
+                    $and: [id_filter, { [synced_field]: { "<": upd[synced_field] } }],
                   };
 
                   updateData.push([syncSafeFilter, omitKeys(upd, id_fields)]);
-                }),
+                })
               );
               await tbl.updateBatch(
                 updateData,
                 { removeDisallowedFields: true },
                 undefined,
-                table_rules,
+                table_rules
               );
             } else {
               updates = [];
             }
 
             if (table_rules.insert && inserts.length) {
-              await tbl.insert(
-                inserts,
-                { removeDisallowedFields: true },
-                undefined,
-                table_rules,
-              );
+              await tbl.insert(inserts, { removeDisallowedFields: true }, undefined, table_rules);
             } else {
               inserts = [];
             }
@@ -352,7 +293,7 @@ export async function syncData(
         })
         .then(({ inserts, updates }) => {
           log(
-            `upsertData: inserted( ${inserts.length} )    updated( ${updates.length} )     total( ${data.length} ) \n last insert ${JSON.stringify(inserts.at(-1))} \n last update ${JSON.stringify(updates.at(-1))}`,
+            `upsertData: inserted( ${inserts.length} )    updated( ${updates.length} )     total( ${data.length} ) \n last insert ${JSON.stringify(inserts.at(-1))} \n last update ${JSON.stringify(updates.at(-1))}`
           );
           return {
             inserted: inserts.length,
@@ -365,11 +306,9 @@ export async function syncData(
             "Something went wrong with syncing to server: \n ->",
             err,
             data.length,
-            id_fields,
-          );
-          return Promise.reject(
-            "Something went wrong with syncing to server: ",
+            id_fields
           );
+          return Promise.reject("Something went wrong with syncing to server: ");
         });
 
       await this._log({
@@ -380,9 +319,7 @@ export async function syncData(
         socketId: socket_id,
         sid: sync.sid,
         duration: Date.now() - start,
-        connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map(
-          (s) => s.id,
-        ),
+        connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
       });
 
       return result;
@@ -391,26 +328,18 @@ export async function syncData(
      * Pushes the given data to client
      * @param isSynced = true if
      */
-    pushData = async (
-      data?: AnyObject[],
-      isSynced = false,
-      err: any = null,
-    ) => {
+    pushData = async (data?: AnyObject[], isSynced = false, err: any = null) => {
       const start = Date.now();
       const result = await new Promise((resolve, reject) => {
-        socket.emit(
-          channel_name,
-          { data, isSynced },
-          (resp?: { ok: boolean }) => {
-            if (resp && resp.ok) {
-              // console.log("PUSHED to client: fr/lr", data[0], data[data.length - 1]);
-              resolve({ pushed: data?.length, resp });
-            } else {
-              reject(resp);
-              console.error("Unexpected response");
-            }
-          },
-        );
+        socket.emit(channel_name, { data, isSynced }, (resp?: { ok: boolean }) => {
+          if (resp && resp.ok) {
+            // console.log("PUSHED to client: fr/lr", data[0], data[data.length - 1]);
+            resolve({ pushed: data?.length, resp });
+          } else {
+            reject(resp);
+            console.error("Unexpected response");
+          }
+        });
       });
 
       await this._log({
@@ -421,9 +350,7 @@ export async function syncData(
         socketId: socket_id,
         duration: Date.now() - start,
         sid: sync.sid,
-        connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map(
-          (s) => s.id,
-        ),
+        connectedSocketIds: this.dboBuilder.prostgles.connectedSockets.map((s) => s.id),
       });
 
       return result;
@@ -433,12 +360,9 @@ export async function syncData(
      * If last rows don't match it will find an earlier matching last row and use that last matching from_synced
      * If no rows or fully synced (c_lr and s_lr match) then returns null
      */
-    getLastSynced = async (
-      clientSyncInfo?: ClientSyncInfo,
-    ): Promise<number | null> => {
+    getLastSynced = async (clientSyncInfo?: ClientSyncInfo): Promise<number | null> => {
       // Get latest row info
-      const { c_fr, c_lr, c_count } =
-        clientSyncInfo || (await getClientRowInfo());
+      const { c_fr, c_lr, c_count } = clientSyncInfo || (await getClientRowInfo());
       const { s_fr, s_lr, s_count } = await getServerRowInfo();
 
       // console.log("getLastSynced", clientData, socket._user )
@@ -462,13 +386,9 @@ export async function syncData(
         /* Sync from last matching synced value */
       } else if (rowsFullyMatch(c_fr, s_fr)) {
         if (s_lr && c_lr) {
-          result = Math.min(
-            ...getNumbers([c_lr[synced_field], s_lr[synced_field]]),
-          );
+          result = Math.min(...getNumbers([c_lr[synced_field], s_lr[synced_field]]));
         } else {
-          result = Math.min(
-            ...getNumbers([c_fr[synced_field], s_fr?.[synced_field]]),
-          );
+          result = Math.min(...getNumbers([c_fr[synced_field], s_fr?.[synced_field]]));
         }
 
         const min_count = Math.min(...getNumbers([c_count, s_count]));
@@ -489,11 +409,11 @@ 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,
-              table_rules,
+              table_rules
             );
           }
 
@@ -518,16 +438,12 @@ export async function syncData(
     updateSyncLR = (data: AnyObject) => {
       if (data.length) {
         const lastRow = data[data.length - 1];
-        if (
-          sync.lr?.[synced_field] &&
-          +sync.lr?.[synced_field] > +lastRow[synced_field]
-        ) {
+        if (sync.lr?.[synced_field] && +sync.lr[synced_field] > +lastRow[synced_field]) {
           console.error(
             {
-              syncIssue:
-                "sync.lr[synced_field] is greater than lastRow[synced_field]",
+              syncIssue: "sync.lr[synced_field] is greater than lastRow[synced_field]",
             },
-            sync.table_name,
+            sync.table_name
           );
         }
         sync.lr = lastRow;
@@ -553,31 +469,27 @@ export async function syncData(
       // console.log("syncBatch", from_synced)
 
       while (canContinue) {
-        const cData = await getClientData(min_synced, offset);
+        const clientData = await getClientData(min_synced, offset);
 
-        if (cData.length) {
-          const res = await upsertData(cData);
+        if (clientData.length) {
+          const res = await upsertData(clientData);
           inserted += res.inserted;
           updated += res.updated;
         }
-        let sData: AnyObject[] | undefined;
+        let serverData: AnyObject[] | undefined;
 
         try {
-          sData = await getServerData(min_synced, offset);
+          serverData = await getServerData(min_synced, offset);
         } catch (e) {
           console.trace("sync getServerData err", e);
-          await pushData(
-            undefined,
-            undefined,
-            "Internal error. Check server logs",
-          );
+          await pushData(undefined, undefined, "Internal error. Check server logs");
           throw " d";
         }
 
         // console.log("allow_delete", table_rules.delete);
         if (allow_delete && table_rules?.delete) {
-          const to_delete = sData.filter((d) => {
-            !cData.find((c) => rowsIdsMatch(c, d));
+          const to_delete = serverData.filter((d) => {
+            return !clientData.find((c) => rowsIdsMatch(c, d));
           });
           await Promise.all(
             to_delete.map((d) => {
@@ -586,38 +498,38 @@ export async function syncData(
                 pickKeys(d, id_fields),
                 {},
                 undefined,
-                table_rules,
+                table_rules
               );
-            }),
+            })
           );
-          sData = await getServerData(min_synced, offset);
+          serverData = await getServerData(min_synced, offset);
         }
 
-        const forClient = sData.filter((s) => {
-          return !cData.find(
-            (c) => rowsIdsMatch(c, s) && +c[synced_field] >= +s[synced_field],
+        const forClient = serverData.filter((s) => {
+          return !clientData.find(
+            (c) => rowsIdsMatch(c, s) && +c[synced_field] >= +s[synced_field]
           );
         });
         if (forClient.length) {
           const res: any = await pushData(
-            forClient.filter((d) => !sync.wal || !sync.wal.isInHistory(d)),
+            forClient.filter((d) => !sync.wal || !sync.wal.isInHistory(d))
           );
           pushed += res.pushed;
         }
 
-        if (sData.length) {
-          updateSyncLR(sData);
-          total += sData.length;
+        if (serverData.length) {
+          updateSyncLR(serverData);
+          total += serverData.length;
         }
-        offset += sData.length;
+        offset += serverData.length;
 
         // canContinue = offset >= limit;
-        canContinue = sData.length >= limit;
+        canContinue = serverData.length >= limit;
         // console.log(`sData ${sData.length}      limit ${limit}`);
       }
       log(
         `server.syncBatch ${table_name}: inserted( ${inserted} )    updated( ${updated} )   deleted( ${deleted} )    pushed to client( ${pushed} )     total( ${total} )`,
-        socket._user,
+        socket._user
       );
 
       return true;
@@ -686,13 +598,7 @@ export async function syncData(
    * Add to WAL manager which will sync at the end
    */
   if (clientData) {
-    if (
-      clientData.data &&
-      Array.isArray(clientData.data) &&
-      clientData.data.length
-    ) {
-      if (!sync.wal) throw "sync.wal missing";
-
+    if (clientData.data && Array.isArray(clientData.data) && clientData.data.length) {
       sync.wal.addData(clientData.data.map((d) => ({ current: d })));
       return;
       // await upsertData(clientData.data, true);

package/lib/TableConfig/TableConfig.ts

@@ -56,7 +56,7 @@ type BaseTableDefinition<LANG_IDS = AnyObject> = {
      * The returned row must satisfy the table schema
      */
     getPreInsertRow?: (
-      args: GetPreInsertRowArgs,
+      args: GetPreInsertRowArgs
     ) => Promise<{ row: AnyObject; onInserted: Promise<void> }>;
   };
   triggers?: {
@@ -169,9 +169,7 @@ type MediaColumn = {
        * https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
        */
       allowedContentType?: Record<
-        Partial<
-          "audio/*" | "video/*" | "image/*" | "text/*" | ALLOWED_CONTENT_TYPE
-        >,
+        Partial<"audio/*" | "video/*" | "image/*" | "text/*" | ALLOWED_CONTENT_TYPE>,
         1
       >;
     }
@@ -219,13 +217,7 @@ export type ColumnConfig<LANG_IDS = { en: 1 }> =
       | NamedJoinColumn
       | MediaColumn
       | (BaseColumn<LANG_IDS> &
-          (
-            | SQLDefColumn
-            | ReferencedColumn
-            | TextColumn
-            | JSONBColumnDef
-            | Enum
-          ))
+          (SQLDefColumn | ReferencedColumn | TextColumn | JSONBColumnDef | Enum))
     >;
 
 export type ColumnConfigs<LANG_IDS = { en: 1 }> = {
@@ -239,9 +231,8 @@ export type ColumnConfigs<LANG_IDS = { en: 1 }> = {
 };
 
 type UnionKeys<T> = T extends T ? keyof T : never;
-type StrictUnionHelper<T, TAll> = T extends any
-  ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>>
-  : never;
+type StrictUnionHelper<T, TAll> =
+  T extends any ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
 export type StrictUnion<T> = StrictUnionHelper<T, T>;
 
 export const CONSTRAINT_TYPES = ["PRIMARY KEY", "UNIQUE", "CHECK"] as const;
@@ -394,22 +385,16 @@ export default class TableConfigurator<LANG_IDS = { en: 1 }> {
     }
   };
 
-  getColumnConfig = (
-    tableName: string,
-    colName: string,
-  ): ColumnConfig | undefined => {
-    const tconf = this.config?.[tableName];
+  getColumnConfig = (tableName: string, colName: string): ColumnConfig | undefined => {
+    const tconf = this.config[tableName];
     if (tconf && "columns" in tconf) {
       return tconf.columns?.[colName];
     }
     return undefined;
   };
 
-  getTableInfo = (params: {
-    tableName: string;
-    lang?: string;
-  }): TableInfo["info"] | undefined => {
-    const tconf = this.config?.[params.tableName];
+  getTableInfo = (params: { tableName: string; lang?: string }): TableInfo["info"] | undefined => {
+    const tconf = this.config[params.tableName];
 
     return {
       label: parseI18N<LANG_IDS, string>({
@@ -425,16 +410,13 @@ export default class TableConfigurator<LANG_IDS = { en: 1 }> {
     col: string;
     table: string;
     lang?: string;
-  }):
-    | (ColExtraInfo & { label?: string } & Pick<ColumnInfo, "jsonbSchema">)
-    | undefined => {
+  }): (ColExtraInfo & { label?: string } & Pick<ColumnInfo, "jsonbSchema">) | undefined => {
     const colConf = this.getColumnConfig(params.table, params.col);
     let result: Partial<ReturnType<typeof this.getColInfo>> = undefined;
     if (colConf) {
       if (isObject(colConf)) {
         const { jsonbSchema, jsonbSchemaType, info } = colConf;
         result = {
-          ...(result ?? {}),
           ...info,
           ...((jsonbSchema || jsonbSchemaType) && {
             jsonbSchema: {
@@ -449,14 +431,14 @@ export default class TableConfigurator<LANG_IDS = { en: 1 }> {
          */
         if (colConf.label) {
           const { lang } = params;
-          const lbl = colConf?.label;
+          const lbl = colConf.label;
           if (["string", "object"].includes(typeof lbl)) {
             if (typeof lbl === "string") {
               result ??= {};
               result.label = lbl;
-            } else if (lang && (lbl?.[lang as "en"] || lbl?.en)) {
+            } else if (lang && (lbl[lang as "en"] || lbl.en)) {
               result ??= {};
-              result.label = lbl?.[lang as "en"] || lbl?.en;
+              result.label = lbl[lang as "en"] || lbl.en;
             }
           }
         }
@@ -478,12 +460,8 @@ export default class TableConfigurator<LANG_IDS = { en: 1 }> {
     }
   };
 
-  getJoinInfo = (
-    sourceTable: string,
-    targetTable: string,
-  ): JoinInfo | undefined => {
+  getJoinInfo = (sourceTable: string, targetTable: string): JoinInfo | undefined => {
     if (
-      this.config &&
       sourceTable in this.config &&
       this.config[sourceTable] &&
       "columns" in this.config[sourceTable]!
@@ -513,9 +491,9 @@ export default class TableConfigurator<LANG_IDS = { en: 1 }> {
 
   getPreInsertRow = async (
     tableHandler: TableHandler,
-    args: Pick<GetPreInsertRowArgs, "localParams" | "row" | "validate" | "dbx">,
+    args: Pick<GetPreInsertRowArgs, "localParams" | "row" | "validate" | "dbx">
   ): Promise<AnyObject> => {
-    const tableHook = this.config?.[tableHandler.name]?.hooks?.getPreInsertRow;
+    const tableHook = this.config[tableHandler.name]?.hooks?.getPreInsertRow;
     if (tableHandler.is_media) {
       return uploadFile.bind(tableHandler)(args) as Promise<AnyObject>;
     }