@alepha/react 0.6.2 → 0.6.3

package/dist/index.js

@@ -1,325 +1,80 @@
-import { $logger, $inject, Alepha, t, $hook, autoInject } from '@alepha/core';
-import { ServerCookieProvider, $cookie, $route, BadRequestError, ServerProvider, ServerLinksProvider, ServerModule } from '@alepha/server';
-import { $ as $auth, R as Router, a as $page, A as Auth, P as PageDescriptorProvider } from './useAuth-Ps01oe8e.js';
-export { L as Link, N as NestedView, l as ReactBrowserProvider, m as RedirectionError, b as RouterContext, d as RouterHookApi, c as RouterLayerContext, p as pageDescriptorKey, j as useActive, k as useAuth, e as useClient, u as useInject, f as useQueryParams, g as useRouter, h as useRouterEvents, i as useRouterState } from './useAuth-Ps01oe8e.js';
-import { discovery, allowInsecureRequests, refreshTokenGrant, randomPKCECodeVerifier, calculatePKCECodeChallenge, buildAuthorizationUrl, authorizationCodeGrant, buildEndSessionUrl } from 'openid-client';
+import { t, $logger, $inject, Alepha, $hook, __bind } from '@alepha/core';
+import { ServerRouterProvider, ServerLinksProvider, ServerModule } from '@alepha/server';
+import { P as PageDescriptorProvider, $ as $page } from './useActive-dAmCT31a.js';
+export { L as Link, N as NestedView, k as ReactBrowserProvider, i as RedirectionError, R as RouterContext, b as RouterHookApi, a as RouterLayerContext, j as isPageRoute, h as useActive, c as useClient, u as useInject, d as useQueryParams, e as useRouter, f as useRouterEvents, g as useRouterState } from './useActive-dAmCT31a.js';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { load } from 'cheerio';
+import { ServerStaticProvider } from '@alepha/server-static';
 import { renderToString } from 'react-dom/server';
 import 'react/jsx-runtime';
 import 'react';
 import 'react-dom/client';
-import 'path-to-regexp';
+import '@alepha/router';
 
