@elench/testkit 0.1.37 → 0.1.39

package/lib/runner/runtime-contexts.mjs

@@ -3,86 +3,77 @@ import path from "path";
 import { execaCommand } from "execa";
 import { resolveServiceCwd } from "../config/index.mjs";
 import { prepareDatabaseRuntime } from "../database/index.mjs";
-import { buildExecutionEnv, resolveWorkerRuntimeConfigs } from "./template.mjs";
+import { buildExecutionEnv, resolveStackRuntimeConfigs } from "./template.mjs";
 import { writeGraphMetadata } from "./state.mjs";
 import { startLocalServices, stopLocalServices } from "./services.mjs";
 
-export function createGraphContext(worker, graph) {
-  const graphDir = path.join(worker.productDir, ".testkit", "_graphs", graph.dirName);
-  const workerStateDir = path.join(graphDir, "workers", `worker-${worker.workerId}`);
-  fs.mkdirSync(workerStateDir, { recursive: true });
+export function createStackContext(stackId, graph, productDir) {
+  const graphDir = path.join(productDir, ".testkit", "_graphs", graph.dirName);
+  const stackStateDir = path.join(graphDir, "stacks", stackId);
+  fs.mkdirSync(stackStateDir, { recursive: true });
   writeGraphMetadata(graphDir, graph);
 
-  const runtimeConfigs = resolveWorkerRuntimeConfigs(
+  const runtimeConfigs = resolveStackRuntimeConfigs(
     graph.rootConfig,
     graph.runtimeConfigs,
-    worker.workerId,
-    workerStateDir
+    stackId,
+    stackStateDir
   );
 
   return {
     graphKey: graph.key,
+    assignedTargets: [...graph.assignedTargets],
     graphDir,
-    workerStateDir,
+    stackId,
+    stackStateDir,
     runtimeConfigs,
     configByName: new Map(runtimeConfigs.map((config) => [config.name, config])),
     prepared: false,
+    preparationPromise: null,
     started: false,
+    startupPromise: null,
     startedServices: [],
   };
 }
 
-export async function ensureWorkerGraph(worker, batch, graphByKey, lifecycle) {
-  const graph = graphByKey.get(batch.graphKey);
-  if (!graph) {
-    throw new Error(`Unknown graph "${batch.graphKey}"`);
-  }
-
-  if (worker.currentGraphKey && worker.currentGraphKey !== batch.graphKey) {
-    await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey), lifecycle);
-    worker.graphSwitches += 1;
-    worker.currentGraphKey = null;
-  }
-
-  let context = worker.graphContexts.get(batch.graphKey);
-  if (!context) {
-    context = createGraphContext(worker, graph);
-    worker.graphContexts.set(batch.graphKey, context);
-    lifecycle.trackGraphContext(context);
-  }
-
+export async function ensureStackContextReady(context, batch, lifecycle) {
   if (!context.prepared) {
-    await prepareDatabases(context.runtimeConfigs);
-    context.prepared = true;
+    if (!context.preparationPromise) {
+      context.preparationPromise = (async () => {
+        await prepareDatabases(context.runtimeConfigs);
+        context.prepared = true;
+      })().finally(() => {
+        context.preparationPromise = null;
+      });
+    }
+    await context.preparationPromise;
   }
 
   if (batchNeedsLocalRuntime(batch) && !context.started) {
-    context.startedServices = await startLocalServices(context.runtimeConfigs, lifecycle);
-    context.started = true;
+    if (!context.startupPromise) {
+      context.startupPromise = (async () => {
+        context.startedServices = await startLocalServices(context.runtimeConfigs, lifecycle);
+        context.started = true;
+      })().finally(() => {
+        context.startupPromise = null;
+      });
+    }
+    await context.startupPromise;
   }
 
-  worker.currentGraphKey = batch.graphKey;
   return context;
 }
 
-export async function deactivateGraphContext(context, lifecycle) {
+export async function deactivateStackContext(context, lifecycle) {
   if (!context?.started) return;
   await stopLocalServices(context.startedServices, lifecycle);
   context.started = false;
   context.startedServices = [];
 }
 
-export async function resetCurrentGraph(worker, lifecycle) {
-  if (!worker.currentGraphKey) return;
-  await deactivateGraphContext(worker.graphContexts.get(worker.currentGraphKey), lifecycle);
-  worker.currentGraphKey = null;
-}
-
-export async function cleanupWorker(worker, lifecycle) {
-  for (const context of worker.graphContexts.values()) {
-    await deactivateGraphContext(context, lifecycle);
-  }
-  worker.currentGraphKey = null;
+export async function cleanupStackContext(context, lifecycle) {
+  if (!context) return;
+  await deactivateStackContext(context, lifecycle);
 }
 
 export async function prepareDatabases(runtimeConfigs) {
@@ -103,7 +94,7 @@ async function runMigrate(config, databaseUrl) {
   const env = buildExecutionEnv(config, {}, process.env);
   if (databaseUrl) env.DATABASE_URL = databaseUrl;
 
-  console.log(`\n── migrate:${config.workerLabel}:${config.name} ──`);
+  console.log(`\n── migrate:${config.stackLabel}:${config.name} ──`);
   await execaCommand(migrate.cmd, {
     cwd: resolveServiceCwd(config.productDir, migrate.cwd),
     env,
@@ -119,7 +110,7 @@ async function runSeed(config, databaseUrl) {
   const env = buildExecutionEnv(config, {}, process.env);
   if (databaseUrl) env.DATABASE_URL = databaseUrl;
 
-  console.log(`\n── seed:${config.workerLabel}:${config.name} ──`);
+  console.log(`\n── seed:${config.stackLabel}:${config.name} ──`);
   await execaCommand(seed.cmd, {
     cwd: resolveServiceCwd(config.productDir, seed.cwd),
     env,

package/lib/runner/services.mjs

@@ -36,12 +36,12 @@ export async function startLocalService(config, lifecycle) {
 
   await assertLocalServicePortsAvailable(config, isPortInUse);
 
-  console.log(`Starting ${config.workerLabel}:${config.name}: ${config.testkit.local.start}`);
+  console.log(`Starting ${config.stackLabel}:${config.name}: ${config.testkit.local.start}`);
   const child = startDetachedCommand(config.testkit.local.start, cwd, env);
 
   const outputDrains = [
-    pipeOutput(child.stdout, `[${config.workerLabel}:${config.name}]`),
-    pipeOutput(child.stderr, `[${config.workerLabel}:${config.name}]`),
+    pipeOutput(child.stdout, `[${config.stackLabel}:${config.name}]`),
+    pipeOutput(child.stderr, `[${config.stackLabel}:${config.name}]`),
   ];
   lifecycle.registerService(config, child, cwd);
 
@@ -49,7 +49,7 @@ export async function startLocalService(config, lifecycle) {
 
   try {
     await waitForReady({
-      name: `${config.workerLabel}:${config.name}`,
+      name: `${config.stackLabel}:${config.name}`,
       url: config.testkit.local.readyUrl,
       timeoutMs: readyTimeoutMs,
       process: child,

package/lib/runner/stack-manager.mjs

@@ -0,0 +1,146 @@
+import { buildStackIds } from "./execution-config.mjs";
+import {
+  cleanupStackContext,
+  createStackContext,
+  ensureStackContextReady,
+} from "./runtime-contexts.mjs";
+
+export function createStackManager({ productDir, graphs, execution, lifecycle }) {
+  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
+  const pools = new Map();
+
+  return {
+    async acquire(batch) {
+      const pool = getPool(pools, graphByKey, batch, execution, productDir, lifecycle);
+      while (true) {
+        if (lifecycle.isStopRequested()) {
+          throw lifecycle.signal.reason || new Error("testkit run interrupted");
+        }
+
+        const slot = claimSlot(pool, batch.accessMode);
+        if (!slot) {
+          await sleep(25);
+          continue;
+        }
+
+        try {
+          const context = await getReadyContext(slot, graphByKey, productDir, batch, lifecycle);
+          return {
+            slot,
+            context,
+          };
+        } catch (error) {
+          releaseSlot(slot, batch.accessMode);
+          await invalidateSlot(slot, lifecycle);
+          throw error;
+        }
+      }
+    },
+    async release(lease, options = {}) {
+      if (!lease?.slot) return;
+      releaseSlot(lease.slot, options.accessMode || lease.slot.lastAccessMode);
+      if (options.invalidate) {
+        await invalidateSlot(lease.slot, lifecycle);
+      }
+    },
+    async cleanupAll() {
+      for (const pool of pools.values()) {
+        for (const slot of pool.slots) {
+          await invalidateSlot(slot, lifecycle);
+        }
+      }
+    },
+  };
+}
+
+function getPool(pools, graphByKey, batch, execution, productDir, lifecycle) {
+  const key = `${batch.graphKey}:${batch.stackMode}`;
+  const existing = pools.get(key);
+  if (existing) return existing;
+
+  const graph = graphByKey.get(batch.graphKey);
+  if (!graph) {
+    throw new Error(`Unknown graph "${batch.graphKey}"`);
+  }
+
+  const slots = buildPoolStackIds(batch.stackMode, execution).map((stackId) => ({
+    graph,
+    stackId,
+    context: null,
+    activeSharedCount: 0,
+    exclusiveActive: false,
+    lastAccessMode: null,
+    contextPromise: null,
+  }));
+  const pool = {
+    productDir,
+    lifecycle,
+    slots,
+  };
+  pools.set(key, pool);
+  return pool;
+}
+
+function buildPoolStackIds(stackMode, execution) {
+  if (stackMode === "isolated") {
+    return Array.from({ length: execution.workers }, (_unused, index) => `isolated-${index + 1}`);
+  }
+  if (stackMode === "shared") {
+    return ["shared"];
+  }
+  return buildStackIds({
+    stackMode: "pooled",
+    stackCount: execution.stackCount,
+  });
+}
+
+function claimSlot(pool, accessMode) {
+  if (accessMode === "shared") {
+    const candidates = pool.slots.filter((slot) => !slot.exclusiveActive);
+    if (candidates.length === 0) return null;
+    const slot = [...candidates].sort((left, right) => left.activeSharedCount - right.activeSharedCount)[0];
+    slot.activeSharedCount += 1;
+    slot.lastAccessMode = "shared";
+    return slot;
+  }
+
+  const slot = pool.slots.find((candidate) => !candidate.exclusiveActive && candidate.activeSharedCount === 0);
+  if (!slot) return null;
+  slot.exclusiveActive = true;
+  slot.lastAccessMode = "exclusive";
+  return slot;
+}
+
+async function getReadyContext(slot, graphByKey, productDir, batch, lifecycle) {
+  if (!slot.context) {
+    slot.context = createStackContext(slot.stackId, slot.graph, productDir);
+    lifecycle.trackGraphContext(slot.context);
+  }
+  if (!slot.contextPromise) {
+    slot.contextPromise = Promise.resolve(slot.context);
+  }
+  await slot.contextPromise;
+  await ensureStackContextReady(slot.context, batch, lifecycle);
+  return slot.context;
+}
+
+function releaseSlot(slot, accessMode) {
+  if (accessMode === "shared") {
+    slot.activeSharedCount = Math.max(0, slot.activeSharedCount - 1);
+    return;
+  }
+  slot.exclusiveActive = false;
+}
+
+async function invalidateSlot(slot, lifecycle) {
+  if (!slot.context) return;
+  await cleanupStackContext(slot.context, lifecycle);
+  slot.context = null;
+  slot.contextPromise = null;
+  slot.activeSharedCount = 0;
+  slot.exclusiveActive = false;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/runner/state-io.mjs

@@ -5,6 +5,29 @@ export function readDatabaseUrl(stateDir) {
   return readStateValue(path.join(stateDir, "database_url"));
 }
 
+export function readDatabaseInfo(stateDir) {
+  return parseDatabaseUrl(readDatabaseUrl(stateDir));
+}
+
+export function parseDatabaseUrl(databaseUrl) {
+  if (!databaseUrl) return null;
+
+  try {
+    const parsed = new URL(databaseUrl);
+    const port = Number(parsed.port || "5432");
+    return {
+      url: databaseUrl,
+      host: parsed.hostname,
+      port: Number.isInteger(port) && port > 0 ? port : 5432,
+      database: parsed.pathname.replace(/^\//, ""),
+      user: decodeURIComponent(parsed.username || ""),
+      password: decodeURIComponent(parsed.password || ""),
+    };
+  } catch {
+    return null;
+  }
+}
+
 export function readStateValue(filePath) {
   if (!fs.existsSync(filePath)) return null;
   return fs.readFileSync(filePath, "utf8").trim();

package/lib/runner/template.mjs

@@ -1,30 +1,43 @@
 import path from "path";
+import { readDatabaseInfo } from "./state-io.mjs";
 
 const PORT_STRIDE = 100;
 
-export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, workerId, workerStateDir) {
-  const portMap = buildPortMap(runtimeConfigs, workerId);
+export function resolveStackRuntimeConfigs(targetConfig, runtimeConfigs, stackId, stackStateDir) {
+  const portMap = buildPortMap(runtimeConfigs, stackId);
   const baseUrlByService = new Map();
   const readyUrlByService = new Map();
+  const stateDirByService = new Map();
+
+  for (const config of runtimeConfigs) {
+    stateDirByService.set(
+      config.name,
+      resolveServiceStateDir(stackStateDir, targetConfig.name, config)
+    );
+  }
 
   for (const config of runtimeConfigs) {
     if (!config.testkit.local) continue;
     baseUrlByService.set(
       config.name,
-      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, targetConfig, workerId, {
-        workerStateDir,
+      resolveRuntimeUrl(config.testkit.local.baseUrl, config.name, targetConfig, stackId, {
+        stackId,
+        stackStateDir,
         portMap,
         baseUrlByService,
         readyUrlByService,
+        stateDirByService,
       })
     );
     readyUrlByService.set(
       config.name,
-      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, targetConfig, workerId, {
-        workerStateDir,
+      resolveRuntimeUrl(config.testkit.local.readyUrl, config.name, targetConfig, stackId, {
+        stackId,
+        stackStateDir,
         portMap,
         baseUrlByService,
         readyUrlByService,
+        stateDirByService,
       })
     );
   }
@@ -43,23 +56,24 @@ export function resolveWorkerRuntimeConfigs(targetConfig, runtimeConfigs, worker
   }
 
   return runtimeConfigs.map((config) =>
-    resolveWorkerConfig(
+    resolveStackConfig(
       config,
       targetConfig,
-      workerId,
-      workerStateDir,
+      stackId,
+      stackStateDir,
       portMap,
       baseUrlByService,
       readyUrlByService,
+      stateDirByService,
       urlMappings
     )
   );
 }
 
-export function buildPortMap(runtimeConfigs, workerId) {
+export function buildPortMap(runtimeConfigs, stackId) {
   const portMap = new Map();
   const seen = new Map();
-  const offset = PORT_STRIDE * (workerId - 1);
+  const offset = stackPortOffset(stackId);
 
   for (const config of runtimeConfigs) {
     if (!config.testkit.local) continue;
@@ -71,7 +85,7 @@ export function buildPortMap(runtimeConfigs, workerId) {
     const existing = seen.get(actualPort);
     if (existing) {
       throw new Error(
-        `Worker port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
+        `Stack port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
           `Assign distinct local.port/baseUrl ports in testkit.setup.ts.`
       );
     }
@@ -82,25 +96,27 @@ export function buildPortMap(runtimeConfigs, workerId) {
   return portMap;
 }
 
-export function resolveWorkerConfig(
+export function resolveStackConfig(
   config,
   targetConfig,
-  workerId,
-  workerStateDir,
+  stackId,
+  stackStateDir,
   portMap,
   baseUrlByService,
   readyUrlByService,
+  stateDirByService,
   urlMappings
 ) {
-  const stateDir = resolveServiceStateDir(workerStateDir, targetConfig.name, config);
+  const stateDir = resolveServiceStateDir(stackStateDir, targetConfig.name, config);
   const context = {
-    workerId,
-    serviceName: config.name,
+    stackId,
     targetName: targetConfig.name,
+    serviceName: config.name,
     serviceStateDir: stateDir,
     portMap,
     baseUrlByService,
     readyUrlByService,
+    stateDirByService,
     urlMappings,
   };
 
@@ -143,51 +159,48 @@ export function resolveWorkerConfig(
         port: portMap.get(config.name) || config.testkit.local.port,
         baseUrl: baseUrlByService.get(config.name),
         readyUrl: readyUrlByService.get(config.name),
-        env: Object.fromEntries(
-          Object.entries(config.testkit.local.env || {}).map(([key, value]) => [
-            key,
-            finalizeString(String(value), context),
-          ])
-        ),
+        env: { ...(config.testkit.local.env || {}) },
       }
     : undefined;
 
   return {
     ...config,
     stateDir,
-    workerId,
-    workerLabel: `w${workerId}`,
+    stackId,
+    stackLabel: stackId,
     targetName: targetConfig.name,
     testkit: {
       ...config.testkit,
       database,
       migrate,
       seed,
+      templateContext: context,
       local,
     },
   };
 }
 
-export function resolveServiceStateDir(workerStateDir, targetName, config) {
+export function resolveServiceStateDir(stackStateDir, targetName, config) {
   const dbSource = config.testkit.databaseFrom || config.name;
-  return getWorkerServiceStateDir(workerStateDir, targetName, dbSource);
+  return getStackServiceStateDir(stackStateDir, targetName, dbSource);
 }
 
-export function getWorkerServiceStateDir(workerStateDir, targetName, serviceName) {
+export function getStackServiceStateDir(stackStateDir, targetName, serviceName) {
   if (targetName === serviceName) {
-    return workerStateDir;
+    return stackStateDir;
   }
-  return path.join(workerStateDir, "deps", serviceName);
+  return path.join(stackStateDir, "deps", serviceName);
 }
 
 export function buildExecutionEnv(config, extraEnv = {}, processEnv = process.env) {
   const inheritedEnv = { ...processEnv };
+  const templateContext = config.testkit?.templateContext;
   const env = {
     ...inheritedEnv,
-    ...(config.testkit.serviceEnv || {}),
-    ...extraEnv,
+    ...resolveEnvTemplates(config.testkit.serviceEnv || {}, templateContext),
+    ...resolveEnvTemplates(extraEnv, templateContext),
     TESTKIT_ACTIVE: "1",
-    ...(config.workerId ? { TESTKIT_WORKER_ID: String(config.workerId) } : {}),
+    ...(config.stackId ? { TESTKIT_STACK_ID: String(config.stackId) } : {}),
   };
   delete env.DATABASE_URL;
   return env;
@@ -202,17 +215,17 @@ export function buildPlaywrightEnv(config, baseUrl, processEnv = process.env) {
       PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS:
         processEnv.PLAYWRIGHT_SKIP_VALIDATE_HOST_REQUIREMENTS || "1",
       TESTKIT_MANAGED_SERVERS: "1",
-      TESTKIT_WORKER_ID: String(config.workerId),
+      TESTKIT_STACK_ID: String(config.stackId),
     },
     processEnv
   );
 }
 
-export function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, workerId, context) {
+export function resolveRuntimeUrl(rawUrl, serviceName, targetConfig, stackId, context) {
   const resolved = resolveTemplateString(rawUrl, {
     ...context,
     targetName: targetConfig.name,
-    workerId,
+    stackId,
     serviceName,
   });
   const actualPort = context.portMap.get(serviceName);
@@ -234,8 +247,8 @@ export function resolveTemplateString(value, context) {
 
   return value.replace(/\{([a-zA-Z]+)(?::([a-zA-Z0-9_-]+))?\}/g, (_match, token, arg) => {
     switch (token) {
-      case "worker":
-        return String(context.workerId);
+      case "stack":
+        return String(context.stackId);
       case "target":
         return context.targetName;
       case "service":
@@ -266,12 +279,61 @@ export function resolveTemplateString(value, context) {
         }
         return readyUrl;
       }
+      case "dbUrl":
+      case "dbHost":
+      case "dbPort":
+      case "dbName":
+      case "dbUser":
+      case "dbPassword": {
+        const serviceName = arg || context.serviceName;
+        return resolveDatabaseTemplateValue(token, serviceName, context);
+      }
       default:
         throw new Error(`Unsupported template token "{${token}${arg ? `:${arg}` : ""}}"`);
     }
   });
 }
 
+function resolveEnvTemplates(values, templateContext) {
+  return Object.fromEntries(
+    Object.entries(values || {}).map(([key, value]) => [
+      key,
+      typeof value === "string" && templateContext ? finalizeString(value, templateContext) : value,
+    ])
+  );
+}
+
+function resolveDatabaseTemplateValue(token, serviceName, context) {
+  const stateDir = context.stateDirByService?.get(serviceName);
+  if (!stateDir) {
+    throw new Error(`Unknown database placeholder for service "${serviceName}"`);
+  }
+
+  const info = readDatabaseInfo(stateDir);
+  if (!info) {
+    throw new Error(
+      `Database placeholder "{${token}:${serviceName}}" is unavailable before "${serviceName}" database preparation`
+    );
+  }
+
+  switch (token) {
+    case "dbUrl":
+      return info.url;
+    case "dbHost":
+      return info.host;
+    case "dbPort":
+      return String(info.port);
+    case "dbName":
+      return info.database;
+    case "dbUser":
+      return info.user;
+    case "dbPassword":
+      return info.password;
+    default:
+      throw new Error(`Unsupported database placeholder "{${token}:${serviceName}}"`);
+  }
+}
+
 export function rewriteUrlPort(rawUrl, port) {
   try {
     const original = new URL(rawUrl);
@@ -318,3 +380,9 @@ export function normalizeSocketHost(hostname) {
   if (hostname === "[::1]") return "::1";
   return hostname;
 }
+
+function stackPortOffset(stackId) {
+  const match = String(stackId).match(/(\d+)$/);
+  if (!match) return 0;
+  return PORT_STRIDE * (Number.parseInt(match[1], 10) - 1);
+}