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

package/dist/streams/streams-service.mjs

@@ -1,9 +1,9 @@
 import { dependency, hydrateSecrets, hydrateSync, number, provisionNeed, resource, service, string } from "@prisma/composer";
 import { blindCast } from "@prisma/composer/casts";
-import { RPC_PEER_KEY } from "@prisma/composer/service-rpc";
 import { type } from "arktype";
+import { RPC_PEER_KEY } from "@prisma/composer/service-rpc";
 import node from "@prisma/composer/node";
-blindCast(Symbol.for("prisma:prisma-cloud-secret-source"));
+//#region ../../1-prisma-cloud/1-extensions/target/dist/serializer-CJiOhF2d.mjs
 /**
 * Walks a node's own params, then each dependency input's connection params —
 * the same enumeration order `configOf` uses, but carrying the raw
@@ -191,6 +191,35 @@ function stashProviderParams(entries, address) {
 		process.env[configKey("", d)] = encode("service", value);
 	}
 }
+/** The framework-resolved origin row: COMPOSER_<addr>_ORIGIN. Written per
+*  compute service at serialize — the service's own provisioned endpoint URL,
+*  riding the reserved-provider-param machinery (`origin-key.ts`'s
+*  `ORIGIN_PARAM`); never a declared param, never in config(). A harness with
+*  no deploy behind it supplies it by setting `COMPOSER_ORIGIN` to the
+*  JSON-encoded origin URL — exactly how the existing entrypoint tests supply
+*  their other `COMPOSER_*` rows. */
+const ORIGIN_KEY_NAME = "ORIGIN";
+/**
+* Reads this service's origin back out of the address-free stash
+* `stashProviderParams` wrote for the ORIGIN entry. `COMPOSER_ORIGIN` unset is
+* a loud failure — a deployed environment always writes it, so an unset row
+* means either a local harness that hasn't supplied it or a boot() called
+* before run().
+*/
+function readOrigin() {
+	const d = {
+		owner: "service",
+		name: ORIGIN_KEY_NAME,
+		param: {
+			schema: type("string"),
+			optional: true
+		}
+	};
+	const key = configKey("", d);
+	const value = coerce(process.env[key], d, key);
+	if (value === void 0) throw new Error("this service's origin is not available (env COMPOSER_ORIGIN is unset) — a deployed environment writes it automatically; a local harness must supply it like any other config value (set COMPOSER_ORIGIN to the JSON-encoded origin URL).");
+	return blindCast(value);
+}
 /** Synchronous Standard Schema validation — see the matching note in core's `config.ts`. */
 function standardValidateSync(schema, value) {
 	const result = schema["~standard"].validate(value);
@@ -199,7 +228,41 @@ function standardValidateSync(schema, value) {
 	return result.value;
 }
 //#endregion
-//#region ../../1-prisma-cloud/1-extensions/target/dist/provisioned-edges-DIQAR4q4.mjs
+//#region ../../1-prisma-cloud/1-extensions/target/dist/provisioned-edges-C1wSO3cx.mjs
+/**
+* The service's own origin as a reserved provider param (ADR-0031): the ONE
+* brand and the ONE entry — shared by control.ts (which registers the
+* deploy-side value function that resolves the provisioned service's
+* `endpointDomain` — see its `selfOriginValue`) and compute.ts (which
+* validates and stashes the row at boot through the generic
+* `stashProviderParams` loop), so writer and reader cannot drift.
+*
+* Unlike the key-minting brands (`service-keys.ts`, `streams-keys.ts`) this
+* brand has no provisioner and no consumer edges: the value derives from the
+* service's OWN provisioned attributes, so control.ts registers it as a
+* service-derived provider param (`descriptors/shared.ts`'s
+* `ServiceProviderParam`) and the descriptor writes it for EVERY compute
+* service, exposing or not.
+*
+* This module is reachable from the RUNTIME/authoring side — it must never
+* import `@internal/lowering` or `effect`, or those tokens leak into a user
+* service's bundle (the deploy-side value function lives in control.ts, the
+* control-plane-only entry).
+*/
+/** ADR-0031's brand for the service's own origin — control.ts registers the deploy-side value function under this. */
+const SELF_ORIGIN = Symbol.for("prisma:self-origin");
+/**
+* The reserved provider param for the origin row: the var name is `ORIGIN`,
+* derived through `configKey` at both ends (`configKey(address, …)` at
+* deploy, `configKey('', …)` — `COMPOSER_ORIGIN` — at boot, where
+* `readOrigin` reads it back). `brand` is `SELF_ORIGIN` — control.ts looks
+* its deploy-side value function up by this field.
+*/
+const ORIGIN_PARAM = {
+	name: ORIGIN_KEY_NAME,
+	schema: type("string"),
+	brand: SELF_ORIGIN
+};
 /**
 * RPC's reserved provider param (ADR-0030/ADR-0031): the declaration —
 * name + schema + brand — for the accepted-keys set a provider stores, shared
@@ -252,8 +315,33 @@ configKey("", {
 	owner: "service",
 	name: STREAMS_API_KEY_PARAM.name
 });
-const RESERVED_PROVIDER_PARAMS = [RPC_ACCEPTED_KEYS_PARAM, STREAMS_API_KEY_PARAM];
-blindCast(Symbol.for("prisma:prisma-cloud-param-source"));
+/**
+* The list of provider-side reserved params the boot path validates and
+* stashes (ADR-0031): every brand's `{name, schema, brand}` declaration,
+* collected from that brand's own module (`service-keys.ts`,
+* `streams-keys.ts`, `origin-key.ts`) so `compute.ts` names no brand itself.
+*
+* This list exists separately from `control.ts`'s deploy-side registry
+* (`PROVIDER_PARAMS`) because `control.ts` is deploy-only code — it imports
+* `@internal/lowering` and `effect` to mint values — and a booted service
+* must never import it. This module is reachable from a user service's
+* bundle through `compute.ts`, so it must never import `@internal/lowering`,
+* `effect`, `alchemy`, or `control.ts`.
+*
+* This is the single source of which reserved provider params exist:
+* control.ts builds `PROVIDER_PARAMS` by mapping over this list and looking
+* up each entry's deploy-side value function (edge-derived `value(refs)` or
+* service-derived `valueForService(provisioned, address)`) by its `brand`,
+* throwing at module load if one is missing. Adding a brand means adding its
+* entry here, plus its deploy-side value function in control.ts — a brand
+* registered for deploy but absent here is no longer expressible, because
+* deploy no longer names its own param set independently.
+*/
+const RESERVED_PROVIDER_PARAMS = [
+	RPC_ACCEPTED_KEYS_PARAM,
+	STREAMS_API_KEY_PARAM,
+	ORIGIN_PARAM
+];
 Object.freeze({
 	kind: "s3",
 	__cmp: {
@@ -270,7 +358,7 @@ const reservedParams = { port: number({ default: 3e3 }) };
 * ports it exposes), no descriptor. `params` merges with the reserved
 * `ReservedParams` (`port`); a user param whose name collides with a reserved
 * one fails at authoring, the same way a colliding dependency name does.
-* Returns the extension's runnable/loadable node:
+*
 *   · run(address, boot) — the process controller: deserialize the platform
 *     environment (keyed off `address`, the extension's ONE env read) into a
 *     typed Config, re-emit it under address-free process-local stash keys,
@@ -278,23 +366,69 @@ const reservedParams = { port: number({ default: 3e3 }) };
 *   · load() / config() — called from inside the app's entry: read the stash;
 *     load() hydrates + memoizes the deps, config() returns the typed params.
 *     Separate accessors so a dep and a param never share a namespace (ADR-0021).
+*   · origin() — this service's platform-assigned public origin, read from the
+*     stash `run()` populates; memoized per process.
 *
-* `service()`'s underlying node carries `extension: '@prisma/composer-prisma-cloud'` —
+* The underlying node carries `extension: '@prisma/composer-prisma-cloud'` —
 * the control-plane registry key `prisma-composer deploy` resolves through the
 * app's `prisma-composer.config.ts` (ADR-0017). This module loads nothing at
-* deploy time; nodes are pure data.
+* deploy time; nodes are pure data until run() or load() is called.
 */
+var ComputeService = class {
+	#resolved;
+	#loadedDeps;
+	#loadedParams;
+	#loadedSecrets;
+	#origin;
+	constructor(node) {
+		Object.assign(this, node);
+	}
+	#processConfig() {
+		if (this.#resolved === void 0) this.#resolved = deserialize(this, "");
+		return this.#resolved;
+	}
+	async run(address, boot) {
+		const config = deserialize(this, address);
+		stash(this, config);
+		stashProviderParams(RESERVED_PROVIDER_PARAMS, address);
+		stashSecrets(this, address);
+		const port = config.service["port"];
+		if (typeof port === "number") process.env["PORT"] = String(port);
+		return boot();
+	}
+	load() {
+		if (this.#loadedDeps === void 0) this.#loadedDeps = blindCast(hydrateSync(this, this.#processConfig()));
+		return this.#loadedDeps;
+	}
+	config() {
+		if (this.#loadedParams === void 0) this.#loadedParams = blindCast(this.#processConfig().service);
+		return this.#loadedParams;
+	}
+	secrets() {
+		if (this.#loadedSecrets === void 0) this.#loadedSecrets = blindCast(hydrateSecrets(this, deserializeSecrets(this, "")));
+		return this.#loadedSecrets;
+	}
+	/** This service's platform-assigned public origin — read from the stash
+	*  run() populates and memoized per process. Throws if called before run()
+	*  has stashed it (readOrigin's pinned message). */
+	origin() {
+		this.#origin ??= readOrigin();
+		return this.#origin;
+	}
+};
 const compute = (def) => {
 	const userParams = def.params ?? blindCast({});
 	for (const reserved of Object.keys(reservedParams)) {
 		if (reserved in def.deps) throw new Error(`compute(): dependency "${reserved}" collides with the reserved service param of the same name — rename the dependency.`);
 		if (reserved in userParams) throw new Error(`compute(): param "${reserved}" collides with the reserved service param of the same name — rename the param.`);
 	}
+	for (const name of Object.keys(userParams)) if (name.toUpperCase() === "ORIGIN") throw new Error(`compute(): param "${name}" collides with the framework-written origin row — rename the param.`);
+	for (const name of Object.keys(def.secrets ?? {})) if (name.toUpperCase() === "ORIGIN") throw new Error(`compute(): secret "${name}" collides with the framework-written origin row — rename the secret.`);
 	const params = blindCast({
 		...userParams,
 		...reservedParams
 	});
-	const node = service({
+	const instance = new ComputeService(service({
 		name: def.name,
 		extension: "@prisma/composer-prisma-cloud",
 		type: "compute",
@@ -303,40 +437,9 @@ const compute = (def) => {
 		...def.secrets !== void 0 ? { secrets: def.secrets } : {},
 		build: def.build,
 		...def.expose !== void 0 ? { expose: def.expose } : {}
-	});
-	let resolved;
-	let loadedDeps;
-	let loadedParams;
-	let loadedSecrets;
-	function processConfig() {
-		if (resolved === void 0) resolved = deserialize(node, "");
-		return resolved;
-	}
-	const runnable = {
-		...node,
-		async run(address, boot) {
-			const config = deserialize(node, address);
-			stash(node, config);
-			stashProviderParams(RESERVED_PROVIDER_PARAMS, address);
-			stashSecrets(node, address);
-			const port = config.service["port"];
-			if (typeof port === "number") process.env["PORT"] = String(port);
-			return boot();
-		},
-		load() {
-			if (loadedDeps === void 0) loadedDeps = blindCast(hydrateSync(node, processConfig()));
-			return loadedDeps;
-		},
-		config() {
-			if (loadedParams === void 0) loadedParams = blindCast(processConfig().service);
-			return loadedParams;
-		},
-		secrets() {
-			if (loadedSecrets === void 0) loadedSecrets = blindCast(hydrateSecrets(node, deserializeSecrets(node, "")));
-			return loadedSecrets;
-		}
-	};
-	return Object.freeze(blindCast(runnable));
+	}));
+	Object.freeze(instance);
+	return instance;
 };
 /**
 * The contract a Postgres provides — and the contract its consumers require.
@@ -407,13 +510,21 @@ function s3Credentials(opts) {
 * return type is compute's exactly (including the reserved `port` param). The
 * storage module (D4b) calls this with its `db`/`credentials` deps, a `bucket`
 * param, and `expose: { store: s3Contract }`.
+*
+* `compute()`'s result is a `ComputeService` instance — its run/load/config/
+* secrets/origin methods live on the class prototype, not as the instance's
+* own properties, so a plain object spread (`{ ...node }`) would silently
+* drop them. Building a fresh `ComputeService` from the same data fields
+* (which `{ ...node }` DOES copy — they're the node's own enumerable
+* properties) with `type` overridden keeps every method intact.
 */
 function s3StoreService(def) {
-	const node = compute(def);
-	return Object.freeze(blindCast({
-		...node,
+	const instance = new ComputeService({
+		...compute(def),
 		type: "s3-store"
-	}));
+	});
+	Object.freeze(instance);
+	return instance;
 }
 //#endregion
 //#region ../../1-prisma-cloud/2-shared-modules/storage/dist/storage-service-DSaZsAC4.mjs