prostgles-client 4.0.76 → 4.0.78

package/lib/prostgles.ts

@@ -5,26 +5,42 @@
  *--------------------------------------------------------------------------------------------*/
 
 import {
-  TableHandler, DbJoinMaker,
-  CHANNELS, DBNotifConfig,
-  DBNoticeConfig, AnyObject, SubscriptionHandler,
-  SQLHandler, DBEventHandles, AuthGuardLocation, DBSchemaTable,
-  AuthGuardLocationResponse, MethodHandler, ClientSyncHandles, UpdateParams, DeleteParams, ClientSchema, SQLResult, DBSchema, ViewHandler,
-  asName, 
-  SubscriptionChannels,
+  AnyObject,
+  AuthGuardLocation,
+  AuthGuardLocationResponse,
+  CHANNELS,
+  ClientSchema,
+  ClientSyncHandles,
+  DBEventHandles,
+  DBNoticeConfig,
+  DBNotifConfig,
+  DBSchema,
+  DBSchemaTable,
+  DbJoinMaker,
+  DeleteParams,
+  EqualityFilter,
   FullFilter,
-  SubscribeParams,
-  OnError,
   GetSelectReturnType,
-  getKeys,
-  getJoinHandlers,
+  MethodHandler,
+  OnError,
+  SQLHandler,
+  SQLResult,
+  SelectParams,
   SocketSQLStreamClient,
   SocketSQLStreamServer,
-  SelectParams
+  SubscribeParams,
+  SubscriptionChannels,
+  SubscriptionHandler,
+  TableHandler,
+  UpdateParams,
+  ViewHandler,
+  asName,
+  getJoinHandlers,
+  getKeys
 } from "prostgles-types";
 
-import { SyncedTable, type DbTableSync, type Sync, type SyncOne } from "./SyncedTable";
-import { getReact, useAsyncEffectQueue, useIsMounted, usePromise, useSubscribe } from "./react-hooks";
+import { SyncDataItem, SyncOptions, SyncedTable, type DbTableSync, type Sync, type SyncOne, SyncOneOptions } from "./SyncedTable";
+import { getReact, useAsyncEffectQueue, useIsMounted, usePromise, useSubscribe, useSubscribeV2, useSync } from "./react-hooks";
 
 const DEBUG_KEY = "DEBUG_SYNCEDTABLE";
 const hasWnd = typeof window !== "undefined";
