@elench/testkit 0.1.64 → 0.1.66

package/lib/app/browser-bridge.mjs

@@ -0,0 +1,66 @@
+import { loadConfigContext, resolveProductDir } from "../config/index.mjs";
+import { discoverTests } from "../discovery/index.mjs";
+import { loadCurrentRunArtifact } from "../cli/viewer.mjs";
+
+export async function loadBrowserBridgeContext(options = {}) {
+  const productDir = resolveProductDir(process.cwd(), options.dir);
+  const [configContext, discovery] = await Promise.all([
+    loadConfigContext({
+      dir: productDir,
+      discoveryOptions: { strict: false },
+    }),
+    discoverTests({
+      dir: productDir,
+      diagnostics: "report",
+    }),
+  ]);
+
+  return {
+    productDir,
+    context: {
+      product: {
+        name: discovery.product.name,
+        directory: discovery.product.directory,
+      },
+      services: configContext.configs
+        .map((config) => {
+          const baseUrl = config.testkit.local?.baseUrl || null;
+          const browserOrigins = config.testkit.browser?.origins || [];
+          if (!baseUrl && browserOrigins.length === 0) return null;
+          const serviceEntries = [];
+          if (baseUrl && !baseUrl.includes("{port}")) {
+            try {
+              const parsed = new URL(baseUrl);
+              serviceEntries.push({
+                name: config.name,
+                baseUrl,
+                origin: parsed.origin,
+              });
+            } catch {
+              // Ignore invalid local.baseUrl templates here; explicit browser origins still work.
+            }
+          }
+          for (const origin of browserOrigins) {
+            serviceEntries.push({
+              name: config.name,
+              baseUrl: origin,
+              origin,
+            });
+          }
+          return serviceEntries;
+        })
+        .flat()
+        .filter(Boolean),
+      discovery,
+      runArtifact: loadRunArtifactIfPresent(productDir),
+    },
+  };
+}
+
+function loadRunArtifactIfPresent(productDir) {
+  try {
+    return loadCurrentRunArtifact(productDir);
+  } catch {
+    return null;
+  }
+}

package/lib/app/configs.mjs

@@ -0,0 +1,81 @@
+import { loadConfigs } from "../config/index.mjs";
+
+export async function loadManagedConfigs(options = {}) {
+  const allConfigs = await loadConfigs({ dir: options.dir });
+  const configs = filterConfigsByService(allConfigs, options.service || null);
+  return { allConfigs, configs };
+}
+
+export function filterConfigsByService(allConfigs, serviceName) {
+  if (!serviceName) return allConfigs;
+  const configs = allConfigs.filter((config) => config.name === serviceName);
+  if (configs.length > 0) return configs;
+  const available = allConfigs.map((config) => config.name).join(", ");
+  throw new Error(`Service "${serviceName}" not found. Available: ${available}`);
+}
+
+export function resolveTargetConfig(configs, serviceName = null) {
+  if (serviceName) {
+    const match = configs.find((config) => config.name === serviceName);
+    if (!match) {
+      const available = configs.map((config) => config.name).join(", ");
+      throw new Error(`Service "${serviceName}" not found. Available: ${available}`);
+    }
+    return match;
+  }
+
+  if (configs.length === 1) return configs[0];
+  const withLocalDb = configs.filter((config) => config.testkit.database?.provider === "local");
+  if (withLocalDb.length === 1) return withLocalDb[0];
+
+  const available = configs.map((config) => config.name).join(", ");
+  throw new Error(`Multiple services available. Pass --service. Available: ${available}`);
+}
+
+export function collectRequiredConfigs(configs, targetName) {
+  const byName = new Map(configs.map((config) => [config.name, config]));
+  const required = new Set();
+
+  const visit = (name) => {
+    if (required.has(name)) return;
+    const config = byName.get(name);
+    if (!config) {
+      throw new Error(`Missing config for dependency "${name}"`);
+    }
+    required.add(name);
+    for (const depName of config.testkit.dependsOn || []) {
+      visit(depName);
+    }
+  };
+
+  visit(targetName);
+  return configs.filter((config) => required.has(config.name));
+}
+
+export function topologicallySortConfigs(configs) {
+  const byName = new Map(configs.map((config) => [config.name, config]));
+  const visited = new Set();
+  const visiting = new Set();
+  const ordered = [];
+
+  const visit = (config) => {
+    if (visited.has(config.name)) return;
+    if (visiting.has(config.name)) {
+      throw new Error(`Dependency cycle while resolving configs for "${config.name}"`);
+    }
+    visiting.add(config.name);
+    for (const depName of config.testkit.dependsOn || []) {
+      const dependency = byName.get(depName);
+      if (dependency) visit(dependency);
+    }
+    visiting.delete(config.name);
+    visited.add(config.name);
+    ordered.push(config);
+  };
+
+  for (const config of configs) {
+    visit(config);
+  }
+
+  return ordered;
+}

