@alepha/react 0.6.10 → 0.7.1

package/dist/index.js

@@ -1,9 +1,8 @@
 import { t, $logger, $inject, Alepha, $hook, OPTIONS, __bind } from '@alepha/core';
-import { ServerRouterProvider, ServerLinksProvider, ServerModule } from '@alepha/server';
-import { P as PageDescriptorProvider, $ as $page } from './useActive-ClUsghB5.js';
-export { L as Link, N as NestedView, l as ReactBrowserProvider, j as RedirectionError, R as RouterContext, b as RouterHookApi, a as RouterLayerContext, k as isPageRoute, i as useActive, d as useApi, c as useClient, u as useInject, e as useQueryParams, f as useRouter, g as useRouterEvents, h as useRouterState } from './useActive-ClUsghB5.js';
+import { ServerRouterProvider, ServerTimingProvider, ServerLinksProvider, apiLinksResponseSchema, ServerModule } from '@alepha/server';
+import { P as PageDescriptorProvider, $ as $page } from './useRouterState-qoMq7Y9J.js';
+export { C as ClientOnly, E as ErrorBoundary, L as Link, N as NestedView, l as ReactBrowserProvider, R as RedirectionError, a as RouterContext, c as RouterHookApi, b as RouterLayerContext, k as isPageRoute, u as useActive, d as useAlepha, e as useClient, f as useInject, g as useQueryParams, h as useRouter, i as useRouterEvents, j as useRouterState } from './useRouterState-qoMq7Y9J.js';
 import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ServerStaticProvider } from '@alepha/server-static';
 import { renderToString } from 'react-dom/server';
