akanjs 2.2.4 → 2.2.5

package/server/routeTree.test.tsx

@@ -1,198 +0,0 @@
-import type { ReactNode } from "react";
-import { renderToReadableStream } from "react-dom/server.browser";
-import { RouteElementComposer } from "./routeElementComposer";
-import { RouteTreeBuilder } from "./routeTreeBuilder";
-
-async function renderToText(node: ReactNode): Promise<string> {
-  return new Response(await renderToReadableStream(node)).text();
-}
-
-describe("RouteTreeBuilder implicit locale", () => {
-  test("matches locale-prefixed routes while keeping special routes at root", () => {
-    const routes = new RouteTreeBuilder({
-      "./__root_layout.tsx": async () => ({ default: ({ children }: { children: ReactNode }) => children }),
-      "./foo.tsx": async () => ({ default: () => null }),
-      "./robots.txt.tsx": async () => ({ default: () => null }),
-    }).build();
-
-    const matched = RouteTreeBuilder.match("/ko/foo", routes);
-    expect(matched?.params).toEqual({ lang: "ko" });
-    expect(matched?.pathRoute.path).toBe("/:lang/foo");
-    expect(matched?.pathRoute.renderRootLayouts).toHaveLength(1);
-
-    const robots = RouteTreeBuilder.match("/robots.txt", routes);
-    expect(robots?.params).toEqual({});
-    expect(robots?.pathRoute.isSpecialRoute).toBe(true);
-    expect(robots?.pathRoute.renderRootLayouts).toHaveLength(0);
-  });
-
-  test("uses the nearest route head without merging parents", async () => {
-    const prevBasePaths = process.env.AKAN_PUBLIC_BASE_PATHS;
-    process.env.AKAN_PUBLIC_BASE_PATHS = "foo";
-    try {
-      const routes = new RouteTreeBuilder({
-        "./__root_layout.tsx": async () => ({
-          default: ({ children }: { children: ReactNode }) => children,
-          head: "root",
-        }),
-        "./foo/__root_layout.tsx": async () => ({
-          default: ({ children }: { children: ReactNode }) => children,
-          head: "foo-root",
-        }),
-        "./foo/bar.tsx": async () => ({ default: () => null }),
-        "./foo/baz.tsx": async () => ({ default: () => null, head: "baz-page" }),
-      }).build();
-
-      const bar = RouteTreeBuilder.match("/ko/foo/bar", routes);
-      const baz = RouteTreeBuilder.match("/ko/foo/baz", routes);
-      expect(
-        bar &&
-          (await RouteElementComposer.resolveHead({ pathRoute: bar.pathRoute, params: bar.params, searchParams: {} })),
-      ).toBe("foo-root");
-      expect(
-        baz &&
-          (await RouteElementComposer.resolveHead({ pathRoute: baz.pathRoute, params: baz.params, searchParams: {} })),
-      ).toBe("baz-page");
-    } finally {
-      process.env.AKAN_PUBLIC_BASE_PATHS = prevBasePaths;
-    }
-  });
-
-  test("supports route groups, repeated search params, and cached lazy modules", async () => {
-    let loadCount = 0;
-    const routes = new RouteTreeBuilder({
-      "./__root_layout.tsx": async () => ({ default: ({ children }: { children: ReactNode }) => children }),
-      "./(marketing)/about.tsx": async () => {
-        loadCount += 1;
-        return { default: () => null, head: "about" };
-      },
-    }).build();
-    const matched = RouteTreeBuilder.match("/ko/about", routes);
-
-    expect(matched?.pathRoute.path).toBe("/:lang/about");
-    expect(RouteTreeBuilder.parseSearchParams("?tag=a&tag=b&sort=latest")).toEqual({
-      tag: ["a", "b"],
-      sort: "latest",
-    });
-
-    expect(
-      matched &&
-        (await RouteElementComposer.resolveHead({
-          pathRoute: matched.pathRoute,
-          params: matched.params,
-          searchParams: {},
-        })),
-    ).toBe("about");
-    expect(
-      matched &&
-        (await RouteElementComposer.resolveHead({
-          pathRoute: matched.pathRoute,
-          params: matched.params,
-          searchParams: {},
-        })),
-    ).toBe("about");
-    expect(loadCount).toBe(1);
-    expect(RouteTreeBuilder.getCacheStats()).toMatchObject({
-      moduleCount: 2,
-      loadedModuleCount: 1,
-      cacheHits: 1,
-      cacheMisses: 1,
-    });
-  });
-
-  test("rejects duplicate route patterns and unsupported page exports", () => {
-    expect(() =>
-      new RouteTreeBuilder({
-        "./users/[id].tsx": async () => ({ default: () => null }),
-        "./users/:id.tsx": async () => ({ default: () => null }),
-      }).build(),
-    ).toThrow();
-
-    const routes = new RouteTreeBuilder({
-      "./bad.tsx": async () => ({ default: () => null, loader: () => null }) as never,
-    }).build();
-    const matched = RouteTreeBuilder.match("/ko/bad", routes);
-
-    expect(
-      matched &&
-        RouteElementComposer.resolveHead({ pathRoute: matched.pathRoute, params: matched.params, searchParams: {} }),
-    ).rejects.toThrow('[route-convention] unsupported export "loader"');
-
-    const routesWithBadFallback = new RouteTreeBuilder({
-      "./bad-fallback.tsx": async () => ({ default: () => null, NotFound: () => null }) as never,
-    }).build();
-    const badFallback = RouteTreeBuilder.match("/ko/bad-fallback", routesWithBadFallback);
-    expect(
-      badFallback &&
-        RouteElementComposer.resolveHead({
-          pathRoute: badFallback.pathRoute,
-          params: badFallback.params,
-          searchParams: {},
-        }),
-    ).rejects.toThrow('[route-convention] unsupported export "NotFound"');
-  });
-
-  test("composes nearest layout NotFound and Error fallbacks", async () => {
-    const builder = new RouteTreeBuilder({
-      "./__root_layout.tsx": async () => ({
-        default: ({ children }: { children: ReactNode }) => <main>root:{children}</main>,
-        NotFound: ({ pathname }: { pathname: string }) => <p>root missing {pathname}</p>,
-      }),
-      "./docs/_layout.tsx": async () => ({
-        default: ({ children }: { children: ReactNode }) => <section>docs:{children}</section>,
-        NotFound: ({ pathname, params }: { pathname: string; params: Record<string, string> }) => (
-          <p>
-            docs missing {params.lang}:{pathname}
-          </p>
-        ),
-        Error: ({ error }: { error?: unknown }) => (
-          <p>docs error {error instanceof Error ? error.message : "unknown"}</p>
-        ),
-      }),
-      "./docs/guide.tsx": async () => ({ default: () => <article>guide</article> }),
-    });
-    const routes = builder.build();
-    const matched = RouteTreeBuilder.match("/ko/docs/guide", routes);
-    if (!matched) throw new Error("route did not match");
-
-    const notFound = await RouteElementComposer.composeFallback({
-      kind: "not-found",
-      route: matched.pathRoute,
-      params: matched.params,
-      searchParams: {},
-      pathname: "/ko/docs/guide",
-    });
-    const error = await RouteElementComposer.composeFallback({
-      kind: "error",
-      route: matched.pathRoute,
-      params: matched.params,
-      searchParams: {},
-      pathname: "/ko/docs/guide",
-      error: new Error("boom"),
-    });
-
-    const notFoundHtml = await renderToText(notFound);
-    const errorHtml = await renderToText(error);
-    expect(notFoundHtml).toContain("root:");
-    expect(notFoundHtml).toContain("docs:");
-    expect(notFoundHtml).toContain("docs missing");
-    expect(notFoundHtml).toContain("/ko/docs/guide");
-    expect(errorHtml).toContain("docs error");
-    expect(errorHtml).toContain("boom");
-
-    const unmatched = RouteTreeBuilder.matchFallback("/ko/docs/missing/path", builder.getFallbackRoutes());
-    expect(unmatched?.fallbackRoute.path).toBe("/:lang/docs");
-    const unmatchedNotFound =
-      unmatched &&
-      (await RouteElementComposer.composeFallback({
-        kind: "not-found",
-        route: unmatched.fallbackRoute,
-        params: unmatched.params,
-        searchParams: {},
-        pathname: "/ko/docs/missing/path",
-      }));
-    const unmatchedHtml = await renderToText(unmatchedNotFound);
-    expect(unmatchedHtml).toContain("docs missing");
-    expect(unmatchedHtml).toContain("/ko/docs/missing/path");
-  });
-});

