prostgles-client 4.0.358 → 4.0.359

package/dist/SyncedTable/createSyncStateUtils.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSyncStateUtils = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const createSyncStateUtils = (socket, options) => {
+    const state = { isSynced: false };
+    const { db, name, select = "*", filter = {}, columns } = options;
+    const channelName = (0, prostgles_types_1.getSyncChannelName)({ filter, select, tableName: name });
+    const onDebug = (evt) => {
+        var _a;
+        return (_a = options.onDebug) === null || _a === void 0 ? void 0 : _a.call(options, {
+            ...evt,
+            type: "sync",
+            tableName: name,
+            channelName,
+            options,
+        });
+    };
+    onDebug({ command: "create", data: { name, filter, select } });
+    const tableHandler = db[name];
+    if (!tableHandler) {
+        throw `${name} table not found in db`;
+    }
+    const { _syncInfo } = tableHandler;
+    if (!_syncInfo) {
+        throw `${name} table does not support sync`;
+    }
+    const { id_fields, synced_field, throttle = 100, batch_size = 50 } = _syncInfo;
+    if (!id_fields.length || !synced_field) {
+        throw "id_fields/synced_field missing";
+    }
+    const _sync = async (handles) => {
+        const sync_info = await new Promise((resolve, reject) => {
+            socket.emit(prostgles_types_1.CHANNEL_PREFIX, {
+                tableName: name,
+                command: "sync",
+                param1: filter,
+                param2: { select },
+            }, (err, syncInfo) => {
+                if (err) {
+                    console.error(err);
+                    reject(err);
+                }
+                else if (syncInfo) {
+                    const { id_fields, synced_field, channelName } = syncInfo;
+                    socket.emit(channelName, { onSyncRequest: handles.onSyncRequest({}) }, (response) => {
+                        console.log(response);
+                    });
+                    resolve({ id_fields, synced_field, channelName });
+                }
+            });
+        });
+        const onCall = function (data, cb) {
+            /*
+                  Client will:
+                  1. Send last_synced     on(onSyncRequest)
+                  2. Send data >= server_synced   on(onPullRequest)
+                  3. Send data on CRUD    emit(data.data)
+                  4. Upsert data.data     on(data.data)
+              */
+            if (!data)
+                return;
+            const { onUpdates, onSyncRequest, onPullRequest } = handles;
+            // syncedTables.get(channelName)?.then((syncedTable) => {
+            //   onDebug?.({
+            //     type: "sync",
+            //     command:
+            //       data.data ? "onUpdates"
+            //       : data.onSyncRequest ? "onSyncRequest"
+            //       : "onPullRequest",
+            //     tableName,
+            //     channelName,
+            //     data,
+            //     options: { n filter, select },
+            //   });
+            // });
+            if (data.data) {
+                Promise.resolve(onUpdates(data))
+                    .then(() => {
+                    cb({ ok: true });
+                })
+                    .catch((err) => {
+                    cb({ err });
+                });
+            }
+            else if (data.onSyncRequest) {
+                Promise.resolve(onSyncRequest(data.onSyncRequest))
+                    .then((res) => cb({ onSyncRequest: res }))
+                    .catch((err) => {
+                    cb({ err });
+                });
+            }
+            else if (data.onPullRequest) {
+                Promise.resolve(onPullRequest(data.onPullRequest))
+                    .then((result) => {
+                    cb(result);
+                })
+                    .catch((err) => {
+                    cb({ err });
+                });
+            }
+            else {
+                console.log("unexpected response");
+            }
+        };
+        socket.on(channelName, onCall);
+        const syncData = function (data, deleted, cb) {
+            socket.emit(channelName, {
+                onSyncRequest: {
+                    ...handles.onSyncRequest({}),
+                    ...{ data },
+                    ...{ deleted },
+                },
+            }, !cb ? null : ((response) => {
+                cb(response);
+            }));
+        };
+        const unsync = () => {
+            return new Promise((resolve, reject) => {
+                socket.emit(channelName + "unsync", {}, (err, res) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(res);
+                });
+                socket.removeListener(channelName, onCall);
+            });
+        };
+        return { sync_info, unsync, syncData };
+    };
+    return {
+        state,
+        onDebug,
+        id_fields,
+        synced_field,
+        throttle,
+        batch_size,
+        columns,
+        _syncInfo,
+        _sync,
+        filter,
+        select,
+        tableHandler,
+    };
+};
+exports.createSyncStateUtils = createSyncStateUtils;

