prostgles-server 4.2.544 → 4.2.546

package/lib/DboBuilder/QueryBuilder/Functions/HASHING_FUNCTIONS.ts

@@ -0,0 +1,120 @@
+import * as pgPromise from "pg-promise";
+import { asNameAlias } from "../../../utils/asNameAlias";
+import type { FunctionSpec } from "./Functions";
+
+const pgp = pgPromise();
+
+const MAX_COL_NUM = 1600;
+
+export const HASHING_FUNCTIONS: FunctionSpec[] = [
+  // Hashing
+  {
+    name: "$md5_multi",
+    description: ` :[...column_names] -> md5 hash of the column content`,
+    type: "function",
+    singleColArg: false,
+    numArgs: MAX_COL_NUM,
+    getFields: (args: any[]) => args,
+    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+      const q = pgp.as.format(
+        "md5(" +
+          args
+            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + "::text, '' )")
+            .join(" || ") +
+          ")",
+      );
+      return q;
+    },
+  },
+  {
+    name: "$md5_multi_agg",
+    description: ` :[...column_names] -> md5 hash of the string aggregation of column content`,
+    type: "aggregation",
+    singleColArg: false,
+    numArgs: MAX_COL_NUM,
+    getFields: (args: any[]) => args,
+    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+      const q = pgp.as.format(
+        "md5(string_agg(" +
+          args
+            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + "::text, '' )")
+            .join(" || ") +
+          ", ','))",
+      );
+      return q;
+    },
+  },
+
+  {
+    name: "$sha256_multi",
+    description: ` :[...column_names] -> sha256 hash of the of column content`,
+    type: "function",
+    singleColArg: false,
+    numArgs: MAX_COL_NUM,
+    getFields: (args: any[]) => args,
+    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+      const q = pgp.as.format(
+        "encode(sha256((" +
+          args
+            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
+            .join(" || ") +
+          ")::text::bytea), 'hex')",
+      );
+      return q;
+    },
+  },
+  {
+    name: "$sha256_multi_agg",
+    description: ` :[...column_names] -> sha256 hash of the string aggregation of column content`,
+    type: "aggregation",
+    singleColArg: false,
+    numArgs: MAX_COL_NUM,
+    getFields: (args: any[]) => args,
+    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+      const q = pgp.as.format(
+        "encode(sha256(string_agg(" +
+          args
+            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
+            .join(" || ") +
+          ", ',')::text::bytea), 'hex')",
+      );
+      return q;
+    },
+  },
+  {
+    name: "$sha512_multi",
+    description: ` :[...column_names] -> sha512 hash of the of column content`,
+    type: "function",
+    singleColArg: false,
+    numArgs: MAX_COL_NUM,
+    getFields: (args: any[]) => args,
+    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+      const q = pgp.as.format(
+        "encode(sha512((" +
+          args
+            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
+            .join(" || ") +
+          ")::text::bytea), 'hex')",
+      );
+      return q;
+    },
+  },
+  {
+    name: "$sha512_multi_agg",
+    description: ` :[...column_names] -> sha512 hash of the string aggregation of column content`,
+    type: "aggregation",
+    singleColArg: false,
+    numArgs: MAX_COL_NUM,
+    getFields: (args: any[]) => args,
+    getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+      const q = pgp.as.format(
+        "encode(sha512(string_agg(" +
+          args
+            .map((fname) => "COALESCE( " + asNameAlias(fname, tableAlias) + ", '' )")
+            .join(" || ") +
+          ", ',')::text::bytea), 'hex')",
+      );
+      return q;
+    },
+  },
+];

package/lib/DboBuilder/QueryBuilder/Functions/TEXT_FUNCTIONS.ts