package/server/routing/apiRouter.test.ts

@@ -1,136 +0,0 @@
-import { getDefaultInjectRegistry } from "akanjs/service";
-import { AkanResponse, WebProxyRunner } from "../proxy";
-import type { HttpRoutes, WebsocketRoutes } from "../types";
-
-describe("ApiRouter.buildRoutes", () => {
-  test("keeps the global prefix by default", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "test";
-    const { ApiRouter } = await import("./apiRouter");
-    const routes = ApiRouter.buildRoutes({
-      prefix: "/api",
-      websocketPrefix: "/ws",
-      routes: { "/admin/ping": () => new Response("ok") } as HttpRoutes,
-      renderEnvRoutes: {},
-      upgradeAppWs: () => false,
-    });
-
-    expect(Object.keys(routes)).toContain("/api/admin/ping");
-  });
-
-  test("allows selected endpoints to skip the global prefix", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "test";
-    const { ApiRouter } = await import("./apiRouter");
-    const routes = ApiRouter.buildRoutes({
-      prefix: "/api",
-      websocketPrefix: "/ws",
-      routes: { "/sitemap.xml": () => new Response("ok") } as HttpRoutes,
-      routeOptions: { "/sitemap.xml": { globalPrefix: false } },
-      renderEnvRoutes: { "/*": () => new Response("fallback") } as HttpRoutes,
-      upgradeAppWs: () => false,
-    });
-
-    expect(Object.keys(routes)).toContain("/sitemap.xml");
-    expect(Object.keys(routes)).not.toContain("/api/sitemap.xml");
-  });
-
-  test("wraps only render routes with the web proxy runner", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "test";
-    const { ApiRouter } = await import("./apiRouter");
-    class RewriteRenderProxy {
-      static refName = "rewriteRenderProxy";
-      use() {
-        return AkanResponse.rewrite("http://localhost/rendered", { request: { headers: { "x-proxy": "1" } } });
-      }
-    }
-    const routes = ApiRouter.buildRoutes({
-      prefix: "/api",
-      websocketPrefix: "/ws",
-      routes: { "/ping": () => Response.json("api") } as HttpRoutes,
-      renderEnvRoutes: {
-        "/*": (req) => Response.json({ url: req.url, proxy: req.headers.get("x-proxy") }),
-      } as HttpRoutes,
-      upgradeAppWs: () => false,
-      webProxyRunner: new WebProxyRunner([RewriteRenderProxy]),
-    });
-
-    expect(await (await (routes["/api/ping"] as () => Response)()).json()).toBe("api");
-    const renderResponse = await (routes["/*"] as (req: Request) => Response | Promise<Response>)(
-      new Request("http://localhost/dashboard"),
-    );
-    expect(await renderResponse.json()).toEqual({ url: "http://localhost/rendered", proxy: "1" });
-  });
-});
-
-describe("ApiRouter.buildWebsocketHandlers", () => {
-  test("dispatches app websocket messages and returns route errors", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "test";
-    const { ApiRouter } = await import("./apiRouter");
-    const sent: string[] = [];
-    const loggerErrors: string[] = [];
-    const ws = {
-      data: {},
-      send: (message: string) => sent.push(message),
-    } as unknown as Bun.ServerWebSocket<unknown>;
-    const handlers = ApiRouter.buildWebsocketHandlers({
-      wsRoutes: {
-        echo: async (_ws, data, event) => ({ event, data }),
-      } as WebsocketRoutes,
-      registry: getDefaultInjectRegistry(),
-      hmrHub: null,
-      hmrState: null,
-      logger: { error: (message: string) => loggerErrors.push(message) } as never,
-    });
-
-    await handlers.message?.(ws, JSON.stringify({ key: "echo", data: ["hello"] }));
-    const originalConsoleError = console.error;
-    console.error = () => undefined;
-    try {
-      await handlers.message?.(ws, JSON.stringify({ key: "missing", data: [] }));
-    } finally {
-      console.error = originalConsoleError;
-    }
-
-    expect(JSON.parse(sent[0] ?? "{}")).toEqual({ event: "message", data: ["hello"] });
-    expect(JSON.parse(sent[1] ?? "{}").error).toBe('WebSocket route "missing" is not registered');
-    expect(loggerErrors).toEqual(['WebSocket route "missing" is not registered']);
-  });
-
-  test("keeps HMR websocket traffic separate from app signal routes", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "test";
-    const { ApiRouter } = await import("./apiRouter");
-    const sent: string[] = [];
-    let attached = false;
-    let detached = false;
-    const ws = {
-      data: { kind: "akan-hmr" },
-      send: (message: string) => sent.push(message),
-    } as unknown as Bun.ServerWebSocket<unknown>;
-    const handlers = ApiRouter.buildWebsocketHandlers({
-      wsRoutes: {
-        hmrShouldNotRun: () => {
-          throw new Error("should not run");
-        },
-      } as WebsocketRoutes,
-      registry: getDefaultInjectRegistry(),
-      hmrHub: {
-        attach: () => {
-          attached = true;
-        },
-        detach: () => {
-          detached = true;
-        },
-      } as never,
-      hmrState: { state: { buildId: 7, cssAssets: {} } },
-      logger: { error: () => undefined } as never,
-    });
-
-    handlers.open?.(ws);
-    await handlers.message?.(ws, JSON.stringify({ key: "hmrShouldNotRun" }));
-    handlers.close?.(ws);
-
-    expect(attached).toBe(true);
-    expect(detached).toBe(true);
-    expect(JSON.parse(sent[0] ?? "{}")).toEqual({ type: "hello", buildId: 7, cssAssets: {} });
-    expect(sent).toHaveLength(1);
-  });
-});

