@thomasfosterau/effect-connect-resend 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Foster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,119 @@
-# @thomasfosterau/effect-connect-resend
+# `@thomasfosterau/effect-connect-resend`
 
-Placeholder reserved for npm trusted publishing; the first real release is 0.1.0, from https://github.com/thomasfosterau/effect-connect.
+The Resend provider for [`@thomasfosterau/effect-connect`](https://github.com/thomasfosterau/effect-connect/tree/trunk/packages/core#readme): `POST /emails` over Effect's `HttpClient` (`effect/http`) with no SDK, a `Redacted` API key, a no-op layer for un-provisioned stages and an env-driven resolver that picks between the two.
+
+This package was created using Claude Code, and its API is in flux: expect churn and breaking changes.
+
+## Install
+
+```bash
+pnpm add @thomasfosterau/effect-connect-resend @thomasfosterau/effect-connect effect
+```
+
+`effect` (`^4.0.0`) is a required peer dependency. Node.js 22 or newer is required. Nothing here is Node-shaped: the provider runs on Cloudflare Workers and in browsers as well as on Node.
+
+## Usage
+
+```ts
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { FetchHttpClient } from "effect/http";
+import { EmailService } from "@thomasfosterau/effect-connect";
+import * as Resend from "@thomasfosterau/effect-connect-resend";
+
+const EmailLive = Resend.layer({ apiKey: Redacted.make(process.env.RESEND_API_KEY!) }).pipe(
+  Layer.provide(FetchHttpClient.layer),
+);
+
+const program = Effect.gen(function* () {
+  const email = yield* EmailService;
+  const result = yield* email.send({
+    from: { email: "noreply@example.com", name: "Example" },
+    to: [{ email: "reader@example.com" }],
+    subject: "Welcome",
+    text: "Welcome aboard.",
+    html: "<p>Welcome aboard.</p>",
+  });
+  // result.id is Resend's email id, as an Option (always `some` here)
+});
+```
+
+`Resend.layerConfig` reads `RESEND_API_KEY` (and an optional `RESEND_BASE_URL`) through `effect/Config` instead. It fails at layer construction with a `ConfigError` when `RESEND_API_KEY` is unset or empty (an empty variable counts as missing); an empty `RESEND_BASE_URL` falls back to the default host. On a Worker whose stages may lack the key, use `resolveTransport(env)` below.
+
+## API
+
+| Export | What it is |
+| --- | --- |
+| `layer(config)`, `layerConfig` | The `EmailService` over the `HttpClient` in context, from literal config or from `RESEND_API_KEY` / `RESEND_BASE_URL`. |
+| `resolveTransport(env)`, `apiKeyFromEnv(env)`, `ResendEnv` | Pick the live sender or the no-op from a Worker env; needs no `HttpClient`. |
+| `noop` | The `EmailService` that succeeds without sending and logs the subject only. |
+| `ResendConfig`, `ResendConfigInput`, `DEFAULT_BASE_URL` | The credential and host as a service. |
+| `toResendPayload`, `formatAddress`, `ResendSendPayload` | The core-message → `POST /emails` mapping. |
+| `layerEmailService` | The `EmailService` over a `ResendConfig` and `HttpClient` you provide yourself. |
+
+## On a Worker: `resolveTransport(env)`
+
+The consuming applications' preview and dev stages deploy without the credential. `resolveTransport` is the one call a Worker makes: the live sender on the platform `fetch` when `RESEND_API_KEY` is bound and non-blank (as a string or a `Redacted`), the logging no-op otherwise, so the fallback cannot be forgotten.
+
+```ts
+import * as Effect from "effect/Effect";
+import type { EmailService } from "@thomasfosterau/effect-connect";
+import * as Resend from "@thomasfosterau/effect-connect-resend";
+
+// Your request handler; it sends through the EmailService in context.
+declare const handle: (request: Request) => Effect.Effect<Response, never, EmailService>;
+
+export default {
+  fetch: (request: Request, env: Resend.ResendEnv) =>
+    handle(request).pipe(Effect.provide(Resend.resolveTransport(env)), Effect.runPromise),
+};
+```
+
+`Resend.noop` succeeds without sending and logs the subject only — never the recipient, never the body (a verification URL is the token). That trade is only safe while the mail is advisory; a send that gates an account should fail loudly at boot instead.
+
+## What the transport pins
+
+- **A fixed literal host.** `https://api.resend.com` is a compile-time constant; `baseUrl` exists for a stub server in a test, never for request input.
+- **`redirect: "error"`** on the underlying fetch, layered over any `FetchHttpClient.RequestInit` defaults you provide. Workers' default (`follow`) replays a request at the redirect target with the headers intact, so a 3xx from a hijacked host would hand the bearer token to whatever host the response named. A Resend send has no legitimate reason to redirect.
+- **Truncated error bodies.** A non-2xx becomes an `EmailSendError` with `provider: "resend"`, `status: some(status)` and at most 200 characters of the response; an unreadable body still fails with the status; a transport failure carries `status: none`. The key never appears in a message.
+- **No retry.** The caller decides the policy (`Effect.retry`).
+
+## Batches
+
+`sendBatch(messages)` is one `POST /emails/batch`, one result per message in order. Resend accepts up to 100 messages per request; chunk beyond that. An empty batch makes no request.
+
+## Message mapping
+
+| Core `EmailMessage`                  | Resend `POST /emails`                      |
+| ------------------------------------ | ------------------------------------------ |
+| `from`, `to`, `cc`, `bcc`            | `Name <address>` strings (`formatAddress`) |
+| `replyTo`                            | `reply_to: [address]`                      |
+| `subject`, `text`, `html`, `headers` | the same                                   |
+| `attachments`                        | `attachments` (`content_type`)             |
+| `tags`                               | `tags: [{ name: tag, value: tag }]`        |
+
+`toResendPayload(message)` is exported for callers that want to inspect the payload.
+
+## Testing a consumer
+
+Provide `EmailService.layerRecording(sent)` from the core. To exercise this package's own transport, provide `FetchHttpClient.layer` with a stub `Fetch`:
+
+```ts
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { FetchHttpClient } from "effect/http";
+import * as Resend from "@thomasfosterau/effect-connect-resend";
+
+// Your stand-in for the platform fetch: return canned Responses.
+declare const stubFetch: typeof globalThis.fetch;
+
+const http = FetchHttpClient.layer.pipe(
+  Layer.provide(Layer.succeed(FetchHttpClient.Fetch, stubFetch)),
+);
+const EmailStub = Resend.layer({ apiKey: Redacted.make("re_test") }).pipe(Layer.provide(http));
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,214 @@
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
+import { EmailMessage, EmailService, EnvSecretBinding, Recipient } from "@thomasfosterau/effect-connect";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/http/HttpClient";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+/**
+ * Resend's API host, as a compile-time constant. A hard-coded literal rather
+ * than anything derived from input: a `fetch` whose host could be steered is
+ * exactly the outbound-request hazard the consuming applications' security
+ * policies forbid (SEC-SSRF-001), and the only values that ever vary in a
+ * send are the message fields in the body. `baseUrl` exists for a stub
+ * server in a test, never for request input.
+ *
+ * @since 0.1.0
+ */
+export declare const DEFAULT_BASE_URL = "https://api.resend.com";
+/**
+ * What {@link ResendConfig.layer} takes.
+ *
+ * @since 0.1.0
+ */
+export interface ResendConfigInput {
+  /** The API key. Wrap with `Redacted.make(...)` or read it via `Config.redacted(...)`. */
+  readonly apiKey: Redacted.Redacted;
+  /** The API host, without a trailing slash. Defaults to {@link DEFAULT_BASE_URL}. */
+  readonly baseUrl?: string;
+}
+declare const ResendConfig_base: Context.ServiceClass<ResendConfig, "@thomasfosterau/effect-connect-resend/ResendConfig", {
+  readonly apiKey: Redacted.Redacted;
+  readonly baseUrl: string;
+}>;
+/**
+ * The Resend configuration as a service.
+ *
+ * @since 0.1.0
+ */
+export declare class ResendConfig extends ResendConfig_base {
+  /**
+   * A configuration from literal values.
+   *
+   * @since 0.1.0
+   */
+  static readonly layer: (config: ResendConfigInput) => Layer.Layer<ResendConfig>;
+  /**
+   * A configuration read through `effect/Config`: `RESEND_API_KEY`
+   * (required, redacted) and `RESEND_BASE_URL` (optional). Fails with a
+   * `ConfigError` when `RESEND_API_KEY` is unset or empty; an empty
+   * `RESEND_BASE_URL` falls back to {@link DEFAULT_BASE_URL}.
+   *
+   * @since 0.1.0
+   */
+  static readonly layerConfig: Layer.Layer<ResendConfig, Config.ConfigError, never>;
+}
+/**
+ * The wire payload Resend's send endpoint accepts, stated once and checked
+ * against what `EmailMessage` carries. Optional members are `Schema.optional`
+ * rather than `optionalKey` on purpose: the mapping assigns `undefined` for
+ * an absent message field and JSON encoding drops the key.
+ *
+ * @since 0.1.0
+ */
+export declare const ResendSendPayload: Schema.Struct<{
+  readonly from: Schema.String;
+  readonly to: Schema.NonEmptyArray<Schema.String>;
+  readonly cc: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly bcc: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly reply_to: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly subject: Schema.String;
+  readonly text: Schema.optional<Schema.String>;
+  readonly html: Schema.optional<Schema.String>;
+  readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly filename: Schema.String;
+    readonly content: Schema.String;
+    readonly content_type: Schema.String;
+  }>>>;
+  readonly tags: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly value: Schema.String;
+  }>>>;
+}>;
+/**
+ * The decoded type of the {@link ResendSendPayload} schema.
+ *
+ * @since 0.1.0
+ */
+export type ResendSendPayload = typeof ResendSendPayload.Type;
+/**
+ * `Name <address>` when the recipient has a display name, else the bare address.
+ *
+ * @since 0.1.0
+ */
+export declare const formatAddress: (recipient: Recipient) => string;
+/**
+ * Map a core message onto Resend's send payload: recipients as
+ * `Name <address>` strings, `replyTo` as a one-element `reply_to`, core
+ * `tags` as Resend tags whose name and value are both the tag.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert";
+ * import { toResendPayload } from "@thomasfosterau/effect-connect-resend";
+ *
+ * const payload = toResendPayload({
+ *   from: { email: "noreply@example.com", name: "Example" },
+ *   to: [{ email: "reader@example.com" }],
+ *   replyTo: { email: "support@example.com" },
+ *   subject: "Welcome",
+ *   tags: ["welcome"],
+ * });
+ *
+ * assert.strictEqual(payload.from, "Example <noreply@example.com>");
+ * assert.deepStrictEqual(payload.to, ["reader@example.com"]);
+ * assert.deepStrictEqual(payload.reply_to, ["support@example.com"]);
+ * assert.deepStrictEqual(payload.tags, [{ name: "welcome", value: "welcome" }]);
+ * ```
+ *
+ * @since 0.1.0
+ */
+export declare const toResendPayload: (message: EmailMessage) => ResendSendPayload;
+/**
+ * The core `EmailService` over Resend's REST API and the `HttpClient` in
+ * context. `sendBatch` uses `POST /emails/batch` (one request, up to 100
+ * messages per Resend's limit — the caller chunks beyond that).
+ *
+ * @since 0.1.0
+ */
+export declare const layerEmailService: Layer.Layer<EmailService, never, ResendConfig | HttpClient.HttpClient>;
+/**
+ * The sender used when no API key is configured: every send **succeeds**
+ * without sending, and logs the subject only.
+ *
+ * Deliberately succeeds rather than failing. The consuming applications'
+ * preview and dev stages deploy without the credential, so a failing stub
+ * would turn "no mail configured" into "signup is broken" on every preview
+ * stage — and inside a queue consumer, into every notification in the batch
+ * being re-delivered, forever. That trade is only safe while the mail is
+ * advisory (a verification a user can still sign in without, a notification
+ * that also went out as push); if a send ever gates an account, fail loudly
+ * at boot instead of installing this.
+ *
+ * @since 0.1.0
+ */
+export declare const noop: Layer.Layer<EmailService>;
+/**
+ * The Resend provider from literal configuration, over the `HttpClient` in
+ * context (provide `FetchHttpClient.layer` on Workers, browsers and Node).
+ *
+ * @since 0.1.0
+ */
+export declare const layer: (config: ResendConfigInput) => Layer.Layer<EmailService, never, HttpClient.HttpClient>;
+/**
+ * The Resend provider configured through `effect/Config` (`RESEND_API_KEY`,
+ * optional `RESEND_BASE_URL`), over the `HttpClient` in context. Fails at
+ * layer construction with a `ConfigError` when `RESEND_API_KEY` is unset or
+ * empty (an empty variable reads as missing); an empty `RESEND_BASE_URL`
+ * falls back to the default host. On a Worker, {@link resolveTransport}
+ * tolerates a missing key.
+ *
+ * @since 0.1.0
+ */
+export declare const layerConfig: Layer.Layer<EmailService, import("effect/Config").ConfigError, HttpClient.HttpClient>;
+/**
+ * The env {@link resolveTransport} reads: the Worker's `RESEND_API_KEY` binding, if any.
+ *
+ * @since 0.1.0
+ */
+export interface ResendEnv {
+  readonly RESEND_API_KEY?: EnvSecretBinding;
+}
+/**
+ * The credential from a Worker env, normalised: `none` when the binding is
+ * absent, `null`, or blank (a stage can bind `""` by hand, and a truthiness
+ * check is what makes that the same case as "unset" rather than a real
+ * transport built around an empty bearer token).
+ *
+ * @since 0.1.0
+ */
+export declare const apiKeyFromEnv: (env: ResendEnv) => Option.Option<Redacted.Redacted>;
+/**
+ * Pick the transport for a Worker's environment: the live sender (on the
+ * platform `fetch`, via `FetchHttpClient`) when `RESEND_API_KEY` is present,
+ * the logging {@link noop} when it is not. One call site per Worker, so the
+ * fallback cannot be forgotten at one of two.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert";
+ * import * as Effect from "effect/Effect";
+ * import * as Option from "effect/Option";
+ * import { send } from "@thomasfosterau/effect-connect";
+ * import { resolveTransport } from "@thomasfosterau/effect-connect-resend";
+ *
+ * // No `RESEND_API_KEY` bound (a blank one counts as unbound): the no-op
+ * // transport, which logs the subject and succeeds without a network call.
+ * const result = Effect.runSync(
+ *   send({
+ *     from: { email: "noreply@example.com" },
+ *     to: [{ email: "reader@example.com" }],
+ *     subject: "Welcome",
+ *   }).pipe(Effect.provide(resolveTransport({ RESEND_API_KEY: "  " }))),
+ * );
+ *
+ * assert.ok(Option.isNone(result.id));
+ * ```
+ *
+ * @since 0.1.0
+ */
+export declare const resolveTransport: (env: ResendEnv) => Layer.Layer<EmailService>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,310 @@
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import "effect/Redacted";
+import { EmailSendError, EmailService, boundSecret, describeHttpError, droppingSender, httpErrorStatus, isSuccessStatus, refuseRedirects, rejectionMessage, selectTransport } from "@thomasfosterau/effect-connect";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+// src/ResendConfig.ts
+/**
+* The Resend credential and host, as a service with two constructors: a
+* literal (`layer`) and one read from `effect/Config` (`layerConfig`).
+*
+* @module ResendConfig
+* @since 0.1.0
+*/
+/**
+* Resend's API host, as a compile-time constant. A hard-coded literal rather
+* than anything derived from input: a `fetch` whose host could be steered is
+* exactly the outbound-request hazard the consuming applications' security
+* policies forbid (SEC-SSRF-001), and the only values that ever vary in a
+* send are the message fields in the body. `baseUrl` exists for a stub
+* server in a test, never for request input.
+*
+* @since 0.1.0
+*/
+const DEFAULT_BASE_URL = "https://api.resend.com";
+/**
+* The Resend configuration as a service.
+*
+* @since 0.1.0
+*/
+var ResendConfig = class ResendConfig extends Context.Service()("@thomasfosterau/effect-connect-resend/ResendConfig") {
+	/**
+	* A configuration from literal values.
+	*
+	* @since 0.1.0
+	*/
+	static layer = (config) => Layer.succeed(ResendConfig, {
+		apiKey: config.apiKey,
+		baseUrl: config.baseUrl ?? "https://api.resend.com"
+	});
+	/**
+	* A configuration read through `effect/Config`: `RESEND_API_KEY`
+	* (required, redacted) and `RESEND_BASE_URL` (optional). Fails with a
+	* `ConfigError` when `RESEND_API_KEY` is unset or empty; an empty
+	* `RESEND_BASE_URL` falls back to {@link DEFAULT_BASE_URL}.
+	*
+	* @since 0.1.0
+	*/
+	static layerConfig = Layer.effect(ResendConfig, Effect.gen(function* () {
+		return {
+			apiKey: yield* Config.Redacted("RESEND_API_KEY"),
+			baseUrl: yield* Config.String("RESEND_BASE_URL").pipe(Config.withDefault(DEFAULT_BASE_URL))
+		};
+	}));
+};
+// src/Resend.ts
+/**
+* The Resend sender: the core `EmailMessage` mapped onto Resend's
+* `POST /emails` (and `POST /emails/batch`) JSON, sent over Effect's
+* `HttpClient` with no SDK — the library form of the hand-rolled senders the
+* website, gardeneria and preferenceflow applications carry.
+*
+* The properties those senders pin, kept here:
+*
+* - a fixed literal host ({@link DEFAULT_BASE_URL});
+* - `redirect: "error"` on the underlying `fetch`. Workers' default
+*   (`follow`) replays the request at the redirect target **with the headers
+*   intact** — it does not drop `Authorization` on a cross-origin hop the way
+*   a browser does — so a 3xx from a hijacked or misconfigured
+*   `api.resend.com` would hand the API key to whatever host the response
+*   named. A Resend send has no legitimate reason to redirect, so the correct
+*   behaviour is to fail loudly (SEC-SECRET-001);
+* - a non-2xx becomes an `EmailSendError` carrying the status and a
+*   **truncated** body, never the raw unbounded one, and never the key;
+* - no retry: the caller decides the policy.
+*
+* @module Resend
+* @since 0.1.0
+*/
+const ResendAttachment = Schema.Struct({
+	filename: Schema.String,
+	content: Schema.String,
+	content_type: Schema.String
+});
+const ResendTag = Schema.Struct({
+	name: Schema.String,
+	value: Schema.String
+});
+/**
+* The wire payload Resend's send endpoint accepts, stated once and checked
+* against what `EmailMessage` carries. Optional members are `Schema.optional`
+* rather than `optionalKey` on purpose: the mapping assigns `undefined` for
+* an absent message field and JSON encoding drops the key.
+*
+* @since 0.1.0
+*/
+const ResendSendPayload = Schema.Struct({
+	from: Schema.String,
+	to: Schema.NonEmptyArray(Schema.String),
+	cc: Schema.optional(Schema.Array(Schema.String)),
+	bcc: Schema.optional(Schema.Array(Schema.String)),
+	reply_to: Schema.optional(Schema.Array(Schema.String)),
+	subject: Schema.String,
+	text: Schema.optional(Schema.String),
+	html: Schema.optional(Schema.String),
+	headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+	attachments: Schema.optional(Schema.Array(ResendAttachment)),
+	tags: Schema.optional(Schema.Array(ResendTag))
+});
+const SendResponse = Schema.Struct({ id: Schema.String });
+const BatchResponse = Schema.Struct({ data: Schema.Array(SendResponse) });
+/**
+* `Name <address>` when the recipient has a display name, else the bare address.
+*
+* @since 0.1.0
+*/
+const formatAddress = (recipient) => Option.match(Option.fromNullishOr(recipient.name), {
+	onNone: () => recipient.email,
+	onSome: (name) => `${name} <${recipient.email}>`
+});
+/**
+* Map a core message onto Resend's send payload: recipients as
+* `Name <address>` strings, `replyTo` as a one-element `reply_to`, core
+* `tags` as Resend tags whose name and value are both the tag.
+*
+* @example
+* ```ts
+* import * as assert from "node:assert";
+* import { toResendPayload } from "@thomasfosterau/effect-connect-resend";
+*
+* const payload = toResendPayload({
+*   from: { email: "noreply@example.com", name: "Example" },
+*   to: [{ email: "reader@example.com" }],
+*   replyTo: { email: "support@example.com" },
+*   subject: "Welcome",
+*   tags: ["welcome"],
+* });
+*
+* assert.strictEqual(payload.from, "Example <noreply@example.com>");
+* assert.deepStrictEqual(payload.to, ["reader@example.com"]);
+* assert.deepStrictEqual(payload.reply_to, ["support@example.com"]);
+* assert.deepStrictEqual(payload.tags, [{ name: "welcome", value: "welcome" }]);
+* ```
+*
+* @since 0.1.0
+*/
+const toResendPayload = (message) => ({
+	from: formatAddress(message.from),
+	to: [formatAddress(message.to[0]), ...message.to.slice(1).map(formatAddress)],
+	cc: message.cc?.map(formatAddress),
+	bcc: message.bcc?.map(formatAddress),
+	reply_to: Option.getOrUndefined(Option.map(Option.fromNullishOr(message.replyTo), (replyTo) => [formatAddress(replyTo)])),
+	subject: message.subject,
+	text: message.text,
+	html: message.html,
+	headers: message.headers,
+	attachments: message.attachments?.map((attachment) => ({
+		filename: attachment.filename,
+		content: attachment.content,
+		content_type: attachment.contentType
+	})),
+	tags: message.tags?.map((tag) => ({
+		name: tag,
+		value: tag
+	}))
+});
+const PROVIDER = "resend";
+/**
+* The core `EmailService` over Resend's REST API and the `HttpClient` in
+* context. `sendBatch` uses `POST /emails/batch` (one request, up to 100
+* messages per Resend's limit — the caller chunks beyond that).
+*
+* @since 0.1.0
+*/
+const layerEmailService = Layer.effect(EmailService, Effect.gen(function* () {
+	const config = yield* ResendConfig;
+	const http = yield* HttpClient.HttpClient;
+	/** One `POST` to Resend, decoded with `schema` on a 2xx. */
+	const post = Effect.fn("Resend.post")(function* (path, body, schema) {
+		const request = yield* HttpClientRequest.post(`${config.baseUrl}${path}`, { acceptJson: true }).pipe(HttpClientRequest.bearerToken(config.apiKey), HttpClientRequest.bodyJson(body), Effect.mapError((cause) => new EmailSendError({
+			provider: PROVIDER,
+			message: "Resend request body could not be encoded as JSON",
+			status: Option.none(),
+			cause
+		})));
+		const response = yield* http.execute(request).pipe(refuseRedirects, Effect.mapError((error) => new EmailSendError({
+			provider: PROVIDER,
+			message: `Resend was unreachable: ${describeHttpError(error)}`,
+			status: httpErrorStatus(error),
+			cause: error
+		})));
+		if (!isSuccessStatus(response.status)) {
+			const message = yield* rejectionMessage(response, "Resend rejected the send");
+			return yield* new EmailSendError({
+				provider: PROVIDER,
+				message,
+				status: Option.some(response.status)
+			});
+		}
+		return yield* HttpClientResponse.schemaBodyJson(schema)(response).pipe(Effect.mapError((cause) => new EmailSendError({
+			provider: PROVIDER,
+			message: `Resend answered ${response.status} with an unexpected body`,
+			status: Option.some(response.status),
+			cause
+		})));
+	});
+	return {
+		send: Effect.fn("Resend.send")(function* (message) {
+			const { id } = yield* post("/emails", toResendPayload(message), SendResponse);
+			return { id: Option.some(id) };
+		}),
+		sendBatch: Effect.fn("Resend.sendBatch")(function* (messages) {
+			if (!Arr.isReadonlyArrayNonEmpty(messages)) return [];
+			const { data } = yield* post("/emails/batch", messages.map(toResendPayload), BatchResponse);
+			return data.map((entry) => ({ id: Option.some(entry.id) }));
+		})
+	};
+}));
+/**
+* The sender used when no API key is configured: every send **succeeds**
+* without sending, and logs the subject only.
+*
+* Deliberately succeeds rather than failing. The consuming applications'
+* preview and dev stages deploy without the credential, so a failing stub
+* would turn "no mail configured" into "signup is broken" on every preview
+* stage — and inside a queue consumer, into every notification in the batch
+* being re-delivered, forever. That trade is only safe while the mail is
+* advisory (a verification a user can still sign in without, a notification
+* that also went out as push); if a send ever gates an account, fail loudly
+* at boot instead of installing this.
+*
+* @since 0.1.0
+*/
+const noop = Layer.succeed(EmailService, droppingSender((message) => `[effect-connect-resend] no RESEND_API_KEY configured; dropping "${message.subject}"`));
+// src/index.ts
+/**
+* `@thomasfosterau/effect-connect-resend` — the Resend provider for
+* `@thomasfosterau/effect-connect`: `POST /emails` over `effect/http`
+* with no SDK, a `Redacted` key, a no-op layer for un-provisioned stages and
+* an env-driven resolver that picks between the two.
+*
+* @module index
+* @since 0.1.0
+*/
+/**
+* The Resend provider from literal configuration, over the `HttpClient` in
+* context (provide `FetchHttpClient.layer` on Workers, browsers and Node).
+*
+* @since 0.1.0
+*/
+const layer = (config) => layerEmailService.pipe(Layer.provide(ResendConfig.layer(config)));
+/**
+* The Resend provider configured through `effect/Config` (`RESEND_API_KEY`,
+* optional `RESEND_BASE_URL`), over the `HttpClient` in context. Fails at
+* layer construction with a `ConfigError` when `RESEND_API_KEY` is unset or
+* empty (an empty variable reads as missing); an empty `RESEND_BASE_URL`
+* falls back to the default host. On a Worker, {@link resolveTransport}
+* tolerates a missing key.
+*
+* @since 0.1.0
+*/
+const layerConfig = layerEmailService.pipe(Layer.provide(ResendConfig.layerConfig));
+/**
+* The credential from a Worker env, normalised: `none` when the binding is
+* absent, `null`, or blank (a stage can bind `""` by hand, and a truthiness
+* check is what makes that the same case as "unset" rather than a real
+* transport built around an empty bearer token).
+*
+* @since 0.1.0
+*/
+const apiKeyFromEnv = (env) => boundSecret(env.RESEND_API_KEY);
+/**
+* Pick the transport for a Worker's environment: the live sender (on the
+* platform `fetch`, via `FetchHttpClient`) when `RESEND_API_KEY` is present,
+* the logging {@link noop} when it is not. One call site per Worker, so the
+* fallback cannot be forgotten at one of two.
+*
+* @example
+* ```ts
+* import * as assert from "node:assert";
+* import * as Effect from "effect/Effect";
+* import * as Option from "effect/Option";
+* import { send } from "@thomasfosterau/effect-connect";
+* import { resolveTransport } from "@thomasfosterau/effect-connect-resend";
+*
+* // No `RESEND_API_KEY` bound (a blank one counts as unbound): the no-op
+* // transport, which logs the subject and succeeds without a network call.
+* const result = Effect.runSync(
+*   send({
+*     from: { email: "noreply@example.com" },
+*     to: [{ email: "reader@example.com" }],
+*     subject: "Welcome",
+*   }).pipe(Effect.provide(resolveTransport({ RESEND_API_KEY: "  " }))),
+* );
+*
+* assert.ok(Option.isNone(result.id));
+* ```
+*
+* @since 0.1.0
+*/
+const resolveTransport = (env) => selectTransport(apiKeyFromEnv(env), (apiKey) => layer({ apiKey }), noop);
+export { DEFAULT_BASE_URL, ResendConfig, ResendSendPayload, apiKeyFromEnv, formatAddress, layer, layerConfig, layerEmailService, noop, resolveTransport, toResendPayload };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/ResendConfig.ts","../src/Resend.ts","../src/index.ts"],"sourcesContent":["/**\n * The Resend credential and host, as a service with two constructors: a\n * literal (`layer`) and one read from `effect/Config` (`layerConfig`).\n *\n * @module ResendConfig\n * @since 0.1.0\n */\n\nimport * as Config from \"effect/Config\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport type * as Redacted from \"effect/Redacted\";\n\n/**\n * Resend's API host, as a compile-time constant. A hard-coded literal rather\n * than anything derived from input: a `fetch` whose host could be steered is\n * exactly the outbound-request hazard the consuming applications' security\n * policies forbid (SEC-SSRF-001), and the only values that ever vary in a\n * send are the message fields in the body. `baseUrl` exists for a stub\n * server in a test, never for request input.\n *\n * @since 0.1.0\n */\nexport const DEFAULT_BASE_URL = \"https://api.resend.com\";\n\n/**\n * What {@link ResendConfig.layer} takes.\n *\n * @since 0.1.0\n */\nexport interface ResendConfigInput {\n  /** The API key. Wrap with `Redacted.make(...)` or read it via `Config.redacted(...)`. */\n  readonly apiKey: Redacted.Redacted;\n  /** The API host, without a trailing slash. Defaults to {@link DEFAULT_BASE_URL}. */\n  // oxlint-disable-next-line effect/prefer-option-over-null -- a consumer-facing config input: an omitted key IS the default, and asking every caller to spell `Option.none()` for it buys nothing\n  readonly baseUrl?: string;\n}\n\n/**\n * The Resend configuration as a service.\n *\n * @since 0.1.0\n */\nexport class ResendConfig extends Context.Service<\n  ResendConfig,\n  {\n    readonly apiKey: Redacted.Redacted;\n    readonly baseUrl: string;\n  }\n>()(\"@thomasfosterau/effect-connect-resend/ResendConfig\") {\n  /**\n   * A configuration from literal values.\n   *\n   * @since 0.1.0\n   */\n  static readonly layer = (config: ResendConfigInput): Layer.Layer<ResendConfig> =>\n    Layer.succeed(ResendConfig, {\n      apiKey: config.apiKey,\n      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,\n    });\n\n  /**\n   * A configuration read through `effect/Config`: `RESEND_API_KEY`\n   * (required, redacted) and `RESEND_BASE_URL` (optional). Fails with a\n   * `ConfigError` when `RESEND_API_KEY` is unset or empty; an empty\n   * `RESEND_BASE_URL` falls back to {@link DEFAULT_BASE_URL}.\n   *\n   * @since 0.1.0\n   */\n  static readonly layerConfig = Layer.effect(\n    ResendConfig,\n    Effect.gen(function* () {\n      const apiKey = yield* Config.Redacted(\"RESEND_API_KEY\");\n      const baseUrl = yield* Config.String(\"RESEND_BASE_URL\").pipe(\n        Config.withDefault(DEFAULT_BASE_URL),\n      );\n      return { apiKey, baseUrl };\n    }),\n  );\n}\n","/**\n * The Resend sender: the core `EmailMessage` mapped onto Resend's\n * `POST /emails` (and `POST /emails/batch`) JSON, sent over Effect's\n * `HttpClient` with no SDK — the library form of the hand-rolled senders the\n * website, gardeneria and preferenceflow applications carry.\n *\n * The properties those senders pin, kept here:\n *\n * - a fixed literal host ({@link DEFAULT_BASE_URL});\n * - `redirect: \"error\"` on the underlying `fetch`. Workers' default\n *   (`follow`) replays the request at the redirect target **with the headers\n *   intact** — it does not drop `Authorization` on a cross-origin hop the way\n *   a browser does — so a 3xx from a hijacked or misconfigured\n *   `api.resend.com` would hand the API key to whatever host the response\n *   named. A Resend send has no legitimate reason to redirect, so the correct\n *   behaviour is to fail loudly (SEC-SECRET-001);\n * - a non-2xx becomes an `EmailSendError` carrying the status and a\n *   **truncated** body, never the raw unbounded one, and never the key;\n * - no retry: the caller decides the policy.\n *\n * @module Resend\n * @since 0.1.0\n */\n\nimport * as Arr from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Schema from \"effect/Schema\";\nimport * as HttpClient from \"effect/http/HttpClient\";\nimport * as HttpClientRequest from \"effect/http/HttpClientRequest\";\nimport * as HttpClientResponse from \"effect/http/HttpClientResponse\";\nimport {\n  describeHttpError,\n  droppingSender,\n  EmailSendError,\n  EmailService,\n  httpErrorStatus,\n  isSuccessStatus,\n  refuseRedirects,\n  rejectionMessage,\n  type EmailMessage,\n  type EmailSendResult,\n  type Recipient,\n} from \"@thomasfosterau/effect-connect\";\nimport { ResendConfig } from \"./ResendConfig.ts\";\n\nconst ResendAttachment = Schema.Struct({\n  filename: Schema.String,\n  content: Schema.String,\n  content_type: Schema.String,\n});\n\nconst ResendTag = Schema.Struct({\n  name: Schema.String,\n  value: Schema.String,\n});\n\n/**\n * The wire payload Resend's send endpoint accepts, stated once and checked\n * against what `EmailMessage` carries. Optional members are `Schema.optional`\n * rather than `optionalKey` on purpose: the mapping assigns `undefined` for\n * an absent message field and JSON encoding drops the key.\n *\n * @since 0.1.0\n */\nexport const ResendSendPayload = Schema.Struct({\n  from: Schema.String,\n  to: Schema.NonEmptyArray(Schema.String),\n  cc: Schema.optional(Schema.Array(Schema.String)),\n  bcc: Schema.optional(Schema.Array(Schema.String)),\n  reply_to: Schema.optional(Schema.Array(Schema.String)),\n  subject: Schema.String,\n  text: Schema.optional(Schema.String),\n  html: Schema.optional(Schema.String),\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),\n  attachments: Schema.optional(Schema.Array(ResendAttachment)),\n  tags: Schema.optional(Schema.Array(ResendTag)),\n});\n/**\n * The decoded type of the {@link ResendSendPayload} schema.\n *\n * @since 0.1.0\n */\nexport type ResendSendPayload = typeof ResendSendPayload.Type;\n\nconst SendResponse = Schema.Struct({ id: Schema.String });\nconst BatchResponse = Schema.Struct({ data: Schema.Array(SendResponse) });\n\n/**\n * `Name <address>` when the recipient has a display name, else the bare address.\n *\n * @since 0.1.0\n */\nexport const formatAddress = (recipient: Recipient): string =>\n  Option.match(Option.fromNullishOr(recipient.name), {\n    onNone: () => recipient.email,\n    onSome: (name) => `${name} <${recipient.email}>`,\n  });\n\n/**\n * Map a core message onto Resend's send payload: recipients as\n * `Name <address>` strings, `replyTo` as a one-element `reply_to`, core\n * `tags` as Resend tags whose name and value are both the tag.\n *\n * @example\n * ```ts\n * import * as assert from \"node:assert\";\n * import { toResendPayload } from \"@thomasfosterau/effect-connect-resend\";\n *\n * const payload = toResendPayload({\n *   from: { email: \"noreply@example.com\", name: \"Example\" },\n *   to: [{ email: \"reader@example.com\" }],\n *   replyTo: { email: \"support@example.com\" },\n *   subject: \"Welcome\",\n *   tags: [\"welcome\"],\n * });\n *\n * assert.strictEqual(payload.from, \"Example <noreply@example.com>\");\n * assert.deepStrictEqual(payload.to, [\"reader@example.com\"]);\n * assert.deepStrictEqual(payload.reply_to, [\"support@example.com\"]);\n * assert.deepStrictEqual(payload.tags, [{ name: \"welcome\", value: \"welcome\" }]);\n * ```\n *\n * @since 0.1.0\n */\nexport const toResendPayload = (message: EmailMessage): ResendSendPayload => ({\n  from: formatAddress(message.from),\n  to: [formatAddress(message.to[0]), ...message.to.slice(1).map(formatAddress)],\n  cc: message.cc?.map(formatAddress),\n  bcc: message.bcc?.map(formatAddress),\n  reply_to: Option.getOrUndefined(\n    Option.map(Option.fromNullishOr(message.replyTo), (replyTo) => [formatAddress(replyTo)]),\n  ),\n  subject: message.subject,\n  text: message.text,\n  html: message.html,\n  headers: message.headers,\n  attachments: message.attachments?.map((attachment) => ({\n    filename: attachment.filename,\n    content: attachment.content,\n    content_type: attachment.contentType,\n  })),\n  tags: message.tags?.map((tag) => ({ name: tag, value: tag })),\n});\n\nconst PROVIDER = \"resend\";\n\n/**\n * The core `EmailService` over Resend's REST API and the `HttpClient` in\n * context. `sendBatch` uses `POST /emails/batch` (one request, up to 100\n * messages per Resend's limit — the caller chunks beyond that).\n *\n * @since 0.1.0\n */\nexport const layerEmailService: Layer.Layer<\n  EmailService,\n  never,\n  ResendConfig | HttpClient.HttpClient\n> = Layer.effect(\n  EmailService,\n  Effect.gen(function* () {\n    const config = yield* ResendConfig;\n    const http = yield* HttpClient.HttpClient;\n\n    /** One `POST` to Resend, decoded with `schema` on a 2xx. */\n    const post = Effect.fn(\"Resend.post\")(function* <A, I>(\n      path: string,\n      body: ResendSendPayload | ReadonlyArray<ResendSendPayload>,\n      schema: Schema.Codec<A, I>,\n    ) {\n      const request = yield* HttpClientRequest.post(`${config.baseUrl}${path}`, {\n        acceptJson: true,\n      }).pipe(\n        HttpClientRequest.bearerToken(config.apiKey),\n        HttpClientRequest.bodyJson(body),\n        Effect.mapError(\n          (cause) =>\n            new EmailSendError({\n              provider: PROVIDER,\n              message: \"Resend request body could not be encoded as JSON\",\n              status: Option.none(),\n              cause,\n            }),\n        ),\n      );\n      const response = yield* http.execute(request).pipe(\n        refuseRedirects,\n        Effect.mapError(\n          (error) =>\n            new EmailSendError({\n              provider: PROVIDER,\n              message: `Resend was unreachable: ${describeHttpError(error)}`,\n              status: httpErrorStatus(error),\n              cause: error,\n            }),\n        ),\n      );\n      if (!isSuccessStatus(response.status)) {\n        const message = yield* rejectionMessage(response, \"Resend rejected the send\");\n        return yield* new EmailSendError({\n          provider: PROVIDER,\n          message,\n          status: Option.some(response.status),\n        });\n      }\n      return yield* HttpClientResponse.schemaBodyJson(schema)(response).pipe(\n        Effect.mapError(\n          (cause) =>\n            new EmailSendError({\n              provider: PROVIDER,\n              message: `Resend answered ${response.status} with an unexpected body`,\n              status: Option.some(response.status),\n              cause,\n            }),\n        ),\n      );\n    });\n\n    const send = Effect.fn(\"Resend.send\")(function* (message: EmailMessage) {\n      const { id } = yield* post(\"/emails\", toResendPayload(message), SendResponse);\n      const result: EmailSendResult = { id: Option.some(id) };\n      return result;\n    });\n\n    const sendBatch = Effect.fn(\"Resend.sendBatch\")(function* (\n      messages: ReadonlyArray<EmailMessage>,\n    ) {\n      if (!Arr.isReadonlyArrayNonEmpty(messages)) {\n        const none: ReadonlyArray<EmailSendResult> = [];\n        return none;\n      }\n      const { data } = yield* post(\"/emails/batch\", messages.map(toResendPayload), BatchResponse);\n      return data.map((entry): EmailSendResult => ({ id: Option.some(entry.id) }));\n    });\n\n    return { send, sendBatch };\n  }),\n);\n\n/**\n * The sender used when no API key is configured: every send **succeeds**\n * without sending, and logs the subject only.\n *\n * Deliberately succeeds rather than failing. The consuming applications'\n * preview and dev stages deploy without the credential, so a failing stub\n * would turn \"no mail configured\" into \"signup is broken\" on every preview\n * stage — and inside a queue consumer, into every notification in the batch\n * being re-delivered, forever. That trade is only safe while the mail is\n * advisory (a verification a user can still sign in without, a notification\n * that also went out as push); if a send ever gates an account, fail loudly\n * at boot instead of installing this.\n *\n * @since 0.1.0\n */\nexport const noop: Layer.Layer<EmailService> = Layer.succeed(\n  EmailService,\n  // Logs the subject only — never the recipient (PII) and never the body\n  // (a verification URL IS the token). The subject alone answers the\n  // question this line exists for: \"is mail being dropped for want of a\n  // credential?\"\n  droppingSender<EmailMessage>(\n    (message) =>\n      `[effect-connect-resend] no RESEND_API_KEY configured; dropping \"${message.subject}\"`,\n  ),\n);\n","/**\n * `@thomasfosterau/effect-connect-resend` — the Resend provider for\n * `@thomasfosterau/effect-connect`: `POST /emails` over `effect/http`\n * with no SDK, a `Redacted` key, a no-op layer for un-provisioned stages and\n * an env-driven resolver that picks between the two.\n *\n * @module index\n * @since 0.1.0\n */\n\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Redacted from \"effect/Redacted\";\nimport type * as HttpClient from \"effect/http/HttpClient\";\nimport {\n  boundSecret,\n  selectTransport,\n  type EmailService,\n  type EnvSecretBinding,\n} from \"@thomasfosterau/effect-connect\";\nimport { layerEmailService, noop } from \"./Resend.ts\";\nimport { ResendConfig, type ResendConfigInput } from \"./ResendConfig.ts\";\n\n/**\n * The Resend sender: the payload mapping, the `EmailService` layer and the no-op transport.\n *\n * @since 0.1.0\n */\nexport * from \"./Resend.ts\";\n/**\n * The Resend credential and host, as a service.\n *\n * @since 0.1.0\n */\nexport * from \"./ResendConfig.ts\";\n\n/**\n * The Resend provider from literal configuration, over the `HttpClient` in\n * context (provide `FetchHttpClient.layer` on Workers, browsers and Node).\n *\n * @since 0.1.0\n */\nexport const layer = (\n  config: ResendConfigInput,\n): Layer.Layer<EmailService, never, HttpClient.HttpClient> =>\n  layerEmailService.pipe(Layer.provide(ResendConfig.layer(config)));\n\n/**\n * The Resend provider configured through `effect/Config` (`RESEND_API_KEY`,\n * optional `RESEND_BASE_URL`), over the `HttpClient` in context. Fails at\n * layer construction with a `ConfigError` when `RESEND_API_KEY` is unset or\n * empty (an empty variable reads as missing); an empty `RESEND_BASE_URL`\n * falls back to the default host. On a Worker, {@link resolveTransport}\n * tolerates a missing key.\n *\n * @since 0.1.0\n */\nexport const layerConfig = layerEmailService.pipe(Layer.provide(ResendConfig.layerConfig));\n\n/**\n * The env {@link resolveTransport} reads: the Worker's `RESEND_API_KEY` binding, if any.\n *\n * @since 0.1.0\n */\nexport interface ResendEnv {\n  readonly RESEND_API_KEY?: EnvSecretBinding;\n}\n\n/**\n * The credential from a Worker env, normalised: `none` when the binding is\n * absent, `null`, or blank (a stage can bind `\"\"` by hand, and a truthiness\n * check is what makes that the same case as \"unset\" rather than a real\n * transport built around an empty bearer token).\n *\n * @since 0.1.0\n */\nexport const apiKeyFromEnv = (env: ResendEnv): Option.Option<Redacted.Redacted> =>\n  boundSecret(env.RESEND_API_KEY);\n\n/**\n * Pick the transport for a Worker's environment: the live sender (on the\n * platform `fetch`, via `FetchHttpClient`) when `RESEND_API_KEY` is present,\n * the logging {@link noop} when it is not. One call site per Worker, so the\n * fallback cannot be forgotten at one of two.\n *\n * @example\n * ```ts\n * import * as assert from \"node:assert\";\n * import * as Effect from \"effect/Effect\";\n * import * as Option from \"effect/Option\";\n * import { send } from \"@thomasfosterau/effect-connect\";\n * import { resolveTransport } from \"@thomasfosterau/effect-connect-resend\";\n *\n * // No `RESEND_API_KEY` bound (a blank one counts as unbound): the no-op\n * // transport, which logs the subject and succeeds without a network call.\n * const result = Effect.runSync(\n *   send({\n *     from: { email: \"noreply@example.com\" },\n *     to: [{ email: \"reader@example.com\" }],\n *     subject: \"Welcome\",\n *   }).pipe(Effect.provide(resolveTransport({ RESEND_API_KEY: \"  \" }))),\n * );\n *\n * assert.ok(Option.isNone(result.id));\n * ```\n *\n * @since 0.1.0\n */\nexport const resolveTransport = (env: ResendEnv): Layer.Layer<EmailService> =>\n  selectTransport(apiKeyFromEnv(env), (apiKey) => layer({ apiKey }), noop);\n"],"mappings":"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"}

