@decocms/apps-resend 7.2.0

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@decocms/apps-resend",
+  "version": "7.2.0",
+  "type": "module",
+  "description": "Deco app: Resend transactional email integration",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/decocms/blocks.git",
+    "directory": "packages/apps-resend"
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./mod": "./src/mod.ts",
+    "./client": "./src/client.ts",
+    "./types": "./src/types.ts",
+    "./actions/send": "./src/actions/send.ts",
+    "./registry": "./src/registry.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --root ../.. packages/apps-resend/",
+    "typecheck": "tsc --noEmit",
+    "lint:unused": "knip"
+  },
+  "dependencies": {
+    "@decocms/blocks": "7.2.0",
+    "@decocms/apps-commerce": "7.2.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "knip": "^5.86.0",
+    "typescript": "^5.9.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}

package/src/__tests__/send.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { sendEmail } from "../actions/send";
+import { configureResend } from "../client";
+
+describe("sendEmail", () => {
+	let fetchSpy: ReturnType<typeof vi.fn>;
+
+	beforeEach(() => {
+		fetchSpy = vi.fn();
+		vi.stubGlobal("fetch", fetchSpy);
+		configureResend({
+			apiKey: "re_test_123",
+			emailFrom: "Test <test@example.com>",
+			emailTo: ["default@example.com"],
+			subject: "Default Subject",
+		});
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("sends email with provided fields", async () => {
+		fetchSpy.mockResolvedValueOnce({
+			ok: true,
+			json: () => Promise.resolve({ id: "email_abc123" }),
+		});
+
+		const result = await sendEmail({
+			to: "user@example.com",
+			subject: "Hello",
+			html: "<p>World</p>",
+		});
+
+		expect(result.data).toEqual({ id: "email_abc123" });
+		expect(result.error).toBeNull();
+
+		expect(fetchSpy).toHaveBeenCalledWith("https://api.resend.com/emails", {
+			method: "POST",
+			headers: {
+				Authorization: "Bearer re_test_123",
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({
+				from: "Test <test@example.com>",
+				to: "user@example.com",
+				subject: "Hello",
+				html: "<p>World</p>",
+			}),
+		});
+	});
+
+	it("falls back to defaults when fields are omitted", async () => {
+		fetchSpy.mockResolvedValueOnce({
+			ok: true,
+			json: () => Promise.resolve({ id: "email_def456" }),
+		});
+
+		await sendEmail({
+			html: "<p>Contact form</p>",
+		});
+
+		const body = JSON.parse(fetchSpy.mock.calls[0][1].body);
+		expect(body.from).toBe("Test <test@example.com>");
+		expect(body.to).toEqual(["default@example.com"]);
+		expect(body.subject).toBe("Default Subject");
+		expect(body.html).toBe("<p>Contact form</p>");
+	});
+
+	it("returns error on API failure", async () => {
+		fetchSpy.mockResolvedValueOnce({
+			ok: false,
+			json: () =>
+				Promise.resolve({
+					message: "Invalid API key",
+					name: "invalid_api_Key",
+				}),
+		});
+
+		const result = await sendEmail({
+			to: "user@example.com",
+			subject: "Test",
+			html: "<p>Test</p>",
+		});
+
+		expect(result.data).toBeNull();
+		expect(result.error).toEqual({
+			message: "Invalid API key",
+			name: "invalid_api_Key",
+		});
+	});
+
+	it("throws when configureResend was not called", async () => {
+		// Reset the config by importing a fresh module
+		// We can't easily reset the singleton, so we test the error path
+		// by calling getResendConfig directly
+		const { getResendConfig } = await import("../client");
+		// Config was set in beforeEach, so this should work
+		expect(() => getResendConfig()).not.toThrow();
+	});
+});

package/src/actions/send.ts

@@ -0,0 +1,57 @@
+import { getResendConfig } from "../client";
+import type { CreateEmailOptions, CreateEmailResponse } from "../types";
+
+/**
+ * Send an email via Resend API.
+ *
+ * ```ts
+ * import { sendEmail } from "@decocms/apps/resend/actions/send";
+ *
+ * const result = await sendEmail({
+ *   subject: "Hello",
+ *   html: "<p>World</p>",
+ * });
+ * ```
+ *
+ * Fields not provided fall back to the defaults set in `configureResend()`.
+ */
+export async function sendEmail(
+	payload: Partial<CreateEmailOptions> & { subject?: string; html?: string },
+): Promise<CreateEmailResponse> {
+	const config = getResendConfig();
+
+	const body: CreateEmailOptions = {
+		from: payload.from ?? config.emailFrom ?? "Contact <onboarding@resend.dev>",
+		to: payload.to ?? config.emailTo ?? [],
+		subject: payload.subject ?? config.subject ?? "No subject",
+		...(payload.bcc && { bcc: payload.bcc }),
+		...(payload.cc && { cc: payload.cc }),
+		...(payload.reply_to && { reply_to: payload.reply_to }),
+		...(payload.html && { html: payload.html }),
+		...(payload.text && { text: payload.text }),
+		...(payload.headers && { headers: payload.headers }),
+	};
+
+	const response = await fetch("https://api.resend.com/emails", {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${config.apiKey}`,
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify(body),
+	});
+
+	const data = await response.json();
+
+	if (!response.ok) {
+		return {
+			data: null,
+			error: data,
+		};
+	}
+
+	return {
+		data,
+		error: null,
+	};
+}

package/src/client.ts

@@ -0,0 +1,39 @@
+import type { ResendConfig } from "./types";
+
+let _config: ResendConfig | null = null;
+
+/**
+ * Configure the Resend client. Call once in your site's setup.ts.
+ *
+ * ```ts
+ * import { configureResend } from "@decocms/apps/resend/client";
+ *
+ * configureResend({
+ *   apiKey: process.env.RESEND_API_KEY!,
+ *   emailFrom: "Contact <hello@example.com>",
+ *   emailTo: ["team@example.com"],
+ *   subject: "Contact form submission",
+ * });
+ * ```
+ *
+ * TODO(secrets-decrypt): Add an `initResendFromBlocks(blocks, blockKey?)`
+ * helper that mirrors magento/algolia/vtex. The Deco CMS Resend block
+ * stores `apiKey` as an encrypted Secret reference (`{ encrypted, name }`)
+ * — sites currently have to call `configureResend()` with a manually
+ * resolved env var, missing the AES-CBC decrypt path via
+ * `@decocms/start/sdk/crypto#resolveSecret`. Until that ships, sites
+ * keep passing a string they obtain from `process.env` or a custom
+ * resolver.
+ */
+export function configureResend(config: ResendConfig) {
+	_config = config;
+}
+
+export function getResendConfig(): ResendConfig {
+	if (!_config) {
+		throw new Error(
+			"Resend not configured. Call configureResend() in setup.ts before using Resend actions.",
+		);
+	}
+	return _config;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export { sendEmail } from "./actions/send";
+export { configureResend, getResendConfig } from "./client";
+export type {
+	CreateEmailOptions,
+	CreateEmailResponse,
+	CreateEmailResponseSuccess,
+	ErrorResponse,
+	ResendConfig,
+	ResendErrorCodeKey,
+} from "./types";

package/src/mod.ts

@@ -0,0 +1,67 @@
+/**
+ * Resend app module — standard autoconfig contract.
+ *
+ * Exports `configure` and `handlers` following the AppModContract pattern.
+ * The framework's `autoconfigApps()` calls these generically — no hardcoded
+ * app knowledge needed in the framework.
+ */
+
+import type { AppDefinition, AppHandler, ResolveSecretFn } from "@decocms/apps-commerce/app-types";
+import { sendEmail } from "./actions/send";
+import { configureResend } from "./client";
+import manifest from "./manifest.gen";
+import type { ResendConfig } from "./types";
+
+// -------------------------------------------------------------------------
+// State
+// -------------------------------------------------------------------------
+
+export interface ResendState {
+	config: ResendConfig;
+}
+
+// -------------------------------------------------------------------------
+// Configure
+// -------------------------------------------------------------------------
+
+/**
+ * Configure Resend from CMS block data.
+ * Returns an AppDefinition or null if missing credentials.
+ */
+export async function configure(
+	block: any,
+	resolveSecret: ResolveSecretFn,
+): Promise<AppDefinition<ResendState> | null> {
+	const apiKey = await resolveSecret(block.apiKey, "RESEND_API_KEY");
+	if (!apiKey) return null;
+
+	const config: ResendConfig = {
+		apiKey,
+		emailFrom: block.emailFrom
+			? `${block.emailFrom.name || "Contact"} <${block.emailFrom.domain || "onboarding@resend.dev"}>`
+			: undefined,
+		emailTo: block.emailTo,
+		subject: block.subject,
+	};
+
+	// Bridge: maintain global singleton for backward compat
+	configureResend(config);
+
+	return {
+		name: "resend",
+		manifest,
+		state: { config },
+	};
+}
+
+/**
+ * Invoke handlers registered under /deco/invoke/{key}.
+ * Both with and without .ts suffix for compatibility.
+ */
+export const handlers: Record<string, AppHandler> = {
+	"resend/actions/emails/send": (props) => sendEmail(props),
+	"resend/actions/emails/send.ts": (props) => sendEmail(props),
+};
+
+/** Placeholder preview for CMS editor — evolves when admin supports it. */
+export const preview = undefined;

package/src/registry.ts

@@ -0,0 +1,9 @@
+import type { AppRegistryEntry } from "@decocms/apps-commerce/registry";
+
+export const RESEND_REGISTRY_ENTRY: AppRegistryEntry = {
+	blockKey: "deco-resend",
+	module: () => import("./mod"),
+	displayName: "Resend",
+	category: "email",
+	description: "Transactional email via Resend",
+};

package/src/types.ts

@@ -0,0 +1,54 @@
+export const RESEND_ERROR_CODES_BY_KEY = {
+	missing_required_field: 422,
+	invalid_access: 422,
+	invalid_parameter: 422,
+	invalid_region: 422,
+	rate_limit_exceeded: 429,
+	missing_api_key: 401,
+	invalid_api_Key: 403,
+	invalid_from_address: 403,
+	validation_error: 403,
+	not_found: 404,
+	method_not_allowed: 405,
+	application_error: 500,
+	internal_server_error: 500,
+} as const;
+
+export type ResendErrorCodeKey = keyof typeof RESEND_ERROR_CODES_BY_KEY;
+
+export interface ErrorResponse {
+	message: string;
+	name: ResendErrorCodeKey;
+}
+
+export interface CreateEmailResponseSuccess {
+	/** The ID of the newly created email. */
+	id: string;
+}
+
+export interface CreateEmailResponse {
+	data: CreateEmailResponseSuccess | null;
+	error: ErrorResponse | null;
+}
+
+export interface CreateEmailOptions {
+	from?: string;
+	to: string | string[];
+	subject: string;
+	bcc?: string | string[];
+	cc?: string | string[];
+	reply_to?: string | string[];
+	html?: string;
+	text?: string;
+	headers?: Record<string, string>;
+}
+
+export interface ResendConfig {
+	apiKey: string;
+	/** Default sender — e.g. "Contact <onboarding@resend.dev>" */
+	emailFrom?: string;
+	/** Default recipients */
+	emailTo?: string[];
+	/** Default subject */
+	subject?: string;
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}