akanjs 2.0.0-rc.7 → 2.0.1

package/test/signalTestRuntime.ts

@@ -0,0 +1,126 @@
+import type { BackendEnv } from "akanjs/base";
+import type { FetchProxy } from "akanjs/fetch";
+import type { AkanLib } from "akanjs/server";
+import { TestServer, type TestServerOptions } from "./testServer";
+
+export interface SignalTestTarget {
+  type: "app" | "lib";
+  name: string;
+  env: BackendEnv;
+  fetch: FetchProxy;
+  libs: AkanLib[];
+}
+
+export interface SignalTestContext<Fetch = FetchProxy> {
+  fetch: Fetch;
+  target: SignalTestTarget;
+  terminate: () => Promise<void>;
+}
+
+export type SignalTestOptions = Pick<TestServerOptions, "databaseMode" | "workerId" | "port" | "serverMode">;
+
+type SignalServerModule = {
+  env: BackendEnv;
+  fetch: FetchProxy;
+  lib: AkanLib;
+};
+
+let currentContext: SignalTestContext | undefined;
+let pendingContext: Promise<SignalTestContext> | undefined;
+let terminatingContext: Promise<void> | undefined;
+let configuredOptions: SignalTestOptions = {};
+
+export const hasSignalTestContext = () => currentContext !== undefined || pendingContext !== undefined;
+
+export const getSignalTestContext = <Fetch = FetchProxy>() => {
+  if (!currentContext) {
+    throw new Error("Signal test context is not initialized. Run through `akan test` or call setupSignalTestTarget().");
+  }
+  return currentContext as SignalTestContext<Fetch>;
+};
+
+export const getSignalTestFetch = <Fetch = FetchProxy>() => getSignalTestContext<Fetch>().fetch;
+
+export const getOrSetupSignalTestContext = async <Fetch = FetchProxy>() =>
+  (await setupSignalTestTarget()) as SignalTestContext<Fetch>;
+
+export const getOrSetupSignalTestFetch = async <Fetch = FetchProxy>() =>
+  (await getOrSetupSignalTestContext<Fetch>()).fetch;
+
+export const configureSignalTest = (options: SignalTestOptions) => {
+  if (currentContext || pendingContext) {
+    throw new Error("configureSignalTest() must be called before the signal test context is initialized.");
+  }
+  configuredOptions = { ...configuredOptions, ...options };
+};
+
+export const terminateSignalTestContext = async () => {
+  if (terminatingContext) return terminatingContext;
+  const context = currentContext;
+  currentContext = undefined;
+  pendingContext = undefined;
+  terminatingContext = context?.terminate() ?? Promise.resolve();
+  await terminatingContext;
+  terminatingContext = undefined;
+};
+
+const importServerModule = async (type: "app" | "lib", name: string): Promise<SignalServerModule> => {
+  return type === "app" ? await import(`@apps/${name}/server`) : await import(`@libs/${name}/server`);
+};
+
+const importLibModule = async (name: string): Promise<SignalServerModule> => {
+  return await import(`@libs/${name}/server`);
+};
+
+export const setupSignalTestTarget = async <Fetch = FetchProxy>(
+  {
+    type = process.env.AKAN_TEST_TARGET_TYPE as "app" | "lib" | undefined,
+    name = process.env.AKAN_TEST_TARGET_NAME,
+    libNames = process.env.AKAN_TEST_LIBS?.split(",").filter(Boolean),
+  }: { type?: "app" | "lib"; name?: string; libNames?: string[] } = {},
+  options: SignalTestOptions = {},
+) => {
+  if (currentContext) return currentContext as SignalTestContext<Fetch>;
+  if (pendingContext) return pendingContext as Promise<SignalTestContext<Fetch>>;
+  if (!type || !name) throw new Error("Signal test target is not configured.");
+
+  pendingContext = (async () => {
+    terminatingContext = undefined;
+    const resolvedOptions = { ...configuredOptions, ...options };
+    const env: BackendEnv = {
+      repoName: process.env.AKAN_PUBLIC_REPO_NAME ?? "akansoft",
+      serveDomain: process.env.AKAN_PUBLIC_SERVE_DOMAIN ?? "akamir.com",
+      appName: name,
+      environment: "testing",
+      operationMode: "local",
+      tunnelUsername: process.env.SSH_TUNNEL_USERNAME ?? "root",
+      tunnelPassword: process.env.SSH_TUNNEL_PASSWORD ?? process.env.AKAN_PUBLIC_REPO_NAME ?? "akansoft",
+    };
+    TestServer.applyProcessEnv(env, resolvedOptions);
+
+    const [dependencyModules, targetModule] = await Promise.all([
+      Promise.all((libNames ?? []).filter((libName) => libName !== name).map(importLibModule)),
+      importServerModule(type, name),
+    ]);
+    const target: SignalTestTarget = {
+      type,
+      name,
+      env: targetModule.env,
+      fetch: targetModule.fetch,
+      libs: [...dependencyModules.map((mod) => mod.lib), targetModule.lib],
+    };
+    const testServer = new TestServer(target.env, target.libs, {
+      databaseMode: "memory",
+      ...resolvedOptions,
+    });
+    await testServer.init();
+    currentContext = {
+      fetch: target.fetch,
+      target,
+      terminate: () => testServer.terminate(),
+    };
+    return currentContext;
+  })();
+
+  return pendingContext as Promise<SignalTestContext<Fetch>>;
+};