package/dist/SyncedTable/createSyncSubscriptionManager.d.ts

@@ -0,0 +1,11 @@
+import type { AnyObject, SyncConfig } from "prostgles-types";
+import { WAL } from "prostgles-types/dist/WAL";
+import type { createSyncDataStore } from "./createSyncDataStore";
+import type { createSyncStateUtils } from "./createSyncStateUtils";
+import type { ItemUpdate, MultiChangeListener, MultiSyncHandles, SingleChangeListener, SingleSyncHandles } from "./SyncedTable";
+export declare const createSyncSubscriptionManager: ({ id_fields, synced_field }: Omit<SyncConfig, "channelName">, store: ReturnType<typeof createSyncDataStore>, stateUtils: ReturnType<typeof createSyncStateUtils>, upsert: (items: ItemUpdate[], from_server?: boolean) => Promise<void>) => {
+    sync: <T extends AnyObject = AnyObject>(onChange: MultiChangeListener<T>, handlesOnData?: boolean) => MultiSyncHandles<T>;
+    syncOne: <T extends AnyObject = AnyObject, Full extends boolean = false>(idObj: Partial<T>, onChange: SingleChangeListener<T, Full>, handlesOnData?: boolean) => SingleSyncHandles<T, Full>;
+    notifyWal: WAL;
+};
+//# sourceMappingURL=createSyncSubscriptionManager.d.ts.map

package/dist/SyncedTable/createSyncSubscriptionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSyncSubscriptionManager.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncSubscriptionManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAiB,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAC/C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAEV,UAAU,EAEV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EAIlB,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,6BAA6B,GACxC,6BAA6B,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,EAC5D,OAAO,UAAU,CAAC,OAAO,mBAAmB,CAAC,EAC7C,YAAY,UAAU,CAAC,OAAO,oBAAoB,CAAC,EACnD,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC;WAgKvD,CAAC,SAAS,SAAS,wBACrB,mBAAmB,CAAC,CAAC,CAAC,8BAE/B,gBAAgB,CAAC,CAAC,CAAC;cAsDL,CAAC,SAAS,SAAS,cAAc,IAAI,SAAS,OAAO,iBAC7D,OAAO,CAAC,CAAC,CAAC,YACP,oBAAoB,CAAC,CAAC,EAAE,IAAI,CAAC,8BAEtC,iBAAiB,CAAC,CAAC,EAAE,IAAI,CAAC;;CAuC9B,CAAC"}

