@elench/testkit 0.1.26 → 0.1.27

package/lib/config/index.mjs

@@ -1,84 +1,55 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { discoverSuites } from "./discovery.mjs";
-import {
-  getServiceEnvFiles as getServiceEnvFilesModel,
-  isObject as isObjectModel,
-  normalizeTelemetryConfig as normalizeTelemetryConfigModel,
-  parseDotenvString,
-  resolveLifecycleConfig as resolveLifecycleConfigModel,
-  resolveSelectedDatabase as resolveSelectedDatabaseModel,
-  validateConfigCoverage as validateConfigCoverageModel,
-  validateServiceConfig as validateServiceConfigModel,
-  validateTelemetryConfig as validateTelemetryConfigModel,
-} from "./model.mjs";
-
-const TESTKIT_CONFIG = "testkit.config.json";
+import { discoverProject } from "./discovery.mjs";
+import { loadTestkitSetup } from "./setup-loader.mjs";
+
 const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
+const DEFAULT_LOCAL_IMAGE = "pgvector/pgvector:pg16";
+const DEFAULT_LOCAL_USER = "testkit";
+const DEFAULT_LOCAL_PASSWORD = "testkit";
+
 export function parseDotenv(filePath) {
   if (!fs.existsSync(filePath)) return {};
   return parseDotenvString(fs.readFileSync(filePath, "utf8"));
 }
 
