prostgles-client 4.0.171 → 4.0.173

package/lib/prostgles.ts

@@ -26,18 +26,16 @@ import type {
 import {
   CHANNELS,
   asName,
-  getJoinHandlers,
-  getKeys,
-  isObject,
-  omitKeys,
+  getJoinHandlers
 } from "prostgles-types";
 
 import { type AuthHandler, setupAuth } from "./Auth";
-import { FunctionQueuer } from "./FunctionQueuer";
-import { isEqual, useFetch, useSubscribe, useSync } from "./react-hooks";
-import { SQL } from "./SQL";
+import { getDBO } from "./getDBO";
+import { getMethods } from "./getMethods";
+import { getSqlHandler } from "./getSqlHandler";
+import { isEqual } from "./react-hooks";
 import { getSubscriptionHandler } from "./subscriptionHandler";
-import type { DbTableSync, Sync, SyncDataItem, SyncOne, SyncOneOptions, SyncOptions, SyncedTable } from "./SyncedTable/SyncedTable";
+import type { Sync, SyncDataItem, SyncOne, SyncOneOptions, SyncOptions, SyncedTable } from "./SyncedTable/SyncedTable";
 import { getSyncHandler } from "./syncHandler";
 
 const DEBUG_KEY = "DEBUG_SYNCEDTABLE";
@@ -48,9 +46,9 @@ export const debug: any = function (...args: any[]) {
   }
 };
 
-export { MethodHandler, SQLResult, asName };
 export * from "./react-hooks";
 export * from "./useProstglesClient";
