@prisma/composer 0.28.0 → 0.29.0-dev.1

package/dist/node-control.mjs

@@ -21665,15 +21665,16 @@ var import_out = require_out();
 * app's code.
 *
 * Two forms, chosen by the descriptor: without `dir`, `entry` is a single
-* self-contained file and only that file is copied. With `dir`, the whole
-* directory is copied verbatim and `entry` names the file inside it that boots.
-* The directory form also follows the declared entry's static runtime dependency
-* graph and stages those files beside the output. The staging root is derived
-* from the declared paths and the traced files themselves — never from the
-* deploy cwd — so the bundle's layout is the same whichever directory the
-* deploy is invoked from. This is deterministic dependency assembly (not app
+* file and only that file is copied. With `dir`, the whole directory is copied
+* verbatim and `entry` names the file inside it that boots. Either form with
+* `dependencies: 'external'` also follows the declared entry's static runtime
+* dependency graph and stages those files beside the output. The staging root
+* is derived from the declared paths and the traced files themselves — never
+* from the deploy cwd — so the bundle's layout is the same whichever directory
+* the deploy is invoked from. This is deterministic dependency assembly (not app
 * bundling), and is what makes framework outputs such as Astro's Node adapter
-* self-contained.
+* self-contained. With the default, `dependencies: 'bundled'`, nothing is
+* traced: the author's build already inlined its packages.
 *
 * The wrapper is a SEPARATE esbuild build of the service module (declarations
 * only, whose node carries run()/load()), emitted as `main.mjs` at the
@@ -21688,8 +21689,13 @@ var import_out = require_out();
 */
 /** Narrows the shared BuildAdapter to this extension's own descriptor — the value-level mirror of the registry routing on (extension, type). `dir` is optional: absent is the single-file form. */
 function isNodeBuild(descriptor) {
-	return descriptor.type === "node" && (!("dir" in descriptor) || typeof descriptor.dir === "string");
+	return descriptor.type === "node" && (!("dir" in descriptor) || typeof descriptor.dir === "string") && (!("dependencies" in descriptor) || descriptor.dependencies === "bundled" || descriptor.dependencies === "external");
 }
+const allowedDependencies = [
+	void 0,
+	"bundled",
+	"external"
+];
 /** The single-file form: `entry` is the whole built runnable, resolved against dirname(module) (ADR-0004). */
 function resolveFile(entrySpec, moduleDir) {
 	const entryPath = path$1.resolve(moduleDir, entrySpec);
@@ -21776,13 +21782,13 @@ function stagedRuntimePath(source, stagingRoot, bundleDir) {
 	const stagedSegments = nodeModules === -1 ? segments : segments.slice(nodeModules);
 	return path$1.join(bundleDir, ...stagedSegments);
 }
-async function copyTracedEntry(source, destination, stagingRoot, bundleDir, dirPath) {
+async function copyTracedEntry(source, destination, stagingRoot, bundleDir, copied) {
 	const stat = await fs$1.promises.lstat(source);
 	await fs$1.promises.mkdir(path$1.dirname(destination), { recursive: true });
 	if (stat.isSymbolicLink()) {
 		const realTarget = await fs$1.promises.realpath(source);
 		if (!isWithin(stagingRoot, realTarget)) throw new Error(`the runtime dependency trace found a symlink outside its staging root: ${source} -> ${realTarget}`);
-		const stagedTarget = isWithin(dirPath, realTarget) ? path$1.join(bundleDir, path$1.relative(dirPath, realTarget)) : stagedRuntimePath(realTarget, stagingRoot, bundleDir);
+		const stagedTarget = isWithin(copied.source, realTarget) ? path$1.join(copied.at, path$1.relative(copied.source, realTarget)) : stagedRuntimePath(realTarget, stagingRoot, bundleDir);
 		await createBundleLink(destination, path$1.relative(path$1.dirname(destination), stagedTarget), (await fs$1.promises.stat(realTarget)).isDirectory() ? "dir" : "file", {
 			resolvedTarget: stagedTarget,
 			copySource: realTarget,
@@ -21809,19 +21815,20 @@ async function copyTracedEntry(source, destination, stagingRoot, bundleDir, dirP
 * would stage arbitrary reachable files. The path that widened it is named so
 * the author can see which dependency caused it.
 */
-function stagingRootFor(moduleDir, dirPath, tracedPaths) {
-	let root = commonAncestor(moduleDir, dirPath);
-	if (isFilesystemRoot(root)) throw new Error(`the build adapter's dir ("${dirPath}") and the directory of its module ("${moduleDir}") share no common ancestor below the filesystem root, so runtime dependency staging has no root to work from.`);
+function stagingRootFor(moduleDir, outputPath, tracedPaths) {
+	let root = commonAncestor(moduleDir, outputPath);
+	if (isFilesystemRoot(root)) throw new Error(`the build output ("${outputPath}") and the directory of its module ("${moduleDir}") share no common ancestor below the filesystem root, so runtime dependency staging has no root to work from.`);
 	for (const traced of tracedPaths) {
 		const widened = commonAncestor(root, traced);
-		if (isFilesystemRoot(widened)) throw new Error(`the runtime dependency trace reached ${traced}, which shares no directory with the build output ("${dirPath}") below the filesystem root — staging from there would sweep in arbitrary files. Keep the traced dependency inside the project that holds the build output.`);
+		if (isFilesystemRoot(widened)) throw new Error(`the runtime dependency trace reached ${traced}, which shares no directory with the build output ("${outputPath}") below the filesystem root — staging from there would sweep in arbitrary files. Keep the traced dependency inside the project that holds the build output.`);
 		root = widened;
 	}
 	return root;
 }
-/** Stages the explicit entry's runtime file graph beside the copied build dir.
+/** Stages the explicit entry's runtime file graph beside the copied build output.
 * `nodeFileTrace` follows import/require/package metadata; it does not rewrite
-* the app. Files already supplied by `dir` remain the author's verbatim copy.
+* the app. Files already supplied by the build output (`dir`, or the single
+* entry file) remain the author's verbatim copy.
 *
 * The trace itself runs from the filesystem root so nothing it finds is dropped
 * for sitting outside a narrower base — a pnpm virtual store at the workspace
@@ -21834,11 +21841,15 @@ function stagingRootFor(moduleDir, dirPath, tracedPaths) {
 * trace never visits, while nft's `conditions` option replaces the default
 * set rather than extending it. */
 async function stageRuntimeDependencies(options) {
-	const [moduleDir, entryPath, dirPath] = await Promise.all([
+	const [moduleDir, entryPath, outputPath] = await Promise.all([
 		fs$1.promises.realpath(options.moduleDir),
 		fs$1.promises.realpath(options.entryPath),
-		fs$1.promises.realpath(options.dirPath)
+		fs$1.promises.realpath(options.outputPath)
 	]);
+	const copied = {
+		source: outputPath,
+		at: options.outputAt
+	};
 	const base = path$1.parse(moduleDir).root;
 	const [nodeTrace, bunTrace] = await Promise.all([(0, import_out.nodeFileTrace)([entryPath], {
 		base,
@@ -21856,11 +21867,11 @@ async function stageRuntimeDependencies(options) {
 			origin: await realPathOrSelf(source)
 		};
 	}));
-	const stagingRoot = stagingRootFor(moduleDir, dirPath, tracedEntries.flatMap(({ source, origin }) => [source, origin]));
+	const stagingRoot = stagingRootFor(moduleDir, outputPath, tracedEntries.flatMap(({ source, origin }) => [source, origin]));
 	const stagedFrom = /* @__PURE__ */ new Map();
 	let bytesStaged = 0;
 	for (const { source, origin } of tracedEntries) {
-		if (isWithin(dirPath, source)) continue;
+		if (isWithin(outputPath, source)) continue;
 		const destination = stagedRuntimePath(source, stagingRoot, options.bundleDir);
 		const alreadyStaged = stagedFrom.get(destination);
 		if (alreadyStaged !== void 0) {
@@ -21868,7 +21879,7 @@ async function stageRuntimeDependencies(options) {
 			throw new Error(`two runtime dependencies stage to the same bundle path ("${path$1.relative(options.bundleDir, destination).split(path$1.sep).join("/")}"): ${alreadyStaged} and ${origin}. Staging keeps each file's path from its first node_modules segment, so two packages of the same name installed at different depths collapse onto one location — deduplicate them in your install so only one version is reachable.`);
 		}
 		if (await pathExists(destination)) continue;
-		bytesStaged += await copyTracedEntry(source, destination, stagingRoot, options.bundleDir, dirPath);
+		bytesStaged += await copyTracedEntry(source, destination, stagingRoot, options.bundleDir, copied);
 		stagedFrom.set(destination, origin);
 	}
 	return {
@@ -21888,8 +21899,10 @@ function assertOutsideWorkDir(runnable, workDir) {
 	if (workDir.startsWith(source + path$1.sep)) throw new Error(`the deploy working dir ("${workDir}") sits inside the build adapter's ${sourceField} ("${source}"), so assembling would copy the artifact into itself — point ${sourceField} at your build output elsewhere.`);
 }
 async function assemble(input) {
+	if ("dependencies" in input.build && !allowedDependencies.includes(input.build.dependencies)) throw new Error(`the node build adapter's dependencies must be 'bundled' or 'external', got "${String(input.build.dependencies)}"`);
 	if (!isNodeBuild(input.build)) throw new Error(`@prisma/composer/node/control: expected a "node" build adapter, got "${input.build.type}".`);
 	const buildDescriptor = input.build;
+	const dependencies = buildDescriptor.dependencies ?? "bundled";
 	const serviceModule = fileURLToPath(buildDescriptor.module);
 	const moduleDir = path$1.dirname(serviceModule);
 	const runnable = buildDescriptor.dir === void 0 ? resolveFile(buildDescriptor.entry, moduleDir) : await resolveDir(buildDescriptor.dir, buildDescriptor.entry, moduleDir);
@@ -21912,17 +21925,23 @@ async function assemble(input) {
 	if (!fs$1.existsSync(path$1.join(workDir, "main.mjs"))) throw new Error(`esbuild produced no main.mjs in ${workDir}`);
 	const bundleDir = path$1.join(workDir, "bundle");
 	await runnable.copyInto(bundleDir);
-	if (buildDescriptor.dir === void 0) input.report?.({ form: "file" });
+	const form = buildDescriptor.dir === void 0 ? "file" : "directory";
+	if (dependencies === "bundled") input.report?.({
+		form,
+		dependencies
+	});
 	else {
-		const staged = await stageRuntimeDependencies({
-			entryPath: path$1.join(runnable.source, ...runnable.entry.split("/")),
-			dirPath: runnable.source,
+		const counts = await stageRuntimeDependencies({
+			entryPath: form === "file" ? runnable.source : path$1.join(runnable.source, ...runnable.entry.split("/")),
+			outputPath: runnable.source,
+			outputAt: form === "file" ? path$1.join(bundleDir, runnable.entry) : bundleDir,
 			moduleDir,
 			bundleDir
 		});
 		input.report?.({
-			form: "directory",
-			...staged
+			form,
+			dependencies,
+			...counts
 		});
 	}
 	await assertBundleSymlinksStayInside(bundleDir);