alchemy 2.0.0-beta.44 → 2.0.0-beta.45

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -1,13 +1,24 @@
+import type { PutScriptRequest } from "@distilled.cloud/cloudflare/workers";
+import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import type { InputProps } from "../../Input.ts";
 import * as Output from "../../Output.ts";
 import type { ResourceBinding } from "../../Resource.ts";
 import { isYieldableEffectLike } from "../../Util/effect.ts";
+import { asEffect } from "../../Util/types.ts";
+import { isAiGateway } from "../AiGateway/AiGateway.ts";
 import { isAnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
 import { isArtifacts } from "../Artifacts/Artifacts.ts";
+import { isBrowserRendering } from "../BrowserRendering/BrowserRendering.ts";
+import { isD1Database } from "../D1/D1Database.ts";
 import { isSendEmail } from "../Email/SendEmail.ts";
+import { isHyperdrive } from "../Hyperdrive/Hyperdrive.ts";
+import { getHyperdriveDevOrigin } from "../Hyperdrive/HyperdriveBinding.ts";
 import { isImages } from "../Images/Images.ts";
+import { isKVNamespace } from "../KV/KVNamespace.ts";
+import { isQueue } from "../Queue/Queue.ts";
+import { isR2Bucket } from "../R2/R2Bucket.ts";
 import { isAssets } from "./Assets.ts";
 import { isDurableObjectNamespaceLike } from "./DurableObjectNamespace.ts";
 import type { WorkerBindingProps } from "./Worker.ts";
@@ -18,10 +29,10 @@ export const bindWorkerAsyncBindings = Effect.fnUntraced(function* (
   resource: Worker,
   props: InputProps<WorkerProps<WorkerBindingProps>>,
 ) {
-  if (props.bindings) {
-    for (const bindingName in props.bindings) {
+  if (props.env) {
+    for (const bindingName in props.env) {
       // @ts-expect-error
-      const bindingEff = props.bindings?.[bindingName] as
+      const bindingEff = props.env?.[bindingName] as
         | WorkerBindingResource
         | Effect.Effect<WorkerBindingResource>;
       // Bindings can be passed as a plain resource value, an Effect that
@@ -32,110 +43,14 @@ export const bindWorkerAsyncBindings = Effect.fnUntraced(function* (
         : bindingEff;
 
       const bindingMeta: InputProps<WorkerBinding> | undefined =
-        typeof binding === "string"
-          ? {
-              type: "plain_text",
-              name: bindingName,
-              value: binding,
-            }
-          : Redacted.isRedacted(binding)
-            ? {
-                type: "secret_text",
-                name: bindingName,
-                value: Redacted.value(binding),
-              }
-            : isAssets(binding)
-              ? {
-                  type: "assets",
-                  name: bindingName,
-                }
-              : isArtifacts(binding)
-                ? ({
-                    type: "artifacts",
-                    name: bindingName,
-                    namespace: binding.namespace,
-                  } as any)
-                : isImages(binding)
-                  ? {
-                      type: "images",
-                      name: bindingName,
-                    }
-                  : isAnalyticsEngineDataset(binding)
-                    ? {
-                        type: "analytics_engine",
-                        name: bindingName,
-                        dataset: binding.dataset,
-                      }
-                    : isSendEmail(binding)
-                      ? {
-                          type: "send_email",
-                          name: bindingName,
-                          destinationAddress: binding.destinationAddress,
-                          allowedDestinationAddresses:
-                            binding.allowedDestinationAddresses,
-                          allowedSenderAddresses:
-                            binding.allowedSenderAddresses,
-                        }
-                      : isDurableObjectNamespaceLike(binding)
-                        ? {
-                            type: "durable_object_namespace",
-                            name: bindingName,
-                            className: binding.className ?? binding.name,
-                          }
-                        : binding.Type === "Cloudflare.D1Database"
-                          ? {
-                              type: "d1",
-                              id: binding.databaseId,
-                              name: bindingName,
-                            }
-                          : binding.Type === "Cloudflare.R2Bucket"
-                            ? {
-                                type: "r2_bucket",
-                                name: bindingName,
-                                bucketName: binding.bucketName,
-                                jurisdiction: binding.jurisdiction.pipe(
-                                  Output.map((jurisdiction) =>
-                                    jurisdiction === "default"
-                                      ? undefined
-                                      : jurisdiction,
-                                  ),
-                                ),
-                              }
-                            : binding.Type === "Cloudflare.KVNamespace"
-                              ? {
-                                  type: "kv_namespace",
-                                  name: bindingName,
-                                  namespaceId: binding.namespaceId,
-                                }
-                              : binding.Type === "Cloudflare.Queue"
-                                ? {
-                                    type: "queue",
-                                    name: bindingName,
-                                    queueName: binding.queueName,
-                                  }
-                                : binding.Type === "Cloudflare.AiGateway"
-                                  ? {
-                                      type: "ai",
-                                      name: bindingName,
-                                    }
-                                  : binding.Type === "Cloudflare.Hyperdrive"
-                                    ? {
-                                        type: "hyperdrive",
-                                        name: bindingName,
-                                        id: binding.hyperdriveId,
-                                      }
-                                    : isWorker(binding)
-                                      ? {
-                                          type: "service",
-                                          name: bindingName,
-                                          service: binding.workerName,
-                                        }
-                                      : // TODO(sam): handle others
-                                        undefined;
+        yield* asEffect(toBinding(bindingName, binding));
 
       if (bindingMeta) {
         yield* resource.bind`${bindingName}`({
           bindings: [bindingMeta],
+          hyperdrives: isHyperdrive(binding)
+            ? getHyperdriveDevOrigin(binding)
+            : undefined,
         });
       } else {
         return yield* Effect.die(`Unknown binding type: ${bindingName}`);
@@ -144,6 +59,146 @@ export const bindWorkerAsyncBindings = Effect.fnUntraced(function* (
   }
 });
 
+type BindingSpec = InputProps<
+  Exclude<PutScriptRequest["metadata"]["bindings"], undefined>[number]
+>;
+
+const toBinding = (
+  bindingName: string,
+  binding: WorkerBindingResource,
+): BindingSpec | Effect.Effect<BindingSpec> | undefined => {
+  // narrowing to Config<unknown> doesn't work for us, we need any
+  const isConfig: (a: any) => a is Config.Config<any> = Config.isConfig;
+  // narrowing to Redacted<unknown> doesn't work for us, we need any
+  const isRedacted: (a: any) => a is Redacted.Redacted<any> =
+    Redacted.isRedacted;
+
+  if (typeof binding === "string") {
+    return {
+      type: "plain_text",
+      name: bindingName,
+      text: binding,
+    };
+  } else if (isRedacted(binding)) {
+    const val = Redacted.value(binding);
+    if (typeof val === "string") {
+      return {
+        type: "secret_text",
+        name: bindingName,
+        text: val,
+      };
+    } else {
+      return {
+        type: "secret_text",
+        name: bindingName,
+        text: JSON.stringify(val),
+      };
+    }
+  } else if (isConfig(binding)) {
+    return binding.pipe(
+      Effect.flatMap((json) => {
+        const b = toBinding(bindingName, json)!;
+        return Effect.isEffect(b) ? b : Effect.succeed(b);
+      }),
+      Effect.orDie,
+    );
+  } else if (isAssets(binding)) {
+    return {
+      type: "assets",
+      name: bindingName,
+    };
+  } else if (isArtifacts(binding)) {
+    return {
+      type: "artifacts",
+      name: bindingName,
+      namespace: binding.namespace,
+    };
+  } else if (isImages(binding)) {
+    return {
+      type: "images",
+      name: bindingName,
+    };
+  } else if (isBrowserRendering(binding)) {
+    return {
+      type: "browser",
+      name: bindingName,
+    };
+  } else if (isAnalyticsEngineDataset(binding)) {
+    return {
+      type: "analytics_engine",
+      name: bindingName,
+      dataset: binding.dataset,
+    };
+  } else if (isSendEmail(binding)) {
+    return {
+      type: "send_email",
+      name: bindingName,
+      destinationAddress: binding.destinationAddress,
+      allowedDestinationAddresses: binding.allowedDestinationAddresses,
+      allowedSenderAddresses: binding.allowedSenderAddresses,
+    };
+  } else if (isDurableObjectNamespaceLike(binding)) {
+    return {
+      type: "durable_object_namespace",
+      name: bindingName,
+      className: binding.className ?? binding.name,
+      scriptName: binding.scriptName,
+    };
+  } else if (isD1Database(binding)) {
+    return {
+      type: "d1",
+      databaseId: binding.databaseId,
+      name: bindingName,
+    };
+  } else if (isR2Bucket(binding)) {
+    return {
+      type: "r2_bucket",
+      name: bindingName,
+      bucketName: binding.bucketName,
+      jurisdiction: binding.jurisdiction.pipe(
+        Output.map((jurisdiction) =>
+          jurisdiction === "default" ? undefined : jurisdiction,
+        ),
+      ),
+    };
+  } else if (isKVNamespace(binding)) {
+    return {
+      type: "kv_namespace",
+      name: bindingName,
+      namespaceId: binding.namespaceId,
+    };
+  } else if (isQueue(binding)) {
+    return {
+      type: "queue",
+      name: bindingName,
+      queueName: binding.queueName,
+    };
+  } else if (isAiGateway(binding)) {
+    return {
+      type: "ai",
+      name: bindingName,
+    };
+  } else if (isHyperdrive(binding)) {
+    return {
+      type: "hyperdrive",
+      name: bindingName,
+      id: binding.hyperdriveId,
+    };
+  } else if (isWorker(binding)) {
+    return {
+      type: "service",
+      name: bindingName,
+      service: binding.workerName,
+    };
+  } else {
+    return {
+      type: "json",
+      name: bindingName,
+      json: binding,
+    };
+  }
+};
+
 export const getCronBindings = (
   bindings: ReadonlyArray<ResourceBinding<Worker["Binding"]>>,
 ) => Array.from(new Set(bindings.flatMap((b) => b.data.crons ?? [])));

package/src/Cloudflare/Workers/WorkerBinding.ts

@@ -1,11 +1,15 @@
 import type * as workers from "@distilled.cloud/cloudflare/workers";
+import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import type { Json } from "effect/Schema";
 import * as Binding from "../../Binding.ts";
 import type { Rpc } from "../../Rpc.ts";
 import { isYieldableEffectLike } from "../../Util/effect.ts";
 import type { AiGateway } from "../AiGateway/AiGateway.ts";
 import { AnalyticsEngineDataset } from "../AnalyticsEngine/AnalyticsEngineDataset.ts";
 import { Artifacts } from "../Artifacts/Artifacts.ts";
+import { BrowserRendering } from "../BrowserRendering/BrowserRendering.ts";
 import type { D1Database } from "../D1/D1Database.ts";
 import { SendEmail } from "../Email/SendEmail.ts";
 import { Hyperdrive } from "../Hyperdrive/Hyperdrive.ts";
@@ -29,6 +33,11 @@ export type WorkerSettingsBinding = Exclude<
 >[number];
 
 export type WorkerBindingResource =
+  // Config values
+  | Json
+  | Redacted.Redacted<Json>
+  | Config.Config<Json>
+  // CF resources
   | Assets
   | R2Bucket
   | D1Database
@@ -38,6 +47,7 @@ export type WorkerBindingResource =
   | AnalyticsEngineDataset
   | SendEmail
   | Artifacts
+  | BrowserRendering
   | Images
   | Hyperdrive
   | Worker

package/src/Cloudflare/Workers/WorkerBridge.ts

@@ -17,6 +17,8 @@ import { ExecutionContext } from "../../ExecutionContext.ts";
 import { makeEntrypointLayer } from "../../Runtime.ts";
 import { Self } from "../../Self.ts";
 import { Stack } from "../../Stack.ts";
+import cloudflare_workers from "./cloudflare_workers.ts";
+import { isScopeEjected } from "./HttpServer.ts";
 import {
   ErrorTag,
   type RpcErrorEnvelope,
@@ -31,7 +33,6 @@ import {
   WorkerExecutionContext,
 } from "./Worker.ts";
 import type { WorkerRuntimeContext } from "./WorkerRuntimeContext.ts";
-import cloudflare_workers from "./cloudflare_workers.ts";
 
 /**
  * Makes the WorkerEntrypoint class and bridges to Effect fetch and RPC calls.
@@ -88,9 +89,11 @@ export const makeWorkerBridge = (
         Effect.runPromiseExit,
       )
       .finally(() =>
-        Scope.close(scope, Exit.void).pipe(Effect.runPromise, (promise) =>
-          ctx.waitUntil(promise),
-        ),
+        isScopeEjected(scope)
+          ? undefined
+          : Scope.close(scope, Exit.void).pipe(Effect.runPromise, (promise) =>
+              ctx.waitUntil(promise),
+            ),
       );
   };
   class WorkerBridge extends Base {

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -5,6 +5,7 @@ import { flow } from "effect/Function";
 import type * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
 import { fileURLToPath } from "node:url";
+import path from "pathe";
 import type * as rolldown from "rolldown";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
@@ -98,7 +99,9 @@ export const WorkerBundle = Effect.gen(function* () {
         return main;
       }
     }).pipe(
-      Effect.flatMap((path) => fs.realPath(path)),
+      Effect.flatMap((p) => fs.realPath(p)),
+      //* fix windows paths
+      Effect.map((p) => path.resolve(p)),
       Effect.mapError(
         (cause) =>
           new Bundle.BundleError({

package/src/Cloudflare/Workers/WorkerRuntimeContext.ts

@@ -33,17 +33,12 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
     get: (key: string) =>
       Effect.serviceOption(WorkerEnvironment).pipe(
         Effect.map(Option.getOrUndefined),
-        Effect.flatMap((env) =>
-          env
-            ? Effect.succeed(env[key])
-            : Effect.die("WorkerEnvironment not found"),
-        ),
-        Effect.flatMap((value) =>
-          value
-            ? Effect.succeed(value)
-            : Effect.die(`Environment variable '${key}' not found`),
-        ),
+        // Key is already canonical (see RuntimeContext.sanitizeKey).
+        Effect.map((env) => env?.[key]),
         Effect.map((json) => {
+          if (json === undefined) {
+            return undefined;
+          }
           try {
             const value = JSON.parse(json);
             // The `set` path serializes Redacted values as
@@ -53,10 +48,9 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
             // and rebuild the Redacted wrapper. Plain values pass
             // through unchanged.
             if (
-              value !== null &&
               typeof value === "object" &&
-              (value as { _tag?: unknown })._tag === "Redacted" &&
-              "value" in (value as object)
+              value?._tag === "Redacted" &&
+              "value" in value
             ) {
               return Redacted.make((value as { value: unknown }).value);
             }
@@ -66,9 +60,8 @@ export const makeWorkerRuntimeContext = (id: string): WorkerRuntimeContext => {
           }
         }),
       ) as any,
-    set: (id: string, output: Output.Output) =>
+    set: (key: string, output: Output.Output) =>
       Effect.sync(() => {
-        const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
         // Preserve `Redacted`-ness across the Output → env → Cloudflare
         // binding boundary so the put-worker loop can deploy secrets via
         // `secret_text` instead of leaking them as `plain_text`. The JSON

package/src/Cloudflare/Workers/Workflow.ts

@@ -1,6 +1,8 @@
 import * as workflows from "@distilled.cloud/cloudflare/workflows";
+import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import { AlchemyContext } from "../../AlchemyContext.ts";
 import { ALCHEMY_PHASE } from "../../Phase.ts";
 import type { PlatformServices } from "../../Platform.ts";
 import * as Provider from "../../Provider.ts";
@@ -173,7 +175,7 @@ export interface WorkflowClass extends Effect.Effect<
   <_Self>(): {
     <Input = unknown, Result = unknown, InitReq = never>(
       name: string,
-      impl: Effect.Effect<WorkflowImpl<Input, Result>, never, InitReq>,
+      impl: Effect.Effect<WorkflowImpl<Input, Result>, ConfigError, InitReq>,
     ): Effect.Effect<
       WorkflowHandle<Input, Result>,
       never,
@@ -184,7 +186,7 @@ export interface WorkflowClass extends Effect.Effect<
   };
   <Input = unknown, Result = unknown, InitReq = never>(
     name: string,
-    impl: Effect.Effect<WorkflowImpl<Input, Result>, never, InitReq>,
+    impl: Effect.Effect<WorkflowImpl<Input, Result>, ConfigError, InitReq>,
   ): Effect.Effect<
     WorkflowHandle<Input, Result>,
     never,
@@ -477,17 +479,34 @@ export const WorkflowProvider = () =>
   Provider.effect(
     WorkflowResource,
     Effect.gen(function* () {
+      const ctx = yield* AlchemyContext;
       const { accountId } = yield* CloudflareEnvironment;
       const putWorkflow = yield* workflows.putWorkflow;
       const deleteWorkflow = yield* workflows.deleteWorkflow;
 
       return WorkflowResource.Provider.of({
-        stables: ["workflowId", "accountId"],
+        // The `workflowId` is no longer marked as stable because if you start in dev mode, the ID will change on first deploy.
+        stables: ["accountId"],
+        diff: Effect.fnUntraced(function* ({ output }) {
+          // If the workflowId starts with "dev:", and we're not in dev mode, trigger an update so the workflow is created.
+          if (output?.workflowId.startsWith("dev:") && !ctx.dev) {
+            return { action: "update" };
+          }
+        }),
         reconcile: Effect.fnUntraced(function* ({ news, output }) {
           const acct = output?.accountId ?? accountId;
           yield* Effect.logInfo(
             `Cloudflare Workflow reconcile: ${news.workflowName}`,
           );
+          if (ctx.dev) {
+            return {
+              workflowId: output?.workflowId ?? `dev:${crypto.randomUUID()}`,
+              accountId,
+              workflowName: news.workflowName,
+              className: news.className,
+              scriptName: news.scriptName,
+            };
+          }
           // Cloudflare's `putWorkflow` is a true PUT-as-upsert: identical
           // payloads converge to the same state and a missing workflow is
           // created on the spot. There is no separate observe step needed

package/src/Cloudflare/Workers/index.ts

@@ -12,6 +12,8 @@ export * from "./InferEnv.ts";
 export * from "./LocalWorkerProvider.ts";
 export * from "./Request.ts";
 export * from "./Rpc.ts";
+export * from "./RpcDurableObjectNamespace.ts";
+export * from "./RpcWorker.ts";
 export * from "./ScheduledEvents.ts";
 export * from "./WebSocket.ts";
 export * from "./Worker.ts";

package/src/Cloudflare/index.ts

@@ -2,6 +2,7 @@ export * from "./AiGateway/index.ts";
 export * from "./AnalyticsEngine/index.ts";
 export * from "./ApiToken/index.ts";
 export * from "./Artifacts/index.ts";
+export * from "./BrowserRendering/index.ts";
 export * from "./CloudflareEnvironment.ts";
 export * from "./Container/index.ts";
 export * from "./D1/index.ts";

package/src/Dependencies.ts

@@ -0,0 +1,10 @@
+import type * as Types from "effect/Types";
+
+export interface Dependencies<A> {
+  /**
+   * Contravariant because it's checked as input to a function (E.g. Counter.from(WorkerA))
+   *
+   * @internal phantom type used to tag the dependencies of a resource
+   */
+  "~alchemy/dependencies": Types.Contravariant<A>;
+}

package/src/Deploy.ts

@@ -12,18 +12,20 @@ export const deploy = <A>({
   stage,
   dev,
   scope,
+  force,
 }: {
   stack: StackEffect<CompiledStack<A>, Stage | AlchemyContext>;
   stage: string;
   dev?: boolean;
   /** See {@link evalStack} — when set, scoped resources outlive `deploy`. */
   scope?: Scope.Scope;
+  force?: boolean;
 }) =>
   evalStack(
     stack,
     (stack) =>
       Effect.gen(function* () {
-        const plan = yield* Plan.make(stack);
+        const plan = yield* Plan.make(stack, { force });
         const output = yield* Apply.apply(plan);
         return output as Input.Resolve<A>;
       }),

package/src/Diff.ts

@@ -133,6 +133,19 @@ const canonicalize = (value: unknown, stripNullish: boolean): unknown => {
   return value;
 };
 
+/**
+ * Collapse bindings that share the same `sid`, keeping the last occurrence.
+ *
+ * The same binding can be recorded more than once on a target resource — e.g.
+ * a KV namespace bound to both a Worker and a Workflow ends up pushed twice to
+ * `stack.bindings[fqn]`. `diffBindings` already collapses these implicitly via
+ * its `Map` keyed by `sid`, so the `reconcile` path never observes duplicates.
+ * Use this helper to give a provider's `diff` handler the same de-duplicated
+ * binding set, keeping plan-time hashing consistent with deploy-time.
+ */
+export const dedupeBindings = <B extends ResourceBinding>(bindings: B[]): B[] =>
+  Array.from(new Map(bindings.map((b) => [b.sid, b])).values());
+
 export const diffBindings = (
   oldBindings: ResourceBinding[],
   newBindings: ResourceBinding[],

package/src/Input.ts

@@ -1,3 +1,4 @@
+import type { Config } from "effect/Config";
 import type { Effect } from "effect/Effect";
 import type * as S from "effect/Schema";
 import type { Primitive } from ".//Util/data.ts";
@@ -10,6 +11,7 @@ type PolicyLike = { kind: "alchemy/Policy" };
 export type Input<T> =
   | T
   | Output<T>
+  | Config<T>
   // TODO(sam): extract Requirements in Resource
   | Effect<T, any, any>
   | (T extends S.Schema<any>