@elench/testkit 0.1.76 → 0.1.78

package/lib/config-api/index.mjs

@@ -3,79 +3,34 @@ import {
   clearRuntimeContext,
   getRepoConfig,
   getRuntimeContext,
-  getRuntimeEnv,
   registerRepoConfig,
   registerRuntimeContext,
   runtimeHttp,
   runtimeJson,
 } from "./runtime.mjs";
+import {
+  customProfile,
+  localJsonProfile,
+  multiActorProfile,
+  rawProfile,
+  sessionProfile,
+} from "./profiles.mjs";
 
 export function defineConfig(config) {
   return config || {};
 }
 
-export function defineHttpProfile(profile) {
-  return profile || {};
-}
-
 export function defineFile(metadata) {
   return metadata || {};
 }
 
-export function postgresDatabase(options = {}) {
+function postgresDatabase(options = {}) {
   return {
     provider: "local",
     ...options,
   };
 }
 
-export function commandStep(cmd, options = {}) {
-  return {
-    kind: "command",
-    cmd,
-    cwd: options.cwd,
-    inputs: Array.isArray(options.inputs) ? [...options.inputs] : undefined,
-  };
-}
-
-export function sqlFileStep(filePath, options = {}) {
-  return {
-    kind: "sql-file",
-    path: filePath,
-    cwd: options.cwd,
-    inputs: Array.isArray(options.inputs) ? [...options.inputs] : undefined,
-  };
-}
-
-export function moduleStep(specifier, options = {}) {
-  return {
-    kind: "module",
-    specifier,
-    cwd: options.cwd,
-    inputs: Array.isArray(options.inputs) ? [...options.inputs] : undefined,
-  };
-}
-
-export function schemaSql(filePath, options = {}) {
-  return sqlFileStep(filePath, options);
-}
-
-export function seedCommand(cmd, options = {}) {
-  return commandStep(cmd, options);
-}
-
-export function seedModule(specifier, options = {}) {
-  return moduleStep(specifier, options);
-}
-
-export function verifyCommand(cmd, options = {}) {
-  return commandStep(cmd, options);
-}
-
-export function verifyModule(specifier, options = {}) {
-  return moduleStep(specifier, options);
-}
-
 function buildDatabaseTemplateConfig(options = {}) {
   const migrate = normalizeTemplateStepList(options.migrate);
   const seed = normalizeTemplateStepList(options.seed);
@@ -90,60 +45,40 @@ function buildDatabaseTemplateConfig(options = {}) {
   };
 }
 
-export function templateDatabase(options = {}) {
-  const {
-    inputs,
-    schema,
-    migrate,
-    seed,
-    verify,
-    ...databaseOptions
-  } = options;
-  return postgresDatabase({
-    ...databaseOptions,
-    template: buildDatabaseTemplateConfig(options.template || { inputs, schema, migrate, seed, verify }),
-  });
-}
-
-export function postgresFixture(options = {}) {
-  const { discovery, envFiles, ...databaseOptions } = options;
+function postgresFixture(options = {}) {
+  const { discovery, envFiles, template, ...databaseOptions } = options;
+  for (const legacyKey of ["inputs", "schema", "migrate", "seed", "verify"]) {
+    if (Object.prototype.hasOwnProperty.call(options, legacyKey)) {
+      throw new Error(
+        `database.fixture(...) no longer accepts top-level "${legacyKey}". Move lifecycle config under database.fixture({ template: { ... } }).`
+      );
+    }
+  }
   return {
     discovery: discovery || {
       roots: [".testkit-fixture"],
     },
     envFiles,
     local: false,
-    database: postgresDatabase(databaseOptions),
-  };
-}
-
-export function databaseServiceEnv(prefix, serviceName) {
-  const normalizedPrefix = String(prefix || "").trim().replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  if (!normalizedPrefix) {
-    throw new Error("databaseServiceEnv prefix must be a non-empty string");
-  }
-  if (!serviceName || !String(serviceName).trim()) {
-    throw new Error("databaseServiceEnv serviceName must be a non-empty string");
-  }
-
-  return {
-    [`${normalizedPrefix}_DATABASE_HOST`]: `{dbHost:${serviceName}}`,
-    [`${normalizedPrefix}_DATABASE_PORT`]: `{dbPort:${serviceName}}`,
-    [`${normalizedPrefix}_DATABASE_NAME`]: `{dbName:${serviceName}}`,
-    [`${normalizedPrefix}_DATABASE_USER`]: `{dbUser:${serviceName}}`,
-    [`${normalizedPrefix}_DATABASE_PASSWORD`]: `{dbPassword:${serviceName}}`,
-    [`${normalizedPrefix}_DATABASE_SSL`]: "0",
+    database: postgresDatabase(
+      template
+        ? {
+            ...databaseOptions,
+            template: buildDatabaseTemplateConfig(template),
+          }
+        : databaseOptions
+    ),
   };
 }
 
-export function nodeToolchain(options = {}) {
+function nodeToolchain(options = {}) {
   return {
     kind: "node",
     ...options,
   };
 }
 
-export function tscBuild(options = {}) {
+function tscBuild(options = {}) {
   return {
     kind: "tsc",
     cwd: options.cwd,
@@ -154,7 +89,7 @@ export function tscBuild(options = {}) {
   };
 }
 
-export function scriptBuild(script, options = {}) {
+function scriptBuild(script, options = {}) {
   return {
     kind: "script",
     script,
@@ -163,7 +98,7 @@ export function scriptBuild(script, options = {}) {
   };
 }
 
-export function stepsBuild(options = {}) {
+function stepsBuild(options = {}) {
   return {
     kind: "steps",
     inputs: Array.isArray(options.inputs) ? [...options.inputs] : undefined,
@@ -171,7 +106,7 @@ export function stepsBuild(options = {}) {
   };
 }
 
-export function nextBuild(options = {}) {
+function nextBuild(options = {}) {
   return {
     kind: "next",
     cwd: options.cwd,
@@ -181,14 +116,14 @@ export function nextBuild(options = {}) {
   };
 }
 
-export function nodeApp(options = {}) {
+function nodeApp(options = {}) {
   const {
     baseUrl: explicitBaseUrl,
     build: explicitBuild,
     buildInputs,
     cwd = ".",
     entry = "src/index.ts",
-    env = {},
+    env,
     envFiles,
     outDir = "dist",
     port,
@@ -202,7 +137,8 @@ export function nodeApp(options = {}) {
     ...serviceConfig
   } = options;
 
-  const normalizedPort = requiredNumber(port, "nodeApp port");
+  const normalizedPort = requiredNumber(port, "app.node port");
+  const normalizedEnv = normalizePresetEnv(env);
   const baseUrl = explicitBaseUrl || "http://127.0.0.1:{port}";
   const build = explicitBuild === undefined ? tscBuild({
     cwd,
@@ -228,12 +164,12 @@ export function nodeApp(options = {}) {
       baseUrl,
       readyUrl: explicitReadyUrl || `${baseUrl}${readyPath}`,
       readyTimeoutMs,
-      env,
+      env: normalizedEnv,
     },
   };
 }
 
-export function nextApp(options = {}) {
+function nextApp(options = {}) {
   const {
     baseUrl: explicitBaseUrl,
     browser,
@@ -241,7 +177,7 @@ export function nextApp(options = {}) {
     buildInputs,
     cwd = ".",
     dependsOn,
-    env = {},
+    env,
     envFiles,
     mode = "dev",
     port,
@@ -253,7 +189,8 @@ export function nextApp(options = {}) {
     ...serviceConfig
   } = options;
 
-  const normalizedPort = requiredNumber(port, "nextApp port");
+  const normalizedPort = requiredNumber(port, "app.next port");
+  const normalizedEnv = normalizePresetEnv(env);
   const baseUrl = explicitBaseUrl || "http://127.0.0.1:{port}";
   const build =
     explicitBuild === undefined
@@ -286,82 +223,54 @@ export function nextApp(options = {}) {
       readyTimeoutMs,
       env: mode === "start"
         ? {
-            NEXT_DIST_DIR: env.NEXT_DIST_DIR || ".next-testkit/{runtimeId}/dist",
-            NEXT_TSCONFIG_PATH: env.NEXT_TSCONFIG_PATH || ".next-testkit/{runtimeId}/tsconfig.json",
-            ...env,
+            NEXT_DIST_DIR: normalizedEnv.NEXT_DIST_DIR || ".next-testkit/{runtimeId}/dist",
+            NEXT_TSCONFIG_PATH:
+              normalizedEnv.NEXT_TSCONFIG_PATH || ".next-testkit/{runtimeId}/tsconfig.json",
+            ...normalizedEnv,
           }
-        : env,
+        : normalizedEnv,
     },
   };
 }
 
-export function clerkSessionProfile(options = {}) {
-  const apiBase = options.apiBase || "https://api.clerk.com/v1";
-  const secretKeyEnv = options.secretKeyEnv || "CLERK_SECRET_KEY";
-  const needsAuth = options.needsAuth !== false;
-
-  return defineHttpProfile({
-    auth: {
-      setup() {
-        return resolveClerkSession({
-          apiBase,
-          secretKey: envValue(secretKeyEnv),
-          needsAuth,
-        });
-      },
-      headers(setupData) {
-        return getClerkAuthHeaders(setupData, { apiBase });
-      },
-    },
-  });
-}
+export const app = {
+  node: nodeApp,
+  next: nextApp,
+};
 
-export function jsonSessionProfile(options = {}) {
-  const loginPath = options.loginPath || "/api/auth/login";
-  const cookieName = options.cookieName || "session";
-  const body =
-    typeof options.body === "function"
-      ? options.body
-      : () => ({
-          username: envValue(options.usernameEnv || "TESTKIT_USERNAME"),
-          password: envValue(options.passwordEnv || "TESTKIT_PASSWORD"),
-        });
-
-  return defineHttpProfile({
-    auth: {
-      setup({ env }) {
-        const requestBody = body({ env });
-        const res = runtimeHttp.post(`${env.BASE}${loginPath}`, JSON.stringify(requestBody), {
-          headers: {
-            "Content-Type": "application/json",
-            ...(env.routeParams || {}),
-            ...(options.headers || {}),
-          },
-        });
-
-        if (res.status !== (options.successStatus || 200)) {
-          throw new Error(`Login failed (${res.status}): ${res.body}`);
-        }
-
-        const cookie = res.cookies?.[cookieName]?.[0]?.value ?? null;
-        if (!cookie) {
-          throw new Error(`No ${cookieName} cookie returned from login`);
-        }
-
-        return {
-          cookie,
-          body: safeJson(res),
-        };
-      },
-      headers(session) {
-        if (!session?.cookie) return {};
-        return {
-          Cookie: `${cookieName}=${session.cookie}`,
-        };
-      },
-    },
-  });
-}
+export const database = {
+  postgres(options = {}) {
+    const { template, ...databaseOptions } = options;
+    for (const legacyKey of ["inputs", "schema", "migrate", "seed", "verify"]) {
+      if (Object.prototype.hasOwnProperty.call(options, legacyKey)) {
+        throw new Error(
+          `database.postgres(...) no longer accepts top-level "${legacyKey}". Move lifecycle config under database.postgres({ template: { ... } }).`
+        );
+      }
+    }
+    return postgresDatabase(
+      template
+        ? {
+            ...databaseOptions,
+            template: buildDatabaseTemplateConfig(template),
+          }
+        : databaseOptions
+    );
+  },
+  fixture: postgresFixture,
+};
+
+export const toolchain = {
+  node: nodeToolchain,
+};
+
+export const profiles = {
+  custom: customProfile,
+  localJson: localJsonProfile,
+  multiActor: multiActorProfile,
+  raw: rawProfile,
+  session: sessionProfile,
+};
 
 export {
   clearRepoConfig,
@@ -381,6 +290,58 @@ function requiredNumber(value, label) {
   return value;
 }
 
+function normalizePresetEnv(env) {
+  if (!env) return {};
+  if (typeof env !== "object" || Array.isArray(env)) {
+    throw new Error("Preset env must be an object");
+  }
+  const allowedKeys = new Set(["values", "databases"]);
+  const unexpectedKeys = Object.keys(env).filter((key) => !allowedKeys.has(key));
+  if (unexpectedKeys.length > 0) {
+    throw new Error(
+      `Preset env only supports "values" and "databases". Received unexpected key(s): ${unexpectedKeys.join(", ")}`
+    );
+  }
+
+  const values = env.values && typeof env.values === "object" && !Array.isArray(env.values) ? env.values : {};
+  const databases =
+    env.databases && typeof env.databases === "object" && !Array.isArray(env.databases) ? env.databases : {};
+
+  return {
+    ...expandDatabaseBindings(databases),
+    ...values,
+  };
+}
+
+function expandDatabaseBindings(bindings) {
+  const env = {};
+  for (const [name, binding] of Object.entries(bindings || {})) {
+    if (!binding || typeof binding !== "object" || Array.isArray(binding)) {
+      throw new Error(`env.databases.${name} must be an object`);
+    }
+    const prefix = normalizeDatabaseEnvToken(binding.prefix, `env.databases.${name}.prefix`);
+    const serviceName = normalizeDatabaseEnvToken(binding.service, `env.databases.${name}.service`, false);
+    env[`${prefix}_DATABASE_HOST`] = `{dbHost:${serviceName}}`;
+    env[`${prefix}_DATABASE_PORT`] = `{dbPort:${serviceName}}`;
+    env[`${prefix}_DATABASE_NAME`] = `{dbName:${serviceName}}`;
+    env[`${prefix}_DATABASE_USER`] = `{dbUser:${serviceName}}`;
+    env[`${prefix}_DATABASE_PASSWORD`] = `{dbPassword:${serviceName}}`;
+    env[`${prefix}_DATABASE_SSL`] = "0";
+  }
+  return env;
+}
+
+function normalizeDatabaseEnvToken(value, label, sanitize = true) {
+  const raw = String(value || "").trim();
+  const normalized = sanitize
+    ? raw.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "")
+    : raw;
+  if (!normalized) {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  return normalized;
+}
+
 function resolveNodeAppStart(build, entry) {
   if (build?.kind === "tsc") {
     const compiled = compiledEntryFromSource(entry || build.entry || "src/index.ts", build.outDir || "dist");
@@ -397,7 +358,10 @@ function normalizeTemplateStepList(value) {
 function normalizeSchemaStep(value) {
   if (value == null) return null;
   if (typeof value === "string") {
-    return sqlFileStep(value);
+    return {
+      kind: "sql-file",
+      path: value,
+    };
   }
   return value;
 }
@@ -408,101 +372,3 @@ function compiledEntryFromSource(entry, outDir) {
   const relative = compiled.startsWith("src/") ? compiled.slice(4) : compiled;
   return `${outDir}/${relative}`.replace(/\/+/g, "/");
 }
-
-function envValue(name) {
-  const env = getRuntimeEnv();
-  const value = env?.rawEnv?.[name] || env?.[name];
-  if (!value) {
-    throw new Error(`Missing required env var "${name}" for testkit config`);
-  }
-  return value;
-}
-
-function safeJson(response) {
-  try {
-    return runtimeJson(response);
-  } catch {
-    return null;
-  }
-}
-
-function resolveClerkSession({ apiBase, secretKey, needsAuth }) {
-  if (!needsAuth) {
-    return { jwt: null };
-  }
-
-  const headers = { Authorization: `Bearer ${secretKey}` };
-  const usersRes = runtimeHttp.get(`${apiBase}/users?limit=1&order_by=-created_at`, {
-    headers,
-  });
-  if (usersRes.status !== 200) {
-    throw new Error(`Clerk list users failed (${usersRes.status}): ${usersRes.body}`);
-  }
-
-  const users = runtimeJson(usersRes);
-  if (!users.length) {
-    throw new Error("No Clerk users found for testkit Clerk auth profile");
-  }
-
-  const userId = users[0].id;
-  const sessionsRes = runtimeHttp.get(
-    `${apiBase}/sessions?user_id=${userId}&status=active&limit=1`,
-    { headers }
-  );
-  if (sessionsRes.status !== 200) {
-    throw new Error(`Clerk list sessions failed (${sessionsRes.status}): ${sessionsRes.body}`);
-  }
-
-  const sessions = runtimeJson(sessionsRes);
-  if (!sessions?.length) {
-    throw new Error("No active Clerk session found for testkit Clerk auth profile");
-  }
-
-  const sessionId = sessions[0].id;
-  const tokenRes = runtimeHttp.post(`${apiBase}/sessions/${sessionId}/tokens`, null, {
-    headers: {
-      ...headers,
-      "Content-Type": "application/json",
-    },
-  });
-  if (tokenRes.status !== 200) {
-    throw new Error(`Clerk create token failed (${tokenRes.status}): ${tokenRes.body}`);
-  }
-
-  return {
-    jwt: runtimeJson(tokenRes).jwt,
-    sessionId,
-    secretKey,
-  };
-}
-
-function getClerkAuthHeaders(setupData, { apiBase }) {
-  if (!setupData?.jwt) return {};
-
-  if (!setupData.sessionId || !setupData.secretKey) {
-    return {
-      Authorization: `Bearer ${setupData.jwt}`,
-      "Content-Type": "application/json",
-    };
-  }
-
-  const tokenRes = runtimeHttp.post(`${apiBase}/sessions/${setupData.sessionId}/tokens`, null, {
-    headers: {
-      Authorization: `Bearer ${setupData.secretKey}`,
-      "Content-Type": "application/json",
-    },
-  });
-  if (tokenRes.status !== 200) {
-    return {
-      Authorization: `Bearer ${setupData.jwt}`,
-      "Content-Type": "application/json",
-    };
-  }
-
-  const nextJwt = runtimeJson(tokenRes).jwt;
-  setupData.jwt = nextJwt;
-  return {
-    Authorization: `Bearer ${nextJwt}`,
-    "Content-Type": "application/json",
-  };
-}