@elench/testkit 0.1.115 → 0.1.116

package/lib/database/template-steps.mjs

@@ -1,4 +1,5 @@
 import fs from "fs";
+import os from "os";
 import path from "path";
 import { execa } from "execa";
 import { buildTemplateExecutionEnv } from "../runner/template.mjs";
@@ -25,6 +26,25 @@ export async function runTemplateStage(config, stageName, databaseUrl, options =
     reporter: options.reporter || null,
     setupRegistry: options.setupRegistry || null,
     parentOperation: options.parentOperation || null,
+    afterStep: options.afterStep || null,
+  });
+}
+
+export async function runTemplateStep(config, stageName, step, stepIndex, databaseUrl, options = {}) {
+  const env = {
+    ...buildTemplateExecutionEnv(config, {}, process.env),
+    DATABASE_URL: databaseUrl,
+  };
+
+  await runConfiguredSteps({
+    config,
+    steps: [step],
+    env,
+    labelPrefix: `template:${stageName}`,
+    reporter: options.reporter || null,
+    setupRegistry: options.setupRegistry || null,
+    parentOperation: options.parentOperation || null,
+    startIndex: stepIndex,
   });
 }
 
@@ -36,45 +56,95 @@ export function collectTemplateInputs(productDir, template = {}) {
   });
 }
 