package/dist/SyncedTable/createSyncSubscriptionManager.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSyncSubscriptionManager = void 0;
+const WAL_1 = require("prostgles-types/dist/WAL");
+const createSyncSubscriptionManager = ({ id_fields, synced_field }, store, stateUtils, upsert) => {
+    let multiSubscriptions = [];
+    let singleSubscriptions = [];
+    const unsubscribe = (onChange) => {
+        singleSubscriptions = singleSubscriptions.filter((s) => s._onChange !== onChange);
+        multiSubscriptions = multiSubscriptions.filter((s) => s._onChange !== onChange);
+        return "ok";
+    };
+    const { state, onDebug } = stateUtils;
+    /**
+     * Notifies multi subs with ALL data + deltas. Attaches handles on data if required
+     * @param newData -> updates. Must include id_fields + updates
+     */
+    const _notifySubscribers = (changes = []) => {
+        if (!state.isSynced) {
+            onDebug({ command: "notifySubscribers", data: [], info: "not synced yet" });
+            return;
+        }
+        else {
+            onDebug({ command: "notifySubscribers", data: changes });
+        }
+        /* Deleted items (changes = []) do not trigger singleSubscriptions notify because it might break things */
+        const items = [], deltas = [], ids = [];
+        changes.map(({ idObj, newItem, delta }) => {
+            /* Single subs do not care about the filter */
+            singleSubscriptions
+                .filter((s) => store.matchesIdObj(s.idObj, idObj))
+                .map(async (s) => {
+                try {
+                    await s.notify(newItem, delta);
+                }
+                catch (e) {
+                    console.error("SyncedTable failed to notify: ", e);
+                }
+            });
+            /* Preparing data for multi subs */
+            if (store.matchesFilter(newItem)) {
+                items.push(newItem);
+                deltas.push(delta);
+                ids.push(idObj);
+            }
+        });
+        if (multiSubscriptions.length) {
+            const allItems = [], allDeltas = [];
+            store.getItems().map((d) => {
+                allItems.push({ ...d });
+                const dIdx = items.findIndex((_d) => store.matchesIdObj(d, _d));
+                allDeltas.push(deltas[dIdx]);
+            });
+            /* Multisubs must not forget about the original filter */
+            multiSubscriptions.map(async (s) => {
+                try {
+                    await s.notify(allItems, allDeltas);
+                }
+                catch (e) {
+                    console.error("SyncedTable failed to notify: ", e);
+                }
+            });
+        }
+    };
+    const notifyWal = new WAL_1.WAL({
+        id_fields,
+        synced_field,
+        batch_size: Infinity,
+        throttle: 5,
+        onSend: async (_, fullItems) => {
+            _notifySubscribers(fullItems.map((d) => {
+                var _a;
+                return ({
+                    delta: store.getDelta((_a = d.initial) !== null && _a !== void 0 ? _a : {}, d.current),
+                    idObj: store.getIdObj(d.current),
+                    newItem: d.current,
+                });
+            }));
+        },
+    });
+    const _delete = async (item, from_server = false) => {
+        var _a, _b;
+        const idObj = store.getIdObj(item);
+        store.setItem(idObj, true, true);
+        if (!from_server) {
+            await ((_b = (_a = stateUtils.tableHandler).delete) === null || _b === void 0 ? void 0 : _b.call(_a, idObj));
+        }
+        _notifySubscribers();
+        return true;
+    };
+    const getMultiSyncSubscription = ({ onChange, handlesOnData, }) => {
+        const handles = {
+            $unsync: () => {
+                return unsubscribe(onChange);
+            },
+            getItems: () => {
+                return store.getItems();
+            },
+            $upsert: (newData) => {
+                if (!newData) {
+                    throw "No data provided for upsert";
+                }
+                const prepareOne = (d) => {
+                    return {
+                        idObj: store.getIdObj(d),
+                        delta: d,
+                    };
+                };
+                if (Array.isArray(newData)) {
+                    upsert(newData.map((d) => prepareOne(d)));
+                }
+                else {
+                    upsert([prepareOne(newData)]);
+                }
+            },
+        };
+        const sub = {
+            _onChange: onChange,
+            handlesOnData,
+            handles,
+            notify: (_allItems, _allDeltas) => {
+                let allItems = [..._allItems];
+                const allDeltas = [..._allDeltas];
+                if (handlesOnData) {
+                    allItems = allItems.map((item, i) => {
+                        const getItem = (d, idObj) => ({
+                            ...d,
+                            ...makeSingleSyncHandles(idObj, onChange),
+                            $get: () => getItem(store.getItem(idObj), idObj),
+                            $find: (idObject) => getItem(store.getItem(idObject), idObject),
+                            $update: (newData, opts) => {
+                                return upsert([{ idObj, delta: newData, opts }]);
+                            },
+                            $delete: async () => {
+                                return _delete(idObj);
+                            },
+                            $cloneMultiSync: (onChange) => sync(onChange, handlesOnData),
+                        });
+                        const idObj = store.getIdObj(item);
+                        return getItem(item, idObj);
+                    });
+                }
+                return onChange(allItems, allDeltas);
+            },
+        };
+        return { sub, handles };
+    };
+    const sync = (onChange, handlesOnData = true) => {
+        const { sub, handles } = getMultiSyncSubscription.bind(this)({
+            onChange: onChange,
+            handlesOnData,
+        });
+        multiSubscriptions.push(sub);
+        setTimeout(() => {
+            const items = store.getItems();
+            sub.notify(items, items);
+        }, 0);
+        return Object.freeze({ ...handles });
+    };
+    const makeSingleSyncHandles = (idObj, onChange) => {
+        const handles = {
+            $get: () => store.getItem(idObj),
+            $find: (idObject) => store.getItem(idObject),
+            $unsync: () => {
+                return unsubscribe(onChange);
+            },
+            $delete: () => {
+                return _delete(idObj);
+            },
+            $update: (newData, opts) => {
+                /* DROPPED SYNC BUG */
+                if (!singleSubscriptions.length && !multiSubscriptions.length) {
+                    console.warn("No sync listeners");
+                }
+                return upsert([{ idObj, delta: newData, opts }]);
+            },
+            $cloneSync: (onChange) => syncOne(idObj, onChange),
+            // TODO: add clone sync hook
+            // $useCloneSync: () => {
+            //   const handles = this.syncOne<T, Full>(idObj, item => {
+            //     setItem()
+            //   });
+            //   return handles.$unsync;
+            // },
+            $cloneMultiSync: (onChange) => sync(onChange, true),
+        };
+        return handles;
+    };
+    /**
+     * Returns a sync handler to a specific record within the SyncedTable instance
+     * @param idObj object containing the target id_fields properties
+     * @param onChange change listener <(item: object, delta: object) => any >
+     * @param handlesOnData If true then $update, $delete and $unsync handles will be added on the data item. True by default;
+     */
+    const syncOne = (idObj, onChange, handlesOnData = true) => {
+        const handles = makeSingleSyncHandles(idObj, onChange);
+        const sub = {
+            _onChange: onChange,
+            idObj,
+            handlesOnData,
+            handles,
+            notify: (data, delta) => {
+                const newData = { ...data };
+                if (handlesOnData) {
+                    newData.$get = handles.$get;
+                    newData.$find = handles.$find;
+                    newData.$update = handles.$update;
+                    newData.$delete = handles.$delete;
+                    newData.$unsync = handles.$unsync;
+                    newData.$cloneSync = handles.$cloneSync;
+                }
+                return onChange(newData, delta);
+            },
+        };
+        singleSubscriptions.push(sub);
+        setTimeout(() => {
+            const existingData = handles.$get();
+            if (existingData) {
+                sub.notify(existingData, existingData);
+            }
+        }, 0);
+        return Object.freeze({ ...handles });
+    };
+    return {
+        sync,
+        syncOne,
+        notifyWal,
+    };
+};
+exports.createSyncSubscriptionManager = createSyncSubscriptionManager;