@@ -0,0 +1,302 @@
+import { isEmpty, postgresToTsType } from "prostgles-types";
+import { asValue } from "../../../PubSubManager/PubSubManagerUtils";
+import { parseFieldFilter } from "../../ViewHandler/parseFieldFilter";
+import { asFunction } from "./utils";
+import type { FunctionSpec } from "./Functions";
+import * as pgPromise from "pg-promise";
+import { asNameAlias } from "../../../utils/asNameAlias";
+const pgp = pgPromise();
+
+export const TEXT_FUNCTIONS: FunctionSpec[] = [
+  {
+    name: "$left",
+    description: ` :[column_name, number] -> substring`,
+    type: "function",
+    numArgs: 2,
+    singleColArg: false,
+    getFields: (args: any[]) => [args[0]],
+    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+      return pgp.as.format("LEFT(" + asNameAlias(args[0], tableAlias) + ", $1)", [args[1]]);
+    },
+  },
+  {
+    name: "$column",
+    description: ` :[column_name] -> Returns the column value as is`,
+    type: "function",
+    numArgs: 1,
+    singleColArg: false,
+    getFields: (args: any[]) => [args[0]],
+    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+      const aliasedColumnName = args[0];
+      if (!aliasedColumnName) {
+        throw `$column: column_name is required`;
+      }
+      return pgp.as.format(asNameAlias(aliasedColumnName, tableAlias));
+    },
+  },
+  {
+    name: "$unnest_words",
+    description: ` :[column_name] -> Splits string at spaces`,
+    type: "function",
+    numArgs: 1,
+    singleColArg: true,
+    getFields: (args: any[]) => [args[0]],
+    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+      return pgp.as.format(
+        "unnest(string_to_array(" + asNameAlias(args[0], tableAlias) + "::TEXT , ' '))",
+      ); //, [args[1]]
+    },
+  } satisfies FunctionSpec,
+  {
+    name: "$right",
+    description: ` :[column_name, number] -> substring`,
+    type: "function",
+    numArgs: 2,
+    singleColArg: false,
+    getFields: (args: any[]) => [args[0]],
+    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+      return pgp.as.format("RIGHT(" + asNameAlias(args[0], tableAlias) + ", $1)", [args[1]]);
+    },
+  },
+
+  {
+    name: "$to_char",
+    type: "function",
+    description: ` :[column_name, format<string>] -> format dates and strings. Eg: [current_timestamp, 'HH12:MI:SS']`,
+    singleColArg: false,
+    numArgs: 2,
+    getFields: (args: any[]) => [args[0]],
+    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+      if (args.length === 3) {
+        return pgp.as.format("to_char(" + asNameAlias(args[0], tableAlias) + ", $2, $3)", [
+          args[0],
+          args[1],
+          args[2],
+        ]);
+      }
+      return pgp.as.format("to_char(" + asNameAlias(args[0], tableAlias) + ", $2)", [
+        args[0],
+        args[1],
+      ]);
+    },
+  },
+
+  /* Text col and value funcs */
+  ...["position", "position_lower"].map((funcName) =>
+    asFunction({
+      name: "$" + funcName,
+      type: "function",
+      numArgs: 1,
+      singleColArg: false,
+      getFields: (args: any[]) => [args[1]],
+      getQuery: ({ args, tableAliasRaw: tableAlias }) => {
+        let a1 = asValue(args[0]),
+          a2 = asNameAlias(args[1], tableAlias);
+        if (funcName === "position_lower") {
+          a1 = `LOWER(${a1}::text)`;
+          a2 = `LOWER(${a2}::text)`;
+        }
+        return `position( ${a1} IN ${a2} )`;
+      },
+    }),
+  ),
+  ...["template_string"].map((funcName) =>
+    asFunction({
+      name: "$" + funcName,
+      type: "function",
+      numArgs: 1,
+      minCols: 0,
+      singleColArg: false,
+      getFields: (args: any[]) => [] as string[], // Fields not validated because we'll use the allowed ones anyway
+      getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias }) => {
+        if (typeof args[0] !== "string")
+          throw "First argument must be a string. E.g.: '{col1} ..text {col2} ...' ";
+
+        const rawValue = args[0];
+        let finalValue = rawValue;
+        const usedColumns = allowedFields.filter((fName) => rawValue.includes(`{${fName}}`));
+        usedColumns.forEach((colName, idx) => {
+          finalValue = finalValue.split(`{${colName}}`).join(`%${idx + 1}$s`);
+        });
+        finalValue = asValue(finalValue);
+
+        if (usedColumns.length) {
+          return `format(${finalValue}, ${usedColumns.map((c) => `${asNameAlias(c, tableAlias)}::TEXT`).join(", ")})`;
+        }
+
+        return `format(${finalValue})`;
+      },
+    }),
+  ),
+
+  /** Custom highlight -> myterm => ['some text and', ['myterm'], ' and some other text']
+   * (fields: "*" | string[], term: string, { edgeTruncate: number = -1; noFields: boolean = false }) => string | (string | [string])[]
+   * edgeTruncate = maximum extra characters left and right of matches
+   * noFields = exclude field names in search
+   * */
+  asFunction({
+    name: "$term_highlight" /* */,
+    description: ` :[column_names<string[] | "*">, search_term<string>, opts?<{ returnIndex?: number; edgeTruncate?: number; noFields?: boolean }>] -> get case-insensitive text match highlight`,
+    type: "function",
+    numArgs: 1,
+    singleColArg: true,
+    canBeUsedForFilter: true,
+    getFields: (args: any[]) => args[0],
+    getQuery: ({ allowedFields, args, tableAliasRaw: tableAlias, allColumns }) => {
+      const cols = parseFieldFilter(args[0], false, allowedFields);
+      let term = args[1];
+      const rawTerm = args[1];
+      const { edgeTruncate, noFields = false, returnType, matchCase = false } = args[2] || {};
+      if (!isEmpty(args[2])) {
+        const keys = Object.keys(args[2]);
+        const validKeys = ["edgeTruncate", "noFields", "returnType", "matchCase"];
+        const bad_keys = keys.filter((k) => !validKeys.includes(k));
+        if (bad_keys.length)
+          throw (
+            "Invalid options provided for $term_highlight. Expecting one of: " +
+            validKeys.join(", ")
+          );
+      }
+      if (!cols.length) throw "Cols are empty/invalid";
+      if (typeof term !== "string") throw "Non string term provided: " + term;
+      if (edgeTruncate !== undefined && (!Number.isInteger(edgeTruncate) || edgeTruncate < -1))
+        throw "Invalid edgeTruncate. expecting a positive integer";
+      if (typeof noFields !== "boolean") throw "Invalid noFields. expecting boolean";
+      const RETURN_TYPES = ["index", "boolean", "object"];
+      if (returnType && !RETURN_TYPES.includes(returnType)) {
+        throw `returnType can only be one of: ${RETURN_TYPES}`;
+      }
+
+      const makeTextMatcherArray = (rawText: string, _term: string) => {
+        let matchText = rawText,
+          term = _term;
+        if (!matchCase) {
+          matchText = `LOWER(${rawText})`;
+          term = `LOWER(${term})`;
+        }
+        let leftStr = `substr(${rawText}, 1, position(${term} IN ${matchText}) - 1 )`,
+          rightStr = `substr(${rawText}, position(${term} IN ${matchText}) + length(${term}) )`;
+        if (edgeTruncate) {
+          leftStr = `RIGHT(${leftStr}, ${asValue(edgeTruncate)})`;
+          rightStr = `LEFT(${rightStr}, ${asValue(edgeTruncate)})`;
+        }
+        return `
+          CASE WHEN position(${term} IN ${matchText}) > 0 AND ${term} <> '' 
+            THEN array_to_json(ARRAY[
+                to_json( ${leftStr}::TEXT ), 
+                array_to_json(
+                  ARRAY[substr(${rawText}, position(${term} IN ${matchText}), length(${term}) )::TEXT ]
+                ),
+                to_json(${rightStr}::TEXT ) 
+              ]) 
+            ELSE 
+              array_to_json(ARRAY[(${rawText})::TEXT]) 
+          END
+        `;
+      };
+
+      const colRaw =
+        "( " +
+        cols
+          .map(
+            (c) =>
+              `${noFields ? "" : asValue(c + ": ") + " || "} COALESCE(${asNameAlias(c, tableAlias)}::TEXT, '')`,
+          )
+          .join(" || ', ' || ") +
+        " )";
+      let col = colRaw;
+      term = asValue(term);
+      if (!matchCase) {
+        col = "LOWER" + col;
+        term = `LOWER(${term})`;
+      }
+
+      let leftStr = `substr(${colRaw}, 1, position(${term} IN ${col}) - 1 )`,
+        rightStr = `substr(${colRaw}, position(${term} IN ${col}) + length(${term}) )`;
+      if (edgeTruncate) {
+        leftStr = `RIGHT(${leftStr}, ${asValue(edgeTruncate)})`;
+        rightStr = `LEFT(${rightStr}, ${asValue(edgeTruncate)})`;
+      }
+
+      // console.log(col);
+      let res = "";
+      if (returnType === "index") {
+        res = `CASE WHEN position(${term} IN ${col}) > 0 THEN position(${term} IN ${col}) - 1 ELSE -1 END`;
+
+        // } else if(returnType === "boolean"){
+        //   res = `CASE WHEN position(${term} IN ${col}) > 0 THEN TRUE ELSE FALSE END`;
+      } else if (returnType === "object" || returnType === "boolean") {
+        const hasChars = Boolean(rawTerm && /[a-z]/i.test(rawTerm));
+        const validCols = cols
+          .map((c) => {
+            const colInfo = allColumns.find((ac) => ac.name === c);
+            return {
+              key: c,
+              colInfo,
+            };
+          })
+          .filter((c) => c.colInfo && c.colInfo.udt_name !== "bytea");
+
+        const _cols = validCols.filter(
+          (c) =>
+            /** Exclude numeric columns when the search tern contains a character */
+            !hasChars || postgresToTsType(c.colInfo!.udt_name) !== "number",
+        );
+
+        /** This will break GROUP BY (non-integer constant in GROUP BY) */
+        if (!_cols.length) {
+          if (validCols.length && hasChars)
+            throw `You're searching the impossible: characters in numeric fields. Use this to prevent making such a request in future: /[a-z]/i.test(your_term) `;
+          return returnType === "boolean" ? "FALSE" : "NULL";
+        }
+        res = `CASE 
+          ${_cols
+            .map((c) => {
+              const colNameEscaped = asNameAlias(c.key, tableAlias);
+              let colSelect = `${colNameEscaped}::TEXT`;
+              const isTstamp = c.colInfo?.udt_name.startsWith("timestamp");
+              if (isTstamp || c.colInfo?.udt_name === "date") {
+                colSelect = `( CASE WHEN ${colNameEscaped} IS NULL THEN '' 
+              ELSE concat_ws(' ', 
+                trim(to_char(${colNameEscaped}, 'YYYY-MM-DD HH24:MI:SS')), 
+                trim(to_char(${colNameEscaped}, 'Day Month')), 
+                'Q' || trim(to_char(${colNameEscaped}, 'Q')),
+                'WK' || trim(to_char(${colNameEscaped}, 'WW'))
+              ) END)`;
+              }
+              const colTxt = `COALESCE(${colSelect}, '')`; //  position(${term} IN ${colTxt}) > 0
+              if (returnType === "boolean") {
+                return ` 
+                WHEN  ${colTxt} ${matchCase ? "LIKE" : "ILIKE"} ${asValue("%" + rawTerm + "%")}
+                  THEN TRUE
+                `;
+              }
+              return ` 
+              WHEN  ${colTxt} ${matchCase ? "LIKE" : "ILIKE"} ${asValue("%" + rawTerm + "%")}
+                THEN json_build_object(
+                  ${asValue(c.key)}, 
+                  ${makeTextMatcherArray(colTxt, term)}
+                )::jsonb
+              `;
+            })
+            .join(" ")}
+          ELSE ${returnType === "boolean" ? "FALSE" : "NULL"}
+
+        END`;
+
+        // console.log(res)
+      } else {
+        /* If no match or empty search THEN return full row as string within first array element  */
+        res = `CASE WHEN position(${term} IN ${col}) > 0 AND ${term} <> '' THEN array_to_json(ARRAY[
+          to_json( ${leftStr}::TEXT ), 
+          array_to_json(
+            ARRAY[substr(${colRaw}, position(${term} IN ${col}), length(${term}) )::TEXT ]
+          ),
+          to_json(${rightStr}::TEXT ) 
+        ]) ELSE array_to_json(ARRAY[(${colRaw})::TEXT]) END`;
+      }
+
+      return res;
+    },
+  } satisfies FunctionSpec),
+];

