@prisma/composer-prisma-cloud 0.2.0-dev.13 → 0.2.0-dev.15

package/dist/buckets-main.mjs

@@ -1,4 +1,4 @@
-import { i as readOwnVersion, n as isValidSegment, r as readJsonFile, t as StateFile } from "./segments-NpKN-46R-B01DmCqy.mjs";
+import { a as readOwnVersion, i as readJsonFile, r as isValidSegment, t as StateFile } from "./segments-NpKN-46R-C_LQ2urs.mjs";
 import * as fs from "node:fs";
 import * as fs$1 from "node:fs/promises";
 import * as path from "node:path";

package/dist/compute-main.mjs

@@ -1,4 +1,4 @@
-import { i as readOwnVersion, n as isValidSegment, r as readJsonFile, t as StateFile } from "./segments-NpKN-46R-B01DmCqy.mjs";
+import { a as readOwnVersion, i as readJsonFile, r as isValidSegment, t as StateFile } from "./segments-NpKN-46R-C_LQ2urs.mjs";
 import { n as portNumbers, t as getPorts } from "./get-port-BYnpbW5H.mjs";
 import * as fs from "node:fs";
 import { spawn } from "node:child_process";

package/dist/local-target.mjs

@@ -1986,6 +1986,27 @@ function encodeSegment(segment) {
 	if (!isValidSegment(segment)) throw new Error(`invalid path segment "${segment}"`);
 	return encodeURIComponent(segment);
 }
