@prisma/composer 0.6.0-dev.14 → 0.6.0-dev.15

package/dist/{pipeline-D3QoVzAB-D_ufjg3N.mjs → pipeline-AoW8zq4I-C6Qe0VaZ.mjs}

@@ -1,5 +1,4 @@
-import { a as CliStructuredError, o as blindCast } from "./shared-CCaR42wo-BvegvmA_.mjs";
-import { i as InternalError } from "./result-CFqJKiqg.mjs";
+import { c as CliStructuredError, d as blindCast, i as effectResolutionDiagnostic, u as InternalError } from "./result-B4XjxVK6.mjs";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -532,7 +531,7 @@ function Load(root, opts) {
 }
 blindCast(Symbol.for("prisma:secret-box"));
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/load-entry-ZpkCjTxj.mjs
+//#region ../../0-framework/3-tooling/cli/dist/load-entry-BYBSCuWg.mjs
 /**
 * `loadEntry` imports a user's topology with the host runtime's own module
 * loader — under node (the CLI's shebang runtime), that loader strips
@@ -653,7 +652,7 @@ async function assembleServices(graph, config, cwd, run) {
 	return { bundles };
 }
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/pipeline-D3QoVzAB.mjs
+//#region ../../0-framework/3-tooling/cli/dist/pipeline-AoW8zq4I.mjs
 /**
 * Pipeline step: find and load `prisma-composer.config.ts` (ADR-0017) — the ONE
 * file that imports control-plane code. Discovery is the standard walk-up
@@ -661,8 +660,19 @@ async function assembleServices(graph, config, cwd, run) {
 * loading is c12 with that explicit path (rc/global/package.json lookups
 * disabled), so the config file's own static imports resolve from the app
 * root by whatever package manager runs — no specifier construction, no
-* anchoring. The loaded shape is validated field-by-field with structured
-* errors naming the field.
+* anchoring.
+*
+* Two shapes of the same machinery:
+*
+*   loadAppConfigDiagnostics — returns the evaluated value together with
+*   EVERY problem found, and never throws. This is the shape the engine
+*   command family consumes: the engine renders diagnostics itself and
+*   decides per command whether a broken section is fatal, so a loader that
+*   threw on the first bad field would both hide the rest and bypass that
+*   rendering.
+*
+*   loadAppConfig — the same load, throwing its first diagnostic. The
+*   clipanion CLI still runs on it; it goes when clipanion does.
 */
 const CONFIG_FILENAME = "prisma-composer.config.ts";
 /** Walks UP from the entry file's directory looking for the literal CONFIG_FILENAME; undefined when the walk hits the filesystem root. */