package/server/sitemap.test.ts

@@ -1,61 +0,0 @@
-import { createDefaultSitemapUrls, createSitemapXml, getSitemapBasePath } from "./sitemap";
-
-describe("sitemap fallback helpers", () => {
-  const i18n = { defaultLocale: "en", locales: ["en", "ko"] };
-
-  test("creates escaped XML with unique sorted URLs", () => {
-    const xml = createSitemapXml(["https://example.com/b?x=1&y=2", "https://example.com/a", "https://example.com/a"]);
-
-    expect(xml).toContain("<loc>https://example.com/a</loc>");
-    expect(xml).toContain("<loc>https://example.com/b?x=1&amp;y=2</loc>");
-    expect(xml.match(/<url>/g)).toHaveLength(2);
-  });
-
-  test("expands only static locale routes", () => {
-    const urls = createDefaultSitemapUrls({
-      origin: "https://example.com",
-      entries: [
-        { routeId: "/:lang", pattern: "/:lang", seeds: [] },
-        { routeId: "/:lang/about", pattern: "/:lang/about", seeds: [] },
-        { routeId: "/:lang/post/:postId", pattern: "/:lang/post/:postId", seeds: [] },
-        { routeId: "/robots.txt", pattern: "/robots.txt", seeds: [] },
-      ],
-      i18n,
-    });
-
-    expect(urls).toEqual([
-      "https://example.com/en",
-      "https://example.com/ko",
-      "https://example.com/en/about",
-      "https://example.com/ko/about",
-    ]);
-  });
-
-  test("uses base path only for filtering subroute sitemap entries", () => {
-    const urls = createDefaultSitemapUrls({
-      origin: "https://example.com/",
-      basePath: "akanjs",
-      entries: [
-        { routeId: "/:lang/akanjs", pattern: "/:lang/akanjs", seeds: [] },
-        { routeId: "/:lang/akanjs/about", pattern: "/:lang/akanjs/about", seeds: [] },
-        { routeId: "/:lang/thin/about", pattern: "/:lang/thin/about", seeds: [] },
-        { routeId: "/:lang/akanjs/post/:postId", pattern: "/:lang/akanjs/post/:postId", seeds: [] },
-      ],
-      i18n,
-    });
-
-    expect(urls).toEqual([
-      "https://example.com/en",
-      "https://example.com/ko",
-      "https://example.com/en/about",
-      "https://example.com/ko/about",
-    ]);
-  });
-
-  test("recognizes root and subroute sitemap paths", () => {
-    expect(getSitemapBasePath("/sitemap.xml", [])).toBeNull();
-    expect(getSitemapBasePath("/sitemap.xml", ["akanjs"])).toBeUndefined();
-    expect(getSitemapBasePath("/sitemap.xml", ["akanjs"], "akanjs")).toBe("akanjs");
-    expect(getSitemapBasePath("/akanjs/sitemap.xml", ["akanjs"], "akanjs")).toBeUndefined();
-  });
-});

