akanjs 2.2.4-rc.4 → 2.2.4

package/server/logging/rotatingLogWriter.test.ts

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,24 @@
+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/processMetricsCollector.ts

@@ -34,7 +34,7 @@ class EventLoopLagMonitor {
       if (this.#samples.length < EventLoopLagMonitor.#maxSamples) this.#samples.push(lag);
       else this.#samples[Math.floor(Math.random() * EventLoopLagMonitor.#maxSamples)] = lag;
     }, intervalMs);
-    
+    // Do not keep the process alive solely for lag sampling.
     (this.#timer as { unref?: () => void }).unref?.();
   }
 

package/server/proxy/webProxyRunner.test.ts

@@ -0,0 +1,66 @@
+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");
+  });
+});

package/server/resolver/database.resolver.ts

@@ -171,7 +171,7 @@ export class DatabaseResolver {
             select(select?: any) {
               return createFindManyChain(query, { ...options, select });
             },
-            
+            // biome-ignore lint/suspicious/noThenProperty: model facade intentionally supports Mongoose-style awaitable queries.
             then(resolve: (value: any[]) => void, reject: (reason: unknown) => void) {
               return store.find(query, options).then(resolve, reject);
             },
@@ -192,7 +192,7 @@ export class DatabaseResolver {
             select(select?: any) {
               return createFindOneChain(query, { ...options, select });
             },
-            
+            // biome-ignore lint/suspicious/noThenProperty: model facade intentionally supports Mongoose-style awaitable queries.
             then(resolve: (value: any | null) => void, reject: (reason: unknown) => void) {
               return store.findOne(query, options).then(resolve, reject);
             },

package/server/resolver/resolver.contract.fixture.ts

@@ -72,6 +72,7 @@ export class ServerResolverTestModelMixin {
     ServerResolverTestModelMixin.schemaTouched = true;
     schema.index({ category: 1 });
     schema.pre("create", () => {
+      //
     });
   }
   static modelKind() {