@@ -696,34 +706,52 @@ function isRecord(value) {
 /**
 * Field-by-field validation of the loaded default export — deliberately no
 * schema library: each check is a structured error naming the offending field.
-* Returns the same object, typed.
+*
+* Collects rather than throws, so one bad config reports every bad field
+* instead of only the first. The `extensions` and `state` checks are
+* independent, and within `extensions` each entry is judged on its own; a
+* field whose own shape check already failed is not probed further, because
+* anything derived from it would be noise rather than a second finding.
 */
-function validateConfigShape(loaded, configPath) {
-	if (!isRecord(loaded) || Object.keys(loaded).length === 0) throw new CliStructuredError("CONFIG.EXPORT_INVALID", `"${configPath}" exported no config.`, {
+function configShapeDiagnostics(loaded, configPath) {
+	if (!isRecord(loaded) || Object.keys(loaded).length === 0) return [new CliStructuredError("CONFIG.EXPORT_INVALID", `"${configPath}" exported no config.`, {
 		fix: "It must default-export defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.",
 		where: { path: configPath }
-	});
+	})];
+	const diagnostics = [];
 	const extensions = loaded["extensions"];
-	if (!Array.isArray(extensions)) throw fieldError("extensions", "must be an array");
-	const seen = /* @__PURE__ */ new Set();
-	for (const [index, entry] of extensions.entries()) {
-		if (!isRecord(entry)) throw fieldError(`extensions[${index}]`, "must be an extension descriptor object");
-		const id = entry["id"];
-		if (typeof id !== "string" || id.length === 0) throw fieldError(`extensions[${index}].id`, "must be a non-empty string (the extension package name)");
-		if (!isRecord(entry["nodes"])) throw fieldError(`extensions[${index}].nodes`, "must be an object (the node-ID → control registry)");
-		if (seen.has(id)) throw new CliStructuredError("CONFIG.EXTENSION_DUPLICATE", `${CONFIG_FILENAME}: extension "${id}" is listed more than once in \`extensions\`.`);
-		seen.add(id);
+	if (!Array.isArray(extensions)) diagnostics.push(fieldError("extensions", "must be an array"));
+	else {
+		const seen = /* @__PURE__ */ new Set();
+		for (const [index, entry] of extensions.entries()) {
+			if (!isRecord(entry)) {
+				diagnostics.push(fieldError(`extensions[${index}]`, "must be an extension descriptor object"));
+				continue;
+			}
+			const id = entry["id"];
+			if (typeof id !== "string" || id.length === 0) diagnostics.push(fieldError(`extensions[${index}].id`, "must be a non-empty string (the extension package name)"));
+			else if (seen.has(id)) diagnostics.push(new CliStructuredError("CONFIG.EXTENSION_DUPLICATE", `${CONFIG_FILENAME}: extension "${id}" is listed more than once in \`extensions\`.`));
+			else seen.add(id);
+			if (!isRecord(entry["nodes"])) diagnostics.push(fieldError(`extensions[${index}].nodes`, "must be an object (the node-ID → control registry)"));
+		}
 	}
 	const state = loaded["state"];
-	if (!isRecord(state) || typeof state["extension"] !== "string" || typeof state["create"] !== "function") throw fieldError("state", "must be a state descriptor (e.g. prismaState())");
+	if (!isRecord(state) || typeof state["extension"] !== "string" || typeof state["create"] !== "function") diagnostics.push(fieldError("state", "must be a state descriptor (e.g. prismaState())"));
+	return diagnostics;
+}
+/** The throwing form of configShapeDiagnostics: raises the first finding, returns the same object typed. Used by the clipanion pipeline. */
+function validateConfigShape(loaded, configPath) {
+	const [first] = configShapeDiagnostics(loaded, configPath);
+	if (first !== void 0) throw first;
 	return blindCast(loaded);
 }
 /**
-* Loads + validates the config at `configPath` via c12 (explicit file; rc /
-* global-rc / package.json lookups disabled — discovery already happened in
-* findConfigPathForEntry).
+* Evaluates `configPath` with c12 (explicit file; rc / global-rc /
+* package.json lookups disabled). `verifySamePath` runs the same-file check
+* against the discovered path — see loadAppConfigDiagnostics for when it does
+* not apply.
 */
-async function loadAppConfig(configPath) {
+async function evaluateConfig(configPath, verifySamePath) {
 	let result;
 	try {
 		result = await c12.loadConfig({
@@ -735,19 +763,99 @@ async function loadAppConfig(configPath) {
 			packageJson: false
 		});
 	} catch (error) {
-		throw new CliStructuredError("CONFIG.EVALUATION_FAILED", `Evaluating "${configPath}" failed: ${error instanceof Error ? error.message : String(error)}`, {
-			where: { path: configPath },
-			cause: error
-		});
+		return {
+			value: void 0,
+			diagnostics: [new CliStructuredError("CONFIG.EVALUATION_FAILED", `Evaluating "${configPath}" failed: ${error instanceof Error ? error.message : String(error)}`, {
+				where: { path: configPath },
+				cause: error
+			})]
+		};
 	}
 	const loadedFile = result.configFile;
-	if (typeof loadedFile !== "string" || fs.realpathSync(loadedFile) !== fs.realpathSync(configPath)) throw new CliStructuredError("CONFIG.PATH_MISMATCH", `Config loading resolved "${String(loadedFile)}" instead of the discovered "${configPath}".`, {
-		why: "Refusing to deploy against a different file.",
-		where: { path: configPath }
-	});
+	if (verifySamePath && (typeof loadedFile !== "string" || fs.realpathSync(loadedFile) !== fs.realpathSync(configPath))) return {
+		value: result.config,
+		diagnostics: [new CliStructuredError("CONFIG.PATH_MISMATCH", `Config loading resolved "${String(loadedFile)}" instead of the discovered "${configPath}".`, {
+			why: "Refusing to deploy against a different file.",
+			where: { path: configPath }
+		})]
+	};
+	return {
+		value: result.config,
+		diagnostics: configShapeDiagnostics(result.config, configPath)
+	};
+}
+/**
+* The front of every config load, shared by the throwing and the
+* diagnostics-list shapes: verify the installed tree can evaluate a config at
+* all, then settle which file to load — the section's path, or the
+* entry-anchored walk.
+*
+* The effect-resolution check comes first because evaluating a config imports
+* alchemy's provider tree: in a tree where alchemy resolves an `effect` we did
+* not pin, nothing downstream can load, so the dependency conflict is the
+* finding with the fix in it and every later failure is its symptom.
+*/
+function configSource(request) {
+	const resolvedEntry = path.resolve(request.entryPath);
+	const cwd = request.cwd ?? path.dirname(resolvedEntry);
+	const effectConflict = effectResolutionDiagnostic(cwd);
+	if (effectConflict !== void 0) return {
+		ok: false,
+		path: void 0,
+		diagnostic: effectConflict
+	};
+	if (request.configPath === void 0) {
+		const discovered = findConfigPathForEntry(resolvedEntry);
+		return discovered === void 0 ? {
+			ok: false,
+			path: void 0,
+			diagnostic: missingConfigError(resolvedEntry)
+		} : {
+			ok: true,
+			path: discovered,
+			explicit: false
+		};
+	}
+	const configPath = path.resolve(cwd, request.configPath);
+	if (!fs.existsSync(configPath)) return {
+		ok: false,
+		path: configPath,
+		diagnostic: new CliStructuredError("CONFIG.FILE_MISSING", `The \`composer\` config section points at "${configPath}", which does not exist.`, {
+			why: "An explicit configPath is used as given — there is no walk to fall back on.",
+			fix: "Correct `configPath` in the `composer` section of prisma.config.ts, or remove it to search upward from the entry.",
+			where: { path: configPath }
+		})
+	};
 	return {
+		ok: true,
 		path: configPath,
-		config: validateConfigShape(result.config, configPath)
+		explicit: true
+	};
+}
+/**
+* The throwing form of that front, for the pipeline: the file the load will
+* use, or the finding raised. `explicit` says the section named the file,
+* which is what retires the same-file check for that case.
+*/
+function resolveConfigFile(request) {
+	const source = configSource(request);
+	if (!source.ok) throw source.diagnostic;
+	return {
+		path: source.path,
+		explicit: source.explicit
+	};
+}
+/**
+* Loads + validates the config at `configPath`, throwing its first diagnostic.
+* The clipanion CLI's pipeline runs on this; it goes when clipanion does.
+*/
+async function loadAppConfig(configPath, verifySamePath = true) {
+	const { value, diagnostics } = await evaluateConfig(configPath, verifySamePath);
+	const [first] = diagnostics;
+	if (first !== void 0) throw first;
+	return {
+		path: configPath,
+		config: validateConfigShape(value, configPath)
 	};
 }
 function lookup(extensions, extension, type, expectedKind, what) {
@@ -797,6 +905,23 @@ function validateRegistryCoverage(graph, config) {
 * cannot drift.
 */
 /**
+* The config step both pipelines share: the effect-resolution check and the
+* choice of config file (load-config.ts's shared front), then evaluation —
+* unless the caller substituted a config, which replaces the evaluation and
+* nothing before it.
+*/
+async function loadConfigStep(entryPath, cwd, deps) {
+	const { path: configPath, explicit } = resolveConfigFile({
+		entryPath,
+		configPath: deps.configPath,
+		cwd
+	});
+	return {
+		configPath,
+		config: deps.config ?? (await loadAppConfig(configPath, !explicit)).config
+	};
+}
+/**
 * The pipeline's front — config discovery/load, entry load, name resolution —
 * WITHOUT Load, coverage, or assemble. `log` needs only who the app is (its
 * config and resolved name) to reach the already-running local instance; it
@@ -804,10 +929,7 @@ function validateRegistryCoverage(graph, config) {
 * output the way the full pipeline does.
 */
 async function resolveAppIdentity(entry, overrideName, cwd, deps = {}) {
-	const resolvedEntryPath = path.resolve(cwd, entry);
-	const configPath = findConfigPathForEntry(resolvedEntryPath);
-	if (configPath === void 0) throw missingConfigError(resolvedEntryPath);
-	const config = deps.config ?? (await loadAppConfig(configPath)).config;
+	const { configPath, config } = await loadConfigStep(path.resolve(cwd, entry), cwd, deps);
 	const entryModule = await loadEntry(entry, cwd);
 	const name = overrideName ?? entryModule.root.name;
 	if (name.length === 0) throw new CliStructuredError("COMPOSE.NAME_MISSING", "The root node has no name.", { fix: "Name it at authoring, or pass --name." });
@@ -825,10 +947,7 @@ async function resolveAppIdentity(entry, overrideName, cwd, deps = {}) {
 * about any one command.
 */
 async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError) {
-	const resolvedEntryPath = path.resolve(cwd, entry);
-	const configPath = findConfigPathForEntry(resolvedEntryPath);
-	if (configPath === void 0) throw missingConfigError(resolvedEntryPath);
-	const config = deps.config ?? (await loadAppConfig(configPath)).config;
+	const { configPath, config } = await loadConfigStep(path.resolve(cwd, entry), cwd, deps);
 	const entryModule = await loadEntry(entry, cwd);
 	const graph = Load(entryModule.root);
 	if (graph.root.node.kind !== "module") throw new CliStructuredError("COMPOSE.ROOT_NOT_MODULE", "The deploy root must be a module.", { fix: "Wrap your service, e.g. export default module('name', ({ provision }) => { provision(service); })." });
@@ -854,4 +973,4 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 //#endregion
 export { runPipeline as n, resolveAppIdentity as t };
 
-//# sourceMappingURL=pipeline-D3QoVzAB-D_ufjg3N.mjs.map
+//# sourceMappingURL=pipeline-AoW8zq4I-C6Qe0VaZ.mjs.map