prostgles-server 4.2.40 → 4.2.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.40",
+  "version": "4.2.41",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/client/hooks.spec.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from "assert";
 import { describe, test } from "node:test";
 import type { DBHandlerClient } from "./index";
-import { renderReactHook } from "./renderReactHook";
+import { renderReactHook, renderReactHookManual } from "./renderReactHook";
 import { AnyObject, pickKeys } from "prostgles-types";
 import { useProstglesClient } from "prostgles-client/dist/prostgles";
  
@@ -9,47 +9,6 @@ export const clientHooks = async (db: DBHandlerClient, getSocketOptions: (watchS
 
   const resultLoading = { data: undefined, isLoading: true, error: undefined };
   await describe("React hooks", async (t) => {
-    const socketOptions = getSocketOptions();
-    await test("useProstglesClient", async (t) => {
-      const { results: [res1, res2] } = await renderReactHook({
-        hook: useProstglesClient,
-        props: [{ socketOptions }],
-        expectedRerenders: 2
-      });
-      assert.deepStrictEqual(
-        res1,
-        { isLoading: true }
-      ); 
-      assert.equal(
-        typeof (res2 as any)?.dbo.items4.useFind,
-        "function"
-      );
-    });
-
-    await test("useProstglesClient with initial skip", async (t) => {
-      const { results: [res1], rerender } = await renderReactHook({
-        hook: useProstglesClient,
-        props: [{ socketOptions, skip: true }],
-        expectedRerenders: 1
-      });
-      assert.deepStrictEqual(
-        res1,
-        { isLoading: true }
-      );
-
-      const { results: [res2, res3] } = await rerender({ 
-        props: [{ socketOptions }],
-        expectedRerenders: 2, 
-      });
-      assert.deepStrictEqual(
-        res2,
-        { isLoading: true }
-      );
-      assert.equal(
-        typeof (res3 as any)?.dbo.items4.useFind,
-        "function"
-      );
-    });
 
     const defaultFilter = { name: "abc" };
     await Promise.all([

package/tests/client/package-lock.json

@@ -10,7 +10,7 @@
       "license": "ISC",
       "dependencies": {
         "@types/node": "^20.9.2",
-        "prostgles-client": "^4.0.109",
+        "prostgles-client": "^4.0.115",
         "prostgles-types": "^4.0.51",
         "socket.io-client": "^4.7.5"
       },
@@ -351,9 +351,9 @@
       }
     },
     "node_modules/prostgles-client": {
-      "version": "4.0.109",
-      "resolved": "https://registry.npmjs.org/prostgles-client/-/prostgles-client-4.0.109.tgz",
-      "integrity": "sha512-PUziWyoM3Khyv4f/MthguaVdM/zTXFjlRRetD6oaVd1S8wipJ9BWEWAoR/LsOdbZdMZGDwmY8+fcJp+IRdojnQ==",
+      "version": "4.0.115",
+      "resolved": "https://registry.npmjs.org/prostgles-client/-/prostgles-client-4.0.115.tgz",
+      "integrity": "sha512-YMnWOY352K8v++eR8Nb2Ikmi+3U0bxaFbPlsHAa1XmFhGq3UqRponUMcgYLiXjbWrvMRULSVWdYezdMTZU/a/g==",
       "dependencies": {
         "prostgles-types": "^4.0.74"
       },

package/tests/client/package.json

@@ -13,7 +13,7 @@
   "license": "ISC",
   "dependencies": {
     "@types/node": "^20.9.2",
-    "prostgles-client": "^4.0.109",
+    "prostgles-client": "^4.0.115",
     "prostgles-types": "^4.0.51",
     "socket.io-client": "^4.7.5"
   },

package/tests/client/renderReactHook.ts

@@ -19,15 +19,14 @@ global.document = window.document;
 import React from "react";
 import { createRoot } from "react-dom/client";
 
+type Hook = (...args: any[]) => any;
+
 // TODO: add  hook result types
 type RenderHookArgs = {
-	hook: (...args: any[]) => any;
+	hook: Hook;
 	props: any[];
 	onResult?: (result: any) => void;
 	expectedRerenders: number;
-	/**
-	 * Time to wait for the expected rerenders
-	 */
 	timeout?: number;
 	/**
 	 * Time to wait after the last render to resolve the promise
@@ -38,7 +37,7 @@ type RenderHookArgs = {
 
 let testedHook: Function;
 const root = createRoot(window.document.getElementById('root'));
-const reactRender = ({ hook, props, onResult, onUnmount }: Pick<Required<RenderHookArgs>, "hook" | "props" | "onResult"> & { onUnmount: ()=>void; }) => {
+const reactRender = ({ hook, props, onResult, onUnmount }: Pick<Required<RenderHookArgs>, "hook" | "props" | "onResult"> & { onUnmount: () => void; }) => {
 	const BasicComponent = ({ props }) => {
 		const result = hook(...props);
 		React.useEffect(() => {
@@ -65,6 +64,67 @@ const resetBasicComponent = () => {
 		React.createElement(OtherBasicComponent, { props: {} }, null)
 	);
 }
+type OnEnd<H extends Hook> = (results: ReturnType<H>[]) => Promise<void> | void;
+export const renderReactHookManual = async <H extends Hook>(rootArgs: {
+	hook: H;
+	initialProps: Parameters<H>;
+	onUnmount?: () => void;
+	/**
+	 * Time to wait after the last render to resolve the promise
+	 * default: 250
+	 */
+	renderDuration?: number;
+	onEnd?: OnEnd<H>;
+}): Promise<{
+	setProps: (props: Parameters<H>, opts: { waitFor?: number; onEnd?: OnEnd<H>; }) => void;
+	getResults: () => ReturnType<H>[];
+}> => {
+	const { hook, onUnmount, renderDuration = 250, onEnd } = rootArgs;
+	let lastRenderWaitTimeout: NodeJS.Timeout | null = null;
+	let didResolve = false;
+	let setProps: (props: any[]) => void;
+	resetBasicComponent();
+	return new Promise((resolve, reject) => {
+		const results = [];
+		const onRender = (result) => {
+			results.push(result);
+			if(didResolve) return;
+			clearTimeout(lastRenderWaitTimeout);
+			lastRenderWaitTimeout = setTimeout(async () => {
+	
+				if(!setProps) {
+					reject("setProps not set");
+					return;
+				}
+				await onEnd?.(results);
+				didResolve = true;
+				return resolve({
+					setProps: async (props, { waitFor = 250, onEnd } = {}) => {
+						setProps(props);
+						await tout(waitFor);
+						await onEnd?.(results);
+					},
+					getResults: () => results
+				});
+			}, renderDuration);
+		}
+		const BasicComponent = ({ props: initialProps }) => {
+			const [props, _setProps] = React.useState(initialProps);
+			setProps = _setProps;
+			const result = hook(...props);
+			React.useEffect(() => {
+				return () => {
+					onUnmount?.();
+				};
+			}, []);
+			onRender(result);
+			return React.createElement('h1', null, `Hello`);
+		}
+		root.render(
+			React.createElement(BasicComponent, { props: rootArgs.initialProps }, null)
+		);
+	});
+}
 
 export const renderReactHook = (rootArgs: RenderHookArgs): Promise<RenderResult> => {
 	const { hook, props, onResult, expectedRerenders, timeout = 5000, lastRenderWait = 250 } = rootArgs;
@@ -110,4 +170,6 @@ export const renderReactHook = (rootArgs: RenderHookArgs): Promise<RenderResult>
 			}
 		}, timeout);
 	});