-class ReactAuthProvider {
-  log = $logger();
-  alepha = $inject(Alepha);
-  serverCookieProvider = $inject(ServerCookieProvider);
-  authProviders = [];
-  authorizationCode = $cookie({
-    name: "authorizationCode",
-    ttl: { minutes: 15 },
-    httpOnly: true,
-    schema: t.object({
-      codeVerifier: t.optional(t.string({ size: "long" })),
-      redirectUri: t.optional(t.string({ size: "long" }))
-    })
-  });
-  tokens = $cookie({
-    name: "tokens",
-    ttl: { days: 1 },
-    httpOnly: true,
-    compress: true,
-    schema: t.object({
-      access_token: t.optional(t.string({ size: "rich" })),
-      expires_in: t.optional(t.number()),
-      refresh_token: t.optional(t.string({ size: "rich" })),
-      id_token: t.optional(t.string({ size: "rich" })),
-      scope: t.optional(t.string()),
-      issued_at: t.optional(t.number())
-    })
-  });
-  user = $cookie({
-    name: "user",
-    ttl: { days: 1 },
-    schema: t.object({
-      id: t.string(),
-      name: t.optional(t.string()),
-      email: t.optional(t.string())
-    })
-  });
-  configure = $hook({
-    name: "configure",
-    handler: async () => {
-      const auths = this.alepha.getDescriptorValues($auth);
-      for (const { value, key, instance } of auths) {
-        const options = value.options;
-        if (options.oidc) {
-          this.log.debug(
-            `Discover OIDC auth provider -> ${options.oidc.issuer}`
-          );
-          const client = await discovery(
-            new URL(options.oidc.issuer),
-            options.oidc.clientId,
-            {
-              client_secret: options.oidc.clientSecret
-            },
-            void 0,
-            {
-              execute: [allowInsecureRequests]
-            }
-          );
-          instance[key].jwks = () => {
-            return client.serverMetadata().jwks_uri;
-          };
-          this.authProviders.push({
-            name: options.name ?? key,
-            redirectUri: options.oidc.redirectUri ?? "/api/_oauth/callback",
-            client
-          });
-        }
-      }
-    }
-  });
-  /**
-   * Configure Fastify to forward Session Access Token to Header Authorization.
-   */
-  onRequest = $hook({
-    name: "server:onRequest",
-    after: this.serverCookieProvider,
-    handler: async ({ request }) => {
-      if (request.cookies && !this.isViteFile(request.url.pathname) && !!this.authProviders.length) {
-        const tokens = await this.refresh(request.cookies);
-        if (tokens) {
-          request.headers.rep("authorization", `Bearer ${tokens.access_token}`);
-        }
-        if (this.user.get(request.cookies) && !this.tokens.get(request.cookies)) {
-          this.user.del(request.cookies);
-        }
-      }
-    }
-  });
-  /**
-   *
-   * @param cookies
-   * @protected
-   */
-  async refresh(cookies) {
-    const now = Date.now();
-    const tokens = this.tokens.get(cookies);
-    if (!tokens) {
-      return;
-    }
-    if (tokens.expires_in && tokens.issued_at) {
-      const expiresAt = tokens.issued_at + (tokens.expires_in - 10) * 1e3;
-      if (expiresAt < now) {
-        if (tokens.refresh_token) {
-          try {
-            const newTokens = await refreshTokenGrant(
-              this.authProviders[0].client,
-              tokens.refresh_token
-            );
-            this.tokens.set(cookies, {
-              ...newTokens,
-              issued_at: Date.now()
-            });
-            return newTokens;
-          } catch (e) {
-            if (e instanceof Error) {
-              this.log.warn("Failed to refresh token", e.message);
-            }
-          }
-        }
-        this.tokens.del(cookies);
-        this.user.del(cookies);
-        return;
-      }
-    }
-    if (!tokens.issued_at && tokens.access_token) {
-      this.tokens.del(cookies);
-      this.user.del(cookies);
-      return;
-    }
-    return tokens;
-  }
-  /**
-   *
-   */
-  login = $route({
-    security: false,
-    internal: true,
-    url: "/_oauth/login",
-    group: "auth",
-    method: "GET",
-    schema: {
-      query: t.object({
-        redirect: t.optional(t.string()),
-        provider: t.optional(t.string())
-      })
-    },
-    handler: async ({ query, cookies, url }) => {
-      const { client, redirectUri } = this.provider(query.provider);
-      const codeVerifier = randomPKCECodeVerifier();
-      const codeChallenge = await calculatePKCECodeChallenge(codeVerifier);
-      const scope = "openid profile email";
-      let redirect_uri = redirectUri;
-      if (redirect_uri.startsWith("/")) {
-        redirect_uri = `${url.protocol}//${url.host}${redirect_uri}`;
-      }
-      const parameters = {
-        redirect_uri,
-        scope,
-        code_challenge: codeChallenge,
-        code_challenge_method: "S256"
-      };
-      this.authorizationCode.set(cookies, {
-        codeVerifier,
-        redirectUri: query.redirect ?? "/"
-      });
-      return new Response("", {
-        status: 302,
-        headers: {
-          Location: buildAuthorizationUrl(client, parameters).toString()
-        }
-      });
-    }
-  });
-  /**
-   *
-   */
-  callback = $route({
-    security: false,
-    internal: true,
-    url: "/_oauth/callback",
-    group: "auth",
-    method: "GET",
-    schema: {
-      query: t.object({
-        provider: t.optional(t.string())
-      })
-    },
-    handler: async ({ url, cookies, query }) => {
-      const { client } = this.provider(query.provider);
-      const authorizationCode = this.authorizationCode.get(cookies);
-      if (!authorizationCode) {
-        throw new BadRequestError("Missing code verifier");
-      }
-      const tokens = await authorizationCodeGrant(client, url, {
-        pkceCodeVerifier: authorizationCode.codeVerifier
-      });
-      this.authorizationCode.del(cookies);
-      this.tokens.set(cookies, {
-        ...tokens,
-        issued_at: Date.now()
-      });
-      const user = this.userFromAccessToken(tokens.access_token);
-      if (user) {
-        this.user.set(cookies, user);
-      }
-      return Response.redirect(authorizationCode.redirectUri ?? "/");
+class ServerHeadProvider {
+  renderHead(template, head) {
+    let result = template;
+    const htmlAttributes = head.htmlAttributes;
+    if (htmlAttributes) {
+      result = result.replace(
+        /<html([^>]*)>/i,
+        (_, existingAttrs) => `<html${this.mergeAttributes(existingAttrs, htmlAttributes)}>`
+      );
     }
-  });
-  /**
-   *
-   * @param accessToken
-   * @protected
-   */
-  userFromAccessToken(accessToken) {
-    try {
-      const parts = accessToken.split(".");
-      if (parts.length !== 3) {
-        return;
-      }
-      const payload = parts[1];
-      const decoded = JSON.parse(atob(payload));
-      if (!decoded.sub) {
-        return;
-      }
-      return {
-        id: decoded.sub,
-        name: decoded.name,
-        email: decoded.email
-        // organization
-        // ...
-      };
-    } catch (e) {
-      this.log.warn(e, "Failed to decode access token");
+    const bodyAttributes = head.bodyAttributes;
+    if (bodyAttributes) {
+      result = result.replace(
+        /<body([^>]*)>/i,
+        (_, existingAttrs) => `<body${this.mergeAttributes(existingAttrs, bodyAttributes)}>`
+      );
     }
-  }
-  /**
-   *
-   */
-  logout = $route({
-    security: false,
-    internal: true,
-    url: "/_oauth/logout",
-    group: "auth",
-    method: "GET",
-    schema: {
-      query: t.object({
-        redirect: t.optional(t.string()),
-        provider: t.optional(t.string())
-      })
-    },
-    handler: async ({ query, cookies }) => {
-      const { client } = this.provider(query.provider);
-      const tokens = this.tokens.get(cookies);
-      const idToken = tokens?.id_token;
-      const redirect = query.redirect ?? "/";
-      const params = new URLSearchParams();
-      params.set("post_logout_redirect_uri", redirect);
-      if (idToken) {
-        params.set("id_token_hint", idToken);
+    let headContent = "";
+    const title = head.title;
+    if (title) {
+      if (template.includes("<title>")) {
+        result = result.replace(
+          /<title>(.*?)<\/title>/i,
+          () => `<title>${this.escapeHtml(title)}</title>`
+        );
+      } else {
+        headContent += `<title>${this.escapeHtml(title)}</title>
+`;
       }
-      this.tokens.del(cookies);
-      this.user.del(cookies);
-      return Response.redirect(buildEndSessionUrl(client, params).toString());
     }
-  });
-  /**
-   *
-   * @param name
-   * @protected
-   */
-  provider(name) {
-    if (!name) {
-      const client = this.authProviders[0];
-      if (!client) {
-        throw new BadRequestError("Client name is required");
+    if (head.meta) {
+      for (const meta of head.meta) {
+        headContent += `<meta name="${this.escapeHtml(meta.name)}" content="${this.escapeHtml(meta.content)}">
+`;
       }
-      return client;
     }
-    const authProvider = this.authProviders.find(
-      (provider) => provider.name === name
+    result = result.replace(
+      /<head([^>]*)>(.*?)<\/head>/is,
+      (_, existingAttrs, existingHead) => `<head${existingAttrs}>${existingHead}${headContent}</head>`
     );
-    if (!authProvider) {
-      throw new BadRequestError(`Client ${name} not found`);
-    }
-    return authProvider;
+    return result.trim();
   }
-  /**
-   *
-   * @param file
-   * @protected
-   */
-  isViteFile(file) {
-    const [pathname] = file.split("?");
-    if (pathname.startsWith("/docs")) {
-      return false;
-    }
-    if (pathname.match(/\.\w{2,5}$/)) {
-      return true;
-    }
-    if (pathname.startsWith("/@")) {
-      return true;
+  mergeAttributes(existing, attrs) {
+    const existingAttrs = this.parseAttributes(existing);
+    const merged = { ...existingAttrs, ...attrs };
+    return Object.entries(merged).map(([k, v]) => ` ${k}="${this.escapeHtml(v)}"`).join("");
+  }
+  parseAttributes(attrStr) {
+    const attrs = {};
+    const attrRegex = /([^\s=]+)(?:="([^"]*)")?/g;
+    let match = attrRegex.exec(attrStr);
+    while (match) {
+      attrs[match[1]] = match[2] ?? "";
+      match = attrRegex.exec(attrStr);
     }
-    return false;
+    return attrs;
+  }
+  escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
   }
 }
 
-const envSchema$1 = t.object({
+const envSchema = t.object({
   REACT_SERVER_DIST: t.string({ default: "client" }),
   REACT_SERVER_PREFIX: t.string({ default: "" }),
   REACT_SSR_ENABLED: t.boolean({ default: false }),
@@ -328,256 +83,197 @@ const envSchema$1 = t.object({
 class ReactServerProvider {
   log = $logger();
   alepha = $inject(Alepha);
-  router = $inject(Router);
-  serverProvider = $inject(ServerProvider);
-  env = $inject(envSchema$1);
+  pageDescriptorProvider = $inject(PageDescriptorProvider);
+  serverStaticProvider = $inject(ServerStaticProvider);
+  serverRouterProvider = $inject(ServerRouterProvider);
+  headProvider = $inject(ServerHeadProvider);
+  env = $inject(envSchema);
+  ROOT_DIV_REGEX = new RegExp(
+    `<div([^>]*)\\s+id=["']${this.env.REACT_ROOT_ID}["']([^>]*)>(.*?)<\\/div>`,
+    "is"
+  );
   configure = $hook({
     name: "configure",
     handler: async () => {
-      await this.configureRoutes();
-    }
-  });
-  id = Math.random().toString(36).substring(2, 7);
-  async configureRoutes() {
-    this.alepha.state("ReactServerProvider.ssr", false);
-    if (this.alepha.isTest()) {
-      this.processDescriptors();
-    }
-    if (this.router.empty()) {
-      return;
-    }
-    if (process.env.VITE_ALEPHA_DEV === "true") {
-      const url = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}`;
-      this.log.info("SSR (vite) OK");
-      this.alepha.state("ReactServerProvider.ssr", true);
-      const templateUrl = `${url}/index.html`;
-      const route2 = this.createHandler(
-        () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0)
-      );
-      await this.serverProvider.route(route2);
-      await this.serverProvider.route({
-        ...route2,
-        url: "*"
-      });
-      return;
-    }
-    let root = "";
-    if (!this.alepha.isServerless()) {
-      const maybe = [
-        join(process.cwd(), this.env.REACT_SERVER_DIST),
-        join(process.cwd(), "..", this.env.REACT_SERVER_DIST)
-      ];
-      for (const it of maybe) {
-        if (existsSync(it)) {
-          root = it;
-          break;
+      const pages = this.alepha.getDescriptorValues($page);
+      if (pages.length === 0) {
+        return;
+      }
+      for (const { key, instance, value } of pages) {
+        const name = value.options.name ?? key;
+        if (this.alepha.isTest()) {
+          instance[key].render = this.createRenderFunction(name);
         }
       }
-      if (!root) {
-        this.log.warn("Missing static files, SSR will be disabled");
+      if (this.alepha.isServerless() === "vite") {
+        await this.configureVite();
         return;
       }
-      await this.serverProvider.serve(this.createStaticHandler(root));
-    }
-    const template = this.alepha.state("ReactServerProvider.template") ?? await readFile(join(root, "index.html"), "utf-8");
-    const route = this.createHandler(async () => template);
-    await this.serverProvider.route(route);
-    await this.serverProvider.route({
-      ...route,
-      url: "*"
-    });
-    this.alepha.state("ReactServerProvider.ssr", true);
-  }
-  /**
-   *
-   * @param root
-   * @protected
-   */
-  createStaticHandler(root) {
-    return {
-      root,
-      prefix: this.env.REACT_SERVER_PREFIX,
-      logLevel: "warn",
-      cacheControl: true,
-      immutable: true,
-      preCompressed: true,
-      maxAge: "30d",
-      index: false
-    };
-  }
-  /**
-   *
-   * @param templateLoader
-   * @protected
-   */
-  createHandler(templateLoader) {
-    return {
-      method: "GET",
-      url: "/",
-      handler: async (ctx) => {
-        const template = await templateLoader();
-        if (!template) {
-          return new Response("Not found", { status: 404 });
-        }
-        const response = this.notFoundHandler(ctx.url);
-        if (response) {
-          return response;
+      let root = "";
+      if (!this.alepha.isServerless()) {
+        root = this.getPublicDirectory();
+        if (!root) {
+          this.log.warn("Missing static files, SSR will be disabled");
+          return;
         }
-        return await this.ssr(ctx.url, template, ctx);
+        await this.configureStaticServer(root);
       }
-    };
-  }
-  /**
-   *
-   * @protected
-   */
-  processDescriptors() {
-    const pages = this.alepha.getDescriptorValues($page);
-    for (const { key, instance, value } of pages) {
-      instance[key].render = async (options = {}) => {
-        const name = value.options.name ?? key;
-        const page = this.router.page(name);
-        const layers = await this.router.createLayers(
-          "",
-          page,
-          options.params ?? {},
-          options.query ?? {},
-          []
-        );
-        return renderToString(
-          this.router.root({
-            layers,
-            pathname: "",
-            search: "",
-            context: {}
-          })
-        );
-      };
+      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);
     }
-  }
-  /**
-   *
-   * @param url
-   * @protected
-   */
-  notFoundHandler(url) {
-    if (url.pathname.match(/\.\w+$/)) {
-      return new Response("Not found", { status: 404 });
+  });
+  async registerPages(templateLoader) {
+    for (const page of this.pageDescriptorProvider.getPages()) {
+      this.log.debug(`+ ${page.match} -> ${page.name}`);
+      await this.serverRouterProvider.route({
+        method: "GET",
+        path: page.match,
+        handler: this.createHandler(page, templateLoader)
+      });
     }
   }
-  /**
-   *
-   * @param url
-   * @param template
-   * @param args
-   */
-  async ssr(url, template, args = {}) {
-    const hasAuth = this.alepha.has(ReactAuthProvider);
-    if (!args.user && args.cookies && hasAuth) {
-      const auth = this.alepha.get(ReactAuthProvider);
-      args.user = auth.user.get(args.cookies);
-      if (args.user) {
-        args.user.roles = [];
+  getPublicDirectory() {
+    const maybe = [
+      join(process.cwd(), this.env.REACT_SERVER_DIST),
+      join(process.cwd(), "..", this.env.REACT_SERVER_DIST)
+    ];
+    for (const it of maybe) {
+      if (existsSync(it)) {
+        return it;
       }
     }
-    if (this.alepha.has(ServerLinksProvider) && hasAuth) {
-      const srv = this.alepha.get(ServerLinksProvider);
-      args.links = await srv.links();
-      this.alepha.als.set("links", args.links);
-    }
-    const { element, layers, redirect, context } = await this.router.render(
-      url.pathname + url.search,
-      {
-        args
-      }
+    return "";
+  }
+  async configureStaticServer(root) {
+    await this.serverStaticProvider.serve({
+      root,
+      path: this.env.REACT_SERVER_PREFIX
+    });
+  }
+  async configureVite() {
+    const url = `http://${process.env.SERVER_HOST}:${process.env.SERVER_PORT}`;
+    this.log.info("SSR (vite) OK");
+    this.alepha.state("ReactServerProvider.ssr", true);
+    const templateUrl = `${url}/index.html`;
+    await this.registerPages(
+      () => fetch(templateUrl).then((it) => it.text()).catch(() => void 0)
     );
-    if (redirect) {
-      return new Response("", {
-        status: 302,
-        headers: {
-          Location: redirect
-        }
+  }
+  createRenderFunction(name) {
+    return async (options = {}) => {
+      const page = this.pageDescriptorProvider.page(name);
+      const state = await this.pageDescriptorProvider.createLayers(page, {
+        url: new URL("http://localhost"),
+        params: options.params ?? {},
+        query: options.query ?? {},
+        head: {}
       });
-    }
-    const html = renderToString(element);
-    const $ = load(template);
-    const script = `<script>window.__ssr=${JSON.stringify({
-      links: args.links,
-      layers: 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 body = $("body");
-    const root = body.find(`#${this.env.REACT_ROOT_ID}`);
-    if (root.length) {
-      root.html(html);
-    } else {
-      body.prepend(`<div id="${this.env.REACT_ROOT_ID}">${html}</div>`);
-    }
-    body.append(script);
-    if (context.head) {
-      this.renderHeadContext($, context.head);
-    }
-    return new Response($.html(), {
-      headers: { "Content-Type": "text/html" }
-    });
+      return renderToString(this.pageDescriptorProvider.root(state));
+    };
   }
-  renderHeadContext($, headContext) {
-    const head = $("head");
-    if (head) {
-      if (headContext.title) {
-        head.find("title").remove();
-        head.append(`<title>${headContext.title}</title>`);
+  createHandler(page, templateLoader) {
+    return async (serverRequest) => {
+      const { url, reply, query, params } = serverRequest;
+      const template = await templateLoader();
+      if (!template) {
+        throw new Error("Template not found");
       }
-      if (headContext.meta) {
-        for (const it of headContext.meta) {
-          const meta = head.find(`meta[name="${it.name}"]`);
-          if (meta.length) {
-            meta.attr("content", it.content);
-          } else {
-            head.append(`<meta name="${it.name}" content="${it.content}" />`);
-          }
+      const request = {
+        url,
+        params,
+        query,
+        head: {}
+      };
+      if (this.alepha.has(ServerLinksProvider)) {
+        const srv = this.alepha.get(ServerLinksProvider);
+        request.links = await srv.links();
+        this.alepha.als.set("links", request.links);
+      }
+      await this.alepha.run(
+        "react:server:render",
+        {
+          request: serverRequest,
+          pageRequest: request
+        },
+        {
+          log: false
         }
+      );
+      const state = await this.pageDescriptorProvider.createLayers(
+        page,
+        request
+      );
+      if (state.redirect) {
+        return reply.redirect(state.redirect);
       }
-    }
-    if (headContext.htmlAttributes) {
-      for (const [key, value] of Object.entries(headContext.htmlAttributes)) {
-        $("html").attr(key, value);
+      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 (headContext.bodyAttributes) {
-      for (const [key, value] of Object.entries(headContext.bodyAttributes)) {
-        $("body").attr(key, value);
+      return response.html;
+    };
+  }
+  fillTemplate(response, app, script) {
+    if (this.ROOT_DIV_REGEX.test(response.html)) {
+      response.html = response.html.replace(
+        this.ROOT_DIV_REGEX,
+        (_match, beforeId, afterId) => {
+          return `<div${beforeId} id="${this.env.REACT_ROOT_ID}"${afterId}>${app}</div>`;
+        }
+      );
+    } else {
+      const bodyOpenTag = /<body([^>]*)>/i;
+      if (bodyOpenTag.test(response.html)) {
+        response.html = response.html.replace(bodyOpenTag, (match) => {
+          return `${match}
+<div id="${this.env.REACT_ROOT_ID}">${app}</div>`;
+        });
       }
     }
+    const bodyCloseTagRegex = /<\/body>/i;
+    if (bodyCloseTagRegex.test(response.html)) {
+      response.html = response.html.replace(
+        bodyCloseTagRegex,
+        `${script}
+</body>`
+      );
+    }
   }
 }
 
-const envSchema = t.object({
-  REACT_AUTH_ENABLED: t.boolean({ default: false })
-});
 class ReactModule {
-  env = $inject(envSchema);
   alepha = $inject(Alepha);
   constructor() {
     this.alepha.with(ServerModule).with(ServerLinksProvider).with(PageDescriptorProvider).with(ReactServerProvider);
-    if (this.env.REACT_AUTH_ENABLED) {
-      this.alepha.with(ReactAuthProvider);
-      this.alepha.with(Auth);
-    }
   }
 }
-autoInject($page, ReactModule);
-autoInject($auth, ReactAuthProvider, Auth);
+__bind($page, ReactModule);
 
-export { $auth, $page, Auth, PageDescriptorProvider, ReactAuthProvider, ReactModule, ReactServerProvider, Router, envSchema$1 as envSchema };
+export { $page, PageDescriptorProvider, ReactModule, ReactServerProvider, envSchema };