akanjs 0.0.1 → 2.0.0-beta.0

package/server/processMetricsCollector.ts

@@ -0,0 +1,78 @@
+import type { AkanMetricsReport } from "akanjs/service";
+
+type BunJscHeapStats = {
+  heapSize?: number;
+  heapCapacity?: number;
+  extraMemorySize?: number;
+  objectCount?: number;
+  protectedObjectCount?: number;
+};
+
+export class ProcessMetricsCollector {
+  static readonly #defaultMemoryLogIntervalMs = 60_000;
+
+  static parseMemoryLogIntervalMs(value = process.env.AKAN_MEMORY_LOG_INTERVAL_MS) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : ProcessMetricsCollector.#defaultMemoryLogIntervalMs;
+  }
+
+  static async collect(extra: AkanMetricsReport = {}): Promise<AkanMetricsReport> {
+    if (process.env.AKAN_MEMORY_GC_ON_REPORT === "1") Bun.gc(true);
+    const memory = process.memoryUsage();
+    const resourceUsage = process.resourceUsage?.();
+    const jsc = await ProcessMetricsCollector.#collectJscHeapStats();
+    return {
+      pid: process.pid,
+      reportedAt: Date.now(),
+      rssBytes: memory.rss,
+      heapTotalBytes: memory.heapTotal,
+      heapUsedBytes: memory.heapUsed,
+      externalBytes: memory.external,
+      arrayBuffersBytes: memory.arrayBuffers,
+      ...(resourceUsage
+        ? {
+            cpuUserMicros: resourceUsage.userCPUTime,
+            cpuSystemMicros: resourceUsage.systemCPUTime,
+            maxRssKb: resourceUsage.maxRSS,
+          }
+        : {}),
+      ...(jsc
+        ? {
+            jscHeapSizeBytes: jsc.heapSize,
+            jscHeapCapacityBytes: jsc.heapCapacity,
+            jscExtraMemorySizeBytes: jsc.extraMemorySize,
+            jscObjectCount: jsc.objectCount,
+            jscProtectedObjectCount: jsc.protectedObjectCount,
+          }
+        : {}),
+      ...extra,
+    };
+  }
+
+  static formatBytes(bytes = 0) {
+    return `${(bytes / 1024 / 1024).toFixed(1)}MiB`;
+  }
+
+  static format(metrics: AkanMetricsReport) {
+    return [
+      `pid=${metrics.pid ?? "unknown"}`,
+      `rss=${ProcessMetricsCollector.formatBytes(metrics.rssBytes)}`,
+      `heapUsed=${ProcessMetricsCollector.formatBytes(metrics.heapUsedBytes)}`,
+      `heapTotal=${ProcessMetricsCollector.formatBytes(metrics.heapTotalBytes)}`,
+      `external=${ProcessMetricsCollector.formatBytes(metrics.externalBytes)}`,
+      `arrayBuffers=${ProcessMetricsCollector.formatBytes(metrics.arrayBuffersBytes)}`,
+      ...(metrics.jscHeapSizeBytes !== undefined
+        ? [`jscHeap=${ProcessMetricsCollector.formatBytes(metrics.jscHeapSizeBytes)}`]
+        : []),
+    ].join(" ");
+  }
+
+  static async #collectJscHeapStats(): Promise<BunJscHeapStats | null> {
+    try {
+      const mod = (await import("bun:jsc")) as { heapStats?: () => BunJscHeapStats };
+      return mod.heapStats?.() ?? null;
+    } catch {
+      return null;
+    }
+  }
+}

package/server/proxy/akanResponse.ts

@@ -0,0 +1,16 @@
+import { WEB_PROXY_RESULT, type WebProxyNextInit, type WebProxyResult } from "./types";
+
+/** Helpers for returning next/rewrite/redirect results from Akan web proxies. */
+export class AkanResponse {
+  static next(init: WebProxyNextInit = {}): WebProxyResult {
+    return { [WEB_PROXY_RESULT]: true, type: "next", request: init.request };
+  }
+
+  static redirect(url: string | URL, status = 307): Response {
+    return Response.redirect(url, status);
+  }
+
+  static rewrite(url: string | URL, init: WebProxyNextInit = {}): WebProxyResult {
+    return { [WEB_PROXY_RESULT]: true, type: "rewrite", url, request: init.request };
+  }
+}

package/server/proxy/bunRequestFields.ts

@@ -0,0 +1,12 @@
+export const copyBunRequestFields = (target: Request, source: Request): Request => {
+  const sourceWithParams = source as Request & { params?: Record<string, string> };
+  if (sourceWithParams.params) {
+    Object.defineProperty(target, "params", {
+      configurable: true,
+      enumerable: true,
+      value: sourceWithParams.params,
+      writable: true,
+    });
+  }
+  return target;
+};