@@ -75,9 +74,9 @@ class ServerHeadProvider {
 }
 
 const envSchema = t.object({
-  REACT_SERVER_DIST: t.string({ default: "client" }),
+  REACT_SERVER_DIST: t.string({ default: "public" }),
   REACT_SERVER_PREFIX: t.string({ default: "" }),
-  REACT_SSR_ENABLED: t.boolean({ default: false }),
+  REACT_SSR_ENABLED: t.optional(t.boolean()),
   REACT_ROOT_ID: t.string({ default: "root" })
 });
 class ReactServerProvider {
@@ -87,46 +86,76 @@ class ReactServerProvider {
   serverStaticProvider = $inject(ServerStaticProvider);
   serverRouterProvider = $inject(ServerRouterProvider);
   headProvider = $inject(ServerHeadProvider);
+  serverTimingProvider = $inject(ServerTimingProvider);
   env = $inject(envSchema);
   ROOT_DIV_REGEX = new RegExp(
     `<div([^>]*)\\s+id=["']${this.env.REACT_ROOT_ID}["']([^>]*)>(.*?)<\\/div>`,
     "is"
   );
-  configure = $hook({
+  onConfigure = $hook({
     name: "configure",
     handler: async () => {
       const pages = this.alepha.getDescriptorValues($page);
-      if (pages.length === 0) {
-        return;
-      }
+      const ssrEnabled = pages.length > 0 && this.env.REACT_SSR_ENABLED !== false;
+      this.alepha.state("ReactServerProvider.ssr", ssrEnabled);
       for (const { key, instance, value } of pages) {
         const name = value[OPTIONS].name ?? key;
+        instance[key].prerender = this.createRenderFunction(name, true);
         if (this.alepha.isTest()) {
           instance[key].render = this.createRenderFunction(name);
         }
       }
       if (this.alepha.isServerless() === "vite") {
-        await this.configureVite();
+        await this.configureVite(ssrEnabled);
         return;
       }
       let root = "";
       if (!this.alepha.isServerless()) {
         root = this.getPublicDirectory();
         if (!root) {
-          this.log.warn("Missing static files, SSR will be disabled");
-          return;
+          this.log.warn(
+            "Missing static files, static file server will be disabled"
+          );
+        } else {
+          this.log.debug(`Using static files from: ${root}`);
+          await this.configureStaticServer(root);
         }
-        await this.configureStaticServer(root);
       }
-      const template = this.alepha.state("ReactServerProvider.template") ?? await readFile(join(root, "index.html"), "utf-8");
-      await this.registerPages(async () => template);
-      this.alepha.state("ReactServerProvider.ssr", true);
+      if (ssrEnabled) {
+        await this.registerPages(async () => this.template);
+        this.log.info("SSR OK");
+        return;
+      }
+      this.log.info("SSR is disabled, use History API fallback");
+      await this.serverRouterProvider.route({
+        path: "*",
+        handler: async ({ url, reply }) => {
+          if (url.pathname.includes(".")) {
+            reply.headers["content-type"] = "text/plain";
+            reply.body = "Not Found";
+            reply.status = 404;
+            return;
+          }
+          reply.headers["content-type"] = "text/html";
+          reply.status = 200;
+          return this.template;
+        }
+      });
     }
   });
+  get template() {
+    return this.alepha.state("ReactServerProvider.template");
+  }
   async registerPages(templateLoader) {
     for (const page of this.pageDescriptorProvider.getPages()) {
+      if (page.children?.length) {
+        continue;
+      }
       this.log.debug(`+ ${page.match} -> ${page.name}`);
       await this.serverRouterProvider.route({
+        ...page,
+        schema: void 0,
+        // schema is handled by the page descriptor provider for now (shared by browser and server)
         method: "GET",
         path: page.match,
         handler: this.createHandler(page, templateLoader)
@@ -135,8 +164,8 @@ class ReactServerProvider {
   }
   getPublicDirectory() {
     const maybe = [
-      join(process.cwd(), this.env.REACT_SERVER_DIST),
-      join(process.cwd(), "..", this.env.REACT_SERVER_DIST)
+      join(process.cwd(), `dist/${this.env.REACT_SERVER_DIST}`),
+      join(process.cwd(), this.env.REACT_SERVER_DIST)
     ];
     for (const it of maybe) {
       if (existsSync(it)) {
@@ -151,25 +180,46 @@ class ReactServerProvider {
       path: this.env.REACT_SERVER_PREFIX
     });
   }
-  async configureVite() {
-    const url = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}`;
+  async configureVite(ssrEnabled) {
+    if (!ssrEnabled) {
+      return;
+    }
     this.log.info("SSR (vite) OK");
-    this.alepha.state("ReactServerProvider.ssr", true);
-    const templateUrl = `${url}/index.html`;
+    const url = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}`;
     await this.registerPages(
-      () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0)
+      () => fetch(`${url}/index.html`).then((it) => it.text()).catch(() => void 0)
     );
   }
-  createRenderFunction(name) {
+  /**
+   * For testing purposes, creates a render function that can be used.
+   */
+  createRenderFunction(name, withIndex = false) {
     return async (options = {}) => {
       const page = this.pageDescriptorProvider.page(name);
-      const state = await this.pageDescriptorProvider.createLayers(page, {
-        url: new URL("http://localhost"),
+      const url = new URL(this.pageDescriptorProvider.url(name, options));
+      const context = {
+        url,
         params: options.params ?? {},
         query: options.query ?? {},
-        head: {}
-      });
-      return renderToString(this.pageDescriptorProvider.root(state));
+        head: {},
+        onError: () => null
+      };
+      const state = await this.pageDescriptorProvider.createLayers(
+        page,
+        context
+      );
+      if (!withIndex) {
+        return {
+          context,
+          html: renderToString(
+            this.pageDescriptorProvider.root(state, context)
+          )
+        };
+      }
+      return {
+        context,
+        html: this.renderToHtml(this.template ?? "", state, context)
+      };
     };
   }
   createHandler(page, templateLoader) {
@@ -179,67 +229,102 @@ class ReactServerProvider {
       if (!template) {
         throw new Error("Template not found");
       }
-      const request = {
+      const context = {
         url,
         params,
         query,
-        head: {}
+        // plugins
+        head: {},
+        onError: () => null
       };
       if (this.alepha.has(ServerLinksProvider)) {
         const srv = this.alepha.get(ServerLinksProvider);
-        request.links = await srv.links();
-        this.alepha.als.set("links", request.links);
+        const schema = apiLinksResponseSchema;
+        context.links = this.alepha.parse(
+          schema,
+          await srv.getLinks({
+            user: serverRequest.user,
+            authorization: serverRequest.headers.authorization
+          })
+        );
+        this.alepha.context.set("links", context.links);
+      }
+      let target = page;
+      while (target) {
+        if (page.can && !page.can()) {
+          reply.status = 403;
+          reply.headers["content-type"] = "text/plain";
+          return "Forbidden";
+        }
+        target = target.parent;
       }
       await this.alepha.emit(
         "react:server:render",
         {
           request: serverRequest,
-          pageRequest: request
+          pageRequest: context
         },
         {
           log: false
         }
       );
+      this.serverTimingProvider.beginTiming("createLayers");
       const state = await this.pageDescriptorProvider.createLayers(
         page,
-        request
+        context
       );
+      this.serverTimingProvider.endTiming("createLayers");
       if (state.redirect) {
         return reply.redirect(state.redirect);
       }
-      const element = this.pageDescriptorProvider.root(state, request);
-      const app = renderToString(element);
-      const script = `<script>window.__ssr=${JSON.stringify({
-        links: request.links,
-        layers: state.layers.map((it) => ({
-          ...it,
-          error: it.error ? {
-            ...it.error,
-            name: it.error.name,
-            message: it.error.message,
-            stack: it.error.stack
-            // TODO: Hide stack in production ?
-          } : void 0,
-          index: void 0,
-          path: void 0,
-          element: void 0
-        }))
-      })}<\/script>`;
-      const response = {
-        html: template
-      };
       reply.status = 200;
       reply.headers["content-type"] = "text/html";
       reply.headers["cache-control"] = "no-store, no-cache, must-revalidate, proxy-revalidate";
       reply.headers.pragma = "no-cache";
       reply.headers.expires = "0";
-      this.fillTemplate(response, app, script);
-      if (state.head) {
-        response.html = this.headProvider.renderHead(response.html, state.head);
+      if (page.cache && serverRequest.user) {
+        delete context.links;
       }
-      return response.html;
+      return this.renderToHtml(template, state, context);
     };
   }
+  renderToHtml(template, state, context) {
+    const element = this.pageDescriptorProvider.root(state, context);
+    this.serverTimingProvider.beginTiming("renderToString");
+    let app = "";
+    try {
+      app = renderToString(element);
+    } catch (error) {
+      this.log.error("Error during SSR", error);
+      app = renderToString(context.onError(error));
+    }
+    this.serverTimingProvider.endTiming("renderToString");
+    const hydrationData = {
+      links: context.links,
+      layers: state.layers.map((it) => ({
+        ...it,
+        error: it.error ? {
+          ...it.error,
+          name: it.error.name,
+          message: it.error.message,
+          stack: it.error.stack
+          // TODO: Hide stack in production ?
+        } : void 0,
+        index: void 0,
+        path: void 0,
+        element: void 0
+      }))
+    };
+    const script = `<script>window.__ssr=${JSON.stringify(hydrationData)}<\/script>`;
+    const response = {
+      html: template
+    };
+    this.fillTemplate(response, app, script);
+    if (context.head) {
+      response.html = this.headProvider.renderHead(response.html, context.head);
+    }
+    return response.html;
+  }
   fillTemplate(response, app, script) {
     if (this.ROOT_DIV_REGEX.test(response.html)) {
       response.html = response.html.replace(
@@ -277,4 +362,3 @@ class ReactModule {
 __bind($page, ReactModule);
 
 export { $page, PageDescriptorProvider, ReactModule, ReactServerProvider, envSchema };
-//# sourceMappingURL=index.js.map