prostgles-client 4.0.356 → 4.0.358

package/dist/getSyncHandler.js

@@ -4,47 +4,53 @@ exports.getSyncHandler = void 0;
 const prostgles_types_1 = require("prostgles-types");
 const FunctionQueuer_1 = require("./FunctionQueuer");
 const prostgles_1 = require("./prostgles");
-const preffix = prostgles_types_1.CHANNELS._preffix;
-const getSyncHandler = ({ socket }) => {
-    let syncedTables = {};
-    let syncs = {};
+const getSyncHandler = ({ socket, onDebug }) => {
+    const syncedTables = new Map();
+    const syncs = new Map();
     const destroySyncs = async () => {
         (0, prostgles_1.debug)("destroySyncs", { syncedTables });
-        syncs = {};
-        Object.values(syncedTables).forEach((s) => {
+        syncs.clear();
+        Array.from(syncedTables.values()).forEach((s) => {
             s.then((s) => s.destroy());
         });
-        syncedTables = {};
+        syncedTables.clear();
     };
     function _unsync(channelName, triggers) {
         (0, prostgles_1.debug)("_unsync", { channelName, triggers });
         return new Promise((resolve, reject) => {
-            if (syncs[channelName]) {
-                syncs[channelName].triggers = syncs[channelName].triggers.filter((tr) => tr.onPullRequest !== triggers.onPullRequest &&
+            const sync = syncs.get(channelName);
+            if (sync) {
+                sync.clientSyncHandles = sync.clientSyncHandles.filter((tr) => tr.onPullRequest !== triggers.onPullRequest &&
                     tr.onSyncRequest !== triggers.onSyncRequest &&
                     tr.onUpdates !== triggers.onUpdates);
-                if (!syncs[channelName].triggers.length) {
+                if (!sync.clientSyncHandles.length) {
                     socket.emit(channelName + "unsync", {}, (err, res) => {
                         if (err)
                             reject(err);
                         else
                             resolve(res);
                     });
-                    socket.removeListener(channelName, syncs[channelName].onCall);
-                    delete syncs[channelName];
+                    socket.removeListener(channelName, sync.onCall);
+                    syncs.delete(channelName);
                 }
             }
         });
     }
-    function addServerSync({ tableName, command, param1, param2 }, onSyncRequest) {
+    function addServerSync({ tableName, command, filter, select }, onSyncRequest) {
         return new Promise((resolve, reject) => {
-            socket.emit(preffix, { tableName, command, param1, param2 }, (err, res) => {
+            socket.emit(prostgles_types_1.CHANNEL_PREFIX, { tableName, command, param1: filter, param2: select }, (err, syncInfo) => {
+                onDebug === null || onDebug === void 0 ? void 0 : onDebug({
+                    type: "table",
+                    command: "getSync",
+                    tableName,
+                    data: { filter, select },
+                });
                 if (err) {
                     console.error(err);
                     reject(err);
                 }
-                else if (res) {
-                    const { id_fields, synced_field, channelName } = res;
+                else if (syncInfo) {
+                    const { id_fields, synced_field, channelName } = syncInfo;
                     socket.emit(channelName, { onSyncRequest: onSyncRequest({}) }, (response) => {
                         console.log(response);
                     });
@@ -57,11 +63,11 @@ const getSyncHandler = ({ socket }) => {
     async function addSync(params, triggers) {
         return addSyncQueuer.run([params, triggers]);
     }
-    async function _addSync({ tableName, command, param1, param2 }, triggers) {
-        const { onSyncRequest } = triggers;
+    async function _addSync({ tableName, command, filter, select }, clientSyncHandlers) {
+        const { onSyncRequest } = clientSyncHandlers;
         function makeHandler(channelName) {
             const unsync = function () {
-                _unsync(channelName, triggers);
+                _unsync(channelName, clientSyncHandlers);
             };
             const syncData = function (data, deleted, cb) {
                 socket.emit(channelName, {
@@ -76,20 +82,19 @@ const getSyncHandler = ({ socket }) => {
             };
             return Object.freeze({ unsync, syncData });
         }
-        const existingChannel = Object.keys(syncs).find((ch) => {
-            const s = syncs[ch];
-            return (s &&
-                s.tableName === tableName &&
+        const matchingSync = Array.from(syncs.entries()).find(([ch, s]) => {
+            return (s.tableName === tableName &&
                 s.command === command &&
-                (0, prostgles_types_1.isEqual)(s.param1, param1) &&
-                (0, prostgles_types_1.isEqual)(s.param2, param2));
+                (0, prostgles_types_1.isEqual)(s.filter, filter) &&
+                (0, prostgles_types_1.isEqual)(s.select, select));
         });
-        if (existingChannel) {
-            syncs[existingChannel].triggers.push(triggers);
+        if (matchingSync) {
+            const [existingChannel, existingSync] = matchingSync;
+            existingSync.clientSyncHandles.push(clientSyncHandlers);
             return makeHandler(existingChannel);
         }
         else {
-            const sync_info = await addServerSync({ tableName, command, param1, param2 }, onSyncRequest);
+            const sync_info = await addServerSync({ tableName, command, filter, select }, onSyncRequest);
             const { channelName } = sync_info;
             const onCall = function (data, cb) {
                 /*
@@ -101,9 +106,23 @@ const getSyncHandler = ({ socket }) => {
                 */
                 if (!data)
                     return;
-                if (!syncs[channelName])
+                const matchingSync = syncs.get(channelName);
+                if (!matchingSync)
                     return;
-                syncs[channelName].triggers.map(({ onUpdates, onSyncRequest, onPullRequest }) => {
+                matchingSync.clientSyncHandles.map(({ onUpdates, onSyncRequest, onPullRequest }) => {
+                    var _a;
+                    (_a = syncedTables.get(channelName)) === null || _a === void 0 ? void 0 : _a.then((syncedTable) => {
+                        onDebug === null || onDebug === void 0 ? void 0 : onDebug({
+                            type: "sync",
+                            command: data.data ? "onUpdates"
+                                : data.onSyncRequest ? "onSyncRequest"
+                                    : "onPullRequest",
+                            tableName,
+                            channelName,
+                            data,
+                            syncedTable,
+                        });
+                    });
                     if (data.data) {
                         Promise.resolve(onUpdates(data))
                             .then(() => {
@@ -134,23 +153,23 @@ const getSyncHandler = ({ socket }) => {
                     }
                 });
             };
-            syncs[channelName] = {
+            syncs.set(channelName, {
                 tableName,
                 command,
-                param1,
-                param2,
-                triggers: [triggers],
+                filter,
+                select,
+                clientSyncHandles: [clientSyncHandlers],
                 syncInfo: sync_info,
                 onCall,
-            };
+            });
             socket.on(channelName, onCall);
             return makeHandler(channelName);
         }
     }
     const reAttachAll = async () => {
         let reAttached = 0;
-        Object.entries(syncs).forEach(async ([ch, s]) => {
-            const firstTrigger = s.triggers[0];
+        Array.from(syncs.entries()).forEach(async ([ch, s]) => {
+            const firstTrigger = s.clientSyncHandles[0];
             if (firstTrigger) {
                 try {
                     await addServerSync(s, firstTrigger.onSyncRequest);