package/server/systemPages.test.tsx

@@ -1,93 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DEFAULT_AKAN_I18N } from "akanjs/common";
-import {
-  createSystemPageFallbackText,
-  createSystemPageHeaders,
-  createSystemPageResponse,
-  getSystemPageHomeHref,
-} from "./systemPages";
-
-describe("system pages", () => {
-  test("renders a pretty not-found page with no-store headers", async () => {
-    const response = await createSystemPageResponse({
-      kind: "not-found",
-      pathname: "/ko/akanjs/missing",
-      homeHref: "/ko/akanjs",
-      lang: "ko",
-      stylesheetHref: "/_akan/styles/akanjs.css",
-    });
-    const html = await response.text();
-
-    expect(response.status).toBe(404);
-    expect(response.headers.get("Content-Type")).toBe("text/html; charset=utf-8");
-    expect(response.headers.get("Cache-Control")).toBe("no-store");
-    expect(html).toContain("Page not found");
-    expect(html).toContain("This page is off the flight path.");
-    expect(html).toContain("/ko/akanjs/missing");
-    expect(html).toContain('href="/ko/akanjs"');
-    expect(html).toContain('href="/_akan/styles/akanjs.css"');
-    expect(html).toContain('name="robots"');
-    expect(html).toContain("noindex");
-  });
-
-  test("keeps server error details dev-only", async () => {
-    const error = new Error("database password leaked in stack");
-    const productionResponse = await createSystemPageResponse({
-      kind: "error",
-      pathname: "/en/broken",
-      homeHref: "/en",
-      showDetails: false,
-      error,
-    });
-    const devResponse = await createSystemPageResponse({
-      kind: "error",
-      pathname: "/en/broken",
-      homeHref: "/en",
-      showDetails: true,
-      error,
-    });
-
-    expect(productionResponse.status).toBe(500);
-    expect(await productionResponse.text()).not.toContain("database password leaked in stack");
-    expect(await devResponse.text()).toContain("database password leaked in stack");
-  });
-
-  test("returns HEAD metadata without a body", async () => {
-    const response = await createSystemPageResponse({
-      kind: "not-found",
-      method: "HEAD",
-      pathname: "/en/missing",
-      homeHref: "/en",
-    });
-
-    expect(response.status).toBe(404);
-    expect(response.headers.get("Cache-Control")).toBe("no-store");
-    expect(await response.text()).toBe("");
-  });
-
-  test("builds locale and base-path aware home links", () => {
-    expect(
-      getSystemPageHomeHref({
-        pathname: "/ko/akanjs/docs/missing",
-        i18n: DEFAULT_AKAN_I18N,
-        basePaths: ["akanjs", "soft"],
-      }),
-    ).toBe("/ko/akanjs");
-    expect(
-      getSystemPageHomeHref({
-        pathname: "/unknown/missing",
-        i18n: DEFAULT_AKAN_I18N,
-        basePaths: ["akanjs", "soft"],
-        headerBasePath: "soft",
-      }),
-    ).toBe("/en/soft");
-  });
-
-  test("provides final fallback text and no-store headers", () => {
-    const headers = createSystemPageHeaders();
-
-    expect(createSystemPageFallbackText("error")).toBe("500 Server error");
-    expect(headers.get("Content-Type")).toBe("text/html; charset=utf-8");
-    expect(headers.get("Cache-Control")).toBe("no-store");
-  });
-});