package/dist/getDbHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDbHandler.d.ts","sourceRoot":"","sources":["../lib/getDbHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAKnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIvD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,WAAW,EAEjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAKL,KAAK,WAAW,EAIjB,MAAM,2BAA2B,CAAC;AAEnC,KAAK,IAAI,GAAG;IACV,WAAW,EAAE,aAAa,EAAE,GAAG,SAAS,CAAC;IACzC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,WAAW,EAAE,OAAO,WAAW,GAAG,SAAS,CAAC;IAC5C,WAAW,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IAC/C,mBAAmB,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;CAChE,CAAC;AAIF,eAAO,MAAM,KAAK,GAAI,QAAQ,GAAG,IAAI,EAAE,kFAOpC,IAAI;QA6Nc,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;CACtD,CAAC"}
+{"version":3,"file":"getDbHandler.d.ts","sourceRoot":"","sources":["../lib/getDbHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAKnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIvD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,WAAW,EAEjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAKL,KAAK,WAAW,EAIjB,MAAM,2BAA2B,CAAC;AAEnC,KAAK,IAAI,GAAG;IACV,WAAW,EAAE,aAAa,EAAE,GAAG,SAAS,CAAC;IACzC,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IAChC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,WAAW,EAAE,OAAO,WAAW,GAAG,SAAS,CAAC;IAC5C,WAAW,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;IAC/C,mBAAmB,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;CAChE,CAAC;AAIF,eAAO,MAAM,KAAK,GAAI,QAAQ,GAAG,IAAI,EAAE,kFAOpC,IAAI;QAgNc,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;CACtD,CAAC"}

package/dist/getDbHandler.js

@@ -21,7 +21,7 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, subscriptionHan
     const subscribeCommands = ["subscribe", "subscribeOne"];
     const db = {};
     const schemaClone = (_a = (0, SyncedTable_1.quickClone)(tableSchema)) !== null && _a !== void 0 ? _a : [];
-    schemaClone.forEach(({ name: tableName, publishInfo }) => {
+    schemaClone.forEach(({ name: tableName, publishInfo, columns }) => {
         const allowedCommands = (0, prostgles_types_1.getAllowedTableMethods)({ publishInfo });
         db[tableName] = {};
         const dboTable = db[tableName];
@@ -36,31 +36,18 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, subscriptionHan
                 }
                 dboTable._syncInfo = { ...syncConfig };
                 if (syncedTable) {
-                    dboTable.getSync = async (filter, params = {}) => {
-                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
-                            type: "table",
-                            command: "getSync",
-                            tableName,
-                            data: { filter, params },
-                        }));
-                        return syncedTable.create({
-                            name: tableName,
-                            onDebug,
-                            filter,
-                            db: db,
-                            ...params,
-                        });
-                    };
                     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.get(syncName)) !== null && _a !== void 0 ? _a : syncedTable.create({
+                            select: undefined,
                             ...options,
                             onDebug,
                             name: tableName,
                             filter: basicFilter,
                             db: db,
                             onError,
+                            columns,
                         });
                         syncHandler.syncedTables.set(syncName, syncedTableHandler);
                         return syncedTableHandler;
@@ -73,8 +60,8 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, subscriptionHan
                             data: { basicFilter, options },
                         }));
                         checkSubscriptionArgs(basicFilter, options, onChange, onError);