package/package.json

@@ -1,14 +1,56 @@
 {
   "name": "@thomasfosterau/effect-connect-resend",
-  "version": "0.0.0",
-  "description": "Placeholder reserved for npm trusted publishing; the first real release of @thomasfosterau/effect-connect-resend is 0.1.0.",
+  "version": "0.1.0",
+  "description": "Resend provider for @thomasfosterau/effect-connect: a fetch-based POST /emails over Effect's HttpClient with no SDK, a Redacted API key, a no-op layer for un-provisioned stages and an env-driven resolver.",
+  "keywords": [
+    "effect",
+    "email",
+    "resend",
+    "transactional",
+    "typescript"
+  ],
+  "homepage": "https://github.com/thomasfosterau/effect-connect#readme",
+  "bugs": {
+    "url": "https://github.com/thomasfosterau/effect-connect/issues"
+  },
   "license": "MIT",
+  "author": "Thomas Foster <me@thomasfoster.au>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/thomasfosterau/effect-connect.git",
+    "url": "https://github.com/thomasfosterau/effect-connect.git",
     "directory": "packages/resend"
   },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@thomasfosterau/effect-connect": "^0.1.0"
+  },
+  "devDependencies": {
+    "@effect/language-service": "^0.87.5",
+    "@effect/vitest": "4.1.2",
+    "@types/node": "^26.6.6",
+    "effect": "4.1.2"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=22"
   }