-}
+}
+
+export const tout = (ms: number) => new Promise(res => setTimeout(res, ms));

package/tests/client/useProstgles.spec.ts

@@ -3,25 +3,41 @@ import { describe, test } from "node:test";
 import { useProstglesClient } from "prostgles-client/dist/prostgles";
 import { AnyObject } from "prostgles-types";
 import type { DBHandlerClient } from "./index";
-import { renderReactHook } from "./renderReactHook";
+import { renderReactHook, renderReactHookManual } from "./renderReactHook";
 
 export const useProstglesTest = async (db: DBHandlerClient, getSocketOptions: (watchSchema?: boolean) => AnyObject) => {
   await describe("useProstgles hook", async (t) => {
+    const socketOptions = getSocketOptions();
+    await test("useProstglesClient", async (t) => {
+      const { results: [res1, res2] } = await renderReactHook({
+        hook: useProstglesClient,
+        props: [{ socketOptions }],
+        expectedRerenders: 2
+      });
+      assert.deepStrictEqual(
+        res1,
+        { isLoading: true }
+      ); 
+      assert.equal(
+        typeof (res2 as any)?.dbo.items4.useFind,
+        "function"
+      );
+    });
     
+    const newTableName = "newly_created_table";
     await test("useProstglesClient with schema reload", async (t) => {
-      const newTableName = "newly_created_table";
-      await db.sql(`DROP TABLE IF EXISTS ${newTableName};`);
+      await db.sql(`DROP TABLE IF EXISTS ${newTableName}; DROP TABLE IF EXISTS will_delete;`);
       await db.sql(`select pg_sleep(1)`);
       let rerenders = 0
-      const { results: [res1, res2, res3] } = await renderReactHook({
+      const { results: [res1, res2, res3], rerender } = await renderReactHook({
         hook: useProstglesClient,
-        props: [{ socketOptions:  getSocketOptions(true) }],
+        props: [{ socketOptions: getSocketOptions(true) }],
         expectedRerenders: 3,
         onResult: () => {
           rerenders++;
           if(rerenders < 2) return;
           rerenders = -2;
-          db.sql(`CREATE TABLE ${newTableName}();`);
+          db.sql(`CREATE TABLE ${newTableName}(id integer);`);
         }
       });
       assert.deepStrictEqual(
@@ -40,6 +56,55 @@ export const useProstglesTest = async (db: DBHandlerClient, getSocketOptions: (w
         typeof (res3 as any)?.dbo[newTableName].useFind,
         "function"
       );
+
+      const count = await (res3 as any)?.dbo[newTableName].count();
+      assert.equal(count, 0);
+    });
+
+    await test("useProstglesClient with initial skip", async (t) => {
+      const { setProps } = await renderReactHookManual({
+        hook: useProstglesClient,
+        initialProps: [{ socketOptions, skip: true }],
+        onEnd: async (results) => {
+          assert.deepStrictEqual(results, [{ isLoading: true }]);
+        }
+      });
+      await setProps([{ socketOptions }], {
+        onEnd: async (results) => {
+          assert.equal(results.length, 3);
+          const [res1, res2, res3] = results;
+          assert.deepStrictEqual([res1, res2], [{ isLoading: true }, { isLoading: true }]);
+          const count = await (res3 as any)?.dbo.items4.count();
+          assert.equal(count, 0);
+
+          assert.equal(res3.isLoading, false);
+          if("error" in res3) throw res3.error;
+          assert.equal(
+            typeof res3.dbo[newTableName]?.useFind,
+            "undefined"
+          );
+        }
+      });
+
+      await setProps([{ socketOptions: getSocketOptions(true) }], {
+        onEnd: async (results) => {
+          assert.equal(results.length, 5);
+          const [res1, res2, res3, res4, res5] = results;
+          assert.equal(results.length, 5);
+          assert.equal(res5.isLoading, false);
+          if("error" in res5) throw res5.error;
+          
+          const count = await res5.dbo.items4.count();
+          assert.equal(count, 0);
+ 
+          assert.equal(
+            typeof res5.dbo[newTableName].useFind,
+            "function"
+          );
+          const count0 = await res5.dbo[newTableName].count();
+          assert.equal(count0, 0);
+        }
+      });
     });
   
   });

package/tests/server/DBoGenerated.d.ts

@@ -264,6 +264,7 @@ export type DBSchemaGenerated = {
     update: true;
     delete: true;
     columns: {
+      id?: null | number;
     };
   };
   obj_table: {
@@ -532,4 +533,5 @@ export type DBSchemaGenerated = {
       tsv?: null | string;
     };
   };
+  
 }

package/tests/server/package-lock.json

@@ -21,7 +21,7 @@
     },
     "../..": {
       "name": "prostgles-server",
-      "version": "4.2.39",
+      "version": "4.2.40",
       "license": "MIT",
       "dependencies": {
         "@types/express": "^4.17.13",