@prisma/composer-prisma-cloud 0.2.0 → 0.3.0-dev.1

package/dist/postgres-main.mjs

@@ -0,0 +1,602 @@
+import { a as readOwnVersion, i as readJsonFile, n as isPidAlive, 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 * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import * as http from "node:http";
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/instance-name-BF6J_weL.mjs
+/**
+* `pcdev-<app>-<database-id>` instance-name derivation (local-dev spec § 2
+* `postgres-main.ts`): each half lowercased, every char outside `[a-z0-9]`
+* replaced by `-`, runs collapsed, the combined name trimmed to 63 chars.
+*
+* A separate, side-effect-free module (not defined inline in
+* `postgres-main.ts`) so it can be imported directly by tests without also
+* running that file's own `main()` — `postgres-main.ts` is a daemon
+* entrypoint script, always invoked as a subprocess, and calls `main()`
+* unconditionally at module load.
+*/
+/**
+* Deliberately linear, no ambiguous quantifiers: a per-character replace
+* (no `+`, so no run-length backtracking surface), a bounded-quantifier
+* collapse (`{2,}`, not alternation-with-quantifiers), and plain
+* index-walking for the leading/trailing trim instead of a regex — a
+* combined `+`-plus-alternation trim (`/^-+|-+$/g`) is exactly the shape
+* CodeQL's polynomial-ReDoS check flags, whether or not this particular
+* instance is provably safe.
+*/
+function slug(segment) {
+	const collapsed = segment.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-{2,}/g, "-");
+	let start = 0;
+	let end = collapsed.length;
+	while (start < end && collapsed[start] === "-") start++;
+	while (end > start && collapsed[end - 1] === "-") end--;
+	return collapsed.slice(start, end);
+}
+function instanceNameFor(app, id) {
+	return `pcdev-${slug(app)}-${slug(id)}`.slice(0, 63);
+}
+//#endregion
+//#region ../../1-prisma-cloud/0-lowering/dev-emulators/dist/postgres-main.mjs
+/**
+* The Postgres emulator daemon (local-dev spec § 2 `postgres-main.ts`): a
+* small local counterpart of hosted Postgres, hosting `@prisma/dev`'s
+* `startPrismaDevServer()` — one named, persistent server per `Database`
+* resource, several servers in this one daemon process. Loopback
+* `node:http` JSON admin API; state under its `--state-dir`.
+*
+* `@prisma/dev` is imported dynamically from a CALLER-RESOLVED path (each
+* admin request that needs it carries `prismaDevModulePath`) so the app
+* owns its own Prisma version — this daemon has no `@prisma/dev` dependency
+* of its own.
+*
+* Runs as its own OS process, started by `daemon.ts`'s `ensureDaemon` via
+* `process.execPath <this file> --port <n> --state-dir <dir>`.
+*/
+const MIN_DATABASE_PORT = 51300;
+const MAX_DATABASE_PORT = 65535;
+const APPS_STATE_MODE = 384;
+/** Spec § 2 step 5's pattern, applied to a fresh database-port allocation. */
+const MAX_FRESH_PORT_CANDIDATES = 5;
+/**
+* A name refused as "already running" is retried a few times, each attempt
+* first waiting out the holder: a cold server boot takes seconds, and a
+* crashed holder's lock is only released once proper-lockfile's ~10s stale
+* threshold passes. Bounded so a genuinely stuck name still fails visibly
+* inside the dev command's own startup budget.
+*/
+const MAX_ALREADY_RUNNING_RETRIES = 2;
+const ALREADY_RUNNING_POLLS = 24;
+const ALREADY_RUNNING_POLL_MS = 500;
+const NOT_INSTALLED_MESSAGE = "local dev needs @prisma/dev for its local Postgres emulator — add \"prisma\" to your app's devDependencies.";
+function maskCredentials(text) {
+	return text.replace(/:\/\/([^:@/\s]+):[^@/\s]+@/g, "://$1:***@");
+}
+function firstLine(text) {
+	return (text.split("\n")[0] ?? text).trim();
+}
+function isDatabaseRecord(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "instanceName" in value && typeof value.instanceName === "string" && "databasePort" in value && typeof value.databasePort === "number" && "url" in value && typeof value.url === "string";
+}
+function isAppRecord(value) {
+	return typeof value === "object" && value !== null && "databases" in value && typeof value.databases === "object" && value.databases !== null && Object.values(value.databases).every(isDatabaseRecord);
+}
+function isAppsState(value) {
+	return typeof value === "object" && value !== null && Object.values(value).every(isAppRecord);
+}
+function isDatabaseBody(value) {
+	return typeof value === "object" && value !== null && "prismaDevModulePath" in value && typeof value.prismaDevModulePath === "string";
+}
+function isPrismaDevModule(value) {
+	return typeof value === "object" && value !== null && "startPrismaDevServer" in value && typeof value.startPrismaDevServer === "function";
+}
+/**
+* `@prisma/dev` exports a `PortNotAvailableError` class with a `readonly
+* port: number`, but the daemon dynamically imports the module from a
+* caller-given path while the class identity checked here would come from
+* whatever module graph THIS file's own bundle produced — two separate
+* instantiations of the same logical class, so `instanceof` doesn't match
+* across them (confirmed empirically: a real port conflict's `err
+* instanceof mod.PortNotAvailableError` is `false` even though the error IS
+* the port-conflict one). Duck-typing the documented shape — a `port`
+* number matching the candidate we just tried — is what actually survives
+* that boundary.
+*/
+/**
+* The port a start refusal is about, when it is one of THIS attempt's ports.
+* Duck-typed (`instanceof` fails across the dynamic-import boundary): every
+* `@prisma/dev` port refusal — not-available, requested-twice, and
+* belongs-to-another-server (its registry can claim a port no bind probe
+* sees) — carries the offending port as `.port`, and any of the four ports
+* we requested (database + the three aux listeners) can be the one refused.
+*/
+function portConflictOf(err, ports) {
+	if (typeof err !== "object" || err === null || !("port" in err)) return void 0;
+	const port = err.port;
+	return typeof port === "number" && ports.includes(port) ? port : void 0;
+}
+function isNameAlreadyTaken(err) {
+	return isStringKeyedRecord(err) && (err["name"] === "ServerAlreadyRunningError" || err["name"] === "ServerStateAlreadyExistsError");
+}
+/** The port of a postgres connection URL, when it parses as one. */
+function databasePortOf(connectionString) {
+	try {
+		const port = Number(new URL(connectionString).port);
+		return Number.isInteger(port) && port > 0 ? port : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* A dynamic `import()` failure's own message routinely names a SECOND path
+* (e.g. bun's "Cannot find module '<target>' from '<importer>'") — the
+* importer half is this daemon's own internal location, not anything the
+* caller gave us, and has no business in a response body. Rather than try
+* to scrub an arbitrary underlying message for every runtime's own error
+* phrasing, the resolution-failure case names only what the caller
+* supplied — the pinned message plus the given `prismaDevModulePath`, and
+* nothing else. (A DIFFERENT case — a module that resolves fine but whose
+* `startPrismaDevServer()` call itself fails — still surfaces its
+* underlying text verbatim, credential-masked, per spec § 2.)
+*/
+async function importPrismaDev(prismaDevModulePath) {
+	let mod;
+	try {
+		mod = await import(pathToFileURL(prismaDevModulePath).href);
+	} catch {
+		throw new Error(`${NOT_INSTALLED_MESSAGE} (could not resolve "${prismaDevModulePath}")`);
+	}
+	if (!isPrismaDevModule(mod)) throw new Error(`${NOT_INSTALLED_MESSAGE} ("${prismaDevModulePath}" is not a @prisma/dev module)`);
+	return mod;
+}
+function isStringKeyedRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPrismaDevInternalStateModule(value) {
+	return isStringKeyedRecord(value) && typeof value["deleteServer"] === "function" && typeof value["killServer"] === "function" && typeof value["getServerStatus"] === "function";
+}
+/**
+* Every port any `@prisma/dev` server RECORD on this machine claims —
+* database, http, shadow, and streams. `startPrismaDevServer` validates a
+* requested port against these records (`ServerState.scan`) and refuses one
+* that any record claims, even when nothing has it bound — and a record's
+* aux ports are picked by `@prisma/dev`'s own walking-upward picker, which
+* over enough servers climbs into this daemon's database range. A fresh
+* database-port pick that only probed the OS would collide with such a
+* claim, so fresh picks exclude these too. Best-effort: `scan` is the same
+* internal surface the rest of this module already binds to, but absent or
+* failing it degrades to the OS probe alone.
+*/
+async function registryClaimedPorts(internalState) {
+	const ports = /* @__PURE__ */ new Set();
+	const scanHost = isStringKeyedRecord(internalState) ? internalState["ServerState"] : void 0;
+	const scan = isStringKeyedRecord(scanHost) ? scanHost["scan"] : void 0;
+	if (!isStringKeyedRecord(scanHost) || typeof scan !== "function") return ports;
+	try {
+		const records = await scan.call(scanHost, { onlyMetadata: true });
+		if (!Array.isArray(records)) return ports;
+		for (const record of records) {
+			if (!isStringKeyedRecord(record)) continue;
+			for (const key of [
+				"databasePort",
+				"port",
+				"shadowDatabasePort",
+				"streamsPort"
+			]) {
+				const port = record[key];
+				if (typeof port === "number" && Number.isInteger(port) && port > 0) ports.add(port);
+			}
+			const experimental = record["experimental"];
+			const streams = isStringKeyedRecord(experimental) ? experimental["streams"] : void 0;
+			const streamsUrl = isStringKeyedRecord(streams) ? streams["serverUrl"] : void 0;
+			if (typeof streamsUrl === "string") {
+				const port = databasePortOf(streamsUrl);
+				if (port !== void 0) ports.add(port);
+			}
+		}
+	} catch {}
+	return ports;
+}
+function readServerStatus(status) {
+	if (!isStringKeyedRecord(status)) return {
+		live: false,
+		recordExists: true,
+		pid: void 0,
+		url: void 0,
+		databasePort: void 0
+	};
+	const exports = status["exports"];
+	const database = isStringKeyedRecord(exports) ? exports["database"] : void 0;
+	const url = isStringKeyedRecord(database) ? database["connectionString"] : void 0;
+	const pid = status["pid"];
+	const databasePort = status["databasePort"];
+	return {
+		live: status["status"] === "running" || status["status"] === "starting_up",
+		recordExists: status["status"] !== "no_such_server",
+		pid: typeof pid === "number" ? pid : void 0,
+		url: typeof url === "string" ? url : void 0,
+		databasePort: typeof databasePort === "number" ? databasePort : void 0
+	};
+}
+async function serverStatusOf(internalState, instanceName) {
+	try {
+		return readServerStatus(await internalState.getServerStatus(instanceName));
+	} catch {
+		return {
+			live: false,
+			recordExists: true,
+			pid: void 0,
+			url: void 0,
+			databasePort: void 0
+		};
+	}
+}
+const CLOSE_SETTLE_ATTEMPTS = 40;
+const CLOSE_SETTLE_DELAY_MS = 250;
+/** True once the named server's persisted state no longer claims it is live — the precondition for `deleteServer`, whose kill path targets the pid in that state, which for an in-daemon server is THIS DAEMON's own pid. */
+async function settledAfterClose(internalState, instanceName) {
+	for (let attempt = 1; attempt <= CLOSE_SETTLE_ATTEMPTS; attempt += 1) {
+		if (!(await serverStatusOf(internalState, instanceName)).live) return true;
+		if (attempt < CLOSE_SETTLE_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, CLOSE_SETTLE_DELAY_MS));
+	}
+	return false;
+}
+/**
+* `@prisma/dev`'s own package.json declares `./internal/state`, whose
+* `deleteServer(name)` actually removes a stateful server's persisted PGlite
+* data — `startPrismaDevServer`'s public surface only starts/closes a live
+* server, never deletes what a closed one left on disk. Resolved by reading
+* the SAME package's own `exports` map (walked up from the caller-given
+* entry path to find `@prisma/dev`'s `package.json`), never by guessing at
+* `dist/` file layout.
+*/
+async function importPrismaDevInternalState(prismaDevModulePath) {
+	let dir = path.dirname(prismaDevModulePath);
+	for (;;) {
+		const pkgPath = path.join(dir, "package.json");
+		if (fs.existsSync(pkgPath)) {
+			const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+			if (isStringKeyedRecord(pkg) && pkg["name"] === "@prisma/dev" && isStringKeyedRecord(pkg["exports"])) {
+				const entry = pkg["exports"]["./internal/state"];
+				const target = resolveExportTarget(entry);
+				if (target === void 0) throw new Error(`"@prisma/dev" at "${dir}" does not declare an "./internal/state" export — cannot delete its persisted database data.`);
+				const mod = await import(pathToFileURL(path.join(dir, target)).href);
+				if (isPrismaDevInternalStateModule(mod)) return mod;
+				throw new Error(`"@prisma/dev"'s "./internal/state" export at "${dir}" has no deleteServer.`);
+			}
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) throw new Error(`could not find "@prisma/dev"'s package.json above "${prismaDevModulePath}".`);
+		dir = parent;
+	}
+}
+function resolveExportTarget(entry) {
+	if (typeof entry === "string") return entry;
+	if (!isStringKeyedRecord(entry)) return void 0;
+	const nested = entry["import"] ?? entry["require"] ?? entry["default"];
+	if (typeof nested === "string") return nested;
+	if (isStringKeyedRecord(nested)) {
+		const def = nested["default"];
+		if (typeof def === "string") return def;
+	}
+}
+function parseArgs(argv) {
+	let port;
+	let stateDir;
+	for (let i = 0; i < argv.length; i++) if (argv[i] === "--port") port = Number(argv[i + 1]);
+	else if (argv[i] === "--state-dir") stateDir = argv[i + 1];
+	if (port === void 0 || Number.isNaN(port)) throw new Error("postgres-main: --port <n> is required");
+	if (stateDir === void 0) throw new Error("postgres-main: --state-dir <dir> is required");
+	return {
+		port,
+		stateDir
+	};
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+function main() {
+	const { port, stateDir } = parseArgs(process.argv.slice(2));
+	const ownVersion = readOwnVersion();
+	const appsJsonPath = path.join(stateDir, "apps.json");
+	const stateFile = new StateFile(appsJsonPath, APPS_STATE_MODE);
+	let state = {};
+	const runtimes = /* @__PURE__ */ new Map();
+	/**
+	* Server starts run ONE AT A TIME. `@prisma/dev`'s start is not
+	* concurrency-safe within a process: two simultaneous calls pick their
+	* ports without seeing each other and one fails with a port refusal
+	* (verified directly — two concurrent starts with distinct, pinned
+	* database ports fail; the same two started in sequence both succeed).
+	* The daemon issues concurrent starts whenever an app converges more than
+	* one database, which is what produced the port refusals, the retries
+	* whose half-started servers held their own name's lock, and every
+	* "already running" failure downstream of that.
+	*/
+	let startQueue = Promise.resolve();
+	function serializeStart(run) {
+		const next = startQueue.then(run, run);
+		startQueue = next.then(() => void 0, () => void 0);
+		return next;
+	}
+	function schedulePersist() {
+		stateFile.write(state);
+	}
+	function getOrCreateApp(app) {
+		let appRec = state[app];
+		if (!appRec) {
+			appRec = { databases: {} };
+			state[app] = appRec;
+		}
+		return appRec;
+	}
+	function usedDatabasePorts() {
+		const ports = /* @__PURE__ */ new Set();
+		for (const appRec of Object.values(state)) for (const db of Object.values(appRec.databases)) ports.add(db.databasePort);
+		return ports;
+	}
+	async function smallestUnusedDatabasePort(min, alsoExclude = /* @__PURE__ */ new Set()) {
+		return getPorts({
+			port: portNumbers(min, MAX_DATABASE_PORT),
+			exclude: [...usedDatabasePorts(), ...alsoExclude]
+		});
+	}
+	const inflightEnsures = /* @__PURE__ */ new Map();
+	/**
+	* Names whose `startPrismaDevServer` call failed in THIS process for any
+	* reason other than "already running". `@prisma/dev` acquires the name's
+	* lock before it validates the requested ports, and a failure after that
+	* point (a port refusal) propagates WITHOUT releasing the lock — so the
+	* very next start of the same name in this process is refused as "already
+	* running" by a holder that is this daemon's own dead attempt, and no
+	* amount of waiting frees it. Membership here is what makes deleting that
+	* lock provably safe: a name this process leaked cannot have been
+	* acquired by anyone else since (the leak never releases).
+	*/
+	const leakedStartNames = /* @__PURE__ */ new Set();
+	/** Concurrent PUTs for the same database coalesce onto one start — a second `startPrismaDevServer` for a name whose first start is still booting fails as "already running". */
+	function ensureDatabase(app, id, prismaDevModulePath) {
+		const instanceName = instanceNameFor(app, id);
+		const inflight = inflightEnsures.get(instanceName);
+		if (inflight) return inflight;
+		const run = ensureDatabaseSerialized(app, id, prismaDevModulePath, instanceName).finally(() => {
+			inflightEnsures.delete(instanceName);
+		});
+		inflightEnsures.set(instanceName, run);
+		return run;
+	}
+	async function ensureDatabaseSerialized(app, id, prismaDevModulePath, instanceName) {
+		const appRec = getOrCreateApp(app);
+		const existingRecord = appRec.databases[id];
+		const runningServer = runtimes.get(instanceName);
+		if (existingRecord && runningServer) return { url: existingRecord.url };
+		const prismaDev = await importPrismaDev(prismaDevModulePath);
+		const internalState = await importPrismaDevInternalState(prismaDevModulePath);
+		const recorded = await serverStatusOf(internalState, instanceName);
+		if (recorded.live && recorded.pid !== void 0 && isPidAlive(recorded.pid)) {
+			if (recorded.url !== void 0) {
+				appRec.databases[id] = {
+					id,
+					instanceName,
+					databasePort: recorded.databasePort ?? databasePortOf(recorded.url) ?? MIN_DATABASE_PORT,
+					url: recorded.url
+				};
+				schedulePersist();
+				return { url: recorded.url };
+			}
+		} else if (recorded.live) await internalState.killServer(instanceName).catch(() => void 0);
+		const isFreshAllocation = existingRecord === void 0;
+		const registryPorts = await registryClaimedPorts(internalState);
+		let dbPort = existingRecord?.databasePort ?? 0;
+		const conflicted = /* @__PURE__ */ new Set();
+		let alreadyRunningRetries = 0;
+		let blindRetries = 0;
+		for (let attempt = 1;; attempt++) {
+			const auxPorts = [];
+			try {
+				const server = await serializeStart(async () => {
+					if (isFreshAllocation) dbPort = await smallestUnusedDatabasePort(MIN_DATABASE_PORT, /* @__PURE__ */ new Set([...registryPorts, ...conflicted]));
+					const auxExclude = /* @__PURE__ */ new Set([
+						...registryPorts,
+						...conflicted,
+						dbPort
+					]);
+					const pickAux = async () => {
+						const port = await smallestUnusedDatabasePort(MIN_DATABASE_PORT, auxExclude);
+						auxExclude.add(port);
+						auxPorts.push(port);
+						return port;
+					};
+					const httpPort = await pickAux();
+					const shadowPort = await pickAux();
+					const streamsPort = await pickAux();
+					return prismaDev.startPrismaDevServer({
+						name: instanceName,
+						databasePort: dbPort,
+						port: httpPort,
+						shadowDatabasePort: shadowPort,
+						streamsPort,
+						persistenceMode: "stateful"
+					});
+				});
+				const url = server.database.connectionString;
+				leakedStartNames.delete(instanceName);
+				runtimes.set(instanceName, server);
+				appRec.databases[id] = {
+					id,
+					instanceName,
+					databasePort: dbPort,
+					url
+				};
+				schedulePersist();
+				return { url };
+			} catch (err) {
+				if (isNameAlreadyTaken(err) && alreadyRunningRetries < MAX_ALREADY_RUNNING_RETRIES) {
+					alreadyRunningRetries += 1;
+					if (leakedStartNames.has(instanceName)) {
+						if (!(await serverStatusOf(internalState, instanceName)).recordExists) {
+							await internalState.deleteServer(instanceName).catch(() => void 0);
+							continue;
+						}
+					}
+					for (let poll = 1; poll <= ALREADY_RUNNING_POLLS; poll += 1) {
+						const now = await serverStatusOf(internalState, instanceName);
+						if (now.live && now.pid !== void 0 && isPidAlive(now.pid) && now.url !== void 0) {
+							appRec.databases[id] = {
+								id,
+								instanceName,
+								databasePort: now.databasePort ?? databasePortOf(now.url) ?? dbPort,
+								url: now.url
+							};
+							schedulePersist();
+							return { url: now.url };
+						}
+						if (now.live && (now.pid === void 0 || !isPidAlive(now.pid))) {
+							await internalState.killServer(instanceName).catch(() => void 0);
+							break;
+						}
+						await new Promise((resolve) => setTimeout(resolve, ALREADY_RUNNING_POLL_MS));
+					}
+					continue;
+				}
+				if (!isNameAlreadyTaken(err)) leakedStartNames.add(instanceName);
+				const conflictPort = portConflictOf(err, [dbPort, ...auxPorts]);
+				if (!(conflictPort !== void 0 && attempt < MAX_FRESH_PORT_CANDIDATES && (conflictPort !== dbPort || isFreshAllocation))) {
+					if (conflictPort === void 0 && !isNameAlreadyTaken(err) && blindRetries < 2) {
+						blindRetries += 1;
+						continue;
+					}
+					const reason = err instanceof Error ? err.message : String(err);
+					throw new Error(`postgres emulator failed to start database "${instanceName}" on port ${String(dbPort)}: ${maskCredentials(firstLine(reason))}`);
+				}
+				conflicted.add(conflictPort);
+			}
+		}
+	}
+	async function deleteApp(app, prismaDevModulePathHint) {
+		const appRec = state[app];
+		if (!appRec) return;
+		const entries = Object.values(appRec.databases);
+		for (const db of entries) {
+			const server = runtimes.get(db.instanceName);
+			if (server) {
+				await server.close().catch(() => void 0);
+				runtimes.delete(db.instanceName);
+			}
+		}
+		if (entries.length > 0 && prismaDevModulePathHint) {
+			const internalState = await importPrismaDevInternalState(prismaDevModulePathHint);
+			for (const db of entries) {
+				if (!runtimes.has(db.instanceName)) {
+					if ((await serverStatusOf(internalState, db.instanceName)).pid !== process.pid) await internalState.killServer(db.instanceName).catch(() => void 0);
+				}
+				if (!await settledAfterClose(internalState, db.instanceName)) {
+					console.error(`postgres-main: server "${db.instanceName}" still reports running after close — leaving its persisted data in place instead of risking a self-kill.`);
+					continue;
+				}
+				await internalState.deleteServer(db.instanceName);
+			}
+		}
+		delete state[app];
+		schedulePersist();
+	}
+	function json(res, status, body) {
+		res.writeHead(status, { "content-type": "application/json" });
+		res.end(JSON.stringify(body));
+	}
+	function text(res, status, body) {
+		res.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+		res.end(body);
+	}
+	function badSegment(res, segment) {
+		text(res, 400, `invalid path segment "${segment}": must match /^[a-z0-9][a-z0-9-]*$/ and be at most 63 characters`);
+	}
+	function databaseView(db) {
+		return {
+			id: db.id,
+			url: db.url,
+			instanceName: db.instanceName,
+			databasePort: db.databasePort
+		};
+	}
+	/** The most recently observed `prismaDevModulePath` for any database of `app` — DELETE has no body of its own to carry one. */
+	const recentPrismaDevModulePath = /* @__PURE__ */ new Map();
+	function lastKnownPrismaDevModulePath(app) {
+		return recentPrismaDevModulePath.get(app);
+	}
+	async function handleRequest(req, res) {
+		const url = new URL(req.url ?? "/", `http://127.0.0.1:${String(port)}`);
+		const method = req.method ?? "GET";
+		const segments = url.pathname.split("/").filter((s) => s.length > 0).map((s) => decodeURIComponent(s));
+		if (method === "GET" && segments.length === 1 && segments[0] === "health") return json(res, 200, { version: ownVersion });
+		if (segments[0] === "apps" && segments.length >= 2) {
+			const app = segments[1];
+			if (app === void 0 || !isValidSegment(app)) return badSegment(res, app ?? "");
+			if (method === "PUT" && segments.length === 4 && segments[2] === "databases") {
+				const id = segments[3];
+				if (id === void 0 || !isValidSegment(id)) return badSegment(res, id ?? "");
+				const raw = await readBody(req);
+				let parsed;
+				try {
+					parsed = JSON.parse(raw.toString("utf8"));
+				} catch {
+					return text(res, 400, "malformed JSON body");
+				}
+				if (!isDatabaseBody(parsed)) return text(res, 400, "malformed database body: expected { \"prismaDevModulePath\": string }");
+				recentPrismaDevModulePath.set(app, parsed.prismaDevModulePath);
+				return json(res, 200, await ensureDatabase(app, id, parsed.prismaDevModulePath));
+			}
+			if (method === "GET" && segments.length === 3 && segments[2] === "databases") {
+				const appRec = state[app];
+				return json(res, 200, appRec ? Object.values(appRec.databases).map(databaseView) : []);
+			}
+			if (method === "DELETE" && segments.length === 2) {
+				await deleteApp(app, lastKnownPrismaDevModulePath(app));
+				res.writeHead(204);
+				res.end();
+				return;
+			}
+		}
+		res.writeHead(404);
+		res.end();
+	}
+	const server = http.createServer((req, res) => {
+		handleRequest(req, res).catch((err) => {
+			if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain" });
+			res.end(err instanceof Error ? maskCredentials(err.message) : String(err));
+		});
+	});
+	async function shutdown() {
+		for (const server of runtimes.values()) await server.close().catch(() => void 0);
+		await stateFile.flush();
+		server.close();
+		process.exit(0);
+	}
+	process.on("SIGTERM", () => void shutdown());
+	process.on("SIGINT", () => void shutdown());
+	process.on("unhandledRejection", (reason) => {
+		console.error("postgres-main: unhandled rejection from background work:", reason instanceof Error ? maskCredentials(reason.stack ?? reason.message) : reason);
+	});
+	process.on("uncaughtException", (err) => {
+		console.error("postgres-main: uncaught exception from background work:", err instanceof Error ? maskCredentials(err.stack ?? err.message) : err);
+	});
+	readJsonFile(appsJsonPath, isAppsState).then((loaded) => {
+		if (loaded) state = loaded;
+		server.listen(port, "127.0.0.1", () => {
+			console.log(`[dev-emulators] postgres-main listening on 127.0.0.1:${String(port)}`);
+		});
+	}).catch((err) => {
+		console.error("postgres-main: failed to load state", err);
+		process.exit(1);
+	});
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=postgres-main.mjs.map