@elench/testkit 0.1.59 → 0.1.61

package/lib/config/database.mjs

@@ -0,0 +1,53 @@
+import { normalizeDatabaseBinding } from "../runner/execution-config.mjs";
+import { normalizeOptionalString, normalizeTemplateInputs, normalizeTemplateLifecycleSteps } from "./runtime.mjs";
+
+const DEFAULT_LOCAL_IMAGE = "pgvector/pgvector:pg16";
+const DEFAULT_LOCAL_USER = "testkit";
+const DEFAULT_LOCAL_PASSWORD = "testkit";
+
+export 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,
+    binding: normalizeDatabaseBinding(database.binding || "per-runtime", `Service "${serviceName}" database.binding`),
+    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: normalizeDatabaseTemplateConfig(database.template, serviceName),
+    serviceName,
+  };
+}
+
+export function normalizeDatabaseTemplateConfig(value, serviceName) {
+  if (value == null) {
+    return {
+      inputs: [],
+      migrate: [],
+      seed: [],
+      verify: [],
+    };
+  }
+  if (!value || typeof value !== "object") {
+    throw new Error(`Service "${serviceName}" database.template must be an object`);
+  }
+
+  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`),
+  };
+}

package/lib/config/database.test.mjs

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { normalizeDatabaseConfig } from "./database.mjs";
+
+describe("config database helpers", () => {
+  it("normalizes local database config with template defaults", () => {
+    expect(
+      normalizeDatabaseConfig(
+        {
+          database: {
+            template: {
+              migrate: [{ kind: "sql-file", path: "sql/migrate.sql" }],
+            },
+          },
+        },
+        "web"
+      )
+    ).toMatchObject({
+      provider: "local",
+      selectedBackend: "local",
+      reset: true,
+      template: {
+        inputs: [],
+        migrate: [{ kind: "sql-file", path: "sql/migrate.sql" }],
+        seed: [],
+        verify: [],
+      },
+    });
+  });
+});

package/lib/config/discovery-config.mjs

@@ -0,0 +1,13 @@
+import { normalizeDiscoveryConfig } from "../discovery/path-policy.mjs";
+
+export function normalizeRepoDiscoveryConfig(value) {
+  return normalizeDiscoveryConfig(value, { allowRoots: true });
+}
+
+export function normalizeServiceDiscoveryConfig(value, serviceName) {
+  try {
+    return normalizeDiscoveryConfig(value, { allowRoots: true });
+  } catch (error) {
+    throw new Error(`Service "${serviceName}" has invalid discovery config: ${error.message}`);
+  }
+}

package/lib/config/env.mjs

@@ -0,0 +1,55 @@
+import fs from "fs";
+import path from "path";
+import { resolveServiceCwd } from "./paths.mjs";
+
+export function parseDotenv(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  return parseDotenvString(fs.readFileSync(filePath, "utf8"));
+}
+
+export 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;
+}
+
+export 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)));
+}
+
+export function loadServiceEnv(productDir, envFiles) {
+  const env = {};
+  for (const envFile of envFiles) {
+    Object.assign(env, parseDotenv(resolveServiceCwd(productDir, envFile)));
+  }
+  return env;
+}

package/lib/config/env.test.mjs

@@ -0,0 +1,40 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { inferEnvFiles, parseDotenvString } from "./env.mjs";
+
+const cleanups = [];
+
+afterEach(() => {
+  while (cleanups.length > 0) {
+    cleanups.pop()();
+  }
+});
+
+describe("config env helpers", () => {
+  it("parses dotenv content with comments and quoted values", () => {
+    expect(
+      parseDotenvString(`
+        # comment
+        FOO=bar
+        BAR="quoted value"
+        BAZ='single quoted'
+      `)
+    ).toEqual({
+      FOO: "bar",
+      BAR: "quoted value",
+      BAZ: "single quoted",
+    });
+  });
+
+  it("infers env files from service cwd and root", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-env-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+    fs.mkdirSync(path.join(productDir, "apps", "web"), { recursive: true });
+    fs.writeFileSync(path.join(productDir, ".env"), "ROOT=1\n");
+    fs.writeFileSync(path.join(productDir, "apps", "web", ".env.testkit"), "WEB=1\n");
+
+    expect(inferEnvFiles(productDir, {}, { cwd: "apps/web" })).toEqual(["apps/web/.env.testkit", ".env"]);
+  });
+});