prostgles-server 3.0.87 → 3.0.89

package/lib/PublishParser.ts

@@ -406,7 +406,7 @@ export class PublishParser {
   }
 
   async getAllowedMethods(socket: any, userData?: AuthResult): Promise<{ [key: string]: Method; }> {
-    let methods: { [key: string]: Method; } = {};
+    const methods: { [key: string]: Method; } = {};
 
     const publishParams = await this.getPublishParams({ socket }, userData);
     const _methods = await applyParamsIfFunc(this.publishMethods, publishParams);
@@ -433,10 +433,10 @@ export class PublishParser {
    */
   async getPublish(localParams: LocalParams, clientInfo?: AuthResult): Promise<PublishObject> {
     const publishParams = await this.getPublishParams(localParams, clientInfo)
-    let _publish = await applyParamsIfFunc(this.publish, publishParams);
+    const _publish = await applyParamsIfFunc(this.publish, publishParams);
 
     if (_publish === "*") {
-      let publish = {} as any;
+      const publish = {} as any;
       this.prostgles.dboBuilder.tablesOrViews?.map(tov => {
         publish[tov.name] = "*";
       });
@@ -455,7 +455,7 @@ export class PublishParser {
 
     if (!command || !tableName) throw "command OR tableName are missing";
 
-    let rtm = RULE_TO_METHODS.find(rtms => (rtms.methods as any).includes(command));
+    const rtm = RULE_TO_METHODS.find(rtms => (rtms.methods as any).includes(command));
     if (!rtm) {
       throw "Invalid command: " + command;
     }
@@ -476,7 +476,7 @@ export class PublishParser {
 
     if (schm && schm.err) throw schm.err;
 
-    let table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
+    const table_rule = await this.getTableRules({ tableName, localParams }, clientInfo);
     if (!table_rule) throw { stack: ["getValidatedRequestRule()"], message: "Invalid or disallowed table: " + tableName };
 
 
@@ -493,174 +493,172 @@ export class PublishParser {
 
   async getTableRules({ tableName, localParams }: DboTable, clientInfo?: AuthResult): Promise<ParsedPublishTable | undefined> {
 
-    try {
-      if (!localParams || !tableName) throw { stack: ["getTableRules()"], message: "publish OR socket OR dbo OR tableName are missing" };
+    if (!localParams || !tableName) throw { stack: ["getTableRules()"], message: "publish OR socket OR dbo OR tableName are missing" };
 
-      let _publish = await this.getPublish(localParams, clientInfo);
+    const _publish = await this.getPublish(localParams, clientInfo);
 
-      const raw_table_rules = _publish[tableName];
-      if (!raw_table_rules || isObject(raw_table_rules) && Object.values(raw_table_rules).every(v => !v)) {
-        return undefined;
-      }
+    const raw_table_rules = _publish[tableName];
+    if (!raw_table_rules || isObject(raw_table_rules) && Object.values(raw_table_rules).every(v => !v)) {
+      return undefined;
+    }
 
-      let parsed_table: ParsedPublishTable = {};
+    let parsed_table: ParsedPublishTable = {};
 
-      /* Get view or table specific rules */
-      const tHandler = (this.dbo[tableName] as TableHandler | ViewHandler);
-      const is_view = tHandler.is_view;
-      const canSubscribe = (!is_view || tHandler.columns.some(c => c.references));
-      if (!tHandler) {
-        throw { stack: ["getTableRules()"], message: `${tableName} could not be found in dbo` };
-      }
+    /* Get view or table specific rules */
+    const tHandler = (this.dbo[tableName] as TableHandler | ViewHandler);
+    const is_view = tHandler.is_view;
+    const canSubscribe = (!is_view || tHandler.columns.some(c => c.references));
+    if (!tHandler) {
+      throw { stack: ["getTableRules()"], message: `${tableName} could not be found in dbo` };
+    }
 
-      const MY_RULES = RULE_TO_METHODS.filter(r => {
+    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;
+      /** Check PG User privileges */
+      const pgUserIsAllowedThis = tHandler.tableOrViewInfo.privileges[r.sqlRule];
+      let result = (!is_view || !r.table_only) && pgUserIsAllowedThis;
 
-        if (!pgUserIsAllowedThis && isPlainObject(raw_table_rules) && (raw_table_rules as PublishTableRule)[r.sqlRule]) {
-          throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
-        }
+      if (!pgUserIsAllowedThis && isPlainObject(raw_table_rules) && (raw_table_rules as PublishTableRule)[r.sqlRule]) {
+        throw `Your postgres user is not allowed ${r.sqlRule} on table ${tableName}`;
+      }
 
-        if ((r.rule === "subscribe" || r.rule === "sync") && !this.prostgles.isSuperUser) {
-          result = false;
-          if (isPlainObject(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" || r.rule === "sync") && !this.prostgles.isSuperUser) {
+        result = false;
+        if (isPlainObject(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;
-        }
+      if(r.rule === "subscribe" && !canSubscribe){
+        result = false;
+      }
 
-        return result;
-      });
+      return result;
+    });
 
 
 
-      /* All methods allowed. Add no limits for table rules */
-      if ([true, "*"].includes(raw_table_rules as any)) {
-        parsed_table = {};
-        MY_RULES.filter(r => r.no_limits).forEach(r => {
-          parsed_table[r.rule] = { ...r.no_limits as object } as any;
-        });
+    /* All methods allowed. Add no limits for table rules */
+    if ([true, "*"].includes(raw_table_rules as any)) {
+      parsed_table = {};
+      MY_RULES.filter(r => r.no_limits).forEach(r => {
+        parsed_table[r.rule] = { ...r.no_limits as object } as any;
+      });
 
-        /** Specific rules allowed */
-      } else if (isPlainObject(raw_table_rules) && getKeys(raw_table_rules).length) {
-        const allRuleKeys: (keyof PublishViewRule | keyof PublishTableRule)[] = getKeys(raw_table_rules);
-        const dissallowedRuleKeys = allRuleKeys.filter(m => !(raw_table_rules as PublishTableRule)[m])
+      /** Specific rules allowed */
+    } else if (isPlainObject(raw_table_rules) && getKeys(raw_table_rules).length) {
+      const allRuleKeys: (keyof PublishViewRule | keyof PublishTableRule)[] = getKeys(raw_table_rules);
+      const dissallowedRuleKeys = allRuleKeys.filter(m => !(raw_table_rules 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)) {
-            parsed_table[r.rule] = r.no_limits as any;
-            return;
-          }
+      MY_RULES.map(r => {
+        /** Unless specifically disabled these are allowed */
+        if (["getInfo", "getColumns"].includes(r.rule) && !dissallowedRuleKeys.includes(r.rule as any)) {
+          parsed_table[r.rule] = r.no_limits as any;
+          return;
+        }
 
-          /** Add no_limit values for implied/ fully allowed methods */
-          if ([true, "*"].includes((raw_table_rules as PublishTableRule)[r.rule] as any) && r.no_limits) {
-            parsed_table[r.rule] = Object.assign({}, r.no_limits) as any;
+        /** Add no_limit values for implied/ fully allowed methods */
+        if ([true, "*"].includes((raw_table_rules as PublishTableRule)[r.rule] as any) && r.no_limits) {
+          parsed_table[r.rule] = Object.assign({}, r.no_limits) as any;
 
-            /** Carry over detailed config */
-          } else if (isPlainObject((raw_table_rules as any)[r.rule])) {
-            parsed_table[r.rule] = (raw_table_rules as any)[r.rule]
-          }
-        });
+          /** Carry over detailed config */
+        } else if (isPlainObject((raw_table_rules as any)[r.rule])) {
+          parsed_table[r.rule] = (raw_table_rules as any)[r.rule]
+        }
+      });
 
-        allRuleKeys.filter(m => parsed_table[m])
-          .forEach((method) => {
-            const rule = parsed_table[method];
-            
-            let rm = MY_RULES.find(r => r.rule === method || (r.methods as readonly string[]).includes(method));
-            if (!rm) {
-              let extraInfo = "";
-              if (is_view && RULE_TO_METHODS.find(r => !is_view && r.rule === method || (r.methods as any).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(", ")}`;
+      allRuleKeys.filter(m => parsed_table[m])
+        .forEach((method) => {
+          const rule = parsed_table[method];
+          
+          const rm = MY_RULES.find(r => r.rule === method || (r.methods as readonly string[]).includes(method));
+          if (!rm) {
+            let extraInfo = "";
+            if (is_view && RULE_TO_METHODS.find(r => !is_view && r.rule === method || (r.methods as any).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 === rm.rule && isObject(rule)) {
-              let method_params = getKeys(rule);
-              let iparam = method_params.find(p => !rm?.allowed_params.includes(<never>p));
-              if (iparam) {
-                throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${rm.allowed_params.join(", ")}`;
-              }
+          /* Check RULES for invalid params */
+          /* Methods do not have params -> They use them from rules */
+          if (method === rm.rule && isObject(rule)) {
+            const method_params = getKeys(rule);
+            const iparam = method_params.find(p => !rm?.allowed_params.includes(<never>p));
+            if (iparam) {
+              throw `Invalid setting in publish.${tableName}.${method} -> ${iparam}. \n Expecting any of: ${rm.allowed_params.join(", ")}`;
             }
+          }
 
-            /* Add default params (if missing) */
-            if (method === "sync") {
+          /* Add default params (if missing) */
+          if (method === "sync") {
 
-              if ([true, "*"].includes(parsed_table[method] as any)) {
-                throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
-              }
+            if ([true, "*"].includes(parsed_table[method] as any)) {
+              throw "Invalid sync rule. Expecting { id_fields: string[], synced_field: string } ";
+            }
 
-              if (typeof parsed_table[method]?.throttle !== "number") {
-                parsed_table[method]!.throttle = 100;
-              }
-              if (typeof parsed_table[method]?.batch_size !== "number") {
-                parsed_table[method]!.batch_size = DEFAULT_SYNC_BATCH_SIZE;
-              }
+            if (typeof parsed_table[method]?.throttle !== "number") {
+              parsed_table[method]!.throttle = 100;
             }
+            if (typeof parsed_table[method]?.batch_size !== "number") {
+              parsed_table[method]!.batch_size = DEFAULT_SYNC_BATCH_SIZE;
+            }
+          }
 
-            /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
-            const subKey = "subscribe" as const;
+          /* Enable subscribe if not explicitly disabled OR if VIEW with referenced tables */
+          const subKey = "subscribe" as const;
 
-            if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
-              const sr = MY_RULES.find(r => r.rule === subKey);
-              if (sr && canSubscribe) {
-                parsed_table[subKey] = { ...sr.no_limits as SubscribeRule };
-                parsed_table.subscribeOne = { ...sr.no_limits as SubscribeRule };
-              }
+          if (method === "select" && !dissallowedRuleKeys.includes(subKey)) {
+            const sr = MY_RULES.find(r => r.rule === subKey);
+            if (sr && canSubscribe) {
+              parsed_table[subKey] = { ...sr.no_limits as SubscribeRule };
+              parsed_table.subscribeOne = { ...sr.no_limits as SubscribeRule };
             }
-          });
+          }
+        });
 
-      } else {
-        throw "Unexpected publish"
-      }
+    } else {
+      throw "Unexpected publish"
+    }
 
-      const getImpliedMethods = (tableRules: ParsedPublishTable): ParsedPublishTable => {
-        let res = { ...tableRules };
+    const getImpliedMethods = (tableRules: ParsedPublishTable): ParsedPublishTable => {
+      const res = { ...tableRules };
 
-        /* Add implied methods if not specifically dissallowed */
-        MY_RULES.map(r => {
+      /* 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) {
+        /** 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) {
+            if (method === "updateBatch" && !tableRules.update) {
+              // not allowed
 
-              } else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
+            } else if (method === "upsert" && (!tableRules.update || !tableRules.insert)) {
+              // not allowed
 
-              } else {
-                (res as any)[method] ??= true;
-              }
+            } else {
+              (res as any)[method] ??= true;
             }
-          });
+          }
         });
+      });
 
-        return res;
-      }
+      return res;
+    }
 
-      parsed_table = getImpliedMethods(parsed_table);
+    parsed_table = getImpliedMethods(parsed_table);
 
-      return parsed_table;
-    } catch (e) {
-      throw e;
-    }
+    return parsed_table; 
   }
 
 
 
   /* Prepares schema for client. Only allowed views and commands will be present */
   async getSchemaFromPublish(socket: any, userData?: AuthResult): Promise<{ schema: TableSchemaForClient; tables: DBSchemaTable[] }> {
-    let schema: TableSchemaForClient = {};
-    let tables: DBSchemaTable[] = []
+    const schema: TableSchemaForClient = {};
+    const tables: DBSchemaTable[] = []
 
     try {
       /* Publish tables and views based on socket */
@@ -730,7 +728,7 @@ export class PublishParser {
 
 
                   if (method === "getInfo" || method === "getColumns") {
-                    let tableRules = await this.getValidatedRequestRule({ tableName, command: method, localParams: { socket } }, clientInfo);
+                    const tableRules = await this.getValidatedRequestRule({ tableName, command: method, localParams: { socket } }, clientInfo);
                     const res = await (this.dbo[tableName] as any)[method](undefined, undefined, undefined, tableRules, { socket, isRemoteRequest: true });
                     if (method === "getInfo") {
                       tableInfo = res;

package/lib/SchemaWatch.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { DboBuilder } from "./DboBuilder";
 import { ProstglesInitOptions } from "./Prostgles";
-export declare type VoidFunction = () => void;
+export type VoidFunction = () => void;
 export declare class SchemaWatch {
     schema_checkIntervalMillis?: NodeJS.Timeout;
     loaded: boolean;

package/lib/SchemaWatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaWatch.d.ts","sourceRoot":"","sources":["SchemaWatch.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,oBAAY,YAAY,GAAG,MAAM,IAAI,CAAC;AAEtC,qBAAa,WAAW;IACtB,0BAA0B,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAC5C,MAAM,UAAS;gBAEH,EAAE,WAAW,EAAE,eAAe,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,oBAAoB,GAAG;QAAE,YAAY,EAAE,UAAU,CAAC;QAAC,eAAe,EAAE,YAAY,CAAA;KAAE;CA8BrL"}
+{"version":3,"file":"SchemaWatch.d.ts","sourceRoot":"","sources":["SchemaWatch.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC;AAEtC,qBAAa,WAAW;IACtB,0BAA0B,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAC5C,MAAM,UAAS;gBAEH,EAAE,WAAW,EAAE,eAAe,EAAE,mBAAmB,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,oBAAoB,GAAG;QAAE,YAAY,EAAE,UAAU,CAAC;QAAC,eAAe,EAAE,YAAY,CAAA;KAAE;CA8BrL"}

package/lib/SyncReplication.d.ts

@@ -1,6 +1,6 @@
 import { PubSubManager, SyncParams } from "./PubSubManager/PubSubManager";
 import { AnyObject } from "prostgles-types";
-export declare type ClientSyncInfo = Partial<{
+export type ClientSyncInfo = Partial<{
     c_fr: AnyObject;
     c_lr: AnyObject;
     /**
@@ -8,7 +8,7 @@ export declare type ClientSyncInfo = Partial<{
      */
     c_count: number | string;
 }>;
-export declare type ServerSyncInfo = Partial<{
+export type ServerSyncInfo = Partial<{
     s_fr: AnyObject;
     s_lr: AnyObject;
     /**
@@ -16,17 +16,17 @@ export declare type ServerSyncInfo = Partial<{
      */
     s_count: number | string;
 }>;
-export declare type SyncBatchInfo = Partial<{
+export type SyncBatchInfo = Partial<{
     from_synced: number | null;
     to_synced: number | null;
     end_offset: number | null;
 }>;
-export declare type onSyncRequestResponse = {
+export type onSyncRequestResponse = {
     onSyncRequest?: ClientSyncInfo;
 } | {
     err: AnyObject | string;
 };
-export declare type ClientExpressData = ClientSyncInfo & {
+export type ClientExpressData = ClientSyncInfo & {
     data?: AnyObject[];
     deleted?: AnyObject[];
 };

package/lib/SyncReplication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SyncReplication.d.ts","sourceRoot":"","sources":["SyncReplication.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,UAAU,EAA2B,MAAM,+BAA+B,CAAC;AACnG,OAAO,EAAgB,SAAS,EAAmB,MAAM,iBAAiB,CAAC;AAG3E,oBAAY,cAAc,GAAG,OAAO,CAAC;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B,CAAC,CAAC;AAEH,oBAAY,cAAc,GAAG,OAAO,CAAC;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B,CAAC,CAAA;AAEF,oBAAY,aAAa,GAAG,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC,CAAC;AAEH,oBAAY,qBAAqB,GAAG;IAChC,aAAa,CAAC,EAAE,cAAc,CAAA;CACjC,GAAG;IACA,GAAG,EAAE,SAAS,GAAG,MAAM,CAAC;CAC3B,CAAC;AAEF,oBAAY,iBAAiB,GAAG,cAAc,GAAG;IAC7C,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;CACzB,CAAA;AAMD,eAAO,MAAM,QAAQ,UAAiB,aAAa,QAAQ,UAAU,cAAc,iBAAiB,GAAG,SAAS,UAAU,SAAS,GAAG,QAAQ,kBA6d7I,CAAA"}
+{"version":3,"file":"SyncReplication.d.ts","sourceRoot":"","sources":["SyncReplication.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,UAAU,EAA2B,MAAM,+BAA+B,CAAC;AACnG,OAAO,EAAgB,SAAS,EAAmB,MAAM,iBAAiB,CAAC;AAG3E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B,CAAC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1B,CAAC,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC;IAClC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,cAAc,CAAA;CAC/B,GAAG;IACF,GAAG,EAAE,SAAS,GAAG,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG;IAC/C,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;CACvB,CAAA;AAMD,eAAO,MAAM,QAAQ,UAAiB,aAAa,QAAQ,UAAU,cAAc,iBAAiB,GAAG,SAAS,UAAU,SAAS,GAAG,QAAQ,kBA4d7I,CAAA"}

package/lib/SyncReplication.js

@@ -13,7 +13,8 @@ const syncData = async (_this, sync, clientData, source) => {
         console.error("Orphaned socket", { sync, clientData });
         return;
     }
-    const sync_fields = [synced_field, ...id_fields.sort()], orderByAsc = sync_fields.reduce((a, v) => ({ ...a, [v]: true }), {}), orderByDesc = sync_fields.reduce((a, v) => ({ ...a, [v]: false }), {}), 
+    const sync_fields = [synced_field, ...id_fields.sort()], orderByAsc = sync_fields.reduce((a, v) => ({ ...a, [v]: true }), {}), 
+    // orderByDesc = sync_fields.reduce((a, v) => ({ ...a, [v]: false }), {}),
     // desc_params = { orderBy: [{ [synced_field]: false }].concat(id_fields.map(f => ({ [f]: false }) )) },
     // asc_params = { orderBy: [synced_field].concat(id_fields) },
     rowsIdsMatch = (a, b) => {
@@ -22,7 +23,7 @@ const syncData = async (_this, sync, clientData, source) => {
         return rowsIdsMatch(a, b) && a?.[synced_field].toString() === b?.[synced_field].toString();
     }, getServerRowInfo = async (args = {}) => {
         const { from_synced = null, to_synced = null, offset = 0, limit } = args;
-        let _filter = { ...filter };
+        const _filter = { ...filter };
         if (from_synced || to_synced) {
             _filter[synced_field] = {
                 ...(from_synced ? { $gte: from_synced } : {}),
@@ -39,11 +40,11 @@ const syncData = async (_this, sync, clientData, source) => {
         return { s_fr: first_rows?.[0] || null, s_lr: last_rows?.[0] || null, s_count: count };
     }, getClientRowInfo = (args = {}) => {
         const { from_synced = null, to_synced = null, end_offset = null } = args;
-        let res = new Promise((resolve, reject) => {
-            let onSyncRequest = { from_synced, to_synced, end_offset }; //, forReal: true };
+        const res = new Promise((resolve, reject) => {
+            const onSyncRequest = { from_synced, to_synced, end_offset }; //, forReal: true };
             socket.emit(channel_name, { onSyncRequest }, (resp) => {
                 if (resp && "onSyncRequest" in resp && resp?.onSyncRequest) {
-                    let c_fr = resp.onSyncRequest.c_fr, c_lr = resp.onSyncRequest.c_lr, c_count = resp.onSyncRequest.c_count;
+                    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 });
                 }
@@ -73,14 +74,14 @@ const syncData = async (_this, sync, clientData, source) => {
             });
         }
     }, getServerData = async (from_synced = 0, offset = 0) => {
-        let _filter = {
+        const _filter = {
             ...filter,
             [synced_field]: { $gte: from_synced || 0 }
         };
         if (!_this?.dbo?.[table_name]?.find)
             throw "_this?.dbo?.[table_name]?.find is missing";
         try {
-            let res = _this?.dbo?.[table_name]?.find?.(_filter, {
+            const res = _this?.dbo?.[table_name]?.find?.(_filter, {
                 select: params.select,
                 orderBy: orderByAsc,
                 offset: offset || 0,
@@ -131,7 +132,7 @@ const syncData = async (_this, sync, clientData, source) => {
                 if (!table_rules)
                     throw "table_rules missing";
                 if (table_rules.update && updates.length) {
-                    let updateData = [];
+                    const updateData = [];
                     await Promise.all(updates.map(upd => {
                         const id_filter = (0, PubSubManager_1.pickKeys)(upd, id_fields);
                         const syncSafeFilter = { $and: [id_filter, { [synced_field]: { "<": upd[synced_field] } }] };
@@ -216,7 +217,7 @@ const syncData = async (_this, sync, clientData, source) => {
             else {
                 result = Math.min(...getNumbers([c_fr[synced_field], s_fr?.[synced_field]]));
             }
-            let min_count = Math.min(...getNumbers([c_count, s_count]));
+            const min_count = Math.min(...getNumbers([c_count, s_count]));
             let end_offset = 1; // Math.min(s_count, c_count) - 1;
             let step = 0;
             while (min_count > 5 && end_offset < min_count) {
@@ -224,7 +225,7 @@ const syncData = async (_this, sync, clientData, source) => {
                 // console.log("getLastSynced... end_offset > " + end_offset);
                 let server_row;
                 if (c_lr) {
-                    let _filter = {};
+                    const _filter = {};
                     sync_fields.map(key => {
                         _filter[key] = c_lr[key];
                     });
@@ -259,13 +260,14 @@ const syncData = async (_this, sync, clientData, source) => {
      * Will push pull sync between client and server from a given from_synced value
      */
     syncBatch = async (from_synced) => {
-        let offset = 0, limit = batch_size, canContinue = true, min_synced = from_synced || 0, max_synced = from_synced;
+        let offset = 0, canContinue = true;
+        const limit = batch_size, min_synced = from_synced || 0, max_synced = from_synced;
         let inserted = 0, updated = 0, pushed = 0, deleted = 0, total = 0;
         // console.log("syncBatch", from_synced)
         while (canContinue) {
-            let cData = await getClientData(min_synced, offset);
+            const cData = await getClientData(min_synced, offset);
             if (cData.length) {
-                let res = await upsertData(cData);
+                const res = await upsertData(cData);
                 inserted += res.inserted;
                 updated += res.updated;
             }
@@ -289,12 +291,12 @@ const syncData = async (_this, sync, clientData, source) => {
                 }));
                 sData = await getServerData(min_synced, offset);
             }
-            let forClient = sData.filter(s => {
+            const forClient = sData.filter(s => {
                 return !cData.find(c => rowsIdsMatch(c, s) &&
                     +c[synced_field] >= +s[synced_field]);
             });
             if (forClient.length) {
-                let res = await pushData(forClient.filter(d => !sync.wal || !sync.wal.isInHistory(d)));
+                const res = await pushData(forClient.filter(d => !sync.wal || !sync.wal.isInHistory(d)));
                 pushed += res.pushed;
             }
             if (sData.length) {
@@ -306,7 +308,7 @@ const syncData = async (_this, sync, clientData, source) => {
             canContinue = sData.length >= limit;
             // console.log(`sData ${sData.length}      limit ${limit}`);
         }
-        // console.log(`syncBatch ${table_name}: inserted( ${inserted} )    updated( ${updated} )   deleted( ${deleted} )    pushed( ${pushed} )     total( ${total} )`, socket._user );
+        (0, PubSubManager_1.log)(`server.syncBatch ${table_name}: inserted( ${inserted} )    updated( ${updated} )   deleted( ${deleted} )    pushed to client( ${pushed} )     total( ${total} )`, socket._user);
         return true;
     };
     if (!wal) {
@@ -377,6 +379,7 @@ const syncData = async (_this, sync, clientData, source) => {
         }
     }
     else {
+        // do nothing
     }
     if (sync.wal.isSending())
         return;