@geekmidas/constructs 10.0.0-alpha.40 → 10.0.0-alpha.42

package/dist/adaptors/testing.cjs

@@ -1,14 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../rolldown-runtime-y5ARvAq5.cjs");
 const require_auth = require("../auth.cjs");
-const require_functions = require("../functions-ZH60FE7H.cjs");
-const require_Endpoint = require("../Endpoint-D1L9qu5C.cjs");
-const require_Queue = require("../Queue-Ckmudcm8.cjs");
+const require_functions = require("../functions-CbP5ZKma.cjs");
+const require_Endpoint = require("../Endpoint-wSCHSnqb.cjs");
+const require_Queue = require("../Queue-D5jcw0mu.cjs");
 const require_email = require("../email.cjs");
 const require_database_kysely = require("../database/kysely.cjs");
 const require_lazyAccessors = require("../lazyAccessors-hJKGv8Ay.cjs");
 const require_Topic = require("../Topic-CkxOTrMv.cjs");
-const require_HonoEndpointAdaptor = require("../HonoEndpointAdaptor-Cq99r9H7.cjs");
+const require_HonoEndpointAdaptor = require("../HonoEndpointAdaptor-CBoSm3TM.cjs");
 const require_processAudits = require("../processAudits-D_2W5x8k.cjs");
 let _geekmidas_manifest = require("@geekmidas/manifest");
 let _geekmidas_errors = require("@geekmidas/errors");
