prostgles-client 4.0.174 → 4.0.176

package/lib/SyncedTable/getMultiSyncSubscription.ts

@@ -1,67 +0,0 @@
-import type { AnyObject } from "prostgles-types";
-import type { $UpdateOpts, MultiChangeListener, MultiSyncHandles, SubscriptionMulti, SyncedTable } from "./SyncedTable";
-
-type Args = {
-  onChange: MultiChangeListener<AnyObject>;
-  handlesOnData: boolean;
-}
-export function getMultiSyncSubscription(this: SyncedTable, { onChange, handlesOnData }: Args){
-
-  const handles: MultiSyncHandles<AnyObject> = {
-    $unsync: () => {
-      return this.unsubscribe(onChange)
-    },
-    getItems: () => { return this.getItems(); },
-    $upsert: (newData) => {
-      if (!(newData as any)) {
-        throw "No data provided for upsert";
-      }
-
-      const prepareOne = (d: AnyObject) => {
-        return ({
-          idObj: this.getIdObj(d),
-          delta: d
-        });
-      }
-
-      if (Array.isArray(newData)) {
-        this.upsert(newData.map(d => prepareOne(d)));
-      } else {
-        this.upsert([prepareOne(newData)]);
-      }
-    }
-  };
-
-  const sub: SubscriptionMulti<AnyObject> = {
-    _onChange: onChange,
-    handlesOnData,
-    handles,
-    notify: (_allItems, _allDeltas) => {
-      let allItems = [..._allItems];
-      const allDeltas = [..._allDeltas];
-      if (handlesOnData) {
-        allItems = allItems.map((item, i) => {
-
-          const getItem = (d: AnyObject, idObj: Partial<AnyObject>) => ({
-            ...d,
-            ...this.makeSingleSyncHandles(idObj, onChange),
-            $get: () => getItem(this.getItem(idObj).data!, idObj),
-            $find: (idObject: Partial<AnyObject>) => getItem(this.getItem(idObject).data!, idObject),
-            $update: (newData: AnyObject, opts: $UpdateOpts): Promise<boolean> => {
-              return this.upsert([{ idObj, delta: newData, opts }]).then(r => true);
-            },
-            $delete: async (): Promise<boolean> => {
-              return this.delete(idObj);
-            },
-            $cloneMultiSync: (onChange: MultiChangeListener) => this.sync(onChange, handlesOnData)
-          })
-          const idObj = this.getIdObj(item) as Partial<AnyObject>;
-          return getItem(item, idObj);
-        });
-      }
-      return onChange(allItems, allDeltas)
-    }
-  };
-
-  return { sub, handles }
-}

package/lib/getDbHandler.ts

