@elench/testkit 0.1.118 → 0.1.120

package/lib/config-api/index.d.ts

@@ -9,9 +9,9 @@ export interface DatabaseTemplateConfig {
 
 export interface DatabaseTemplateOptions {
   inputs?: string[];
-  migrate?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[];
-  seed?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[];
-  verify?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[];
+  migrate?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
+  seed?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
+  verify?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
 }
 
 export interface DatabaseSourceSchemaOptions {
@@ -26,6 +26,7 @@ export interface DatabaseSourceSchemaConfig extends DatabaseSourceSchemaOptions
 }
 
 export interface TemplateStepBaseConfig {
+  args?: unknown;
   cwd?: string;
   inputs?: string[];
 }
@@ -50,6 +51,8 @@ export type TemplateLifecycleStepConfig =
   | TemplateSqlFileStepConfig
   | TemplateModuleStepConfig;
 
+export interface TemplateLifecycleStepOptions extends TemplateStepBaseConfig {}
+
 export interface TscBuildConfig {
   kind: "tsc";
   cwd?: string;
@@ -160,6 +163,81 @@ export interface RegressionSyncConfig {
   cacheTtlSeconds?: number;
 }
 
+export interface TestkitBoundaryLintConfig {
+  allowed?: string[];
+  severity?: "error" | "warn" | false;
+  trackedOnly?: boolean;
+}
+
+export interface TestkitLintConfig {
+  disable?: string[];
+  rules?: Partial<Record<
+    | "missingImports"
+    | "uiRuntimeImports"
+    | "uiSpecShape"
+    | "dalParallelSafety"
+    | "legacyHttpAssertions"
+    | "legacyDalAssertions"
+    | "configImports",
+    boolean
+  >> & {
+    testkitBoundary?: TestkitBoundaryLintConfig | boolean;
+  };
+  testkitBoundary?: TestkitBoundaryLintConfig | boolean;
+  ui?: {
+    maxLines?: number;
+    maxTests?: number;
+  };
+}
+
+export interface UiProvisionProfileConfig {
+  afterSignupSql?: string | string[];
+  email?: string;
+  emailDomain?: string;
+  loginBody?: Record<string, unknown>;
+  loginExpect?: number | number[];
+  loginPath?: string;
+  name?: string;
+  organizationName?: string;
+  password?: string;
+  sessionPath?: string;
+  signup?: false;
+  signupBody?: Record<string, unknown>;
+  signupExpect?: number | number[];
+  signupPath?: string;
+}
+
+export interface UiAuthConfig {
+  afterSignupSql?: string | string[];
+  authenticatedSelector?: string;
+  backendBaseUrl?: string;
+  browserState?: {
+    localStorage?: Record<string, unknown>;
+  };
+  databaseUrl?: string;
+  emailSelector?: string;
+  frontendBaseUrl?: string;
+  homePath?: string;
+  loginBody?: Record<string, unknown>;
+  loginExpect?: number | number[];
+  loginPagePath?: string;
+  loginPath?: string;
+  passwordSelector?: string;
+  profiles?: Record<string, UiProvisionProfileConfig>;
+  sessionPath?: string;
+  signup?: false;
+  signupBody?: Record<string, unknown>;
+  signupExpect?: number | number[];
+  signupPath?: string;
+  storage?: Record<string, unknown>;
+  storagePath?: string;
+  submitSelector?: string;
+}
+
+export interface UiConfig {
+  auth?: UiAuthConfig;
+}
+
 export interface DiscoveryConfig {
   roots?: string[];
   exclude?: string[];
@@ -379,6 +457,8 @@ export interface NodeAppOptions extends Omit<ServiceConfig, "local" | "runtime"
 }
 
 export interface NextAppOptions extends Omit<ServiceConfig, "local" | "runtime" | "env"> {
+  api?: string | { baseUrl: string };
+  auth?: "disabled-clerk" | { kind: "disabled-clerk" };
   baseUrl?: string;
   build?: BuildConfig | null;
   buildInputs?: string[];
@@ -396,6 +476,7 @@ export interface NextAppOptions extends Omit<ServiceConfig, "local" | "runtime"
 export interface TestkitConfig {
   discovery?: DiscoveryConfig;
   execution?: TestkitExecutionConfig;
+  lint?: TestkitLintConfig;
   profiles?: {
     http?: Record<string, HttpSuiteConfig<any>>;
   };
@@ -411,6 +492,15 @@ export interface TestkitConfig {
     timeoutMs?: number;
     tokenEnv?: string;
   };
+  ui?: UiConfig;
+}
+
+export interface NodeNextPresetOptions {
+  fileTimeoutSeconds?: number;
+  install?: "require-host" | "download";
+  node?: string;
+  npm?: string;
+  workers?: number;
 }
 
 export declare function defineConfig<T extends TestkitConfig>(config: T): T;
@@ -423,22 +513,55 @@ export declare const database: {
   schema: {
     fromEnv(envName: string, options?: DatabaseSourceSchemaOptions): DatabaseSourceSchemaConfig;
   };
+  steps: {
+    materializePostgresBinding(options?: unknown): TemplateModuleStepConfig;
+    runSql(options?: unknown): TemplateModuleStepConfig;
+    seedRows(options?: unknown): TemplateModuleStepConfig;
+    updateRows(options?: unknown): TemplateModuleStepConfig;
+    verifyRows(options?: unknown): TemplateModuleStepConfig;
+    verifySeed(options?: unknown): TemplateModuleStepConfig;
+  };
+  values: {
+    env(name: string): unknown;
+    json(value: unknown): unknown;
+    now(): unknown;
+    postgresConnectionFromEnv(prefix: string): unknown;
+  };
   postgres(
     options?: Omit<LocalDatabaseConfig, "provider" | "template"> & {
+      inputs?: string[];
+      migrate?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
+      seed?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
       template?: DatabaseTemplateOptions;
+      verify?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
     }
   ): LocalDatabaseConfig;
   fixture(
     options?: Omit<LocalDatabaseConfig, "provider" | "template"> & {
+      inputs?: string[];
+      migrate?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
+      seed?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
       template?: DatabaseTemplateOptions;
+      verify?: TemplateLifecycleStepConfig | TemplateLifecycleStepConfig[] | string | string[];
       discovery?: DiscoveryConfig;
       envFiles?: string[];
     }
   ): ServiceConfig;
 };
+export declare const step: {
+  command(run: string, options?: TemplateLifecycleStepOptions): TemplateCommandStepConfig;
+  module(target: string, options?: TemplateLifecycleStepOptions): TemplateModuleStepConfig;
+  sqlFile(path: string, options?: TemplateLifecycleStepOptions): TemplateSqlFileStepConfig;
+};
+export declare const presets: {
+  nodeNext(options?: NodeNextPresetOptions): Pick<TestkitConfig, "execution" | "toolchains">;
+};
 export declare const toolchain: {
   node(options?: NodeToolchainConfig): NodeToolchainConfig;
 };
+export declare const ui: {
+  auth(options?: UiAuthConfig): UiConfig;
+};
 export declare const auth: {
   fixture(options: { contract: JsonSessionContract; topology: AuthTopology }): AuthFixture;
   contracts: {

package/lib/config-api/index.mjs

@@ -53,6 +53,38 @@ function buildDatabaseTemplateConfig(options = {}) {
   };
 }
 
+function commandStep(run, options = {}) {
+  return {
+    kind: "command",
+    run,
+    ...copyStepOptions(options),
+  };
+}
+
+function sqlFileStep(filePath, options = {}) {
+  return {
+    kind: "sql-file",
+    path: filePath,
+    ...copyStepOptions(options),
+  };
+}
+
+function moduleStep(target, options = {}) {
+  return {
+    kind: "module",
+    target,
+    ...copyStepOptions(options),
+  };
+}
+
+function copyStepOptions(options = {}) {
+  return {
+    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+    ...(options.inputs !== undefined ? { inputs: [...options.inputs] } : {}),
+    ...(options.args !== undefined ? { args: options.args } : {}),
+  };
+}
+
 function sourceSchemaFromEnv(envName, options = {}) {
   if (typeof envName !== "string" || envName.trim().length === 0) {
     throw new Error("database.schema.fromEnv(...) requires a non-empty env var name");
@@ -69,15 +101,65 @@ function sourceSchemaFromEnv(envName, options = {}) {
   };
 }
 
+function databaseStepTarget(exportName) {
+  return `@elench/testkit/config/database-steps#${exportName}`;
+}
+
+function verifySeedStep(options = {}) {
+  return moduleStep(databaseStepTarget("verifySeed"), { args: options });
+}
+
+function verifyRowsStep(options = {}) {
+  return moduleStep(databaseStepTarget("verifyRows"), { args: options });
+}
+
+function runSqlStep(options = {}) {
+  return moduleStep(databaseStepTarget("runSql"), { args: options });
+}
+
+function seedRowsStep(options = {}) {
+  return moduleStep(databaseStepTarget("seedRows"), { args: options });
+}
+
+function materializePostgresBindingStep(options = {}) {
+  return moduleStep(databaseStepTarget("materializePostgresBinding"), { args: options });
+}
+
+function updateRowsStep(options = {}) {
+  return moduleStep(databaseStepTarget("updateRows"), { args: options });
+}
+
+function nowValue() {
+  return { kind: "now" };
+}
+
+function envValue(name) {
+  return { kind: "env", name: normalizeDatabaseEnvToken(name, "database.values.env(...) name", false) };
+}
+
+function jsonValue(value) {
+  return { kind: "json", value };
+}
+
+function postgresConnectionFromEnvValue(prefix) {
+  return {
+    kind: "postgres-connection-from-env",
+    prefix: normalizeDatabaseEnvToken(prefix, "database.values.postgresConnectionFromEnv(...) prefix", false),
+  };
+}
+
 function postgresFixture(options = {}) {
-  const { discovery, envFiles, template, ...databaseOptions } = options;
-  for (const legacyKey of ["inputs", "schema", "migrate", "seed", "verify"]) {
+  const { discovery, envFiles, template, inputs, migrate, seed, verify, ...databaseOptions } = options;
+  for (const legacyKey of ["schema"]) {
     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: { ... } }).`
+        `database.fixture(...) no longer accepts "${legacyKey}". Configure database.sourceSchema instead.`
       );
     }
   }
+  const resolvedTemplate = template || hasTemplateLifecycle(options)
+    ? buildDatabaseTemplateConfig({ inputs, migrate, seed, verify, ...(template || {}) })
+    : undefined;
   return {
     discovery: discovery || {
       roots: [".testkit-fixture"],
@@ -85,16 +167,22 @@ function postgresFixture(options = {}) {
     envFiles,
     local: false,
     database: postgresDatabase(
-      template
+      resolvedTemplate
         ? {
             ...databaseOptions,
-            template: buildDatabaseTemplateConfig(template),
+            template: resolvedTemplate,
           }
         : databaseOptions
     ),
   };
 }
 
+function hasTemplateLifecycle(options = {}) {
+  return ["inputs", "migrate", "seed", "verify"].some((key) =>
+    Object.prototype.hasOwnProperty.call(options, key)
+  );
+}
+
 function nodeToolchain(options = {}) {
   return {
     kind: "node",
@@ -102,6 +190,15 @@ function nodeToolchain(options = {}) {
   };
 }
 
+function uiAuth(options = {}) {
+  return {
+    auth: {
+      ...options,
+      ...(options.profiles ? { profiles: { ...options.profiles } } : {}),
+    },
+  };
+}
+
 function tscBuild(options = {}) {
   return {
     kind: "tsc",
@@ -195,6 +292,8 @@ function nodeApp(options = {}) {
 
 function nextApp(options = {}) {
   const {
+    api,
+    auth: authMode,
     baseUrl: explicitBaseUrl,
     browser,
     build: explicitBuild,
@@ -214,7 +313,10 @@ function nextApp(options = {}) {
   } = options;
 
   const normalizedPort = requiredNumber(port, "app.next port");
-  const normalizedEnv = normalizePresetEnv(env);
+  const normalizedEnv = {
+    ...normalizeNextPresetEnv({ api, authMode }),
+    ...normalizePresetEnv(env),
+  };
   const baseUrl = explicitBaseUrl || "http://127.0.0.1:{port}";
   const build =
     explicitBuild === undefined
@@ -266,12 +368,26 @@ export const database = {
   schema: {
     fromEnv: sourceSchemaFromEnv,
   },
+  steps: {
+    materializePostgresBinding: materializePostgresBindingStep,
+    runSql: runSqlStep,
+    seedRows: seedRowsStep,
+    updateRows: updateRowsStep,
+    verifyRows: verifyRowsStep,
+    verifySeed: verifySeedStep,
+  },
+  values: {
+    env: envValue,
+    json: jsonValue,
+    now: nowValue,
+    postgresConnectionFromEnv: postgresConnectionFromEnvValue,
+  },
   postgres(options = {}) {
-    const { template, sourceSchema, ...databaseOptions } = options;
-    for (const legacyKey of ["inputs", "schema", "migrate", "seed", "verify"]) {
+    const { template, sourceSchema, inputs, migrate, seed, verify, ...databaseOptions } = options;
+    for (const legacyKey of ["schema"]) {
       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: { ... } }).`
+          `database.postgres(...) no longer accepts "${legacyKey}". Use database.postgres({ sourceSchema: database.schema.fromEnv(...) }) instead.`
         );
       }
     }
@@ -281,11 +397,14 @@ export const database = {
           ...databaseOptions,
           sourceSchema,
         };
+    const resolvedTemplate = template || hasTemplateLifecycle(options)
+      ? buildDatabaseTemplateConfig({ inputs, migrate, seed, verify, ...(template || {}) })
+      : undefined;
     return postgresDatabase(
-      template
+      resolvedTemplate
         ? {
             ...normalizedDatabaseOptions,
-            template: buildDatabaseTemplateConfig(template),
+            template: resolvedTemplate,
           }
         : normalizedDatabaseOptions
     );
@@ -293,10 +412,38 @@ export const database = {
   fixture: postgresFixture,
 };
 
+export const step = {
+  command: commandStep,
+  module: moduleStep,
+  sqlFile: sqlFileStep,
+};
+
+export const presets = {
+  nodeNext(options = {}) {
+    return {
+      execution: {
+        workers: options.workers ?? 1,
+        fileTimeoutSeconds: options.fileTimeoutSeconds ?? 120,
+      },
+      toolchains: {
+        node: nodeToolchain({
+          install: options.install ?? "download",
+          ...(options.node ? { node: options.node } : {}),
+          ...(options.npm ? { npm: options.npm } : {}),
+        }),
+      },
+    };
+  },
+};
+
 export const toolchain = {
   node: nodeToolchain,
 };
 
+export const ui = {
+  auth: uiAuth,
+};
+
 export const auth = {
   fixture: createAuthFixture,
   contracts: {
@@ -383,6 +530,22 @@ function normalizeDatabaseEnvToken(value, label, sanitize = true) {
   return normalized;
 }
 
+function normalizeNextPresetEnv({ api, authMode } = {}) {
+  const env = {};
+  if (api) {
+    const baseUrlToken = typeof api === "string" ? api : api.baseUrl;
+    if (baseUrlToken) {
+      env.NEXT_PUBLIC_API_URL = baseUrlToken;
+    }
+  }
+  if (authMode === "disabled-clerk" || authMode?.kind === "disabled-clerk") {
+    env.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY = "testkit_disabled";
+    env.CLERK_SECRET_KEY = "testkit_disabled";
+    env.CLERK_WEBHOOK_SECRET = "testkit_disabled";
+  }
+  return env;
+}
+
 function resolveNodeAppStart(build, entry) {
   if (build?.kind === "tsc") {
     const compiled = compiledEntryFromSource(entry || build.entry || "src/index.ts", build.outDir || "dist");
@@ -393,7 +556,8 @@ function resolveNodeAppStart(build, entry) {
 
 function normalizeTemplateStepList(value) {
   if (value == null) return [];
-  return Array.isArray(value) ? [...value] : [value];
+  const values = Array.isArray(value) ? value : [value];
+  return values.map((entry) => typeof entry === "string" ? commandStep(entry) : entry);
 }
 
 function compiledEntryFromSource(entry, outDir) {