package/lib/app/configs.test.mjs

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import {
+  collectRequiredConfigs,
+  filterConfigsByService,
+  resolveTargetConfig,
+  topologicallySortConfigs,
+} from "./configs.mjs";
+
+function makeConfig(name, dependsOn = [], provider = null) {
+  return {
+    name,
+    testkit: {
+      dependsOn,
+      database: provider ? { provider } : undefined,
+    },
+  };
+}
+
+describe("app config helpers", () => {
+  it("filters and resolves target configs", () => {
+    const configs = [makeConfig("api"), makeConfig("frontend", ["api"], "local")];
+
+    expect(filterConfigsByService(configs, "api")).toEqual([configs[0]]);
+    expect(resolveTargetConfig(configs)).toBe(configs[1]);
+    expect(() => filterConfigsByService(configs, "missing")).toThrow('Service "missing" not found');
+  });
+
+  it("collects dependencies and sorts them topologically", () => {
+    const configs = [makeConfig("frontend", ["api"]), makeConfig("api"), makeConfig("worker", ["api"])];
+
+    expect(collectRequiredConfigs(configs, "frontend").map((config) => config.name).sort()).toEqual(["api", "frontend"]);
+    expect(topologicallySortConfigs(configs).map((config) => config.name)).toEqual(["api", "frontend", "worker"]);
+  });
+});

package/lib/cli/command-helpers.mjs

@@ -1,6 +1,6 @@
 import path from "path";
 import { Flags } from "@oclif/core";