-}
+}

package/src/Resend.ts

@@ -0,0 +1,266 @@
+/**
+ * The Resend sender: the core `EmailMessage` mapped onto Resend's
+ * `POST /emails` (and `POST /emails/batch`) JSON, sent over Effect's
+ * `HttpClient` with no SDK — the library form of the hand-rolled senders the
+ * website, gardeneria and preferenceflow applications carry.
+ *
+ * The properties those senders pin, kept here:
+ *
+ * - a fixed literal host ({@link DEFAULT_BASE_URL});
+ * - `redirect: "error"` on the underlying `fetch`. Workers' default
+ *   (`follow`) replays the request at the redirect target **with the headers
+ *   intact** — it does not drop `Authorization` on a cross-origin hop the way
+ *   a browser does — so a 3xx from a hijacked or misconfigured
+ *   `api.resend.com` would hand the API key to whatever host the response
+ *   named. A Resend send has no legitimate reason to redirect, so the correct
+ *   behaviour is to fail loudly (SEC-SECRET-001);
+ * - a non-2xx becomes an `EmailSendError` carrying the status and a
+ *   **truncated** body, never the raw unbounded one, and never the key;
+ * - no retry: the caller decides the policy.
+ *
+ * @module Resend
+ * @since 0.1.0
+ */
+
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
+import {
+  describeHttpError,
+  droppingSender,
+  EmailSendError,
+  EmailService,
+  httpErrorStatus,
+  isSuccessStatus,
+  refuseRedirects,
+  rejectionMessage,
+  type EmailMessage,
+  type EmailSendResult,
+  type Recipient,
+} from "@thomasfosterau/effect-connect";
+import { ResendConfig } from "./ResendConfig.ts";
+
+const ResendAttachment = Schema.Struct({
+  filename: Schema.String,
+  content: Schema.String,
+  content_type: Schema.String,
+});
+
+const ResendTag = Schema.Struct({
+  name: Schema.String,
+  value: Schema.String,
+});
+
+/**
+ * The wire payload Resend's send endpoint accepts, stated once and checked
+ * against what `EmailMessage` carries. Optional members are `Schema.optional`
+ * rather than `optionalKey` on purpose: the mapping assigns `undefined` for
+ * an absent message field and JSON encoding drops the key.
+ *
+ * @since 0.1.0
+ */
+export const ResendSendPayload = Schema.Struct({
+  from: Schema.String,
+  to: Schema.NonEmptyArray(Schema.String),
+  cc: Schema.optional(Schema.Array(Schema.String)),
+  bcc: Schema.optional(Schema.Array(Schema.String)),
+  reply_to: Schema.optional(Schema.Array(Schema.String)),
+  subject: Schema.String,
+  text: Schema.optional(Schema.String),
+  html: Schema.optional(Schema.String),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  attachments: Schema.optional(Schema.Array(ResendAttachment)),
+  tags: Schema.optional(Schema.Array(ResendTag)),
+});
+/**
+ * The decoded type of the {@link ResendSendPayload} schema.
+ *
+ * @since 0.1.0
+ */
+export type ResendSendPayload = typeof ResendSendPayload.Type;
+
+const SendResponse = Schema.Struct({ id: Schema.String });
+const BatchResponse = Schema.Struct({ data: Schema.Array(SendResponse) });
+
+/**
+ * `Name <address>` when the recipient has a display name, else the bare address.
+ *
+ * @since 0.1.0
+ */
+export const formatAddress = (recipient: Recipient): string =>
+  Option.match(Option.fromNullishOr(recipient.name), {
+    onNone: () => recipient.email,
+    onSome: (name) => `${name} <${recipient.email}>`,
+  });
+
+/**
+ * Map a core message onto Resend's send payload: recipients as
+ * `Name <address>` strings, `replyTo` as a one-element `reply_to`, core
+ * `tags` as Resend tags whose name and value are both the tag.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert";
+ * import { toResendPayload } from "@thomasfosterau/effect-connect-resend";
+ *
+ * const payload = toResendPayload({
+ *   from: { email: "noreply@example.com", name: "Example" },
+ *   to: [{ email: "reader@example.com" }],
+ *   replyTo: { email: "support@example.com" },
+ *   subject: "Welcome",
+ *   tags: ["welcome"],
+ * });
+ *
+ * assert.strictEqual(payload.from, "Example <noreply@example.com>");
+ * assert.deepStrictEqual(payload.to, ["reader@example.com"]);
+ * assert.deepStrictEqual(payload.reply_to, ["support@example.com"]);
+ * assert.deepStrictEqual(payload.tags, [{ name: "welcome", value: "welcome" }]);
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const toResendPayload = (message: EmailMessage): ResendSendPayload => ({
+  from: formatAddress(message.from),
+  to: [formatAddress(message.to[0]), ...message.to.slice(1).map(formatAddress)],
+  cc: message.cc?.map(formatAddress),
+  bcc: message.bcc?.map(formatAddress),
+  reply_to: Option.getOrUndefined(
+    Option.map(Option.fromNullishOr(message.replyTo), (replyTo) => [formatAddress(replyTo)]),
+  ),
+  subject: message.subject,
+  text: message.text,
+  html: message.html,
+  headers: message.headers,
+  attachments: message.attachments?.map((attachment) => ({
+    filename: attachment.filename,
+    content: attachment.content,
+    content_type: attachment.contentType,
+  })),
+  tags: message.tags?.map((tag) => ({ name: tag, value: tag })),
+});
+
+const PROVIDER = "resend";
+
+/**
+ * The core `EmailService` over Resend's REST API and the `HttpClient` in
+ * context. `sendBatch` uses `POST /emails/batch` (one request, up to 100
+ * messages per Resend's limit — the caller chunks beyond that).
+ *
+ * @since 0.1.0
+ */
+export const layerEmailService: Layer.Layer<
+  EmailService,
+  never,
+  ResendConfig | HttpClient.HttpClient
+> = Layer.effect(
+  EmailService,
+  Effect.gen(function* () {
+    const config = yield* ResendConfig;
+    const http = yield* HttpClient.HttpClient;
+
+    /** One `POST` to Resend, decoded with `schema` on a 2xx. */
+    const post = Effect.fn("Resend.post")(function* <A, I>(
+      path: string,
+      body: ResendSendPayload | ReadonlyArray<ResendSendPayload>,
+      schema: Schema.Codec<A, I>,
+    ) {
+      const request = yield* HttpClientRequest.post(`${config.baseUrl}${path}`, {
+        acceptJson: true,
+      }).pipe(
+        HttpClientRequest.bearerToken(config.apiKey),
+        HttpClientRequest.bodyJson(body),
+        Effect.mapError(
+          (cause) =>
+            new EmailSendError({
+              provider: PROVIDER,
+              message: "Resend request body could not be encoded as JSON",
+              status: Option.none(),
+              cause,
+            }),
+        ),
+      );
+      const response = yield* http.execute(request).pipe(
+        refuseRedirects,
+        Effect.mapError(
+          (error) =>
+            new EmailSendError({
+              provider: PROVIDER,
+              message: `Resend was unreachable: ${describeHttpError(error)}`,
+              status: httpErrorStatus(error),
+              cause: error,
+            }),
+        ),
+      );
+      if (!isSuccessStatus(response.status)) {
+        const message = yield* rejectionMessage(response, "Resend rejected the send");
+        return yield* new EmailSendError({
+          provider: PROVIDER,
+          message,
+          status: Option.some(response.status),
+        });
+      }
+      return yield* HttpClientResponse.schemaBodyJson(schema)(response).pipe(
+        Effect.mapError(
+          (cause) =>
+            new EmailSendError({
+              provider: PROVIDER,
+              message: `Resend answered ${response.status} with an unexpected body`,
+              status: Option.some(response.status),
+              cause,
+            }),
+        ),
+      );
+    });
+
+    const send = Effect.fn("Resend.send")(function* (message: EmailMessage) {
+      const { id } = yield* post("/emails", toResendPayload(message), SendResponse);
+      const result: EmailSendResult = { id: Option.some(id) };
+      return result;
+    });
+
+    const sendBatch = Effect.fn("Resend.sendBatch")(function* (
+      messages: ReadonlyArray<EmailMessage>,
+    ) {
+      if (!Arr.isReadonlyArrayNonEmpty(messages)) {
+        const none: ReadonlyArray<EmailSendResult> = [];
+        return none;
+      }
+      const { data } = yield* post("/emails/batch", messages.map(toResendPayload), BatchResponse);
+      return data.map((entry): EmailSendResult => ({ id: Option.some(entry.id) }));
+    });
+
+    return { send, sendBatch };
+  }),
+);
+
+/**
+ * The sender used when no API key is configured: every send **succeeds**
+ * without sending, and logs the subject only.
+ *
+ * Deliberately succeeds rather than failing. The consuming applications'
+ * preview and dev stages deploy without the credential, so a failing stub
+ * would turn "no mail configured" into "signup is broken" on every preview
+ * stage — and inside a queue consumer, into every notification in the batch
+ * being re-delivered, forever. That trade is only safe while the mail is
+ * advisory (a verification a user can still sign in without, a notification
+ * that also went out as push); if a send ever gates an account, fail loudly
+ * at boot instead of installing this.
+ *
+ * @since 0.1.0
+ */
+export const noop: Layer.Layer<EmailService> = Layer.succeed(
+  EmailService,
+  // Logs the subject only — never the recipient (PII) and never the body
+  // (a verification URL IS the token). The subject alone answers the
+  // question this line exists for: "is mail being dropped for want of a
+  // credential?"
+  droppingSender<EmailMessage>(
+    (message) =>
+      `[effect-connect-resend] no RESEND_API_KEY configured; dropping "${message.subject}"`,
+  ),
+);

