@prisma/composer-cli 0.25.0 → 0.26.0-dev.1

package/dist/{execute-dev-BLCK5wF7-CuzMSK7T.mjs → execute-dev-BICPaq1g-CSoZJuhB.mjs}

@@ -1,12 +1,12 @@
-import { i as CliStructuredError, n as ok, t as notOk } from "./result-sR7PBi61.mjs";
-import { i as toStructured } from "./shared-BTnATsqm-BH4axbJg.mjs";
-import { n as alchemyInvocation, r as spawnAlchemy } from "./run-alchemy-pANK8XNX-XcCQncKN.mjs";
-import { n as runPipeline } from "./pipeline-C7gNjMzJ-CixaMvnR.mjs";
-import { t as containerEnv } from "./container-transport-HcvNOGZL-CIoZc7Rs.mjs";
-import { n as withEmulatorRetry, r as DEV_DIR, t as resolveLocalTargets } from "./local-target-BOGjATc2.mjs";
+import { a as CliStructuredError, o as notOk, s as ok } from "./composer-config-CY9fET8H-KpGjlYgO.mjs";
+import { n as alchemyInvocation, r as spawnAlchemy, s as toStructured } from "./run-alchemy-BEvB2sYQ-BgV2deuO.mjs";
+import { r as writeDevStackFile, t as DEV_STACK_RELATIVE_PATH } from "./generate-dev-stack-BUadNY_w-DF_lHVaP.mjs";
+import { r as runPipeline, t as containerEnv } from "./container-transport-HcvNOGZL-CHqecFc7.mjs";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { join, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+import "effect/Layer";
 import { stat, unwatchFile, watch, watchFile } from "fs";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "fs/promises";
 import { EventEmitter } from "events";
@@ -14,6 +14,69 @@ import * as sysPath from "path";
 import { lstat as lstat$1, readdir as readdir$1, realpath as realpath$1, stat as stat$2 } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { type } from "os";
+//#region ../../0-framework/1-core/core/dist/app-config-CGJHcFb-.mjs
+/** `<cwd>/.prisma-composer/dev` — the dev instance's app-scoped state directory (ADR-0041, ADR-0004's tool-state rule). "dev" names the user-facing feature/dir (naming, operator 2026-07-23) — this constant's name and value are unchanged by the localTarget rename. */
+const DEV_DIR = ".prisma-composer/dev";
+/**
+* True when an extension only participates in assembly (every `nodes` entry
+* is `kind: 'build'`, and it declares none of `providers`/`application`/
+* `provisions`/`container`) — it owns no resources or services, so it has
+* nothing to emulate and is exempt from local-target-capability requirements
+* (ADR-0041). Shared by `localTargetProviders` and every local-target hook
+* iteration.
+*/
+function isBuildOnlyExtension(extension) {
+	return Object.values(extension.nodes).every((node) => node.kind === "build") && extension.providers === void 0 && extension.application === void 0 && extension.provisions === void 0 && extension.container === void 0;
+}
+//#endregion
+//#region ../../0-framework/3-tooling/cli/dist/emulator-retry-DGonap4g.mjs
+/**
+* An emulator admin call right after a converge that just PUT dozens of
+* resources through the same daemon can hit a transient refused/reset
+* connection — a brief loopback hiccup under load, not a real failure.
+* Retried before giving up. Shared by the dev and log executors, which talk
+* to the same daemons (`startServices`, `endpoints`, `attach`).
+*/
+const EMULATOR_RETRY_ATTEMPTS = 5;
+const EMULATOR_RETRY_DELAY_MS = 500;
+async function withEmulatorRetry(call) {
+	let lastError;
+	for (let attempt = 1; attempt <= EMULATOR_RETRY_ATTEMPTS; attempt += 1) try {
+		return await call();
+	} catch (error) {
+		lastError = error;
+		if (attempt < EMULATOR_RETRY_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, EMULATOR_RETRY_DELAY_MS));
+	}
+	throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+//#endregion
+//#region ../../0-framework/1-core/core/dist/local-target.mjs
+/** The local-target stack's own provider aggregation (ADR-0041; naming, operator 2026-07-23 — the seam is `localTarget`, "dev" names the user-facing feature only) — the local-target counterpart of `deploy.ts`'s `mergedProviders`, kept in its own module so `lower()` learns nothing about it (deploy.ts's REVISED — operator review of #162). */
+function noLocalTargetSupportError(id) {
+	return new CliStructuredError("DEV.TARGET_UNSUPPORTED", `extension "${id}" has no dev support — it declares no \`localTarget\` descriptor (ADR-0041).`);
+}
+/**
+* Resolves every non-build-only configured extension's lazy `localTarget`
+* thunk, once (ADR-0041's lazy local-target reference — operator directive:
+* the production control entry carries only the thunk, never the
+* descriptor, so resolving it is this module's job, not something a deploy
+* path ever does). A build-only extension (`isBuildOnlyExtension`) owns no
+* resources or services and is skipped entirely — never even checked for a
+* `localTarget` thunk. Every other configured extension must be
+* local-target-capable, or the dev command cannot bring the app up at all,
+* so a missing thunk throws naming the extension. The generated dev stack
+* module calls this once and threads the resolved map through every
+* subsequent hook, including `localTargetProviders`.
+*/
+async function resolveLocalTargets(config) {
+	const entries = await Promise.all(config.extensions.flatMap((extension) => {
+		if (isBuildOnlyExtension(extension)) return [];
+		if (extension.localTarget === void 0) throw noLocalTargetSupportError(extension.id);
+		return [extension.localTarget().then((descriptor) => [extension.id, descriptor])];
+	}));
+	return new Map(entries);
+}
+//#endregion
 //#region ../../0-framework/3-tooling/cli/node_modules/readdirp/esm/index.js
 const EntryTypes = {
 	FILE_TYPE: "files",
@@ -1562,79 +1625,7 @@ var esm_default = {
 	FSWatcher
 };
 //#endregion
-//#region ../../0-framework/3-tooling/cli/dist/execute-dev-BLCK5wF7.mjs
-/**
-* Local-dev spec § 6 `generate-dev-stack.ts`: like generate-stack.ts but at
-* `.prisma-composer/dev/alchemy.run.ts`, always Alchemy stage `dev`, using
-* Alchemy's own `localState()` and no `report` — dev prints its own front
-* door (run-dev.ts), so core's presentation-free lower() gets nothing to
-* call back into. The generated module IS the one orchestration point where
-* dev provenance is resolved (spec § 3 REVISED): it deserializes the
-* containers, top-level-awaits `resolveLocalTargets(config)` (the lazy
-* `localTarget` thunks, ADR-0041), and passes
-* `providers: localTargetProviders(...)` + `state: localState()` explicitly
-* — `lower()` learns nothing about dev.
-*/
-const DEV_GENERATED_DIR = ".prisma-composer/dev";
-const DEV_GENERATED_FILE = "alchemy.run.ts";
-/** A relative import specifier from `.prisma-composer/dev/alchemy.run.ts` to `target` (posix separators). */
-function relativeImportSpecifier(generatedDir, target) {
-	const rel = path.relative(generatedDir, target).split(path.sep).join("/");
-	return rel.startsWith(".") ? rel : `./${rel}`;
-}
-function quote(value) {
-	return JSON.stringify(value);
-}
-function renderBundle(bundle) {
-	return `{ dir: ${quote(bundle.dir)}, entry: ${quote(bundle.entry)} }`;
-}
-function renderOptions(input) {
-	const lines = [];
-	lines.push(`  name: ${quote(input.name)},`);
-	lines.push("  bundles: {");
-	for (const [id, bundle] of Object.entries(input.assembled.bundles)) lines.push(`    ${quote(id)}: ${renderBundle(bundle)},`);
-	lines.push("  },");
-	lines.push("  providers: localTargetProviders(resolved, containers, devDir),");
-	lines.push("  state: localState(),");
-	return lines.join("\n");
-}
-/** Renders the dev stack module's source (tests assert on it without touching disk). */
-function renderDevStackFile(input) {
-	const generatedDir = path.join(input.cwd, DEV_GENERATED_DIR);
-	const appImport = relativeImportSpecifier(generatedDir, input.entryPath);
-	const configImport = relativeImportSpecifier(generatedDir, input.configPath);
-	return `// Generated by \`prisma-composer dev\` — overwritten on every run; do not
-// edit by hand. Independently runnable from ${quote(input.cwd)}:
-//
-//   alchemy deploy ${DEV_GENERATED_DIR}/${DEV_GENERATED_FILE} --stage dev
-//
-// bisects a CLI bug from an Alchemy bug (deploy-cli.md § Implementation decisions).
-import * as path from 'node:path';
-import { deserializeContainers } from '@prisma/composer/config';
-import { lower } from '@prisma/composer/deploy';
-import { DEV_DIR, localTargetProviders, resolveLocalTargets } from '@prisma/composer/local-target';
-import { localState } from 'alchemy/State/LocalState';
-import config from ${quote(configImport)};
-import app from ${quote(appImport)};
-
-const containers = deserializeContainers(config.extensions, process.env);
-const resolved = await resolveLocalTargets(config);
-const devDir = path.join(process.cwd(), DEV_DIR);
-
-export default lower(app, config, {
-${renderOptions(input)}
-});
-`;
-}
-/** Writes the dev stack file, returning its absolute path. */
-function writeDevStackFile(input) {
-	const generatedDir = path.join(input.cwd, DEV_GENERATED_DIR);
-	fs.mkdirSync(generatedDir, { recursive: true });
-	const filePath = path.join(generatedDir, DEV_GENERATED_FILE);
-	fs.writeFileSync(filePath, renderDevStackFile(input));
-	return filePath;
-}
-const DEV_STACK_RELATIVE_PATH = path.join(DEV_GENERATED_DIR, DEV_GENERATED_FILE);
+//#region ../../0-framework/3-tooling/cli/dist/execute-dev-BICPaq1g.mjs
 /**
 * Local-dev spec § 6 `watch.ts`: watches each assembled bundle's declared
 * `watch` paths (a directory watched recursively, a file watched through
@@ -1759,6 +1750,14 @@ async function mergedEndpoints(attachments) {
 	return (await Promise.all(attachments.map((a) => withEmulatorRetry(() => a.endpoints())))).flat();
 }
 /** Runs the full dev pipeline; resolves to a running session or a structured failure. */
+/** The file's content hash; undefined when it cannot be read, which counts as a change. */
+function contentHash(file) {
+	try {
+		return createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+	} catch {
+		return;
+	}
+}
 async function executeDev(input, deps, cwd) {
 	if (process.platform === "win32") return notOk(new CliStructuredError("DEV.PLATFORM_UNSUPPORTED", "local dev is not supported on Windows yet."));
 	const { onEvent } = input;
@@ -1767,13 +1766,10 @@ async function executeDev(input, deps, cwd) {
 	let resolved;
 	const containers = /* @__PURE__ */ new Map();
 	try {
-		const pipelineDeps = {
-			runAssembler: deps.runAssembler,
-			config: deps.config,
-			configPath: deps.configPath
-		};
-		pipeline = await runPipeline(input.entry, input.name, cwd, pipelineDeps);
-		const { config, graph, name } = pipeline;
+		const pipelineDeps = { runAssembler: deps.runAssembler };
+		pipeline = await runPipeline(input.entry, input.name, cwd, input.config, pipelineDeps);
+		const { graph, name } = pipeline;
+		const config = pipeline.configSource.value;
 		resolved = await resolveLocalTargets(config);
 		for (const [id, dev] of resolved) try {
 			containers.set(id, await dev.container.ensure({
@@ -1829,7 +1825,7 @@ async function executeDev(input, deps, cwd) {
 			stackPath = writeDevStackFile({
 				entryPath: pipeline.entryModule.path,
 				cwd,
-				configPath: pipeline.configPath,
+				configFile: pipeline.configSource.file,
 				name: pipeline.name,
 				assembled: pipeline.assembled
 			});
@@ -1888,6 +1884,7 @@ async function executeDev(input, deps, cwd) {
 	const attachments = [];
 	const started = [];
 	let watch;
+	let configWatch;
 	try {
 		for (const [id, dev] of resolved) try {
 			attachments.push(await dev.attach({
@@ -1920,55 +1917,86 @@ async function executeDev(input, deps, cwd) {
 			kind: "unwatchable",
 			address
 		});
-		const watchDeps = {
-			runAssembler: deps.runAssembler,
-			config: deps.config,
-			configPath: deps.configPath
+		const watchDeps = { runAssembler: deps.runAssembler };
+		const watchFiles = deps.watch ?? startWatch;
+		const onWatchError = (error) => emit({
+			kind: "watch-error",
+			message: failureMessage(error)
+		});
+		const configFile = pipeline.configSource.file;
+		const startedConfig = contentHash(configFile);
+		let configChanged = false;
+		const pausedForConfig = () => {
+			if (!configChanged && contentHash(configFile) === startedConfig) return false;
+			configChanged = true;
+			emit({
+				kind: "config-changed",
+				file: configFile
+			});
+			return true;
 		};
-		watch = startWatch(targets, () => {
-			(async () => {
-				try {
-					const rePipeline = await runPipeline(input.entry, input.name, cwd, watchDeps);
-					const stackPath = writeDevStackFile({
-						entryPath: rePipeline.entryModule.path,
-						cwd,
-						configPath: rePipeline.configPath,
-						name: rePipeline.name,
-						assembled: rePipeline.assembled
-					});
-					const outcome = await (deps.alchemy ?? spawnAlchemy)(alchemyInvocation({
-						command: "deploy",
-						stackFileRelativePath: DEV_STACK_RELATIVE_PATH,
-						cwd,
-						stage: "dev",
-						containerEnv: containerEnv(containers)
-					}));
-					if (outcome.signal !== null || outcome.exitCode !== 0) {
-						emit({
-							kind: "converge-failed",
-							stackFilePath: stackPath,
-							reproduceCommand,
-							cwd
-						});
-						return;
-					}
-					emit({
-						kind: "ready",
-						endpoints: await mergedEndpoints(attachments)
-					});
-				} catch (error) {
+		configWatch = watchFiles([{
+			address: configFile,
+			paths: [configFile]
+		}], () => void pausedForConfig(), onWatchError);
+		const rebuild = async () => {
+			try {
+				const rePipeline = await runPipeline(input.entry, input.name, cwd, input.config, watchDeps);
+				const stackPath = writeDevStackFile({
+					entryPath: rePipeline.entryModule.path,
+					cwd,
+					configFile: rePipeline.configSource.file,
+					name: rePipeline.name,
+					assembled: rePipeline.assembled
+				});
+				const outcome = await (deps.alchemy ?? spawnAlchemy)(alchemyInvocation({
+					command: "deploy",
+					stackFileRelativePath: DEV_STACK_RELATIVE_PATH,
+					cwd,
+					stage: "dev",
+					containerEnv: containerEnv(containers)
+				}));
+				if (outcome.signal !== null || outcome.exitCode !== 0) {
 					emit({
-						kind: "rebuild-failed",
-						message: failureMessage(error)
+						kind: "converge-failed",
+						stackFilePath: stackPath,
+						reproduceCommand,
+						cwd
 					});
+					return;
 				}
-			})();
-		}, (error) => emit({
-			kind: "watch-error",
-			message: failureMessage(error)
-		}));
+				emit({
+					kind: "ready",
+					endpoints: await mergedEndpoints(attachments)
+				});
+			} catch (error) {
+				emit({
+					kind: "rebuild-failed",
+					message: failureMessage(error)
+				});
+			}
+		};
+		let rebuilding = false;
+		let changedDuringRebuild = false;
+		const rebuildUntilSettled = async () => {
+			rebuilding = true;
+			do {
+				changedDuringRebuild = false;
+				await rebuild();
+			} while (changedDuringRebuild && !pausedForConfig());
+			rebuilding = false;
+		};
+		watch = watchFiles(targets, () => {
+			if (pausedForConfig()) return;
+			if (rebuilding) {
+				changedDuringRebuild = true;
+				return;
+			}
+			rebuildUntilSettled();
+		}, onWatchError);
 		const startedWatch = watch;
-		await watch.ready;
+		const startedConfigWatch = configWatch;
+		await Promise.all([watch.ready, configWatch.ready]);
 		let stopping = false;
 		let resolveClosed = () => void 0;
 		const closed = new Promise((resolve) => {
@@ -1979,6 +2007,7 @@ async function executeDev(input, deps, cwd) {
 				stopping = true;
 				emit({ kind: "stopping" });
 				startedWatch.stop();
+				startedConfigWatch.stop();
 				(async () => {
 					for (const attachment of attachments) try {
 						await attachment.stopServices();
@@ -2001,6 +2030,7 @@ async function executeDev(input, deps, cwd) {
 		});
 	} catch (error) {
 		watch?.stop();
+		configWatch?.stop();
 		await Promise.all(started.map((a) => a.stopServices().catch(() => void 0)));
 		if (CliStructuredError.is(error)) return notOk(error);
 		throw error;
@@ -2009,4 +2039,4 @@ async function executeDev(input, deps, cwd) {
 //#endregion
 export { executeDev };
 
-//# sourceMappingURL=execute-dev-BLCK5wF7-CuzMSK7T.mjs.map
+//# sourceMappingURL=execute-dev-BICPaq1g-CSoZJuhB.mjs.map