-                        const s = await upsertSyncTable(basicFilter, options, onError);
-                        return await s.syncOne(basicFilter, onChange, options.handlesOnData);
+                        const syncedTable = await upsertSyncTable(basicFilter, options, onError);
+                        return await syncedTable.syncOne(basicFilter, onChange, options.handlesOnData);
                     });
                     const sync = (async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {
                         await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
@@ -118,7 +105,7 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, subscriptionHan
                     return subscriptionHandler.addSub(db, { tableName, command, param1, param2 }, onChange, onError);
                 };
                 dboTable[command] = subFunc;
-                const SUBONE = "subscribeOne";
+                const SUBSCRIBE_ONE = "subscribeOne";
                 /**
                  * React hooks
                  */
@@ -128,13 +115,13 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, subscriptionHan
                 if (handlerName) {
                     dboTable[handlerName] = (filter, options, hookOptions) => 
                     // eslint-disable-next-line react-hooks/rules-of-hooks
-                    (0, useSubscribe_1.useSubscribe)(subFunc, command === SUBONE, filter, options, hookOptions);
+                    (0, useSubscribe_1.useSubscribe)(subFunc, command === SUBSCRIBE_ONE, filter, options, hookOptions);
                 }
-                if (command === SUBONE || !subscribeCommands.includes(SUBONE)) {
-                    dboTable[SUBONE] = async function (param1, param2, onChange) {
+                if (command === SUBSCRIBE_ONE || !subscribeCommands.includes(SUBSCRIBE_ONE)) {
+                    dboTable[SUBSCRIBE_ONE] = async function (param1, param2, onChange) {
                         await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
                             type: "table",
-                            command: "getSync",
+                            command: SUBSCRIBE_ONE,
                             tableName,
                             data: { param1, param2, onChange },
                         }));

package/dist/getSyncHandler.d.ts.map

@@ -1 +1 @@
-{"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,EAA2B,WAAW,EAAY,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9F,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAQ1E,eAAO,MAAM,cAAc,GAAI,qBAAqB,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,SAAS,CAAC;;;sBAoE1D,UAAU,YAAY,iBAAiB,KAAG,OAAO,CAAC,GAAG,CAAC;;CAiJtF,CAAC"}
+{"version":3,"file":"getSyncHandler.d.ts","sourceRoot":"","sources":["../lib/getSyncHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAe,WAAW,EAAY,UAAU,EAAE,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;;;sBA4E1D,UAAU,YAAY,iBAAiB,KAAG,OAAO,CAAC,GAAG,CAAC;;CA4ItF,CAAC"}

package/dist/getSyncHandler.js

@@ -36,12 +36,17 @@ const getSyncHandler = ({ socket, onDebug }) => {
             }
         });
     }
