prostgles-client 4.0.355 → 4.0.357

package/dist/getAuthHandler.js

@@ -18,18 +18,18 @@ const getAuthHandler = ({ authData: authConfig, socket, onReload, endpoint, ...a
                 if (onReload)
                     onReload();
                 else if (prostgles_1.isClientSide) {
-                    console.log("prostgles page reload due to authguard", res);
+                    console.log("prostgles page reload due to auth guard", res);
                     setTimeout(() => {
                         window.location.reload();
                     }, 200);
                 }
             }
         };
-        socket.emit(prostgles_types_1.CHANNELS.AUTHGUARD, JSON.stringify(window.location), (_err, res) => {
+        socket.emit(prostgles_types_1.CHANNELS.AUTH_GUARD, JSON.stringify(window.location), (_err, res) => {
             doReload(res);
         });
-        socket.removeAllListeners(prostgles_types_1.CHANNELS.AUTHGUARD);
-        socket.on(prostgles_types_1.CHANNELS.AUTHGUARD, (res) => {
+        socket.removeAllListeners(prostgles_types_1.CHANNELS.AUTH_GUARD);
+        socket.on(prostgles_types_1.CHANNELS.AUTH_GUARD, (res) => {
             doReload(res);
         });
     }

package/dist/getDbHandler.js

@@ -54,15 +54,15 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, subscriptionHan
                     const upsertSyncTable = async (basicFilter = {}, options = {}, onError) => {
                         var _a;
                         const syncName = `${tableName}.${JSON.stringify(basicFilter)}.${JSON.stringify((0, prostgles_types_1.omitKeys)(options, ["handlesOnData"]))}`;
-                        const syncedTableHandler = (_a = syncHandler.syncedTables[syncName]) !== null && _a !== void 0 ? _a : (await syncedTable.create({
+                        const syncedTableHandler = (_a = syncHandler.syncedTables.get(syncName)) !== null && _a !== void 0 ? _a : syncedTable.create({
                             ...options,
-                            onDebug: onDebug,
+                            onDebug,
                             name: tableName,
                             filter: basicFilter,
                             db: db,
                             onError,
-                        }));
-                        syncHandler.syncedTables[syncName] = syncedTableHandler;
+                        });
+                        syncHandler.syncedTables.set(syncName, syncedTableHandler);
                         return syncedTableHandler;
                     };
                     const syncOne = (async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {

package/dist/getSyncHandler.d.ts

@@ -1,9 +1,9 @@
 import { type ClientSyncHandles } from "prostgles-types";
 import type { CoreParams, InitOptions } from "./prostgles";
 import type { SyncedTable } from "./SyncedTable/SyncedTable";
-export declare const getSyncHandler: ({ socket }: Pick<InitOptions, "socket">) => {
+export declare const getSyncHandler: ({ socket, onDebug }: Pick<InitOptions, "socket" | "onDebug">) => {
     destroySyncs: () => Promise<void>;
-    syncedTables: Record<string, SyncedTable>;
+    syncedTables: Map<string, Promise<SyncedTable>>;
     addSync: (params: CoreParams, triggers: ClientSyncHandles) => Promise<any>;
     reAttachAll: () => Promise<void>;
 };

package/dist/getSyncHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getSyncHandler.d.ts","sourceRoot":"","sources":["../lib/getSyncHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,OAAO,KAAK,EAAe,UAAU,EAAE,WAAW,EAAY,MAAM,aAAa,CAAC;AAElF,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAa1E,eAAO,MAAM,cAAc,GAAI,YAAY,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC;;;sBAyDrC,UAAU,YAAY,iBAAiB,KAAG,OAAO,CAAC,GAAG,CAAC;;CAoItF,CAAC"}
+{"version":3,"file":"getSyncHandler.d.ts","sourceRoot":"","sources":["../lib/getSyncHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAElF,OAAO,KAAK,EAAe,UAAU,EAAE,WAAW,EAAY,MAAM,aAAa,CAAC;AAElF,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAQ1E,eAAO,MAAM,cAAc,GAAI,qBAAqB,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,SAAS,CAAC;;;sBA8D1D,UAAU,YAAY,iBAAiB,KAAG,OAAO,CAAC,GAAG,CAAC;;CA+ItF,CAAC"}

package/dist/getSyncHandler.js

@@ -4,47 +4,47 @@ 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) => {
-            s.destroy();
+        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) {
         return new Promise((resolve, reject) => {
-            socket.emit(preffix, { tableName, command, param1, param2 }, (err, res) => {
+            socket.emit(prostgles_types_1.CHANNEL_PREFIX, { tableName, command, param1, param2 }, (err, syncInfo) => {
                 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 +57,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, param1, param2 }, 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,16 +76,15 @@ 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));
         });
-        if (existingChannel) {
-            syncs[existingChannel].triggers.push(triggers);
+        if (matchingSync) {
+            const [existingChannel, existingSync] = matchingSync;
+            existingSync.clientSyncHandles.push(clientSyncHandlers);
             return makeHandler(existingChannel);
         }
         else {
@@ -101,9 +100,20 @@ 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 }) => {
+                    onDebug === null || onDebug === void 0 ? void 0 : onDebug({
+                        type: "sync",
+                        command: data.data ? "onUpdates"
+                            : data.onSyncRequest ? "onSyncRequest"
+                                : "onPullRequest",
+                        tableName,
+                        channelName,
+                        data,
+                        syncedTable: syncedTables.get(channelName),
+                    });
                     if (data.data) {
                         Promise.resolve(onUpdates(data))
                             .then(() => {
@@ -134,23 +144,23 @@ const getSyncHandler = ({ socket }) => {
                     }
                 });
             };
-            syncs[channelName] = {
+            syncs.set(channelName, {
                 tableName,
                 command,
                 param1,
                 param2,
-                triggers: [triggers],
+                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);