@geekmidas/cli 10.0.0-alpha.42 → 10.0.0-alpha.43

package/dist/{workspace-BTM5-aaI.mjs → workspace-Bt-pXoIi.mjs}

@@ -4,7 +4,7 @@ import { c as loadWorkspaceAppInfo, f as appKey, l as loadWorkspaceConfig, r as
 import { E as TEST_STAGE, t as allConstructGlobs } from "./workspace-DOmIhiau.mjs";
 import { i as toEmbeddableSecrets } from "./storage-BzaUxmqe.mjs";
 import { i as FileSecretsStore, n as secretsStoreFor } from "./store-DeGATCS-.mjs";
-import { l as readFakes } from "./ready-BZ0fLpyL.mjs";
+import { l as readFakes } from "./ready-Bdh5SSXn.mjs";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { networkInterfaces } from "node:os";
@@ -2153,6 +2153,27 @@ async function allocate(project, containers, existing = {}, probe = isPortFree)
 	}
 	return assignments;
 }
+/**
+* The ports to keep: what running containers are observed on, then what was
+* saved — minus any saved entry whose port something else already holds.
+*
+* Spreading one over the other let an observed port override its own key and
+* leave a *different* key still saved on the same number: two services on one
+* port, and whichever answered first won. Saved keys for containers the plan no
+* longer has — a backend switched and back — were the usual source. Observed
+* wins because it is what is actually bound; a dropped entry is simply
+* allocated again.
+*/
+function keptPorts(saved = {}, observed = {}) {
+	const kept = { ...observed };
+	const taken = new Set(Object.values(observed));
+	for (const [key, port] of Object.entries(saved).sort(([a], [b]) => a < b ? -1 : 1)) {
+		if (key in kept || taken.has(port)) continue;
+		kept[key] = port;
+		taken.add(port);
+	}
+	return kept;
+}
 /** The window was exhausted. */
 var NoPortAvailable = class extends Error {
 	/** Where the search started. */
@@ -2469,6 +2490,25 @@ async function applyCarriers(client, carriers) {
 	}
 	return applied;
 }
+/** The Postgres databases the plan creates — each is a `CREATE DATABASE`. */
+function postgresDatabaseNames(plan) {
+	return plan.resources.filter((resource) => resource.kind === "database" && resource.provisions && resource.container === "postgres").map((resource) => resource.name);
+}
+/**
+* Whether every one of these databases exists. A database dropped behind the
+* recorded state's back — by another checkout's test teardown, against the
+* same container — makes the state a lie, and only asking Postgres finds out.
+* Unreachable counts as missing: applying again is what finds out why.
+*/
+async function databasesExist(client, names) {
+	if (names.length === 0) return true;
+	try {
+		const rows = await client.query(void 0, "SELECT datname FROM pg_catalog.pg_database WHERE datname = ANY($1)", [names]);
+		return new Set(rows.map((row) => row.datname)).size === names.length;
+	} catch {
+		return false;
+	}
+}
 /**
 * Apply each served bucket's open-path policy, skipping those already correct.
 *
@@ -2665,10 +2705,7 @@ async function reconcile(options) {
 	});
 	const composePath = join(root, COMPOSE_PATH);
 	const observed = await observedPorts(docker, composePath, plan.containers, plan.fakes);
-	const ports = await allocate(project, portKeys(plan.containers, plan.fakes), {
-		...options.saved,
-		...observed
-	}, probe);
+	const ports = await allocate(project, portKeys(plan.containers, plan.fakes), keptPorts(options.saved, observed), probe);
 	const compose = composeFor(plan, {
 		project,
 		ports,
@@ -2702,7 +2739,9 @@ async function reconcile(options) {
 		hash,
 		changed: false
 	};
-	if ((await loadState(root, stage))?.hash === hash && existsSync(composePath) && (!start || await docker.healthy(composePath, plan.containers))) return result;
+	const recorded = await loadState(root, stage);
+	const postgresPort = ports[primaryPortKey("postgres")];
+	if (recorded?.hash === hash && existsSync(composePath) && (!start || await docker.healthy(composePath, plan.containers)) && (!start || !provision || postgresPort === void 0 || await databasesExist(sql(postgresPort), postgresDatabaseNames(plan)))) return result;
 	await write(composePath, toYaml(compose));
 	if (plan.containers.includes("caddy")) {
 		await write(join(root, CADDYFILE_PATH), caddyfileRoot());
@@ -2951,6 +2990,6 @@ function localAddress(port) {
 	return `http://localhost:${port}`;
 }
 //#endregion
-export { findAvailablePort as C, prepareEntryCredentials as D, loadSecretsForApp as E, createEntryWrapper as S, loadEnvFiles as T, cacheBackendFor as _, reconcileWorkspace as a, storageBackendFor as b, LOCAL_CA_PATH as c, quoteIdentifier as d, pgClient as f, primaryPortKey as g, fakeKey as h, derivedContainers as i, forgetState as l, rootSite as m, backendsOf as n, workspace_exports as o, resourceName as p, constructGlobs as r, COMPOSE_PATH as s, FAKE_ENV as t, applyPostgres as u, eventsBackendFor as v, isPortAvailable as w, createCredentialsPreload as x, providerOf as y };
+export { createEntryWrapper as C, loadSecretsForApp as D, loadEnvFiles as E, prepareEntryCredentials as O, createCredentialsPreload as S, isPortAvailable as T, primaryPortKey as _, reconcileWorkspace as a, providerOf as b, LOCAL_CA_PATH as c, postgresDatabaseNames as d, quoteIdentifier as f, fakeKey as g, rootSite as h, derivedContainers as i, forgetState as l, resourceName as m, backendsOf as n, workspace_exports as o, pgClient as p, constructGlobs as r, COMPOSE_PATH as s, FAKE_ENV as t, applyPostgres as u, cacheBackendFor as v, findAvailablePort as w, storageBackendFor as x, eventsBackendFor as y };
 
-//# sourceMappingURL=workspace-BTM5-aaI.mjs.map
+//# sourceMappingURL=workspace-Bt-pXoIi.mjs.map