akanjs 3.0.0-beta.9 → 3.0.1

package/test/conformance.ts

@@ -0,0 +1,299 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  DEFAULT_TOKENIZER,
+  getSolidConfig,
+  LibsqlDatabase,
+  PostgresDatabase,
+  PostgresDialect,
+  RedisCache,
+  Scheduler,
+  type SearchConfig,
+  SolidCache,
+  type SqlDialect,
+  SqliteDatabase,
+  SqliteDialect,
+} from "akanjs/service";
+
+type ConformanceBackend = "redis" | "postgres" | "libsql";
+
+export type ConformanceCacheKind = "solid" | "redis";
+
+/** `libsqlRemote` is a sqld server shared by every run, so it only hosts cases that bring their own table. */
+export type SqlDriverKind = "sqlite" | "libsql" | "postgres" | "libsqlRemote";
+
+export interface SqlDriverOptions {
+  insight?: boolean;
+  memory?: boolean;
+  search?: SearchConfig;
+}
+
+export interface SqlDriver {
+  kind: SqlDriverKind;
+  database: SqliteDatabase | LibsqlDatabase | PostgresDatabase;
+  dialect: SqlDialect;
+  /** A new adaptor on the same storage — what a process restart sees, so only what was committed. */
+  restart: () => Promise<SqlDriver>;
+  /** A second adaptor on the same storage while this one stays open: another process, with these search settings. */
+  sibling: (search?: SearchConfig) => Promise<SqlDriver>;
+  /** A restart with other text search settings — a redeploy that changed `AKAN_SEARCH_*`. */
+  reconfigure: (search: SearchConfig) => Promise<SqlDriver>;
+  close: () => Promise<void>;
+}
+
+const backendEnvNames = {
+  redis: "AKAN_TEST_REDIS_URL",
+  postgres: "AKAN_TEST_POSTGRES_URL",
+  libsql: "AKAN_TEST_LIBSQL_URL",
+} as const;
+
+/** `bun run testConformance` (`infra/test/compose.yaml`) sets all three backends; plain `bun test` runs SQLite. */
+export class ConformanceEnv {
+  static readonly #announced = new Set<string>();
+  /** Where a deployment points an app at its data. A test that hands its storage in has these cleared first. */
+  static readonly deploymentEnvKeys = [
+    "AKAN_DATABASE_MODES",
+    "AKAN_SOLID_DB_PATH",
+    "SQLITE_DATABASE_PATH",
+    "LIBSQL_URL",
+    "LIBSQL_URI",
+    "LIBSQL_AUTH_TOKEN",
+    "POSTGRES_URL",
+    "POSTGRES_URI",
+    "POSTGRES_HOST",
+    "POSTGRES_PORT",
+    "POSTGRES_DATABASE",
+    "POSTGRES_DB",
+    "POSTGRES_USER",
+    "POSTGRES_PASSWORD",
+    "POSTGRES_INSIGHT_URL",
+  ] as const;
+
+  /** This process's env without what a deployment would point the app at. */
+  static isolatedProcessEnv() {
+    const env: Record<string, string | undefined> = { ...process.env };
+    for (const key of ConformanceEnv.deploymentEnvKeys) delete env[key];
+    return env;
+  }
+
+  static url(backend: ConformanceBackend): string | null {
+    return process.env[backendEnvNames[backend]]?.trim() || null;
+  }
+
+  /** Says once per suite and backend when it is missing: a skipped suite must never read as a passing one. */
+  static has(suite: string, backend: ConformanceBackend): boolean {
+    if (ConformanceEnv.url(backend)) return true;
+    const key = `${suite}:${backend}`;
+    if (!ConformanceEnv.#announced.has(key)) {
+      ConformanceEnv.#announced.add(key);
+      console.info(
+        `[conformance] ${suite}: ${backend} cases skipped — set ${backendEnvNames[backend]}, or run \`bun run testConformance\``,
+      );
+    }
+    return false;
+  }
+
+  static uniqueName(prefix: string) {
+    return `${prefix}_${process.pid}_${crypto.randomUUID().replaceAll("-", "").slice(0, 8)}`;
+  }
+
+  static async tempDir(prefix: string) {
+    const dir = await mkdtemp(path.join(tmpdir(), `${prefix}-`));
+    return { dir, remove: async () => await rm(dir, { recursive: true, force: true }) };
+  }
+
+  /**
+   * A throwaway schema and a URL pinning every pooled connection to it: postgres.js forwards unknown query parameters
+   * as startup parameters, so `search_path` holds on later connections too. `insight` adds a login role, dropped too.
+   */
+  static async postgresSchema(prefix: string, { insight = false }: { insight?: boolean } = {}) {
+    const base = ConformanceEnv.url("postgres");
+    if (!base) throw new Error("postgresSchema() needs AKAN_TEST_POSTGRES_URL");
+    const schema = ConformanceEnv.uniqueName(prefix).toLowerCase();
+    const role = `${schema}_insight`;
+    const { default: postgres } = await import("postgres");
+    const admin = postgres(base, { max: 1, onnotice: () => undefined });
+    await admin.unsafe(`CREATE SCHEMA "${schema}"`);
+    const insightUrl = insight ? await ConformanceEnv.#createLoginRole(admin, base, role) : undefined;
+    await admin.end();
+    const url = new URL(base);
+    url.searchParams.set("search_path", schema);
+    return {
+      schema,
+      url: url.toString(),
+      insightUrl,
+      drop: async () => {
+        const dropper = postgres(base, { max: 1, onnotice: () => undefined });
+        await dropper.unsafe(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+        if (insight) await dropper.unsafe(`DROP ROLE IF EXISTS "${role}"`);
+        await dropper.end();
+      },
+    };
+  }
+
+  /** A login role with no privilege and no membership, and the URL that logs in as it. */
+  static async createPostgresLoginRole(role: string) {
+    const base = ConformanceEnv.url("postgres");
+    if (!base) throw new Error("createPostgresLoginRole() needs AKAN_TEST_POSTGRES_URL");
+    const { default: postgres } = await import("postgres");
+    const admin = postgres(base, { max: 1, onnotice: () => undefined });
+    const url = await ConformanceEnv.#createLoginRole(admin, base, role);
+    await admin.end();
+    return {
+      url,
+      drop: async () => {
+        const dropper = postgres(base, { max: 1, onnotice: () => undefined });
+        await dropper.unsafe(`DROP OWNED BY "${role}"`);
+        await dropper.unsafe(`DROP ROLE IF EXISTS "${role}"`);
+        await dropper.end();
+      },
+    };
+  }
+
+  static async #createLoginRole(admin: { unsafe: (sql: string) => Promise<unknown> }, base: string, role: string) {
+    const password = crypto.randomUUID().replaceAll("-", "");
+    await admin.unsafe(`CREATE ROLE "${role}" LOGIN PASSWORD '${password}'`);
+    const url = new URL(base);
+    url.username = role;
+    url.password = password;
+    return url.toString();
+  }
+
+  static cacheKinds(suite: string): ConformanceCacheKind[] {
+    return ConformanceEnv.has(suite, "redis") ? ["solid", "redis"] : ["solid"];
+  }
+
+  /** `app` stands for the app that built the cache: on Redis it is the key prefix, and closing deletes under it. */
+  static async openCache(
+    kind: ConformanceCacheKind,
+    { app = ConformanceEnv.uniqueName("app") }: { app?: string } = {},
+  ) {
+    if (kind === "solid") {
+      const { dir, remove } = await ConformanceEnv.tempDir("akan-cache");
+      const cache = new SolidCache();
+      Object.assign(cache, { config: getSolidConfig({ solid: { filePath: path.join(dir, `${app}.db`) } }) });
+      await cache.onInit();
+      return {
+        cache: cache as SolidCache | RedisCache,
+        close: async () => {
+          await cache.onDestroy();
+          await remove();
+        },
+      };
+    }
+    const { Redis } = await import("ioredis");
+    const client = new Redis(ConformanceEnv.url("redis") as string, { lazyConnect: true });
+    await client.connect();
+    const cache = new RedisCache();
+    const keyPrefix = `${app}:testing:`;
+    Object.assign(cache, { redis: client, keyPrefix });
+    return {
+      cache: cache as SolidCache | RedisCache,
+      close: async () => {
+        const keys = await client.keys(`${keyPrefix}*`);
+        if (keys.length) await client.del(...keys);
+        await cache.onDestroy();
+      },
+    };
+  }
+
+  /** The local drivers always, and each remote one whose backend the suite can reach. */
+  static sqlDrivers(suite: string, { remote = false }: { remote?: boolean } = {}): SqlDriverKind[] {
+    const kinds: SqlDriverKind[] = ["sqlite"];
+    if (ConformanceEnv.#hasLibsqlBinding(suite)) kinds.push("libsql");
+    if (ConformanceEnv.has(suite, "postgres")) kinds.push("postgres");
+    if (remote && ConformanceEnv.has(suite, "libsql")) kinds.push("libsqlRemote");
+    return kinds;
+  }
+
+  static #hasLibsqlBinding(suite: string) {
+    if (process.platform !== "win32" || process.arch !== "arm64") return true;
+    const key = `${suite}:libsql-binding`;
+    if (!ConformanceEnv.#announced.has(key)) {
+      ConformanceEnv.#announced.add(key);
+      console.info(`[conformance] ${suite}: local libsql cases skipped — libsql publishes no win32-arm64 binding`);
+    }
+    return false;
+  }
+
+  /**
+   * The real adaptor, initialised as the DI container would, on storage nothing else sees. `insight` gives Postgres a
+   * login role for `InsightQuery`; `memory` puts SQLite in memory, as `TestServer` does.
+   */
+  static async openSqlDriver(kind: SqlDriverKind, options: SqlDriverOptions = {}): Promise<SqlDriver> {
+    return await ConformanceEnv.#openSqlAdaptor(kind, await ConformanceEnv.#sqlStorage(kind, options));
+  }
+
+  static async #sqlStorage(
+    kind: SqlDriverKind,
+    { insight = false, memory = false, search: searchConfig }: SqlDriverOptions,
+  ): Promise<{ config: object; remove: () => Promise<void> }> {
+    const search = { enabled: kind !== "libsqlRemote", tokenizer: DEFAULT_TOKENIZER, ...searchConfig };
+    if (kind === "postgres") {
+      const { url, insightUrl, drop } = await ConformanceEnv.postgresSchema("akan_sql", { insight });
+      return { config: { url, insightUrl, search }, remove: drop };
+    }
+    if (kind === "libsqlRemote")
+      return { config: { url: ConformanceEnv.url("libsql"), search }, remove: async () => undefined };
+    if (kind === "sqlite" && memory)
+      return {
+        config: { filePath: ":memory:", journalMode: "MEMORY", synchronous: "OFF", foreignKeys: true, search },
+        remove: async () => undefined,
+      };
+    const { dir, remove } = await ConformanceEnv.tempDir(`akan-${kind}`);
+    const filePath = path.join(dir, "conformance.db");
+    return {
+      config:
+        kind === "sqlite"
+          ? { filePath, journalMode: "WAL", busyTimeoutMs: 5000, synchronous: "NORMAL", foreignKeys: true, search }
+          : { url: `file:${filePath}`, search },
+      remove,
+    };
+  }
+
+  static #withSearch(config: object, search: SearchConfig) {
+    const current = (config as { search?: SearchConfig }).search;
+    return { ...config, search: { ...current, ...search } };
+  }
+
+  static async #openSqlAdaptor(
+    kind: SqlDriverKind,
+    storage: { config: object; remove: () => Promise<void> },
+  ): Promise<SqlDriver> {
+    const scheduler = new Scheduler();
+    const database =
+      kind === "postgres" ? new PostgresDatabase() : kind === "sqlite" ? new SqliteDatabase() : new LibsqlDatabase();
+    Object.assign(database, { scheduler, config: storage.config });
+    await database.onInit();
+    const shutdown = async () => {
+      await database.onDestroy();
+      await scheduler.onDestroy();
+    };
+    return {
+      kind,
+      database,
+      dialect: kind === "postgres" ? new PostgresDialect() : new SqliteDialect(),
+      restart: async () => {
+        await shutdown();
+        return await ConformanceEnv.#openSqlAdaptor(kind, storage);
+      },
+      sibling: async (search: SearchConfig = {}) =>
+        await ConformanceEnv.#openSqlAdaptor(kind, {
+          config: ConformanceEnv.#withSearch(storage.config, search),
+          remove: async () => undefined,
+        }),
+      reconfigure: async (search: SearchConfig) => {
+        await shutdown();
+        return await ConformanceEnv.#openSqlAdaptor(kind, {
+          ...storage,
+          config: ConformanceEnv.#withSearch(storage.config, search),
+        });
+      },
+      close: async () => {
+        await shutdown();
+        await storage.remove();
+      },
+    };
+  }
+}