package/src/ResendConfig.ts

@@ -0,0 +1,81 @@
+/**
+ * The Resend credential and host, as a service with two constructors: a
+ * literal (`layer`) and one read from `effect/Config` (`layerConfig`).
+ *
+ * @module ResendConfig
+ * @since 0.1.0
+ */
+
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Redacted from "effect/Redacted";
+
+/**
+ * Resend's API host, as a compile-time constant. A hard-coded literal rather
+ * than anything derived from input: a `fetch` whose host could be steered is
+ * exactly the outbound-request hazard the consuming applications' security
+ * policies forbid (SEC-SSRF-001), and the only values that ever vary in a
+ * send are the message fields in the body. `baseUrl` exists for a stub
+ * server in a test, never for request input.
+ *
+ * @since 0.1.0
+ */
+export const DEFAULT_BASE_URL = "https://api.resend.com";
+
+/**
+ * What {@link ResendConfig.layer} takes.
+ *
+ * @since 0.1.0
+ */
+export interface ResendConfigInput {
+  /** The API key. Wrap with `Redacted.make(...)` or read it via `Config.redacted(...)`. */
+  readonly apiKey: Redacted.Redacted;
+  /** The API host, without a trailing slash. Defaults to {@link DEFAULT_BASE_URL}. */
+  // oxlint-disable-next-line effect/prefer-option-over-null -- a consumer-facing config input: an omitted key IS the default, and asking every caller to spell `Option.none()` for it buys nothing
+  readonly baseUrl?: string;
+}
+
+/**
+ * The Resend configuration as a service.
+ *
+ * @since 0.1.0
+ */
+export class ResendConfig extends Context.Service<
+  ResendConfig,
+  {
+    readonly apiKey: Redacted.Redacted;
+    readonly baseUrl: string;
+  }
+>()("@thomasfosterau/effect-connect-resend/ResendConfig") {
+  /**
+   * A configuration from literal values.
+   *
+   * @since 0.1.0
+   */
+  static readonly layer = (config: ResendConfigInput): Layer.Layer<ResendConfig> =>
+    Layer.succeed(ResendConfig, {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+    });
+
+  /**
+   * A configuration read through `effect/Config`: `RESEND_API_KEY`
+   * (required, redacted) and `RESEND_BASE_URL` (optional). Fails with a
+   * `ConfigError` when `RESEND_API_KEY` is unset or empty; an empty
+   * `RESEND_BASE_URL` falls back to {@link DEFAULT_BASE_URL}.
+   *
+   * @since 0.1.0
+   */
+  static readonly layerConfig = Layer.effect(
+    ResendConfig,
+    Effect.gen(function* () {
+      const apiKey = yield* Config.Redacted("RESEND_API_KEY");
+      const baseUrl = yield* Config.String("RESEND_BASE_URL").pipe(
+        Config.withDefault(DEFAULT_BASE_URL),
+      );
+      return { apiKey, baseUrl };
+    }),
+  );
+}

