@prisma/composer-cli 0.25.0-dev.3 → 0.25.0-dev.5

package/dist/{pipeline-C7gNjMzJ-CixaMvnR.mjs → pipeline-DAYhea3J-uuBciVDS.mjs}

@@ -1,11 +1,9 @@
-import { a as InternalError, i as CliStructuredError, o as blindCast } from "./result-sR7PBi61.mjs";
-import { t as effectResolutionDiagnostic } from "./shared-BTnATsqm-BH4axbJg.mjs";
+import { a as configFileMissing, d as CliStructuredError, f as InternalError, i as checkComposerConfig, p as blindCast } from "./result-SF9LFOuR.mjs";
 import * as mod from "node:module";
 import * as fs from "node:fs";
 import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import * as c12 from "c12";
 //#region ../../0-framework/1-core/core/dist/graph-BfKAg2Ap.mjs
 /** The reserved name of a resource's single anonymous output port. Rejected as a user-declared port name (node.ts). */
 const RESOURCE_OUT_PORT = "$out";
@@ -828,7 +826,7 @@ var AssembleError = class extends CliStructuredError {
 function buildDescriptorAssemble(config, node, address, cwd) {
 	const { extension, type } = node.build;
 	const extensionDescriptor = config.extensions.find((candidate) => candidate.id === extension);
-	if (extensionDescriptor === void 0) throw new AssembleError("ASSEMBLE.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by service "${node.name}"'s build).`, { fix: "Add it to prisma-composer.config.ts's `extensions`." });
+	if (extensionDescriptor === void 0) throw new AssembleError("ASSEMBLE.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by service "${node.name}"'s build).`, { fix: "Add it to `extensions` in the `composer` section of prisma.config.ts." });
 	const nodeDescriptor = extensionDescriptor.nodes[type];
 	if (nodeDescriptor === void 0) throw new AssembleError("ASSEMBLE.DESCRIPTOR_MISSING", `Extension "${extension}" has no descriptor for build type "${type}".`, { why: `Known types: ${Object.keys(extensionDescriptor.nodes).join(", ")}.` });
 	if (nodeDescriptor.kind !== "build") throw new AssembleError("ASSEMBLE.DESCRIPTOR_KIND_MISMATCH", `Extension "${extension}"'s descriptor for type "${type}" is a "${nodeDescriptor.kind}" descriptor.`, { why: "Assembling a service build needs a \"build\" descriptor." });
@@ -855,242 +853,11 @@ async function assembleServices(graph, config, cwd, run) {
 	return { bundles };
 }
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/pipeline-C7gNjMzJ.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
-* from the deploy entry's directory (mirrors prisma/orm's config-loader);
-* 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.
-*
-* 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.
-*/
-/**
-* Accepted config file names, in precedence order: when several sit in one
-* directory the first one found wins. The JavaScript spellings exist so a
-* project whose own TypeScript build would otherwise compile the config file
-* (no `include`, a `rootDir`, `module: commonjs`) can keep it out of that
-* build's sight.
-*/
-const CONFIG_FILENAMES = [
-	"prisma-composer.config.ts",
-	"prisma-composer.config.mts",
-	"prisma-composer.config.mjs",
-	"prisma-composer.config.js"
-];
-/** The canonical spelling, used in messages and docs. */
-const CONFIG_FILENAME = CONFIG_FILENAMES[0];
-/** The accepted spellings as one glob-like string for messages. */
-const CONFIG_FILENAME_PATTERN = "prisma-composer.config.{ts,mts,mjs,js}";
-/** Walks UP from the entry file's directory looking for one of CONFIG_FILENAMES; undefined when the walk hits the filesystem root. */
-function findConfigPathForEntry(entryPath) {
-	let current = path.dirname(path.resolve(entryPath));
-	while (true) {
-		for (const filename of CONFIG_FILENAMES) {
-			const candidate = path.join(current, filename);
-			if (fs.existsSync(candidate)) return candidate;
-		}
-		const parent = path.dirname(current);
-		if (parent === current) return void 0;
-		current = parent;
-	}
-}
-function missingConfigError(entryPath) {
-	const searchedFrom = path.dirname(path.resolve(entryPath));
-	return new CliStructuredError("CONFIG.FILE_MISSING", `No ${CONFIG_FILENAME_PATTERN} found walking up from "${searchedFrom}".`, {
-		why: "The deploy needs the app's config file.",
-		fix: "Create one next to (or above) the entry, default-exporting defineConfig({ extensions: [...], state: ... }) from '@prisma/composer/config'.",
-		where: { path: searchedFrom }
-	});
-}
-function fieldError(configPath, field, requirement) {
-	return new CliStructuredError("CONFIG.FIELD_INVALID", `${path.basename(configPath)}: \`${field}\` ${requirement}.`, {
-		fix: "See defineConfig() in '@prisma/composer/config'.",
-		meta: { field }
-	});
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Field-by-field validation of the loaded default export — deliberately no
-* schema library: each check is a structured error naming the offending field.
-*
-* 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 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)) diagnostics.push(fieldError(configPath, "extensions", "must be an array"));
-	else {
-		const seen = /* @__PURE__ */ new Set();
-		for (const [index, entry] of extensions.entries()) {
-			if (!isRecord(entry)) {
-				diagnostics.push(fieldError(configPath, `extensions[${index}]`, "must be an extension descriptor object"));
-				continue;
-			}
-			const id = entry["id"];
-			if (typeof id !== "string" || id.length === 0) diagnostics.push(fieldError(configPath, `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", `${path.basename(configPath)}: extension "${id}" is listed more than once in \`extensions\`.`));
-			else seen.add(id);
-			if (!isRecord(entry["nodes"])) diagnostics.push(fieldError(configPath, `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") diagnostics.push(fieldError(configPath, "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);
-}
-/**
-* 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 evaluateConfig(configPath, verifySamePath) {
-	let result;
-	try {
-		result = await c12.loadConfig({
-			name: "prisma-composer",
-			configFile: configPath,
-			cwd: path.dirname(configPath),
-			rcFile: false,
-			globalRc: false,
-			packageJson: false
-		});
-	} catch (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 (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 effectConflict = effectResolutionDiagnostic(request.cwd ?? path.dirname(resolvedEntry));
-	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 = request.configPath;
-	if (!path.isAbsolute(configPath)) return {
-		ok: false,
-		path: configPath,
-		diagnostic: new CliStructuredError("CONFIG.PATH_NOT_ABSOLUTE", `The \`composer\` config section's configPath must arrive absolute, and "${configPath}" is relative.`, {
-			why: "The section validator resolves a relative configPath against the config file that declared it; a relative value here means that resolution was skipped.",
-			fix: "Run the configPath through the composer section validator, or resolve it against its declaring file before constructing the load request.",
-			where: { path: 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,
-		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)
-	};
-}
+//#region ../../0-framework/3-tooling/cli/dist/pipeline-DAYhea3J.mjs
 function lookup(extensions, extension, type, expectedKind, what) {
 	const ext = extensions.get(extension);
 	if (ext === void 0) throw new CliStructuredError("CONFIG.EXTENSION_MISSING", `No extension "${extension}" is configured (needed by ${what}).`, {
-		fix: `Add it to ${CONFIG_FILENAME}'s \`extensions\` (import its /control entry and list its descriptor).`,
+		fix: "Add it to `extensions` in the `composer` section of prisma.config.ts (import its /control entry and list its descriptor).",
 		meta: {
 			extension,
 			type
@@ -1125,7 +892,7 @@ function validateRegistryCoverage(graph, config) {
 }
 /**
 * The shared prefix of `deploy`/`destroy`/`dev` (deploy-cli.md § The
-* pipeline; local-dev spec § 6): config discovery/load, entry load, Load,
+* pipeline; local-dev spec § 6): entry load, Load,
 * registry coverage validation, name resolution, assemble. Deploy and dev
 * diverge after this — deploy resolves containers/preflight/stack file
 * against the hosted providers, dev against the local ones — so everything
@@ -1133,50 +900,58 @@ function validateRegistryCoverage(graph, config) {
 * `run()` (main.ts) and `runDev()` (dev/run-dev.ts), so the two pipelines
 * cannot drift.
 */
+function configError(findings, file) {
+	const [first] = findings;
+	return new CliStructuredError(first.code, first.summary, {
+		...first.why === void 0 ? {} : { why: first.why },
+		fix: first.fix,
+		where: { path: first.where ?? file },
+		meta: {
+			...first.field === void 0 ? {} : { field: first.field },
+			findings
+		}
+	});
+}
 /**
-* 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.
+* Refuses a caller's config with the same findings, in the same order, as the CLI's section validator.
+* The error is the first finding and carries all of them in `meta.findings`. Returns the config with `file` resolved against `cwd`.
 */
-async function loadConfigStep(entryPath, cwd, deps) {
-	const { path: configPath, explicit } = resolveConfigFile({
-		entryPath,
-		configPath: deps.configPath,
-		cwd
-	});
+function checkConfigSource(source, cwd) {
+	const file = path.resolve(cwd, source.file);
+	if (!fs.existsSync(file)) throw configError([configFileMissing(file)], file);
+	const checked = checkComposerConfig(source.value, file);
+	if (!checked.ok) throw configError(checked.findings, file);
 	return {
-		configPath,
-		config: deps.config ?? (await loadAppConfig(configPath, !explicit)).config
+		value: checked.value,
+		file
 	};
 }
 /**
-* The pipeline's front — config discovery/load, entry load, name resolution —
+* The pipeline's front — entry load and 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
 * neither builds nor provisions, so it must not require the user's built
 * output the way the full pipeline does.
 */
-async function resolveAppIdentity(entry, overrideName, cwd, deps = {}) {
-	const { configPath, config } = await loadConfigStep(path.resolve(cwd, entry), cwd, deps);
+async function resolveAppIdentity(entry, overrideName, cwd, config) {
+	const { value } = checkConfigSource(config, cwd);
 	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." });
 	return {
-		configPath,
-		config,
+		config: value,
 		name
 	};
 }
 /**
-* Runs config discovery/load, entry load, Load, registry coverage, name
-* resolution, and assemble — steps 1–6 of `run()`. `onAssembleError`, when
+* Runs entry load, Load, registry coverage, name resolution, and assemble — steps 1–5 of `run()`. `onAssembleError`, when
 * given, lets a caller decorate an assemble failure with command-specific
 * guidance (destroy's "build first" hint) without this shared step knowing
 * about any one command.
 */
-async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError) {
-	const { configPath, config } = await loadConfigStep(path.resolve(cwd, entry), cwd, deps);
+async function runPipeline(entry, overrideName, cwd, source, deps = {}, onAssembleError) {
+	const configSource = checkConfigSource(source, cwd);
+	const config = configSource.value;
 	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); })." });
@@ -1191,8 +966,7 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 		throw error;
 	}
 	return {
-		configPath,
-		config,
+		configSource,
 		entryModule,
 		graph,
 		name,
@@ -1202,4 +976,4 @@ async function runPipeline(entry, overrideName, cwd, deps = {}, onAssembleError)
 //#endregion
 export { runPipeline as n, resolveAppIdentity as t };
 
-//# sourceMappingURL=pipeline-C7gNjMzJ-CixaMvnR.mjs.map
+//# sourceMappingURL=pipeline-DAYhea3J-uuBciVDS.mjs.map