alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/src/Cloudflare/AnalyticsEngine/AnalyticsEngineDatasetBinding.ts

@@ -0,0 +1,106 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import type { ResourceLike } from "../../Resource.ts";
+import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
+import type { AnalyticsEngineDataset as AnalyticsEngineDatasetLike } from "./AnalyticsEngineDataset.ts";
+
+export interface AnalyticsEngineDataPoint {
+  indexes?: string[];
+  blobs?: string[];
+  doubles?: number[];
+}
+
+export interface RuntimeAnalyticsEngineDataset {
+  writeDataPoint(dataPoint: AnalyticsEngineDataPoint): void;
+}
+
+export class AnalyticsEngineDatasetError extends Data.TaggedError(
+  "AnalyticsEngineDatasetError",
+)<{
+  message: string;
+  cause: Error;
+}> {}
+
+export interface AnalyticsEngineDatasetClient {
+  raw: Effect.Effect<RuntimeAnalyticsEngineDataset, never, WorkerEnvironment>;
+  writeDataPoint(
+    dataPoint: AnalyticsEngineDataPoint,
+  ): Effect.Effect<void, AnalyticsEngineDatasetError, WorkerEnvironment>;
+}
+
+export class AnalyticsEngineDatasetBinding extends Binding.Service<
+  AnalyticsEngineDatasetBinding,
+  (
+    dataset: AnalyticsEngineDatasetLike,
+  ) => Effect.Effect<AnalyticsEngineDatasetClient>
+>()("Cloudflare.AnalyticsEngineDataset.Binding") {}
+
+export const AnalyticsEngineDatasetBindingLive = Layer.effect(
+  AnalyticsEngineDatasetBinding,
+  Effect.gen(function* () {
+    const bind = yield* AnalyticsEngineDatasetBindingPolicy;
+
+    return Effect.fnUntraced(function* (dataset: AnalyticsEngineDatasetLike) {
+      yield* bind(dataset);
+
+      const raw = WorkerEnvironment.pipe(
+        Effect.map(
+          (env) =>
+            (env as Record<string, RuntimeAnalyticsEngineDataset>)[
+              dataset.name
+            ]!,
+        ),
+      );
+
+      return {
+        raw,
+        writeDataPoint: (dataPoint) =>
+          raw.pipe(
+            Effect.flatMap((raw) =>
+              Effect.try({
+                try: () => raw.writeDataPoint(dataPoint),
+                catch: (error: any) =>
+                  new AnalyticsEngineDatasetError({
+                    message: error?.message ?? "Unknown error",
+                    cause: error,
+                  }),
+              }),
+            ),
+          ),
+      } satisfies AnalyticsEngineDatasetClient;
+    });
+  }),
+);
+
+export class AnalyticsEngineDatasetBindingPolicy extends Binding.Policy<
+  AnalyticsEngineDatasetBindingPolicy,
+  (dataset: AnalyticsEngineDatasetLike) => Effect.Effect<void>
+>()("Cloudflare.AnalyticsEngineDataset.Binding") {}
+
+export const AnalyticsEngineDatasetBindingPolicyLive =
+  AnalyticsEngineDatasetBindingPolicy.layer.succeed(
+    Effect.fnUntraced(function* (
+      host: ResourceLike,
+      dataset: AnalyticsEngineDatasetLike,
+    ) {
+      if (isWorker(host)) {
+        yield* host.bind(dataset.name, {
+          bindings: [
+            {
+              type: "analytics_engine",
+              name: dataset.name,
+              dataset: dataset.dataset,
+            },
+          ],
+        });
+      } else {
+        return yield* Effect.die(
+          new Error(
+            `AnalyticsEngineDatasetBinding does not support runtime '${host.Type}'`,
+          ),
+        );
+      }
+    }),
+  );

package/src/Cloudflare/AnalyticsEngine/index.ts

@@ -0,0 +1,2 @@
+export * from "./AnalyticsEngineDataset.ts";
+export * from "./AnalyticsEngineDatasetBinding.ts";

package/src/Cloudflare/Artifacts/ArtifactsBinding.ts