@@ -1,152 +0,0 @@
-import { type AnyObject, CHANNELS, type ClientSchema, getKeys, isObject, omitKeys, type TableSchemaForClient } from "prostgles-types";
-import { type InitOptions, type TableHandlerClient, type AnyFunction, type DBHandlerClient, useSync, useSubscribe, useFetch } from "./prostgles";
-import type { Sync, SyncedTable, SyncOne, SyncOptions } from "./SyncedTable/SyncedTable";
-import type { getSyncHandler } from "./getSyncHandler";
-import type { getSubscriptionHandler } from "./getSubscriptionHandler";
-
-
-type Args = {
-  schema: TableSchemaForClient; 
-  onDebug: InitOptions["onDebug"];
-  socket: InitOptions["socket"];
-  joinTables: ClientSchema["joinTables"];
-  syncedTable: typeof SyncedTable | undefined;
-  syncHandler: ReturnType<typeof getSyncHandler>;
-  subscriptionHandler: ReturnType<typeof getSubscriptionHandler>;
-}
-
-const preffix = CHANNELS._preffix;
-
-export const getDBO = ({ schema, onDebug, syncedTable, syncHandler, subscriptionHandler, socket, joinTables }: Args) => {
-
-  const dbo: Partial<DBHandlerClient> = JSON.parse(JSON.stringify(schema));
-
-  /* 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);
-            }
-          }
-        }
-      })
-  });
-
-  return { dbo };
-}

package/lib/getMethods.ts

@@ -1,30 +0,0 @@
-import type { ClientSchema, MethodHandler } from "prostgles-types";
-import { CHANNELS } from "prostgles-types";
-import type { InitOptions } from "./prostgles";
-
-export const getMethods = ({ onDebug, methods, socket }: Pick<InitOptions, "onDebug" | "socket"> & Pick<ClientSchema, "methods">) => {
-
-  let methodsObj: MethodHandler = {};
-  const _methods: typeof methods = JSON.parse(JSON.stringify(methods));
-  _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
-    };
-  });
-  methodsObj = Object.freeze(methodsObj);
-
-  return { methodsObj };
-}

package/lib/getSqlHandler.ts

@@ -1,174 +0,0 @@
-import { CHANNELS, type SQLHandler, type DBEventHandles, type DBNoticeConfig, type DBNotifConfig, type SocketSQLStreamClient, type SocketSQLStreamServer } from "prostgles-types";
-import type { InitOptions } from "./prostgles";
- 
-export const getSqlHandler = ({ socket }: Pick<InitOptions, "socket">) => {
-
-  let noticeSubs: {
-    listeners: ((notice: any) => void)[];
-    config: DBNoticeConfig;
-  } | undefined;
-  const notifSubs: {
-    [key: string]: {
-      config: DBNotifConfig
-      listeners: ((notif: any) => void)[]
-    }
-  } = {};
-  const removeNotifListener = (listener: any, conf: DBNotifConfig, socket: any) => {
-    const channelSubs = 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 notifSubs[conf.notifChannel];
-      }
-    }
-  };
-  const addNotifListener = (listener: any, conf: DBNotifConfig, socket: any) => {
-    const channelSubs = notifSubs[conf.notifChannel]
-    if (!channelSubs) {
-      notifSubs[conf.notifChannel] = {
-        config: conf,
-        listeners: [listener]
-      };
-      socket.removeAllListeners(conf.socketChannel);
-      socket.on(conf.socketChannel, (notif: any) => {
-        if (notifSubs[conf.notifChannel]?.listeners.length) {
-          notifSubs[conf.notifChannel]!.listeners.map(l => {
-            l(notif);
-          })
-        } else {
-          socket.emit(notifSubs[conf.notifChannel]?.config.socketUnsubChannel, {});
-        }
-      });
-
-    } else {
-      notifSubs[conf.notifChannel]?.listeners.push(listener);
-    }
-  };
-
-
-  const removeNoticeListener = (listener: any, socket: any) => {
-    if (noticeSubs) {
-      noticeSubs.listeners = noticeSubs.listeners.filter(nl => nl !== listener);
-      if (!noticeSubs.listeners.length && noticeSubs.config.socketUnsubChannel && socket) {
-        socket.emit(noticeSubs.config.socketUnsubChannel, {});
-      }
-    }
-  }
-  const addNoticeListener = (listener: any, conf: DBNoticeConfig, socket: any) => {
-    noticeSubs ??= {
-      config: conf,
-      listeners: []
-    };
-
-    if (!noticeSubs.listeners.length) {
-      socket.removeAllListeners(conf.socketChannel);
-      socket.on(conf.socketChannel, (notice: any) => {
-        if (noticeSubs && noticeSubs.listeners.length) {
-          noticeSubs.listeners.map(l => {
-            l(notice);
-          })
-        } else {
-          socket.emit(conf.socketUnsubChannel, {});
-        }
-      });
-    }
-    noticeSubs.listeners.push(listener);
-  }
-
-  const sql: SQLHandler = function (query, params, options) {
-    return new Promise((resolve, reject) => {
-      socket.emit(CHANNELS.SQL, { query, params, options }, (err, res) => {
-        if (err) {
-          return reject(err);
-        }
-        if(options?.returnType === "stream"){
-          const { channel, unsubChannel } = res as SocketSQLStreamServer;
-          const start: SocketSQLStreamClient["start"] = (listener) => new Promise<Awaited<ReturnType<SocketSQLStreamClient["start"]>>>((resolveStart, rejectStart) => {
-            socket.on(channel, listener)
-            socket.emit(channel, {}, (pid: number, 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?: boolean) => {
-                    return new Promise((resolveStop, rejectStop) => {
-                      socket.emit(unsubChannel, { terminate }, (data, _err) => {
-                        if(_err){
-                          rejectStop(_err);
-                        } else {
-                          resolveStop(data);
-                        }
-                      });
-                    });
-                  }
-                });
-              }
-            });
-          });
-          const streamHandlers = {
-            channel,
-            unsubChannel,
-            start,
-          } satisfies SocketSQLStreamClient;
-
-          return resolve(streamHandlers as any);
-        } 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: DBNoticeConfig = res;
-          const addListener = (listener: (arg: any) => void) => {
-            addNoticeListener(listener, sockInfo, socket);
-            return {
-              ...sockInfo,
-              removeListener: () => removeNoticeListener(listener, socket)
-            }
-          };
-          const handle: DBEventHandles = {
-            ...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: DBNotifConfig = res;
-          const addListener = (listener: (arg: any) => void) => {
-            addNotifListener(listener, sockInfo, socket)
-            return {
-              ...res,
-              removeListener: () => removeNotifListener(listener, sockInfo, socket)
-            }
-          }
-          const handle: DBEventHandles = { ...res, addListener };
-          resolve(handle as any);
-
-        } else {
-          resolve(res);
-        }
-      });
-    });
-  }
-
-  return { sql };
-}

package/lib/getSubscriptionHandler.ts

@@ -1,211 +0,0 @@
-import { CHANNELS, type AnyObject, type DeleteParams, type SubscriptionChannels, type SubscriptionHandler, type UpdateParams } from "prostgles-types";
-import { debug, isEqual, type AnyFunction, type CoreParams, type InitOptions } from "./prostgles";
-import { FunctionQueuer } from "./FunctionQueuer";
-
-type Subscription = CoreParams & {
-  lastData: any;
-  onCall: AnyFunction,
-  handlers: AnyFunction[];
-  errorHandlers: (AnyFunction | undefined)[];
-  unsubChannel: string;
-  reAttach: () => Promise<void>;
-};
-
-type Subscriptions = {
-  [key: string]: Subscription
-};
-
-const preffix = CHANNELS._preffix;
-
-export const getSubscriptionHandler = (initOpts: Pick<InitOptions, "socket" | "onDebug">) => {
-  const { socket, onDebug, } = initOpts;
-
-  const subscriptions: Subscriptions = {};
-
-  const removeServerSub = (unsubChannel: string) => {
-    return new Promise((resolve, reject) => {
-      socket.emit(unsubChannel, {}, (err: any, _res: any) => {
-        if (err) {
-          console.error(err);
-          reject(err);
-        } else {
-          resolve(_res);
-        }
-      });
-    });
-  }
-
-  function _unsubscribe(channelName: string, unsubChannel: string, handler: AnyFunction): Promise<true> {
-    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 });
-          removeServerSub(unsubChannel);
-          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)
-      }
-    });
-  }
-
-
-  /**
-   * 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);
-        }
-      });
-    });
-  }
-
-
-  /**
-   * Can be used concurrently
-   */
-  const addSubQueuer = new FunctionQueuer(_addSub, ([_, { tableName }]) => tableName);
-  const addSub = async (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> {
-
-    const makeHandler = (channelName: string, unsubChannel: string) => {
-
-      const unsubscribe = function () {
-        return _unsubscribe(channelName, unsubChannel, onChange);
-      }
-
-      let subHandlers: any = { unsubscribe, filter: { ...param1 } }
-
-      /* Some dbo sorting was done to make sure this will work */
-      if (dbo[tableName].update) {
-        subHandlers = {
-          ...subHandlers,
-          update: function (newData: AnyObject, updateParams: UpdateParams) {
-            return dbo[tableName].update(param1, newData, updateParams);
-          }
-        }
-      }
-      if (dbo[tableName].delete) {
-        subHandlers = {
-          ...subHandlers,
-          delete: function (deleteParams: DeleteParams) {
-            return dbo[tableName].delete(param1, deleteParams);
-          }
-        }
-      }
-      return Object.freeze(subHandlers);
-    }
-
-    const existing = Object.entries(subscriptions).find(([ch, s]) => {
-      return (
-        s.tableName === tableName &&
-        s.command === command &&
-        isEqual(s.param1 || {}, param1 || {}) &&
-        isEqual(s.param2 || {}, 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);
-    }
-
-    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],
-      reAttach: async () => {
-        await removeServerSub(channelNameUnsubscribe).catch(console.error);
-        await addServerSub({ tableName, command, param1, param2 });
-        socket.emit(channelNameReady, { now: Date.now() });
-      }
-    }
-    socket.emit(channelNameReady, { now: Date.now() });
-    return makeHandler(channelName, channelNameUnsubscribe);
-  }
-
-  /**
-   * Reconnect all subscriptions
-   * Used when connection is lost and re-established or schema changes
-   */
-  const reAttachAll = async () => {
-    for await (const s of Object.values(subscriptions)) {
-      try {
-        await s.reAttach();
-      } catch (err) {
-        console.error("There was an issue reconnecting old subscriptions", err, s)
-        Object.values(s.errorHandlers).forEach(h => h?.(err));
-      }
-    }
-  }
-
-  return {
-    addSub,
-    subscriptions,
-    addServerSub,
-    _unsubscribe,
-    reAttachAll,
-  }
-}