@prisma/composer-prisma-cloud 0.1.0-dev.1 → 0.1.0-dev.2

package/dist/streams/streams-service.mjs

@@ -1,6 +1,7 @@
-import { dependency, hydrateSecrets, hydrateSync, number, resource, secret, service, string } from "@prisma/composer";
+import { dependency, hydrateSecrets, hydrateSync, number, provisionNeed, resource, service, string } from "@prisma/composer";
 import { blindCast } from "@prisma/composer/casts";
-import "@prisma/composer/rpc";
+import { RPC_PEER_KEY } from "@prisma/composer/rpc";
+import { type } from "arktype";
 import node from "@prisma/composer/node";
 blindCast(Symbol.for("prisma:prisma-cloud-secret-source"));
 /**
@@ -164,6 +165,32 @@ const stashSecrets = (node, address) => {
 		process.env[secretKey("", slot)] = name;
 	}
 };
+/**
+* Boot: for each reserved provider param, read its address-scoped row through
+* the same `coerce` a declared param uses (JSON-decode, schema-validate), and
+* re-emit it address-free — `stash`'s counterpart for this separate
+* declaration space. A param is declared optional here unconditionally: an
+* absent row means "never provisioned" (local dev, tests, a provider with no
+* registered value for this deploy), never a boot failure, so nothing is
+* stashed and the runtime reader that owns this slot falls back to its own
+* pass-through behavior.
+*/
+function stashProviderParams(entries, address) {
+	for (const entry of entries) {
+		const d = {
+			owner: "service",
+			name: entry.name,
+			param: {
+				schema: entry.schema,
+				optional: true
+			}
+		};
+		const key = configKey(address, d);
+		const value = coerce(process.env[key], d, key);
+		if (value === void 0) continue;
+		process.env[configKey("", d)] = encode("service", value);
+	}
+}
 /** Synchronous Standard Schema validation — see the matching note in core's `config.ts`. */
 function standardValidateSync(schema, value) {
 	const result = schema["~standard"].validate(value);
@@ -172,12 +199,60 @@ function standardValidateSync(schema, value) {
 	return result.value;
 }
 //#endregion
-//#region ../../1-prisma-cloud/1-extensions/target/dist/param-DB0B8m15.mjs
-/** The reserved accepted-keys env var: COMPOSER_<addr>_RPC_ACCEPTED_KEYS ("" ↦ @internal/rpc's RPC_ACCEPTED_KEYS_ENV). */
-const serviceKeyEnvName = (address) => configKey(address, {
+//#region ../../1-prisma-cloud/1-extensions/target/dist/provisioned-edges-Bb7WiV49.mjs
+/**
+* RPC's reserved provider param (ADR-0030/ADR-0031): the declaration —
+* name + schema + brand — for the accepted-keys set a provider stores, shared
+* by `control.ts` (which registers the deploy-side `value(refs)` that mints
+* and aggregates it — see its `rpcAcceptedKeysValue`) and `compute.ts` (which
+* validates and stashes it at boot), so writer and reader cannot drift.
+* Finding the edges themselves is `provisioned-edges.ts`'s generic,
+* brand-blind scan — RPC is not special-cased anywhere in this target.
+*
+* 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(refs)` lives in control.ts, the
+* control-plane-only entry).
+*/
+/**
+* The reserved provider param for RPC's accepted-keys set: the var name is
+* `RPC_ACCEPTED_KEYS`, derived through `configKey` at both ends
+* (`configKey(address, …)` at deploy, `configKey('', …)` at boot — the
+* address-free form is `@internal/rpc`'s `RPC_ACCEPTED_KEYS_ENV`). `brand` is
+* `RPC_PEER_KEY`, the same brand `perBindingToken()`'s need carries — control.ts
+* looks its `value(refs)` up by this field.
+*/
+const RPC_ACCEPTED_KEYS_PARAM = {
+	name: "RPC_ACCEPTED_KEYS",
+	schema: type("string[]"),
+	brand: RPC_PEER_KEY
+};
+/** ADR-0031's need brand for the streams module's bearer key — control.ts registers the provisioner under this. */
+const STREAMS_API_KEY = Symbol.for("prisma:streams/api-key");
+/**
+* The provisioning need `durableStreams()`'s `apiKey` param declares: an
+* unguessable value the target mints ONCE PER PROVIDER (not per edge) —
+* `@prisma/streams-server` authenticates a single `API_KEY`, so every
+* consumer of one streams module must present the same value. Per-provider
+* cardinality is provisioner policy (ADR-0031), invisible to core.
+*/
+const streamsApiKeyNeed = () => provisionNeed(STREAMS_API_KEY);
+/**
+* The reserved provider param for the streams bearer key: the var name is
+* `STREAMS_API_KEY`. `brand` is `STREAMS_API_KEY` itself (the same symbol
+* `streamsApiKeyNeed()`'s need carries) — control.ts looks its `value(refs)`
+* up by this field.
+*/
+const STREAMS_API_KEY_PARAM = {
+	name: "STREAMS_API_KEY",
+	schema: type("string"),
+	brand: STREAMS_API_KEY
+};
+configKey("", {
 	owner: "service",
-	name: "RPC_ACCEPTED_KEYS"
+	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"));
 //#endregion
 //#region ../../1-prisma-cloud/1-extensions/target/dist/index.mjs
@@ -234,9 +309,8 @@ const compute = (def) => {
 		async run(address, boot) {
 			const config = deserialize(node, address);
 			stash(node, config);
+			stashProviderParams(RESERVED_PROVIDER_PARAMS, address);
 			stashSecrets(node, address);
-			const accepted = process.env[serviceKeyEnvName(address)];
-			if (accepted !== void 0) process.env[serviceKeyEnvName("")] = accepted;
 			const port = config.service["port"];
 			if (typeof port === "number") process.env["PORT"] = String(port);
 			return boot();
@@ -390,31 +464,336 @@ function storageService(opts) {
 	});
 }
 storageService({ bucket: "storage" });
-//#endregion
-//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/streams-service-Dx0z-whA.mjs
-const streamsContract = Object.freeze({
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var require_reusify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function reusify(Constructor) {
+		var head = new Constructor();
+		var tail = head;
+		function get() {
+			var current = head;
+			if (current.next) head = current.next;
+			else {
+				head = new Constructor();
+				tail = head;
+			}
+			current.next = null;
+			return current;
+		}
+		function release(obj) {
+			tail.next = obj;
+			tail = obj;
+		}
+		return {
+			get,
+			release
+		};
+	}
+	module.exports = reusify;
+}));
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var reusify = require_reusify();
+	function fastqueue(context, worker, _concurrency) {
+		if (typeof context === "function") {
+			_concurrency = worker;
+			worker = context;
+			context = null;
+		}
+		if (!(_concurrency >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
+		var cache = reusify(Task);
+		var queueHead = null;
+		var queueTail = null;
+		var _running = 0;
+		var errorHandler = null;
+		var self = {
+			push,
+			drain: noop,
+			saturated: noop,
+			pause,
+			paused: false,
+			get concurrency() {
+				return _concurrency;
+			},
+			set concurrency(value) {
+				if (!(value >= 1)) throw new Error("fastqueue concurrency must be equal to or greater than 1");
+				_concurrency = value;
+				if (self.paused) return;
+				for (; queueHead && _running < _concurrency;) {
+					_running++;
+					release();
+				}
+			},
+			running,
+			resume,
+			idle,
+			length,
+			getQueue,
+			unshift,
+			empty: noop,
+			kill,
+			killAndDrain,
+			error,
+			abort
+		};
+		return self;
+		function running() {
+			return _running;
+		}
+		function pause() {
+			self.paused = true;
+		}
+		function length() {
+			var current = queueHead;
+			var counter = 0;
+			while (current) {
+				current = current.next;
+				counter++;
+			}
+			return counter;
+		}
+		function getQueue() {
+			var current = queueHead;
+			var tasks = [];
+			while (current) {
+				tasks.push(current.value);
+				current = current.next;
+			}
+			return tasks;
+		}
+		function resume() {
+			if (!self.paused) return;
+			self.paused = false;
+			if (queueHead === null) {
+				_running++;
+				release();
+				return;
+			}
+			for (; queueHead && _running < _concurrency;) {
+				_running++;
+				release();
+			}
+		}
+		function idle() {
+			return _running === 0 && self.length() === 0;
+		}
+		function push(value, done) {
+			var current = cache.get();
+			current.context = context;
+			current.release = release;
+			current.value = value;
+			current.callback = done || noop;
+			current.errorHandler = errorHandler;
+			if (_running >= _concurrency || self.paused) if (queueTail) {
+				queueTail.next = current;
+				queueTail = current;
+			} else {
+				queueHead = current;
+				queueTail = current;
+				self.saturated();
+			}
+			else {
+				_running++;
+				worker.call(context, current.value, current.worked);
+			}
+		}
+		function unshift(value, done) {
+			var current = cache.get();
+			current.context = context;
+			current.release = release;
+			current.value = value;
+			current.callback = done || noop;
+			current.errorHandler = errorHandler;
+			if (_running >= _concurrency || self.paused) if (queueHead) {
+				current.next = queueHead;
+				queueHead = current;
+			} else {
+				queueHead = current;
+				queueTail = current;
+				self.saturated();
+			}
+			else {
+				_running++;
+				worker.call(context, current.value, current.worked);
+			}
+		}
+		function release(holder) {
+			if (holder) cache.release(holder);
+			var next = queueHead;
+			if (next && _running <= _concurrency) if (!self.paused) {
+				if (queueTail === queueHead) queueTail = null;
+				queueHead = next.next;
+				next.next = null;
+				worker.call(context, next.value, next.worked);
+				if (queueTail === null) self.empty();
+			} else _running--;
+			else if (--_running === 0) self.drain();
+		}
+		function kill() {
+			queueHead = null;
+			queueTail = null;
+			self.drain = noop;
+		}
+		function killAndDrain() {
+			queueHead = null;
+			queueTail = null;
+			self.drain();
+			self.drain = noop;
+		}
+		function abort() {
+			var current = queueHead;
+			queueHead = null;
+			queueTail = null;
+			while (current) {
+				var next = current.next;
+				var callback = current.callback;
+				var errorHandler = current.errorHandler;
+				var val = current.value;
+				var context = current.context;
+				current.value = null;
+				current.callback = noop;
+				current.errorHandler = null;
+				if (errorHandler) errorHandler(/* @__PURE__ */ new Error("abort"), val);
+				callback.call(context, /* @__PURE__ */ new Error("abort"));
+				current.release(current);
+				current = next;
+			}
+			self.drain = noop;
+		}
+		function error(handler) {
+			errorHandler = handler;
+		}
+	}
+	function noop() {}
+	function Task() {
+		this.value = null;
+		this.callback = noop;
+		this.next = null;
+		this.release = noop;
+		this.context = null;
+		this.errorHandler = null;
+		var self = this;
+		this.worked = function worked(err, result) {
+			var callback = self.callback;
+			var errorHandler = self.errorHandler;
+			var val = self.value;
+			self.value = null;
+			self.callback = noop;
+			if (self.errorHandler) errorHandler(err, val);
+			callback.call(self.context, err, result);
+			self.release(self);
+		};
+	}
+	function queueAsPromised(context, worker, _concurrency) {
+		if (typeof context === "function") {
+			_concurrency = worker;
+			worker = context;
+			context = null;
+		}
+		function asyncWrapper(arg, cb) {
+			worker.call(this, arg).then(function(res) {
+				cb(null, res);
+			}, cb);
+		}
+		var queue = fastqueue(context, asyncWrapper, _concurrency);
+		var pushCb = queue.push;
+		var unshiftCb = queue.unshift;
+		queue.push = push;
+		queue.unshift = unshift;
+		queue.drained = drained;
+		return queue;
+		function push(value) {
+			var p = new Promise(function(resolve, reject) {
+				pushCb(value, function(err, result) {
+					if (err) {
+						reject(err);
+						return;
+					}
+					resolve(result);
+				});
+			});
+			p.catch(noop);
+			return p;
+		}
+		function unshift(value) {
+			var p = new Promise(function(resolve, reject) {
+				unshiftCb(value, function(err, result) {
+					if (err) {
+						reject(err);
+						return;
+					}
+					resolve(result);
+				});
+			});
+			p.catch(noop);
+			return p;
+		}
+		function drained() {
+			return new Promise(function(resolve) {
+				process.nextTick(function() {
+					if (queue.idle()) resolve();
+					else {
+						var previousDrain = queue.drain;
+						queue.drain = function() {
+							if (typeof previousDrain === "function") previousDrain();
+							resolve();
+							queue.drain = previousDrain;
+						};
+					}
+				});
+			});
+		}
+	}
+	module.exports = fastqueue;
+	module.exports.promise = queueAsPromised;
+})))();
+/**
+* Default backoff options.
+*/
+const BackoffDefaults = {
+	initialDelay: 100,
+	maxDelay: 6e4,
+	multiplier: 1.3,
+	maxRetries: Infinity
+};
+({ ...BackoffDefaults });
+({ ...BackoffDefaults });
+/**
+* The `streams()` module's own exposed port: a general streams provider,
+* satisfied by kind alone — the `postgresContract` pattern. The module
+* cannot know its eventual consumers' stream names (different consumers of
+* one module each name their own), and the server genuinely serves any
+* stream, so what a consumer requires of its provider is only "is a streams
+* provider". That is exactly what this wide type says, and the empty def
+* map is a legitimate `StreamDefs` value — a placeholder nobody reads, like
+* postgres's `{ url: '' }`. Consumers keep their literal handle typing from
+* `durableStreams(contract)`'s generic parameter, which is independent of
+* the wiring-compatibility type here.
+*/
+const streamsProviderContract = Object.freeze({
 	kind: "streams",
-	__cmp: { url: "" },
+	__cmp: {},
 	satisfies: (required) => required.kind === "streams"
 });
+string(), string({ provision: streamsApiKeyNeed() });
 /**
-* The streams service node: a plain `compute` service (no lowering extension —
-* the contract binding is `{ url }`, which compute's deploy outputs already
-* carry). It declares the `store` dependency (`s3()`, the storage module's
-* port), the `apiKey` secret slot, and the `streams` expose. The deploy
-* bootstrap runs the default-exported bare node; the real wiring arrives
-* through serialized config at runtime — exactly like `storage-service.ts`.
+* The streams service node: a plain `compute` service — the contract binding's
+* `url` is a producer output compute's deploy already carries, and its
+* `apiKey` is minted by the target's registered provisioner (ADR-0031), so
+* nothing is left for a bespoke lowering to extend. It declares the `store`
+* dependency (`s3()`, the storage module's port) and the `streams` expose; the
+* bearer key reaches this service through the target's reserved provider
+* param, not through a dependency. The deploy bootstrap runs the
+* default-exported bare node; the real wiring arrives through serialized
+* config at runtime — exactly like `storage-service.ts`.
 */
 function streamsService() {
 	return compute({
 		name: "streams",
 		deps: { store: s3() },
-		secrets: { apiKey: secret() },
 		build: node({
 			module: new URL("./streams-service.mjs", import.meta.url).href,
 			entry: "./streams-entrypoint.mjs"
 		}),
-		expose: { streams: streamsContract }
+		expose: { streams: streamsProviderContract }
 	});
 }
 var streams_service_default = streamsService();