alchemy 2.0.0-beta.50 → 2.0.0-beta.52

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -66,6 +66,10 @@ import type { WorkerBinding } from "./WorkerBinding.ts";
 import { WorkerBundle, type WorkerBundleOptions } from "./WorkerBundle.ts";
 import { createWorkerName } from "./WorkerName.ts";
 
+type WorkerPropsWithDev = Omit<WorkerProps, "dev"> & {
+  dev: Exclude<WorkerProps["dev"], false | string>;
+};
+
 export class WorkerValidationError extends Schema.TaggedErrorClass<WorkerValidationError>()(
   "WorkerValidationError",
   {
@@ -227,7 +231,7 @@ export const LocalWorkerProvider = () =>
         bindings,
       }: {
         id: string;
-        props: WorkerProps;
+        props: WorkerPropsWithDev;
         bindings: ResourceBinding<Worker["Binding"]>[];
       }) {
         const name = yield* createWorkerName(id, props.name);
@@ -244,6 +248,7 @@ export const LocalWorkerProvider = () =>
               ? Text.local(key, unredacted)
               : Json.local(key, unredacted);
           }),
+          ...(props.assets || props.vite ? [Assets.local("ASSETS")] : []),
         ];
         const durableObjectNamespaces: Record<string, string> = {};
         const hyperdrives: Record<string, Required<HyperdriveOrigin>> = {};
@@ -257,11 +262,19 @@ export const LocalWorkerProvider = () =>
             ) {
               // Reuse the existing namespace id if it was provided, otherwise generate a new one.
               // `workerd` uses this for the object's storage path, so it must be safe to use as a file name.
-              durableObjectNamespaces[binding.className] =
+              const namespaceId =
                 binding.namespaceId ??
-                encodeURIComponent(`${id}-${binding.className}`);
+                encodeURIComponent(`${name}-${binding.className}`);
+              durableObjectNamespaces[binding.className] = namespaceId;
+              workerBindings.push(
+                yield* toRuntimeBinding({
+                  ...binding,
+                  namespaceId,
+                }),
+              );
+            } else {
+              workerBindings.push(yield* toRuntimeBinding(binding));
             }
-            workerBindings.push(yield* toRuntimeBinding(binding));
           }
           if (data.hyperdrives) {
             for (const [id, origin] of Object.entries(data.hyperdrives)) {
@@ -408,7 +421,7 @@ export const LocalWorkerProvider = () =>
 
       const runInstance = Effect.fn(function* (options: {
         id: string;
-        props: WorkerProps;
+        props: WorkerPropsWithDev;
         bindings: ResourceBinding<Worker["Binding"]>[];
       }) {
         const { props, bindings } = options;
@@ -450,7 +463,32 @@ export const LocalWorkerProvider = () =>
           };
         }),
         reconcile: Effect.fn(function* ({ id, news, bindings }) {
-          const options = { id, props: news, bindings };
+          // `dev: false` opts out of running a local Worker entirely —
+          // typically because an external dev process (DevCommand) is
+          // serving requests. Tear down any prior instance and return a
+          // stub Attributes; the resource exists in state but has no
+          // running workerd / proxy behind it.
+          if (news.dev === false || typeof news.dev === "string") {
+            const existing = instances.get(id);
+            if (existing) {
+              yield* Fiber.interrupt(existing.fiber);
+              yield* Scope.close(existing.scope, Exit.void);
+              instances.delete(id);
+            }
+            const name = yield* createWorkerName(id, news.name);
+            return {
+              workerId: name,
+              workerName: name,
+              logpush: undefined,
+              url: news.dev || undefined,
+              tags: [],
+              durableObjectNamespaces: {},
+              accountId,
+              domains: [],
+              crons: news.crons ?? [],
+            } satisfies Worker["Attributes"];
+          }
+          const options = { id, props: news as WorkerPropsWithDev, bindings };
           const hash = Hash.structure(options);
           const existing = instances.get(options.id);
           if (existing) {
@@ -526,6 +564,9 @@ const toRuntimeBinding = Effect.fnUntraced(function* (b: WorkerBinding) {
         binding: b.name,
         className: b.className,
         scriptName: b.scriptName,
+        uniqueKey:
+          b.namespaceId ??
+          encodeURIComponent(`${b.scriptName!}-${b.className}`),
       });
     case "hyperdrive":
       return Hyperdrive.local(b.name, b.id);
@@ -600,24 +641,24 @@ const toRuntimeAssets = (
     };
   }
   return {
-    directory: "directory" in assets ? assets.directory : assets.path,
-    headers: assets.config?.headers,
-    redirects: assets.config?.redirects,
+    directory: assets.directory,
+    headers: assets.headers,
+    redirects: assets.redirects,
     // Distilled widened generated string enums to open unions (`string & {}`);
     // the API only ever returns the known variants here.
-    htmlHandling: assets.config?.htmlHandling as
+    htmlHandling: assets.htmlHandling as
       | "none"
       | "auto-trailing-slash"
       | "force-trailing-slash"
       | "drop-trailing-slash"
       | undefined,
-    notFoundHandling: assets.config?.notFoundHandling as
+    notFoundHandling: assets.notFoundHandling as
       | "none"
       | "404-page"
       | "single-page-application"
       | undefined,
-    runWorkerFirst: assets.config?.runWorkerFirst,
-    serveDirectly: assets.config?.serveDirectly,
+    runWorkerFirst: assets.runWorkerFirst,
+    serveDirectly: assets.serveDirectly,
   };
 };
 

package/src/Cloudflare/Workers/RpcDurableObjectNamespace.ts

@@ -1,3 +1,4 @@
+import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import type * as Layer from "effect/Layer";
@@ -100,7 +101,7 @@ export interface RpcDurableObjectNamespaceClass extends Effect.Effect<
       from<Req = never>(
         worker:
           | Dependencies<Self>
-          | Effect.Effect<Dependencies<Self>, never, Req>,
+          | Effect.Effect<Dependencies<Self>, ConfigError, Req>,
       ): Effect.Effect<
         RpcDurableObjectNamespace<Self, Rpcs>,
         never,
@@ -113,7 +114,7 @@ export interface RpcDurableObjectNamespaceClass extends Effect.Effect<
             never,
             DurableObjectServices
           >,
-          never,
+          ConfigError,
           InitReq
         >,
       ): Layer.Layer<
@@ -132,7 +133,7 @@ export interface RpcDurableObjectNamespaceClass extends Effect.Effect<
           never,
           DurableObjectServices
         >,
-        never,
+        ConfigError,
         InitReq
       >,
     ): Effect.Effect<