package/server/proxy/hostBasePathWebProxy.ts

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getEnv } from "akanjs/base";
+import type { BaseBuildArtifact } from "../types";
+import { AkanResponse } from "./akanResponse";
+import type { WebProxy } from "./types";
+
+const RESERVED_BASE_PATHS = new Set(["admin"]);
+
+export class HostBasePathWebProxy implements WebProxy {
+  static readonly refName = "HostBasePathWebProxy";
+  #domainMap: Map<string, string> | null = null;
+
+  use(request: Bun.BunRequest) {
+    const requestUrl = new URL(request.url);
+    const basePath = this.#getBasePath(request);
+    if (!basePath) return;
+
+    const targetUrl = getProxyTargetUrl(requestUrl);
+    const targetPath = targetUrl.pathname;
+    const headers = new Headers(request.headers);
+    headers.set("x-base-path", basePath);
+    if (targetPath === "/sitemap.xml") return AkanResponse.next({ request: { headers } });
+
+    const segments = targetPath.split("/");
+    const locale = segments[1];
+    if (!locale) return;
+
+    const firstPath = segments[2] ?? "";
+
+    if (firstPath === basePath) {
+      if (isInternalProxyRequest(requestUrl)) return AkanResponse.next({ request: { headers } });
+      const publicPath = `/${[locale, ...segments.slice(3)].filter(Boolean).join("/")}`;
+      return Response.redirect(
+        new URL(`${publicPath || `/${locale}`}${targetUrl.search}`, getPublicRequestUrl(request)),
+        308,
+      );
+    }
+
+    if (RESERVED_BASE_PATHS.has(firstPath)) return AkanResponse.next({ request: { headers } });
+
+    const internalPath = `/${[locale, basePath, ...segments.slice(2)].filter(Boolean).join("/")}`;
+    targetUrl.pathname = internalPath;
+    return AkanResponse.rewrite(toProxyRequestUrl(requestUrl, targetUrl), { request: { headers } });
+  }
+
+  #getBasePath(request: Request): string | null {
+    const host = normalizeHost(request.headers.get("x-forwarded-host") ?? request.headers.get("host"));
+    if (!host) return null;
+    const domainMap = this.#getDomainMap();
+    return domainMap.get(host) ?? null;
+  }
+
+  #getDomainMap(): Map<string, string> {
+    if (this.#domainMap) return this.#domainMap;
+    const subRoutes = loadWebRouteMetadata();
+    const map = new Map<string, string>();
+    for (const [basePath, domains] of Object.entries(subRoutes)) {
+      for (const domain of domains) map.set(normalizeHost(domain), basePath);
+    }
+    this.#domainMap = map;
+    return map;
+  }
+}
+
+function loadWebRouteMetadata() {
+  const artifactPath = path.join(resolveArtifactDir(), "base-artifact.json");
+  if (!fs.existsSync(artifactPath)) return { routes: [] };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(artifactPath, "utf8")) as Partial<BaseBuildArtifact>;
+    return parsed.subRoutes ?? {};
+  } catch {
+    return { routes: [] };
+  }
+}
+
+function resolveArtifactDir(): string {
+  const localArtifactDir = path.join(process.cwd(), ".akan", "artifact");
+  if (fs.existsSync(path.join(localArtifactDir, "base-artifact.json"))) return localArtifactDir;
+  return path.join(process.cwd(), "apps", getEnv().appName, ".akan", "artifact");
+}
+
+function normalizeHost(host: string | null): string {
+  return (host ?? "").toLowerCase().replace(/:\d+$/, "");
+}
+
+function getPublicRequestUrl(request: Bun.BunRequest): URL {
+  const url = new URL(request.url);
+  const host = request.headers.get("x-forwarded-host") ?? request.headers.get("host");
+  const proto = request.headers.get("x-forwarded-proto");
+  if (host) url.host = host;
+  if (host && !host.includes(":")) url.port = "";
+  if (proto) url.protocol = proto.endsWith(":") ? proto : `${proto}:`;
+  return url;
+}
+
+function getProxyTargetUrl(requestUrl: URL): URL {
+  if (!isInternalProxyRequest(requestUrl)) return new URL(requestUrl);
+  const target = requestUrl.searchParams.get("url");
+  return target ? new URL(target, requestUrl.origin) : new URL(requestUrl);
+}
+
+function toProxyRequestUrl(requestUrl: URL, targetUrl: URL): URL {
+  if (!isInternalProxyRequest(requestUrl)) return targetUrl;
+  const rewritten = new URL(requestUrl);
+  rewritten.searchParams.set("url", `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`);
+  return rewritten;
+}
+
+function isInternalProxyRequest(requestUrl: URL): boolean {
+  return requestUrl.pathname === "/__rsc";
+}