package/server/webRouter.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DEFAULT_AKAN_I18N } from "akanjs/common";
-import { normalizeRscTargetUrlForHostBasePath } from "./webRouter";
-
-describe("WebRouter RSC target normalization", () => {
-  test("maps public host paths to the hidden basePath route for RSC navigation", () => {
-    const target = new URL("https://akanjs.com/en/docs/intro/quickstart");
-
-    const normalized = normalizeRscTargetUrlForHostBasePath(target, {
-      basePath: "akanjs",
-      i18n: DEFAULT_AKAN_I18N,
-    });
-
-    expect(normalized.url.href).toBe("https://akanjs.com/en/akanjs/docs/intro/quickstart");
-    expect(normalized.basePath).toBe("akanjs");
-  });
-
-  test("maps debug public paths by matching configured basePath route seeds", () => {
-    const target = new URL("https://akanjs-debug.akanjs.com/en/references/cli/overview");
-
-    const normalized = normalizeRscTargetUrlForHostBasePath(target, {
-      basePath: null,
-      basePaths: ["office", "akanjs", "soft"],
-      i18n: DEFAULT_AKAN_I18N,
-      seedEntries: [
-        {
-          routeId: "/:lang/akanjs/references/cli/overview",
-          pattern: "/:lang/akanjs/references/cli/overview",
-          seeds: [],
-        },
-      ],
-    });
-
-    expect(normalized.url.href).toBe("https://akanjs-debug.akanjs.com/en/akanjs/references/cli/overview");
-    expect(normalized.basePath).toBe("akanjs");
-  });
-
-  test("does not duplicate an already internal basePath route", () => {
-    const target = new URL("https://akanjs.com/en/akanjs/docs/intro/quickstart");
-
-    const normalized = normalizeRscTargetUrlForHostBasePath(target, {
-      basePath: "akanjs",
-      i18n: DEFAULT_AKAN_I18N,
-    });
-
-    expect(normalized.url.href).toBe("https://akanjs.com/en/akanjs/docs/intro/quickstart");
-    expect(normalized.basePath).toBe("akanjs");
-  });
-});