@riebeckite/test 0.0.6

package/dist/e2e/index.js

@@ -0,0 +1,573 @@
+// e2e/assertions.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// e2e/files.ts
+import fs from "node:fs";
+import path from "node:path";
+function walkFiles(root, predicate = () => true) {
+  const found = [];
+  if (!fs.existsSync(root)) return found;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) break;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (predicate(full)) {
+        found.push(full);
+      }
+    }
+  }
+  return found;
+}
+
+// e2e/process.ts
+import { spawn, spawnSync } from "node:child_process";
+var MAX_BUFFER = 128 * 1024 * 1024;
+function quote(value) {
+  const text = String(value);
+  return /[\s"]/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
+}
+function failureDetail(stdout, stderr) {
+  return `--- stdout ---
+${stdout}
+--- stderr ---
+${stderr}`;
+}
+function run(command, args, options = {}) {
+  const line = [command, ...args].map(quote).join(" ");
+  const result = spawnSync(line, {
+    shell: true,
+    cwd: options.cwd ?? process.cwd(),
+    env: { ...process.env, ...options.env },
+    encoding: "utf8",
+    maxBuffer: MAX_BUFFER
+  });
+  if (result.error) {
+    throw new Error(`Failed to run: ${line}
+${result.error.message}`);
+  }
+  const stdout = result.stdout ?? "";
+  const stderr = result.stderr ?? "";
+  if (result.status !== 0 && !options.allowFailure) {
+    throw new Error(
+      `Command failed (exit ${result.status}): ${line}
+` + failureDetail(stdout, stderr)
+    );
+  }
+  return { status: result.status, stdout, stderr };
+}
+function runAsync(command, args, options = {}) {
+  const line = [command, ...args].map(quote).join(" ");
+  return new Promise((resolve, reject) => {
+    const child = spawn(line, {
+      shell: true,
+      cwd: options.cwd ?? process.cwd(),
+      env: { ...process.env, ...options.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let settled = false;
+    let exceeded = false;
+    let stdout = "";
+    let stderr = "";
+    const stdoutStream = child.stdout;
+    const stderrStream = child.stderr;
+    if (!stdoutStream || !stderrStream) {
+      child.kill("SIGKILL");
+      reject(new Error(`Failed to run: ${line}
+no stdio streams available`));
+      return;
+    }
+    const onData = (kind, chunk) => {
+      const length = kind === "stdout" ? stdout.length : stderr.length;
+      if (length + chunk.length > MAX_BUFFER) {
+        exceeded = true;
+        child.kill("SIGKILL");
+        return;
+      }
+      if (kind === "stdout") stdout += chunk;
+      else stderr += chunk;
+    };
+    stdoutStream.setEncoding("utf8");
+    stderrStream.setEncoding("utf8");
+    stdoutStream.on("data", (chunk) => onData("stdout", chunk));
+    stderrStream.on("data", (chunk) => onData("stderr", chunk));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      reject(new Error(`Failed to run: ${line}
+${error.message}`));
+    });
+    child.on("close", (status) => {
+      if (settled) return;
+      settled = true;
+      if (exceeded) {
+        reject(
+          new Error(`Command output exceeded ${MAX_BUFFER} bytes: ${line}`)
+        );
+        return;
+      }
+      if (status !== 0 && !options.allowFailure) {
+        reject(
+          new Error(
+            `Command failed (exit ${status}): ${line}
+` + failureDetail(stdout, stderr)
+          )
+        );
+        return;
+      }
+      resolve({ status, stdout, stderr });
+    });
+  });
+}
+
+// e2e/assertions.ts
+function isInside(parent, child) {
+  const relative = path2.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function assertIsolatedInstall(siteDir, tempRoot, options) {
+  const { repoRoot, requiredPaths = [], logger } = options;
+  logger.step("verifying standalone install (no pnpm/monorepo inheritance)");
+  if (isInside(repoRoot, tempRoot)) {
+    logger.fail("the external workspace must live outside the repository");
+  }
+  const forbiddenState = [
+    path2.join(tempRoot, "pnpm-workspace.yaml"),
+    path2.join(tempRoot, "pnpm-lock.yaml"),
+    path2.join(siteDir, "pnpm-workspace.yaml"),
+    path2.join(siteDir, "pnpm-lock.yaml"),
+    path2.join(siteDir, "node_modules", ".pnpm")
+  ];
+  for (const file of forbiddenState) {
+    if (fs2.existsSync(file)) {
+      logger.fail(
+        `external site must not inherit pnpm workspace state: ${path2.relative(
+          tempRoot,
+          file
+        )}`
+      );
+    }
+  }
+  const nodeModules = path2.join(siteDir, "node_modules");
+  if (!fs2.existsSync(nodeModules)) {
+    logger.fail("the isolated install did not create site/node_modules");
+  }
+  const probes = [];
+  for (const required of requiredPaths) {
+    const absolute = path2.join(siteDir, required.relativePath);
+    if (!fs2.existsSync(absolute)) {
+      logger.fail(required.missingMessage);
+    }
+    if (required.report ?? true) {
+      probes.push(`${required.label} -> ${path2.relative(siteDir, absolute)}`);
+    }
+  }
+  const nodeModulesLabel = path2.relative(path2.dirname(siteDir), nodeModules).split(path2.sep).join("/");
+  const suffix = probes.length > 0 ? `; ${probes.join("; ")}` : "";
+  console.log(`  ${nodeModulesLabel} is local${suffix}`);
+}
+function reachesDirectory(contents, directory, minimumTraversals) {
+  const needle = `${directory}/`;
+  const parent = `${"."}${"."}/`;
+  let index = contents.indexOf(needle);
+  while (index !== -1) {
+    let cursor = index;
+    let traversals = 0;
+    while (cursor - parent.length >= 0 && contents.slice(cursor - parent.length, cursor) === parent) {
+      traversals += 1;
+      cursor -= parent.length;
+    }
+    if (traversals >= minimumTraversals) return true;
+    index = contents.indexOf(needle, index + needle.length);
+  }
+  return false;
+}
+function assertNoMonorepoEscapeHatches(siteDir, options) {
+  const { monorepoPackagesDirectory = "packages", logger } = options;
+  logger.step("checking the site for monorepo escape hatches");
+  const manifest = JSON.parse(
+    fs2.readFileSync(path2.join(siteDir, "package.json"), "utf8")
+  );
+  if (JSON.stringify(manifest).includes("workspace:")) {
+    logger.fail(
+      "site/package.json must not contain `workspace:` protocol references"
+    );
+  }
+  const sourceFiles = walkFiles(siteDir, (full) => {
+    const relative = path2.relative(siteDir, full);
+    if (relative.startsWith(`node_modules${path2.sep}`)) return false;
+    if (relative.startsWith(`dist${path2.sep}`)) return false;
+    return /\.(ts|tsx|mts|cts|js|mjs|json)$/.test(full);
+  });
+  for (const file of sourceFiles) {
+    const contents = fs2.readFileSync(file, "utf8");
+    if (contents.includes("workspace:")) {
+      logger.fail(`${path2.relative(siteDir, file)} contains \`workspace:\``);
+    }
+    if (reachesDirectory(contents, monorepoPackagesDirectory, 2)) {
+      logger.fail(
+        `${path2.relative(
+          siteDir,
+          file
+        )} reaches into the monorepo \`${monorepoPackagesDirectory}/\``
+      );
+    }
+  }
+  if (fs2.existsSync(path2.join(siteDir, monorepoPackagesDirectory))) {
+    logger.fail(
+      `site must not contain a \`${monorepoPackagesDirectory}/\` directory`
+    );
+  }
+}
+function assertPublishedArtifacts(siteDir, options) {
+  const { repoRoot, scope, logger } = options;
+  logger.step(`verifying ${scope}/* resolves to installed tarballs only`);
+  const scopeDir = path2.join(siteDir, "node_modules", ...scope.split("/"));
+  if (!fs2.existsSync(scopeDir)) {
+    logger.fail(`no ${scope}/* packages were installed`);
+  }
+  for (const entry of fs2.readdirSync(scopeDir)) {
+    const full = path2.join(scopeDir, entry);
+    const real = fs2.realpathSync(full);
+    if (isInside(repoRoot, real)) {
+      logger.fail(
+        `${scope}/${entry} resolves into the repository (${real}); the fixture must use installed tarballs only`
+      );
+    }
+    if (fs2.lstatSync(full).isSymbolicLink()) {
+      logger.fail(
+        `${scope}/${entry} is a symlink; expected a real installed directory`
+      );
+    }
+    console.log(`  ${scope}/${entry} -> ${real}`);
+  }
+}
+function assertDeclaredDependencies(siteDir, options) {
+  const { dependencyCheckScript, cwd, logger } = options;
+  logger.step("checking the site for undeclared (hoisted) dependencies");
+  run(process.execPath, [dependencyCheckScript, siteDir], { cwd });
+}
+
+// e2e/cli.ts
+import path3 from "node:path";
+function runCli(args, options) {
+  const { cliEntry, cwd, cliName, logger } = options;
+  logger.step(`${cliName} ${args.join(" ")}`);
+  const result = run(process.execPath, [cliEntry, ...args], { cwd });
+  const output = cliText(result).trim();
+  if (output) console.log(output);
+  return result;
+}
+function cliText(result) {
+  return `${result.stdout}${result.stderr}`;
+}
+function runTypecheck(siteDir, project, logger) {
+  logger.step(`tsc --noEmit -p ${project}`);
+  const tsc = path3.join(siteDir, "node_modules", "typescript", "bin", "tsc");
+  const result = run(process.execPath, [tsc, "--noEmit", "-p", project], {
+    cwd: siteDir
+  });
+  const output = cliText(result).trim();
+  if (output) console.log(output);
+  return result;
+}
+
+// e2e/format.ts
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  const digits = value >= 10 || unitIndex === 0 ? 0 : 1;
+  return `${value.toFixed(digits)} ${units[unitIndex]}`;
+}
+
+// e2e/html.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractScriptPayloads(html, attribute) {
+  const pattern = new RegExp(
+    `<script[^>]*${escapeRegExp(attribute)}[^>]*>([\\s\\S]*?)</script>`,
+    "g"
+  );
+  return [...html.matchAll(pattern)].map((match) => match[1] ?? "").join("\n");
+}
+
+// e2e/logger.ts
+function createLogger(label = "e2e") {
+  return {
+    step(message) {
+      console.log(`
+[${label}] ${message}`);
+    },
+    fail(message) {
+      throw new Error(message);
+    }
+  };
+}
+
+// e2e/pack.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+async function packPackages(tarballDir, options) {
+  const { repoRoot, packages, logger, concurrency = 4 } = options;
+  logger.step(
+    `packing ${packages.length} packages with pnpm pack (concurrency ${concurrency})`
+  );
+  const packOne = async (pkg) => {
+    const packageDir = path4.join(repoRoot, pkg.directory);
+    if (!fs3.existsSync(packageDir)) {
+      logger.fail(`Package directory is missing: ${pkg.directory}`);
+    }
+    const manifest = JSON.parse(
+      fs3.readFileSync(path4.join(packageDir, "package.json"), "utf8")
+    );
+    await runAsync("pnpm", ["pack", "--pack-destination", tarballDir], {
+      cwd: packageDir
+    });
+    const sanitized = pkg.name.replace(/^@/, "").replace(/\//g, "-");
+    const tarball = path4.join(
+      tarballDir,
+      `${sanitized}-${manifest.version}.tgz`
+    );
+    if (!fs3.existsSync(tarball)) {
+      logger.fail(`pnpm pack did not produce the expected tarball: ${tarball}`);
+    }
+    console.log(`  packed ${pkg.name} -> ${path4.basename(tarball)}`);
+    return { pkg, version: manifest.version, tarball };
+  };
+  const results = new Array(packages.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < packages.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const pkg = packages[index];
+      if (pkg === void 0) continue;
+      results[index] = await packOne(pkg);
+    }
+  };
+  const batch = await Promise.allSettled(
+    Array.from(
+      { length: Math.min(concurrency, packages.length) },
+      () => worker()
+    )
+  );
+  const failure = batch.find(
+    (result) => result.status === "rejected"
+  );
+  if (failure) {
+    throw failure.reason;
+  }
+  const packed = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    packed.set(result.pkg.name, {
+      tarball: result.tarball,
+      version: result.version
+    });
+  }
+  return packed;
+}
+
+// e2e/run.ts
+import fs5 from "node:fs";
+import os from "node:os";
+import path6 from "node:path";
+
+// e2e/stage.ts
+import fs4 from "node:fs";
+import path5 from "node:path";
+function stageIsolatedSite(options) {
+  fs4.cpSync(options.fixtureSite, options.siteDir, { recursive: true });
+  fs4.cpSync(options.fixtureVault, options.vaultDir, { recursive: true });
+}
+function writeFileDependencies(siteDir, packed) {
+  const manifestPath = path5.join(siteDir, "package.json");
+  const manifest = JSON.parse(
+    fs4.readFileSync(manifestPath, "utf8")
+  );
+  const dependencies = { ...manifest.dependencies };
+  const devDependencies = { ...manifest.devDependencies };
+  const overrides = { ...manifest.overrides };
+  for (const [name, info] of packed) {
+    const fileSpec = `file:${path5.relative(siteDir, info.tarball).split(path5.sep).join("/")}`;
+    if (name in devDependencies) {
+      devDependencies[name] = fileSpec;
+    } else {
+      dependencies[name] = fileSpec;
+    }
+    overrides[name] = fileSpec;
+  }
+  manifest.dependencies = dependencies;
+  manifest.devDependencies = devDependencies;
+  manifest.overrides = overrides;
+  fs4.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function layerExternalConsumerTypes(siteDir, options) {
+  const { additionalTypeLibraries, exclude, nodeNext, logger } = options;
+  logger.step(
+    `layering the external-consumer type libraries (${additionalTypeLibraries.join(", ")})`
+  );
+  const configPath = path5.join(siteDir, "tsconfig.json");
+  const config = JSON.parse(
+    fs4.readFileSync(configPath, "utf8")
+  );
+  const types = new Set(config.compilerOptions?.types ?? []);
+  types.add("node");
+  for (const library of additionalTypeLibraries) types.add(library);
+  config.compilerOptions = { ...config.compilerOptions, types: [...types] };
+  if (exclude !== void 0) config.exclude = [...exclude];
+  fs4.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  if (nodeNext) {
+    const nodeNextConfigPath = path5.join(siteDir, nodeNext.config);
+    const nodeNextConfig = JSON.parse(
+      fs4.readFileSync(nodeNextConfigPath, "utf8")
+    );
+    nodeNextConfig.include = [...nodeNext.include];
+    fs4.writeFileSync(
+      nodeNextConfigPath,
+      `${JSON.stringify(nodeNextConfig, null, 2)}
+`
+    );
+  }
+  const written = JSON.parse(
+    fs4.readFileSync(configPath, "utf8")
+  );
+  const effective = new Set(written.compilerOptions?.types ?? []);
+  for (const library of additionalTypeLibraries) {
+    if (!effective.has(library)) {
+      logger.fail(
+        `external-consumer tsconfig is missing the ${library} type library`
+      );
+    }
+  }
+  const label = path5.relative(path5.dirname(siteDir), configPath).split(path5.sep).join("/");
+  console.log(`  ${label} types: ${[...effective].join(", ")}`);
+}
+
+// e2e/run.ts
+async function runExternalSiteE2E(config) {
+  const logger = config.logger ?? createLogger(config.stepLabel ?? "e2e");
+  const tempRoot = fs5.mkdtempSync(
+    path6.join(os.tmpdir(), config.tempPrefix ?? "riebeckite-e2e-")
+  );
+  const siteDir = path6.join(tempRoot, "site");
+  const vaultDir = path6.join(tempRoot, "vault");
+  const tarballDir = path6.join(tempRoot, "tarballs");
+  fs5.mkdirSync(tarballDir, { recursive: true });
+  logger.step(`temporary workspace: ${tempRoot}`);
+  try {
+    const packed = await packPackages(tarballDir, {
+      repoRoot: config.repoRoot,
+      packages: config.packages,
+      concurrency: config.concurrency,
+      logger
+    });
+    logger.step(
+      "copying fixture site and vault (content stays outside the site root)"
+    );
+    stageIsolatedSite({
+      fixtureSite: config.fixture.site,
+      fixtureVault: config.fixture.vault,
+      siteDir,
+      vaultDir
+    });
+    layerExternalConsumerTypes(siteDir, {
+      additionalTypeLibraries: config.additionalTypeLibraries ?? [],
+      exclude: config.bundlerTypeExclude,
+      nodeNext: config.nodeNextProject,
+      logger
+    });
+    writeFileDependencies(siteDir, packed);
+    logger.step("npm install (tarballs + normal registry dependencies)");
+    run("npm", ["install", "--no-audit", "--no-fund", "--loglevel=error"], {
+      cwd: siteDir
+    });
+    assertIsolatedInstall(siteDir, tempRoot, {
+      repoRoot: config.repoRoot,
+      requiredPaths: config.requiredInstallPaths,
+      logger
+    });
+    assertNoMonorepoEscapeHatches(siteDir, {
+      monorepoPackagesDirectory: config.monorepoPackagesDirectory,
+      logger
+    });
+    assertDeclaredDependencies(siteDir, {
+      dependencyCheckScript: config.dependencyCheckScript,
+      cwd: config.repoRoot,
+      logger
+    });
+    assertPublishedArtifacts(siteDir, {
+      repoRoot: config.repoRoot,
+      scope: config.scope,
+      logger
+    });
+    const workspace = {
+      repoRoot: config.repoRoot,
+      tempRoot,
+      siteDir,
+      vaultDir,
+      tarballDir,
+      packed
+    };
+    for (const check of config.siteChecks ?? []) check(workspace, logger);
+    const cliCwd = config.cliWorkingDirectory ? path6.join(siteDir, config.cliWorkingDirectory) : siteDir;
+    const cliEntry = config.resolveCliEntry(siteDir);
+    for (const command of config.cliCommands) {
+      const result = runCli(command.args, {
+        cliEntry,
+        cwd: cliCwd,
+        cliName: config.cliName,
+        logger
+      });
+      command.assertOutput?.(cliText(result));
+    }
+    config.assertions.buildOutput(siteDir, vaultDir);
+    for (const project of config.typecheckProjects ?? []) {
+      runTypecheck(siteDir, project, logger);
+    }
+    await config.afterSiteChecks?.(workspace);
+    logger.step(
+      `PASS: ${config.passMessage ?? "external site built from published artifacts"}`
+    );
+  } finally {
+    if (process.env[config.keepEnv]) {
+      logger.step(`kept workspace: ${tempRoot}`);
+    } else {
+      fs5.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  }
+}
+export {
+  MAX_BUFFER,
+  assertDeclaredDependencies,
+  assertIsolatedInstall,
+  assertNoMonorepoEscapeHatches,
+  assertPublishedArtifacts,
+  cliText,
+  createLogger,
+  escapeRegExp,
+  extractScriptPayloads,
+  formatBytes,
+  layerExternalConsumerTypes,
+  packPackages,
+  quote,
+  run,
+  runAsync,
+  runCli,
+  runExternalSiteE2E,
+  runTypecheck,
+  stageIsolatedSite,
+  walkFiles,
+  writeFileDependencies
+};

package/dist/e2e/logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Minimal console logger shared by the external-site engine.
+ *
+ * The engine is published as the shared test package's e2e entry point and
+ * must not assume any repository layout, so every phase receives a logger
+ * instead of reading a module-level one. `createLogger` reproduces the `\n[label] message` format
+ * the repo-local driver has always printed.
+ */
+export interface Logger {
+    /** Print a phase heading. */
+    step(message: string): void;
+    /** Abort the run with `message`. */
+    fail(message: string): never;
+}
+/**
+ * Create a logger whose `step` lines are prefixed with `\n[label] `.
+ */
+export declare function createLogger(label?: string): Logger;

package/dist/e2e/pack.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from "./logger.js";
+/** A package that should be packed and injected into the consumer project. */
+export interface PackageSpec {
+    /** Package directory, relative to the repository root. */
+    directory: string;
+    /** Published package name, e.g. `@scope/name` or `create-thing`. */
+    name: string;
+}
+/** A tarball produced for one package. */
+export interface PackedPackage {
+    tarball: string;
+    version: string;
+}
+/** Packed packages keyed by package name. */
+export type PackedPackages = Map<string, PackedPackage>;
+export interface PackPackagesOptions {
+    /** Absolute repository root the package directories are resolved against. */
+    repoRoot: string;
+    /** Packages to pack. */
+    packages: readonly PackageSpec[];
+    /** Maximum number of `pnpm pack` processes in flight. Defaults to 4. */
+    concurrency?: number;
+    logger: Logger;
+}
+/**
+ * Pack every package with `pnpm pack` into `tarballDir`, using a
+ * limited-concurrency pool. Returns a map from package name to its tarball and
+ * version. The first failure rejects the returned promise.
+ */
+export declare function packPackages(tarballDir: string, options: PackPackagesOptions): Promise<PackedPackages>;

package/dist/e2e/process.d.ts

@@ -0,0 +1,34 @@
+/** Upper bound on captured stdout/stderr per command. */
+export declare const MAX_BUFFER: number;
+/**
+ * Quote a value for the shell command line. Values containing whitespace or a
+ * double quote are wrapped and their quotes escaped; everything else is passed
+ * through unchanged.
+ */
+export declare function quote(value: unknown): string;
+export interface RunOptions {
+    /** Working directory. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /** Extra environment variables merged over `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** Return the result instead of throwing on a non-zero exit. */
+    allowFailure?: boolean;
+}
+export interface RunResult {
+    /** Process exit status, or `null` when the process was signalled. */
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Run a command through the shell, synchronously. Throws on spawn errors and,
+ * unless `allowFailure` is set, on a non-zero exit status. The command and its
+ * arguments are quoted and joined into a single shell line.
+ */
+export declare function run(command: string, args: readonly string[], options?: RunOptions): RunResult;
+/**
+ * Asynchronous counterpart of {@link run}, suitable for parallel jobs. Mirrors
+ * the synchronous semantics: shell execution, the same buffer cap, and a
+ * rejection on spawn error or (unless `allowFailure` is set) non-zero exit.
+ */
+export declare function runAsync(command: string, args: readonly string[], options?: RunOptions): Promise<RunResult>;