@@ -160,7 +161,7 @@ export interface RpcDurableObjectNamespaceClass extends Effect.Effect<
         never,
         DurableObjectServices
       >,
-      never,
+      ConfigError,
       InitReq
     >,
   ): Effect.Effect<
@@ -456,11 +457,12 @@ const build = (
   // eagerly here (consumers wanting cross-script binding use the
   // modular form below).
   const underlying = (DurableObjectNamespace as any)()(name, wrapImpl(impl));
-  const underlyingEff: Effect.Effect<
+  // `underlying` is itself an Effect now, no `.asEffect()` hop required.
+  const underlyingEff = underlying as Effect.Effect<
     DurableObjectNamespaceType<any>,
     never,
     any
-  > = (underlying as { asEffect(): Effect.Effect<any, never, any> }).asEffect();
+  >;
   const rpcBound = underlyingEff.pipe(
     Effect.map((rawNs) => rpcWrap(rawNs, props.schema)),
   ) as unknown as Effect.Effect<RpcDurableObjectNamespace<any>>;
@@ -476,11 +478,12 @@ const buildModular = (name: string, schema: RpcGroup.RpcGroup<any>) => {
   //     binding on the surrounding worker and yields a fresh handle
   // We just rpc-wrap each output so consumers see a typed `getByName`.
   const Underlying: any = (DurableObjectNamespace as any)()(name);
-  const underlyingEff: Effect.Effect<
+  // `Underlying` is itself an Effect now, no `.asEffect()` hop required.
+  const underlyingEff = Underlying as Effect.Effect<
     DurableObjectNamespaceType<any>,
     never,
     any
-  > = (Underlying as { asEffect(): Effect.Effect<any, never, any> }).asEffect();
+  >;
 
   return class extends effectClass(
     underlyingEff.pipe(

package/src/Cloudflare/Workers/RpcWorker.ts

@@ -1,3 +1,4 @@
+import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -107,7 +108,7 @@ export interface RpcWorkerClass extends Effect.Effect<
       make<InnerR = never, InitReq = never>(
         impl: Effect.Effect<
           Effect.Effect<HttpEffect<InnerR>, never, InnerR>,
-          never,
+          ConfigError,
           InitReq
         >,
       ): Layer.Layer<Self, never, Exclude<InitReq | InnerR, never>>;
@@ -118,7 +119,7 @@ export interface RpcWorkerClass extends Effect.Effect<
       props: RpcWorkerProps<Rpcs>,
       impl: Effect.Effect<
         Effect.Effect<HttpEffect<InnerR>, never, InnerR>,
-        never,
+        ConfigError,
         InitReq
       >,
     ): RpcWorkerYieldable<Self, Rpcs, Deps> & {
@@ -519,9 +520,9 @@ const buildModular = (id: string, props: RpcWorkerProps<any>) => {
   // shape `Cloudflare.Worker` expects, and stash the rpc schema on
   // the class so `RpcWorker.bind(WorkerClass)` can recover it.
   const Underlying: any = (WorkerCtor as any)()(id, workerProps);
-  const klass = class extends effectClass(
-    (Underlying as { asEffect(): Effect.Effect<Worker> }).asEffect(),
-  ) {
+  // `Underlying` is itself an Effect (the no-impl Worker class), so hand it
+  // straight to `effectClass` rather than reaching for a removed `.asEffect()`.
+  const klass = class extends effectClass(Underlying as Effect.Effect<Worker>) {
     static make = (
       impl: Effect.Effect<Effect.Effect<HttpEffect<any>>>,
     ): Layer.Layer<any, never, any> => Underlying.make(wrapImpl(impl));
@@ -553,9 +554,9 @@ const build = (
   // Re-wrap as our own `effectClass` so we can stash the rpc schema
   // on the class for `RpcWorker.bind` to recover later. (Re-using
   // `effectClass` here means `class X extends RpcWorker<X>()(...)`
-  // still works.)
+  // still works.) `underlying` is already an Effect, so pass it directly.
   const klass = effectClass(
-    (underlying as { asEffect(): Effect.Effect<Worker> }).asEffect(),
+    underlying as Effect.Effect<Worker>,
   ) as unknown as Record<symbol, unknown>;
   klass[SchemaSymbol] = schema;
   return klass;

package/src/Cloudflare/Workers/VersionMetadata.ts

@@ -0,0 +1,129 @@
+import type * as Effect from "effect/Effect";
+import { SingleShotGen } from "effect/Utils";
+import {
+  VersionMetadataBinding,
+  type VersionMetadataAccessor,
+} from "./VersionMetadataBinding.ts";
+
+type VersionMetadataTypeId = typeof VersionMetadataTypeId;
+const VersionMetadataTypeId = "Cloudflare.VersionMetadata" as const;
+
+export type VersionMetadataProps = {
+  /**
+   * Binding name used when `VersionMetadata` is bound from inside a Worker init
+   * phase (`yield* Cloudflare.VersionMetadata(...)`). When passed through
+   * `Worker({ env: { ... } })`, the object key remains the binding name.
+   *
+   * @default "CF_VERSION_METADATA"
+   */
+  name?: string;
+};
+
+/**
+ * The Effect yielded when a `VersionMetadata` marker is used inside a Worker
+ * init phase: it attaches the `version_metadata` binding to the surrounding
+ * Worker and resolves to a deferred {@link VersionMetadataAccessor}.
+ */
+type BindEffect = Effect.Effect<
+  VersionMetadataAccessor,
+  never,
+  VersionMetadataBinding
+>;
+
+/**
+ * Marker for a Cloudflare Workers Version Metadata binding.
+ *
+ * It is a plain data structure (so it can be declared directly on a Worker's
+ * `env`) that is **also** yieldable inside an Effect-native Worker. Yielding it
+ * (`yield* Cloudflare.VersionMetadata(...)`) attaches the binding to the
+ * surrounding Worker and returns a deferred accessor for the runtime
+ * {@link import("./VersionMetadataBinding.ts").WorkerVersionMetadata}.
+ *
+ * The divergence is achieved via `[Symbol.iterator]`: the object is
+ * deliberately not an `Effect` (so `InferEnv` and the Worker `env` resolver
+ * keep it as the native version metadata rather than `yield*`-ing it), but it
+ * is iterable as one when `yield*`-ed.
+ */
+export type VersionMetadata = {
+  kind: VersionMetadataTypeId;
+  name: string;
+  asEffect(): BindEffect;
+  [Symbol.iterator](): SingleShotGen<BindEffect, VersionMetadataAccessor>;
+};
+
+export const isVersionMetadata = (value: unknown): value is VersionMetadata =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  (value as VersionMetadata).kind === VersionMetadataTypeId;
+
+/**
+ * A Cloudflare Workers Version Metadata binding.
+ *
+ * Cloudflare provides the deployed Worker version at runtime (`id`, `tag`,
+ * `timestamp`).
+ *
+ * @binding
+ *
+ * @section Effect-style Worker (recommended)
+ * @example Read the deployed version from inside a handler
+ * ```typescript
+ * import * as Effect from "effect/Effect";
+ *
+ * Cloudflare.Worker(
+ *   "VersionWorker",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     // Attaches the binding to this Worker AND returns a deferred accessor.
+ *     const versionMetadata = yield* Cloudflare.VersionMetadata();
+ *
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const { id, tag, timestamp } = yield* versionMetadata;
+ *         return Response.json({ id, tag, timestamp });
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Cloudflare.VersionMetadataBindingLive)),
+ * );
+ * ```
+ *
+ * @section Worker binding metadata
+ * @example
+ * ```typescript
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   env: {
+ *     CF_VERSION_METADATA: Cloudflare.VersionMetadata(),
+ *   },
+ * });
+ *
+ * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
+ * //   { CF_VERSION_METADATA: WorkerVersionMetadata }
+ * ```
+ *
+ * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/
+ */
+export const VersionMetadata: {
+  (props?: VersionMetadataProps): VersionMetadata;
+  /**
+   * Bind an existing `VersionMetadata` marker to the surrounding Worker,
+   * returning the deferred accessor. Equivalent to `yield* versionMetadata` —
+   * prefer yielding the marker directly.
+   */
+  bind: typeof VersionMetadataBinding.bind;
+} = Object.assign(
+  (props?: VersionMetadataProps): VersionMetadata => {
+    const self: VersionMetadata = {
+      kind: VersionMetadataTypeId,
+      name: props?.name ?? "CF_VERSION_METADATA",
+      asEffect: () => VersionMetadataBinding.bind(self),
+      [Symbol.iterator]: () =>
+        new SingleShotGen(VersionMetadataBinding.bind(self)),
+    };
+    return self;
+  },
+  {
+    bind: (...args: Parameters<typeof VersionMetadataBinding.bind>) =>
+      VersionMetadataBinding.bind(...args),
+  },
+);

package/src/Cloudflare/Workers/VersionMetadataBinding.ts

@@ -0,0 +1,82 @@
+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 type { VersionMetadata as VersionMetadataLike } from "./VersionMetadata.ts";
+import { isWorker, WorkerEnvironment } from "./Worker.ts";
+
+/**
+ * Runtime value Cloudflare exposes for a `version_metadata` binding — the
+ * deployed Worker version's `id`, `tag`, and `timestamp`.
+ */
+export interface WorkerVersionMetadata {
+  readonly id: string;
+  readonly tag: string;
+  readonly timestamp: string;
+}
+
+/**
+ * Effect-native accessor for a Cloudflare Workers Version Metadata binding.
+ *
+ * The Worker env binding only exists at the *exec* phase on the deployed
+ * Worker, so reading it is deferred behind an Effect that requires
+ * {@link WorkerEnvironment}. Yield it inside a handler to obtain the
+ * {@link WorkerVersionMetadata}.
+ */
+export type VersionMetadataAccessor = Effect.Effect<
+  WorkerVersionMetadata,
+  never,
+  WorkerEnvironment
+>;
+
+export class VersionMetadataBinding extends Binding.Service<
+  VersionMetadataBinding,
+  (
+    versionMetadata: VersionMetadataLike,
+  ) => Effect.Effect<VersionMetadataAccessor>
+>()("Cloudflare.VersionMetadata") {}
+
+export const VersionMetadataBindingLive = Layer.effect(
+  VersionMetadataBinding,
+  Effect.gen(function* () {
+    const Policy = yield* VersionMetadataBindingPolicy;
+
+    return Effect.fn(function* (versionMetadata: VersionMetadataLike) {
+      yield* Policy(versionMetadata);
+      return WorkerEnvironment.useSync(
+        (env) =>
+          (env as Record<string, WorkerVersionMetadata>)[versionMetadata.name]!,
+      );
+    });
+  }),
+);
+
+export class VersionMetadataBindingPolicy extends Binding.Policy<
+  VersionMetadataBindingPolicy,
+  (versionMetadata: VersionMetadataLike) => Effect.Effect<void>
+>()("Cloudflare.VersionMetadata") {}
+
+export const VersionMetadataBindingPolicyLive =
+  VersionMetadataBindingPolicy.layer.succeed(
+    Effect.fn(function* (
+      host: ResourceLike,
+      versionMetadata: VersionMetadataLike,
+    ) {
+      if (isWorker(host)) {
+        yield* host.bind(versionMetadata.name, {
+          bindings: [
+            {
+              type: "version_metadata",
+              name: versionMetadata.name,
+            },
+          ],
+        });
+      } else {
+        return yield* Effect.die(
+          new Error(
+            `VersionMetadataBinding does not support runtime '${host.Type}'`,
+          ),
+        );
+      }
+    }),
+  );