effect-cf 0.14.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/Email.ts

@@ -0,0 +1,134 @@
+import type {
+  EmailAddress as CloudflareEmailAddress,
+  EmailAttachment as CloudflareEmailAttachment,
+  EmailMessage as CloudflareEmailMessage,
+  EmailSendResult as CloudflareEmailSendResult,
+  SendEmail as CloudflareSendEmail,
+} from "@cloudflare/workers-types";
+import { Context, Data, Effect, type Layer } from "effect";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+const expectedSendEmailBinding = "Send Email binding with send()";
+
+/** Error raised when a Cloudflare Send Email operation fails. */
+export class EmailOperationError extends Data.TaggedError("EmailOperationError")<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+/** Typed Cloudflare Send Email binding definition. */
+export interface EmailDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type EmailAddress = CloudflareEmailAddress;
+export type EmailAttachment = CloudflareEmailAttachment;
+export type EmailMessage = CloudflareEmailMessage;
+export type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
+export type EmailSendInput = EmailMessage | EmailMessageBuilder;
+export type EmailSendResult = CloudflareEmailSendResult;
+export type EmailBinding = CloudflareSendEmail;
+
+interface EmailRuntimeBinding {
+  readonly send: (message: EmailSendInput) => Promise<EmailSendResult>;
+}
+
+export interface EmailClient {
+  readonly send: {
+    (message: EmailMessage): Effect.Effect<EmailSendResult, EmailOperationError>;
+    (builder: EmailMessageBuilder): Effect.Effect<EmailSendResult, EmailOperationError>;
+  };
+  readonly unsafeRaw: Effect.Effect<EmailBinding>;
+  readonly definition: EmailDefinition;
+}
+
+declare const EmailServiceTypeId: unique symbol;
+
+/** Nominal service marker for Send Email services created with {@link make}. */
+export interface EmailService<Id extends string> {
+  readonly [EmailServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  EmailClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+const emailError = (binding: string, operation: string, cause: unknown) =>
+  new EmailOperationError({ binding, operation, cause });
+
+const tryEmailPromise = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => Promise<A>,
+): Effect.Effect<A, EmailOperationError> =>
+  Effect.tryPromise({
+    try: evaluate,
+    catch: (cause) => emailError(binding, operation, cause),
+  });
+
+export const isEmailBinding = (value: unknown): value is EmailBinding => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const resource = value as Record<string, unknown>;
+
+  return typeof resource.send === "function";
+};
+
+export const makeClient =
+  (definition: EmailDefinition) =>
+  (email: EmailBinding): EmailClient => {
+    const runtime = email as EmailRuntimeBinding;
+    const send = ((message: EmailSendInput) =>
+      tryEmailPromise(definition.binding, "send", () =>
+        runtime.send(message),
+      )) as EmailClient["send"];
+
+    return {
+      definition,
+      send,
+      unsafeRaw: Effect.succeed(email),
+    };
+  };
+
+export const layer = <Self>(tag: Context.Service<Self, EmailClient>, definition: EmailDefinition) =>
+  Binding.layer(tag, definition.binding, isEmailBinding, makeClient(definition), {
+    expected: expectedSendEmailBinding,
+  });
+
+export const make = <Id extends string>(id: Id) => Tag<EmailService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, EmailClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };

package/src/index.ts

@@ -12,6 +12,7 @@ export * as DurableObjectSqlite from "./DurableObjectSqlite";
 export * as DurableObjectState from "./DurableObjectState";
 export * as DurableObjectWebSocket from "./DurableObjectWebSocket";
 export * as DurableObjectStorage from "./DurableObjectStorage";
+export * as Email from "./Email";
 export * as Hyperdrive from "./Hyperdrive";
 export * as Images from "./Images";
 export * as Kv from "./Kv";