+export { MethodHandler, SQLResult, asName };
 
 
 export type ViewHandlerClient<T extends AnyObject = AnyObject, S extends DBSchema | void = void> = ViewHandler<T, S> & {
@@ -124,7 +122,7 @@ export type DBHandlerClient<Schema = void> = (Schema extends DBSchema ? {
 } & DbJoinMaker;
 
 type OnReadyArgs = {
-  dbo: DBHandlerClient<DBSchema>; 
+  dbo: DBHandlerClient | any; 
   methods: MethodHandler | undefined;
   tableSchema: DBSchemaTable[] | undefined; 
   auth: AuthHandler; 
@@ -163,6 +161,7 @@ type DebugEvent =
 | {
   type: "schemaChanged";
   data: ClientSchema;
+  state: "connected" | "disconnected" | "reconnected" | undefined;
 }
 | {
   type: "onReady";
@@ -172,6 +171,11 @@ type DebugEvent =
   type: "onReady.notMounted";
   data: OnReadyArgs;
 }
+| {
+  type: "onReady.call";
+  data: OnReadyArgs;
+  state: "connected" | "disconnected" | "reconnected" | undefined;
+}
 ;
 
 export type InitOptions<DBSchema = void> = {
@@ -219,6 +223,7 @@ type CurrentClientSchema = {
   date: Date; 
   clientSchema: Omit<ClientSchema, "joinTables">;
 };
+
 export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable: typeof SyncedTable | undefined) {
   const { socket, onReady, onDisconnect, onReconnect, onSchemaChange = true, onReload, onDebug } = initOpts;
   let schemaAge: CurrentClientSchema | undefined;
@@ -232,13 +237,11 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
     if (cb) socket.on(CHANNELS.SCHEMA_CHANGED, cb)
   }
 
-  const preffix = CHANNELS._preffix;
-
   const subscriptionHandler = getSubscriptionHandler(initOpts);
   const syncHandler = getSyncHandler(initOpts);
 
   let state: undefined | "connected" | "disconnected" | "reconnected";
-  const sql = new SQL();
+  const sqlHandler = getSqlHandler({ socket });
 
 
   return new Promise((resolve, reject) => {
@@ -266,20 +269,22 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
 
     /* Schema = published schema */
     socket.on(CHANNELS.SCHEMA, async (args: ClientSchema) => {
-      await onDebug?.({ type: "schemaChanged", data: args });
+      await onDebug?.({ type: "schemaChanged", data: args, state });
       const { joinTables = [], ...clientSchema } = args;
       const { schema, methods, tableSchema, auth: authConfig, rawSQL, err } = clientSchema;
 
       /** Only destroy existing syncs if schema changed */
       const schemaDidNotChange = schemaAge?.clientSchema && isEqual(schemaAge.clientSchema, clientSchema)
       if(!schemaDidNotChange){
-        await syncHandler.destroySyncs();
+        await syncHandler.destroySyncs().catch(error => console.error("Error while destroying syncs", error));
       }
 
+      if (err) {
+        console.error("Error on schema change:", err)
+      }
       if ((state === "connected" || state === "reconnected") && onReconnect) {
         onReconnect(socket, err);
         if (err) {
-          console.error(err)
           return;
         }
         schemaAge = { origin: "onReconnect", date: new Date(), clientSchema };
@@ -295,163 +300,22 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
       const isReconnect = state === "reconnected";
       state = "connected";
 
-      const dbo: Partial<DBHandlerClient> = JSON.parse(JSON.stringify(schema));
-      const _methods: typeof methods = JSON.parse(JSON.stringify(methods));
-      let methodsObj: MethodHandler = {};
-
       const auth = setupAuth({ authData: authConfig, socket, onReload }); 
-
-      _methods.map(method => {
-        /** New method def */
-        const isBasic = typeof method === "string";
-        const methodName = isBasic ? method : method.name;
-        const onRun = async function (...params) {
-          await onDebug?.({ type: "method", command: methodName, data: { params } });
-          return new Promise((resolve, reject) => {
-            socket.emit(CHANNELS.METHOD, { method: methodName, params }, (err, res) => {
-              if (err) reject(err);
-              else resolve(res);
-            });
-          })
-        }
-        methodsObj[methodName] = isBasic ? onRun : {
-          ...method,
-          run: onRun
-        };
+      const { methodsObj } = getMethods({ onDebug, methods, socket });
+
+      const { dbo } = getDBO({ 
+        schema, 
+        onDebug, 
+        syncedTable, 
+        syncHandler, 
+        subscriptionHandler, 
+        socket, 
+        joinTables,
       });
-      methodsObj = Object.freeze(methodsObj);
-
-      if (rawSQL) {
-        sql.setup({ dbo, socket });
+      if(rawSQL){
+        dbo.sql = sqlHandler.sql;
       }
 
-      /* Building DBO object */
-      const checkSubscriptionArgs = (basicFilter: AnyObject | undefined, options: AnyObject | undefined, onChange: AnyFunction, onError?: AnyFunction) => {
-        if (basicFilter !== undefined && !isObject(basicFilter) || options !== undefined && !isObject(options) || !(typeof onChange === "function") || onError !== undefined && typeof onError !== "function") {
-          throw "Expecting: ( basicFilter<object>, options<object>, onChange<function> , onError?<function>) but got something else";
-        }
-      }
-      const sub_commands = ["subscribe", "subscribeOne"] as const;
-      getKeys(dbo).forEach(tableName => {
-        const all_commands = Object.keys(dbo[tableName]!);
-
-        const dboTable = dbo[tableName] as TableHandlerClient;
-        all_commands
-          .sort((a, b) => <never>sub_commands.includes(a as any) - <never>sub_commands.includes(b as any))
-          .forEach(command => {
-
-            if (command === "sync") {
-              dboTable._syncInfo = { ...dboTable[command] };
-              if (syncedTable) {
-                dboTable.getSync = async (filter, params = {}) => {
-                  await onDebug?.({ type: "table", command: "getSync", tableName, data: { filter, params } });
-                  return syncedTable.create({ 
-                    name: tableName, 
-                    onDebug: onDebug as any, 
-                    filter, 
-                    db: dbo, 
-                    ...params 
-                  });
-                }
-                const upsertSyncTable = async (basicFilter = {}, options: SyncOptions = {}, onError) => {
-                  const syncName = `${tableName}.${JSON.stringify(basicFilter)}.${JSON.stringify(omitKeys(options, ["handlesOnData"]))}`
-                  if (!syncHandler.syncedTables[syncName]) {
-                    syncHandler.syncedTables[syncName] = await syncedTable.create({ 
-                      ...options, 
-                      onDebug: onDebug as any, 
-                      name: tableName, 
-                      filter: basicFilter, 
-                      db: dbo, 
-                      onError 
-                    });
-                  }
-                  return syncHandler.syncedTables[syncName]
-                }
-                const sync: Sync<AnyObject> = async (basicFilter, options = { handlesOnData: true, select: "*" }, onChange, onError) => {
-                  await onDebug?.({ type: "table", command: "sync", tableName, data: { basicFilter, options } });
-                  checkSubscriptionArgs(basicFilter, options, onChange, onError);
-                  const s = await upsertSyncTable(basicFilter, options, onError);
-                  return await s.sync(onChange, options.handlesOnData);
-                }
-                const syncOne: SyncOne<AnyObject> = async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {
-                  await onDebug?.({ type: "table", command: "syncOne", tableName, data: { basicFilter, options } });
-                  checkSubscriptionArgs(basicFilter, options, onChange, onError);
-                  const s = await upsertSyncTable(basicFilter, options, onError);
-                  return await s.syncOne(basicFilter, onChange, options.handlesOnData);
-                }
-                dboTable.sync = sync;
-                dboTable.syncOne = syncOne;
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                dboTable.useSync = (basicFilter, options) => useSync(sync, basicFilter, options) as any;
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                dboTable.useSyncOne = (basicFilter, options) => useSync(syncOne, basicFilter, options) as any;
-              }
-
-              dboTable._sync = async function (param1, param2, syncHandles) {
-                await onDebug?.({ type: "table", command: "_sync", tableName, data: { param1, param2, syncHandles } });
-                return syncHandler.addSync({ tableName, command, param1, param2 }, syncHandles);
-              }
-            } else if (sub_commands.includes(command as any)) {
-              const subFunc = async function (param1 = {}, param2 = {}, onChange, onError) {
-                await onDebug?.({ type: "table", command: command as typeof sub_commands[number], tableName, data: { param1, param2, onChange, onError } });
-                checkSubscriptionArgs(param1, param2, onChange, onError);
-                return subscriptionHandler.addSub(dbo, { tableName, command, param1, param2 }, onChange, onError);
-              };
-              dboTable[command] = subFunc;
-              const SUBONE = "subscribeOne";
-
-              /**
-               * React hooks 
-               */
-              const handlerName = command === "subscribe" ? "useSubscribe" : command === "subscribeOne"? "useSubscribeOne" : undefined;
-              if(handlerName){
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                dboTable[handlerName] = (filter, options) => useSubscribe(subFunc, command === SUBONE, filter, options)
-              }
-
-              if (command === SUBONE || !sub_commands.includes(SUBONE)) {
-                dboTable[SUBONE] = async function (param1, param2, onChange, onError) {
-                  await onDebug?.({ type: "table", command: "getSync", tableName, data: { param1, param2, onChange, onError } });
-                  checkSubscriptionArgs(param1, param2, onChange, onError);
-
-                  const onChangeOne = (rows) => { onChange(rows[0]) };
-                  return subscriptionHandler.addSub(dbo, { tableName, command, param1, param2 }, onChangeOne, onError);
-                };
-              }
-            } else {
-              const method = async function (param1, param2, param3) {
-                await onDebug?.({ type: "table", command: command as any, tableName, data: { param1, param2, param3 } });
-                return new Promise((resolve, reject) => {
-                  socket.emit(preffix,
-                    { tableName, command, param1, param2, param3 },
-
-                    /* Get col definition and re-cast data types?! */
-                    (err, res) => {
-                      if (err) reject(err);
-                      else resolve(res);
-                    }
-                  );
-                })
-              }
-              dboTable[command] = method;
-
-              const methodName = command === "findOne" ? "useFindOne" : command === "find" ? "useFind" : command === "count" ? "useCount" : command === "size" ? "useSize" : undefined;
-              if(methodName){
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                dboTable[methodName] = (param1, param2, param3?) => useFetch(method, [param1, param2, param3]);
-              }
-              if (["find", "findOne"].includes(command)) {
-                dboTable.getJoinedTables = function () {
-                  return joinTables
-                    .filter(tb => Array.isArray(tb) && tb.includes(tableName))
-                    .flat()
-                    .filter(t => t !== tableName);
-                }
-              }
-            }
-          })
-      });
-
       await subscriptionHandler.reAttachAll();
       await syncHandler.reAttachAll();
 
@@ -470,6 +334,8 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
 
       (async () => {
         try {
+          const onReadyArgs = { dbo, methods: methodsObj, tableSchema, auth, isReconnect };
+          await onDebug?.({ type: "onReady.call", data: onReadyArgs, state });
           await onReady(dbo as DBHandlerClient<DBSchema>, methodsObj, tableSchema, auth, isReconnect);
         } catch (err) {
           console.error("Prostgles: Error within onReady: \n", err);

package/lib/useProstglesClient.ts

@@ -72,7 +72,7 @@ export const useProstglesClient = <DBSchema>({ skip, socketOptions, ...initOpts
           initOpts.onDebug?.({ type: "onReady.notMounted", data: onReadyArgs as any });
           return;
         }
-        initOpts.onDebug?.({ type: "onReady", data: args as any });
+        initOpts.onDebug?.({ type: "onReady", data: onReadyArgs as any });
         setOnReadyArgs({ ...onReadyArgs, isLoading: false });
       }
     }, SyncedTable)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-client",
-  "version": "4.0.171",
+  "version": "4.0.173",
   "description": "Reactive client for Postgres",
   "main": "dist/prostgles-full.js",
   "types": "dist/prostgles-full.d.ts",

package/tests/package-lock.json

@@ -17,7 +17,7 @@
     },
     "..": {
       "name": "prostgles-client",
-      "version": "4.0.170",
+      "version": "4.0.172",
       "license": "MIT",
       "dependencies": {
         "prostgles-types": "^4.0.112"

package/dist/SQL.d.ts

@@ -1,25 +0,0 @@
-import { type DBNoticeConfig, type DBNotifConfig } from "prostgles-types";
-import type { DBHandlerClient } from "./prostgles";
-type Args = {
-    socket: any;
-    dbo: Partial<DBHandlerClient<void>>;
-};
-export declare class SQL {
-    notifSubs: {
-        [key: string]: {
-            config: DBNotifConfig;
-            listeners: ((notif: any) => void)[];
-        };
-    };
-    removeNotifListener: (listener: any, conf: DBNotifConfig, socket: any) => void;
-    addNotifListener: (listener: any, conf: DBNotifConfig, socket: any) => void;
-    noticeSubs: {
-        listeners: ((notice: any) => void)[];
-        config: DBNoticeConfig;
-    } | undefined;
-    removeNoticeListener: (listener: any, socket: any) => void;
-    addNoticeListener: (listener: any, conf: DBNoticeConfig, socket: any) => void;
-    setup: ({ socket, dbo }: Args) => Promise<void>;
-}
-export {};
-//# sourceMappingURL=SQL.d.ts.map

package/dist/SQL.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SQL.d.ts","sourceRoot":"","sources":["../lib/SQL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,cAAc,EAAE,KAAK,aAAa,EAA0D,MAAM,iBAAiB,CAAC;AACjK,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,GAAG,CAAC;IACZ,GAAG,EAAE,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;CACrC,CAAA;AACD,qBAAa,GAAG;IAEd,SAAS,EAAE;QACT,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,MAAM,EAAE,aAAa,CAAA;YACrB,SAAS,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,EAAE,CAAA;SACpC,CAAA;KACF,CAAM;IACP,mBAAmB,aAAc,GAAG,QAAQ,aAAa,UAAU,GAAG,UASpE;IACF,gBAAgB,aAAc,GAAG,QAAQ,aAAa,UAAU,GAAG,UAqBjE;IAGF,UAAU,EAAE;QACV,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC,EAAE,CAAC;QACrC,MAAM,EAAE,cAAc,CAAC;KACxB,GAAG,SAAS,CAAC;IACd,oBAAoB,aAAc,GAAG,UAAU,GAAG,UAOjD;IACD,iBAAiB,aAAc,GAAG,QAAQ,cAAc,UAAU,GAAG,UAmBpE;IACD,KAAK,oBAA2B,IAAI,mBA+FnC;CACF"}

package/dist/SQL.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQL = void 0;
-const prostgles_types_1 = require("prostgles-types");
-class SQL {
-    constructor() {
-        this.notifSubs = {};
-        this.removeNotifListener = (listener, conf, socket) => {
-            const channelSubs = this.notifSubs[conf.notifChannel];
-            if (channelSubs) {
-                channelSubs.listeners = channelSubs.listeners.filter(nl => nl !== listener);
-                if (!channelSubs.listeners.length && channelSubs.config.socketUnsubChannel && socket) {
-                    socket.emit(channelSubs.config.socketUnsubChannel, {});
-                    delete this.notifSubs[conf.notifChannel];
-                }
-            }
-        };
-        this.addNotifListener = (listener, conf, socket) => {
-            var _a;
-            const channelSubs = this.notifSubs[conf.notifChannel];
-            if (!channelSubs) {
-                this.notifSubs[conf.notifChannel] = {
-                    config: conf,
-                    listeners: [listener]
-                };
-                socket.removeAllListeners(conf.socketChannel);
-                socket.on(conf.socketChannel, (notif) => {
-                    var _a, _b;
-                    if ((_a = this.notifSubs[conf.notifChannel]) === null || _a === void 0 ? void 0 : _a.listeners.length) {
-                        this.notifSubs[conf.notifChannel].listeners.map(l => {
-                            l(notif);
-                        });
-                    }
-                    else {
-                        socket.emit((_b = this.notifSubs[conf.notifChannel]) === null || _b === void 0 ? void 0 : _b.config.socketUnsubChannel, {});
-                    }
-                });
-            }
-            else {
-                (_a = this.notifSubs[conf.notifChannel]) === null || _a === void 0 ? void 0 : _a.listeners.push(listener);
-            }
-        };
-        this.removeNoticeListener = (listener, socket) => {
-            if (this.noticeSubs) {
-                this.noticeSubs.listeners = this.noticeSubs.listeners.filter(nl => nl !== listener);
-                if (!this.noticeSubs.listeners.length && this.noticeSubs.config.socketUnsubChannel && socket) {
-                    socket.emit(this.noticeSubs.config.socketUnsubChannel, {});
-                }
-            }
-        };
-        this.addNoticeListener = (listener, conf, socket) => {
-            var _a;
-            (_a = this.noticeSubs) !== null && _a !== void 0 ? _a : (this.noticeSubs = {
-                config: conf,
-                listeners: []
-            });
-            if (!this.noticeSubs.listeners.length) {
-                socket.removeAllListeners(conf.socketChannel);
-                socket.on(conf.socketChannel, (notice) => {
-                    if (this.noticeSubs && this.noticeSubs.listeners.length) {
-                        this.noticeSubs.listeners.map(l => {
-                            l(notice);
-                        });
-                    }
-                    else {
-                        socket.emit(conf.socketUnsubChannel, {});
-                    }
-                });
-            }
-            this.noticeSubs.listeners.push(listener);
-        };
-        this.setup = async ({ socket, dbo }) => {
-            const { removeNotifListener, addNotifListener, removeNoticeListener, addNoticeListener } = this;
-            dbo.sql = function (query, params, options) {
-                return new Promise((resolve, reject) => {
-                    socket.emit(prostgles_types_1.CHANNELS.SQL, { query, params, options }, (err, res) => {
-                        if (err)
-                            reject(err);
-                        else {
-                            if ((options === null || options === void 0 ? void 0 : options.returnType) === "stream") {
-                                const { channel, unsubChannel } = res;
-                                const start = (listener) => new Promise((resolveStart, rejectStart) => {
-                                    socket.on(channel, listener);
-                                    socket.emit(channel, {}, (pid, err) => {
-                                        if (err) {
-                                            rejectStart(err);
-                                            socket.removeAllListeners(channel);
-                                        }
-                                        else {
-                                            resolveStart({
-                                                pid,
-                                                run: (query, params) => {
-                                                    return new Promise((resolveRun, rejectRun) => {
-                                                        socket.emit(channel, { query, params }, (data, _err) => {
-                                                            if (_err) {
-                                                                rejectRun(_err);
-                                                            }
-                                                            else {
-                                                                resolveRun(data);
-                                                            }
-                                                        });
-                                                    });
-                                                },
-                                                stop: (terminate) => {
-                                                    return new Promise((resolveStop, rejectStop) => {
-                                                        socket.emit(unsubChannel, { terminate }, (data, _err) => {
-                                                            if (_err) {
-                                                                rejectStop(_err);
-                                                            }
-                                                            else {
-                                                                resolveStop(data);
-                                                            }
-                                                        });
-                                                    });
-                                                }
-                                            });
-                                        }
-                                    });
-                                });
-                                const streamHandlers = {
-                                    channel,
-                                    unsubChannel,
-                                    start,
-                                };
-                                return resolve(streamHandlers);
-                            }
-                            else if (options &&
-                                (options.returnType === "noticeSubscription") &&
-                                res &&
-                                Object.keys(res).sort().join() === ["socketChannel", "socketUnsubChannel"].sort().join() &&
-                                !Object.values(res).find(v => typeof v !== "string")) {
-                                const sockInfo = res;
-                                const addListener = (listener) => {
-                                    addNoticeListener(listener, sockInfo, socket);
-                                    return {
-                                        ...sockInfo,
-                                        removeListener: () => removeNoticeListener(listener, socket)
-                                    };
-                                };
-                                const handle = {
-                                    ...sockInfo,
-                                    addListener
-                                };
-                                // @ts-ignore
-                                resolve(handle);
-                            }
-                            else if ((!options || !options.returnType || options.returnType !== "statement") &&
-                                res &&
-                                Object.keys(res).sort().join() === ["socketChannel", "socketUnsubChannel", "notifChannel"].sort().join() &&
-                                !Object.values(res).find(v => typeof v !== "string")) {
-                                const sockInfo = res;
-                                const addListener = (listener) => {
-                                    addNotifListener(listener, sockInfo, socket);
-                                    return {
-                                        ...res,
-                                        removeListener: () => removeNotifListener(listener, sockInfo, socket)
-                                    };
-                                };
-                                const handle = { ...res, addListener };
-                                resolve(handle);
-                            }
-                            else {
-                                resolve(res);
-                            }
-                        }
-                    });
-                });
-            };
-        };
-    }
-}
-exports.SQL = SQL;