prostgles-client 4.0.360 → 4.0.362

package/dist/SyncedTable/createSync.js

@@ -8,20 +8,21 @@ const createSyncStateUtils_1 = require("./createSyncStateUtils");
 const createSyncSubscriptionManager_1 = require("./createSyncSubscriptionManager");
 const SyncedTable_1 = require("./SyncedTable");
 const createSync = async (socket, options) => {
-    var _a;
     const stateUtils = (0, createSyncStateUtils_1.createSyncStateUtils)(socket, options);
-    const { state, onDebug, id_fields, synced_field, throttle, batch_size, columns, _syncInfo, _sync, filter, } = stateUtils;
+    const { state, onDebug, id_fields, synced_field, throttle, batch_size, columns, _syncInfo, initializeSync, filter, } = stateUtils;
     const store = (0, createSyncDataStore_1.createSyncDataStore)({ ..._syncInfo, columns, filter });
-    const onError = (_a = options.onError) !== null && _a !== void 0 ? _a : function (err) {
+    const onError = (err) => {
         console.error("Sync internal error: ", err);
     };
     const onSyncRequest = (syncBatchParams) => {
         let clientSyncInfo = { c_lr: undefined, c_fr: undefined, c_count: 0 };
         const batch = store.getBatch(syncBatchParams);
-        if (batch.length) {
+        const firstRow = batch[0];
+        const lastRow = batch[batch.length - 1];
+        if (firstRow && lastRow) {
             clientSyncInfo = {
-                c_fr: store.getRowSyncObj(batch[0]),
-                c_lr: store.getRowSyncObj(batch[batch.length - 1]),
+                c_fr: store.getRowSyncObj(firstRow),
+                c_lr: store.getRowSyncObj(lastRow),
                 c_count: batch.length,
             };
         }
@@ -71,7 +72,7 @@ const createSync = async (socket, options) => {
         synced_field,
         throttle,
     };
-    const dbSync = await _sync({ onSyncRequest, onPullRequest, onUpdates });
+    const dbSync = await initializeSync({ onSyncRequest, onPullRequest, onUpdates });
     /**
      * Some syncs can be read only. Any changes are local
      */
@@ -114,7 +115,6 @@ const createSync = async (socket, options) => {
         let status;
         const walItems = [];
         await Promise.all(items.map(async (item, i) => {
-            var _a;
             // let d = { ...item.idObj, ...item.delta };
             const idObj = { ...item.idObj };
             let delta = { ...item.delta };
@@ -144,7 +144,7 @@ const createSync = async (socket, options) => {
                 /**
                  * Merge deep
                  */
-                if ((_a = item.opts) === null || _a === void 0 ? void 0 : _a.deepMerge) {
+                if (item.opts?.deepMerge) {
                     newItem = (0, SyncedTable_1.mergeDeep)({ ...oldItem, ...idObj }, { ...delta });
                 }
             }
@@ -184,6 +184,13 @@ const createSync = async (socket, options) => {
         }
     };
     const subscriptionManager = (0, createSyncSubscriptionManager_1.createSyncSubscriptionManager)({ id_fields, synced_field }, store, stateUtils, upsert);
+    store.setItems(dbSync.syncInfo.data);
+    if (!dbSync.syncInfo.isSynced) {
+        dbSync.syncData();
+    }
+    else {
+        state.isSynced = true;
+    }
     return subscriptionManager;
 };
 exports.createSync = createSync;

package/dist/SyncedTable/createSyncDataStore.d.ts

@@ -1,6 +1,6 @@
-import type { SyncInfo } from "lib/prostgles";
 import { type AnyObject, type SyncBatchParams } from "prostgles-types";
 import { type SyncedTableOptions } from "./SyncedTable";
+import type { SyncInfo } from "../prostgles";
 export declare const createSyncDataStore: ({ id_fields, synced_field, filter, columns, }: Pick<SyncInfo, "id_fields" | "synced_field"> & Pick<SyncedTableOptions, "filter" | "columns">) => {
     getItems: <T extends AnyObject = AnyObject>() => T[];
     getBatch: ({ from_synced, to_synced, offset, limit }?: SyncBatchParams) => {

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

@@ -1 +1 @@
-{"version":3,"file":"createSyncDataStore.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncDataStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAML,KAAK,SAAS,EACd,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEpE,eAAO,MAAM,mBAAmB,GAAI,+CAKjC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,cAAc,CAAC,GAC7C,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,CAAC;eA2B5B,CAAC,SAAS,SAAS,mBAAiB,CAAC,EAAE;2DAyBZ,eAAe;;;kBA3CvC,SAAS;uBAOJ,SAAS;kBA0Fd,SAAS,KAAK,SAAS,KAAG,SAAS;uBA3B9B,SAAS,EAAE,KAAG,IAAI;0BAkBf,SAAS;qBA7Bd,SAAS;cAoBhB,CAAC,qBAAqB,OAAO,CAAC,CAAC,CAAC,KAAG,CAAC,GAAG,SAAS;sBA0CxC,SAAS,GAAG,SAAS,KAAK,SAAS,GAAG,SAAS;0BAN3C,SAAS,GAAG,SAAS;CAuBnD,CAAC"}
+{"version":3,"file":"createSyncDataStore.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncDataStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,SAAS,EACd,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,eAAO,MAAM,mBAAmB,GAAI,+CAKjC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,cAAc,CAAC,GAC7C,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,CAAC;eA2B5B,CAAC,SAAS,SAAS,mBAAiB,CAAC,EAAE;2DAyBZ,eAAe;;;kBA3CvC,SAAS;uBAOJ,SAAS;kBA0Fd,SAAS,KAAK,SAAS,KAAG,SAAS;uBA3B9B,SAAS,EAAE,KAAG,IAAI;0BAkBf,SAAS;qBA7Bd,SAAS;cAoBhB,CAAC,qBAAqB,OAAO,CAAC,CAAC,CAAC,KAAG,CAAC,GAAG,SAAS;sBA0CxC,SAAS,GAAG,SAAS,KAAK,SAAS,GAAG,SAAS;0BAN3C,SAAS,GAAG,SAAS;CAuBnD,CAAC"}

package/dist/SyncedTable/createSyncDataStore.js

@@ -49,19 +49,18 @@ const createSyncDataStore = ({ id_fields, synced_field, filter, columns, }) => {
             .filter((c) => (!Number.isFinite(from_synced) || +c[synced_field] >= +from_synced) &&
             (!Number.isFinite(to_synced) || +c[synced_field] <= +to_synced));
         if (offset || limit) {
-            res = res.splice(offset !== null && offset !== void 0 ? offset : 0, limit || res.length);
+            res = res.splice(offset ?? 0, limit || res.length);
         }
         return res;
     };
     const setItem = (_item, isFullData = false, deleteItem = false) => {
-        var _a;
         const item = (0, SyncedTable_1.quickClone)(_item);
         const id = getIdStr(item);
         if (deleteItem) {
             itemsMap.delete(id);
         }
         else {
-            const existing = (_a = itemsMap.get(id)) !== null && _a !== void 0 ? _a : {};
+            const existing = itemsMap.get(id) ?? {};
             itemsMap.set(id, isFullData ? { ...item } : { ...existing, ...item });
         }
     };

package/dist/SyncedTable/createSyncStateUtils.d.ts

@@ -1,6 +1,6 @@
-import { type SyncDebugEvent, type SyncInfo } from "lib/prostgles";
 import { type ClientSyncHandles } from "prostgles-types";
 import type { Socket } from "socket.io-client";
+import { type SyncDebugEvent } from "../prostgles";
 import type { SyncedTableOptions } from "./SyncedTable";
 export declare const createSyncStateUtils: (socket: Socket, options: Omit<SyncedTableOptions, "onReady">) => {
     state: {
@@ -13,13 +13,16 @@ export declare const createSyncStateUtils: (socket: Socket, options: Omit<Synced
     batch_size: number;
     columns: import("prostgles-types").ValidatedColumnInfo[];
     _syncInfo: import("prostgles-types").SyncTableInfo;
-    _sync: (handles: ClientSyncHandles) => Promise<{
-        sync_info: SyncInfo;
+    initializeSync: (handles: ClientSyncHandles) => Promise<{
+        syncInfo: import("prostgles-types").SyncConfig & {
+            data: import("prostgles-types").AnyObject[];
+            isSynced: boolean;
+        };
         unsync: () => Promise<unknown>;
         syncData: (data?: import("prostgles-types").AnyObject[], deleted?: import("prostgles-types").AnyObject[], cb?: (err?: any) => void) => void;
     }>;
     filter: import("prostgles-types").EqualityFilter<import("prostgles-types").AnyObject>;
     select: import("prostgles-types").FieldFilter;
-    tableHandler: Partial<import("prostgles-types").TableHandler & import("lib/prostgles").TableHandlerClientMethods<import("prostgles-types").AnyObject, void>>;
+    tableHandler: Partial<import("prostgles-types").TableHandler & import("../prostgles").TableHandlerClientMethods<import("prostgles-types").AnyObject, void>>;
 };
 //# sourceMappingURL=createSyncStateUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createSyncStateUtils.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncStateUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAErE,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,MAAM,EACd,SAAS,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC;;;;mBAKtB,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;;;;;;;qBAyB9D,iBAAiB;;;2HAkIi6B,CAAC;;;;;CADl9B,CAAC"}
+{"version":3,"file":"createSyncStateUtils.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncStateUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAErE,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,MAAM,EACd,SAAS,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC;;;;mBAKtB,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;;;;;;;8BAyBrD,iBAAiB;;;;;;2HA6HuuB,CAAC;;;;;CADjyB,CAAC"}

package/dist/SyncedTable/createSyncStateUtils.js

@@ -6,16 +6,13 @@ 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,
-        });
-    };
+    const onDebug = (evt) => options.onDebug?.({
+        ...evt,
+        type: "sync",
+        tableName: name,
+        channelName,
+        options,
+    });
     onDebug({ command: "create", data: { name, filter, select } });
     const tableHandler = db[name];
     if (!tableHandler) {
@@ -29,8 +26,8 @@ const createSyncStateUtils = (socket, options) => {
     if (!id_fields.length || !synced_field) {
         throw "id_fields/synced_field missing";
     }
-    const _sync = async (handles) => {
-        const sync_info = await new Promise((resolve, reject) => {
+    const initializeSync = async (handles) => {
+        const syncInfo = await new Promise((resolve, reject) => {
             socket.emit(prostgles_types_1.CHANNEL_PREFIX, {
                 tableName: name,
                 command: "sync",
@@ -42,38 +39,35 @@ const createSyncStateUtils = (socket, options) => {
                     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 { channelName } = syncInfo;
+                    // socket.emit(
+                    //   channelName,
+                    //   { onSyncRequest: handles.onSyncRequest({}) },
+                    //   (response: any) => {
+                    //     console.log(response);
+                    //   },
+                    // );
+                    resolve(syncInfo);
                 }
             });
         });
         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)
-              */
+              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 },
-            //   });
-            // });
+            onDebug({
+                command: data.data ? "onUpdates"
+                    : data.onSyncRequest ? "onSyncRequest"
+                        : "onPullRequest",
+                data,
+            });
             if (data.data) {
                 Promise.resolve(onUpdates(data))
                     .then(() => {
@@ -126,7 +120,7 @@ const createSyncStateUtils = (socket, options) => {
                 socket.removeListener(channelName, onCall);
             });
         };
-        return { sync_info, unsync, syncData };
+        return { syncInfo, unsync, syncData };
     };
     return {
         state,
@@ -137,7 +131,7 @@ const createSyncStateUtils = (socket, options) => {
         batch_size,
         columns,
         _syncInfo,
-        _sync,
+        initializeSync,
         filter,
         select,
         tableHandler,

package/dist/SyncedTable/createSyncSubscriptionManager.js

@@ -68,22 +68,18 @@ const createSyncSubscriptionManager = ({ id_fields, synced_field }, store, state
         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,
-                });
-            }));
+            _notifySubscribers(fullItems.map((d) => ({
+                delta: store.getDelta(d.initial ?? {}, 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));
+            await stateUtils.tableHandler.delete?.(idObj);
         }
         _notifySubscribers();
         return true;

package/dist/auth/useAuthState.d.ts

@@ -1,5 +1,5 @@
 import { type AuthResponse } from "prostgles-types";
-import type { AuthHandler, PasswordLogin, PasswordRegister } from "lib/getAuthHandler";
+import type { AuthHandler, PasswordLogin, PasswordRegister } from "../getAuthHandler";
 export declare const useAuthState: ({ auth }: {
     auth: AuthHandler;
 }) => {
@@ -116,7 +116,7 @@ export declare const useAuthState: ({ auth }: {
         username: string;
         emailVerificationCode: string;
         setEmailVerificationCode: import("react").Dispatch<import("react").SetStateAction<string>>;
-        onCall: () => Promise<import("lib/getAuthHandler").PasswordRegisterResponse>;
+        onCall: () => Promise<import("../getAuthHandler").PasswordRegisterResponse>;
         result: (import("prostgles-types").CommonAuthFailure & {
             redirect_url?: string;
         }) | ({

package/dist/auth/useAuthState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAuthState.d.ts","sourceRoot":"","sources":["../../lib/auth/useAuthState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGjE,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AA2BvF,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa/C,OAAO;iBACP,MAAM;;;CA2MlB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;CA8B7B,CAAC"}
+{"version":3,"file":"useAuthState.d.ts","sourceRoot":"","sources":["../../lib/auth/useAuthState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGjE,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AA2BtF,eAAO,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa/C,OAAO;iBACP,MAAM;;;CA2MlB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;CA8B7B,CAAC"}

package/dist/auth/useAuthState.js

@@ -97,7 +97,6 @@ const useAuthState = ({ auth }) => {
     const isOnLogin = loginStates.some((v) => v === state);
     const registerTypeAllowed = "registerWithPassword";
     const onAuthCall = async () => {
-        var _a, _b, _c;
         const formData = {
             username,
             password,
@@ -114,7 +113,7 @@ const useAuthState = ({ auth }) => {
         const setErrorWithInfo = (err) => {
             return setError(err === "no match" ? errorMap[err] : err);
         };
-        if (!(formHandlers === null || formHandlers === void 0 ? void 0 : formHandlers.onCall)) {
+        if (!formHandlers?.onCall) {
             return setError("Invalid state");
         }
         /**
@@ -165,8 +164,8 @@ const useAuthState = ({ auth }) => {
                 setState("loginTotp");
             }
             else if (res.code !== "password-missing") {
-                const errorMessage = (_a = res.message) !== null && _a !== void 0 ? _a : (0, prostgles_types_1.getProperty)(exports.ERR_CODE_MESSAGES, res.code);
-                setErrorWithInfo(errorMessage !== null && errorMessage !== void 0 ? errorMessage : "Error");
+                const errorMessage = res.message ?? (0, prostgles_types_1.getProperty)(exports.ERR_CODE_MESSAGES, res.code);
+                setErrorWithInfo(errorMessage ?? "Error");
             }
         }
         else {
@@ -176,7 +175,7 @@ const useAuthState = ({ auth }) => {
             if (state === "registerWithPassword" || res.code === "magic-link-sent") {
                 setState("registerWithPasswordConfirmationCode");
             }
-            let message = (_c = (_b = (res.code && SIGNUP_CODE_MESSAGES[res.code])) !== null && _b !== void 0 ? _b : res.message) !== null && _c !== void 0 ? _c : "Success";
+            let message = (res.code && SIGNUP_CODE_MESSAGES[res.code]) ?? res.message ?? "Success";
             if (formHandlers.state === "registerWithPasswordConfirmationCode") {
                 message = SIGNUP_CODE_MESSAGES["email-verified"];
                 setState("login");

package/dist/getAuthHandler.js

@@ -4,7 +4,6 @@ exports.authRequest = exports.getAuthHandler = void 0;
 const prostgles_types_1 = require("prostgles-types");
 const prostgles_1 = require("./prostgles");
 const getAuthHandler = ({ authData: authConfig, socket, onReload, endpoint, ...authOpts }) => {
-    var _a;
     const urlWithEndpointAndSearch = (route) => {
         const { search } = window.location;
         let url = route + search;
@@ -12,9 +11,9 @@ const getAuthHandler = ({ authData: authConfig, socket, onReload, endpoint, ...a
             url = `${endpoint}${url}`;
         return url;
     };
-    if ((authConfig === null || authConfig === void 0 ? void 0 : authConfig.pathGuard) && prostgles_1.isClientSide) {
+    if (authConfig?.pathGuard && prostgles_1.isClientSide) {
         const doReload = (res) => {
-            if (res === null || res === void 0 ? void 0 : res.shouldReload) {
+            if (res?.shouldReload) {
                 if (onReload)
                     onReload();
                 else if (prostgles_1.isClientSide) {
@@ -34,13 +33,13 @@ const getAuthHandler = ({ authData: authConfig, socket, onReload, endpoint, ...a
         });
     }
     const loginSignupOptions = {
-        loginType: (_a = authConfig === null || authConfig === void 0 ? void 0 : authConfig.login) === null || _a === void 0 ? void 0 : _a.mode,
+        loginType: authConfig?.login?.mode,
         login: undefined,
-        preferredLogin: authConfig === null || authConfig === void 0 ? void 0 : authConfig.preferredLogin,
+        preferredLogin: authConfig?.preferredLogin,
         loginWithProvider: undefined,
         signupWithEmailAndPassword: undefined,
         confirmEmail: undefined,
-        providers: authConfig === null || authConfig === void 0 ? void 0 : authConfig.providers,
+        providers: authConfig?.providers,
     };
     if (authConfig) {
         const { providers, signupWithEmailAndPassword, login } = authConfig;
@@ -68,7 +67,7 @@ const getAuthHandler = ({ authData: authConfig, socket, onReload, endpoint, ...a
                     return (0, exports.authRequest)(urlWithEndpointAndSearch(signupWithEmailAndPassword.emailConfirmationRoute), data, "POST", authOpts);
                 });
     }
-    if (!(authConfig === null || authConfig === void 0 ? void 0 : authConfig.user)) {
+    if (!authConfig?.user) {
         return {
             isLoggedin: false,
             user: undefined,
@@ -79,8 +78,7 @@ const getAuthHandler = ({ authData: authConfig, socket, onReload, endpoint, ...a
         isLoggedin: true,
         user: authConfig.user,
         logout: async () => {
-            var _a;
-            const { logoutRoute } = (_a = authConfig.login) !== null && _a !== void 0 ? _a : {};
+            const { logoutRoute } = authConfig.login ?? {};
             if (!logoutRoute)
                 throw new Error("Unexpected");
             return (0, exports.authRequest)(urlWithEndpointAndSearch(logoutRoute), {}, "POST", authOpts);

package/dist/getDbHandler.d.ts

@@ -1,19 +1,15 @@
 import { type DBSchemaTable } from "prostgles-types";
 import type { getSubscriptionHandler } from "./getSubscriptionHandler";
-import type { getSyncHandler } from "./getSyncHandler";
-import { type DBHandlerClient, type InitOptions } from "./prostgles";
-import { type SyncedTable } from "./SyncedTable/SyncedTable";
 import type { getSyncHandlerV2 } from "./getSyncHandlerV2";
+import { type DBHandlerClient, type InitOptions } from "./prostgles";
 type Args = {
     tableSchema: DBSchemaTable[] | undefined;
     onDebug: InitOptions["onDebug"];
     socket: InitOptions["socket"];
-    syncedTable: typeof SyncedTable | undefined;
-    syncHandler: ReturnType<typeof getSyncHandler>;
     syncHandlerV2: ReturnType<typeof getSyncHandlerV2>;
     subscriptionHandler: ReturnType<typeof getSubscriptionHandler>;
 };
-export declare const getDB: <DBSchema = void>({ tableSchema, onDebug, syncedTable, syncHandler, syncHandlerV2, subscriptionHandler, socket, }: Args) => {
+export declare const getDB: <DBSchema = void>({ tableSchema, onDebug, syncHandlerV2, subscriptionHandler, socket, }: Args) => {
     db: Partial<DBHandlerClient<DBSchema>>;
 };
 export {};

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;AACnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,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,aAAa,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;IACnD,mBAAmB,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;CAChE,CAAC;AAIF,eAAO,MAAM,KAAK,GAAI,QAAQ,GAAG,IAAI,EAAE,iGAQpC,IAAI;QAyNc,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,EAInB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,WAAW,EAEjB,MAAM,aAAa,CAAC;AAWrB,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,aAAa,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;IACnD,mBAAmB,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;CAChE,CAAC;AAIF,eAAO,MAAM,KAAK,GAAI,QAAQ,GAAG,IAAI,EAAE,uEAMpC,IAAI;QAiLc,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;CACtD,CAAC"}

package/dist/getDbHandler.js

@@ -6,9 +6,8 @@ const useFetch_1 = require("./hooks/useFetch");
 const useSubscribe_1 = require("./hooks/useSubscribe");
 const useSync_1 = require("./hooks/useSync");
 const SyncedTable_1 = require("./SyncedTable/SyncedTable");
-const preffix = prostgles_types_1.CHANNELS._preffix;
-const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, syncHandlerV2, subscriptionHandler, socket, }) => {
-    var _a;
+const prefix = prostgles_types_1.CHANNELS._preffix;
+const getDB = ({ tableSchema, onDebug, syncHandlerV2, subscriptionHandler, socket, }) => {
     /* Building DB object */
     const checkSubscriptionArgs = (basicFilter, options, onChange, onError) => {
         if ((basicFilter !== undefined && !(0, prostgles_types_1.isObject)(basicFilter)) ||
@@ -20,7 +19,7 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, syncHandlerV2,
     };
     const subscribeCommands = ["subscribe", "subscribeOne"];
     const db = {};
-    const schemaClone = (_a = (0, SyncedTable_1.quickClone)(tableSchema)) !== null && _a !== void 0 ? _a : [];
+    const schemaClone = (0, SyncedTable_1.quickClone)(tableSchema) ?? [];
     schemaClone.forEach(({ name: tableName, publishInfo, columns }) => {
         const allowedCommands = (0, prostgles_types_1.getAllowedTableMethods)({ publishInfo });
         db[tableName] = {};
@@ -28,81 +27,49 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, syncHandlerV2,
         allowedCommands
             .sort((a, b) => Number((0, prostgles_types_1.includes)(subscribeCommands, a)) - Number((0, prostgles_types_1.includes)(subscribeCommands, b)))
             .forEach((command) => {
-            var _a;
             if (command === "sync") {
-                const syncConfig = (_a = publishInfo.select) === null || _a === void 0 ? void 0 : _a.syncConfig;
+                const syncConfig = publishInfo.select?.syncConfig;
                 if (!syncConfig) {
                     throw `Table ${tableName} does not have syncConfig in publishInfo.select`;
                 }
                 dboTable._syncInfo = { ...syncConfig };
-                if (syncedTable) {
-                    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;
-                    };
-                    const syncOne = (async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {
-                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
-                            type: "table",
-                            command: "syncOne",
-                            tableName,
-                            data: { basicFilter, options },
-                        }));
-                        checkSubscriptionArgs(basicFilter, options, onChange, onError);
-                        // const syncedTable = await upsertSyncTable(basicFilter, options, onError);
-                        // return await syncedTable.syncOne(basicFilter, onChange as any, options.handlesOnData);
-                        return (await syncHandlerV2.getTableSyncFunctions({ db, tableName, columns })).addSyncOne(basicFilter, options, onChange, onError);
-                    });
-                    const sync = (async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {
-                        await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
-                            type: "table",
-                            command: "sync",
-                            tableName,
-                            data: { basicFilter, options },
-                        }));
-                        checkSubscriptionArgs(basicFilter, options, onChange, onError);
-                        // const syncedTable = await upsertSyncTable(basicFilter, options, onError);
-                        // return await syncedTable.sync(onChange as any, options.handlesOnData);
-                        return (await syncHandlerV2.getTableSyncFunctions({ db, tableName, columns })).addSync(basicFilter, options, onChange, onError);
+                const syncOne = (async (basicFilter, options = { handlesOnData: true }, onChange) => {
+                    await onDebug?.({
+                        type: "table",
+                        command: "syncOne",
+                        tableName,
+                        data: { basicFilter, options },
                     });
-                    dboTable.sync = sync;
-                    dboTable.syncOne = syncOne;
-                    dboTable.useSync = (basicFilter, options, hookOptions) => 
-                    // eslint-disable-next-line react-hooks/rules-of-hooks
-                    (0, useSync_1.useSync)(sync, basicFilter, options, hookOptions);
-                    dboTable.useSyncOne = (basicFilter, options, hookOptions) => 
-                    // eslint-disable-next-line react-hooks/rules-of-hooks
-                    (0, useSync_1.useSync)(syncOne, basicFilter, options, hookOptions);
-                }
-                dboTable._sync = async function (filter, select, syncHandles) {
-                    await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
+                    checkSubscriptionArgs(basicFilter, options, onChange);
+                    return (await syncHandlerV2.getTableSyncFunctions({ db, tableName, columns })).addSyncOne(basicFilter, options, onChange);
+                });
+                const sync = (async (basicFilter, options = { handlesOnData: true }, onChange) => {
+                    await onDebug?.({
                         type: "table",
-                        command: "_sync",
+                        command: "sync",
                         tableName,
-                        data: { filter, select, syncHandles },
-                    }));
-                    return syncHandler.addSync({ tableName, command, param1: filter, param2: select }, syncHandles);
-                };
+                        data: { basicFilter, options },
+                    });
+                    checkSubscriptionArgs(basicFilter, options, onChange);
+                    return (await syncHandlerV2.getTableSyncFunctions({ db, tableName, columns })).addSync(basicFilter, options, onChange);
+                });
+                dboTable.sync = sync;
+                dboTable.syncOne = syncOne;
+                dboTable.useSync = (basicFilter, options, hookOptions) => 
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                (0, useSync_1.useSync)(sync, basicFilter, options, hookOptions);
+                dboTable.useSyncOne = (basicFilter, options, hookOptions) => 
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                (0, useSync_1.useSync)(syncOne, basicFilter, options, hookOptions);
             }
             else if (subscribeCommands.includes(command)) {
                 const subFunc = async function (param1 = {}, param2 = {}, onChange, onError) {
-                    await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
+                    await onDebug?.({
                         type: "table",
                         command: command,
                         tableName,
                         data: { param1, param2, onChange, onError },
-                    }));
+                    });
                     checkSubscriptionArgs(param1, param2, onChange, onError);
                     return subscriptionHandler.addSub(db, { tableName, command, param1, param2 }, onChange, onError);
                 };
@@ -121,12 +88,12 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, syncHandlerV2,
                 }
                 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({
+                        await onDebug?.({
                             type: "table",
                             command: SUBSCRIBE_ONE,
                             tableName,
                             data: { param1, param2, onChange },
-                        }));
+                        });
                         checkSubscriptionArgs(param1, param2, onChange);
                         const onChangeOne = (rows) => {
                             onChange(rows[0]);
@@ -137,20 +104,19 @@ const getDB = ({ tableSchema, onDebug, syncedTable, syncHandler, syncHandlerV2,
             }
             else {
                 const method = async function (param1, param2, param3) {
-                    var _a;
                     if (command === "getColumns" && !param1 && !param2 && !param3) {
-                        const columns = (_a = tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.find((t) => t.name === tableName)) === null || _a === void 0 ? void 0 : _a.columns;
+                        const columns = tableSchema?.find((t) => t.name === tableName)?.columns;
                         if (columns)
                             return columns;
                     }
-                    await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({
+                    await onDebug?.({
                         type: "table",
                         command: command,
                         tableName,
                         data: { param1, param2, param3 },
-                    }));
+                    });
                     return new Promise((resolve, reject) => {
-                        socket.emit(preffix, { tableName, command, param1, param2, param3 }, 
+                        socket.emit(prefix, { tableName, command, param1, param2, param3 }, 
                         /* Get col definition and re-cast data types?! */
                         (err, res) => {
                             if (err)

package/dist/getMethods.js

@@ -8,7 +8,7 @@ const getMethods = ({ onDebug, methods, socket, }) => {
     const _methods = JSON.parse(JSON.stringify(methods));
     _methods.map(({ name, description, input, output }) => {
         const onRun = async function (input) {
-            await (onDebug === null || onDebug === void 0 ? void 0 : onDebug({ type: "method", command: name, data: { params: input } }));
+            await onDebug?.({ type: "method", command: name, data: { params: input } });
             return new Promise((resolve, reject) => {
                 socket.emit(prostgles_types_1.CHANNELS.METHOD, { name, input }, (err, res) => {
                     if (err)