alchemy 2.0.0-beta.35 → 2.0.0-beta.36

package/src/Cloudflare/R2/R2Bucket.ts

@@ -42,6 +42,60 @@ export type R2BucketCustomDomain = {
   minTLS?: "1.0" | "1.1" | "1.2" | "1.3";
 };
 
+export type R2BucketLifecycleCondition =
+  | {
+      type: "Age";
+      /**
+       * Maximum age of an object, in seconds, before the rule's action applies.
+       */
+      maxAge: number;
+    }
+  | {
+      type: "Date";
+      /**
+       * Absolute date (ISO 8601) at which the rule's action applies.
+       */
+      date: string;
+    };
+
+export type R2BucketLifecycleRule = {
+  /**
+   * Unique identifier for the rule within the bucket.
+   */
+  id: string;
+  /**
+   * Whether the rule is enabled.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Object key prefix the rule applies to. Use `""` (or omit) to match all
+   * objects in the bucket.
+   * @default ""
+   */
+  prefix?: string;
+  /**
+   * Abort incomplete multipart uploads after the configured age.
+   */
+  abortMultipartUploadsTransition?: {
+    condition?: { type: "Age"; maxAge: number };
+  };
+  /**
+   * Delete matching objects after the configured age or on a specific date.
+   */
+  deleteObjectsTransition?: {
+    condition?: R2BucketLifecycleCondition;
+  };
+  /**
+   * Transition matching objects to a different storage class. Cloudflare R2
+   * only supports transitioning to `InfrequentAccess` today.
+   */
+  storageClassTransitions?: {
+    condition: R2BucketLifecycleCondition;
+    storageClass: "InfrequentAccess";
+  }[];
+};
+
 export type R2BucketProps = {
   /**
    * Name of the bucket. If omitted, a unique name will be generated.
@@ -67,6 +121,12 @@ export type R2BucketProps = {
    * to remove all custom domains.
    */
   domains?: R2BucketCustomDomain[];
+  /**
+   * Object lifecycle rules applied to the bucket. Pass an empty array (or
+   * omit) to clear all lifecycle rules. See the Cloudflare R2 docs for
+   * supported transitions.
+   */
+  lifecycleRules?: R2BucketLifecycleRule[];
 };
 
 export type R2Bucket = Resource<
@@ -79,6 +139,7 @@ export type R2Bucket = Resource<
     location: R2Bucket.Location | undefined;
     accountId: string;
     domains: R2Bucket.CustomDomain[];
+    lifecycleRules: R2Bucket.LifecycleRule[];
   },
   never,
   Cloudflare.Providers