-export async function captureTemplateSnapshot(config, outputPath, databaseUrl, options = {}) {
-  const templateDbUrl = databaseUrl;
-  const absoluteOutputPath = path.resolve(config.productDir, outputPath);
-  fs.mkdirSync(path.dirname(absoluteOutputPath), { recursive: true });
+export async function captureTemplateSnapshotText(config, databaseUrl, options = {}) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-schema-snapshot-"));
+  const tempPath = path.join(tempDir, "schema.sql");
+  try {
+    await dumpPostgresSchemaToFile(config, tempPath, databaseUrl, options);
+    return fs.readFileSync(tempPath, "utf8");
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
 
-  const child = execa(
-    "pg_dump",
+export async function dumpPostgresSchemaToFile(config, outputPath, databaseUrl, options = {}) {
+  const env = {
+    ...buildTemplateExecutionEnv(config, {}, process.env),
+    ...buildPostgresConnectionEnv(databaseUrl),
+  };
+  const result = await runPgDumpCommand(config, "pg_dump", pgDumpArgs(), env, options);
+  if (result.exitCode !== 0 && isPgDumpServerVersionMismatch(result)) {
+    const serverMajor = parsePgDumpServerMajor(result);
+    if (serverMajor) {
+      const fallback = await runDockerizedPgDump(config, serverMajor, env, options);
+      if (fallback.exitCode === 0) {
+        fs.writeFileSync(outputPath, fallback.stdout);
+        sanitizeSnapshotFile(outputPath);
+        return;
+      }
+      throw new Error(fallback.shortMessage || fallback.stderr || fallback.stdout || "dockerized pg_dump failed");
+    }
+  }
+  if (result.exitCode !== 0) {
+    throw new Error(result.shortMessage || result.stderr || result.stdout || "pg_dump failed");
+  }
+  fs.writeFileSync(outputPath, result.stdout);
+  sanitizeSnapshotFile(outputPath);
+}
+
+function pgDumpArgs() {
+  return [
+    "--schema-only",
+    "--no-owner",
+    "--no-privileges",
+  ];
+}
+
+async function runDockerizedPgDump(config, serverMajor, env, options) {
+  const image = `${process.env.TESTKIT_PG_DUMP_IMAGE_PREFIX || "postgres"}:${serverMajor}`;
+  return runPgDumpCommand(
+    config,
+    "docker",
     [
-      "--schema-only",
-      "--no-owner",
-      "--no-privileges",
-      "--file",
-      absoluteOutputPath,
-      templateDbUrl,
+      "run",
+      "--rm",
+      "--network",
+      "host",
+      "-e",
+      "PGHOST",
+      "-e",
+      "PGPORT",
+      "-e",
+      "PGDATABASE",
+      "-e",
+      "PGUSER",
+      "-e",
+      "PGPASSWORD",
+      "-e",
+      "PGSSLMODE",
+      image,
+      "pg_dump",
+      ...pgDumpArgs(),
     ],
-    {
-      cwd: config.productDir,
-      env: {
-        ...buildTemplateExecutionEnv(config, {}, process.env),
-        DATABASE_URL: templateDbUrl,
-      },
-      stdout: "pipe",
-      stderr: "pipe",
-      reject: false,
-    }
+    env,
+    options
   );
+}
+
+async function runPgDumpCommand(config, command, args, env, options = {}) {
+  const child = execa(command, args, {
+    cwd: config.productDir,
+    env,
+    stdout: "pipe",
+    stderr: "pipe",
+    reject: false,
+  });
   const liveWriter =
     options.reporter?.outputMode === "debug"
       ? (line) => options.reporter.writeDebugLine?.(line)
       : null;
   const logRecord = options.logRecord || null;
   const drains = [
-    captureOutput(child.stdout, {
-      livePrefix: `[${config.runtimeLabel || config.name}:${config.name}]`,
-      liveWriter,
-      onLine(line) {
-        if (logRecord) logRecord.stream.write(`${new Date().toISOString()} [stdout] ${line}\n`);
-      },
-    }),
     captureOutput(child.stderr, {
       livePrefix: `[${config.runtimeLabel || config.name}:${config.name}]`,
       liveWriter,
@@ -85,29 +155,79 @@ export async function captureTemplateSnapshot(config, outputPath, databaseUrl, o
   ];
   const result = await child;
   await Promise.all(drains);
-  if (result.exitCode !== 0) {
-    throw new Error(result.shortMessage || result.stderr || result.stdout || "pg_dump failed");
-  }
+  return result;
+}
+
+function isPgDumpServerVersionMismatch(result) {
+  const text = `${result.stderr || ""}\n${result.stdout || ""}`;
+  return text.includes("server version mismatch");
+}
 
-  sanitizeSnapshotFile(absoluteOutputPath);
-  return absoluteOutputPath;
+function parsePgDumpServerMajor(result) {
+  const text = `${result.stderr || ""}\n${result.stdout || ""}`;
+  const match = text.match(/server version:\s*([0-9]+)/i);
+  return match ? Number(match[1]) : null;
+}
+
+function buildPostgresConnectionEnv(databaseUrl) {
+  const parsed = new URL(databaseUrl);
+  return compactObject({
+    PGHOST: parsed.hostname,
+    PGPORT: parsed.port || "5432",
+    PGDATABASE: decodeURIComponent(parsed.pathname.replace(/^\//, "")),
+    PGUSER: decodeURIComponent(parsed.username || ""),
+    PGPASSWORD: decodeURIComponent(parsed.password || ""),
+    PGSSLMODE: parsed.searchParams.get("sslmode") || undefined,
+  });
+}
+
+function compactObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([_key, entry]) => entry !== undefined && entry !== null && entry !== "")
+  );
 }
 
 export function sanitizeSnapshotFile(filePath) {
   const dump = fs.readFileSync(filePath, "utf8");
-  const sanitized = dump
-    .split("\n")
+  const sanitized = sanitizeSnapshotText(dump);
+
+  if (sanitized !== dump) {
+    fs.writeFileSync(filePath, sanitized);
+  }
+}
+
+export function sanitizeSnapshotText(dump) {
+  return removePublicSchemaInitdbBlock(String(dump).split("\n"))
     .filter((line) => {
       const trimmed = line.trim();
       return (
+        !trimmed.startsWith("-- Dumped from database version ") &&
+        !trimmed.startsWith("-- Dumped by pg_dump version ") &&
         trimmed !== "SET transaction_timeout = 0;" &&
         !trimmed.startsWith("\\restrict ") &&
         !trimmed.startsWith("\\unrestrict ")
       );
     })
     .join("\n");
+}
 
-  if (sanitized !== dump) {
-    fs.writeFileSync(filePath, sanitized);
+function removePublicSchemaInitdbBlock(lines) {
+  const normalized = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.trim() === "--" && lines[index + 1]?.startsWith("-- Name: public; Type: SCHEMA;")) {
+      let cursor = index + 1;
+      while (cursor < lines.length && !lines[cursor]?.includes("*not* creating schema")) {
+        cursor += 1;
+      }
+      if (cursor < lines.length) {
+        while (cursor + 1 < lines.length && lines[cursor + 1]?.trim() === "") {
+          cursor += 1;
+        }
+        index = cursor;
+        continue;
+      }
+    }
+    normalized.push(lines[index]);
   }
+  return normalized;
 }

package/lib/runner/orchestrator.mjs

@@ -146,9 +146,10 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
         runtimeOptions: {
           reporter,
           logRegistry,
-          setupRegistry,
-        },
-      });
+        setupRegistry,
+        skipSchemaSourceVerify: opts.skipSchemaSourceVerify,
+      },
+    });
       const timingUpdates = [];
 
       try {

package/lib/runner/template-steps.mjs

@@ -51,13 +51,16 @@ export async function runConfiguredSteps({
   reporter = null,
   setupRegistry = null,
   parentOperation = null,
+  startIndex = 0,
+  afterStep = null,
 }) {
   if (steps.length === 0) return;
   const resolvedToolchain = await resolveConfiguredToolchain(config);
   await announceResolvedToolchain(config, resolvedToolchain, reporter);
 
   for (const [index, step] of steps.entries()) {
-    const label = `${labelPrefix}:${config.name}:${index + 1}`;
+    const stepNumber = startIndex + index + 1;
+    const label = `${labelPrefix}:${config.name}:${stepNumber}`;
     const stepOperation = setupRegistry?.start({
       config,
       stage: label,
@@ -89,6 +92,14 @@ export async function runConfiguredSteps({
       if (finished) reporter?.setupOperationFinished?.(finished);
       throw error;
     }
+    if (afterStep) {
+      await afterStep({
+        step,
+        index: startIndex + index,
+        stepNumber,
+        label,
+      });
+    }
   }
 }
 

package/lib/runner/template.mjs

@@ -1,5 +1,8 @@
 import path from "path";
-import { finalizeConfiguredInputs, finalizeConfiguredSteps } from "../shared/configured-steps.mjs";
+import {
+  finalizeConfiguredInputs,
+  finalizeConfiguredSteps,
+} from "../shared/configured-steps.mjs";
 import { readDatabaseInfo } from "./state-io.mjs";
 
 const PORT_STRIDE = 100;
@@ -135,6 +138,7 @@ export function resolveRuntimeConfig(
   const database = config.testkit.database
     ? {
         ...config.testkit.database,
+        sourceSchema: finalizeSourceSchema(config.testkit.database.sourceSchema, context),
         template: finalizeDatabaseTemplate(config.testkit.database.template, context),
       }
     : undefined;
@@ -193,6 +197,17 @@ function finalizeDatabaseTemplate(template, context) {
   };
 }
 
+function finalizeSourceSchema(sourceSchema, context) {
+  if (!sourceSchema) return null;
+  return {
+    ...sourceSchema,
+    ...(typeof sourceSchema.env === "string" ? { env: finalizeString(sourceSchema.env, context) } : {}),
+    ...(typeof sourceSchema.cachePath === "string"
+      ? { cachePath: finalizeString(sourceSchema.cachePath, context) }
+      : {}),
+  };
+}
+
 export function resolveServiceStateDir(runtimeDir, config) {
   return path.join(runtimeDir, "services", config.name);
 }

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.115",
+  "version": "0.1.116",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.115",
+  "version": "0.1.116",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.115"
+    "@elench/testkit-protocol": "0.1.116"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.115",
+  "version": "0.1.116",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.115",
+  "version": "0.1.116",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {