@geekmidas/cloud 10.0.0-alpha.123 → 10.0.0-alpha.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cloud",
-  "version": "10.0.0-alpha.123",
+  "version": "10.0.0-alpha.125",
   "type": "module",
   "files": [
     "dist",
@@ -41,8 +41,8 @@
   },
   "dependencies": {
     "lodash.snakecase": "~4.1.1",
-    "@geekmidas/envkit": "10.0.0-alpha.123",
-    "@geekmidas/manifest": "10.0.0-alpha.123"
+    "@geekmidas/envkit": "10.0.0-alpha.125",
+    "@geekmidas/manifest": "10.0.0-alpha.125"
   },
   "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.123",
-    "@geekmidas/storage": "^10.0.0-alpha.123",
-    "@geekmidas/events": "^10.0.0-alpha.123",
-    "@geekmidas/db": "^10.0.0-alpha.123"
+    "@geekmidas/manifest": "^10.0.0-alpha.125",
+    "@geekmidas/storage": "^10.0.0-alpha.125",
+    "@geekmidas/events": "^10.0.0-alpha.125",
+    "@geekmidas/db": "^10.0.0-alpha.125"
   },
   "peerDependenciesMeta": {
     "@geekmidas/manifest": {

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

@@ -16,6 +16,7 @@ import {
 	type ProvisionedManifest,
 	provisionCompute,
 	provisionerFor,
+	provisionProcessors,
 	resolveEdges,
 	subscribeConsumers,
 	vpcFor,
@@ -556,6 +557,78 @@ describe('functions and crons', () => {
 	});
 });
 
+describe("a file server's processors", () => {
+	const stack = new App({
+		name: 'shop',
+		stage: 'production',
+		domain: 'example.com',
+		hostedZoneId: 'Z',
+		region: 'eu-west-1',
+	}).stack('media');
+	const argsOf = (component: unknown) =>
+		(component as { args: Record<string, any> }).args;
+
+	it('are Lambdas behind IAM-auth URLs, served through the router on their prefix', () => {
+		const media = { _id: 'Media', _type: 'sst.aws.Bucket' };
+		const router = { _id: 'MediaServer' };
+		const provisioned = {
+			Media: media,
+			MediaServer: router,
+		} as unknown as ProvisionedManifest;
+
+		const [thumbnails, pages] = provisionProcessors(
+			stack,
+			{
+				Media: { kind: 'objects', id: 'Media', provides: ['MEDIA_URL'] },
+				MediaServer: {
+					kind: 'file-server',
+					id: 'MediaServer',
+					of: 'Media',
+					processors: [
+						{
+							id: 'thumbnails',
+							handler: 'apps/api/.gkm/aws/processors/thumbnails.handler',
+							path: '/i/:width/*',
+							prefix: '/i/',
+							native: ['sharp'],
+							timeout: 15_000,
+							memorySize: 1536,
+							dependencies: [{ target: 'Media', kind: 'objects' }],
+						},
+						{
+							id: 'pages',
+							handler: 'apps/api/.gkm/aws/processors/pages.handler',
+							path: '/pdf/:page/*',
+							prefix: '/pdf/',
+							dependencies: [{ target: 'Media', kind: 'objects' }],
+						},
+					],
+				},
+			} as never,
+			provisioned,
+		);
+
+		expect(thumbnails).toBeInstanceOf(Function);
+		expect(argsOf(thumbnails)).toMatchObject({
+			name: stack.logicalPrefixedName('MediaServerthumbnails'),
+			handler: 'apps/api/.gkm/aws/processors/thumbnails.handler',
+			link: [media],
+			timeout: '15 seconds',
+			memory: '1536 MB',
+			// Installed for the Lambda, never bundled.
+			nodejs: { install: ['sharp'] },
+			url: {
+				authorization: 'iam',
+				router: { instance: router, path: '/i' },
+			},
+		});
+		expect(argsOf(pages)).toMatchObject({
+			url: { router: { path: '/pdf' } },
+		});
+		expect(argsOf(pages).nodejs).toBeUndefined();
+	});
+});
+
 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,

package/src/sst/fromManifest.ts

@@ -839,6 +839,65 @@ export function provisionCompute(
 	return crons;
 }
 
+/**
+ * Every file server's processors: each a Lambda behind a function URL with
+ * IAM auth, served through the file server's router on its pattern's prefix
+ * — so the CDN signs each request (origin access control) and the URL cannot
+ * be called around the cache. Linked to the bucket it reads and what it
+ * depends on; its native packages installed for the Lambda, not bundled.
+ *
+ * After everything else, for the reason {@link provisionCompute} is.
+ */
+export function provisionProcessors(
+	stack: StackType,
+	manifest: ConstructManifest,
+	provisioned: ProvisionedManifest,
+): Function[] {
+	const lambdas: Function[] = [];
+
+	for (const [id, declaration] of Object.entries(manifest)) {
+		if (declaration?.kind !== 'file-server') continue;
+		const router = provisioned[id];
+		if (!router) continue;
+
+		for (const processor of declaration.processors ?? []) {
+			const { link } = resolveEdges(processor.dependencies, provisioned);
+			const vpc = vpcFor(link);
+			const native = processor.native ?? [];
+			lambdas.push(
+				new Function(stack, `${id}${processor.id}`, {
+					name: stack.logicalPrefixedName(`${id}${processor.id}`),
+					handler: processor.handler,
+					link,
+					...(vpc ? { vpc } : {}),
+					...(processor.timeout !== undefined
+						? {
+								timeout:
+									`${Math.ceil(processor.timeout / 1000)} seconds` as sst.aws.FunctionArgs['timeout'],
+							}
+						: {}),
+					...(processor.memorySize !== undefined
+						? {
+								memory:
+									`${processor.memorySize} MB` as sst.aws.FunctionArgs['memory'],
+							}
+						: {}),
+					...(native.length ? { nodejs: { install: [...native] } } : {}),
+					url: {
+						authorization: 'iam',
+						router: {
+							instance: router as unknown as sst.aws.Router,
+							path: processor.prefix.replace(/\/$/, ''),
+						},
+					},
+				}),
+			);
+		}
+	}
+
+	return lambdas;
+}
+
 /** A provisioned queue: what {@link subscribeConsumers} subscribes through. */
 interface Consumable {
 	consume(consumer: {
@@ -1051,6 +1110,7 @@ export function fromManifest<
 	// The functions and crons, each queue's one consumer and each surface's
 	// endpoints, once everything they link to exists.
 	provisionCompute(stack, manifest, provisioned);
+	provisionProcessors(stack, manifest, provisioned);
 	subscribeConsumers(manifest, provisioned);
 	mountRoutes(manifest, provisioned);