package/server/proxy/index.ts

@@ -0,0 +1,15 @@
+export { AkanResponse } from "./akanResponse";
+export { copyBunRequestFields } from "./bunRequestFields";
+export { HostBasePathWebProxy } from "./hostBasePathWebProxy";
+export { LocaleWebProxy } from "./localeWebProxy";
+export type {
+  WebProxy,
+  WebProxyCls,
+  WebProxyMatcher,
+  WebProxyNextInit,
+  WebProxyRegistration,
+  WebProxyResult,
+  WebProxyReturn,
+  WebProxyRunResult,
+} from "./types";
+export { WebProxyRunner } from "./webProxyRunner";

package/server/proxy/localeWebProxy.ts

@@ -0,0 +1,71 @@
+import { match as matchLocale } from "@formatjs/intl-localematcher";
+import { parseAkanI18nEnv } from "akanjs/common";
+import Negotiator from "negotiator";
+import { AkanResponse } from "./akanResponse";
+import type { WebProxy } from "./types";
+
+function getLocale(request: Bun.BunRequest): string {
+  const i18n = parseAkanI18nEnv();
+  if (!request.headers.get("accept-language")) return i18n.defaultLocale;
+  const negotiatorHeaders: Record<string, string> = {};
+  request.headers.forEach((value, key) => {
+    negotiatorHeaders[key] = value;
+  });
+  try {
+    const languages = new Negotiator({ headers: negotiatorHeaders }).languages();
+    return matchLocale(languages, i18n.locales, i18n.defaultLocale);
+  } catch {
+    return i18n.defaultLocale;
+  }
+}
+
+export class LocaleWebProxy implements WebProxy {
+  static readonly refName = "LocaleWebProxy";
+
+  use(request: Bun.BunRequest) {
+    const i18n = parseAkanI18nEnv();
+    const requestUrl = new URL(request.url);
+
+    const targetUrl = getProxyTargetUrl(requestUrl);
+    const pathname = targetUrl.pathname;
+    const pathnameIsMissingLocale = i18n.locales.every(
+      (locale) => !pathname.startsWith(`/${locale}/`) && pathname !== `/${locale}`,
+    );
+
+    if (!isInternalProxyRequest(requestUrl) && pathnameIsMissingLocale) {
+      return Response.redirect(
+        new URL(`/${getLocale(request)}/${pathname.slice(1)}${targetUrl.search}`, getPublicRequestUrl(request)),
+        307,
+      );
+    }
+
+    const splits = pathname.split("/");
+    const [, locale = i18n.defaultLocale] = splits;
+    const headers = new Headers(request.headers);
+
+    headers.set("x-locale", i18n.locales.includes(locale) ? locale : i18n.defaultLocale);
+    headers.set("x-path", `/${splits.slice(2).join("/")}`);
+
+    return AkanResponse.next({ request: { headers } });
+  }
+}
+
+function getProxyTargetUrl(requestUrl: URL): URL {
+  if (requestUrl.pathname !== "/__rsc") return requestUrl;
+  const target = requestUrl.searchParams.get("url");
+  return target ? new URL(target, requestUrl.origin) : requestUrl;
+}
+
+function getPublicRequestUrl(request: Bun.BunRequest): URL {
+  const url = new URL(request.url);
+  const host = request.headers.get("x-forwarded-host") ?? request.headers.get("host");
+  const proto = request.headers.get("x-forwarded-proto");
+  if (host) url.host = host;
+  if (host && !host.includes(":")) url.port = "";
+  if (proto) url.protocol = proto.endsWith(":") ? proto : `${proto}:`;
+  return url;
+}
+
+function isInternalProxyRequest(requestUrl: URL): boolean {
+  return requestUrl.pathname === "/__rsc";
+}

package/server/proxy/types.ts