package/lib/DboBuilder/QueryBuilder/Functions/utils.ts

@@ -0,0 +1,3 @@
+import type { FunctionSpec } from "./Functions";
+
+export const asFunction = (def: FunctionSpec) => def;

package/lib/DboBuilder/TableHandler/update.ts

@@ -112,7 +112,7 @@ export async function update(
       }
       await Promise.all(
         nestedInserts.map(async (nestedInsert) => {
-          const nesedTableHandler = finalDBtx[nestedInsert.tableName] as TableHandler | undefined;
+          const nesedTableHandler = finalDBtx[nestedInsert.tableName];
           if (!nesedTableHandler)
             throw `nestedInsert Tablehandler not found for ${nestedInsert.tableName}`;
           const refTableRules =

package/lib/DboBuilder/ViewHandler/getExistsCondition.ts

@@ -21,7 +21,7 @@ export async function getExistsCondition(
   if (Object.keys(targetTableFilter).find((fk) => EXISTS_KEYS.includes(fk as EXISTS_KEY))) {
     throw {
       stack: ["prepareExistCondition()"],
-      message: "Nested exists dissallowed",
+      message: "Nested exists disallowed",
     };
   }
 
@@ -35,16 +35,16 @@ export async function getExistsCondition(
   }
   const targetTable = eConfig.isJoined ? eConfig.parsedPath.at(-1)!.table : eConfig.targetTable;
   if (localParams?.clientReq && this.dboBuilder.publishParser) {
-    t2Rules = (await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
+    t2Rules = await this.dboBuilder.publishParser.getValidatedRequestRuleWusr(
       {
         tableName: targetTable,
         command: "find",
         clientReq: localParams.clientReq,
       },
       localParams.scope,
-    )) as ParsedTableRule | undefined;
+    );
 
-    if (!t2Rules || !t2Rules.select) throw "Dissallowed";
+    if (!t2Rules.select) throw "Disallowed";
     ({ forcedFilter, filterFields } = t2Rules.select);
   }
 

package/lib/DboBuilder/ViewHandler/parseFieldFilter.ts

@@ -50,7 +50,7 @@ export const parseFieldFilter = <AllowedKeys extends string[]>(
           ["field1", "field2", "field3"] 
         */
       } else {
-        colNames = fieldParams.slice(0) as AllowedKeys;
+        colNames = fieldParams.slice(0);
       }
 
       /*

package/lib/DboBuilder/runSql/runSQL.ts

@@ -37,7 +37,7 @@ export async function runSQL(
     throw "Not allowed to run SQL";
   }
 
-  const { returnType, allowListen, hasParams = true }: SQLOptions = options || ({} as SQLOptions);
+  const { returnType, allowListen, hasParams = true }: SQLOptions = options || ({});
   const { socket } = localParams?.clientReq ?? {};
 
   const db = localParams?.tx?.t || this.db;

package/lib/FileManager/FileManager.ts

@@ -340,7 +340,7 @@ export const getFileType = async (
     /* Set correct/missing extension */
     const nameExt = fileNameMime.ext;
     if (["xml", "txt", "csv", "tsv", "svg", "sql"].includes(nameExt)) {
-      return fileNameMime as any;
+      return fileNameMime;
     }
 
     throw new Error("Could not get the file type from file buffer");

package/lib/Logging.ts

@@ -43,7 +43,7 @@ export namespace EventTypes {
             | "sync.wal.isSending()"
             | "initial"
             | "socket?.connected"
-            | "sync.last_synced"
+            | "sync.lr"
             | "rowsFullyMatch"
             | "getLastSynced.rowsFullyMatch(lr)"
             | "getLastSynced.nothingToSync"

package/lib/PubSubManager/PubSubManager.ts

@@ -54,7 +54,6 @@ export type SyncParams = {
   wal?: WAL;
   throttle?: number;
   lr?: AnyObject;
-  last_synced: number;
   is_syncing: boolean;
   handlers: ReturnType<(typeof ReplicationProtocol)["getServerHandlers"]>;
 };

package/lib/PubSubManager/SyncReplication/getSyncUtilFunctions.ts

@@ -104,8 +104,8 @@ export const getSyncUtilFunctions = ({
     getClientData = (from_synced: number | undefined, offset = 0): Promise<AnyObject[]> => {
       return new Promise(async (resolve, reject) => {
         const onPullRequest = {
-          from_synced: from_synced,
-          offset: offset || 0,
+          from_synced,
+          offset,
           limit: batch_size,
           to_synced: undefined,
         };
@@ -169,13 +169,13 @@ export const getSyncUtilFunctions = ({
     /**
      * Upserts the given client data where synced_field is higher than on server
      */
-    upsertData = async (data: AnyObject[]) => {
+    upsertData = async (data: AnyObject[], source: "WAL" | "client") => {
       const start = Date.now();
       const result = await pubSubManager.dboBuilder
         .getTX(async (dbTX) => {
           const tableHandlerTx = dbTX[table_name] as TableHandler;
-          const existingData = await tableHandlerTx.find(
-            { $or: data.map((d) => pickKeys(d, id_fields)) },
+          const existingData = (await tableHandlerTx.find(
+            { $or: data.map((row) => pickKeys(row, id_fields)) },
             {
               select: [synced_field, ...id_fields],
               orderBy: orderByAsc,
@@ -183,11 +183,16 @@ export const getSyncUtilFunctions = ({
             undefined,
             table_rules,
             { clientReq: { socket } },
+          )) as AnyObject[];
+          let rowsToInsert = data.filter(
+            (incomingRow) =>
+              !existingData.find((existingRow) => rowsIdsMatch(existingRow, incomingRow)),
           );
-          let rowsToInsert = data.filter((d) => !existingData.find((ed) => rowsIdsMatch(ed, d)));
-          let rowsToUpdate = data.filter((d) =>
+          let rowsToUpdate = data.filter((incomingRow) =>
             existingData.find(
-              (ed) => rowsIdsMatch(ed, d) && Number(ed[synced_field]) < Number(d[synced_field]),
+              (existingRow) =>
+                rowsIdsMatch(existingRow, incomingRow) &&
+                Number(existingRow[synced_field]) < Number(incomingRow[synced_field]),
             ),
           );
 
@@ -227,7 +232,7 @@ export const getSyncUtilFunctions = ({
         })
         .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 (from ${source}): 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,
@@ -263,17 +268,22 @@ export const getSyncUtilFunctions = ({
      * Pushes the given data to client
      * @param isSynced = true if
      */
-    pushData = async (data: AnyObject[], isSynced = false) => {
+    pushData = async (
+      request: { state: "syncing-data"; data: AnyObject[] } | { state: "synced" },
+    ) => {
+      const items = request.state === "syncing-data" ? request.data : undefined;
       const start = Date.now();
       const result = await new Promise<{
         pushed: number;
       }>(async (resolve, reject) => {
         const resp = await handlers.UpdateRequest(
-          isSynced ? { state: "synced", isSynced: true } : { state: "syncing", data },
+          request.state === "synced" ?
+            { state: "synced", isSynced: true }
+          : { state: "syncing", data: request.data },
         );
         if (resp.success) {
           // console.log("PUSHED to client: fr/lr", data[0], data[data.length - 1]);
-          resolve({ pushed: data.length });
+          resolve({ pushed: items?.length ?? 0 });
         } else {
           reject(resp);
           console.error("Unexpected response");
@@ -284,7 +294,7 @@ export const getSyncUtilFunctions = ({
         type: "sync",
         command: "pushData",
         tableName: sync.table_name,
-        rows: data.length,
+        rows: items?.length ?? 0,
         socketId: socket_id,
         duration: Date.now() - start,
         sid: sync.sid,
@@ -392,7 +402,6 @@ export const getSyncUtilFunctions = ({
         );
       }
       sync.lr = lastRow;
-      sync.last_synced = +sync.lr[synced_field];
     },
     /**
      * Will push pull sync between client and server from a given from_synced value
@@ -415,7 +424,7 @@ export const getSyncUtilFunctions = ({
         const clientData = await getClientData(min_synced, offset);
 
         if (clientData.length) {
-          const res = await upsertData(clientData);
+          const res = await upsertData(clientData, "client");
           inserted += res.inserted;
           updated += res.updated;
         }
@@ -425,7 +434,6 @@ export const getSyncUtilFunctions = ({
           serverData = await getServerData(min_synced, offset);
         } catch (e) {
           console.trace("sync getServerData err", e);
-          // await pushData(undefined, undefined, "Internal error. Check server logs");
           throw " d";
         }
 
@@ -455,9 +463,10 @@ export const getSyncUtilFunctions = ({
           );
         });
         if (forClient.length) {
-          const res = await pushData(
-            forClient.filter((d) => !sync.wal || !sync.wal.isInHistory(d)),
-          );
+          const res = await pushData({
+            state: "syncing-data",
+            data: forClient.filter((d) => !sync.wal || !sync.wal.isInHistory(d)),
+          });
           pushed += res.pushed;
         }