@geekmidas/cloud 10.0.0-alpha.38 → 10.0.0-alpha.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cloud",
-  "version": "10.0.0-alpha.38",
+  "version": "10.0.0-alpha.39",
   "type": "module",
   "files": [
     "dist",
@@ -41,8 +41,8 @@
   },
   "dependencies": {
     "lodash.snakecase": "~4.1.1",
-    "@geekmidas/envkit": "10.0.0-alpha.38",
-    "@geekmidas/manifest": "10.0.0-alpha.38"
+    "@geekmidas/envkit": "10.0.0-alpha.39",
+    "@geekmidas/manifest": "10.0.0-alpha.39"
   },
   "devDependencies": {
     "@types/lodash.get": "~4.4.9",
@@ -58,10 +58,10 @@
     "@pulumi/aws": ">=7.47.0",
     "@pulumi/random": ">=4.21.2",
     "@pulumi/pulumi": ">=3.263.0",
-    "@geekmidas/manifest": "^10.0.0-alpha.38",
-    "@geekmidas/storage": "^10.0.0-alpha.38",
-    "@geekmidas/events": "^10.0.0-alpha.38",
-    "@geekmidas/db": "^10.0.0-alpha.38"
+    "@geekmidas/manifest": "^10.0.0-alpha.39",
+    "@geekmidas/storage": "^10.0.0-alpha.39",
+    "@geekmidas/events": "^10.0.0-alpha.39",
+    "@geekmidas/db": "^10.0.0-alpha.39"
   },
   "peerDependenciesMeta": {
     "@geekmidas/manifest": {

package/src/sst/__tests__/fromManifest.integration.spec.ts

@@ -44,6 +44,12 @@ function manifest(): ConstructManifest {
 			id: 'Emails',
 			fifo: true,
 			provides: keys('Emails', 'queue', ['publisherConnectionString']),
+			// The queue's one consumer, as the build folds it in.
+			worker: {
+				id: 'EmailsWorker',
+				handler: '.gkm/aws-lambda/queues/emails.handler',
+				dependencies: [{ target: 'Uploads', kind: 'objects' }],
+			},
 		},
 		Users: {
 			kind: 'topic',
@@ -172,6 +178,27 @@ describe('fromManifest', () => {
 		expect(argsOf(provisioned.Orders)).toMatchObject({ vpc, version: '18' });
 	});
 
+	it('subscribes each queue’s one consumer, linked to the queue and what it reaches', () => {
+		vi.spyOn(console, 'log').mockImplementation(() => {});
+
+		const provisioned = fromManifest(stack, manifest(), overrides, {
+			cache: 'db',
+			email: 'smtp',
+		});
+		const { subscribed } = provisioned.Emails as unknown as {
+			subscribed: { subscriber: { handler: string; link: unknown[] } }[];
+		};
+
+		expect(subscribed).toHaveLength(1);
+		expect(subscribed[0]?.subscriber.handler).toBe(
+			'.gkm/aws-lambda/queues/emails.handler',
+		);
+		expect(subscribed[0]?.subscriber.link).toEqual([
+			provisioned.Emails,
+			provisioned.Uploads,
+		]);
+	});
+
 	it('builds the site against the addresses its edges resolve to', () => {
 		vi.spyOn(console, 'log').mockImplementation(() => {});
 

package/src/sst/__tests__/fromManifest.spec.ts

@@ -5,9 +5,11 @@ import { ObjectStorage } from '../aws/ObjectStorage';
 import { type ProvidesMismatch, UnknownDeclarationKind } from '../errors';
 import {
 	assertProvides,
+	PROVISIONED_ELSEWHERE,
 	type ProvisionedManifest,
 	provisionerFor,
 	resolveEdges,
+	subscribeConsumers,
 } from '../fromManifest';
 
 /**
@@ -337,3 +339,64 @@ describe('ExternalApi', () => {
 		).toEqual(['PAY_FAST_CREDENTIALS', 'PAY_FAST_URL']);
 	});
 });
+
+describe('a queue’s one consumer', () => {
+	it('is subscribed from the handler the build wrote, linked to what it depends on', () => {
+		const consumed: { handler: string; link?: unknown[] }[] = [];
+		const uploads = { _id: 'Uploads', _type: 'sst.aws.Bucket' };
+		const provisioned = {
+			Uploads: uploads,
+			Emails: {
+				_id: 'Emails',
+				_type: 'sst.aws.Queue',
+				consume: (consumer: { handler: string; link?: unknown[] }) =>
+					consumed.push(consumer),
+			},
+		} as unknown as ProvisionedManifest;
+
+		subscribeConsumers(
+			{
+				Uploads: { kind: 'objects', id: 'Uploads', provides: ['UPLOADS_URL'] },
+				Emails: {
+					kind: 'queue',
+					id: 'Emails',
+					provides: ['EMAILS_PUBLISHER_CONNECTION_STRING'],
+					worker: {
+						id: 'EmailsWorker',
+						handler: '.gkm/aws-lambda/queues/emails.handler',
+						dependencies: [{ target: 'Uploads', kind: 'objects' }],
+					},
+				},
+			} as never,
+			provisioned,
+		);
+
+		expect(consumed).toEqual([
+			{ handler: '.gkm/aws-lambda/queues/emails.handler', link: [uploads] },
+		]);
+	});
+
+	it('subscribes through SST, with the queue itself linked', async () => {
+		const { Queue } = await import('../aws/Queue');
+		const queue = new Queue({} as never, 'Emails');
+
+		queue.consume({ handler: 'emails.handler', link: [], batchSize: 5 });
+
+		const [{ subscriber, args }] = (
+			queue as unknown as { subscribed: { subscriber: any; args: unknown }[] }
+		).subscribed;
+		expect(subscriber.handler).toBe('emails.handler');
+		expect(subscriber.link).toEqual([queue]);
+		expect(args).toEqual({ batch: { size: 5 } });
+	});
+});
+
+describe('kinds provisioned elsewhere', () => {
+	it('skips a worker, which is a process rather than a resource', () => {
+		// A worker in the manifest used to throw UnknownDeclarationKind at synth,
+		// so any app with background work could not be deployed to AWS at all.
+		expect(PROVISIONED_ELSEWHERE.has('worker')).toBe(true);
+		expect(PROVISIONED_ELSEWHERE.has('mobile-app')).toBe(true);
+		expect(PROVISIONED_ELSEWHERE.has('queue')).toBe(false);
+	});
+});

package/src/sst/aws/Queue.ts

@@ -11,7 +11,8 @@ import type { StackType } from '../Stack';
  * work queue. Link it to a producer and the runtime resolves `<NAME>_URL`,
  * `<NAME>_ARN`, and a `<NAME>_PUBLISHER_CONNECTION_STRING` (`sqs://?queueUrl=…`)
  * that `@geekmidas/events`'s `Publisher.fromConnectionString` consumes. Its
- * single consumer is wired by `QueueSubscriber`.
+ * one consumer — the handler the queue was declared with — is subscribed by
+ * {@link Queue.consume}.
  *
  * SST's native `Queue` link exposes only `url`, so `getSSTLink` is overridden to
  * also expose `arn` (what the resolver needs). `QueueProps` extends
@@ -73,6 +74,25 @@ export class Queue<
 		};
 	}
 
+	/**
+	 * Subscribe the queue's one consumer: a Lambda running `handler`, linked to
+	 * what the consumer depends on and to this queue itself.
+	 *
+	 * A queue has exactly one consumer, so this is called once per queue — by
+	 * `fromManifest`, from the handler the build wrote for it.
+	 */
+	consume(consumer: QueueConsumer) {
+		return this.subscribe(
+			{
+				handler: consumer.handler,
+				link: [this, ...(consumer.link ?? [])],
+				runtime: 'nodejs24.x',
+				...(consumer.timeout ? { timeout: consumer.timeout } : {}),
+			},
+			consumer.batchSize ? { batch: { size: consumer.batchSize } } : {},
+		);
+	}
+
 	override getSSTLink() {
 		const link = super.getSSTLink();
 		return {
@@ -82,6 +102,16 @@ export class Queue<
 	}
 }
 
+/** The queue's one consumer, as {@link Queue.consume} subscribes it. */
+export interface QueueConsumer {
+	/** The built handler — `.gkm/aws-lambda/queues/emails.handler`. */
+	handler: string;
+	/** What the consumer depends on; the queue itself is always linked. */
+	link?: unknown[];
+	timeout?: `${number} seconds` | `${number} minutes`;
+	batchSize?: number;
+}
+
 export interface QueueProps extends sst.aws.QueueArgs {
 	/**
 	 * The physical queue name, where the auto-generated one will not do.

package/src/sst/fromManifest.ts

@@ -750,6 +750,46 @@ export function isServed(id: string, manifest: ConstructManifest): boolean {
 	);
 }
 
+/**
+ * Kinds this stack provisions nothing for of their own.
+ *
+ * - `mobile-app` ships through EAS and the stores. It is in the manifest for
+ *   what it makes the surfaces trust, which `callersOf` reads off the graph.
+ * - `worker` is a process, not a resource: what it runs is provisioned as
+ *   what it is — a queue's consumer by {@link subscribeConsumers}.
+ * - `cron` and `function` are Lambdas built from `manifest.crons` and
+ *   `manifest.functions` (`Cron.fromManifest`, `Function.fromManifest`).
+ */
+export const PROVISIONED_ELSEWHERE: ReadonlySet<DeclarationKind> =
+	new Set<DeclarationKind>(['mobile-app', 'worker', 'cron', 'function']);
+
+/** A provisioned queue: what {@link subscribeConsumers} subscribes through. */
+interface Consumable {
+	consume(consumer: { handler: string; link?: unknown[] }): unknown;
+}
+
+/**
+ * Subscribe every queue's one consumer — the handler the build wrote for it,
+ * linked to what that consumer depends on.
+ *
+ * After every construct is provisioned, because a consumer links to things
+ * that `provisionOrder` does not order before the queue.
+ */
+export function subscribeConsumers(
+	manifest: ConstructManifest,
+	provisioned: ProvisionedManifest,
+): void {
+	for (const [id, declaration] of Object.entries(manifest)) {
+		if (declaration?.kind !== 'queue') continue;
+
+		const queue = provisioned[id] as unknown as Consumable | undefined;
+		if (!queue) continue;
+
+		const { link } = resolveEdges(declaration.worker.dependencies, provisioned);
+		queue.consume({ handler: declaration.worker.handler, link });
+	}
+}
+
 /** The provisioner for a kind. Pure — the lookup is testable without Pulumi. */
 export function provisionerFor(kind: DeclarationKind): Provisioner {
 	const provisioner = PROVISIONERS[kind];
@@ -838,10 +878,7 @@ export function fromManifest(
 	for (const id of [...rest, ...sites]) {
 		const declaration = manifest[id];
 		if (!declaration) continue;
-		// A mobile app ships through EAS and the stores, not this stack. It is
-		// in the manifest for what it makes the surfaces trust, which
-		// `callersOf` reads off the graph.
-		if (declaration.kind === 'mobile-app') continue;
+		if (PROVISIONED_ELSEWHERE.has(declaration.kind)) continue;
 
 		const component = provisionerFor(declaration.kind)(
 			stack,
@@ -865,6 +902,9 @@ export function fromManifest(
 		provisioned[id] = component;
 	}
 
+	// Each queue's one consumer, once everything it links to exists.
+	subscribeConsumers(manifest, provisioned);
+
 	for (const line of describeRoutes(manifest)) console.log(line);
 
 	// Now everything exists, so every surface's callers can be resolved — the