@geekmidas/cloud 10.0.0-alpha.13 → 10.0.0-alpha.14

package/package.json

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

package/src/dokploy/Application.ts

@@ -195,6 +195,45 @@ const provider: dynamic.ResourceProvider<
 	},
 };
 
+/**
+ * A Dokploy API call that answered with an error status.
+ *
+ * Defined here, beside the provider, rather than imported: the provider's
+ * functions are serialised into state, and Pulumi's closure serialiser
+ * captures a class declared in the same module by value — once, shared by
+ * every function that refers to it, so `instanceof` still holds in the
+ * deployed provider. An imported class would have to be resolvable as a
+ * module where the provider runs, which is the obscure failure the note on
+ * `call` below is about.
+ *
+ * Serialisation rewrites the class into a plain function and drops its link to
+ * `Error.prototype`, so the constructor sets `message` and `stack` itself and
+ * the class says how to print itself. `Application.provider.spec.ts` runs the
+ * serialised provider to keep all of this true.
+ */
+export class DokployCallFailed extends Error {
+	constructor(
+		readonly path: string,
+		readonly status: number,
+		readonly statusText: string,
+		readonly detail: string,
+	) {
+		const message = `Dokploy ${path} failed: ${status} ${statusText}${detail ? ` — ${detail}` : ''}. Check the endpoint and API token, and Dokploy's own logs for the request.`;
+		super(message);
+		// Serialised, this constructor becomes a plain function whose super call
+		// does not initialise `this`: without these the provider host, which
+		// reports `e.message` and logs `${e}: ${e.stack}`, would show nothing.
+		this.message = message;
+		Error.captureStackTrace?.(this, DokployCallFailed);
+		this.name = 'DokployCallFailed';
+	}
+
+	/** What `${error}` prints once serialisation has dropped Error's own. */
+	override toString(): string {
+		return `${this.name}: ${this.message}`;
+	}
+}
+
 /**
  * One call to Dokploy.
  *
@@ -218,10 +257,11 @@ async function call<T>(
 
 	if (!response.ok) {
 		const detail = await response.text().catch(() => '');
-		throw new Error(
-			`Dokploy ${path} failed: ${response.status} ${response.statusText}${
-				detail ? ` — ${detail}` : ''
-			}`,
+		throw new DokployCallFailed(
+			path,
+			response.status,
+			response.statusText,
+			detail,
 		);
 	}
 
@@ -230,7 +270,7 @@ async function call<T>(
 
 /** Whether an error means the thing is already absent. */
 function isNotFound(error: unknown): boolean {
-	return error instanceof Error && /\b404\b/.test(error.message);
+	return error instanceof DokployCallFailed && error.status === 404;
 }
 
 export interface ApplicationArgs {

package/src/dokploy/__tests__/Application.provider.spec.ts

@@ -1,7 +1,12 @@
+import { runInNewContext } from 'node:vm';
+import { runtime } from '@pulumi/pulumi';
 import { HttpResponse, http } from 'msw';
 import { setupServer } from 'msw/node';
 import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest';
-import { applicationProvider as provider } from '../Application';
+import {
+	DokployCallFailed,
+	applicationProvider as provider,
+} from '../Application';
 
 /**
  * The provider against Dokploy's tRPC API, served by MSW: what each lifecycle
@@ -132,8 +137,13 @@ describe('Dokploy application provider', () => {
 			}),
 		);
 		await expect(provider.delete!('app-1', outs)).rejects.toThrow(
-			'Dokploy application.remove failed: 500 Internal Server Error — database is locked',
+			DokployCallFailed,
 		);
+		await expect(provider.delete!('app-1', outs)).rejects.toMatchObject({
+			path: 'application.remove',
+			status: 500,
+			detail: 'database is locked',
+		});
 
 		server.resetHandlers();
 		answer(
@@ -141,8 +151,56 @@ describe('Dokploy application provider', () => {
 			'application.create',
 			() => new HttpResponse(null, { status: 401, statusText: 'Unauthorized' }),
 		);
-		await expect(provider.create!(inputs)).rejects.toThrow(
-			'Dokploy application.create failed: 401 Unauthorized',
+		await expect(provider.create!(inputs)).rejects.toMatchObject({
+			name: 'DokployCallFailed',
+			status: 401,
+		});
+	});
+
+	/**
+	 * What actually runs: Pulumi serialises the provider into state and the
+	 * deploy runs that text, not this module. Serialisation rewrites
+	 * `DokployCallFailed` into a plain function that drops `Error.prototype` and
+	 * never initialises `message` — which the provider host reports — so this
+	 * runs the serialised provider and checks the error still says something.
+	 */
+	it('still recognises a 404, and reports a failure, once serialised', async () => {
+		const serialised = await runtime.serializeFunction(() => provider, {
+			isFactoryFunction: true,
+		});
+		const module = { exports: {} as Record<string, typeof provider> };
+		runInNewContext(serialised.text, {
+			module,
+			exports: module.exports,
+			require,
+			global: globalThis,
+			fetch: (...args: Parameters<typeof fetch>) => fetch(...args),
+			Error,
+		});
+		const deployed = module.exports[serialised.exportName]!;
+
+		answer('post', 'application.remove', () =>
+			HttpResponse.json({}, { status: 404, statusText: 'Not Found' }),
+		);
+		await expect(deployed.delete!('app-1', outs)).resolves.toBeUndefined();
+
+		server.resetHandlers();
+		answer('post', 'application.remove', () =>
+			HttpResponse.text('database is locked', {
+				status: 500,
+				statusText: 'Internal Server Error',
+			}),
+		);
+		const failure = await deployed.delete!('app-1', outs).catch(
+			(error: unknown) => error as Error & { status: number },
+		);
+		expect(failure).toMatchObject({ name: 'DokployCallFailed', status: 500 });
+		expect(failure?.message).toContain(
+			'Dokploy application.remove failed: 500 Internal Server Error — database is locked',
+		);
+		expect(failure?.stack).toBeTruthy();
+		expect(`${failure}`).toMatch(
+			/^DokployCallFailed: Dokploy application\.remove failed/,
 		);
 	});
 });

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { App } from '../App';
-import { Api } from '../aws/Api';
+import { Api, RoutesMissingEnvironment } from '../aws/Api';
 import { type GkmLinkable, ResourceType } from '../Linkable';
 
 /**
@@ -167,6 +167,7 @@ describe('Api', () => {
 				],
 			});
 
+		expect(build).toThrow(RoutesMissingEnvironment);
 		expect(build).toThrow(/Http POST \/pay[\s\S]*STRIPE_KEY/);
 		expect(build).toThrow(/Http GET \/mail[\s\S]*SMTP_URL/);
 	});

package/src/sst/aws/Api.ts

@@ -153,7 +153,7 @@ export class Api<
 		// Fail the whole synth if any route is misconfigured, with one actionable
 		// message per offending route.
 		if (failures.length) {
-			throw new Error(failures.map((f) => f.message).join('\n\n'));
+			throw new RoutesMissingEnvironment(id, failures);
 		}
 	}
 
@@ -307,3 +307,18 @@ export interface ApiProps<TAuthorizers extends Record<string, unknown> = {}>
 	 * may override it. */
 	runtime?: sst.aws.FunctionArgs['runtime'];
 }
+
+/**
+ * Routes that read variables nothing links or whitelists. Collected across
+ * every route so one synth reports all of them, each with its own suggestions,
+ * rather than stopping at the first.
+ */
+export class RoutesMissingEnvironment extends Error {
+	constructor(
+		readonly api: string,
+		readonly failures: readonly EnvValidationError[],
+	) {
+		super(failures.map((f) => f.message).join('\n\n'));
+		this.name = 'RoutesMissingEnvironment';
+	}
+}