@@ -345,7 +345,8 @@ var TestFunctionAdaptor = class TestFunctionAdaptor {
 /**
 * In-memory test driver for a {@link Queue} worker. Hand it a batch of messages
 * and it registers the queue's services, runs the handler in a request context,
-* and returns the handler result — no SQS/pg-boss required.
+* and returns the handler result — no SQS/pg-boss required. A queue with a
+* database gets `db` registered from it, or the one the request passes.
 *
 * @example
 * const adapter = new TestQueueAdaptor(ordersQueue);
@@ -364,6 +365,7 @@ var TestQueueAdaptor = class TestQueueAdaptor {
 	async invoke(request) {
 		const logger = this.queue.logger.child({ test: true });
 		const services = request.services ?? await this.serviceDiscovery.register(this.queue.services);
+		const db = request.db !== void 0 ? request.db : await this.getDatabase();
 		const requestId = `test-${Date.now()}`;
 		return (0, _geekmidas_services.runWithRequestContext)({
 			logger,
@@ -372,9 +374,15 @@ var TestQueueAdaptor = class TestQueueAdaptor {
 		}, () => this.queue.handler({
 			messages: request.messages,
 			services,
-			logger
+			logger,
+			db
 		}));
 	}
+	async getDatabase() {
+		const service = this.queue.databaseService;
+		if (!service) return void 0;
+		return (await this.serviceDiscovery.register([service]))[service.serviceName];
+	}
 };
 //#endregion
 //#region src/subscribers/TestSubscriberAdaptor.ts
@@ -393,6 +401,7 @@ var TestSubscriberAdaptor = class TestSubscriberAdaptor {
 		let services;
 		if (request.services) services = request.services;
 		else services = await this.serviceDiscovery.register(this.subscriber.services);
+		const db = request.db !== void 0 ? request.db : await this.getDatabase();
 		const filteredEvents = this.filterEvents(request.events);
 		if (filteredEvents.length === 0) return { batchItemFailures: [] };
 		const requestId = `test-${Date.now()}`;
@@ -404,7 +413,8 @@ var TestSubscriberAdaptor = class TestSubscriberAdaptor {
 			const result = await this.subscriber.handler({
 				events: filteredEvents,
 				services,
-				logger
+				logger,
+				db
 			});
 			let output = result;
 			if (this.subscriber.outputSchema && result) {
@@ -415,6 +425,11 @@ var TestSubscriberAdaptor = class TestSubscriberAdaptor {
 			return output;
 		});
 	}
+	async getDatabase() {
+		const service = this.subscriber.databaseService;
+		if (!service) return void 0;
+		return (await this.serviceDiscovery.register([service]))[service.serviceName];
+	}
 	filterEvents(events) {
 		if (!this.subscriber.subscribedEvents) return events;
 		return events.filter((event) => this.subscriber.subscribedEvents.includes(event.type));
@@ -518,7 +533,16 @@ function featureTest(options = {}) {
 			if (isLocal(new URL(request.url))) return;
 			print.error();
 		} });
-		restoreFetch = (0, _geekmidas_testkit_context.installContextFetch)();
+		const restoreStamp = (0, _geekmidas_testkit_context.installContextFetch)();
+		const stamped = globalThis.fetch;
+		globalThis.fetch = deliveringFetch(stamped, (id) => {
+			const state = contexts.get(id);
+			return state ? deliver(app, state, id) : Promise.resolve();
+		});
+		restoreFetch = () => {
+			globalThis.fetch = stamped;
+			restoreStamp();
+		};
 	});
 	(0, vitest.afterAll)(() => {
 		restoreFetch();
@@ -533,7 +557,9 @@ function featureTest(options = {}) {
 			surfaces: /* @__PURE__ */ new Map(),
 			auth: /* @__PURE__ */ new Map(),
 			addresses: /* @__PURE__ */ new Set(),
-			published: /* @__PURE__ */ new Map()
+			published: /* @__PURE__ */ new Map(),
+			pending: [],
+			delivering: false
 		};
 		const readMail = app.readMail;
 		if (readMail) state.mailbox = (address) => {
@@ -573,8 +599,8 @@ function featureTest(options = {}) {
 							return state.mailbox(address);
 						},
 						published: (channel) => [...state.published.get(channel.id) ?? []],
-						subscriber: (subscriber) => new TestSubscriberAdaptor(subscriber, state.discovery),
-						queue: (queue) => new TestQueueAdaptor(queue, state.discovery)
+						subscriber: (subscriber) => thenDeliver(new TestSubscriberAdaptor(subscriber, state.discovery), () => deliver(app, state, id)),
+						queue: (queue) => thenDeliver(new TestQueueAdaptor(queue, state.discovery), () => deliver(app, state, id))
 					});
 				} finally {
 					restore();
@@ -610,6 +636,10 @@ async function load(manifest, modules) {
 	const imported = async ({ file, export: name }) => (modules[file] ?? await import(file))[name];
 	const constructs = await Promise.all(Object.values(manifest.constructs).map(({ source }) => imported(source)));
 	const endpoints = (await Promise.all(manifest.endpoints.map(({ source }) => imported(source)))).filter((value) => require_Endpoint.Endpoint.isEndpoint(value));
+	const subscribers = (await Promise.all((manifest.subscribers ?? []).map(async ({ source }) => ({
+		name: source.export,
+		subscriber: await imported(source)
+	})))).filter((entry) => entry.subscriber?.__IS_SUBSCRIBER__ === true);
 	const unique = (values) => [...new Set(values)];
 	const databases = unique(constructs.filter((value) => value instanceof require_database_kysely.KyselyDatabase));
 	const auths = unique(constructs.filter((value) => value instanceof require_auth.BetterAuth));
@@ -623,6 +653,7 @@ async function load(manifest, modules) {
 		auths,
 		emails,
 		channels,
+		subscribers,
 		...inbox ? { readMail: (0, _geekmidas_testkit_mailbox.createMailbox)({ inbox }) } : {}
 	};
 }
@@ -634,10 +665,15 @@ async function load(manifest, modules) {
 function recorders(channels, state) {
 	return channels.map((channel) => {
 		const publisher = { async publish(messages) {
-			state.published.set(channel.id, [...state.published.get(channel.id) ?? [], ...messages.map(({ type, payload }) => ({
+			const sent = messages.map(({ type, payload }) => ({
 				type,
 				payload
-			}))]);
+			}));
+			state.published.set(channel.id, [...state.published.get(channel.id) ?? [], ...sent]);
+			state.pending.push({
+				channel,
+				messages: sent
+			});
 		} };
 		return {
 			serviceName: channel.service.serviceName,
@@ -671,6 +707,90 @@ function databasesFor(factories, databases) {
 * the one place a test's connection can be handed over. Outside a test it is
 * the database it always was.
 */
+/** Rounds of delivery before a chain of consumers is called a loop. */
+const MAX_DELIVERY_ROUNDS = 25;
+/**
+* Deliver what this test published, in-process, as the broker would — and
+* keep delivering what the consumers publish in turn, until nothing is left.
+*
+* - A queue's messages go to its one consumer, as a batch.
+* - A topic's events go to every subscriber that named their type, and only
+*   those: fan-out, as the filter policy (SNS) or the per-subscriber queue
+*   (pg-boss) does it.
+* - Each payload is checked against the consumer's schema first. Turning an
+*   SNS envelope or an SQS record into `{ type, payload }` is each adaptor's
+*   job and tested there; what is tested here is what the handler is handed.
+* - Consumers run as the server side of this test, so their databases are
+*   this test's transactions and their writes roll back with it.
+* - A consumer that throws fails the test. Deployed, the message would be
+*   retried; here a retry would only hide the bug.
+*/
+async function deliver(app, state, id) {
+	if (state.delivering) return;
+	state.delivering = true;
+	try {
+		for (let round = 0; state.pending.length > 0; round++) {
+			if (round === MAX_DELIVERY_ROUNDS) throw new DeliveryDidNotSettle(MAX_DELIVERY_ROUNDS, [...new Set(state.pending.map(({ channel }) => channel.id))]);
+			for (const { channel, messages } of state.pending.splice(0)) if (channel instanceof require_Queue.Queue) await toQueue(channel, messages, state, id);
+			else await toSubscribers(channel, messages, app, state, id);
+		}
+	} finally {
+		state.delivering = false;
+	}
+}
+async function toQueue(queue, messages, state, id) {
+	const payloads = [];
+	for (const message of messages) payloads.push(await accepted(queue.messageSchema, message, `queue '${queue.name}'`));
+	await (0, _geekmidas_testkit_context.runAsServer)(id, () => new TestQueueAdaptor(queue, state.discovery).invoke({ messages: payloads })).catch((error) => {
+		throw new DeliveryFailed(`queue '${queue.name}'`, messages, error);
+	});
+}
+async function toSubscribers(topic, messages, app, state, id) {
+	for (const { name, subscriber } of app.subscribers) {
+		if (subscriber.topicName !== topic.name) continue;
+		const named = messages.filter(({ type }) => (subscriber.subscribedEvents ?? []).includes(type));
+		if (named.length === 0) continue;
+		const consumer = `subscriber '${name}'`;
+		const events = [];
+		for (const message of named) {
+			const schema = topic.eventSchemas[message.type];
+			events.push({
+				type: message.type,
+				payload: await accepted(schema, message, consumer)
+			});
+		}
+		await (0, _geekmidas_testkit_context.runAsServer)(id, () => new TestSubscriberAdaptor(subscriber, state.discovery).invoke({ events })).catch((error) => {
+			throw new DeliveryFailed(consumer, named, error);
+		});
+	}
+}
+/** The payload, if the consumer's schema takes it — what the handler is handed. */
+async function accepted(schema, message, consumer) {
+	const standard = schema?.["~standard"];
+	if (!standard) return message.payload;
+	const result = await standard.validate(message.payload);
+	if (result.issues) throw new MessageRejected(consumer, message, result.issues);
+	return result.value;
+}
+/** `fetch`, delivering what the test published once each of its requests answers. */
+function deliveringFetch(inner, settle) {
+	return async (input, init) => {
+		const context = (0, _geekmidas_testkit_context.currentTestContext)();
+		const response = await inner(input, init);
+		if (context?.side === "client") await settle(context.id);
+		return response;
+	};
+}
+/** An adaptor whose `invoke` delivers what it published before returning. */
+function thenDeliver(adaptor, settle) {
+	const invoke = adaptor.invoke.bind(adaptor);
+	adaptor.invoke = (async (...args) => {
+		const result = await invoke(...args);
+		await settle();
+		return result;
+	});
+	return adaptor;
+}
 function bindToTests(database) {
 	if (bound.has(database)) return;
 	bound.add(database);
@@ -841,6 +961,43 @@ var UnknownFactory = class extends Error {
 		this.name = "UnknownFactory";
 	}
 };
+/** A published message the consumer's own schema refuses. */
+var MessageRejected = class extends Error {
+	consumer;
+	published;
+	issues;
+	constructor(consumer, published, issues) {
+		super(`${consumer} refuses '${published.type}': ${issues.map((issue) => issue.message).join("; ")}. What is published must be what the consumer's schema takes — fix the producer, or the schema.`);
+		this.consumer = consumer;
+		this.published = published;
+		this.issues = issues;
+		this.name = "MessageRejected";
+	}
+};
+/** A consumer that threw while handling what the test published. */
+var DeliveryFailed = class extends Error {
+	consumer;
+	messages;
+	cause;
+	constructor(consumer, messages, cause) {
+		super(`${consumer} failed handling ${messages.map(({ type }) => `'${type}'`).join(", ")}: ${cause?.message ?? String(cause)}. Deployed, the message would be retried; here the failure is the result.`, { cause });
+		this.consumer = consumer;
+		this.messages = messages;
+		this.cause = cause;
+		this.name = "DeliveryFailed";
+	}
+};
+/** Consumers that kept publishing to each other without settling. */
+var DeliveryDidNotSettle = class extends Error {
+	rounds;
+	channels;
+	constructor(rounds, channels) {
+		super(`Delivery did not settle after ${rounds} rounds — consumers are still publishing to ${channels.join(", ")}. A consumer that publishes to what triggers it loops forever deployed too.`);
+		this.rounds = rounds;
+		this.channels = channels;
+		this.name = "DeliveryDidNotSettle";
+	}
+};
 //#endregion
 exports.NoInbox = NoInbox;
 exports.NoTestManifest = NoTestManifest;