-import { loadConfigs } from "../config/index.mjs";
+import { loadManagedConfigs } from "../app/configs.mjs";
 import {
   parseFileTimeoutOption,
   parseShardOption,
@@ -73,15 +73,7 @@ export const runFlags = {
 };
 
 export async function resolveConfigsForCommand(flags) {
-  const allConfigs = await loadConfigs({ dir: flags.dir });
-  const configs = flags.service
-    ? allConfigs.filter((config) => config.name === flags.service)
-    : allConfigs;
-  if (flags.service && configs.length === 0) {
-    const available = allConfigs.map((config) => config.name).join(", ");
-    throw new Error(`Service "${flags.service}" not found. Available: ${available}`);
-  }
-  return { allConfigs, configs };
+  return loadManagedConfigs({ dir: flags.dir, service: flags.service });
 }
 
 export async function executeRunCommand(command, flags, positionalType = null) {

package/lib/cli/commands/browser/serve.mjs

@@ -1,8 +1,6 @@
 import { Command, Flags } from "@oclif/core";
 import { startBrowserBridgeServer } from "@elench/testkit-bridge";
-import { loadConfigContext, resolveProductDir } from "../../../config/index.mjs";
-import { discoverTests } from "../../../discovery/index.mjs";
-import { loadCurrentRunArtifact } from "../../viewer.mjs";
+import { loadBrowserBridgeContext } from "../../../app/browser-bridge.mjs";
 
 export default class BrowserServeCommand extends Command {
   static summary = "Serve the local browser bridge for the current testkit product";
@@ -25,59 +23,10 @@ export default class BrowserServeCommand extends Command {
 
   async run() {
     const { flags } = await this.parse(BrowserServeCommand);
-    const productDir = resolveProductDir(process.cwd(), flags.dir);
+    const { productDir, context } = await loadBrowserBridgeContext({ dir: flags.dir });
 
     const adapter = {
-      loadProductContext: async () => {
-        const [configContext, discovery] = await Promise.all([
-          loadConfigContext({
-            dir: productDir,
-            discoveryOptions: { strict: false },
-          }),
-          discoverTests({
-            dir: productDir,
-            diagnostics: "report",
-          }),
-        ]);
-
-        return {
-          product: {
-            name: discovery.product.name,
-            directory: discovery.product.directory,
-          },
-          services: configContext.configs
-            .map((config) => {
-              const baseUrl = config.testkit.local?.baseUrl || null;
-              const browserOrigins = config.testkit.browser?.origins || [];
-              if (!baseUrl && browserOrigins.length === 0) return null;
-              const serviceEntries = [];
-              if (baseUrl && !baseUrl.includes("{port}")) {
-                try {
-                  const parsed = new URL(baseUrl);
-                  serviceEntries.push({
-                    name: config.name,
-                    baseUrl,
-                    origin: parsed.origin,
-                  });
-                } catch {
-                  // Ignore invalid local.baseUrl templates here; explicit browser origins still work.
-                }
-              }
-              for (const origin of browserOrigins) {
-                serviceEntries.push({
-                  name: config.name,
-                  baseUrl: origin,
-                  origin,
-                });
-              }
-              return serviceEntries;
-            })
-            .flat()
-            .filter(Boolean),
-          discovery,
-          runArtifact: loadRunArtifactIfPresent(productDir),
-        };
-      },
+      loadProductContext: async () => context,
     };
 
     const serverRef = await startBrowserBridgeServer(adapter, {
@@ -102,11 +51,3 @@ export default class BrowserServeCommand extends Command {
     return payload;
   }
 }
-
-function loadRunArtifactIfPresent(productDir) {
-  try {
-    return loadCurrentRunArtifact(productDir);
-  } catch {
-    return null;
-  }
-}

package/lib/cli/db.mjs

@@ -1,7 +1,8 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { loadConfigs, resolveProductDir } from "../config/index.mjs";
+import { loadManagedConfigs, resolveTargetConfig, collectRequiredConfigs, topologicallySortConfigs } from "../app/configs.mjs";
+import { resolveProductDir } from "../config/index.mjs";
 import { captureDatabaseTemplateSnapshot, prepareDatabaseRuntime } from "../database/index.mjs";
 import { createRunReporter } from "./presentation/run-reporter.mjs";
 import { createRunLogRegistry } from "../runner/logs.mjs";
@@ -10,7 +11,7 @@ import { resolveRuntimeInstanceConfigs } from "../runner/template.mjs";
 
 export async function runDatabaseSnapshotCaptureCommand(options = {}) {
   const productDir = resolveProductDir(process.cwd(), options.dir);
-  const configs = await loadConfigs({ dir: productDir });
+  const { configs } = await loadManagedConfigs({ dir: productDir });
   const target = resolveTargetConfig(configs, options.service);
   const outputPath = normalizeOptionalString(options.output);
   if (!outputPath) {
@@ -57,74 +58,8 @@ export async function runDatabaseSnapshotCaptureCommand(options = {}) {
   }
 }
 
-function resolveTargetConfig(configs, serviceName) {
-  if (serviceName) {
-    const match = configs.find((config) => config.name === serviceName);
-    if (!match) {
-      const available = configs.map((config) => config.name).join(", ");
-      throw new Error(`Service "${serviceName}" not found. Available: ${available}`);
-    }
-    return match;
-  }
-
-  if (configs.length === 1) return configs[0];
-  const withLocalDb = configs.filter((config) => config.testkit.database?.provider === "local");
-  if (withLocalDb.length === 1) return withLocalDb[0];
-
-  const available = configs.map((config) => config.name).join(", ");
-  throw new Error(`Multiple services available. Pass --service. Available: ${available}`);
-}
-
 function normalizeOptionalString(value) {
   if (typeof value !== "string") return null;
   const normalized = value.trim();
   return normalized.length > 0 ? normalized : null;
 }
-
-function collectRequiredConfigs(configs, targetName) {
-  const byName = new Map(configs.map((config) => [config.name, config]));
-  const required = new Set();
-
-  const visit = (name) => {
-    if (required.has(name)) return;
-    const config = byName.get(name);
-    if (!config) {
-      throw new Error(`Missing config for dependency "${name}"`);
-    }
-    required.add(name);
-    for (const depName of config.testkit.dependsOn || []) {
-      visit(depName);
-    }
-  };
-
-  visit(targetName);
-  return configs.filter((config) => required.has(config.name));
-}
-
-function topologicallySortConfigs(configs) {
-  const byName = new Map(configs.map((config) => [config.name, config]));
-  const visited = new Set();
-  const visiting = new Set();
-  const ordered = [];
-
-  const visit = (config) => {
-    if (visited.has(config.name)) return;
-    if (visiting.has(config.name)) {
-      throw new Error(`Dependency cycle while resolving snapshot capture for "${config.name}"`);
-    }
-    visiting.add(config.name);
-    for (const depName of config.testkit.dependsOn || []) {
-      const dependency = byName.get(depName);
-      if (dependency) visit(dependency);
-    }
-    visiting.delete(config.name);
-    visited.add(config.name);
-    ordered.push(config);
-  };
-
-  for (const config of configs) {
-    visit(config);
-  }
-
-  return ordered;
-}

package/lib/config/binaries.mjs

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
+
+export function resolveK6Binary() {
+  const override = process.env[TESTKIT_K6_BIN]?.trim();
+  if (override) {
+    const isPathLike =
+      path.isAbsolute(override) ||
+      override.includes(path.sep) ||
+      override.includes(path.posix.sep) ||
+      override.includes(path.win32.sep);
+    const overridePath = isPathLike ? path.resolve(process.cwd(), override) : override;
+
+    if (isPathLike && !fs.existsSync(overridePath)) {
+      throw new Error(`${TESTKIT_K6_BIN} points to a missing file: ${overridePath}`);
+    }
+
+    return overridePath;
+  }
+
+  const thisFile = fileURLToPath(import.meta.url);
+  const abs = path.resolve(path.dirname(thisFile), "..", "..", "vendor", "k6");
+  if (!fs.existsSync(abs)) {
+    throw new Error(`Bundled k6 binary not found: ${abs}`);
+  }
+  return abs;
+}
+
+export function resolveDalBinary() {
+  return resolveK6Binary();
+}

package/lib/config/database.mjs

@@ -1,5 +1,8 @@
-import { normalizeDatabaseBinding } from "../runner/execution-config.mjs";
-import { normalizeOptionalString, normalizeTemplateInputs, normalizeTemplateLifecycleSteps } from "./runtime.mjs";
+import { normalizeDatabaseBinding } from "../shared/execution-schema.mjs";
+import {
+  normalizeConfiguredInputs,
+  normalizeConfiguredSteps,
+} from "../shared/configured-steps.mjs";
 
 const DEFAULT_LOCAL_IMAGE = "pgvector/pgvector:pg16";
 const DEFAULT_LOCAL_USER = "testkit";
@@ -45,9 +48,9 @@ export function normalizeDatabaseTemplateConfig(value, serviceName) {
   }
 
   return {
-    inputs: normalizeTemplateInputs(value.inputs, `Service "${serviceName}" database.template`),
-    migrate: normalizeTemplateLifecycleSteps(value.migrate, `Service "${serviceName}" database.template.migrate`),
-    seed: normalizeTemplateLifecycleSteps(value.seed, `Service "${serviceName}" database.template.seed`),
-    verify: normalizeTemplateLifecycleSteps(value.verify, `Service "${serviceName}" database.template.verify`),
+    inputs: normalizeConfiguredInputs(value.inputs, `Service "${serviceName}" database.template`),
+    migrate: normalizeConfiguredSteps(value.migrate, `Service "${serviceName}" database.template.migrate`),
+    seed: normalizeConfiguredSteps(value.seed, `Service "${serviceName}" database.template.seed`),
+    verify: normalizeConfiguredSteps(value.verify, `Service "${serviceName}" database.template.verify`),
   };
 }

package/lib/config/index.mjs

@@ -1,6 +1,5 @@
 import fs from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
 import { discoverProject } from "./discovery.mjs";
 import { loadTestkitSetup } from "./setup-loader.mjs";
 import { normalizeToolchainRegistry } from "../toolchains/index.mjs";
@@ -8,6 +7,7 @@ import { mergeDiscoveryConfigs } from "../discovery/path-policy.mjs";
 import { normalizeDatabaseConfig } from "./database.mjs";
 import { normalizeRepoDiscoveryConfig, normalizeServiceDiscoveryConfig } from "./discovery-config.mjs";
 import { inferEnvFiles, loadServiceEnv, parseDotenv } from "./env.mjs";
+import { resolveDalBinary, resolveK6Binary } from "./binaries.mjs";
 import { ensureExistingPath, resolveProductDir, resolveServiceCwd } from "./paths.mjs";
 import {
   detectNextApp,
@@ -22,8 +22,6 @@ import { normalizeServiceRequirements, normalizeSkipConfig } from "./skip-config
 import { normalizeTelemetryConfig } from "./telemetry.mjs";
 import { validateConfigCoverage, validateServiceConfig } from "./validation.mjs";
 
-const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
-
 export { parseDotenv, resolveProductDir, resolveServiceCwd };
 
 export async function loadConfigContext(opts = {}) {
@@ -92,34 +90,7 @@ export async function loadConfigs(opts = {}) {
   return filtered;
 }
 
-export function resolveK6Binary() {
-  const override = process.env[TESTKIT_K6_BIN]?.trim();
-  if (override) {
-    const isPathLike =
-      path.isAbsolute(override) ||
-      override.includes(path.sep) ||
-      override.includes(path.posix.sep) ||
-      override.includes(path.win32.sep);
-    const overridePath = isPathLike ? path.resolve(process.cwd(), override) : override;
-
-    if (isPathLike && !fs.existsSync(overridePath)) {
-      throw new Error(`${TESTKIT_K6_BIN} points to a missing file: ${overridePath}`);
-    }
-
-    return overridePath;
-  }
-
-  const thisFile = fileURLToPath(import.meta.url);
-  const abs = path.resolve(path.dirname(thisFile), "..", "..", "vendor", "k6");
-  if (!fs.existsSync(abs)) {
-    throw new Error(`Bundled k6 binary not found: ${abs}`);
-  }
-  return abs;
-}
-
-export function resolveDalBinary() {
-  return resolveK6Binary();
-}
+export { resolveDalBinary, resolveK6Binary } from "./binaries.mjs";
 
 function normalizeServiceConfig({
   name,

package/lib/config/runtime.mjs

@@ -1,16 +1,23 @@
 import fs from "fs";
 import path from "path";
-import { DEFAULT_FILE_TIMEOUT_SECONDS, normalizeExecutionConfig, normalizeRuntimeMaxConcurrentTasks, normalizeRuntimeInstances } from "../runner/execution-config.mjs";
+import {
+  DEFAULT_FILE_TIMEOUT_SECONDS,
+  normalizeExecutionConfig,
+  normalizeRuntimeMaxConcurrentTasks,
+  normalizeRuntimeInstances,
+} from "../shared/execution-schema.mjs";
+import {
+  normalizeConfiguredInputs,
+  normalizeConfiguredStep,
+  normalizeConfiguredStepInputs,
+  normalizeConfiguredSteps,
+  normalizeOptionalString,
+  parseModuleSpecifier,
+} from "../shared/configured-steps.mjs";
 import { normalizeKnownFailureIssueValidationConfig } from "../known-failures/github.mjs";
 import { normalizeRuntimeToolchain } from "../toolchains/index.mjs";
 import { resolveServiceCwd } from "./paths.mjs";
 
-export function normalizeOptionalString(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
 export function normalizeReportingConfig(value) {
   if (!value) return null;
 
@@ -107,90 +114,11 @@ export function normalizeRuntimePrepareConfig(value, serviceName) {
   }
 
   return {
-    inputs: normalizeTemplateInputs(value.inputs, `Service "${serviceName}" runtime.prepare`),
-    steps: normalizeTemplateLifecycleSteps(value.steps, `Service "${serviceName}" runtime.prepare.steps`),
+    inputs: normalizeConfiguredInputs(value.inputs, `Service "${serviceName}" runtime.prepare`),
+    steps: normalizeConfiguredSteps(value.steps, `Service "${serviceName}" runtime.prepare.steps`),
   };
 }
 
-export function normalizeTemplateInputs(value, label) {
-  if (value == null) return [];
-  if (!Array.isArray(value)) {
-    throw new Error(`${label}.inputs must be an array`);
-  }
-
-  return value.map((entry, index) => {
-    const normalized = normalizeOptionalString(entry);
-    if (!normalized) {
-      throw new Error(`${label}.inputs[${index}] must be a non-empty string`);
-    }
-    return normalized;
-  });
-}
-
-export function normalizeTemplateLifecycleSteps(value, label) {
-  if (value == null) return [];
-  if (!Array.isArray(value)) {
-    throw new Error(`${label} must be an array`);
-  }
-
-  return value.map((step, index) => normalizeTemplateLifecycleStep(step, `${label}[${index}]`));
-}
-
-export function normalizeTemplateLifecycleStep(step, label) {
-  if (!step || typeof step !== "object") {
-    throw new Error(`${label} must be an object`);
-  }
-
-  const kind = normalizeOptionalString(step.kind);
-  if (kind === "command") {
-    const cmd = normalizeOptionalString(step.cmd);
-    if (!cmd) throw new Error(`${label}.cmd must be a non-empty string`);
-    return {
-      kind,
-      cmd,
-      cwd: normalizeOptionalString(step.cwd),
-      inputs: normalizeTemplateStepInputs(step.inputs, label),
-    };
-  }
-  if (kind === "sql-file") {
-    const filePath = normalizeOptionalString(step.path);
-    if (!filePath) throw new Error(`${label}.path must be a non-empty string`);
-    return {
-      kind,
-      path: filePath,
-      cwd: normalizeOptionalString(step.cwd),
-      inputs: normalizeTemplateStepInputs(step.inputs, label),
-    };
-  }
-  if (kind === "module") {
-    const specifier = normalizeOptionalString(step.specifier);
-    if (!specifier) throw new Error(`${label}.specifier must be a non-empty string`);
-    return {
-      kind,
-      specifier,
-      cwd: normalizeOptionalString(step.cwd),
-      inputs: normalizeTemplateStepInputs(step.inputs, label),
-    };
-  }
-
-  throw new Error(`${label}.kind must be one of: command, sql-file, module`);
-}
-
-export function normalizeTemplateStepInputs(value, label) {
-  if (value == null) return [];
-  if (!Array.isArray(value)) {
-    throw new Error(`${label}.inputs must be an array`);
-  }
-
-  return value.map((entry, index) => {
-    const normalized = normalizeOptionalString(entry);
-    if (!normalized) {
-      throw new Error(`${label}.inputs[${index}] must be a non-empty string`);
-    }
-    return normalized;
-  });
-}
-
 export function normalizeBrowserServiceConfig(value, serviceName) {
   if (!value) return undefined;
   if (typeof value !== "object" || Array.isArray(value)) {
@@ -232,10 +160,11 @@ export function detectNextApp(cwd) {
   );
 }
 
-export function parseModuleSpecifier(specifier) {
-  const [modulePath, exportName] = String(specifier).split("#", 2);
-  return {
-    modulePath,
-    exportName: exportName || "default",
-  };
-}
+export {
+  normalizeConfiguredInputs as normalizeTemplateInputs,
+  normalizeConfiguredStep as normalizeTemplateLifecycleStep,
+  normalizeConfiguredStepInputs as normalizeTemplateStepInputs,
+  normalizeConfiguredSteps as normalizeTemplateLifecycleSteps,
+  normalizeOptionalString,
+  parseModuleSpecifier,
+} from "../shared/configured-steps.mjs";