@alepha/react 0.14.4 → 0.15.0

package/dist/websocket/index.d.ts

@@ -2,54 +2,53 @@ import { ChannelPrimitive, TWSObject } from "alepha/websocket";
 import { Static } from "alepha";
 
 //#region ../../src/websocket/hooks/useRoom.d.ts
-
 /**
  * UseRoom options
  */
 interface UseRoomOptions<TClient extends TWSObject, TServer extends TWSObject> {
   /**
-   * Room ID to connect to
-   */
+       * Room ID to connect to
+       */
   roomId: string;
   /**
-   * Channel primitive defining the schemas
-   */
+       * Channel primitive defining the schemas
+       */
   channel: ChannelPrimitive<TClient, TServer>;
   /**
-   * Handler for incoming messages from the server
-   */
+       * Handler for incoming messages from the server
+       */
   handler: (message: Static<TClient>) => void;
   /**
-   * Optional WebSocket URL override
-   * Defaults to auto-detected URL based on window.location
-   */
+       * Optional WebSocket URL override
+       * Defaults to auto-detected URL based on window.location
+       */
   url?: string;
   /**
-   * Enable automatic reconnection on disconnect
-   * @default true
-   */
+       * Enable automatic reconnection on disconnect
+       * @default true
+       */
   autoReconnect?: boolean;
   /**
-   * Reconnection interval in milliseconds
-   * @default 3000
-   */
+       * Reconnection interval in milliseconds
+       * @default 3000
+       */
   reconnectInterval?: number;
   /**
-   * Maximum reconnection attempts (-1 for infinite)
-   * @default 10
-   */
+       * Maximum reconnection attempts (-1 for infinite)
+       * @default 10
+       */
   maxReconnectAttempts?: number;
   /**
-   * Called when connection is established
-   */
+       * Called when connection is established
+       */
   onConnect?: () => void;
   /**
-   * Called when connection is closed
-   */
+       * Called when connection is closed
+       */
   onDisconnect?: () => void;
   /**
-   * Called on connection error
-   */
+       * Called on connection error
+       */
   onError?: (error: Error) => void;
 }
 /**
@@ -57,32 +56,32 @@ interface UseRoomOptions<TClient extends TWSObject, TServer extends TWSObject> {
  */
 interface UseRoomReturn<TServer extends TWSObject> {
   /**
-   * Send a message to the server
-   */
+       * Send a message to the server
+       */
   send: (message: Static<TServer>) => Promise<void>;
   /**
-   * Whether the connection is established
-   */
+       * Whether the connection is established
+       */
   isConnected: boolean;
   /**
-   * Whether the connection is in progress
-   */
+       * Whether the connection is in progress
+       */
   isConnecting: boolean;
   /**
-   * Whether there was an error
-   */
+       * Whether there was an error
+       */
   isError: boolean;
   /**
-   * The error object if any
-   */
+       * The error object if any
+       */
   error?: Error;
   /**
-   * Manually reconnect
-   */
+       * Manually reconnect
+       */
   reconnect: () => void;
   /**
-   * Manually disconnect
-   */
+       * Manually disconnect
+       */
   disconnect: () => void;
 }
 /**

package/dist/websocket/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/websocket/hooks/useRoom.tsx"],"sourcesContent":[],"mappings":";;;;;;;AASA;AACkB,UADD,cACC,CAAA,gBAAA,SAAA,EAAA,gBACA,SADA,CAAA,CAAA;EACA;;;EAUP,MAAA,EAAA,MAAA;EAKiB;;;EAuCH,OAAA,EA5Cd,gBA4Cc,CA5CG,OA4CH,EA5CY,OA4CZ,CAAA;EAMR;;;EAIC,OAAA,EAAA,CAAA,OAAA,EAjDG,MAiDH,CAjDU,OAiDV,CAAA,EAAA,GAAA,IAAA;EAAoB;;;AA4DtC;EAAwC,GAAA,CAAA,EAAA,MAAA;EAA2B;;;;EAGlD,aAAA,CAAA,EAAA,OAAA;EAAd;;;;;;;;;;;;;;;;;;;;;oBAzEiB;;;;;UAMH,8BAA8B;;;;kBAI7B,OAAO,aAAa;;;;;;;;;;;;;;;;UAoB5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCG,0BAA2B,2BAA2B,oBACxD,eAAe,SAAS,8BAEhC,cAAc"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/websocket/hooks/useRoom.tsx"],"mappings":";;;;;AASA;;UAAiB,cAAA,iBACC,SAAA,kBACA,SAAA;EAAA;;;EAAA,MAAA;EAAA;;;EAAA,OAAA,EAUP,gBAAA,CAAiB,OAAA,EAAS,OAAA;EAAA;;;EAAA,OAAA,GAAA,OAAA,EAKhB,MAAA,CAAO,OAAA;EAAA;;;;EAAA,GAAA;EAAA;;;;EAAA,aAAA;EAAA;;;;EAAA,iBAAA;EAAA;;;;EAAA,oBAAA;EAAA;;;EAAA,SAAA;EAAA;;;EAAA,YAAA;EAAA;;;EAAA,OAAA,IAAA,KAAA,EAuCR,KAAA;AAAA;AAAA;;AAMpB;AANoB,UAMH,aAAA,iBAA8B,SAAA;EAAA;;;EAAA,IAAA,GAAA,OAAA,EAI7B,MAAA,CAAO,OAAA,MAAa,OAAA;EAAA;;;EAAA,WAAA;EAAA;;;EAAA,YAAA;EAAA;;;EAAA,OAAA;EAAA;;;EAAA,KAAA,GAoB5B,KAAA;EAAA;;AAwCV;EAxCU,SAAA;EAAA;;AAwCV;EAxCU,UAAA;AAAA;AAAA;;AAwCV;;;;;;;;;;;;;;;;;;;;;;;;;AAxCU,cAwCG,OAAA,mBAA2B,SAAA,kBAA2B,SAAA,EAAA,OAAA,EACxD,cAAA,CAAe,OAAA,EAAS,OAAA,GAAA,IAAA,gBAEhC,aAAA,CAAc,OAAA"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@alepha/react",
   "description": "React components and hooks for building Alepha applications.",
   "author": "Nicolas Foures",
-  "version": "0.14.4",
+  "version": "0.15.0",
   "type": "module",
   "engines": {
     "node": ">=22.0.0"
@@ -25,14 +25,14 @@
     "@testing-library/react": "^16.3.1",
     "@types/react": "^19",
     "@types/react-dom": "^19",
-    "alepha": "0.14.4",
+    "alepha": "0.15.0",
     "jsdom": "^27.4.0",
     "react": "^19.2.3",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.17"
   },
   "peerDependencies": {
-    "alepha": "0.14.4",
+    "alepha": "0.15.0",
     "react": "^19"
   },
   "scripts": {

package/src/auth/__tests__/$auth.spec.ts

@@ -1,10 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { Alepha } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
-import { $realm } from "alepha/security";
-import { HttpClient, ServerProvider } from "alepha/server";
+import { $issuer, AlephaSecurity } from "alepha/security";
+import { AlephaServer, HttpClient, ServerProvider } from "alepha/server";
 import { $client } from "alepha/server/links";
-import { AlephaServerSecurity } from "alepha/server/security";
 import { describe, test } from "vitest";
 import {
   $auth,
@@ -25,7 +24,7 @@ describe("$auth", () => {
     };
 
     class App {
-      realm = $realm({
+      issuer = $issuer({
         secret: "my-secret-key",
         roles: [
           {
@@ -36,7 +35,7 @@ describe("$auth", () => {
       });
 
       auth = $auth({
-        realm: this.realm,
+        issuer: this.issuer,
         credentials: {
           account: () => user,
         },
@@ -94,7 +93,7 @@ describe("$auth", () => {
         );
 
     test("should login with credentials", async ({ expect }) => {
-      const alepha = Alepha.create().with(App).with(AlephaServerSecurity);
+      const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity).with(App);
       const auth = alepha.inject(ReactAuth);
       await alepha.start();
 
@@ -113,7 +112,7 @@ describe("$auth", () => {
     });
 
     test("should get userinfo", async ({ expect }) => {
-      const alepha = Alepha.create().with(App).with(AlephaServerSecurity);
+      const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity).with(App);
       await alepha.start();
 
       const { data: tokens } = await login(alepha);
@@ -134,7 +133,7 @@ describe("$auth", () => {
     });
 
     test("should reject expired token", async ({ expect }) => {
-      const alepha = Alepha.create().with(App);
+      const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity).with(App);
       await alepha.start();
 
       const { data: tokens } = await login(alepha);
@@ -150,7 +149,7 @@ describe("$auth", () => {
     });
 
     test("should refresh expired token", async ({ expect }) => {
-      const alepha = Alepha.create().with(App);
+      const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity).with(App);
       await alepha.start();
 
       const { data: tokens } = await login(alepha);
@@ -174,7 +173,7 @@ describe("$auth", () => {
     });
 
     test("should reject expired refresh token", async ({ expect }) => {
-      const alepha = Alepha.create().with(App);
+      const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity).with(App);
       await alepha.start();
 
       const { data: tokens } = await login(alepha);
@@ -182,7 +181,7 @@ describe("$auth", () => {
       await alepha.inject(DateTimeProvider).travel(40, "days");
 
       await expect(refresh(alepha, tokens)).rejects.toThrowError(
-        "Failed to refresh access token using the refresh token (realm)",
+        "Failed to refresh access token using the refresh token (issuer)",
       );
     });
 });

package/src/router/providers/ReactServerProvider.ts

@@ -67,10 +67,6 @@ export class ReactServerProvider {
 
       this.alepha.store.set("alepha.react.server.ssr", ssrEnabled);
 
-      if (ssrEnabled) {
-        this.log.info("SSR streaming enabled");
-      }
-
       // development mode
       if (this.alepha.isViteDev()) {
         await this.configureVite(ssrEnabled);
@@ -338,9 +334,9 @@ export class ReactServerProvider {
           const result = await this.renderPage(route, state);
 
           if (result.redirect) {
-            // Note: redirect happens after early head is sent, handled by stream
-            reply.redirect(result.redirect);
-            return null;
+            // Return redirect URL - template provider will inject meta refresh
+            // since HTTP headers have already been sent
+            return { redirect: result.redirect };
           }
 
           return { state, reactStream: result.reactStream! };
@@ -389,10 +385,7 @@ export class ReactServerProvider {
     state: ReactRouterState,
   ): Promise<{ redirect?: string; reactStream?: ReadableStream<Uint8Array> }> {
     // Resolve page layers (loaders)
-    this.serverTimingProvider.beginTiming("createLayers");
     const { redirect } = await this.pageApi.createLayers(route, state);
-    this.serverTimingProvider.endTiming("createLayers");
-
     if (redirect) {
       this.log.debug("Resolver resulted in redirection", { redirect });
       return { redirect };
@@ -409,7 +402,6 @@ export class ReactServerProvider {
     }
 
     // Render React to stream
-    this.serverTimingProvider.beginTiming("renderToStream");
 
     const element = this.pageApi.root(state);
     this.alepha.store.set("alepha.react.router.state", state);
@@ -426,8 +418,6 @@ export class ReactServerProvider {
       },
     });
 
-    this.serverTimingProvider.endTiming("renderToStream");
-
     return { reactStream };
   }
 

package/src/router/providers/ReactServerTemplateProvider.ts

@@ -392,26 +392,31 @@ export class ReactServerTemplateProvider {
     const { request, context, ...store } =
       this.alepha.context.als?.getStore() ?? {};
 
-    return {
-      ...store,
-      "alepha.react.router.state": undefined,
-      layers: state.layers.map((layer) => ({
-        ...layer,
-        error: layer.error
-          ? {
-              ...layer.error,
-              name: layer.error.name,
-              message: layer.error.message,
-              stack: !this.alepha.isProduction() ? layer.error.stack : undefined,
-            }
-          : undefined,
-        // Remove non-serializable properties
-        index: undefined,
-        path: undefined,
-        element: undefined,
-        route: undefined,
-      })),
-    };
+    const layers = state.layers.map((layer) => ({
+      name: layer.name,
+      props: layer.props,
+      config: layer.config,
+      error: layer.error
+        ? {
+          ...layer.error,
+          name: layer.error.name,
+          message: layer.error.message,
+          stack: !this.alepha.isProduction() ? layer.error.stack : undefined,
+        }
+        : undefined,
+    }));
+
+    const hydrationData: HydrationData = {
+      layers,
+    }
+
+    for (const [key, value] of Object.entries(store)) {
+      if (key.charAt(0) !== "_" && key !== "alepha.react.router.state" && key !== "registry") {
+        hydrationData[key] = value;
+      }
+    }
+
+    return hydrationData;
   }
 
   /**
@@ -613,17 +618,20 @@ export class ReactServerTemplateProvider {
    */
   public createEarlyHtmlStream(
     globalHead: SimpleHead,
-    asyncWork: () => Promise<{
-      state: ReactRouterState;
-      reactStream: ReadableStream<Uint8Array>;
-    } | null>,
+    asyncWork: () => Promise<
+      | {
+          state: ReactRouterState;
+          reactStream: ReadableStream<Uint8Array>;
+        }
+      | { redirect: string }
+      | null
+    >,
     options: {
       hydration?: boolean;
       onError?: (error: unknown) => void;
-      onRedirect?: (url: string) => void;
     } = {},
   ): ReadableStream<Uint8Array> {
-    const { hydration = true, onError, onRedirect } = options;
+    const { hydration = true, onError } = options;
     const slots = this.getSlots();
     const encoder = this.encoder;
 
@@ -653,9 +661,19 @@ export class ReactServerTemplateProvider {
           // === ASYNC WORK (createLayers, etc.) ===
           const result = await asyncWork();
 
-          // Handle redirect - can't undo what we've sent, but caller handles it
-          if (!result) {
-            // Redirect happened - close with minimal valid HTML
+          // Handle redirect - inject meta refresh since headers already sent
+          if (!result || "redirect" in result) {
+            if (result && "redirect" in result) {
+              this.log.debug(
+                "Loader redirect detected after streaming started, using meta refresh",
+                { redirect: result.redirect },
+              );
+              controller.enqueue(
+                encoder.encode(
+                  `<meta http-equiv="refresh" content="0; url=${this.escapeHtml(result.redirect)}">\n`,
+                ),
+              );
+            }
             controller.enqueue(slots.headClose);
             controller.enqueue(encoder.encode("<body></body></html>"));
             controller.close();