@@ -106,7 +106,7 @@ export const ArtifactsBindingLive = Layer.effect(
 
     return Effect.fn(function* (artifacts: ArtifactsLike) {
       yield* Policy(artifacts);
-      const env = WorkerEnvironment.asEffect();
+      const env = WorkerEnvironment;
       const raw = env.pipe(
         Effect.map(
           (env) => (env as Record<string, Artifacts>)[artifacts.name]!,

package/src/Cloudflare/Container/Container.ts

@@ -270,7 +270,7 @@ export const Container: Platform<
           }),
         get: <T>(key: string) =>
           Config.string(key)
-            .asEffect()
+
             .pipe(
               Effect.flatMap((value) =>
                 Effect.try({

package/src/Cloudflare/Container/ContainerApplication.ts

@@ -532,6 +532,7 @@ const HttpServer = NodeHttpServer;
 `
 }
 import { Stack } from "alchemy/Stack";
+import { makeEntrypointLayer } from "alchemy/Runtime";
 import * as Effect from "effect/Effect";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as Layer from "effect/Layer";
@@ -539,13 +540,10 @@ import * as Logger from "effect/Logger";
 import * as Context from "effect/Context";
 import { MinimumLogLevel } from "effect/References";
 
-import ${handler === "default" ? "entry" : `{ ${handler} as entry }`} from "${importPath}";
+import ${handler === "default" ? "entrypoint" : `{ ${handler} as entrypoint }`} from "${importPath}";
 
 const tag = Context.Service("${Self.key}")
-const layer =
-  typeof entry?.build === "function"
-    ? entry
-    : Layer.effect(tag, typeof entry?.asEffect === "function" ? entry.asEffect() : entry);
+const layer = makeEntrypointLayer(tag, entrypoint);
 
 const platform = Layer.mergeAll(
   ${runtime === "bun" ? "BunServices.layer" : "NodeServices.layer"},
@@ -561,7 +559,7 @@ const stack = Layer.succeed(Stack, {
   resources: {}
 });
 
-const serverEffect = tag.asEffect().pipe(
+const serverEffect = tag.pipe(
   Effect.flatMap(func => func.RuntimeContext.exports),
   Effect.flatMap(exports => exports.default),
   Effect.provide(

package/src/Cloudflare/Container/ContainerBinding.ts

@@ -16,11 +16,11 @@ export const bindContainer = Effect.fnUntraced(function* <Shape, Req = never>(
     | (ContainerApplication & Rpc<Shape>)
     | Effect.Effect<ContainerApplication & Rpc<Shape>, never, Req>,
 ) {
-  const namespace = yield* DurableObjectNamespace.asEffect();
+  const namespace = yield* DurableObjectNamespace;
 
   const container =
     "asEffect" in containerEff
-      ? yield* (containerEff as any).asEffect() as Effect.Effect<
+      ? yield* containerEff as any as Effect.Effect<
           ContainerApplication & Rpc<Shape>
         >
       : Effect.isEffect(containerEff)

package/src/Cloudflare/D1/D1Connection.ts

@@ -7,6 +7,86 @@ import { WorkerEnvironment } from "../Workers/Worker.ts";
 import type { D1Database } from "./D1Database.ts";
 import { DatabaseBinding } from "./D1DatabaseBinding.ts";
 
+/**
+ * Effect-native wrapper around a Cloudflare D1 prepared statement.
+ *
+ * Construction (`prepare`) and binding (`bind`) are synchronous —
+ * they're plan builders and don't touch D1. Only the executors
+ * (`all`, `first`, `run`, `raw`) round-trip to the database, and
+ * those return Effects so they participate in the Effect runtime.
+ */
+export class D1PreparedStatement {
+  /** @internal */
+  constructor(
+    private readonly query: string,
+    private readonly binds: ReadonlyArray<unknown>,
+    private readonly rawEff: Effect.Effect<runtime.D1Database>,
+  ) {}
+
+  /**
+   * Return a new prepared statement bound to `values`. Subsequent
+   * calls replace the previous binding, matching the underlying
+   * Cloudflare runtime semantics.
+   */
+  bind(...values: unknown[]): D1PreparedStatement {
+    return new D1PreparedStatement(this.query, values, this.rawEff);
+  }
+
+  /** Run the query and return all matching rows. */
+  all<T = unknown>(): Effect.Effect<runtime.D1Result<T>> {
+    return this.withRuntime((stmt) => stmt.all<T>());
+  }
+
+  /** Run the query and return the first row, or `null` if no rows. */
+  first<T = unknown>(): Effect.Effect<T | null>;
+  first<T = unknown>(column: string): Effect.Effect<T | null>;
+  first<T = unknown>(column?: string): Effect.Effect<T | null> {
+    return this.withRuntime((stmt) =>
+      column !== undefined ? stmt.first<T>(column) : stmt.first<T>(),
+    );
+  }
+
+  /** Run the query as a mutation; returns row metadata. */
+  run<T = unknown>(): Effect.Effect<runtime.D1Result<T>> {
+    return this.withRuntime((stmt) => stmt.run<T>());
+  }
+
+  /** Run the query and return rows as flat arrays. */
+  raw<T = unknown[]>(): Effect.Effect<T[]>;
+  raw<T = unknown[]>(options: {
+    columnNames: true;
+  }): Effect.Effect<[string[], ...T[]]>;
+  raw<T = unknown[]>(options?: {
+    columnNames: true;
+  }): Effect.Effect<T[] | [string[], ...T[]]> {
+    return this.withRuntime((stmt) =>
+      options
+        ? stmt.raw<T>(options)
+        : (stmt.raw<T>() as Promise<T[] | [string[], ...T[]]>),
+    );
+  }
+
+  /**
+   * Materialize the underlying Cloudflare prepared statement against
+   * a concrete D1 binding. Used by `D1ConnectionClient.batch` to
+   * collect statements for a single transactional call.
+   *
+   * @internal
+   */
+  _build(raw: runtime.D1Database): runtime.D1PreparedStatement {
+    const stmt = raw.prepare(this.query);
+    return this.binds.length > 0 ? stmt.bind(...this.binds) : stmt;
+  }
+
+  private withRuntime<A>(
+    fn: (stmt: runtime.D1PreparedStatement) => Promise<A>,
+  ): Effect.Effect<A> {
+    return Effect.flatMap(this.rawEff, (raw) =>
+      Effect.promise(() => fn(this._build(raw))),
+    );
+  }
+}
+
 export interface D1ConnectionClient {
   /**
    * An Effect that resolves to the raw underlying Cloudflare D1Database binding.
@@ -14,9 +94,11 @@ export interface D1ConnectionClient {
    */
   raw: Effect.Effect<runtime.D1Database>;
   /**
-   * Prepare a SQL query statement for later execution.
+   * Prepare a SQL statement. Returns synchronously — the network
+   * round-trip happens when you yield one of the statement's
+   * executors (`all`, `first`, `run`, `raw`).
    */
-  prepare: (query: string) => Effect.Effect<runtime.D1PreparedStatement>;
+  prepare: (query: string) => D1PreparedStatement;
   /**
    * Execute raw SQL without prepared statements.
    */
@@ -26,7 +108,7 @@ export interface D1ConnectionClient {
    * Statements execute sequentially and are rolled back on failure.
    */
   batch: <T = unknown>(
-    statements: runtime.D1PreparedStatement[],
+    statements: D1PreparedStatement[],
   ) => Effect.Effect<runtime.D1Result<T>[]>;
 }
 
@@ -42,22 +124,23 @@ export const D1ConnectionLive = Layer.effect(
 
     return Effect.fn(function* (database: D1Database) {
       yield* Policy(database);
-      const d1 = yield* Effect.serviceOption(WorkerEnvironment).pipe(
+      const rawEff = yield* Effect.serviceOption(WorkerEnvironment).pipe(
         Effect.map(Option.getOrUndefined),
         Effect.map((env) => env?.[database.LogicalId]! as runtime.D1Database),
         Effect.cached,
       );
 
       return {
-        raw: d1,
-        prepare: (query: string) =>
-          d1.pipe(Effect.map((d1) => d1.prepare(query))),
+        raw: rawEff,
+        prepare: (query: string) => new D1PreparedStatement(query, [], rawEff),
         exec: (query: string) =>
-          d1.pipe(Effect.flatMap((d1) => Effect.promise(() => d1.exec(query)))),
-        batch: <T = unknown>(statements: runtime.D1PreparedStatement[]) =>
-          d1.pipe(
-            Effect.flatMap((d1) =>
-              Effect.promise(() => d1.batch<T>(statements)),
+          Effect.flatMap(rawEff, (raw) =>
+            Effect.promise(() => raw.exec(query)),
+          ),
+        batch: <T = unknown>(statements: D1PreparedStatement[]) =>
+          Effect.flatMap(rawEff, (raw) =>
+            Effect.promise(() =>
+              raw.batch<T>(statements.map((s) => s._build(raw))),
             ),
           ),
       } satisfies D1ConnectionClient;

package/src/Cloudflare/Email/EmailAddress.ts

@@ -0,0 +1,155 @@
+import * as emailRouting from "@distilled.cloud/cloudflare/email-routing";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+
+export type EmailAddressProps = {
+  /**
+   * The email address to register as a verified destination on the
+   * account. Cloudflare sends a verification email to this address; the
+   * recipient must click the link before the address can receive routed
+   * mail or be used as a verified sender.
+   *
+   * Changing this property triggers a replacement.
+   */
+  email: string;
+};
+
+export type EmailAddress = Resource<
+  "Cloudflare.EmailAddress",
+  EmailAddressProps,
+  {
+    addressId: string;
+    email: string;
+    accountId: string;
+    verified: boolean;
+    verifiedAt: string | undefined;
+    created: string | undefined;
+    modified: string | undefined;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * A verified destination email address on the account.
+ *
+ * Destination addresses are account-scoped (not zone-scoped). They are used
+ * as forwarding targets in `EmailRule` actions and can also serve as the
+ * `destinationAddress` on a `send_email` Worker binding.
+ *
+ * @section Registering an Address
+ * @example Register a destination address
+ * ```typescript
+ * const ops = yield* Cloudflare.EmailAddress("Ops", {
+ *   email: "ops@example.com",
+ * });
+ * ```
+ *
+ * Cloudflare sends a verification email when the address is first created.
+ * The address must be verified before it can receive routed mail.
+ */
+export const EmailAddress = Resource<EmailAddress>("Cloudflare.EmailAddress");
+
+const toAttrs = (
+  accountId: string,
+  result: {
+    id?: string | null;
+    email?: string | null;
+    verified?: string | null;
+    created?: string | null;
+    modified?: string | null;
+  },
+) => ({
+  addressId: result.id ?? "",
+  email: result.email ?? "",
+  accountId,
+  verified: Boolean(result.verified),
+  verifiedAt: result.verified ?? undefined,
+  created: result.created ?? undefined,
+  modified: result.modified ?? undefined,
+});
+
+export const EmailAddressProvider = () =>
+  Provider.effect(
+    EmailAddress,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const create = yield* emailRouting.createAddress;
+      const get = yield* emailRouting.getAddress;
+      const del = yield* emailRouting.deleteAddress;
+
+      return {
+        stables: ["addressId", "accountId", "email"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!output) return undefined;
+          if (output.accountId !== accountId) {
+            return { action: "replace" } as const;
+          }
+          if (!isResolved(news)) return undefined;
+          if (news.email !== output.email) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fn(function* ({ output, olds }) {
+          const identifier =
+            output?.addressId ??
+            (olds?.email ? encodeURIComponent(olds.email) : undefined);
+          if (!identifier) return undefined;
+          const acct = output?.accountId ?? accountId;
+          return yield* get({
+            accountId: acct,
+            destinationAddressIdentifier: identifier,
+          }).pipe(
+            Effect.map((r) => toAttrs(acct, r)),
+            Effect.catch(() => Effect.succeed(undefined)),
+          );
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          const acct = output?.accountId ?? accountId;
+          const email = news.email;
+
+          // Observe — by addressId if known, else by email lookup.
+          let observed: ReturnType<typeof toAttrs> | undefined =
+            output?.addressId
+              ? yield* get({
+                  accountId: acct,
+                  destinationAddressIdentifier: output.addressId,
+                }).pipe(
+                  Effect.map((r) => toAttrs(acct, r)),
+                  Effect.catch(() => Effect.succeed(undefined)),
+                )
+              : undefined;
+
+          if (!observed) {
+            observed = yield* get({
+              accountId: acct,
+              destinationAddressIdentifier: encodeURIComponent(email),
+            }).pipe(
+              Effect.map((r) => toAttrs(acct, r)),
+              Effect.catch(() => Effect.succeed(undefined)),
+            );
+          }
+
+          // Ensure — register the address if it doesn't already exist.
+          if (!observed) {
+            const created = yield* create({ accountId: acct, email });
+            observed = toAttrs(acct, created);
+          }
+
+          return observed;
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          if (!output?.addressId) return;
+          yield* del({
+            accountId: output.accountId,
+            destinationAddressIdentifier: output.addressId,
+          }).pipe(Effect.catch(() => Effect.void));
+        }),
+      };
+    }),
+  );

package/src/Cloudflare/Email/EmailRouting.ts

@@ -0,0 +1,138 @@
+import * as emailRouting from "@distilled.cloud/cloudflare/email-routing";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import type { Providers } from "../Providers.ts";
+import { resolveZoneId, type ZoneReference } from "../Zone.ts";
+
+export type EmailRoutingStatus =
+  | "ready"
+  | "unconfigured"
+  | "misconfigured"
+  | "misconfigured/locked"
+  | "unlocked";
+
+export type EmailRoutingProps = {
+  /**
+   * Zone to enable email routing on. Accepts a zone id, a zone name
+   * (`example.com`), or a `{ zoneId, name? }` object.
+   */
+  zone: ZoneReference;
+  /**
+   * Whether to enable Email Routing on the zone.
+   *
+   * @default true
+   */
+  enabled?: boolean;
+};
+
+export type EmailRouting = Resource<
+  "Cloudflare.EmailRouting",
+  EmailRoutingProps,
+  {
+    routingId: string;
+    zoneId: string;
+    name: string;
+    enabled: boolean;
+    status: EmailRoutingStatus | undefined;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * Enables Cloudflare Email Routing on a zone. This is the prerequisite for
+ * receiving mail at any address on the domain and for sending email from a
+ * Worker via `send_email` bindings.
+ *
+ * @section Enabling Email Routing
+ * @example Enable on a zone you own
+ * ```typescript
+ * const routing = yield* Cloudflare.EmailRouting("Routing", {
+ *   zone: "example.com",
+ * });
+ * ```
+ */
+export const EmailRouting = Resource<EmailRouting>("Cloudflare.EmailRouting");
+
+export const EmailRoutingProvider = () =>
+  Provider.effect(
+    EmailRouting,
+    Effect.gen(function* () {
+      const { accountId } = yield* CloudflareEnvironment;
+      const enable = yield* emailRouting.enableEmailRouting;
+      const disable = yield* emailRouting.disableEmailRouting;
+      const get = yield* emailRouting.getEmailRouting;
+
+      const resolve = (zone: ZoneReference) =>
+        resolveZoneId({
+          accountId,
+          zone,
+          hostname: typeof zone === "string" ? zone : (zone.name ?? ""),
+        });
+
+      return {
+        stables: ["zoneId", "routingId"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!output) return undefined;
+          if (!isResolved(news)) return undefined;
+          const zoneId = yield* resolve(news.zone);
+          if (zoneId !== output.zoneId) {
+            return { action: "replace" } as const;
+          }
+          if ((news.enabled ?? true) !== output.enabled) {
+            return { action: "update" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.zoneId) return undefined;
+          const result = yield* get({ zoneId: output.zoneId });
+          return {
+            routingId: result.id,
+            zoneId: output.zoneId,
+            name: result.name,
+            enabled: result.enabled,
+            status: (result.status ?? undefined) as
+              | EmailRoutingStatus
+              | undefined,
+          };
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          const zoneId = output?.zoneId ?? (yield* resolve(news.zone));
+          const desired = news.enabled ?? true;
+
+          if (desired) {
+            const result = yield* enable({ zoneId, body: {} });
+            return {
+              routingId: result.id,
+              zoneId,
+              name: result.name,
+              enabled: result.enabled,
+              status: (result.status ?? undefined) as
+                | EmailRoutingStatus
+                | undefined,
+            };
+          } else {
+            const result = yield* disable({ zoneId, body: {} });
+            return {
+              routingId: result.id,
+              zoneId,
+              name: result.name,
+              enabled: result.enabled,
+              status: (result.status ?? undefined) as
+                | EmailRoutingStatus
+                | undefined,
+            };
+          }
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* disable({ zoneId: output.zoneId, body: {} }).pipe(
+            Effect.catch(() => Effect.void),
+          );
+        }),
+      };
+    }),
+  );