@decocms/apps-resend 8.1.0-next.0 → 8.1.0-next.1

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@decocms/apps-resend",
-  "version": "8.1.0-next.0",
+  "version": "8.1.0-next.1",
   "type": "module",
-  "description": "Deco app: Resend transactional email integration",
+  "description": "Thin Resend email API client for Deco sites",
   "repository": {
     "type": "git",
     "url": "https://github.com/decocms/blocks.git",
@@ -10,35 +10,22 @@
   },
   "files": [
     "src",
-    "tsconfig.json"
+    "!src/**/*.test.ts",
+    "!src/**/__tests__"
   ],
   "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"
+    ".": "./src/index.ts"
   },
   "scripts": {
     "build": "tsc",
     "test": "vitest run --root ../.. packages/apps-resend/",
-    "typecheck": "tsc --noEmit",
-    "lint:unused": "knip"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@decocms/blocks": "8.1.0-next.0",
-    "@decocms/apps-commerce": "8.1.0-next.0"
-  },
-  "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "@decocms/blocks": "8.1.0-next.1"
   },
   "devDependencies": {
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
-    "knip": "^5.86.0",
     "typescript": "^5.9.0"
   },
   "publishConfig": {

package/src/index.ts

@@ -1,12 +1,7 @@
 /**
  * `@decocms/apps-resend`: the Resend client (`createResendClient`).
  * See /next/upstream-clients.
- *
- * `sendEmail`, `configureResend` and `getResendConfig` are the v7 surface,
- * kept for v7 sites.
  */
-export { sendEmail } from "./actions/send";
-export { configureResend, getResendConfig } from "./client";
 export {
   createResendClient,
   type ResendClient,
@@ -14,11 +9,4 @@ export {
   ResendError,
   type SendEmailOptions,
 } from "./emails";
-export type {
-  CreateEmailOptions,
-  CreateEmailResponse,
-  CreateEmailResponseSuccess,
-  ErrorResponse,
-  ResendConfig,
-  ResendErrorCodeKey,
-} from "./types";
+export type { CreateEmailOptions, CreateEmailResponseSuccess } from "./types";

package/src/types.ts

@@ -1,54 +1,18 @@
-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;
-}
+// The Resend API shapes the client sends and receives (https://resend.com/docs/api-reference/emails/send-email).
 
 export interface CreateEmailResponseSuccess {
-	/** The ID of the newly created email. */
-	id: string;
-}
-
-export interface CreateEmailResponse {
-	data: CreateEmailResponseSuccess | null;
-	error: ErrorResponse | null;
+  /** The ID of the newly created email. */
+  id: string;
 }
 
 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;
+  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>;
 }

package/src/__tests__/emails.test.ts

@@ -1,54 +0,0 @@
-/**
- * The v8 Resend client (/next/upstream-clients): one typed call through the
- * instrumented fetch, errors without bodies or keys, no retries.
- */
-import { describe, expect, it, vi } from "vitest";
-import { createResendClient, ResendError } from "../index";
-
-function fakeFetch(status: number, body: unknown) {
-  return vi.fn(
-    async (_input: string | URL | Request, _init?: RequestInit) =>
-      new Response(JSON.stringify(body), { status }),
-  );
-}
-
-const email = {
-  from: "Store <hello@example.com>",
-  to: "shopper@example.com",
-  subject: "Your order",
-  html: "<p>Thanks</p>",
-};
-
-describe("createResendClient", () => {
-  it("sendEmail posts the email with the API key and returns its id", async () => {
-    const fetch = fakeFetch(200, { id: "email_1" });
-    const resend = createResendClient({ apiKey: "re_test" }, { fetch });
-
-    await expect(resend.sendEmail(email)).resolves.toEqual({ id: "email_1" });
-
-    const [url, init] = fetch.mock.calls[0];
-    expect(String(url)).toBe("https://api.resend.com/emails");
-    expect(init?.method).toBe("POST");
-    expect(init?.headers).toMatchObject({ authorization: "Bearer re_test" });
-    expect(JSON.parse(String(init?.body))).toEqual(email);
-  });
-
-  it("throws the operation and status, never the body or the key", async () => {
-    const fetch = fakeFetch(422, { name: "validation_error", message: "re_test is bad" });
-    const resend = createResendClient({ apiKey: "re_test" }, { fetch });
-
-    const error = await resend.sendEmail(email).catch((e: unknown) => e);
-
-    expect(error).toBeInstanceOf(ResendError);
-    expect(error).toMatchObject({ operation: "sendEmail", status: 422 });
-    expect((error as Error).message).not.toContain("re_test");
-  });
-
-  it("does not retry", async () => {
-    const fetch = fakeFetch(503, {});
-    const resend = createResendClient({ apiKey: "re_test" }, { fetch });
-
-    await expect(resend.sendEmail(email)).rejects.toThrow(ResendError);
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-});

package/src/__tests__/send.test.ts

@@ -1,105 +0,0 @@
-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",
-			expect.objectContaining({
-				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>",
-				}),
-				signal: expect.any(AbortSignal),
-			}),
-		);
-	});
-
-	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

@@ -1,60 +0,0 @@
-import { withFetchTimeout } from "@decocms/blocks/sdk/fetchTimeout";
-import { getResendConfig } from "../client";
-import type { CreateEmailOptions, CreateEmailResponse } from "../types";
-
-const timeoutFetch = withFetchTimeout();
-
-/**
- * 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 timeoutFetch("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

@@ -1,39 +0,0 @@
-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/manifest.gen.ts

@@ -1,15 +0,0 @@
-// AUTO-GENERATED by scripts/generate-manifests.ts — DO NOT EDIT
-// This file is checked into source control and updated via: npm run generate:manifests
-import * as actions_send from "./actions/send";
-
-const manifest = {
-	name: "resend",
-	loaders: {},
-	actions: {
-		"resend/actions/send": actions_send,
-	},
-	sections: {},
-} as const;
-
-export type Manifest = typeof manifest;
-export default manifest;

package/src/mod.ts

@@ -1,67 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-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/tsconfig.json

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