@@ -175,6 +236,63 @@ export type R2Bucket = Resource<
  *   ],
  * });
  * ```
+ *
+ * @section Object Lifecycle Rules
+ *
+ * Configure lifecycle rules to automatically delete objects, abort
+ * incomplete multipart uploads, or transition objects to InfrequentAccess
+ * storage. Pass an empty array (or omit) to clear all rules. See the
+ * [Cloudflare R2 docs](https://developers.cloudflare.com/r2/buckets/object-lifecycles/)
+ * for details and limits (max 1000 rules per bucket).
+ *
+ * @example Delete objects 30 days after upload
+ * ```typescript
+ * const bucket = yield* Cloudflare.R2Bucket("MyBucket", {
+ *   lifecycleRules: [
+ *     {
+ *       id: "expire-old-objects",
+ *       deleteObjectsTransition: {
+ *         condition: { type: "Age", maxAge: 60 * 60 * 24 * 30 },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Transition to InfrequentAccess after 60 days, delete after 365
+ * ```typescript
+ * const bucket = yield* Cloudflare.R2Bucket("MyBucket", {
+ *   lifecycleRules: [
+ *     {
+ *       id: "archive-then-delete",
+ *       prefix: "logs/",
+ *       storageClassTransitions: [
+ *         {
+ *           condition: { type: "Age", maxAge: 60 * 60 * 24 * 60 },
+ *           storageClass: "InfrequentAccess",
+ *         },
+ *       ],
+ *       deleteObjectsTransition: {
+ *         condition: { type: "Age", maxAge: 60 * 60 * 24 * 365 },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Abort incomplete multipart uploads after 7 days
+ * ```typescript
+ * const bucket = yield* Cloudflare.R2Bucket("MyBucket", {
+ *   lifecycleRules: [
+ *     {
+ *       id: "abort-stale-uploads",
+ *       abortMultipartUploadsTransition: {
+ *         condition: { type: "Age", maxAge: 60 * 60 * 24 * 7 },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
  */
 export const R2Bucket = Resource<R2Bucket>("Cloudflare.R2Bucket")({
   bind: R2BucketBinding.bind,
@@ -184,6 +302,23 @@ export declare namespace R2Bucket {
   export type StorageClass = "Standard" | "InfrequentAccess";
   export type Jurisdiction = "default" | "eu" | "fedramp";
   export type Location = "apac" | "eeur" | "enam" | "weur" | "wnam" | "oc";
+  export type LifecycleRule = {
+    id: string;
+    enabled: boolean;
+    prefix: string;
+    abortMultipartUploadsTransition:
+      | { condition: { type: "Age"; maxAge: number } | undefined }
+      | undefined;
+    deleteObjectsTransition:
+      | { condition: R2BucketLifecycleCondition | undefined }
+      | undefined;
+    storageClassTransitions:
+      | {
+          condition: R2BucketLifecycleCondition;
+          storageClass: "InfrequentAccess";
+        }[]
+      | undefined;
+  };
   export type CustomDomain = {
     domain: string;
     zoneId: string | undefined;
@@ -224,6 +359,8 @@ export const R2BucketProvider = () =>
       const createBucketDomainCustom = yield* r2.createBucketDomainCustom;
       const updateBucketDomainCustom = yield* r2.updateBucketDomainCustom;
       const deleteBucketDomainCustom = yield* r2.deleteBucketDomainCustom;
+      const getBucketLifecycle = yield* r2.getBucketLifecycle;
+      const putBucketLifecycle = yield* r2.putBucketLifecycle;
 
       const createBucketName = (id: string, name: string | undefined) =>
         Effect.gen(function* () {
@@ -252,7 +389,7 @@ export const R2BucketProvider = () =>
         }).pipe(
           Effect.retry({
             while: isNoSuchBucket,
-            schedule: r2CustomDomainConsistencySchedule,
+            schedule: r2BucketEndpointConsistencySchedule,
           }),
           Effect.map((response) =>
             response.domains.map(toCustomDomainAttributes),
@@ -351,7 +488,7 @@ export const R2BucketProvider = () =>
                   }).pipe(
                     Effect.retry({
                       while: isNoSuchBucket,
-                      schedule: r2CustomDomainConsistencySchedule,
+                      schedule: r2BucketEndpointConsistencySchedule,
                     }),
                   );
                   return toCustomDomainAttributes({ ...created, zoneId });
@@ -368,7 +505,7 @@ export const R2BucketProvider = () =>
                 }).pipe(
                   Effect.retry({
                     while: isNoSuchBucket,
-                    schedule: r2CustomDomainConsistencySchedule,
+                    schedule: r2BucketEndpointConsistencySchedule,
                   }),
                 );
                 return toCustomDomainAttributes({
@@ -383,6 +520,45 @@ export const R2BucketProvider = () =>
           return applied.sort((a, b) => a.domain.localeCompare(b.domain));
         });
 
+      const reconcileLifecycleRules = (
+        bucketName: string,
+        jurisdiction: R2Bucket.Jurisdiction,
+        desired: R2BucketLifecycleRule[],
+      ) =>
+        Effect.gen(function* () {
+          const observed = yield* getBucketLifecycle({
+            accountId,
+            bucketName,
+            jurisdiction,
+          }).pipe(
+            Effect.retry({
+              while: isNoSuchBucket,
+              schedule: r2BucketEndpointConsistencySchedule,
+            }),
+          );
+
+          const observedRules = (observed.rules ?? []).map(toLifecycleRule);
+          const desiredRules = desired.map(normalizeLifecycleRule);
+
+          if (deepEqual(observedRules, desiredRules)) {
+            return desiredRules;
+          }
+
+          yield* putBucketLifecycle({
+            accountId,
+            bucketName,
+            jurisdiction,
+            rules: desired.map(toLifecyclePutPayload),
+          }).pipe(
+            Effect.retry({
+              while: isNoSuchBucket,
+              schedule: r2BucketEndpointConsistencySchedule,
+            }),
+          );
+
+          return desiredRules;
+        });
+
       return {
         stables: ["bucketName", "accountId"],
         diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
@@ -412,6 +588,9 @@ export const R2BucketProvider = () =>
           if (!deepEqual(olds.domains, news.domains)) {
             return { action: "update" } as const;
           }
+          if (!deepEqual(olds.lifecycleRules, news.lifecycleRules)) {
+            return { action: "update" } as const;
+          }
         }),
         reconcile: Effect.fn(function* ({ id, news = {}, output }) {
           const name = yield* createBucketName(id, news.name);
@@ -481,9 +660,16 @@ export const R2BucketProvider = () =>
             output?.domains ?? [],
           );
 
+          const lifecycleRules = yield* reconcileLifecycleRules(
+            attrs.bucketName,
+            attrs.jurisdiction,
+            news.lifecycleRules ?? [],
+          );
+
           return {
             ...attrs,
             domains,
+            lifecycleRules,
           };
         }),
         delete: Effect.fn(function* ({ output }) {
@@ -519,6 +705,7 @@ export const R2BucketProvider = () =>
               location: normalizeLocation(bucket.location),
               accountId: acct,
               domains: output?.domains ?? [],
+              lifecycleRules: output?.lifecycleRules ?? [],
             })),
             Effect.catchTag("NoSuchBucket", () => Effect.succeed(undefined)),
           );
@@ -527,10 +714,11 @@ export const R2BucketProvider = () =>
     }),
   );
 
-// R2 can make a newly-created bucket visible to `getBucket` before the custom
-// domain endpoints accept it. Retry only that narrow `NoSuchBucket` lag here;
-// not-found domains are still treated as terminal for idempotent deletes.
-const r2CustomDomainConsistencySchedule = Schedule.exponential(100).pipe(
+// R2 can make a newly-created bucket visible to `getBucket` before its
+// sub-resource endpoints (custom domains, lifecycle) accept it. Retry only
+// that narrow `NoSuchBucket` lag here; not-found sub-resources are still
+// treated as terminal for idempotent deletes.
+const r2BucketEndpointConsistencySchedule = Schedule.exponential(100).pipe(
   Schedule.both(Schedule.recurs(5)),
 );
 
@@ -573,6 +761,51 @@ const isMissingCustomDomainOrBucket = (error: unknown): boolean =>
       ((error as { _tag: unknown })._tag === "DomainNotFound" ||
         (error as { _tag: unknown })._tag === "NoSuchBucket")));
 
+type LifecycleRuleResponse = NonNullable<
+  r2.GetBucketLifecycleResponse["rules"]
+>[number];
+
+const toLifecycleRule = (
+  rule: LifecycleRuleResponse,
+): R2Bucket.LifecycleRule => ({
+  id: rule.id,
+  enabled: rule.enabled,
+  prefix: rule.conditions.prefix ?? "",
+  abortMultipartUploadsTransition: rule.abortMultipartUploadsTransition
+    ? { condition: rule.abortMultipartUploadsTransition.condition ?? undefined }
+    : undefined,
+  deleteObjectsTransition: rule.deleteObjectsTransition
+    ? { condition: rule.deleteObjectsTransition.condition ?? undefined }
+    : undefined,
+  storageClassTransitions: rule.storageClassTransitions ?? undefined,
+});
+
+const normalizeLifecycleRule = (
+  rule: R2BucketLifecycleRule,
+): R2Bucket.LifecycleRule => ({
+  id: rule.id,
+  enabled: rule.enabled ?? true,
+  prefix: rule.prefix ?? "",
+  abortMultipartUploadsTransition: rule.abortMultipartUploadsTransition
+    ? { condition: rule.abortMultipartUploadsTransition.condition }
+    : undefined,
+  deleteObjectsTransition: rule.deleteObjectsTransition
+    ? { condition: rule.deleteObjectsTransition.condition }
+    : undefined,
+  storageClassTransitions: rule.storageClassTransitions,
+});
+
+const toLifecyclePutPayload = (
+  rule: R2BucketLifecycleRule,
+): NonNullable<r2.PutBucketLifecycleRequest["rules"]>[number] => ({
+  id: rule.id,
+  enabled: rule.enabled ?? true,
+  conditions: { prefix: rule.prefix ?? "" },
+  abortMultipartUploadsTransition: rule.abortMultipartUploadsTransition,
+  deleteObjectsTransition: rule.deleteObjectsTransition,
+  storageClassTransitions: rule.storageClassTransitions,
+});
+
 const isNoSuchBucket = (error: unknown): boolean =>
   typeof error === "object" &&
   error !== null &&

package/src/Cloudflare/Workers/InferEnv.ts

@@ -27,6 +27,10 @@ type GetBindingType<T> = T extends Cloudflare.Assets
             ? Ai
             : T extends Cloudflare.Artifacts
               ? Artifacts
-              : T extends Cloudflare.DurableObjectNamespaceLike
-                ? DurableObjectNamespace<Exclude<T["Shape"], undefined>>
-                : never;
+              : T extends Cloudflare.Images
+                ? ImagesBinding
+                : T extends Cloudflare.Hyperdrive
+                  ? Hyperdrive
+                  : T extends Cloudflare.DurableObjectNamespaceLike
+                    ? DurableObjectNamespace<Exclude<T["Shape"], undefined>>
+                    : never;

package/src/Cloudflare/Workers/Worker.ts

@@ -6,7 +6,6 @@ import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
-import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
@@ -46,7 +45,14 @@ import {
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { D1Database } from "../D1/D1Database.ts";
 import { fromCloudflareFetcher } from "../Fetcher.ts";
-import type { HyperdriveDevOrigin } from "../Hyperdrive/Hyperdrive.ts";
+import type {
+  Hyperdrive,
+  HyperdriveDevOrigin,
+} from "../Hyperdrive/Hyperdrive.ts";
+import {
+  isImages as isImagesBinding,
+  type Images as ImagesBinding,
+} from "../Images/Images.ts";
 import type { KVNamespace } from "../KV/KVNamespace.ts";
 import { SidecarLive } from "../Local/Sidecar.ts";
 import { CloudflareLogs } from "../Logs.ts";
@@ -182,6 +188,8 @@ export type WorkerBindingResource =
   | CloudflareQueue
   | AiGateway
   | ArtifactsBinding
+  | ImagesBinding
+  | Hyperdrive
   | DurableObjectNamespaceLike<any>;
 
 export type WorkerBindings = {
@@ -734,48 +742,61 @@ export const Worker: Platform<
                 name: bindingName,
                 namespace: binding.namespace,
               } as any)
-            : isDurableObjectNamespaceLike(binding)
+            : isImagesBinding(binding)
               ? {
-                  type: "durable_object_namespace",
+                  type: "images",
                   name: bindingName,
-                  className: binding.className ?? binding.name,
                 }
-              : binding.Type === "Cloudflare.D1Database"
+              : isDurableObjectNamespaceLike(binding)
                 ? {
-                    type: "d1",
-                    id: binding.databaseId,
+                    type: "durable_object_namespace",
                     name: bindingName,
+                    className: binding.className ?? binding.name,
                   }
-                : binding.Type === "Cloudflare.R2Bucket"
+                : binding.Type === "Cloudflare.D1Database"
                   ? {
-                      type: "r2_bucket",
+                      type: "d1",
+                      id: binding.databaseId,
                       name: bindingName,
-                      bucketName: binding.bucketName,
-                      jurisdiction: binding.jurisdiction.pipe(
-                        Output.map((jurisdiction) =>
-                          jurisdiction === "default" ? undefined : jurisdiction,
-                        ),
-                      ),
                     }
-                  : binding.Type === "Cloudflare.KVNamespace"
+                  : binding.Type === "Cloudflare.R2Bucket"
                     ? {
-                        type: "kv_namespace",
+                        type: "r2_bucket",
                         name: bindingName,
-                        namespaceId: binding.namespaceId,
+                        bucketName: binding.bucketName,
+                        jurisdiction: binding.jurisdiction.pipe(
+                          Output.map((jurisdiction) =>
+                            jurisdiction === "default"
+                              ? undefined
+                              : jurisdiction,
+                          ),
+                        ),
                       }
-                    : binding.Type === "Cloudflare.Queue"
+                    : binding.Type === "Cloudflare.KVNamespace"
                       ? {
-                          type: "queue",
+                          type: "kv_namespace",
                           name: bindingName,
-                          queueName: binding.queueName,
+                          namespaceId: binding.namespaceId,
                         }
-                      : binding.Type === "Cloudflare.AiGateway"
+                      : binding.Type === "Cloudflare.Queue"
                         ? {
-                            type: "ai",
+                            type: "queue",
                             name: bindingName,
+                            queueName: binding.queueName,
                           }
-                        : // TODO(sam): handle others
-                          undefined;
+                        : binding.Type === "Cloudflare.AiGateway"
+                          ? {
+                              type: "ai",
+                              name: bindingName,
+                            }
+                          : binding.Type === "Cloudflare.Hyperdrive"
+                            ? {
+                                type: "hyperdrive",
+                                name: bindingName,
+                                id: binding.hyperdriveId,
+                              }
+                            : // TODO(sam): handle others
+                              undefined;
 
         if (bindingMeta) {
           yield* resource.bind`${bindingName}`({
@@ -1059,11 +1080,9 @@ export const LiveWorkerProvider = () =>
   Provider.effect(
     Worker,
     Effect.gen(function* () {
-      const fs = yield* FileSystem.FileSystem;
       const path = yield* Path.Path;
 
       const { accountId } = yield* CloudflareEnvironment;
-      const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
       const bundler = yield* WorkerBundle;
       const stack = yield* Stack;
 

package/src/Cloudflare/index.ts

@@ -6,6 +6,7 @@ export * from "./Container/index.ts";
 export * from "./D1/index.ts";
 export * from "./EdgeSession.ts";
 export * from "./Hyperdrive/index.ts";
+export * from "./Images/index.ts";
 export * from "./KV/index.ts";
 export * from "./Providers.ts";
 export * from "./Queue/index.ts";

package/src/Test/Vitest.ts

@@ -10,8 +10,11 @@ import {
 import type { AlchemyContext } from "../AlchemyContext.ts";
 import type { CompiledStack } from "../Stack.ts";
 import type { Stage } from "../Stage.ts";
+import { installLocalhostDns } from "../Util/LocalhostDns.ts";
 import * as Core from "./Core.ts";
 
+installLocalhostDns();
+
 export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
 export type ScratchStack = Core.ScratchStack;
 export type TestEffect<A, R = never> = Core.TestEffect<A, R>;

package/src/Util/LocalhostDns.ts

@@ -0,0 +1,58 @@
+/**
+ * Process-level DNS shim that makes `*.localhost` resolve to 127.0.0.1.
+ *
+ * Background: macOS's `getaddrinfo` does not honor RFC 6761 for arbitrary
+ * `*.localhost` names; only the bare `localhost` is mapped to loopback.
+ * workerd and browsers handle it themselves, but Node's undici-based fetch
+ * (and Bun's libcurl-based fetch on some platforms) fails with `ENOTFOUND`
+ * when calling URLs returned by the local Cloudflare worker proxy
+ * (e.g. `http://my-worker.localhost:1337`).
+ *
+ * The proxy in `@distilled.cloud/cloudflare-runtime` dispatches by the
+ * URL hostname, so we cannot rewrite the URL client-side to `127.0.0.1`
+ * (and `Host` is a forbidden fetch header). The fix is to make the host
+ * resolvable at the network layer.
+ *
+ * Calling `installLocalhostDns()` is idempotent.
+ */
+
+import { createRequire } from "node:module";
+
+let installed = false;
+
+const isLocalhost = (hostname: string): boolean =>
+  hostname === "localhost" ||
+  hostname === "[::1]" ||
+  hostname.endsWith(".localhost");
+
+export const installLocalhostDns = (): void => {
+  if (installed) return;
+  installed = true;
+  // Bun resolves `*.localhost` natively via its libcurl-based fetch on
+  // Darwin and Linux, so the shim is a no-op there. If a future Bun
+  // release changes this, install via Bun's undici-compatible global
+  // dispatcher here.
+  if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") return;
+  try {
+    const require = createRequire(import.meta.url);
+    const undici: typeof import("undici") = require("undici");
+    const dns: typeof import("node:dns") = require("node:dns");
+    undici.setGlobalDispatcher(
+      new undici.Agent({
+        connect: {
+          lookup: (hostname, options, cb: any) => {
+            if (isLocalhost(hostname)) {
+              if (options && (options as { all?: boolean }).all) {
+                return cb(null, [{ address: "127.0.0.1", family: 4 }]);
+              }
+              return cb(null, "127.0.0.1", 4);
+            }
+            return dns.lookup(hostname, options, cb);
+          },
+        },
+      }),
+    );
+  } catch {
+    // undici not available; nothing to do.
+  }
+};

package/src/Util/PlatformServices.ts

@@ -9,6 +9,7 @@ import type { HttpServer } from "effect/unstable/http/HttpServer";
 import type { ServeError } from "effect/unstable/http/HttpServerError";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
+import { installLocalhostDns } from "./LocalhostDns.ts";
 
 const isBun = typeof Bun !== "undefined";
 
@@ -52,6 +53,7 @@ export const runMain = <E, A>(
     readonly teardown?: Teardown | undefined;
   },
 ): void => {
+  installLocalhostDns();
   if (isBun) {
     void import("@effect/platform-bun/BunRuntime").then((BunRuntime) =>
       BunRuntime.runMain(effect, options),