@@ -0,0 +1,41 @@
+import type { Cls, PromiseOrObject } from "akanjs/base";
+
+export const WEB_PROXY_RESULT = Symbol.for("akanjs/web-proxy-result");
+
+export type WebProxyNextInit = {
+  request?: {
+    headers?: HeadersInit;
+  };
+};
+
+export type WebProxyResult =
+  | {
+      readonly [WEB_PROXY_RESULT]: true;
+      readonly type: "next";
+      readonly request?: {
+        readonly headers?: HeadersInit;
+      };
+    }
+  | {
+      readonly [WEB_PROXY_RESULT]: true;
+      readonly type: "rewrite";
+      readonly url: string | URL;
+      readonly request?: {
+        readonly headers?: HeadersInit;
+      };
+    };
+
+export type WebProxyReturn = Response | WebProxyResult | undefined;
+
+export interface WebProxy {
+  use(request: Bun.BunRequest): PromiseOrObject<WebProxyReturn>;
+}
+
+export type WebProxyCls = Cls<WebProxy, { readonly refName: string }>;
+export type WebProxyMatcher = string | RegExp | ((request: Request) => boolean);
+export type WebProxyRegistration = WebProxyCls | { proxy: WebProxyCls; matcher?: WebProxyMatcher };
+
+export interface WebProxyRunResult {
+  request: Request;
+  response?: Response;
+}

package/server/proxy/webProxyRunner.ts

@@ -0,0 +1,90 @@
+import { copyBunRequestFields } from "./bunRequestFields";
+import {
+  WEB_PROXY_RESULT,
+  type WebProxy,
+  type WebProxyMatcher,
+  type WebProxyRegistration,
+  type WebProxyResult,
+  type WebProxyReturn,
+  type WebProxyRunResult,
+} from "./types";
+
+export class WebProxyRunner {
+  readonly #proxies: Array<{ proxy: WebProxy; matcher?: WebProxyMatcher }>;
+
+  static create(registrations: WebProxyRegistration[] = []): WebProxyRunner | null {
+    if (registrations.length === 0) return null;
+    return new WebProxyRunner(registrations);
+  }
+
+  constructor(registrations: WebProxyRegistration[] = []) {
+    this.#proxies = registrations.map(WebProxyRunner.#normalizeRegistration);
+  }
+
+  async run(input: Request): Promise<WebProxyRunResult> {
+    let request = input;
+    for (const { proxy, matcher } of this.#proxies) {
+      if (!WebProxyRunner.#matches(request, matcher)) continue;
+      const result = await proxy.use(request as Bun.BunRequest);
+      if (result instanceof Response) return { request, response: result };
+      if (WebProxyRunner.#isResult(result)) {
+        request = WebProxyRunner.#applyResult(request, result);
+      } else {
+        request = copyBunRequestFields(request, input);
+      }
+    }
+    return { request };
+  }
+
+  static #normalizeRegistration(registration: WebProxyRegistration): { proxy: WebProxy; matcher?: WebProxyMatcher } {
+    if (typeof registration === "function") return { proxy: new registration() };
+    return { proxy: new registration.proxy(), matcher: registration.matcher };
+  }
+
+  static #matches(request: Request, matcher?: WebProxyMatcher): boolean {
+    if (!matcher) return WebProxyRunner.#matchesDefault(request);
+    if (typeof matcher === "function") return matcher(request);
+    const pathname = new URL(request.url).pathname;
+    if (typeof matcher === "string")
+      return pathname === matcher || pathname.startsWith(`${matcher.replace(/\/$/, "")}/`);
+    return matcher.test(pathname);
+  }
+
+  static #matchesDefault(request: Request): boolean {
+    const { pathname } = new URL(request.url);
+    if (pathname === "/__csr" || pathname === "/_akan/hmr") return false;
+    if (pathname.startsWith("/_akan/client/") || pathname.startsWith("/_akan/styles/")) return false;
+    if (pathname === "/favicon.ico" || /\.[a-z0-9]+$/i.test(pathname)) return false;
+    return true;
+  }
+
+  static #isResult(value: WebProxyReturn): value is WebProxyResult {
+    return Boolean(value && typeof value === "object" && WEB_PROXY_RESULT in value);
+  }
+
+  static #applyResult(request: Request, result: WebProxyResult): Request {
+    const headers = result.request?.headers;
+    if (result.type === "rewrite") return WebProxyRunner.#cloneRequest(request, { url: result.url, headers });
+    return WebProxyRunner.#cloneRequest(request, { headers });
+  }
+
+  static #cloneRequest(request: Request, init: { url?: string | URL; headers?: HeadersInit }): Request {
+    if (!init.url && !init.headers) return request;
+    const cloned = new Request(init.url ?? request.url, {
+      body: request.method === "GET" || request.method === "HEAD" ? undefined : request.body,
+      cache: request.cache,
+      credentials: request.credentials,
+      headers: init.headers ?? request.headers,
+      integrity: request.integrity,
+      keepalive: request.keepalive,
+      method: request.method,
+      mode: request.mode,
+      redirect: request.redirect,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy,
+      signal: request.signal,
+    });
+    copyBunRequestFields(cloned, request);
+    return cloned;
+  }
+}