package/test/index.ts

@@ -1,5 +1,5 @@
-export { sample } from "./sample";
-export { sampleOf } from "./sampleOf";
+export { type ConformanceCacheKind, ConformanceEnv, type SqlDriver, type SqlDriverKind } from "./conformance";
+export { sample, sampleOf } from "./sampleOf";
 export {
   configureSignalTest,
   getOrSetupSignalTestContext,

package/test/sampleOf.ts

@@ -2,6 +2,10 @@ import {
   Any,
   Binary,
   type Cls,
+  type Dayjs,
+  DEFAULT_VALUE,
+  dayjs,
+  EXAMPLE_VALUE,
   FIELD_META,
   Float,
   ID,
@@ -10,10 +14,33 @@ import {
   type PrimitiveScalar,
   Upload,
 } from "akanjs/base";
-import { randomPick } from "akanjs/common";
-import type { BaseObject, ConstantCls, ConstantField, DocumentModel, FieldObject, FieldPreset } from "akanjs/constant";
+import { randomPick, randomPicks } from "akanjs/common";
+import {
+  type BaseObject,
+  type ConstantCls,
+  type ConstantField,
+  type DocumentModel,
+  type FieldObject,
+  type FieldPreset,
+  freshPrimitiveValue,
+} from "akanjs/constant";
+import Chance from "chance";
+
+const chance = new Chance();
 
-import { sample } from "./sample";
+export const sample = Object.assign(chance, {
+  dayjs: (opt?: {
+    string?: boolean | undefined;
+    american?: boolean | undefined;
+    year?: number | undefined;
+    month?: number | undefined;
+    day?: number | undefined;
+    min?: Dayjs | undefined;
+    max?: Dayjs | undefined;
+  }) => dayjs(chance.date({ ...opt, min: opt?.min?.toDate(), max: opt?.max?.toDate() })),
+  pick: randomPick,
+  picks: randomPicks,
+});
 
 const getFieldTypeExample: { [key in FieldPreset]: () => any } = {
   email: () => sample.email(),
@@ -33,15 +60,17 @@ const scalarSampleMap = new Map<PrimitiveScalar, () => any>([
   [Any, () => ({})],
 ]);
 const getPrimitiveSample = (ref: Cls, field: ConstantField) => {
-  if (field.type) {
-    return getFieldTypeExample[field.type]() as string;
-  } else if (typeof field.min === "number") {
-    return field.min;
-  } else if (typeof field.max === "number") {
-    return field.max;
-  } else {
-    return (scalarSampleMap.get(ref)?.() ?? null) as string | null;
-  }
+  if (field.type) return getFieldTypeExample[field.type]() as string;
+  if (typeof field.min === "number") return field.min;
+  if (typeof field.max === "number") return field.max;
+  const sampler = scalarSampleMap.get(ref);
+  return (sampler ? sampler() : primitiveSampleOf(ref as unknown as typeof PrimitiveScalar)) as string | null;
+};
+
+const primitiveSampleOf = (primitive: typeof PrimitiveScalar) => {
+  const example = primitive[EXAMPLE_VALUE];
+  if (example === null || example === undefined) return freshPrimitiveValue(primitive[DEFAULT_VALUE]) ?? null;
+  return primitive._parse(freshPrimitiveValue(example) as never);
 };
 
 const makeSample = (field: ConstantField): any => {
@@ -49,24 +78,19 @@ const makeSample = (field: ConstantField): any => {
     return typeof field.default === "function" ? (field.default as () => object)() : (field.default as object);
   else if (field.enum) return randomPick([...field.enum.values]);
   if (PrimitiveRegistry.has(field.modelRef)) return getPrimitiveSample(field.modelRef, field);
-  return Object.fromEntries(
-    Object.entries(field.modelRef[FIELD_META]).map(
-      ([key, fld]) => [key, fld.arrDepth ? [] : fld.isClass && !fld.isScalar ? null : makeSample(fld)] as const,
-    ),
-  );
+  return sampleFields(field.modelRef[FIELD_META]);
 };
 
-export type SampleOf<Model> = DocumentModel<{
-  [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]>;
-}>;
-export const sampleOf = <Model, FieldObj extends FieldObject>(
-  modelRef: ConstantCls<Model, FieldObj>,
-): DocumentModel<{ [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]> }> => {
-  
-  return Object.fromEntries(
-    Object.entries(modelRef[FIELD_META]).map(([key, field]) => [
+const sampleFields = (fieldMap: FieldObject) =>
+  Object.fromEntries(
+    Object.entries(fieldMap).map(([key, field]) => [
       key,
       field.arrDepth ? [] : field.isClass && !field.isScalar ? null : makeSample(field),
     ]),
-  ) as any;
-};
+  );
+
+export type SampleOf<Model> = DocumentModel<{
+  [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]>;
+}>;
+export const sampleOf = <Model, FieldObj extends FieldObject>(modelRef: ConstantCls<Model, FieldObj>) =>
+  sampleFields(modelRef[FIELD_META]) as SampleOf<Model>;

package/test/signalTestRuntime.ts

@@ -17,10 +17,10 @@ export interface SignalTestContext<Fetch = FetchProxy> {
   terminate: () => Promise<void>;
 }
 
-export type SignalTestOptions = Pick<TestServerOptions, "databaseMode" | "workerId" | "port" | "serverMode">;
+export type SignalTestOptions = Pick<TestServerOptions, "storage" | "workerId" | "port" | "serverMode">;
 
 type SignalServerModule = {
-  env: BackendEnv;
+  env?: BackendEnv;
   fetch: FetchProxy;
   lib: AkanLib;
 };
@@ -33,9 +33,8 @@ let configuredOptions: SignalTestOptions = {};
 export const hasSignalTestContext = () => currentContext !== undefined || pendingContext !== undefined;
 
 export const getSignalTestContext = <Fetch = FetchProxy>() => {
-  if (!currentContext) {
+  if (!currentContext)
     throw new Error("Signal test context is not initialized. Run through `akan test` or call setupSignalTestTarget().");
-  }
   return currentContext as SignalTestContext<Fetch>;
 };
 
@@ -64,13 +63,15 @@ export const terminateSignalTestContext = async () => {
   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 importServerModule = async (type: "app" | "lib", name: string): Promise<SignalServerModule> =>
+  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`);
-};
+const importLibModule = async (name: string): Promise<SignalServerModule> => await import(`@libs/${name}/server`);
+
+const importTestingEnv = async (type: "app" | "lib", name: string, targetModule: SignalServerModule) =>
+  type === "app"
+    ? ((await import(`@apps/${name}/env/env.server.testing`)) as { env?: BackendEnv }).env
+    : targetModule.env;
 
 export const setupSignalTestTarget = async <Fetch = FetchProxy>(
   {
@@ -100,15 +101,16 @@ export const setupSignalTestTarget = async <Fetch = FetchProxy>(
       Promise.all((libNames ?? []).filter((libName) => libName !== name).map(importLibModule)),
       importServerModule(type, name),
     ]);
+    const testingEnv = await importTestingEnv(type, name, targetModule);
     const target: SignalTestTarget = {
       type,
       name,
-      env: { ...env, ...targetModule.env },
+      env: { ...env, ...testingEnv },
       fetch: targetModule.fetch,
       libs: [...dependencyModules.map((mod) => mod.lib), targetModule.lib],
     };
     const testServer = new TestServer(target.env, target.libs, {
-      databaseMode: "memory",
+      storage: "memory",
       ...resolvedOptions,
     });
     await testServer.init();

package/test/testServer.ts

@@ -1,16 +1,16 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { BackendEnv, BaseEnv } from "akanjs/base";
+import { type BackendEnv, type BaseEnv, type DatabaseMode, DatabaseModes, resetEnvCache } from "akanjs/base";
 import { Logger, sleep } from "akanjs/common";
 import { type AkanLib, AkanServer } from "akanjs/server";
+import { ConformanceEnv } from "./conformance";
 
 const MAX_RETRY = 5;
 const TEST_LISTEN_PORT_BASE = 38080;
-const MIN_ACTIVATION_TIME = 0;
 const MAX_ACTIVATION_TIME = 30000;
 
-type TestDatabaseMode = "memory" | "tempFile";
+type TestStorage = "memory" | "tempFile";
 
 /** `BackendEnv` carries server options only, so a harness that also stamps `process.env` needs the identity beside it. */
 export type TestEnv = BaseEnv & BackendEnv;
@@ -18,7 +18,8 @@ export type TestEnv = BaseEnv & BackendEnv;
 export interface TestServerOptions {
   workerId?: number;
   port?: number;
-  databaseMode?: TestDatabaseMode;
+  /** Where the SQLite files live. */
+  storage?: TestStorage;
   serverMode?: "federation" | "batch" | "all";
   listen?: boolean;
   web?: boolean;
@@ -35,6 +36,9 @@ const TEST_ENV_KEYS = [
   "AKAN_PUBLIC_OPERATION_MODE",
   "AKAN_PUBLIC_SERVER_PORT",
   "SERVER_HTTP_PROTOCOL",
+  "AKAN_DATABASE_MODE",
+  "REDIS_URI",
+  ...ConformanceEnv.deploymentEnvKeys,
 ] as const;
 
 const resolveWorkerId = (workerId?: number) => {
@@ -48,7 +52,9 @@ export class TestServer {
   readonly #logger = new Logger("TestServer");
   readonly #libs: AkanLib[];
   readonly #env: TestEnv;
-  readonly #databaseMode: TestDatabaseMode;
+  readonly #storage: TestStorage;
+  readonly #mode: DatabaseMode = TestServer.#modeFromEnv();
+  #dropSchema: (() => Promise<void>) | null = null;
   readonly #serverMode: "federation" | "batch" | "all";
   readonly #listen: boolean;
   readonly #web: boolean;
@@ -90,7 +96,7 @@ export class TestServer {
     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.#storage = options.storage ?? "memory";
     this.#serverMode = options.serverMode ?? "all";
     this.#listen = options.listen ?? true;
     this.#web = options.web ?? false;
@@ -117,32 +123,30 @@ export class TestServer {
     const now = Date.now();
     this.#logger.info(`Test System #${this.workerId} Initializing...`);
     this.#rememberProcessEnv();
+    
+    for (const key of ConformanceEnv.deploymentEnvKeys) delete process.env[key];
     TestServer.applyProcessEnv(this.#env, { workerId: this.workerId, port: this.#port, serverMode: this.#serverMode });
     const { databaseFilePath, solidFilePath } = await this.#makeDatabaseFiles();
+    const pragmas =
+      this.#storage === "memory"
+        ? { journalMode: "MEMORY", synchronous: "OFF" }
+        : { journalMode: "WAL", synchronous: "NORMAL" };
     this.#env.port = this.#port;
-    this.#env.database = {
-      driver: "sqlite",
-      sqlite: {
-        filePath: databaseFilePath,
-        journalMode: this.#databaseMode === "memory" ? "MEMORY" : "WAL",
-        synchronous: this.#databaseMode === "memory" ? "OFF" : "NORMAL",
-        foreignKeys: true,
-      },
-    };
+    this.#env.database = { sqlite: { filePath: databaseFilePath, ...pragmas, foreignKeys: true } };
     this.#env.solid = {
       filePath: solidFilePath,
-      journalMode: this.#databaseMode === "memory" ? "MEMORY" : "WAL",
-      synchronous: this.#databaseMode === "memory" ? "OFF" : "NORMAL",
+      ...pragmas,
       cleanupIntervalMs: 60_000,
       queuePollIntervalMs: 60_000,
       queueLeaseMs: 30_000,
     };
-    this.#env.onCleanup = async () => {
-      await this.cleanup();
-    };
+    this.#env.onCleanup = () => this.cleanup();
+    await this.#applyDatabaseMode();
     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.info(`Test System #${this.workerId} Initialized, SQLite: ${this.#databaseMode}`);
+    this.#logger.info(
+      `Test System #${this.workerId} Initialized, database mode: ${this.#mode}, SQLite: ${this.#storage}`,
+    );
     this.#startAt = Date.now();
     this.#logger.info(`Test System #${this.workerId} Activation Time: ${this.#startAt - now}ms`);
   }
@@ -151,26 +155,56 @@ export class TestServer {
   }
   async terminate() {
     const now = Date.now();
-    const elapsed = now - this.#startAt;
-    await sleep(50); 
+    await sleep(50);
     await this.#server?.stop();
     this.#server = undefined;
+    await this.#dropSchema?.();
+    this.#dropSchema = null;
     if (this.#tempDir) {
       await rm(this.#tempDir, { recursive: true, force: true });
       this.#tempDir = undefined;
     }
     this.#restoreProcessEnv();
-    if (elapsed < MIN_ACTIVATION_TIME) {
-      this.#logger.info(`waiting for ${MIN_ACTIVATION_TIME - elapsed}`);
-      await sleep(MIN_ACTIVATION_TIME - elapsed);
-    }
     this.#logger.info(`System Terminated in ${Date.now() - now}ms`);
   }
+  
+  static #modeFromEnv(): DatabaseMode {
+    return DatabaseModes.parse(process.env.AKAN_TEST_DATABASE_MODE?.trim() || "single", "AKAN_TEST_DATABASE_MODE");
+  }
+
+  async #applyDatabaseMode() {
+    process.env.AKAN_DATABASE_MODE = this.#mode;
+    resetEnvCache();
+    if (this.#mode === "single") return;
+    const redisUrl = ConformanceEnv.url("redis");
+    const postgresUrl = ConformanceEnv.url("postgres");
+    const missing = [
+      ...(redisUrl ? [] : ["AKAN_TEST_REDIS_URL"]),
+      ...(this.#mode === "cluster" && !postgresUrl ? ["AKAN_TEST_POSTGRES_URL"] : []),
+    ];
+    if (!redisUrl || missing.length)
+      throw new Error(
+        `AKAN_TEST_DATABASE_MODE=${this.#mode} needs ${missing.join(" and ")}; \`bun run testConformance --keep\` starts both`,
+      );
+
+    const redis = new URL(redisUrl);
+    redis.pathname = `/${this.workerId % 16}`;
+    process.env.REDIS_URI = redis.toString();
+    const { Redis } = await import("ioredis");
+    const client = new Redis(redis.toString(), { lazyConnect: true });
+    await client.connect();
+    await client.flushdb();
+    client.disconnect();
+    if (this.#mode === "multiple") return;
+    const { url, insightUrl, drop } = await ConformanceEnv.postgresSchema(`akan_test_w${this.workerId}`, {
+      insight: true,
+    });
+    this.#env.database = { ...this.#env.database, postgres: { url, insightUrl } };
+    this.#dropSchema = drop;
+  }
   #rememberProcessEnv() {
     this.#previousEnv.clear();
-    TEST_ENV_KEYS.forEach((key) => {
-      this.#previousEnv.set(key, process.env[key]);
-    });
+    for (const key of TEST_ENV_KEYS) this.#previousEnv.set(key, process.env[key]);
   }
   #restoreProcessEnv() {
     this.#previousEnv.forEach((value, key) => {
@@ -178,9 +212,10 @@ export class TestServer {
       else process.env[key] = value;
     });
     this.#previousEnv.clear();
+    resetEnvCache();
   }
   async #makeDatabaseFiles() {
-    if (this.#databaseMode === "memory") return { databaseFilePath: ":memory:", solidFilePath: ":memory:" };
+    if (this.#storage === "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`),

package/types/base/base.d.ts

@@ -20,11 +20,10 @@ export type EnumInstance<RefName extends string = string, T = string | number> =
     map: <R>(callback: (value: T, index: number, array: readonly T[]) => R) => R[];
     forEach: (callback: (value: T, index: number, array: readonly T[]) => void) => void;
 }>;
-/** Returns true when a class was created by `enumOf`. */
+/** True for a `class X extends enumOf(...) {}`, not for the bare `enumOf(...)` result. */
 export declare const isEnum: (enumRef: Cls) => boolean;
-/** Creates a typed scalar enum class from a readonly list of string or number values. */
+/** `type` is `String` for string values, else `Int` when every value is an integer, else `Float`. */
 export declare const enumOf: <RefName extends string, T = string | number>(refName: RefName, values: readonly T[]) => EnumInstance<RefName, T>;
-/** Id-keyed list helper used for light model collections and immutable-style list updates. */
 export declare class DataList<Light extends {
     id: string;
 }> {