-    function addServerSync({ tableName, command, filter, select }, onSyncRequest) {
+    function addServerSync({ tableName, command, filter = {}, select }, onSyncRequest) {
         return new Promise((resolve, reject) => {
-            socket.emit(prostgles_types_1.CHANNEL_PREFIX, { tableName, command, param1: filter, param2: select }, (err, syncInfo) => {
+            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",
+                    command: "sync",
                     tableName,
                     data: { filter, select },
                 });
@@ -83,10 +88,7 @@ const getSyncHandler = ({ socket, onDebug }) => {
             return Object.freeze({ unsync, syncData });
         }
         const matchingSync = Array.from(syncs.entries()).find(([ch, s]) => {
-            return (s.tableName === tableName &&
-                s.command === command &&
-                (0, prostgles_types_1.isEqual)(s.filter, filter) &&
-                (0, prostgles_types_1.isEqual)(s.select, select));
+            return s.tableName === tableName && (0, prostgles_types_1.isEqual)(s.filter, filter) && (0, prostgles_types_1.isEqual)(s.select, select);
         });
         if (matchingSync) {
             const [existingChannel, existingSync] = matchingSync;
@@ -110,19 +112,19 @@ const getSyncHandler = ({ socket, onDebug }) => {
                 if (!matchingSync)
                     return;
                 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,
-                        });
-                    });
+                    // syncedTables.get(channelName)?.then((syncedTable) => {
+                    //   onDebug?.({
+                    //     type: "sync",
+                    //     command:
+                    //       data.data ? "onUpdates"
+                    //       : data.onSyncRequest ? "onSyncRequest"
+                    //       : "onPullRequest",
+                    //     tableName,
+                    //     channelName,
+                    //     data,
+                    //     options: { n filter, select },
+                    //   });
+                    // });
                     if (data.data) {
                         Promise.resolve(onUpdates(data))
                             .then(() => {

package/dist/getSyncHandlerV2.d.ts

@@ -0,0 +1,14 @@
+import { type AnyObject, type DBHandler, type ValidatedColumnInfo } from "prostgles-types";
+import type { InitOptions } from "./prostgles";
+import type { Sync, SyncOne } from "./SyncedTable/SyncedTable";
+export declare const getSyncHandlerV2: ({ socket, onDebug }: Pick<InitOptions, "socket" | "onDebug">) => {
+    getTableSyncFunctions: ({ db, tableName, columns, }: {
+        db: DBHandler;
+        tableName: string;
+        columns: ValidatedColumnInfo[];
+    }) => Promise<{
+        addSync: Sync<AnyObject>;
+        addSyncOne: SyncOne<AnyObject>;
+    }>;
+};
+//# sourceMappingURL=getSyncHandlerV2.d.ts.map

package/dist/getSyncHandlerV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSyncHandlerV2.d.ts","sourceRoot":"","sources":["../lib/getSyncHandlerV2.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EAGd,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAwB,IAAI,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAErF,eAAO,MAAM,gBAAgB,GAAI,qBAAqB,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,SAAS,CAAC;yDA8CxF;QACD,EAAE,EAAE,SAAS,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,mBAAmB,EAAE,CAAC;KAChC;;;;CAiBF,CAAC"}

package/dist/getSyncHandlerV2.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSyncHandlerV2 = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const createSync_1 = require("./SyncedTable/createSync");
+const getSyncHandlerV2 = ({ socket, onDebug }) => {
+    const syncs = new Map();
+    const upsertSync = async (db, columns, tableName, filter, select) => {
+        var _a;
+        const channelName = (0, prostgles_types_1.getSyncChannelName)({
+            filter,
+            select,
+            tableName,
+        });
+        syncs.set(channelName, (_a = syncs.get(channelName)) !== null && _a !== void 0 ? _a : {
+            options: { tableName, filter, select },
+            sync: (0, createSync_1.createSync)(socket, {
+                name: tableName,
+                filter,
+                select,
+                onDebug,
+                db,
+                columns,
+            }),
+        });
+        return syncs.get(channelName).sync;
+    };
+    const getTableSyncFunctions = async ({ db, tableName, columns, }) => {
+        const addSync = (async (filter, opts, onChange, onError) => {
+            const { sync } = await upsertSync(db, columns, tableName, filter, opts.select);
+            return sync(onChange, opts.handlesOnData);
+        });
+        const addSyncOne = (async (filter, opts, onChange, onError) => {
+            const { syncOne } = await upsertSync(db, columns, tableName, filter, opts.select);
+            return syncOne(filter, onChange, opts.handlesOnData);
+        });
+        return { addSync, addSyncOne };
+    };
+    return { getTableSyncFunctions };
+};
+exports.getSyncHandlerV2 = getSyncHandlerV2;