package/src/index.ts

@@ -0,0 +1,110 @@
+/**
+ * `@thomasfosterau/effect-connect-resend` — the Resend provider for
+ * `@thomasfosterau/effect-connect`: `POST /emails` over `effect/http`
+ * with no SDK, a `Redacted` key, a no-op layer for un-provisioned stages and
+ * an env-driven resolver that picks between the two.
+ *
+ * @module index
+ * @since 0.1.0
+ */
+
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
+import type * as HttpClient from "effect/http/HttpClient";
+import {
+  boundSecret,
+  selectTransport,
+  type EmailService,
+  type EnvSecretBinding,
+} from "@thomasfosterau/effect-connect";
+import { layerEmailService, noop } from "./Resend.ts";
+import { ResendConfig, type ResendConfigInput } from "./ResendConfig.ts";
+
+/**
+ * The Resend sender: the payload mapping, the `EmailService` layer and the no-op transport.
+ *
+ * @since 0.1.0
+ */
+export * from "./Resend.ts";
+/**
+ * The Resend credential and host, as a service.
+ *
+ * @since 0.1.0
+ */
+export * from "./ResendConfig.ts";
+
+/**
+ * The Resend provider from literal configuration, over the `HttpClient` in
+ * context (provide `FetchHttpClient.layer` on Workers, browsers and Node).
+ *
+ * @since 0.1.0
+ */
+export const layer = (
+  config: ResendConfigInput,
+): Layer.Layer<EmailService, never, HttpClient.HttpClient> =>
+  layerEmailService.pipe(Layer.provide(ResendConfig.layer(config)));
+
+/**
+ * The Resend provider configured through `effect/Config` (`RESEND_API_KEY`,
+ * optional `RESEND_BASE_URL`), over the `HttpClient` in context. Fails at
+ * layer construction with a `ConfigError` when `RESEND_API_KEY` is unset or
+ * empty (an empty variable reads as missing); an empty `RESEND_BASE_URL`
+ * falls back to the default host. On a Worker, {@link resolveTransport}
+ * tolerates a missing key.
+ *
+ * @since 0.1.0
+ */
+export const layerConfig = layerEmailService.pipe(Layer.provide(ResendConfig.layerConfig));
+
+/**
+ * The env {@link resolveTransport} reads: the Worker's `RESEND_API_KEY` binding, if any.
+ *
+ * @since 0.1.0
+ */
+export interface ResendEnv {
+  readonly RESEND_API_KEY?: EnvSecretBinding;
+}
+
+/**
+ * The credential from a Worker env, normalised: `none` when the binding is
+ * absent, `null`, or blank (a stage can bind `""` by hand, and a truthiness
+ * check is what makes that the same case as "unset" rather than a real
+ * transport built around an empty bearer token).
+ *
+ * @since 0.1.0
+ */
+export const apiKeyFromEnv = (env: ResendEnv): Option.Option<Redacted.Redacted> =>
+  boundSecret(env.RESEND_API_KEY);
+
+/**
+ * Pick the transport for a Worker's environment: the live sender (on the
+ * platform `fetch`, via `FetchHttpClient`) when `RESEND_API_KEY` is present,
+ * the logging {@link noop} when it is not. One call site per Worker, so the
+ * fallback cannot be forgotten at one of two.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert";
+ * import * as Effect from "effect/Effect";
+ * import * as Option from "effect/Option";
+ * import { send } from "@thomasfosterau/effect-connect";
+ * import { resolveTransport } from "@thomasfosterau/effect-connect-resend";
+ *
+ * // No `RESEND_API_KEY` bound (a blank one counts as unbound): the no-op
+ * // transport, which logs the subject and succeeds without a network call.
+ * const result = Effect.runSync(
+ *   send({
+ *     from: { email: "noreply@example.com" },
+ *     to: [{ email: "reader@example.com" }],
+ *     subject: "Welcome",
+ *   }).pipe(Effect.provide(resolveTransport({ RESEND_API_KEY: "  " }))),
+ * );
+ *
+ * assert.ok(Option.isNone(result.id));
+ * ```
+ *
+ * @since 0.1.0
+ */
+export const resolveTransport = (env: ResendEnv): Layer.Layer<EmailService> =>
+  selectTransport(apiKeyFromEnv(env), (apiKey) => layer({ apiKey }), noop);