@signal-spec/react-client 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,21 +1,23 @@
 import * as SignalR from "@microsoft/signalr";
 import { HubConnection } from "@microsoft/signalr";
-//#region src/helpers/useSignalRConnectionsStore.d.ts
-export interface SignalRConnectionData {
+//#region src/helpers/useSignalRConnections.d.ts
+interface SignalRConnectionData {
   connection: SignalR.HubConnection;
   componentsSubscribed: number;
 }
 export declare function isConnectionAlive(connectionState: SignalR.HubConnectionState | null | undefined): boolean | null | undefined;
-export interface SignalRConnectionsStore {
-  backendUri: string;
-  EnableSignalRDebug: boolean;
-  connectionsStore: Map<string, SignalRConnectionData>;
+interface SignalRConnections {
   createConnection: (hubName: string) => Promise<SignalRConnectionData>;
   setupEventHandlers: <T>(hubName: string, handlers: Partial<T>, onConnected?: (connection: SignalR.HubConnection) => void) => Promise<void>;
   deleteConnection: <T>(hubName: string, handlers: Partial<T>) => void;
 }
-export declare const useSignalRConnectionsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SignalRConnectionsStore>>;
-export declare const useSignalRConnections: import("zustand").UseBoundStore<import("zustand").StoreApi<SignalRConnectionsStore>>;
+interface SignalRConfiguration {
+  backendUri: string;
+  enableDebug?: boolean;
+}
+/** Configure SignalR before mounting consumers. Backend switching is not supported. */
+export declare function configureSignalR({ backendUri, enableDebug }: SignalRConfiguration): void;
+export declare function useSignalRConnections(): SignalRConnections;
 //#endregion
 //#region src/helpers/useStableHandlers.d.ts
 /**
@@ -25,15 +27,12 @@ export declare const useSignalRConnections: import("zustand").UseBoundStore<impo
  */
 export declare function useStableHandlers<T extends Record<string, (...args: any[]) => any>>(handlers: T | undefined): T;
 //#endregion
-//#region src/generation/safeInvokeHubMethod.d.ts
-type Warning = {
-  warning: string;
-};
+//#region src/helpers/safeInvokeHubMethod.d.ts
 /**
  * Safely invokes the SignalR hub method, i.e. it will only throw in case of an actual error,
  * and will return `Warning` object in case the connection hasn't yet been established or
  * has been already closed.
  */
-export declare function safeInvokeHubMethod(connection: HubConnection | null, methodName: string, ...args: any[]): Promise<Warning | any>;
+export declare function safeInvokeHubMethod(connection: HubConnection | null, methodName: string, ...args: any[]): Promise<any>;
 //#endregion
-export {};
+export type { SignalRConfiguration, SignalRConnectionData, SignalRConnections };

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { create } from "zustand";
 import * as SignalR from "@microsoft/signalr";
 import { HubConnectionState } from "@microsoft/signalr";
 import { useLayoutEffect, useMemo, useRef } from "react";
-//#region src/helpers/useSignalRConnectionsStore.ts
+//#region src/helpers/useSignalRConnections.ts
 function isConnectionAlive(connectionState) {
 	return connectionState && connectionState !== SignalR.HubConnectionState.Disconnected && connectionState !== SignalR.HubConnectionState.Disconnecting;
 }
@@ -29,10 +29,8 @@ const useSignalRConnectionsStore = create((set, get) => ({
 	},
 	async setupEventHandlers(hubName, handlers, onConnected) {
 		let data = get().connectionsStore.get(hubName);
-		if (!data) {
-			data = await get().createConnection(hubName);
-			onConnected?.(data.connection);
-		}
+		if (!data) data = await get().createConnection(hubName);
+		onConnected?.(data.connection);
 		for (const key of Object.keys(handlers)) {
 			const handler = handlers[key];
 			if (handler !== void 0) data.connection.on(key, handler);
@@ -58,7 +56,20 @@ const useSignalRConnectionsStore = create((set, get) => ({
 		set({ connectionsStore });
 	}
 }));
-const useSignalRConnections = useSignalRConnectionsStore;
+/** Configure SignalR before mounting consumers. Backend switching is not supported. */
+function configureSignalR({ backendUri, enableDebug = false }) {
+	useSignalRConnectionsStore.setState({
+		backendUri,
+		EnableSignalRDebug: enableDebug
+	});
+}
+function useSignalRConnections() {
+	return {
+		createConnection: useSignalRConnectionsStore((state) => state.createConnection),
+		setupEventHandlers: useSignalRConnectionsStore((state) => state.setupEventHandlers),
+		deleteConnection: useSignalRConnectionsStore((state) => state.deleteConnection)
+	};
+}
 //#endregion
 //#region src/helpers/useStableHandlers.ts
 /**
@@ -81,20 +92,26 @@ function useStableHandlers(handlers) {
 	}, []);
 }
 //#endregion
-//#region src/generation/safeInvokeHubMethod.ts
+//#region src/helpers/safeInvokeHubMethod.ts
 /**
 * Safely invokes the SignalR hub method, i.e. it will only throw in case of an actual error,
 * and will return `Warning` object in case the connection hasn't yet been established or
 * has been already closed.
 */
 async function safeInvokeHubMethod(connection, methodName, ...args) {
-	if (connection?.state !== HubConnectionState.Connected) return { warning: "Skipped invocation: not connected" };
+	if (connection?.state !== HubConnectionState.Connected) {
+		console.warn("[SignalSpec] Skipped invocation: not connected");
+		return;
+	}
 	try {
 		return await connection.invoke(methodName, ...args);
 	} catch (err) {
-		if (err instanceof Error && err.message.includes("underlying connection being closed")) return { warning: "Skipped invocation: connection is being closed" };
+		if (err instanceof Error && err.message.includes("underlying connection being closed")) {
+			console.warn("[SignalSpec] Skipped invocation: connection is being closed");
+			return;
+		}
 		throw err;
 	}
 }
 //#endregion
-export { isConnectionAlive, safeInvokeHubMethod, useSignalRConnections, useSignalRConnectionsStore, useStableHandlers };
+export { configureSignalR, isConnectionAlive, safeInvokeHubMethod, useSignalRConnections, useStableHandlers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signal-spec/react-client",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A SignalR client generator for React based on the SignalSpec.",
   "repository": {
     "type": "git",
@@ -48,6 +48,6 @@
     "dev": "vp pack --watch",
     "test": "vp test",
     "check": "vp check",
-    "generate": "node ./bin/signal-spec.mjs generate"
+    "generate": "node --use-system-ca ./bin/signal-spec.mjs generate --input=https://localhost:49363/api/signal-spec.json --output=./src/result --backend-uri=https://localhost:49363"
   }
 }

package/src/generation/templates/config.hbs

@@ -1,5 +1,14 @@
-import { useSignalRConnectionsStore } from "@signal-spec/react-client";
+import { configureSignalR } from "@signal-spec/react-client";
+
+//--------------------------------------------------------------------------------------------------------------
+// <auto-generated>
+//     This file is auto-generated by "SignalSpec.ReactClient" (@signal-spec/react-client).
+//     Do not modify this file manually.
+//     If you want to adjust it, copy the template "config.hbs" and supply your edited version of it.
+// </auto-generated>
+//--------------------------------------------------------------------------------------------------------------
 
 export const backendUri = {{{backendUriLiteral}}};
 export const EnableSignalRDebug = false;
-useSignalRConnectionsStore.setState({ backendUri, EnableSignalRDebug });
+configureSignalR({ backendUri, enableDebug: EnableSignalRDebug });
+

package/src/generation/templates/dtos.hbs

@@ -1,8 +1,8 @@
 //--------------------------------------------------------------------------------------------------------------
 // <auto-generated>
-//     This file is auto-generated by "SignalSpec.ReactClient".
+//     This file is auto-generated by "SignalSpec.ReactClient" (@signal-spec/react-client).
 //     Do not modify this file manually.
-//     If you want to adjust it, copy the template and supply your edited version of it.
+//     If you want to adjust it, copy the template "dtos.hbs" and supply your edited version of it.
 // </auto-generated>
 //--------------------------------------------------------------------------------------------------------------
 

package/src/generation/templates/hubClient.hbs

@@ -1,8 +1,8 @@
-import "../config.js";
+import { backendUri } from "../config";
 import type { HubConnection } from "@microsoft/signalr";
 import { useState, useEffect } from "react";
 {{#if dtoImports}}
-import type { {{#each dtoImports}}{{this}}{{#unless @last}}, {{/unless}}{{/each}} } from "../DTOs.js";
+import type { {{#each dtoImports}}{{this}}{{#unless @last}}, {{/unless}}{{/each}} } from "../DTOs";
 {{/if}}
 import { useStableHandlers, useSignalRConnections{{#if (hasAnyBackendMethods hubContract.methods)}}, safeInvokeHubMethod{{/if}} } from "@signal-spec/react-client";
 
@@ -11,7 +11,7 @@ import { useStableHandlers, useSignalRConnections{{#if (hasAnyBackendMethods hub
 // <auto-generated>
 //     This file is auto-generated by "SignalSpec.ReactClient" (@signal-spec/react-client).
 //     Do not modify this file manually.
-//     If you want to adjust it, copy the template and supply your edited version of it.
+//     If you want to adjust it, copy the template "hubClient.hbs" and supply your edited version of it.
 // </auto-generated>
 //--------------------------------------------------------------------------------------------------------------
 
@@ -50,64 +50,61 @@ interface {{clientName}}Backend {
 
 export function use{{hubName}}(
 {{#if (hasAnyFrontendMethods hubContract.methods)}}handlers: Partial<{{clientName}}Frontend> = {},{{/if}}
-  enabled: boolean = true,
-  ): { {{#if (hasAnyBackendMethods hubContract.methods)}}invoker: {{clientName}}Backend;{{/if}} connection: HubConnection | null; } {
+    enabled: boolean = true,
+    ): { {{#if (hasAnyBackendMethods hubContract.methods)}}invoker: {{clientName}}Methods;{{/if}} connection: HubConnection | null; } {
 
-  const { setupEventHandlers, deleteConnection } = useSignalRConnections();
-  const [connection, setConnection] = useState<HubConnection | null>(
-  null,
-  );
+    const { setupEventHandlers, deleteConnection } = useSignalRConnections();
+    const [connection, setConnection] = useState<HubConnection | null>(
+    null,
+    );
 
-  const stableHandlers = useStableHandlers({{#if (hasAnyFrontendMethods hubContract.methods)}}handlers{{else}}{}{{/if}});
-  const onConnected = (connection: HubConnection) =>
-  setConnection(connection);
+    const stableHandlers = useStableHandlers(handlers);
+    const onConnected = (connection: HubConnection) =>
+    setConnection(connection);
 
-  useEffect(() => {
-  if (!enabled) return;
+    useEffect(() => {
+    if (!enabled) return;
 
-  const data = useSignalRConnections.getState().createConnection('{{hubName}}');
-  onConnected(data.connection);
-  setupEventHandlers('{{hubName}}', stableHandlers);
+    setupEventHandlers('{{hubName}}', stableHandlers, onConnected);
 
-  return () => {
-  deleteConnection('{{hubName}}', stableHandlers);
-  };
-  }, [enabled]);
-
-  {{#if (hasAnyBackendMethods hubContract.methods)}}
-    const invoker = {
-    {{#each hubContract.methods}}
-      {{#if (isBackendMethod this)}}
-        {{name}}: async (
-        {{#if parameters}}
-          {{#each parameters}}
-            {{name}}: {{safeType this}}{{#unless @last}}, {{/unless}}
-          {{/each}}
-        {{/if}}
-        ) => {
-        {{#if returns}}
-          return await safeInvokeHubMethod(connection,
-          "{{name}}"
-          {{#if parameters}}, {{/if}}
-          {{#each parameters}}
-            {{name}}{{#unless @last}}, {{/unless}}
-          {{/each}}
-          ) as {{safeType returns}};
-        {{else}}
-          await safeInvokeHubMethod(connection,
-          "{{name}}"
-          {{#if parameters}}, {{/if}}
-          {{#each parameters}}
-            {{name}}{{#unless @last}}, {{/unless}}
-          {{/each}}
-          );
-        {{/if}}
-        }{{#unless @last}},{{/unless}}
-      {{/if}}
-    {{/each}}
+    return () => {
+    deleteConnection('{{hubName}}', stableHandlers);
     };
-  {{/if}}
+    }, [backendUri, enabled]);
 
-  return { {{#if (hasAnyBackendMethods hubContract.methods)}}invoker,{{/if}} connection };
-}
+    {{#if (hasAnyBackendMethods hubContract.methods)}}
+        const invoker = {
+        {{#each hubContract.methods}}
+            {{#if (isBackendMethod this)}}
+                {{name}}: async (
+                {{#if parameters}}
+                    {{#each parameters}}
+                        {{name}}: {{safeType this}}{{#unless @last}}, {{/unless}}
+                    {{/each}}
+                {{/if}}
+                ) => {
+                {{#if returns}}
+                    return await safeInvokeHubMethod(connection,
+                    '{{name}}'
+                    {{#if parameters}}, {{/if}}
+                    {{#each parameters}}
+                        {{name}}{{#unless @last}}, {{/unless}}
+                    {{/each}}
+                    ) as {{safeType returns}};
+                {{else}}
+                    await safeInvokeHubMethod(connection,
+                    '{{name}}'
+                    {{#if parameters}}, {{/if}}
+                    {{#each parameters}}
+                        {{name}}{{#unless @last}}, {{/unless}}
+                    {{/each}}
+                    );
+                {{/if}}
+                }{{#unless @last}},{{/unless}}
+            {{/if}}
+        {{/each}}
+        };
+    {{/if}}
 
+    return { {{#if (hasAnyBackendMethods hubContract.methods)}}invoker,{{/if}} connection };
+}

package/src/generation/safeInvokeHubMethod.ts

@@ -1,27 +0,0 @@
-import { HubConnectionState, type HubConnection } from "@microsoft/signalr";
-
-type Warning = { warning: string };
-
-/**
- * Safely invokes the SignalR hub method, i.e. it will only throw in case of an actual error,
- * and will return `Warning` object in case the connection hasn't yet been established or
- * has been already closed.
- */
-export async function safeInvokeHubMethod(
-  connection: HubConnection | null,
-  methodName: string,
-  ...args: any[]
-): Promise<Warning | any> {
-  if (connection?.state !== HubConnectionState.Connected) {
-    return { warning: "Skipped invocation: not connected" };
-  }
-
-  try {
-    return await connection.invoke(methodName, ...args);
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("underlying connection being closed")) {
-      return { warning: "Skipped invocation: connection is being closed" };
-    }
-    throw err;
-  }
-}