@@ -36,7 +52,7 @@ export const debug: any = function (...args: any[]) {
 
 export { MethodHandler, SQLResult, asName };
 
-export * from "./react-hooks";
+  export * from "./react-hooks";
 
 type OnReadyParams<DBSchema> = {
   dbo: DBHandlerClient<DBSchema>;
@@ -45,7 +61,8 @@ type OnReadyParams<DBSchema> = {
   auth: Auth | undefined;
   isReconnect: boolean;
 }
-export const useProstglesClient = <DBSchema>(initOpts: InitOptions<DBSchema>): undefined | OnReadyParams<DBSchema> => {
+type HookInitOpts = Omit<InitOptions<DBSchema>, "onReady"> & Pick<Partial<InitOptions<DBSchema>>, "onReady">;
+export const useProstglesClient = <DBSchema>(initOpts: HookInitOpts): undefined | OnReadyParams<DBSchema> => {
   const React = getReact(true);
   const [onReadyArgs, setOnReadyArgs] = React.useState<undefined | OnReadyParams<DBSchema>>();
   const getIsMounted = useIsMounted();
@@ -72,7 +89,23 @@ export type ViewHandlerClient<T extends AnyObject = AnyObject, S extends DBSchem
   _syncInfo?: any;
   getSync?: any;
   sync?: Sync<T>;
+  useSync?: (
+    basicFilter: EqualityFilter<T>, 
+    syncOptions: SyncOptions, 
+  ) => { 
+    data: undefined | SyncDataItem<Required<T>>[];
+    isLoading: boolean;
+    error?: any;
+  };
   syncOne?: SyncOne<T>;
+  useSyncOne?: (
+    basicFilter: EqualityFilter<T>, 
+    syncOptions: SyncOneOptions, 
+  ) => {
+    data: undefined | SyncDataItem<Required<T>>;
+    isLoading: boolean;
+    error?: any;
+  };
   _sync?: any;
   /**
    * Will return undefined while loading
@@ -90,6 +123,28 @@ export type ViewHandlerClient<T extends AnyObject = AnyObject, S extends DBSchem
     options?: SubParams, 
     onError?: OnError
   ) => GetSelectReturnType<S, SubParams, T, false> | undefined;
+  /**
+   * Will return undefined while loading
+   */
+  useSubscribeV2: <SubParams extends SubscribeParams<T, S>>(
+    filter?: FullFilter<T, S>, 
+    options?: SubParams, 
+  ) => {
+    data: GetSelectReturnType<S, SubParams, T, false>[] | undefined;
+    error?: any;
+    isLoading: boolean;
+  }
+  /**
+   * Will return undefined while loading
+   */
+  useSubscribeOneV2: <SubParams extends SubscribeParams<T, S>>(
+    filter?: FullFilter<T, S>, 
+    options?: SubParams, 
+  ) => {
+    data: GetSelectReturnType<S, SubParams, T, false> | undefined;
+    error?: any;
+    isLoading: boolean;
+  };
   useFind: <P extends SelectParams<T, S>>(filter?: FullFilter<T, S>, selectParams?: P) => undefined | GetSelectReturnType<S, P, T, true>;
   useFindOne: <P extends SelectParams<T, S>>(filter?: FullFilter<T, S>, selectParams?: P) => undefined | GetSelectReturnType<S, P, T, false>;
   useCount: <P extends SelectParams<T, S>>(filter?: FullFilter<T, S>, selectParams?: P) => number | undefined;
@@ -108,7 +163,6 @@ export type TableHandlerClient<T extends AnyObject = AnyObject, S extends DBSche
   _sync?: any;
 }
 
-
 export type DBHandlerClient<Schema = void> = (Schema extends DBSchema ? {
   [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true ?
     ViewHandlerClient<Schema[tov_name]["columns"], Schema> :
@@ -872,18 +926,21 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
                   }
                   return syncedTables[syncName]
                 }
-                dboTable.sync = async (basicFilter, options = { handlesOnData: true, select: "*" }, onChange, onError) => {
+                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 upsertSTable(basicFilter, options, onError);
                   return await s.sync(onChange, options.handlesOnData);
                 }
-                dboTable.syncOne = async (basicFilter, options = { handlesOnData: true }, onChange, onError) => {
+                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 upsertSTable(basicFilter, options, onError);
                   return await s.syncOne(basicFilter, onChange, options.handlesOnData);
                 }
+                dboTable.sync = sync;
+                dboTable.syncOne = syncOne;
+                dboTable.useSync = (basicFilter, options) => useSync(dboTable.sync!, basicFilter, options) as any;
               }
 
               dboTable._sync = async function (param1, param2, syncHandles) {
@@ -914,6 +971,7 @@ export function prostgles<DBSchema>(initOpts: InitOptions<DBSchema>, syncedTable
               const handlerName = command === "subscribe" ? "useSubscribe" : command === "subscribeOne"? "useSubscribeOne" : undefined;
               if(handlerName){
                 dboTable[handlerName] = (...args) => useSubscribe(startHook(...args) as any)
+                dboTable[handlerName + "v2"] = (filter, options) => useSubscribeV2(subFunc, filter, options)
               }
 
               if (command === SUBONE || !sub_commands.includes(SUBONE)) {

package/lib/react-hooks.ts

@@ -1,4 +1,5 @@
-import { SubscriptionHandler, getKeys, isObject } from "prostgles-types";
+import { AnyObject, SubscriptionHandler, getKeys, isObject } from "prostgles-types";
+import { TableHandlerClient } from "./prostgles";
 let React: typeof import("react") | undefined;
 
 
@@ -14,12 +15,12 @@ export const getReact = (throwError?: boolean): typeof import("react") => {
   return React as any;
 };
 getReact();
-const { useEffect = alertNoReact, useCallback = alertNoReact, useRef = alertNoReactT, useState = alertNoReactT } = React ?? {};
+const { useEffect = alertNoReact, useCallback = alertNoReact, useRef, useState = alertNoReactT } = React! ?? {};
 
 export const isEqual = function (x, y) {
   if (x === y) {
     return true;
-
+    
   } else if ((typeof x == "object" && x != null) && (typeof y == "object" && y != null)) {
     if (Object.keys(x).length != Object.keys(y).length){
       return false;
@@ -106,7 +107,7 @@ export const useAsyncEffectQueue = (effect: () => Promise<void | (() => void)>,
     }
   }
   const cleanupActiveEffect = async () => {
-    await queue.current.activeEffect.resolvedCleanup.run?.();
+    await queue.current.activeEffect?.resolvedCleanup?.run?.();
     queue.current.activeEffect = undefined;
     runAsyncEffect(queue)
   }
@@ -233,6 +234,63 @@ export const useSubscribe = <SubHook extends ReturnType<SubHooks>>(
   return data;
 }
 
+type HookResult = 
+| { data: any; error?: undefined; isLoading: false; } 
+| { data?: undefined; error: any; isLoading: false; }
+| { data?: undefined; error?: undefined; isLoading: true; };
+
+export const useSubscribeV2 = (
+  subFunc: (filter: any, options: any, onData: any, onError: any) => Promise<SubscriptionHandler>,
+  filter: any,
+  options: any
+) => {
+  const [{ data, error, isLoading }, setResult] = useState<HookResult>({ data: undefined, error: undefined, isLoading: true });
+
+  const getIsMounted = useIsMounted();
+  useAsyncEffectQueue(async () => {
+    const sub = await subFunc(
+      filter,
+      options,
+      newData => {
+        if (!getIsMounted()) return;
+        setResult({ data: newData, error: undefined });
+      }, 
+      newError => {
+        if (!getIsMounted()) return;
+        setResult({ data: undefined, error: newError });
+      }
+    );
+
+    return sub.unsubscribe;
+  }, [subFunc, filter, options]);
+
+  return { data, error, isLoading };
+}
+
+export const useSync = (
+  sync: Required<TableHandlerClient>["sync"] | Required<TableHandlerClient>["syncOne"], 
+  basicFilter: Parameters<Required<TableHandlerClient>["sync"]>[0],
+  syncOptions: Parameters<Required<TableHandlerClient>["sync"]>[1],
+) => {
+  const [{ data, error, isLoading }, setResult] = useState<HookResult>({ data: undefined, error: undefined, isLoading: true });
+  const getIsMounted = useIsMounted();
+  useAsyncEffectQueue(async () => {
+    const syncHandlers = await sync(
+      basicFilter, 
+      syncOptions, 
+      newData => {
+        if (!getIsMounted()) return;
+        setResult({ data: newData, error: undefined, isLoading: false });
+      }, 
+      newError => {
+        if (!getIsMounted()) return;
+        setResult({ data: undefined, error: newError, isLoading: false });
+      }
+    );
+    return syncHandlers.$unsync();
+  }, [sync, basicFilter, syncOptions]);
+  return { data, error, isLoading };
+}
 
 export const __prglReactInstalled = () => Boolean(React && useRef);
 

package/lib/typeTests.ts

@@ -1,5 +1,5 @@
-import { AnyObject, DBSchema, FullFilter, Select, TableHandler } from "prostgles-types";
-import { DBHandlerClient, TableHandlerClient } from "./prostgles";
+import { AnyObject, FullFilter, TableHandler } from "prostgles-types";
+import { DBHandlerClient, useProstglesClient } from "./prostgles";
 
 (async () => {
   // const schema: DBSchema = {
@@ -16,6 +16,8 @@ import { DBHandlerClient, TableHandlerClient } from "./prostgles";
     }
   };
   
+  const client = useProstglesClient<GeneratedSchema>({ socket: 1 as any })
+  const t1 = client?.dbo.table1.useFind({ }, { orderBy: { col1: 1 } });
   const dbo: DBHandlerClient<GeneratedSchema> = 1 as any;
   
   const filter: FullFilter<GeneratedSchema["table1"]["columns"], GeneratedSchema> = {  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-client",
-  "version": "4.0.76",
+  "version": "4.0.78",
   "description": "Reactive client for Postgres",
   "main": "dist/prostgles-full.js",
   "types": "dist/prostgles-full.d.ts",
@@ -28,7 +28,7 @@
     "pushpublish": "npm version patch --git-tag-version false && git push && npm publish"
   },
   "dependencies": {
-    "prostgles-types": "^4.0.71"
+    "prostgles-types": "^4.0.72"
   },
   "devDependencies": {
     "@types/node": "^14.14.14",

package/tests/package-lock.json

@@ -17,10 +17,10 @@
     },
     "..": {
       "name": "prostgles-client",
-      "version": "4.0.75",
+      "version": "4.0.77",
       "license": "MIT",
       "dependencies": {
-        "prostgles-types": "^4.0.71"
+        "prostgles-types": "^4.0.72"
       },
       "devDependencies": {
         "@types/node": "^14.14.14",