package/test/testServer.ts

@@ -1,36 +1,99 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import type { BackendEnv } from "akanjs/base";
 import { Logger, sleep } from "akanjs/common";
+import { type AkanLib, AkanServer } from "akanjs/server";
 
 const MAX_RETRY = 5;
 const TEST_LISTEN_PORT_BASE = 38080;
-const TEST_REDIS_PORT_BASE = 38082;
 const MIN_ACTIVATION_TIME = 0;
 const MAX_ACTIVATION_TIME = 30000;
 
+type TestDatabaseMode = "memory" | "tempFile";
+
+export interface TestServerOptions {
+  workerId?: number;
+  port?: number;
+  databaseMode?: TestDatabaseMode;
+  serverMode?: "federation" | "batch" | "all";
+  listen?: boolean;
+  web?: boolean;
+}
+
+const TEST_ENV_KEYS = [
+  "NODE_ENV",
+  "SERVER_MODE",
+  "PORT",
+  "AKAN_PUBLIC_APP_NAME",
+  "AKAN_PUBLIC_REPO_NAME",
+  "AKAN_PUBLIC_SERVE_DOMAIN",
+  "AKAN_PUBLIC_ENV",
+  "AKAN_PUBLIC_OPERATION_MODE",
+  "AKAN_PUBLIC_SERVER_PORT",
+  "SERVER_HTTP_PROTOCOL",
+] as const;
+
+const resolveWorkerId = (workerId?: number) => {
+  if (workerId !== undefined) return workerId;
+  const bunWorkerId = Number(process.env.BUN_WORKER_ID);
+  if (Number.isInteger(bunWorkerId) && bunWorkerId > 0) return bunWorkerId;
+  return Math.max(process.pid % 1000, 1);
+};
+
 export class TestServer {
   readonly #logger = new Logger("TestServer");
-  readonly #redis: any;
-
+  readonly #libs: AkanLib[];
   readonly #env: BackendEnv;
+  readonly #databaseMode: TestDatabaseMode;
+  readonly #serverMode: "federation" | "batch" | "all";
+  readonly #listen: boolean;
+  readonly #web: boolean;
+  readonly #port: number;
+  readonly #previousEnv = new Map<(typeof TEST_ENV_KEYS)[number], string | undefined>();
   workerId: number;
   #startAt = Date.now();
-  
-  #portOffset = 0;
-  static initClient(env: BackendEnv, workerId = parseInt(process.env.JEST_WORKER_ID ?? "0")) {
-    if (workerId === 0) throw new Error("TestClient should not be used in main thread");
+  #server?: AkanServer;
+  #tempDir?: string;
+  static initClient(env: BackendEnv, workerId?: number) {
+    TestServer.applyProcessEnv(env, {
+      workerId,
+      port: TEST_LISTEN_PORT_BASE + resolveWorkerId(workerId),
+      serverMode: "all",
+    });
   }
-  constructor(
-
+  static applyProcessEnv(
     env: BackendEnv,
-    workerId?: number,
+    {
+      workerId,
+      port,
+      serverMode = "all",
+    }: { workerId?: number; port?: number; serverMode?: "federation" | "batch" | "all" } = {},
   ) {
-    this.workerId = workerId ?? parseInt(process.env.JEST_WORKER_ID ?? "0");
-    if (this.workerId === 0) throw new Error("TestServer should not be used in main thread");
-    this.#portOffset = this.workerId * 1000; 
-    this.#redis = 1 as any; 
+    const resolvedPort = port ?? TEST_LISTEN_PORT_BASE + resolveWorkerId(workerId);
+    process.env.NODE_ENV = "test";
+    process.env.SERVER_MODE = serverMode;
+    process.env.PORT = String(resolvedPort);
+    process.env.AKAN_PUBLIC_APP_NAME = env.appName;
+    process.env.AKAN_PUBLIC_REPO_NAME = env.repoName;
+    process.env.AKAN_PUBLIC_SERVE_DOMAIN = env.serveDomain;
+    process.env.AKAN_PUBLIC_ENV = env.environment;
+    process.env.AKAN_PUBLIC_OPERATION_MODE = env.operationMode;
+    process.env.AKAN_PUBLIC_SERVER_PORT = String(resolvedPort);
+    process.env.SERVER_HTTP_PROTOCOL = "http:";
+  }
+  constructor(env: BackendEnv, libs: AkanLib | AkanLib[], options: TestServerOptions = {}) {
+    this.workerId = resolveWorkerId(options.workerId);
+    this.#port = options.port ?? TEST_LISTEN_PORT_BASE + this.workerId;
     this.#env = { ...env };
+    this.#libs = Array.isArray(libs) ? libs : [libs];
+    this.#databaseMode = options.databaseMode ?? "memory";
+    this.#serverMode = options.serverMode ?? "all";
+    this.#listen = options.listen ?? true;
+    this.#web = options.web ?? false;
   }
   async init() {
+    let lastError: unknown;
     for (let i = 0; i < MAX_RETRY; i++) {
       try {
         const watchdog = setTimeout(() => {
@@ -40,43 +103,85 @@ export class TestServer {
         clearTimeout(watchdog);
         return;
       } catch (e) {
+        lastError = e;
         this.#logger.error(e as string);
         await this.terminate();
       }
     }
+    throw lastError instanceof Error ? lastError : new Error("TestServer Init Failed");
   }
   async #init() {
     const now = Date.now();
     this.#logger.log(`Test System #${this.workerId} Initializing...`);
-    const port = TEST_LISTEN_PORT_BASE + this.#portOffset;
-    const [redisHost, redisPort] = await Promise.all([this.#redis.getHost(), this.#redis.getPort()]);
-    this.#env.port = port;
+    this.#rememberProcessEnv();
+    TestServer.applyProcessEnv(this.#env, { workerId: this.workerId, port: this.#port, serverMode: this.#serverMode });
+    const { databaseFilePath, solidFilePath } = await this.#makeDatabaseFiles();
+    this.#env.port = this.#port;
     this.#env.database = {
       driver: "sqlite",
-      sqlite: { filePath: `${process.cwd()}/local/test/${this.#env.appName}_${this.workerId}.db` },
+      sqlite: {
+        filePath: databaseFilePath,
+        journalMode: this.#databaseMode === "memory" ? "MEMORY" : "WAL",
+        synchronous: this.#databaseMode === "memory" ? "OFF" : "NORMAL",
+        foreignKeys: true,
+      },
+    };
+    this.#env.solid = {
+      filePath: solidFilePath,
+      journalMode: this.#databaseMode === "memory" ? "MEMORY" : "WAL",
+      synchronous: this.#databaseMode === "memory" ? "OFF" : "NORMAL",
+      cleanupIntervalMs: 60_000,
+      queuePollIntervalMs: 60_000,
+      queueLeaseMs: 30_000,
     };
-    
     this.#env.onCleanup = async () => {
       await this.cleanup();
     };
-
-    this.#logger.log(`Test System #${this.workerId} Initialized, SQLite, Redis: ${redisHost}:${redisPort}`);
+    this.#server = new AkanServer(this.#env.appName, this.#env, this.#serverMode, ...this.#libs);
+    await this.#server.start({ listen: this.#listen, web: this.#web });
+    this.#logger.log(`Test System #${this.workerId} Initialized, SQLite: ${this.#databaseMode}`);
     this.#startAt = Date.now();
     this.#logger.log(`Test System #${this.workerId} Activation Time: ${this.#startAt - now}ms`);
   }
   async cleanup() {
-    this.#logger.log("SQLite test database cleanup is handled by file replacement.");
+    this.#logger.log("SQLite test database cleanup is handled by server termination.");
   }
   async terminate() {
     const now = Date.now();
     const elapsed = now - this.#startAt;
-    await sleep(50);
-
+    await sleep(50); 
+    await this.#server?.stop();
+    this.#server = undefined;
+    if (this.#tempDir) {
+      await rm(this.#tempDir, { recursive: true, force: true });
+      this.#tempDir = undefined;
+    }
+    this.#restoreProcessEnv();
     if (elapsed < MIN_ACTIVATION_TIME) {
       this.#logger.log(`waiting for ${MIN_ACTIVATION_TIME - elapsed}`);
       await sleep(MIN_ACTIVATION_TIME - elapsed);
     }
-    await Promise.all([this.#redis.stop()]);
     this.#logger.log(`System Terminated in ${Date.now() - now}ms`);
   }
+  #rememberProcessEnv() {
+    this.#previousEnv.clear();
+    TEST_ENV_KEYS.forEach((key) => {
+      this.#previousEnv.set(key, process.env[key]);
+    });
+  }
+  #restoreProcessEnv() {
+    this.#previousEnv.forEach((value, key) => {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    });
+    this.#previousEnv.clear();
+  }
+  async #makeDatabaseFiles() {
+    if (this.#databaseMode === "memory") return { databaseFilePath: ":memory:", solidFilePath: ":memory:" };
+    this.#tempDir = await mkdtemp(join(tmpdir(), `akan-${this.#env.appName}-${this.workerId}-`));
+    return {
+      databaseFilePath: join(this.#tempDir, `${this.#env.appName}.db`),
+      solidFilePath: join(this.#tempDir, `${this.#env.appName}.solid.db`),
+    };
+  }
 }