+const ADMIN_FETCH_ATTEMPTS = 3;
+const ADMIN_FETCH_RETRY_DELAY_MS = 150;
+/**
+* `fetch` for the loopback admin calls, retried on transient socket errors:
+* a keep-alive reuse race (the runtime re-uses a pooled connection the
+* daemon's HTTP server just closed idle — surfaces as "fetch failed" /
+* "other side closed") or a briefly overloaded daemon. Every admin call is
+* idempotent by design, so a short blind retry is safe. A caller-driven
+* abort is never retried.
+*/
+async function adminFetch(url, init) {
+	let lastError;
+	for (let attempt = 1; attempt <= ADMIN_FETCH_ATTEMPTS; attempt += 1) try {
+		return await fetch(url, init);
+	} catch (error) {
+		if (init?.signal?.aborted === true) throw error;
+		lastError = error;
+		if (attempt < ADMIN_FETCH_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, ADMIN_FETCH_RETRY_DELAY_MS));
+	}
+	throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
 async function expectOk(res) {
 	if (!res.ok) {
 		const body = await res.text();
@@ -2016,33 +2037,29 @@ function computeClient(opts = {}) {
 	return {
 		baseUrl,
 		async health() {
-			const body = await (await expectOk(await fetch(`${baseUrl}/health`))).json();
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/health`))).json();
 			if (!isHealthBody(body)) throw new Error("malformed /health response from the compute emulator");
 			return body;
 		},
 		async ensureService(app, id) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}`;
-			const body = await (await expectOk(await fetch(url, { method: "PUT" }))).json();
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}`, { method: "PUT" }))).json();
 			if (!isServiceReservation(body)) throw new Error("malformed service-reservation response from the compute emulator");
 			return body;
 		},
 		async putDeployment(app, id, deployment) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/deployment`;
-			await expectOk(await fetch(url, {
+			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/deployment`, {
 				method: "PUT",
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify(deployment)
 			}));
 		},
 		async listServices(app) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/services`;
-			const body = await (await expectOk(await fetch(url))).json();
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services`))).json();
 			if (!isServiceInfoArray(body)) throw new Error("malformed services listing from the compute emulator");
 			return body;
 		},
 		async *followLogs(app, id, signal) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/logs?follow=1`;
-			const body = (await expectOk(await fetch(url, signal ? { signal } : void 0))).body;
+			const body = (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/services/${encodeSegment(id)}/logs?follow=1`, signal ? { signal } : void 0))).body;
 			if (!body) return;
 			const reader = body.getReader();
 			const decoder = new TextDecoder();
@@ -2057,16 +2074,13 @@ function computeClient(opts = {}) {
 			}
 		},
 		async stopApp(app) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/stop`;
-			await expectOk(await fetch(url, { method: "POST" }));
+			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/stop`, { method: "POST" }));
 		},
 		async startApp(app) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/start`;
-			await expectOk(await fetch(url, { method: "POST" }));
+			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/start`, { method: "POST" }));
 		},
 		async deleteApp(app) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}`;
-			await expectOk(await fetch(url, { method: "DELETE" }));
+			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}`, { method: "DELETE" }));
 		}
 	};
 }
@@ -2075,21 +2089,19 @@ function bucketsClient(opts = {}) {
 	return {
 		baseUrl,
 		async health() {
-			const body = await (await expectOk(await fetch(`${baseUrl}/_pcdev/health`))).json();
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/_pcdev/health`))).json();
 			if (!isHealthBody(body)) throw new Error("malformed /_pcdev/health response from the buckets emulator");
 			return body;
 		},
 		async putBucket(app, name, dir) {
-			const url = `${baseUrl}/_pcdev/apps/${encodeSegment(app)}/buckets/${encodeSegment(name)}`;
-			await expectOk(await fetch(url, {
+			await expectOk(await adminFetch(`${baseUrl}/_pcdev/apps/${encodeSegment(app)}/buckets/${encodeSegment(name)}`, {
 				method: "PUT",
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify({ dir })
 			}));
 		},
 		async putCredentials(app, accessKeyId, secretAccessKey) {
-			const url = `${baseUrl}/_pcdev/apps/${encodeSegment(app)}/credentials`;
-			await expectOk(await fetch(url, {
+			await expectOk(await adminFetch(`${baseUrl}/_pcdev/apps/${encodeSegment(app)}/credentials`, {
 				method: "PUT",
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify({
@@ -2099,8 +2111,7 @@ function bucketsClient(opts = {}) {
 			}));
 		},
 		async deleteApp(app) {
-			const url = `${baseUrl}/_pcdev/apps/${encodeSegment(app)}`;
-			await expectOk(await fetch(url, { method: "DELETE" }));
+			await expectOk(await adminFetch(`${baseUrl}/_pcdev/apps/${encodeSegment(app)}`, { method: "DELETE" }));
 		}
 	};
 }
@@ -2118,13 +2129,12 @@ function postgresClient(opts = {}) {
 	return {
 		baseUrl,
 		async health() {
-			const body = await (await expectOk(await fetch(`${baseUrl}/health`))).json();
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/health`))).json();
 			if (!isHealthBody(body)) throw new Error("malformed /health response from the postgres emulator");
 			return body;
 		},
 		async ensureDatabase(app, id, prismaDevModulePath) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/databases/${encodeSegment(id)}`;
-			const body = await (await expectOk(await fetch(url, {
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/databases/${encodeSegment(id)}`, {
 				method: "PUT",
 				headers: { "content-type": "application/json" },
 				body: JSON.stringify({ prismaDevModulePath })
@@ -2133,14 +2143,12 @@ function postgresClient(opts = {}) {
 			return body;
 		},
 		async listDatabases(app) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}/databases`;
-			const body = await (await expectOk(await fetch(url))).json();
+			const body = await (await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}/databases`))).json();
 			if (!isDatabaseInfoArray(body)) throw new Error("malformed databases listing from the postgres emulator");
 			return body;
 		},
 		async deleteApp(app) {
-			const url = `${baseUrl}/apps/${encodeSegment(app)}`;
-			await expectOk(await fetch(url, { method: "DELETE" }));
+			await expectOk(await adminFetch(`${baseUrl}/apps/${encodeSegment(app)}`, { method: "DELETE" }));
 		}
 	};
 }
@@ -5668,6 +5676,32 @@ function servicePortEnvKey(address) {
 		"PORT"
 	].join("_").toUpperCase();
 }
+/** The `COMPOSER_<ADDRESS SEGMENTS>_` prefix every env row this address OWNS carries — `configKey`'s convention (see `servicePortEnvKey`'s doc comment). */
+function ownEnvKeyPrefix(address) {
+	return `${["COMPOSER", ...address.split(".").filter((s) => s.length > 0)].join("_").toUpperCase()}_`;
+}
+const COMPOSER_NAMESPACE_PREFIX = "COMPOSER_";
+/**
+* Scopes `env.json` to what THIS service is allowed to see: rows it owns
+* (`COMPOSER_<its address>_*`) plus every row OUTSIDE the `COMPOSER_`
+* namespace entirely — the poison `DATABASE_URL(_POOLED)` rows are
+* deliberately unprefixed and app-wide (local-dev spec § 4's pinned parity
+* note). The hosted platform materializes the app-wide row set into every
+* deployment but DIFFS a deployment only on its own referenced rows; an
+* app-wide LOCAL materialization restart-amplifies instead — an
+* early-deployed service's snapshot is incomplete on the first converge,
+* "completes" on the second, and diffs as changed. Scoping the content here
+* aligns local restart behavior with the platform's diff scope. The dropped
+* sibling rows have no sanctioned reader: `run()`/`load()` consume only
+* own-address rows, and ambient sibling reads are exactly what the poison
+* rows exist to punish.
+*/
+function scopedEnvRows(allRows, address) {
+	const ownPrefix = ownEnvKeyPrefix(address);
+	const scoped = {};
+	for (const [key, value] of Object.entries(allRows)) if (key.startsWith(ownPrefix) || !key.startsWith(COMPOSER_NAMESPACE_PREFIX)) scoped[key] = value;
+	return scoped;
+}
 function manifestMissingAddressError() {
 	return /* @__PURE__ */ new Error("artifact manifest carries no address — repackage with a current @prisma/composer.");
 }
@@ -5692,8 +5726,24 @@ function readManifestAddress(artifactDir) {
 	if (!isComputeManifest(parsed) || parsed.address === void 0) throw manifestMissingAddressError();
 	return parsed.address;
 }
+/**
+* The Compute emulator's `<id>` path segment must match
+* `/^[a-z0-9][a-z0-9-]*$/` (its API hygiene rule, local-dev spec § 2) — but a
+* service's own address (`news.name`/`news.computeServiceId`) is
+* hierarchical and dot-separated (e.g. `"orders.service"`, a nested
+* module's service). This is the seam: every dot (or other disallowed char)
+* becomes a dash, runs collapse, and the result is what both `ensureService`
+* and `putDeployment` address the emulator with — the REAL address still
+* rides the deployment body's `address` field untouched, so the front door
+* and every listing still show it verbatim (compute-main.ts's `svc.address`
+* is set from that field, not from the id).
+*/
+function slugServiceId(address) {
+	const slug = address.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	return slug.length > 0 ? slug : "svc";
+}
 async function materializeEnv(devDir, address, port) {
-	const env = { ...await envStore(devDir).read() };
+	const env = scopedEnvRows(await envStore(devDir).read(), address);
 	env[servicePortEnvKey(address)] = JSON.stringify(port);
 	const secrets = await secretsStore(devDir).read();
 	for (const [key, value] of Object.entries(secrets)) env[key] = value;
@@ -5712,7 +5762,7 @@ function LocalComputeServiceProvider(input) {
 		reconcile: ({ news }) => Effect.tryPromise({
 			try: async () => {
 				const app = appNameOf(input.container);
-				const { url } = await computeClient().ensureService(app, news.name);
+				const { url } = await computeClient().ensureService(app, slugServiceId(news.name));
 				return {
 					id: news.name,
 					name: news.name,
@@ -5767,12 +5817,13 @@ function LocalDeploymentProvider(input) {
 			try: async () => {
 				const app = appNameOf(input.container);
 				const id = news.computeServiceId;
+				const emulatorId = slugServiceId(id);
 				const artifactDir = path.join(input.devDir, "artifacts", news.artifactHash);
 				if (!fs$1.existsSync(artifactDir)) extractComputeArtifact(news.artifactPath, artifactDir);
 				const address = readManifestAddress(artifactDir);
-				const { port } = await computeClient().ensureService(app, id);
+				const { port } = await computeClient().ensureService(app, emulatorId);
 				const env = await materializeEnv(input.devDir, address, port);
-				await computeClient().putDeployment(app, id, {
+				await computeClient().putDeployment(app, emulatorId, {
 					address,
 					artifactDir,
 					artifactHash: news.artifactHash,
@@ -5860,7 +5911,7 @@ function LocalDatabaseProvider(input) {
 			try: async () => {
 				const app = appNameOf(input.container);
 				const prismaDevModulePath = resolvePrismaDevModulePath(process.cwd());
-				const { url } = await postgresClient().ensureDatabase(app, news.name, prismaDevModulePath);
+				const { url } = await postgresClient().ensureDatabase(app, slug(news.name), prismaDevModulePath);
 				return {
 					id: instanceNameFor(app, news.name),
 					name: news.name,
@@ -5953,7 +6004,7 @@ async function* mergedLogs(app, signal) {
 		wake?.();
 		wake = void 0;
 	};
-	const follow = (id) => {
+	const follow = (id, address) => {
 		if (followed.has(id)) return;
 		followed.add(id);
 		(async () => {
@@ -5964,7 +6015,7 @@ async function* mergedLogs(app, signal) {
 					let newlineAt = buffer.indexOf("\n");
 					while (newlineAt !== -1) {
 						push({
-							service: id,
+							service: address,
 							line: buffer.slice(0, newlineAt)
 						});
 						buffer = buffer.slice(newlineAt + 1);
@@ -5978,7 +6029,7 @@ async function* mergedLogs(app, signal) {
 	};
 	const relist = async () => {
 		const services = await client.listServices(app);
-		for (const svc of services) follow(svc.id);
+		for (const svc of services) follow(svc.id, svc.address);
 	};
 	await relist();
 	const timer = setInterval(() => void relist(), RELIST_INTERVAL_MS);
@@ -6006,6 +6057,7 @@ async function devAttach(input) {
 	const app = prismaCloudContainerOf(input.container).input.appName;
 	const client = computeClient();
 	return {
+		startServices: () => client.startApp(app),
 		endpoints: async () => {
 			return (await client.listServices(app)).map((svc) => ({
 				address: svc.address,