@jterrazz/test 11.0.0 → 12.0.1

package/README.md

@@ -247,7 +247,7 @@ The handle destructures to `{ mobile, cleanup, udid }` (plus `backendUrl` with `
 
 ### Root auto-discovery
 
-When `root` is absent, the framework walks up from the specification file to the first directory containing `docker/compose.test.yaml`, else the first containing `package.json`. Pass `root` only when the convention does not fit. `root` is strictly the **project root** (compose detection + local-bin resolution, or the cwd of a `specification.website()` server command) — it is not a fixtures root; `.fixture()` resolves its own paths.
+When `root` is absent, the framework walks up from the specification file to the **nearest** directory carrying `package.json` or `docker/compose.test.yaml`. In a workspace that is the member being tested, not the repository root above it. Pass `root` only when the convention does not fit. `root` is strictly the **project root** (compose detection + local-bin resolution, or the cwd of a `specification.website()` server command) — it is not a fixtures root; `.fixture()` resolves its own paths.
 
 ## Builder API
 

package/dist/index.d.ts

@@ -1412,7 +1412,15 @@ interface OrchestratorOptions {
    */
   services: Record<string, ServiceHandle>;
   mode: 'e2e' | 'integration';
-  root?: string;
+  /**
+   * The project root, already resolved. REQUIRED: the constructors derive it
+   * by walking up from the calling specification file (CONVENTIONS A9), and
+   * the orchestrator is handed the answer. Defaulting to `process.cwd()` here
+   * meant one silent second opinion about what the project is — the runner
+   * resolving from the caller, this from wherever the runner happened to be
+   * launched, which in a workspace is rarely the same directory.
+   */
+  root: string;
   /** Compose project name — used for per-worker stack isolation. */
   projectName?: string;
 }
@@ -2016,8 +2024,9 @@ interface SqliteOptions {
    */
   init?: string;
   /**
-   * Path to a Prisma schema directory or file.
-   * The adapter runs `prisma db push` to create the template.
+   * Path to a Prisma schema directory or file, resolved against the current
+   * working directory. The adapter runs `prisma db push --schema <path>` to
+   * create the template, so the schema needs no Prisma config at the cwd.
    * Mutually exclusive with `init`.
    */
   prismaSchema?: string;
@@ -2035,6 +2044,7 @@ declare class SqliteHandle implements DatabasePort, ServiceHandle {
   private workerDbPath;
   private initSql;
   private prismaSchema;
+  private readonly options;
   constructor(options?: SqliteOptions);
   buildConnectionString(): string;
   createDatabaseAdapter(): DatabasePort;

package/dist/index.js

@@ -1,7 +1,7 @@
 import { i as match, n as Matcher, t as CaptureScope } from "./match.js";
 import { a as isContract, c as mergeTextPreservingPlaceholders, d as structuralSubset, f as textEquals, i as defineContracts, l as renderExpected, n as contractsOf, o as isContracts, r as defineContract, s as mergePreservingPlaceholders, t as ContractQueue, u as structuralEquals } from "./queue.js";
-import { closeSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { closeSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parse } from "yaml";
 import { execFile, execSync, spawn, spawnSync } from "node:child_process";
 import { Client } from "pg";
@@ -12,6 +12,7 @@ import { createServer } from "node:http";
 import { createServer as createServer$1 } from "node:net";
 import { promisify } from "node:util";
 import Database from "better-sqlite3";
+import { createHash } from "node:crypto";
 import { mockDeep } from "vitest-mock-extended";
 import MockDatePackage from "mockdate";
 //#region src/core/specification/shared/registry.ts
@@ -790,13 +791,55 @@ var FilesystemAccessor = class {
 };
 //#endregion
 //#region src/core/specification/shared/caller.ts
+/** Sibling module tests are callers, not internals (CONVENTIONS I2). */
+const TEST_FILE = /\.test\.[cm]?[jt]s$/;
+/** Where this very module sits inside the framework's SOURCE tree. */
+const SOURCE_LOCATION = join("core", "specification", "shared");
+/** The real path of `path`, or `path` itself when it cannot be resolved. */
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
 /**
 * Directory of the running framework module itself. From the built package
 * this is `<package root>/dist`, whatever the resolution path — including a
 * `file:` link, where the real path carries neither `node_modules` nor
 * `/src/…` and would otherwise be mistaken for a caller frame.
 */
-const FRAMEWORK_DIR = dirname(fileURLToPath(import.meta.url));
+const FRAMEWORK_DIR = realPath(dirname(fileURLToPath(import.meta.url)));
+/**
+* The directory holding the framework's OWN modules: `<package>/dist` for a
+* built install (everything is bundled there), `<repo>/src` when the framework
+* runs from source — this module's known location inside that tree is what
+* tells the two apart.
+*/
+const FRAMEWORK_TREE = FRAMEWORK_DIR.endsWith(`${sep}${SOURCE_LOCATION}`) ? resolve(FRAMEWORK_DIR, "../../..") : FRAMEWORK_DIR;
+/** Is `path` inside `directory` (strictly — a directory is not inside itself)? */
+function isInside(directory, path) {
+	const rest = relative(directory, path);
+	return rest !== "" && !rest.startsWith("..") && !isAbsolute(rest);
+}
+/**
+* Is this stack frame a module of the framework itself, rather than of the code
+* calling it?
+*
+* Answered by IDENTITY: the frame is inside the framework's own directory.
+* Answering it by substring — `/src/core/`, `/src/integrations/`, `/src/vitest/`
+* — was answering a different question, "does this path look like the framework's
+* layout", and a consumer that happens to have its own `src/core/` matched it.
+* Its files were then skipped as framework internals, and fixture resolution
+* anchored on the wrong directory (or fell through to the cwd) with nothing
+* reported.
+*
+* @internal
+*/
+function isFrameworkFrame(filePath, frameworkTree = FRAMEWORK_TREE) {
+	if (TEST_FILE.test(filePath)) return false;
+	return isInside(realPath(frameworkTree), realPath(filePath));
+}
 /**
 * Detect the directory of the first stack frame that lives outside this
 * package. Used to anchor fixture resolution (`seeds/`, `requests/`,
@@ -813,7 +856,7 @@ function getCallerDir() {
 		if (!match?.groups?.filePath) continue;
 		const filePath = match.groups.filePath;
 		if (filePath.includes("node_modules")) continue;
-		if ((filePath.includes("/src/core/") || filePath.includes("/src/integrations/") || filePath.includes("/src/vitest/") || resolve(filePath, "..") === FRAMEWORK_DIR) && !/\.test\.[cm]?[jt]s$/.test(filePath)) continue;
+		if (isFrameworkFrame(filePath)) continue;
 		return resolve(filePath, "..");
 	}
 	return process.cwd();
@@ -2583,7 +2626,7 @@ var Orchestrator = class {
 	constructor(options) {
 		this.services = options.services;
 		this.mode = options.mode;
-		this.root = options.root ?? process.cwd();
+		this.root = options.root;
 		this.projectName = options.projectName;
 	}
 	/**
@@ -2804,23 +2847,39 @@ var Orchestrator = class {
 };
 //#endregion
 //#region src/core/specification/shared/resolve.ts
+/** What makes a directory a project root — a manifest, or a test stack. */
+const ROOT_MARKERS = ["package.json", "docker/compose.test.yaml"];
+/**
+* The NEAREST ancestor of `startDir` (itself included) carrying a root marker,
+* `undefined` when none does.
+*
+* Both markers are probed at each ancestor, in ONE walk. Two walks — the
+* compose file all the way up, then `package.json` all the way up — made the
+* further directory win: in a workspace, a `docker/compose.test.yaml` at the
+* repository root outranked the `package.json` of the very package being
+* tested, and every path the runner resolved was measured from the wrong unit.
+* The unit is the nearest thing that declares itself a project.
+*
+* The existence probe is injected so the lint layer can pass its cached one
+* (A9's `a9w-redundant-root` derives the same root, and must derive it the
+* same way).
+*/
+function findRoot(startDir, exists) {
+	let dir = startDir;
+	for (;;) {
+		if (ROOT_MARKERS.some((marker) => exists(resolve(dir, marker)))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
 /**
 * Auto-discover the project root from a starting directory (CONVENTIONS A9):
-* walk up to the first directory containing `docker/compose.test.yaml`;
-* if none, walk up to the first directory containing `package.json`;
-* if none, the starting directory itself.
+* walk up to the first directory that carries `package.json` or
+* `docker/compose.test.yaml`; if none does, the starting directory itself.
 */
 function discoverRoot(startDir) {
-	for (const marker of ["docker/compose.test.yaml", "package.json"]) {
-		let dir = startDir;
-		for (;;) {
-			if (existsSync(resolve(dir, marker))) return dir;
-			const parent = dirname(dir);
-			if (parent === dir) break;
-			dir = parent;
-		}
-	}
-	return startDir;
+	return findRoot(startDir, existsSync) ?? startDir;
 }
 /**
 * Resolve the project root for a specification. An explicit `root` option is
@@ -3861,6 +3920,64 @@ function isValidSqliteTemplate(path) {
 		closeSync(fd);
 	}
 }
+/** The invocation used when no `prismaSchema` is declared — Prisma discovers its own schema. */
+const PRISMA_PUSH = "npx prisma db push --force-reset";
+/**
+* The `prisma db push` command line for a `prismaSchema` option.
+*
+* The declared path is resolved against `process.cwd()` and handed to the CLI
+* as `--schema`. Without the flag Prisma falls back to its own discovery
+* (`prisma.config.ts` / `package.json#prisma` at the cwd), which silently
+* ignores the option: a repo whose config does not sit at the cwd then fails
+* with "Could not find Prisma Schema that is required for this command" — but
+* only on a machine without a cached template, so the divergence hides until CI.
+*
+* `null` (no option) keeps the bare invocation, discovery and all.
+*/
+function prismaPushCommand(prismaSchema) {
+	if (!prismaSchema) return PRISMA_PUSH;
+	return `${PRISMA_PUSH} --schema ${JSON.stringify(resolve(prismaSchema))}`;
+}
+/** Every template file this package writes carries that prefix, then its key. */
+const TEMPLATE_PREFIX = "jterrazz-test-sqlite-template";
+/**
+* The schema source as bytes: a file's content, or every file under a
+* directory in a stable order (a Prisma `schema/` folder is a directory). Each
+* entry carries its own path, so moving a schema changes the fingerprint.
+* Anything unreadable degrades to a marker rather than throwing — the path is
+* already in the key, so two projects still never collide.
+*/
+function schemaBytes(path) {
+	try {
+		if (statSync(path).isDirectory()) return readdirSync(path).sort().map((entry) => schemaBytes(join(path, entry))).join("\0");
+		return `${path}\0${readFileSync(path, "utf8")}`;
+	} catch {
+		return `${path}\0<unreadable>`;
+	}
+}
+/**
+* The name of the template database for a set of options — `<prefix>-<sha8>`,
+* the digest taken over the schema KIND, its resolved path and its content.
+*
+* The template lives in the machine-global OS tmpdir, so the name is the only
+* thing keeping two projects apart. A single fixed name meant the first project
+* to run on a machine built the template and every other project that day
+* silently inherited its tables — the file is header-valid, so the staleness
+* check accepts it and the schema never gets built. Keying on the schema makes
+* reuse mean "the same schema", which is what the cache was ever for.
+*/
+function sqliteTemplateName(options = {}) {
+	let fingerprint;
+	if (options.prismaSchema) {
+		const path = resolve(options.prismaSchema);
+		fingerprint = `prisma\0${path}\0${schemaBytes(path)}`;
+	} else if (options.init) {
+		const path = resolve(options.init);
+		fingerprint = `init\0${path}\0${schemaBytes(path)}`;
+	} else fingerprint = "empty";
+	const key = createHash("sha256").update(fingerprint).digest("hex").slice(0, 8);
+	return `${TEMPLATE_PREFIX}-${key}.sqlite`;
+}
 var SqliteHandle = class {
 	type = "sqlite";
 	composeName = null;
@@ -3874,7 +3991,9 @@ var SqliteHandle = class {
 	workerDbPath = "";
 	initSql;
 	prismaSchema;
+	options;
 	constructor(options = {}) {
+		this.options = options;
 		this.initSql = options.init ?? null;
 		this.prismaSchema = options.prismaSchema ?? null;
 	}
@@ -3886,7 +4005,7 @@ var SqliteHandle = class {
 	}
 	async healthcheck() {}
 	async initialize() {
-		this.templatePath = resolve(tmpdir(), "jterrazz-test-sqlite-template.sqlite");
+		this.templatePath = resolve(tmpdir(), sqliteTemplateName(this.options));
 		const lockPath = `${this.templatePath}.lock`;
 		if (existsSync(lockPath)) {
 			const start = Date.now();
@@ -3906,7 +4025,7 @@ var SqliteHandle = class {
 		writeFileSync(lockPath, process.pid.toString());
 		if (this.prismaSchema) {
 			const { execSync } = await import("node:child_process");
-			execSync("npx prisma db push --force-reset", {
+			execSync(prismaPushCommand(this.prismaSchema), {
 				env: {
 					...process.env,
 					DATABASE_URL: `file:${this.templatePath}`,