@elench/testkit 0.1.65 → 0.1.67

package/lib/setup/index.test.mjs

@@ -1,38 +1,49 @@
 import { describe, expect, it } from "vitest";
 import {
-  goService,
-  nextService,
+  databaseServiceEnv,
+  defineTestkitFile,
+  nextApp,
+  nextBuild,
   nodeToolchain,
+  nodeApp,
+  postgresDatabase,
+  postgresFixture,
   schemaSql,
   seedCommand,
   seedModule,
-  seededDatabaseTemplate,
-  tsxService,
+  stepsBuild,
+  templateDatabase,
+  tscBuild,
   verifyCommand,
   verifyModule,
 } from "./index.mjs";
 
 describe("setup helpers", () => {
-  it("emits plain next start commands without an exec prefix", () => {
-    const config = nextService({ port: 3000 });
-
-    expect(config.local.start).toBe("./node_modules/.bin/next dev -p {port}");
+  it("defines file-local metadata plainly", () => {
+    expect(defineTestkitFile({ skip: "Auth is stubbed", locks: ["background-workers"] })).toEqual({
+      skip: "Auth is stubbed",
+      locks: ["background-workers"],
+    });
   });
 
-  it("emits plain tsx start commands without an exec prefix", () => {
-    const config = tsxService({ port: 3000, entry: "src/server.ts" });
+  it("builds a Next app preset for dev mode", () => {
+    const config = nextApp({ port: 3000 });
 
-    expect(config.local.start).toBe("./node_modules/.bin/tsx watch src/server.ts");
+    expect(config.local.start).toBe("./node_modules/.bin/next dev -p {port}");
   });
 
-  it("emits plain go start commands without an exec prefix", () => {
-    expect(goService({ port: 3000 }).local.start).toBe("go run ./cmd/server");
-    expect(goService({ port: 3000, entrypoint: "./cmd/api" }).local.start).toBe(
-      "go run ./cmd/api"
-    );
-    expect(goService({ port: 3000, command: "./cmd/worker" }).local.start).toBe(
-      "go run ./cmd/worker"
-    );
+  it("builds a Node app preset with tsc build defaults", () => {
+    const config = nodeApp({ port: 3000, entry: "src/server.ts" });
+
+    expect(config.local.start).toBe("node {prepareDir}/dist/server.js");
+    expect(config.runtime.build).toEqual({
+      kind: "tsc",
+      cwd: ".",
+      entry: "src/server.ts",
+      tsconfig: "tsconfig.json",
+      outDir: "dist",
+      inputs: undefined,
+    });
   });
 
   it("builds node toolchain profiles with a node kind", () => {
@@ -43,6 +54,40 @@ describe("setup helpers", () => {
     });
   });
 
+  it("builds explicit build presets", () => {
+    expect(tscBuild({ entry: "src/server.ts", outDir: "build" })).toEqual({
+      kind: "tsc",
+      cwd: undefined,
+      entry: "src/server.ts",
+      tsconfig: "tsconfig.json",
+      outDir: "build",
+      inputs: undefined,
+    });
+    expect(nextBuild({ cwd: "frontend" })).toEqual({
+      kind: "script",
+      script: "./node_modules/.bin/next build",
+      cwd: "frontend",
+      inputs: undefined,
+    });
+    expect(
+      stepsBuild({
+        inputs: ["scripts/prepare.mjs"],
+        steps: [seedCommand("node scripts/prepare.mjs")],
+      })
+    ).toEqual({
+      kind: "steps",
+      inputs: ["scripts/prepare.mjs"],
+      steps: [
+        {
+          kind: "command",
+          cmd: "node scripts/prepare.mjs",
+          cwd: undefined,
+          inputs: undefined,
+        },
+      ],
+    });
+  });
+
   it("emits semantic database template steps using the underlying step shapes", () => {
     expect(schemaSql("db/schema.sql")).toEqual({
       kind: "sql-file",
@@ -76,67 +121,152 @@ describe("setup helpers", () => {
     });
   });
 
-  it("builds a seeded database template from schema, seed, and verify intents", () => {
+  it("builds declarative template databases from schema, seed, and verify intents", () => {
     expect(
-      seededDatabaseTemplate({
+      templateDatabase({
         inputs: ["db/schema.sql", "scripts/seed.ts"],
         schema: "db/schema.sql",
         seed: seedCommand("npm run db:seed"),
         verify: verifyModule("scripts/verify.ts#verifySeed"),
       })
     ).toEqual({
-      inputs: ["db/schema.sql", "scripts/seed.ts"],
-      migrate: [
-        {
-          kind: "sql-file",
-          path: "db/schema.sql",
-          cwd: undefined,
-          inputs: undefined,
-        },
-      ],
-      seed: [
-        {
-          kind: "command",
-          cmd: "npm run db:seed",
-          cwd: undefined,
-          inputs: undefined,
-        },
-      ],
-      verify: [
-        {
-          kind: "module",
-          specifier: "scripts/verify.ts#verifySeed",
-          cwd: undefined,
-          inputs: undefined,
-        },
-      ],
+      provider: "local",
+      template: {
+        inputs: ["db/schema.sql", "scripts/seed.ts"],
+        migrate: [
+          {
+            kind: "sql-file",
+            path: "db/schema.sql",
+            cwd: undefined,
+            inputs: undefined,
+          },
+        ],
+        seed: [
+          {
+            kind: "command",
+            cmd: "npm run db:seed",
+            cwd: undefined,
+            inputs: undefined,
+          },
+        ],
+        verify: [
+          {
+            kind: "module",
+            specifier: "scripts/verify.ts#verifySeed",
+            cwd: undefined,
+            inputs: undefined,
+          },
+        ],
+      },
     });
   });
 
   it("prepends schema before explicit migrate steps and normalizes singletons to arrays", () => {
     expect(
-      seededDatabaseTemplate({
+      templateDatabase({
         schema: schemaSql("db/schema.sql", { cwd: "db" }),
         migrate: seedCommand("echo migrate"),
       })
     ).toEqual({
-      inputs: undefined,
-      migrate: [
-        {
-          kind: "sql-file",
-          path: "db/schema.sql",
-          cwd: "db",
-          inputs: undefined,
-        },
-        {
-          kind: "command",
-          cmd: "echo migrate",
-          cwd: undefined,
-          inputs: undefined,
-        },
-      ],
-      seed: [],
-      verify: [],
+      provider: "local",
+      template: {
+        inputs: undefined,
+        migrate: [
+          {
+            kind: "sql-file",
+            path: "db/schema.sql",
+            cwd: "db",
+            inputs: undefined,
+          },
+          {
+            kind: "command",
+            cmd: "echo migrate",
+            cwd: undefined,
+            inputs: undefined,
+          },
+        ],
+        seed: [],
+        verify: [],
+      },
+    });
+  });
+
+  it("builds declarative postgres database helpers", () => {
+    expect(postgresDatabase({ reset: false })).toEqual({
+      provider: "local",
+      reset: false,
     });
+    expect(
+      templateDatabase({
+        reset: true,
+        schema: "db/schema.sql",
+        seed: seedCommand("npm run db:seed"),
+      })
+    ).toEqual({
+      provider: "local",
+      reset: true,
+      template: {
+        inputs: undefined,
+        migrate: [
+          {
+            kind: "sql-file",
+            path: "db/schema.sql",
+            cwd: undefined,
+            inputs: undefined,
+          },
+        ],
+        seed: [
+          {
+            kind: "command",
+            cmd: "npm run db:seed",
+            cwd: undefined,
+            inputs: undefined,
+          },
+        ],
+        verify: [],
+      },
+    });
+  });
+
+  it("builds support database presets and env bindings", () => {
+    expect(
+      postgresFixture({
+        reset: true,
+      })
+    ).toEqual({
+      discovery: {
+        roots: [".testkit-fixture"],
+      },
+      envFiles: undefined,
+      local: false,
+      database: {
+        provider: "local",
+        reset: true,
+      },
+    });
+    expect(databaseServiceEnv("ONIX", "catalog")).toEqual({
+      ONIX_DATABASE_HOST: "{dbHost:catalog}",
+      ONIX_DATABASE_PORT: "{dbPort:catalog}",
+      ONIX_DATABASE_NAME: "{dbName:catalog}",
+      ONIX_DATABASE_USER: "{dbUser:catalog}",
+      ONIX_DATABASE_PASSWORD: "{dbPassword:catalog}",
+      ONIX_DATABASE_SSL: "0",
+    });
+  });
+
+  it("does not leak preset-only helper fields into node app configs", () => {
+    const config = nodeApp({
+      port: 3000,
+      entry: "src/server.ts",
+      buildInputs: ["src", "package.json"],
+      env: { API_KEY: "test" },
+      readyPath: "/live",
+    });
+
+    expect(config).not.toHaveProperty("entry");
+    expect(config).not.toHaveProperty("buildInputs");
+    expect(config).not.toHaveProperty("readyPath");
+    expect(config.local.env).toEqual({ API_KEY: "test" });
+    expect(config.local.readyUrl).toBe("http://127.0.0.1:{port}/live");
   });
 });

package/lib/shared/build-config.mjs

@@ -0,0 +1,144 @@
+import path from "path";
+import { normalizeConfiguredInputs, normalizeConfiguredSteps, normalizeOptionalString } from "./configured-steps.mjs";
+
+export function normalizeBuildConfig(value, label) {
+  if (value == null) return null;
+  if (!value || typeof value !== "object") {
+    throw new Error(`${label} must be an object`);
+  }
+
+  const kind = normalizeOptionalString(value.kind);
+  if (kind === "tsc") {
+    return {
+      kind,
+      cwd: normalizeOptionalString(value.cwd),
+      entry: normalizeOptionalString(value.entry) || "src/index.ts",
+      tsconfig: normalizeOptionalString(value.tsconfig) || "tsconfig.json",
+      outDir: normalizeOptionalString(value.outDir) || "dist",
+      inputs: normalizeConfiguredInputs(value.inputs, `${label}.inputs`),
+    };
+  }
+
+  if (kind === "script") {
+    const script = normalizeOptionalString(value.script);
+    if (!script) throw new Error(`${label}.script must be a non-empty string`);
+    return {
+      kind,
+      cwd: normalizeOptionalString(value.cwd),
+      script,
+      inputs: normalizeConfiguredInputs(value.inputs, `${label}.inputs`),
+    };
+  }
+
+  if (kind === "steps") {
+    return {
+      kind,
+      inputs: normalizeConfiguredInputs(value.inputs, `${label}.inputs`),
+      steps: normalizeConfiguredSteps(value.steps, `${label}.steps`),
+    };
+  }
+
+  throw new Error(`${label}.kind must be one of: tsc, script, steps`);
+}
+
+export function finalizeBuildConfig(build, transform) {
+  if (!build) return null;
+  if (build.kind === "tsc") {
+    return {
+      ...build,
+      cwd: build.cwd ? transform(build.cwd) : build.cwd,
+      entry: transform(build.entry),
+      tsconfig: transform(build.tsconfig),
+      outDir: transform(build.outDir),
+      inputs: build.inputs.map((input) => transform(input)),
+    };
+  }
+  if (build.kind === "script") {
+    return {
+      ...build,
+      cwd: build.cwd ? transform(build.cwd) : build.cwd,
+      script: transform(build.script),
+      inputs: build.inputs.map((input) => transform(input)),
+    };
+  }
+  return {
+    ...build,
+    inputs: build.inputs.map((input) => transform(input)),
+    steps: build.steps.map((step) => ({
+      ...step,
+      ...(typeof step.cmd === "string" ? { cmd: transform(step.cmd) } : {}),
+      ...(typeof step.cwd === "string" ? { cwd: transform(step.cwd) } : {}),
+      ...(typeof step.path === "string" ? { path: transform(step.path) } : {}),
+      ...(typeof step.specifier === "string" ? { specifier: transform(step.specifier) } : {}),
+      inputs: (step.inputs || []).map((input) => transform(input)),
+    })),
+  };
+}
+
+export function buildConfigToPrepare(build) {
+  if (!build) {
+    return {
+      inputs: [],
+      steps: [],
+    };
+  }
+
+  if (build.kind === "steps") {
+    return {
+      inputs: [...build.inputs],
+      steps: [...build.steps],
+    };
+  }
+
+  if (build.kind === "script") {
+    return {
+      inputs: [...build.inputs],
+      steps: [
+        {
+          kind: "command",
+          cmd: build.script,
+          cwd: build.cwd || undefined,
+          inputs: [...build.inputs],
+        },
+      ],
+    };
+  }
+
+  const inputs = build.inputs.length > 0 ? [...build.inputs] : defaultTscInputs(build);
+  const cmd = `./node_modules/.bin/tsc -p ${build.tsconfig} --outDir "{prepareDir}/${build.outDir}"`;
+  return {
+    inputs,
+    steps: [
+      {
+        kind: "command",
+        cmd,
+        cwd: build.cwd || undefined,
+        inputs,
+      },
+    ],
+  };
+}
+
+export function compiledEntryFromBuild(build) {
+  if (!build || build.kind !== "tsc") return null;
+  return path.posix.join(build.outDir, sourceEntryToOutputPath(build.entry));
+}
+
+function sourceEntryToOutputPath(entry) {
+  const normalized = String(entry).split(path.sep).join("/");
+  const withoutExtension = normalized.replace(/\.[cm]?[jt]sx?$/i, ".js");
+  if (withoutExtension.startsWith("src/")) {
+    return withoutExtension.slice(4);
+  }
+  return withoutExtension;
+}
+
+function defaultTscInputs(build) {
+  const inputs = new Set([build.tsconfig, "package.json"]);
+  const normalizedEntry = String(build.entry).split(path.sep).join("/");
+  const topLevelDir = normalizedEntry.includes("/") ? normalizedEntry.slice(0, normalizedEntry.indexOf("/")) : normalizedEntry;
+  if (topLevelDir) {
+    inputs.add(topLevelDir);
+  }
+  return [...inputs];
+}

package/lib/shared/build-config.test.mjs

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildConfigToPrepare,
+  compiledEntryFromBuild,
+  normalizeBuildConfig,
+} from "./build-config.mjs";
+
+describe("shared build config helpers", () => {
+  it("normalizes tsc build config and derives prepare steps", () => {
+    const build = normalizeBuildConfig(
+      {
+        kind: "tsc",
+        entry: "src/server.ts",
+        outDir: "dist",
+      },
+      "runtime.build"
+    );
+
+    expect(build).toEqual({
+      kind: "tsc",
+      cwd: null,
+      entry: "src/server.ts",
+      tsconfig: "tsconfig.json",
+      outDir: "dist",
+      inputs: [],
+    });
+    expect(compiledEntryFromBuild(build)).toBe("dist/server.js");
+    expect(buildConfigToPrepare(build)).toEqual({
+      inputs: ["tsconfig.json", "package.json", "src"],
+      steps: [
+        {
+          kind: "command",
+          cmd: './node_modules/.bin/tsc -p tsconfig.json --outDir "{prepareDir}/dist"',
+          cwd: undefined,
+          inputs: ["tsconfig.json", "package.json", "src"],
+        },
+      ],
+    });
+  });
+
+  it("normalizes script and steps builds", () => {
+    expect(
+      normalizeBuildConfig(
+        {
+          kind: "script",
+          script: "npm run build",
+          cwd: "frontend",
+          inputs: ["frontend/package.json"],
+        },
+        "runtime.build"
+      )
+    ).toEqual({
+      kind: "script",
+      script: "npm run build",
+      cwd: "frontend",
+      inputs: ["frontend/package.json"],
+    });
+
+    expect(
+      normalizeBuildConfig(
+        {
+          kind: "steps",
+          inputs: ["scripts/prepare.mjs"],
+          steps: [{ kind: "command", cmd: "node scripts/prepare.mjs" }],
+        },
+        "runtime.build"
+      )
+    ).toEqual({
+      kind: "steps",
+      inputs: ["scripts/prepare.mjs"],
+      steps: [
+        {
+          kind: "command",
+          cmd: "node scripts/prepare.mjs",
+          cwd: null,
+          inputs: [],
+        },
+      ],
+    });
+  });
+});