prostgles-client 4.0.165 → 4.0.167

package/lib/prostgles.ts

@@ -11,7 +11,6 @@ import type {
   DBSchema,
   DBSchemaTable,
   DbJoinMaker,
-  DeleteParams,
   EqualityFilter,
   FullFilter,
   GetSelectReturnType,
@@ -20,10 +19,7 @@ import type {
   SQLResult,
   SelectParams,
   SubscribeParams,
-  SubscriptionChannels,
-  SubscriptionHandler,
   TableHandler,
-  UpdateParams,
   ViewHandler
 } from "prostgles-types";
 
@@ -40,7 +36,9 @@ import { type AuthHandler, setupAuth } from "./Auth";
 import { FunctionQueuer } from "./FunctionQueuer";
 import { isEqual, useFetch, useSubscribe, useSync } from "./react-hooks";
 import { SQL } from "./SQL";
+import { getSubscriptionHandler } from "./subscriptionHandler";
 import type { DbTableSync, Sync, SyncDataItem, SyncOne, SyncOneOptions, SyncOptions, SyncedTable } from "./SyncedTable/SyncedTable";
+import { getSyncHandler } from "./syncHandler";
 
 const DEBUG_KEY = "DEBUG_SYNCEDTABLE";
 export const hasWnd = typeof window !== "undefined";
@@ -51,9 +49,8 @@ export const debug: any = function (...args: any[]) {
 };
 
 export { MethodHandler, SQLResult, asName };
-
-  export * from "./react-hooks";
-  export * from "./useProstglesClient";
+export * from "./react-hooks";
+export * from "./useProstglesClient";
 
 
 export type ViewHandlerClient<T extends AnyObject = AnyObject, S extends DBSchema | void = void> = ViewHandler<T, S> & {
@@ -148,11 +145,17 @@ type DebugEvent =
   command: keyof TableHandlerClient;
   tableName: string;
   data: AnyObject;
-} | {
+} 
+| {
   type: "method";
   command: string;
   data: AnyObject;
-} | SyncDebugEvent;
+} 
+| SyncDebugEvent
+| {
+  type: "schemaChanged";
+  data: AnyObject;
+};
 
 export type InitOptions<DBSchema = void> = {
   socket: any;
@@ -178,28 +181,15 @@ export type InitOptions<DBSchema = void> = {
   onDebug?: (event: DebugEvent) => any;
 }
 
-type AnyFunction = (...args: any[]) => any;
+export type AnyFunction = (...args: any[]) => any;
 
-type CoreParams = {
+export type CoreParams = {
   tableName: string;
   command: string;
   param1?: AnyObject;
   param2?: AnyObject;
 };
 
-type Subscription = CoreParams & {
-  lastData: any;
-  onCall: AnyFunction,
-  handlers: AnyFunction[];
-  errorHandlers: (AnyFunction | undefined)[];
-  unsubChannel: string;
-  destroy: () => any;
-};
-
-type Subscriptions = {
-  [key: string]: Subscription
-};
-
 export type onUpdatesParams = { data: object[]; isSynced: boolean }
 
 export type SyncInfo = {
@@ -207,14 +197,6 @@ export type SyncInfo = {
   synced_field: string,
   channelName: string
 }
-type SyncConfig = CoreParams & {
-  onCall: AnyFunction,
-  syncInfo: SyncInfo;
-  triggers: ClientSyncHandles[]
-};
-type Syncs = {
-  [channelName: string]: SyncConfig;
-};
 type CurrentClientSchema = { 
   origin: "onReady" | "onReconnect"; 
   date: Date; 
@@ -234,317 +216,15 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
   }
 
   const preffix = CHANNELS._preffix;
-  const subscriptions: Subscriptions = {};
 
-  let syncedTables: Record<string, any> = {};
 
-  let syncs: Syncs = {};
-  let state: undefined | "connected" | "disconnected" | "reconnected";
-  const sql = new SQL()
-
-  const destroySyncs = async () => {
-    debug("destroySyncs", { subscriptions, syncedTables });
-    await Promise.all(Object.values(subscriptions).map(s => s.destroy()));
-    syncs = {};
-    Object.values(syncedTables).map((s: any) => {
-      if (s && s.destroy) s.destroy();
-    });
-    syncedTables = {};
-  }
-
-  function _unsubscribe(channelName: string, unsubChannel: string, handler: AnyFunction, onDebug: InitOptions["onDebug"]) {
-    debug("_unsubscribe", { channelName, handler });
-
-    return new Promise((resolve, reject) => {
-      const sub = subscriptions[channelName];
-      if (sub) {
-        sub.handlers = sub.handlers.filter(h => h !== handler);
-        if (!sub.handlers.length) {
-          onDebug?.({ type: "table", command: "unsubscribe", tableName: sub.tableName });
-          socket.emit(unsubChannel, {}, (err: any, _res: any) => {
-            if (err) console.error(err);
-            else reject(err);
-          });
-          socket.removeListener(channelName, sub.onCall);
-          delete subscriptions[channelName];
-
-          /* Not waiting for server confirmation to speed things up */
-          resolve(true)
-        } else {
-          onDebug?.({ type: "table", command: "unsubscribe", tableName: sub.tableName, unsubChannel });
-          resolve(true)
-        }
-      } else {
-        resolve(true)
-      }
-    });
-  }
+  //@ts-ignore
+  const subscriptionHandler = getSubscriptionHandler(initOpts);
+  const syncHandler = getSyncHandler(initOpts);
 
-  function _unsync(channelName: string, triggers: ClientSyncHandles) {
-    debug("_unsync", { channelName, triggers })
-    return new Promise((resolve, reject) => {
-      if (syncs[channelName]) {
-        syncs[channelName]!.triggers = syncs[channelName]!.triggers.filter(tr => (
-          tr.onPullRequest !== triggers.onPullRequest &&
-          tr.onSyncRequest !== triggers.onSyncRequest &&
-          tr.onUpdates !== triggers.onUpdates
-        ));
-
-        if (!syncs[channelName]!.triggers.length) {
-          socket.emit(channelName + "unsync", {}, (err: any, res: any) => {
-            if (err) reject(err);
-            else resolve(res);
-          });
-          socket.removeListener(channelName, syncs[channelName]!.onCall);
-          delete syncs[channelName];
-        }
-      }
-    });
-  }
-  function addServerSync({ tableName, command, param1, param2 }: CoreParams, onSyncRequest: ClientSyncHandles["onSyncRequest"]): Promise<SyncInfo> {
-    return new Promise((resolve, reject) => {
-      socket.emit(preffix, { tableName, command, param1, param2 }, (err: any, res: SyncInfo) => {
-        if (err) {
-          console.error(err);
-          reject(err);
-        } else if (res as any) {
-          const { id_fields, synced_field, channelName } = res;
-
-          socket.emit(channelName, { onSyncRequest: onSyncRequest({}) }, (response: any) => {
-            console.log(response);
-          });
-          resolve({ id_fields, synced_field, channelName });
-        }
-      });
-    });
-  }
-  /**
-   * Obtaines subscribe channel from server
-   */
-  function addServerSub({ tableName, command, param1, param2 }: CoreParams): Promise<SubscriptionChannels> {
-    return new Promise((resolve, reject) => {
-      socket.emit(preffix, { tableName, command, param1, param2 }, (err?: any, res?: SubscriptionChannels) => {
-        if (err) {
-          console.error(err);
-          reject(err);
-        } else if (res) {
-          resolve(res);
-        }
-      });
-    });
-  }
-
-  const addSyncQueuer = new FunctionQueuer(_addSync, ([{ tableName }]) => tableName);
-  async function addSync(params: CoreParams, triggers: ClientSyncHandles): Promise<any> {
-    return addSyncQueuer.run([params, triggers])
-  }
-  async function _addSync({ tableName, command, param1, param2 }: CoreParams, triggers: ClientSyncHandles): Promise<any> {
-    const { onSyncRequest } = triggers;
-
-    function makeHandler(channelName: string) {
-      const unsync = function () {
-        _unsync(channelName, triggers);
-      }
-
-      const syncData: DbTableSync["syncData"] = function (data, deleted, cb) {
-        socket.emit(channelName,
-          {
-            onSyncRequest: {
-              ...onSyncRequest({}),
-              ...({ data }),
-              ...({ deleted })
-            },
-          },
-          !cb ? null : (response?: any) => {
-            cb(response)
-          }
-        );
-      }
-
-      return Object.freeze({ unsync, syncData });
-    }
-
-    const existingChannel = Object.keys(syncs).find(ch => {
-      const s = syncs[ch];
-      return (
-        s &&
-        s.tableName === tableName &&
-        s.command === command &&
-        isEqual(s.param1, param1) &&
-        isEqual(s.param2, param2) 
-      );
-    });
-
-    if (existingChannel) {
-      syncs[existingChannel]!.triggers.push(triggers);
-      return makeHandler(existingChannel);
-    } else {
-      const sync_info = await addServerSync({ tableName, command, param1, param2 }, onSyncRequest);
-      const { channelName } = sync_info;
-      const onCall = function (data: any | undefined, cb: AnyFunction) {
-        /*               
-            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;
-
-        if (!syncs[channelName]) return;
-
-        syncs[channelName]!.triggers.map(({ onUpdates, onSyncRequest, onPullRequest }) => {
-          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(arr => {
-                cb({ data: arr });
-              })
-              .catch(err => {
-                cb({ err });
-              })
-          } else {
-            console.log("unexpected response")
-          }
-        })
-
-
-      }
-      syncs[channelName] = {
-        tableName,
-        command,
-        param1,
-        param2,
-        triggers: [triggers],
-        syncInfo: sync_info,
-        onCall
-      }
-
-      socket.on(channelName, onCall);
-      return makeHandler(channelName);
-    }
-
-  }
-
-  /**
-   * Can be used concurrently
-   */
-  const addSubQueuer = new FunctionQueuer(_addSub, ([_, { tableName }]) => tableName);
-  async function addSub(dbo: any, params: CoreParams, onChange: AnyFunction, _onError?: AnyFunction): Promise<SubscriptionHandler> { 
-    return addSubQueuer.run([dbo, params, onChange, _onError]);
-  }
-
-  /**
-   * Do NOT use concurrently
-   */
-  async function _addSub(dbo: any, { tableName, command, param1, param2 }: CoreParams, onChange: AnyFunction, _onError?: AnyFunction): Promise<SubscriptionHandler> {
-
-    function makeHandler(channelName: string, unsubChannel: string) {
-
-      const unsubscribe = function () {
-        return _unsubscribe(channelName, unsubChannel, onChange, onDebug);
-      }
-      let res: any = { unsubscribe, filter: { ...param1 } }
-      /* Some dbo sorting was done to make sure this will work */
-      if (dbo[tableName].update) {
-        res = {
-          ...res,
-          update: function (newData: AnyObject, updateParams: UpdateParams) {
-            return dbo[tableName].update(param1, newData, updateParams);
-          }
-        }
-      }
-      if (dbo[tableName].delete) {
-        res = {
-          ...res,
-          delete: function (deleteParams: DeleteParams) {
-            return dbo[tableName].delete(param1, deleteParams);
-          }
-        }
-      }
-      return Object.freeze(res);
-    }
-
-    const existing = Object.entries(subscriptions).find(([ch, s]) => {
-      return (
-        s.tableName === tableName &&
-        s.command === command &&
-        JSON.stringify(s.param1 || {}) === JSON.stringify(param1 || {}) &&
-        JSON.stringify(s.param2 || {}) === JSON.stringify(param2 || {})
-      );
-    });
-
-    if (existing) {
-      const existingCh = existing[0];
-      existing[1].handlers.push(onChange);
-      existing[1].errorHandlers.push(_onError);
-      setTimeout(() => {
-        if (subscriptions[existingCh]?.lastData) {
-          onChange(subscriptions[existingCh]?.lastData)
-        }
-      }, 10)
-      return makeHandler(existingCh, existing[1].unsubChannel);
-    }
+  let state: undefined | "connected" | "disconnected" | "reconnected";
+  const sql = new SQL();
 
-    const { channelName, channelNameReady, channelNameUnsubscribe } = await addServerSub({ tableName, command, param1, param2 })
-
-    const onCall = function (data: any) {
-      /* TO DO: confirm receiving data or server will unsubscribe */
-      // if(cb) cb(true);
-      const sub = subscriptions[channelName];
-      if (sub) {
-        if (data.data) {
-          sub.lastData = data.data;
-          sub.handlers.forEach(h => {
-            h(data.data);
-          });
-        } else if (data.err) {
-          sub.errorHandlers.forEach(h => {
-            h?.(data.err);
-          });
-        } else {
-          console.error("INTERNAL ERROR: Unexpected data format from subscription: ", data)
-        }
-      } else {
-        console.warn("Orphaned subscription: ", channelName)
-      }
-    }
-    const onError = _onError || function (err: any) { console.error(`Uncaught error within running subscription \n ${channelName}`, err) }
-
-    socket.on(channelName, onCall);
-    subscriptions[channelName] = {
-      lastData: undefined,
-      tableName,
-      command,
-      param1,
-      param2,
-      onCall,
-      unsubChannel: channelNameUnsubscribe,
-      handlers: [onChange],
-      errorHandlers: [onError],
-      destroy: async () => {
-        for await(const h of subscriptions[channelName]?.handlers ?? []){
-          await _unsubscribe(channelName, channelNameUnsubscribe, h, onDebug);
-        }
-      }
-    }
-    socket.emit(channelNameReady, { now: Date.now() });
-    return makeHandler(channelName, channelNameUnsubscribe);
-  }
 
   return new Promise((resolve, reject) => {
 
@@ -571,12 +251,15 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
 
     /* Schema = published schema */
     socket.on(CHANNELS.SCHEMA, async ({ joinTables = [], ...clientSchema }: ClientSchema) => {
+      await onDebug?.({ type: "schemaChanged", data: clientSchema });
       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 destroySyncs();
+        await syncHandler.destroySyncs();
       }
+
       if ((state === "connected" || state === "reconnected") && onReconnect) {
         onReconnect(socket, err);
         if (err) {
@@ -656,8 +339,8 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
                 }
                 const upsertSyncTable = async (basicFilter = {}, options: SyncOptions = {}, onError) => {
                   const syncName = `${tableName}.${JSON.stringify(basicFilter)}.${JSON.stringify(omitKeys(options, ["handlesOnData"]))}`
-                  if (!syncedTables[syncName]) {
-                    syncedTables[syncName] = await syncedTable.create({ 
+                  if (!syncHandler.syncedTables[syncName]) {
+                    syncHandler.syncedTables[syncName] = await syncedTable.create({ 
                       ...options, 
                       onDebug: onDebug as any, 
                       name: tableName, 
@@ -666,7 +349,7 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
                       onError 
                     });
                   }
-                  return syncedTables[syncName]
+                  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 } });
@@ -690,13 +373,13 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
 
               dboTable._sync = async function (param1, param2, syncHandles) {
                 await onDebug?.({ type: "table", command: "_sync", tableName, data: { param1, param2, syncHandles } });
-                return addSync({ tableName, command, 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 addSub(dbo, { tableName, command, param1, param2 }, onChange, onError);
+                return subscriptionHandler.addSub(dbo, { tableName, command, param1, param2 }, onChange, onError);
               };
               dboTable[command] = subFunc;
               const SUBONE = "subscribeOne";
@@ -716,7 +399,7 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
                   checkSubscriptionArgs(param1, param2, onChange, onError);
 
                   const onChangeOne = (rows) => { onChange(rows[0]) };
-                  return addSub(dbo, { tableName, command, param1, param2 }, onChangeOne, onError);
+                  return subscriptionHandler.addSub(dbo, { tableName, command, param1, param2 }, onChangeOne, onError);
                 };
               }
             } else {
@@ -753,28 +436,8 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
           })
       });
 
-
-      // Re-attach listeners
-      Object.entries(subscriptions).forEach(async ([ch, s]) => {
-        try {
-          await addServerSub(s);
-          socket.on(ch, s.onCall);
-        } catch (err) {
-          console.error("There was an issue reconnecting old subscriptions", err)
-        }
-      });
-      Object.entries(syncs).forEach(async ([ch, s]) => {
-        const firstTrigger = s.triggers[0];
-        if(firstTrigger){
-          try { 
-            await addServerSync(s, firstTrigger.onSyncRequest);
-            socket.on(ch, s.onCall);
-          } catch (err) {
-            console.error("There was an issue reconnecting olf subscriptions", err)
-          }
-        }
-      });
-
+      await subscriptionHandler.reAttachAll();
+      await syncHandler.reAttachAll();
 
       joinTables.flat().map(table => {
         dbo.innerJoin ??= {};