akanjs 2.2.4 → 2.2.5

package/server/di/diLifecycle.contract.test.ts

@@ -1,168 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { BackendEnv } from "akanjs/base";
-import { SolidPubSub } from "akanjs/service";
-import { AkanLib } from "../akanLib";
-import { AkanOption } from "../akanOption";
-import { HostBasePathWebProxy, LocaleWebProxy } from "../proxy";
-import {
-  ServerResolverTestEndpoint,
-  ServerResolverTestInternal,
-  ServerResolverTestServerSignal,
-  ServerResolverTestSlice,
-  serverResolverTestConstant,
-  serverResolverTestDatabase,
-  serverResolverTestServiceModel,
-  validId,
-} from "../resolver/resolver.contract.fixture";
-
-describe("DiLifecycle declaration-to-runtime contract", () => {
-  test("prepends default web proxies before library proxies", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "serverLifecycle";
-    process.env.AKAN_PUBLIC_REPO_NAME = "akan";
-    process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
-    process.env.AKAN_PUBLIC_ENV = "local";
-    process.env.AKAN_PUBLIC_OPERATION_MODE = "local";
-    process.env.SERVER_MODE = "all";
-    process.env.NODE_ENV = "test";
-    const { DiLifecycle } = await import("./diLifecycle");
-
-    class CustomWebProxy {
-      static readonly refName = "CustomWebProxy";
-      use() {}
-    }
-
-    const env = {
-      repoName: "akan",
-      serveDomain: "example.com",
-      appName: "serverLifecycle",
-      environment: "local",
-      operationMode: "local",
-      tunnelUsername: "root",
-      tunnelPassword: "akan",
-    } satisfies BackendEnv;
-    const lib = new AkanLib("serverLifecycleTest", {
-      databases: [],
-      services: [],
-      scalars: [],
-      option: new AkanOption().applyWebProxy(CustomWebProxy),
-    });
-
-    const lifecycle = new DiLifecycle(env, "all", lib);
-
-    expect(lifecycle.webProxies).toEqual([LocaleWebProxy, HostBasePathWebProxy, CustomWebProxy]);
-  });
-
-  test("assembles AkanLib declarations into registry, live services, and routes", async () => {
-    process.env.AKAN_PUBLIC_APP_NAME = "serverLifecycle";
-    process.env.AKAN_PUBLIC_REPO_NAME = "akan";
-    process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
-    process.env.AKAN_PUBLIC_ENV = "local";
-    process.env.AKAN_PUBLIC_OPERATION_MODE = "local";
-    process.env.SERVER_MODE = "all";
-    process.env.NODE_ENV = "test";
-    const { DiLifecycle } = await import("./diLifecycle");
-
-    const tmp = await mkdtemp(join(tmpdir(), "akan-server-di-"));
-    const env = {
-      repoName: "akan",
-      serveDomain: "example.com",
-      appName: "serverLifecycle",
-      environment: "local",
-      operationMode: "local",
-      tunnelUsername: "root",
-      tunnelPassword: "akan",
-      workspaceRoot: tmp,
-      database: {
-        sqlite: {
-          filePath: join(tmp, "akan.db"),
-          journalMode: "WAL",
-          busyTimeoutMs: 1000,
-          synchronous: "NORMAL",
-          foreignKeys: true,
-        },
-      },
-      solid: {
-        filePath: join(tmp, "solid.db"),
-        journalMode: "WAL",
-        busyTimeoutMs: 1000,
-        synchronous: "NORMAL",
-        cleanupIntervalMs: 60_000,
-        queuePollIntervalMs: 60_000,
-        queueLeaseMs: 30_000,
-      },
-    } satisfies BackendEnv & { workspaceRoot: string };
-    const lib = new AkanLib("serverLifecycleTest", {
-      databases: [
-        {
-          constant: serverResolverTestConstant,
-          database: serverResolverTestDatabase,
-          service: serverResolverTestServiceModel,
-          signal: {
-            endpoint: ServerResolverTestEndpoint,
-            slice: ServerResolverTestSlice,
-            internal: ServerResolverTestInternal,
-            server: ServerResolverTestServerSignal,
-          },
-        },
-      ],
-      services: [],
-      scalars: [],
-      option: new AkanOption(),
-    });
-    const lifecycle = new DiLifecycle(env, "all", lib);
-
-    try {
-      const routes = await lifecycle.initializeAll();
-
-      expect(lifecycle.registry.adaptorCls.has("serverResolverTestItemModel")).toBe(true);
-      expect(lifecycle.live.adaptor.has("serverResolverTestItemModel")).toBe(true);
-      expect(lifecycle.registry.serviceCls.has("serverResolverTestItem")).toBe(true);
-      expect(lifecycle.live.service.has("serverResolverTestItem")).toBe(true);
-      expect(lifecycle.registry.serverSignalCls.has("serverResolverTestItemSignal")).toBe(true);
-      expect(lifecycle.registry.internalCls.has("serverResolverTestItemInternal")).toBe(true);
-      expect(lifecycle.live.internal.has("serverResolverTestItemInternal")).toBe(true);
-      expect(lifecycle.registry.endpointCls.has("serverResolverTestItemEndpoint")).toBe(true);
-      expect(lifecycle.live.sliceCls.has("serverResolverTestItem")).toBe(true);
-
-      expect(Object.keys(routes.routes ?? {})).toEqual(
-        expect.arrayContaining([
-          "/getTitle/:id",
-          "/serverResolverTestItem/updateTitle/:id",
-          "/serverResolverTestItem/serverResolverTestItem/:serverResolverTestItemId",
-          "/serverResolverTestItem/serverResolverTestItemListInCategory",
-        ]),
-      );
-      expect(Object.keys(routes.wsRoutes ?? {})).toEqual(expect.arrayContaining(["roomFeed", "echoMessage"]));
-      expect(routes.routeOptions?.["/getTitle/:id"]).toEqual({ globalPrefix: false });
-
-      const service = lifecycle.live.service.get("serverResolverTestItem") as {
-        createServerResolverTestItem(data: Record<string, unknown>): Promise<Record<string, unknown>>;
-        listInCategory(...args: unknown[]): Promise<unknown[]>;
-      };
-      const created = await service.createServerResolverTestItem({
-        ownerId: validId,
-        category: "news",
-        title: "Alpha",
-        resolvedLabel: "resolved",
-        count: 1,
-        tags: ["featured"],
-        nested: { label: "Nested" },
-      });
-      expect(created).toMatchObject({
-        category: "news",
-        parentPostCreate: true,
-        childPostCreate: true,
-      });
-      expect(await service.listInCategory("news", false, { limit: 10 })).toHaveLength(1);
-
-      const websocket = lifecycle.registry.adaptor.get(SolidPubSub) as SolidPubSub | undefined;
-      expect(websocket).toBeDefined();
-    } finally {
-      await lifecycle.destroyAll();
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-});

package/server/logging/rotatingLogWriter.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { RotatingLogWriter } from "./rotatingLogWriter";
-
-const createTmp = () => mkdtemp(join(tmpdir(), "akan-logs-"));
-
-describe("RotatingLogWriter", () => {
-  test("rotates by size and sanitizes filename parts", async () => {
-    const tmp = await createTmp();
-    const writer = new RotatingLogWriter({
-      logDir: tmp,
-      appName: "my/app",
-      environment: "local env",
-      operationMode: "local",
-      maxSizeBytes: 10,
-      now: () => new Date(2026, 4, 25, 10),
-    });
-
-    try {
-      writer.write("gateway", "12345\n");
-      writer.write("gateway", "67890\n");
-      await writer.close();
-
-      expect((await readdir(tmp)).sort()).toEqual([
-        "my_app-local_env-local-2026-05-25-gateway-0001.log",
-        "my_app-local_env-local-2026-05-25-gateway-0002.log",
-      ]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-
-  test("rotates by local date", async () => {
-    const tmp = await createTmp();
-    let now = new Date(2026, 4, 25, 23);
-    const writer = new RotatingLogWriter({
-      logDir: tmp,
-      appName: "akan",
-      environment: "local",
-      operationMode: "local",
-      maxSizeBytes: 1024,
-      now: () => now,
-    });
-
-    try {
-      writer.write("0-federation", "before\n");
-      now = new Date(2026, 4, 26, 0);
-      writer.write("0-federation", "after\n");
-      await writer.close();
-
-      expect((await readdir(tmp)).sort()).toEqual([
-        "akan-local-local-2026-05-25-0-federation-0001.log",
-        "akan-local-local-2026-05-26-0-federation-0001.log",
-      ]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-
-  test("continues with the next sequence on restart", async () => {
-    const tmp = await createTmp();
-    const options = {
-      logDir: tmp,
-      appName: "akan",
-      environment: "local",
-      operationMode: "local",
-      maxSizeBytes: 1024,
-      now: () => new Date(2026, 4, 25, 10),
-    };
-
-    try {
-      const first = new RotatingLogWriter(options);
-      first.write("gateway", "first\n");
-      await first.close();
-
-      const second = new RotatingLogWriter(options);
-      second.write("gateway", "second\n");
-      await second.close();
-
-      expect((await readdir(tmp)).sort()).toEqual([
-        "akan-local-local-2026-05-25-gateway-0001.log",
-        "akan-local-local-2026-05-25-gateway-0002.log",
-      ]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-
-  test("keeps retention per process key", async () => {
-    const tmp = await createTmp();
-    const writer = new RotatingLogWriter({
-      logDir: tmp,
-      appName: "akan",
-      environment: "local",
-      operationMode: "local",
-      maxSizeBytes: 5,
-      maxFiles: 2,
-      now: () => new Date(2026, 4, 25, 10),
-    });
-
-    try {
-      writer.write("gateway", "11111\n");
-      writer.write("gateway", "22222\n");
-      writer.write("gateway", "33333\n");
-      writer.write("0-federation", "child\n");
-      await writer.close();
-
-      expect((await readdir(tmp)).sort()).toEqual([
-        "akan-local-local-2026-05-25-0-federation-0001.log",
-        "akan-local-local-2026-05-25-gateway-0002.log",
-        "akan-local-local-2026-05-25-gateway-0003.log",
-      ]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-});

package/server/processMetrics.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { ProcessMetricsCollector } from "./processMetricsCollector";
-
-describe("process metrics helpers", () => {
-  test("parses positive memory log intervals and falls back otherwise", () => {
-    expect(ProcessMetricsCollector.parseMemoryLogIntervalMs("1000")).toBe(1000);
-    expect(ProcessMetricsCollector.parseMemoryLogIntervalMs("0")).toBe(60_000);
-    expect(ProcessMetricsCollector.parseMemoryLogIntervalMs("not-a-number")).toBe(60_000);
-  });
-
-  test("formats memory usage as stable one-line fields", () => {
-    expect(ProcessMetricsCollector.formatBytes(1024 * 1024)).toBe("1.0MiB");
-    expect(
-      ProcessMetricsCollector.format({
-        pid: 123,
-        rssBytes: 2 * 1024 * 1024,
-        heapUsedBytes: 3 * 1024 * 1024,
-        heapTotalBytes: 4 * 1024 * 1024,
-        externalBytes: 5 * 1024 * 1024,
-        arrayBuffersBytes: 6 * 1024 * 1024,
-      }),
-    ).toBe("pid=123 rss=2.0MiB heapUsed=3.0MiB heapTotal=4.0MiB external=5.0MiB arrayBuffers=6.0MiB");
-  });
-});

package/server/proxy/webProxyRunner.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { AkanResponse } from "./akanResponse";
-import { WebProxyRunner } from "./webProxyRunner";
-
-describe("WebProxyRunner", () => {
-  test("matches default document requests and applies next header mutations", async () => {
-    class AddHeaderProxy {
-      static refName = "addHeader";
-      use(request: Bun.BunRequest) {
-        return AkanResponse.next({ request: { headers: { ...Object.fromEntries(request.headers), "x-proxy": "1" } } });
-      }
-    }
-    const request = new Request("http://localhost/dashboard") as Request & { params?: Record<string, string> };
-    request.params = { lang: "ko" };
-    const result = await new WebProxyRunner([AddHeaderProxy]).run(request);
-
-    expect(result.response).toBeUndefined();
-    expect(result.request.headers.get("x-proxy")).toBe("1");
-    expect((result.request as Request & { params?: Record<string, string> }).params).toEqual({ lang: "ko" });
-  });
-
-  test("skips static/internal paths by default and supports matcher rewrites", async () => {
-    const calls: string[] = [];
-    class DefaultProxy {
-      static refName = "defaultProxy";
-      use() {
-        calls.push("default");
-      }
-    }
-    class RewriteProxy {
-      static refName = "rewriteProxy";
-      use() {
-        calls.push("rewrite");
-        return AkanResponse.rewrite("http://localhost/rewritten");
-      }
-    }
-    const runner = new WebProxyRunner([DefaultProxy, { proxy: RewriteProxy, matcher: /^\/api\// }]);
-
-    const staticResult = await runner.run(new Request("http://localhost/favicon.ico"));
-    const apiResult = await runner.run(new Request("http://localhost/api/users"));
-
-    expect(staticResult.request.url).toBe("http://localhost/favicon.ico");
-    expect(apiResult.request.url).toBe("http://localhost/rewritten");
-    expect(calls).toEqual(["default", "rewrite"]);
-  });
-
-  test("short-circuits when a proxy returns a response", async () => {
-    class StopProxy {
-      static refName = "stopProxy";
-      use() {
-        return new Response("blocked", { status: 401 });
-      }
-    }
-    class NeverProxy {
-      static refName = "neverProxy";
-      use() {
-        throw new Error("should not run");
-      }
-    }
-
-    const result = await new WebProxyRunner([StopProxy, NeverProxy]).run(new Request("http://localhost/private"));
-
-    expect(result.response?.status).toBe(401);
-    expect(await result.response?.text()).toBe("blocked");
-  });
-});