-export function getServiceNames(cwd) {
-  const dir = cwd || process.cwd();
-  const configPath = path.join(dir, TESTKIT_CONFIG);
-  if (!fs.existsSync(configPath)) return [];
-  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-  if (!isObject(config.services)) return [];
-  return Object.keys(config.services);
-}
-
-export function loadConfigs(opts = {}) {
+export async function loadConfigs(opts = {}) {
   const productDir = resolveProductDir(process.cwd(), opts.dir);
-  const config = loadTestkitConfig(productDir);
-  validateConfigCoverage(config);
-  const discoveredSuites = discoverSuites(productDir, config.services);
+  const { setup, setupFile } = await loadTestkitSetup(productDir);
+  const explicitServices = setup.services || {};
+  const discovery = discoverProject(productDir, explicitServices);
+  const serviceNames = new Set([
+    ...Object.keys(explicitServices),
+    ...Object.keys(discovery.suitesByService),
+  ]);
+
+  const configs = [...serviceNames]
+    .sort((left, right) => left.localeCompare(right))
+    .map((name) =>
+      normalizeServiceConfig({
+        name,
+        productDir,
+        setup,
+        setupFile,
+        explicitService: explicitServices[name] || {},
+        discoveredService: discovery.services[name] || null,
+        suites: discovery.suitesByService[name] || {},
+      })
+    );
+
+  validateConfigCoverage(configs);
 
-  const serviceEntries = Object.entries(config.services);
   const filtered = opts.service
-    ? serviceEntries.filter(([name]) => name === opts.service)
-    : serviceEntries;
+    ? configs.filter((config) => config.name === opts.service)
+    : configs;
 
   if (opts.service && filtered.length === 0) {
-    const available = serviceEntries.map(([name]) => name).join(", ");
+    const available = configs.map((config) => config.name).join(", ");
     throw new Error(`Service "${opts.service}" not found. Available: ${available}`);
   }
 
-  return filtered.map(([name, serviceConfig]) => {
-    const suites = discoveredSuites[name] || {};
-    const resolvedDatabase = resolveSelectedDatabase(name, serviceConfig);
-    const serviceEnv = loadServiceEnv(productDir, serviceConfig);
-    const selectedBackend = resolvedDatabase?.selectedBackend;
-    const resolvedMigrate = resolveLifecycleConfig(serviceConfig.migrate, selectedBackend);
-    const resolvedSeed = resolveLifecycleConfig(serviceConfig.seed, selectedBackend);
-    validateMergedService(
-      name,
-      suites,
-      serviceConfig,
-      resolvedDatabase,
-      resolvedMigrate,
-      resolvedSeed,
-      productDir
-    );
-
-    return {
-      name,
-      productDir,
-      stateDir: path.join(productDir, ".testkit", name),
-      telemetry: normalizeTelemetryConfig(config.telemetry),
-      suites,
-      testkit: {
-        ...serviceConfig,
-        database: resolvedDatabase,
-        migrate: resolvedMigrate,
-        seed: resolvedSeed,
-        envFiles: getServiceEnvFiles(serviceConfig),
-        serviceEnv,
-      },
-    };
-  });
+  return filtered;
 }
 
 export function resolveK6Binary() {
@@ -114,142 +85,314 @@ export function resolveServiceCwd(productDir, maybeRelative) {
   return path.resolve(productDir, maybeRelative || ".");
 }
 
-function loadTestkitConfig(productDir) {
-  const configPath = path.join(productDir, TESTKIT_CONFIG);
-  const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+function normalizeServiceConfig({
+  name,
+  productDir,
+  setup,
+  setupFile,
+  explicitService,
+  discoveredService,
+  suites,
+}) {
+  const local = normalizeLocalConfig(name, explicitService, discoveredService, productDir);
+  const envFiles = inferEnvFiles(productDir, explicitService, local);
+  const serviceEnv = loadServiceEnv(productDir, envFiles);
+  const database = normalizeDatabaseConfig(explicitService, name);
+  const migrate = normalizeLifecycle(explicitService.migrate);
+  const seed = normalizeLifecycle(explicitService.seed);
+
+  if (!explicitService.databaseFrom && !database && (migrate || seed)) {
+    throw new Error(
+      `Service "${name}" defines migrate/seed hooks but no database. Add localDatabase(...) in testkit.setup.ts.`
+    );
+  }
+
+  validateServiceConfig({
+    name,
+    local,
+    database,
+    databaseFrom: explicitService.databaseFrom,
+    migrate,
+    seed,
+    dependsOn: explicitService.dependsOn || [],
+    suites,
+    productDir,
+  });
+
+  return {
+    name,
+    productDir,
+    setupFile,
+    stateDir: path.join(productDir, ".testkit", name),
+    telemetry: normalizeTelemetryConfig(setup.telemetry),
+    suites,
+    testkit: {
+      dependsOn: explicitService.dependsOn || [],
+      database,
+      databaseFrom: explicitService.databaseFrom,
+      envFiles,
+      serviceEnv,
+      migrate,
+      seed,
+      local,
+    },
+  };
+}
+
+function normalizeLocalConfig(name, explicitService, discoveredService, productDir) {
+  if (explicitService.local) {
+    return {
+      ...explicitService.local,
+      cwd: explicitService.local.cwd || ".",
+      env: explicitService.local.env || {},
+    };
+  }
+
+  const inferredCwd = discoveredService?.inferredLocalCwd || ".";
+  const detected = inferLocalRuntime(productDir, inferredCwd);
+  if (!detected) return undefined;
+
+  return detected;
+}
+
+function inferLocalRuntime(productDir, cwd) {
+  const absoluteCwd = resolveServiceCwd(productDir, cwd);
+  if (!fs.existsSync(absoluteCwd)) return undefined;
 
-  if (!isObject(raw.services)) {
-    throw new Error(`${TESTKIT_CONFIG} must have a "services" object (${configPath})`);
+  if (detectNextApp(absoluteCwd)) {
+    return {
+      cwd,
+      start: "exec ./node_modules/.bin/next dev -p {port}",
+      port: 3000,
+      baseUrl: "http://127.0.0.1:{port}",
+      readyUrl: "http://127.0.0.1:{port}",
+      env: {},
+    };
   }
 
-  if (raw.telemetry !== undefined) {
-    validateTelemetryConfigModel(raw.telemetry, configPath, TESTKIT_CONFIG);
+  if (fs.existsSync(path.join(absoluteCwd, "cmd", "server"))) {
+    return {
+      cwd,
+      start: "exec go run ./cmd/server",
+      port: 3000,
+      baseUrl: "http://127.0.0.1:{port}",
+      readyUrl: "http://127.0.0.1:{port}/health",
+      env: {},
+    };
   }
 
-  for (const [serviceName, service] of Object.entries(raw.services)) {
-    validateServiceConfigModel(serviceName, service, configPath);
+  if (fs.existsSync(path.join(absoluteCwd, "package.json")) && fs.existsSync(path.join(absoluteCwd, "src"))) {
+    return {
+      cwd,
+      start: "exec ./node_modules/.bin/tsx watch src/index.ts",
+      port: 3000,
+      baseUrl: "http://127.0.0.1:{port}",
+      readyUrl: "http://127.0.0.1:{port}/health",
+      env: {},
+    };
   }
 
-  return raw;
+  return undefined;
 }
 
-function validateConfigCoverage(config) {
-  return validateConfigCoverageModel(config, TESTKIT_CONFIG);
+function normalizeDatabaseConfig(explicitService, serviceName) {
+  if (explicitService.databaseFrom) return undefined;
+  if (!explicitService.database) return undefined;
+
+  const database =
+    explicitService.database.provider === "local"
+      ? explicitService.database
+      : {
+          provider: "local",
+          ...explicitService.database,
+        };
+
+  return {
+    ...database,
+    provider: "local",
+    selectedBackend: "local",
+    reset: database.reset !== false,
+    image: database.image || DEFAULT_LOCAL_IMAGE,
+    user: database.user || DEFAULT_LOCAL_USER,
+    password: database.password || DEFAULT_LOCAL_PASSWORD,
+    template: {
+      inputs: Array.isArray(database.template?.inputs) ? [...database.template.inputs] : [],
+    },
+    serviceName,
+  };
 }
 
-function resolveProductDir(cwd, explicitDir) {
-  if (explicitDir) {
-    const dir = path.resolve(cwd, explicitDir);
-    ensureProductFiles(dir);
-    return dir;
+function normalizeLifecycle(value) {
+  if (!value) return undefined;
+  if (!value.cmd && !value.testkitCmd) {
+    throw new Error("Lifecycle config requires cmd or testkitCmd");
   }
 
-  ensureProductFiles(cwd);
-  return cwd;
+  return {
+    cmd: value.testkitCmd || value.cmd,
+    cwd: value.testkitCwd || value.cwd,
+  };
 }
 
-function ensureProductFiles(dir) {
-  const missing = [TESTKIT_CONFIG].filter(
-    (file) => !fs.existsSync(path.join(dir, file))
-  );
-  if (missing.length > 0) {
-    throw new Error(
-      `Expected ${missing.join(" and ")} in ${dir}. Either cd into a product directory or use --dir.`
-    );
+function inferEnvFiles(productDir, explicitService, local) {
+  if (explicitService.envFile || explicitService.envFiles) {
+    const files = [];
+    if (explicitService.envFile) files.push(explicitService.envFile);
+    if (Array.isArray(explicitService.envFiles)) files.push(...explicitService.envFiles);
+    return files;
   }
+
+  const candidates = [];
+  const serviceCwd = local?.cwd || ".";
+  if (serviceCwd !== ".") {
+    candidates.push(path.posix.join(serviceCwd, ".env.testkit"));
+    candidates.push(path.posix.join(serviceCwd, ".env"));
+  }
+  candidates.push(".env.testkit");
+  candidates.push(".env");
+
+  return [...new Set(candidates)]
+    .map((candidate) => candidate.split(path.sep).join("/"))
+    .filter((candidate) => fs.existsSync(resolveServiceCwd(productDir, candidate)));
 }
 
-function validateMergedService(
+function loadServiceEnv(productDir, envFiles) {
+  const env = {};
+  for (const envFile of envFiles) {
+    Object.assign(env, parseDotenv(resolveServiceCwd(productDir, envFile)));
+  }
+  return env;
+}
+
+function validateConfigCoverage(configs) {
+  const names = new Set(configs.map((config) => config.name));
+  for (const config of configs) {
+    for (const depName of config.testkit.dependsOn || []) {
+      if (!names.has(depName)) {
+        throw new Error(`Service "${config.name}" depends on "${depName}", but ${depName} is not defined`);
+      }
+    }
+    const databaseFrom = config.testkit.databaseFrom;
+    if (databaseFrom && !names.has(databaseFrom)) {
+      throw new Error(
+        `Service "${config.name}" databaseFrom "${databaseFrom}" is not defined`
+      );
+    }
+  }
+}
+
+function validateServiceConfig({
   name,
+  local,
+  database,
+  databaseFrom,
+  migrate,
+  seed,
+  dependsOn,
   suites,
-  serviceConfig,
-  resolvedDatabase,
-  resolvedMigrate,
-  resolvedSeed,
-  productDir
-) {
+  productDir,
+}) {
   const usesLocalExecution = Object.entries(suites).some(([suiteType, discoveredSuites]) =>
     discoveredSuites.some(
       (suite) => (suite.framework && suite.framework !== "k6") || suiteType !== "dal"
     )
   );
 
-  if (usesLocalExecution && !isObject(serviceConfig.local)) {
+  if (usesLocalExecution && !local) {
     throw new Error(
-      `Service "${name}" defines non-DAL suites but has no local runtime in ${TESTKIT_CONFIG}`
+      `Service "${name}" defines non-DAL suites but no local runtime could be resolved. Add it in testkit.setup.ts.`
     );
   }
 
-  if (serviceConfig.dependsOn) {
-    for (const dep of serviceConfig.dependsOn) {
-      if (dep === name) {
-        throw new Error(`Service "${name}" cannot depend on itself`);
-      }
-    }
+  if (database && databaseFrom) {
+    throw new Error(`Service "${name}" cannot define both database and databaseFrom`);
   }
 
-  if (
-    resolvedDatabase?.provider === "local" &&
-    (serviceConfig.migrate || serviceConfig.seed) &&
-    resolvedDatabase.template.inputs.length === 0
-  ) {
-    throw new Error(
-      `Service "${name}" uses local database provisioning with migrations or seeds, so database.template.inputs must list the files/directories that define the template cache`
-    );
-  }
-
-  if (serviceConfig.local?.cwd) {
-    const cwdPath = resolveServiceCwd(productDir, serviceConfig.local.cwd);
-    if (!fs.existsSync(cwdPath)) {
-      throw new Error(
-        `Service "${name}" local.cwd does not exist: ${serviceConfig.local.cwd}`
-      );
+  for (const depName of dependsOn || []) {
+    if (depName === name) {
+      throw new Error(`Service "${name}" cannot depend on itself`);
     }
   }
 
-  if (resolvedMigrate?.cwd) {
-    const cwdPath = resolveServiceCwd(productDir, resolvedMigrate.cwd);
-    if (!fs.existsSync(cwdPath)) {
-      throw new Error(
-        `Service "${name}" migrate.cwd does not exist: ${resolvedMigrate.cwd}`
-      );
-    }
+  if (local?.cwd) {
+    ensureExistingPath(productDir, local.cwd, `Service "${name}" local.cwd`);
   }
-
-  if (resolvedSeed?.cwd) {
-    const cwdPath = resolveServiceCwd(productDir, resolvedSeed.cwd);
-    if (!fs.existsSync(cwdPath)) {
-      throw new Error(
-        `Service "${name}" seed.cwd does not exist: ${resolvedSeed.cwd}`
-      );
-    }
+  if (migrate?.cwd) {
+    ensureExistingPath(productDir, migrate.cwd, `Service "${name}" migrate.cwd`);
   }
-
-}
-function loadServiceEnv(productDir, serviceConfig) {
-  const env = {};
-  for (const envFile of getServiceEnvFiles(serviceConfig)) {
-    Object.assign(env, parseDotenv(resolveServiceCwd(productDir, envFile)));
+  if (seed?.cwd) {
+    ensureExistingPath(productDir, seed.cwd, `Service "${name}" seed.cwd`);
   }
-  return env;
 }
 
-function getServiceEnvFiles(serviceConfig) {
-  return getServiceEnvFilesModel(serviceConfig);
+function ensureExistingPath(productDir, relativePath, label) {
+  const absolute = resolveServiceCwd(productDir, relativePath);
+  if (!fs.existsSync(absolute)) {
+    throw new Error(`${label} does not exist: ${relativePath}`);
+  }
 }
 
-function resolveSelectedDatabase(name, serviceConfig) {
-  return resolveSelectedDatabaseModel(name, serviceConfig);
+function normalizeTelemetryConfig(telemetry) {
+  if (!telemetry) return null;
+  if (telemetry.endpoint) {
+    let parsed;
+    try {
+      parsed = new URL(telemetry.endpoint);
+    } catch {
+      throw new Error("testkit.setup telemetry.endpoint must be a valid URL");
+    }
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error("testkit.setup telemetry.endpoint must use http or https");
+    }
+  }
+  if (telemetry.enabled === true) {
+    if (!telemetry.endpoint) {
+      throw new Error("testkit.setup telemetry.endpoint is required when telemetry.enabled is true");
+    }
+    if (!telemetry.tokenEnv) {
+      throw new Error("testkit.setup telemetry.tokenEnv is required when telemetry.enabled is true");
+    }
+  }
+  return {
+    enabled: telemetry.enabled === true,
+    endpoint: telemetry.endpoint,
+    tokenEnv: telemetry.tokenEnv,
+    timeoutMs: telemetry.timeoutMs || 3000,
+  };
 }
 
-function resolveLifecycleConfig(value, selectedBackend) {
-  return resolveLifecycleConfigModel(value, selectedBackend);
+function resolveProductDir(cwd, explicitDir) {
+  const dir = explicitDir ? path.resolve(cwd, explicitDir) : cwd;
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Product directory does not exist: ${dir}`);
+  }
+  return dir;
 }
 
-function isObject(value) {
-  return isObjectModel(value);
+function parseDotenvString(source) {
+  const env = {};
+  for (const line of String(source).split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let val = trimmed.slice(eq + 1).trim();
+    if (
+      (val.startsWith("'") && val.endsWith("'")) ||
+      (val.startsWith("\"") && val.endsWith("\""))
+    ) {
+      val = val.slice(1, -1);
+    }
+    env[key] = val;
+  }
+  return env;
 }
 
-function normalizeTelemetryConfig(telemetry) {
-  return normalizeTelemetryConfigModel(telemetry);
+function detectNextApp(cwd) {
+  return (
+    fs.existsSync(path.join(cwd, "next.config.js")) ||
+    fs.existsSync(path.join(cwd, "next.config.mjs")) ||
+    fs.existsSync(path.join(cwd, "next.config.ts"))
+  );
 }

package/lib/config/setup-loader.mjs

@@ -0,0 +1,98 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { build } from "esbuild";
+import { fileURLToPath, pathToFileURL } from "url";
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const ROOT_ENTRY = path.join(PACKAGE_ROOT, "lib", "index.mjs");
+const SETUP_ENTRY = path.join(PACKAGE_ROOT, "lib", "setup", "index.mjs");
+const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
+const SETUP_FILES = [
+  "testkit.setup.ts",
+  "testkit.setup.mts",
+  "testkit.setup.mjs",
+  "testkit.setup.js",
+];
+
+export function findSetupFile(productDir) {
+  for (const candidate of SETUP_FILES) {
+    const absolute = path.join(productDir, candidate);
+    if (fs.existsSync(absolute)) {
+      return absolute;
+    }
+  }
+  return null;
+}
+
+export async function loadTestkitSetup(productDir) {
+  const setupFile = findSetupFile(productDir);
+  if (!setupFile) {
+    return {
+      setup: {},
+      setupFile: null,
+    };
+  }
+
+  const bundleDir = path.join(productDir, ".testkit", "_setup");
+  fs.mkdirSync(bundleDir, { recursive: true });
+
+  const cacheKey = buildSetupCacheKey(setupFile);
+  const outputFile = path.join(bundleDir, `setup-${cacheKey.slice(0, 12)}.mjs`);
+
+  await build({
+    absWorkingDir: productDir,
+    bundle: true,
+    entryPoints: [setupFile],
+    format: "esm",
+    legalComments: "none",
+    outfile: outputFile,
+    platform: "node",
+    sourcemap: "inline",
+    target: "es2020",
+    plugins: [testkitSetupAliasPlugin()],
+  });
+
+  const imported = await import(`${pathToFileURL(outputFile).href}?v=${cacheKey}`);
+  const setup = imported.default || imported.setup || {};
+  if (!setup || typeof setup !== "object") {
+    throw new Error(`testkit setup file must export an object: ${path.basename(setupFile)}`);
+  }
+
+  return {
+    setup,
+    setupFile,
+  };
+}
+
+function buildSetupCacheKey(setupFile) {
+  const content = fs.readFileSync(setupFile, "utf8");
+  return crypto.createHash("sha256").update(setupFile).update("\0").update(content).digest("hex");
+}
+
+function testkitSetupAliasPlugin() {
+  return {
+    name: "testkit-setup-alias",
+    setup(buildApi) {
+      buildApi.onResolve({ filter: /^@elench\/testkit(?:\/.*)?$/ }, (args) => ({
+        namespace: "file",
+        path: resolvePackageSubpath(args.path),
+      }));
+    },
+  };
+}
+
+function resolvePackageSubpath(specifier) {
+  const subpath = specifier.slice("@elench/testkit".length);
+  if (!subpath) return ROOT_ENTRY;
+  if (subpath === "/setup") return SETUP_ENTRY;
+  if (subpath === "/runtime") {
+    throw new Error(
+      "testkit.setup.ts may not import @elench/testkit/runtime. " +
+        "Use @elench/testkit/setup runtime helpers instead."
+    );
+  }
+  if (subpath === "/runtime/index.mjs") return RUNTIME_ENTRY;
+
+  throw new Error(`Unsupported @elench/testkit import "${specifier}" while loading testkit setup`);
+}

package/lib/index.d.ts

@@ -42,6 +42,7 @@ export interface HttpSuiteConfig<TSetup = unknown> {
   auth?: AuthAdapter<TSetup> | null;
   env?: RuntimeEnv;
   headers?: HeaderBuilder<TSetup>;
+  profile?: string;
   rawHeaders?: HeaderBuilder<never>;
   options?: RuntimeOptions;
 }

package/lib/package.test.mjs

@@ -14,11 +14,16 @@ describe("package metadata", () => {
       types: "./lib/index.d.ts",
       default: "./lib/index.mjs",
     });
+    expect(packageJson.exports["./setup"]).toEqual({
+      types: "./lib/setup/index.d.ts",
+      default: "./lib/setup/index.mjs",
+    });
     expect(packageJson.exports["./runtime"]).toEqual({
       types: "./lib/runtime/index.d.ts",
       default: "./lib/runtime/index.mjs",
     });
     expect(fs.existsSync(path.join(rootDir, "lib", "index.d.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(rootDir, "lib", "setup", "index.d.ts"))).toBe(true);
     expect(fs.existsSync(path.join(rootDir, "lib", "runtime", "index.d.ts"))).toBe(true);
   });
 });

package/lib/runner/template.mjs

@@ -72,7 +72,7 @@ export function buildPortMap(runtimeConfigs, workerId) {
     if (existing) {
       throw new Error(
         `Worker port collision: services "${existing}" and "${config.name}" both resolve to ${actualPort}. ` +
-          `Assign distinct local.port/baseUrl ports in testkit.config.json.`
+          `Assign distinct local.port/baseUrl ports in testkit.setup.ts.`
       );
     }
     seen.set(actualPort, config.name);

package/lib/runtime-src/k6/http.js

@@ -56,6 +56,7 @@ export function createHttpClient(config) {
   }
 
   return {
+    rawHttp: http,
     request,
     raw,
     get(path, setupData, extraHeaders = {}) {