alchemy 2.0.0-beta.23 → 2.0.0-beta.25

package/src/Cloudflare/Workers/Worker.ts

@@ -22,6 +22,7 @@ import { pathToFileURL } from "node:url";
 import type * as rolldown from "rolldown";
 import Sonda from "sonda/rolldown";
 import type * as vite from "vite";
+import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
 import {
@@ -53,6 +54,7 @@ import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { D1Database } from "../D1/D1Database.ts";
 import { fromCloudflareFetcher } from "../Fetcher.ts";
 import type { KVNamespace } from "../KV/KVNamespace.ts";
+import { SidecarLive } from "../Local/Sidecar.ts";
 import { CloudflareLogs } from "../Logs.ts";
 import type { Providers } from "../Providers.ts";
 import type { Queue as CloudflareQueue } from "../Queue/Queue.ts";
@@ -72,6 +74,7 @@ import {
   type DurableObjectNamespaceLike,
 } from "./DurableObjectNamespace.ts";
 import { workersHttpHandler } from "./HttpServer.ts";
+import { LocalWorkerProvider } from "./LocalWorkerProvider.ts";
 import { Request } from "./Request.ts";
 import { makeRpcStub } from "./Rpc.ts";
 import { isWorkflowExport } from "./Workflow.ts";
@@ -966,7 +969,30 @@ function getDurableObjectTagMap(tags: ReadonlyArray<string>) {
   );
 }
 
+const selectLayer = <
+  LayerLive extends Layer.Layer<any, any, any>,
+  LayerDev extends Layer.Layer<any, any, any>,
+>(input: {
+  live: () => LayerLive;
+  dev: () => LayerDev;
+}): Layer.Layer<
+  Layer.Success<LayerLive | LayerDev>,
+  Layer.Error<LayerLive | LayerDev>,
+  Layer.Services<LayerLive | LayerDev> | AlchemyContext
+> =>
+  Layer.unwrap(
+    AlchemyContext.useSync((context) =>
+      context.dev ? input.dev() : input.live(),
+    ),
+  );
+
 export const WorkerProvider = () =>
+  selectLayer({
+    live: LiveWorkerProvider,
+    dev: () => Layer.provide(LocalWorkerProvider(), SidecarLive),
+  });
+
+export const LiveWorkerProvider = () =>
   Provider.effect(
     Worker,
     Effect.gen(function* () {
@@ -1078,11 +1104,44 @@ export const WorkerProvider = () =>
       const reconcileDomains = (
         scriptName: string,
         desired: string[],
-        previous: Worker["Attributes"]["domains"],
+        _previous: Worker["Attributes"]["domains"],
       ) =>
         Effect.gen(function* () {
+          // Always query the live state of domains attached to *this*
+          // Worker rather than trusting `_previous` from local state.
+          // State may have been wiped, populated by another machine, or
+          // simply be out of date. Without this we PUT domains that are
+          // already registered to this same Worker and Cloudflare
+          // returns a confusing "hostname already in use" error.
+          const liveAll = yield* listDomains({
+            accountId,
+            service: scriptName,
+          }).pipe(
+            Effect.map((r) =>
+              (r.result ?? []).flatMap((d) =>
+                d.id && d.hostname && d.zoneId
+                  ? [
+                      {
+                        id: d.id,
+                        hostname: d.hostname,
+                        zoneId: d.zoneId,
+                        service: d.service ?? undefined,
+                      },
+                    ]
+                  : [],
+              ),
+            ),
+            Effect.catch(() => Effect.succeed([])),
+          );
+
           const desiredSet = new Set(desired);
-          const toRemove = previous.filter((p) => !desiredSet.has(p.hostname));
+          const liveByHostname = new Map(liveAll.map((d) => [d.hostname, d]));
+
+          // Detach what's no longer wanted. Use the live list so we
+          // don't try to delete domains we no longer track.
+          const toRemove = liveAll.filter(
+            (d) => !desiredSet.has(d.hostname),
+          );
           yield* Effect.all(
             toRemove.map((d) =>
               deleteDomain({ accountId, domainId: d.id }).pipe(
@@ -1095,26 +1154,62 @@ export const WorkerProvider = () =>
           if (desired.length === 0) return [];
 
           const zoneCache = new Map<string, string>();
+
+          // Attach `hostname` to this Worker. Skip the PUT entirely if
+          // the hostname is already attached to *this* Worker — that's a
+          // no-op for Cloudflare and avoids the "already in use" 409.
+          // If it's attached to a *different* Worker, refuse with a
+          // clear message rather than silently re-routing traffic.
+          const attachDomain = Effect.fnUntraced(function* (hostname: string) {
+            const live = liveByHostname.get(hostname);
+            if (live) {
+              return {
+                hostname: live.hostname,
+                id: live.id,
+                zoneId: live.zoneId,
+              };
+            }
+
+            // Not attached to this Worker — but it could still belong
+            // to another Worker. Check before we try to PUT so we can
+            // emit a helpful error instead of the raw 409.
+            const otherOwner = yield* listDomains({
+              accountId,
+              hostname,
+            }).pipe(
+              Effect.map((r) =>
+                (r.result ?? []).find(
+                  (d) => d.hostname === hostname && d.service !== scriptName,
+                ),
+              ),
+              Effect.catch(() => Effect.succeed(undefined)),
+            );
+            if (otherOwner?.id) {
+              return yield* Effect.die(
+                new Error(
+                  `Cannot attach hostname '${hostname}' to Worker '${scriptName}': ` +
+                    `it is already attached to Worker '${otherOwner.service ?? "<unknown>"}'. ` +
+                    `Detach it from that Worker first, or pick a different hostname.`,
+                ),
+              );
+            }
+
+            const zoneId = yield* inferZoneIdForHostname(hostname, zoneCache);
+            const res = yield* putDomain({
+              accountId,
+              hostname,
+              service: scriptName,
+              zoneId,
+            });
+            return {
+              hostname,
+              id: res.id ?? "",
+              zoneId: res.zoneId ?? zoneId,
+            };
+          });
+
           const applied = yield* Effect.all(
-            desired.map((hostname) =>
-              Effect.gen(function* () {
-                const zoneId = yield* inferZoneIdForHostname(
-                  hostname,
-                  zoneCache,
-                );
-                const res = yield* putDomain({
-                  accountId,
-                  hostname,
-                  service: scriptName,
-                  zoneId,
-                });
-                return {
-                  hostname,
-                  id: res.id ?? "",
-                  zoneId: res.zoneId ?? zoneId,
-                };
-              }),
-            ),
+            desired.map(attachDomain),
             { concurrency: "unbounded" },
           );
           return applied;
@@ -1205,21 +1300,15 @@ export const WorkerProvider = () =>
           return undefined;
         }
 
-        // Handle AssetsWithHash (from Build resource)
-        // Props are resolved by Plan, so Input<string> values are already strings at runtime
         if (
           typeof assets === "object" &&
           "path" in assets &&
           "hash" in assets
         ) {
-          const result = yield* readAssets({
+          return yield* readAssets({
             directory: assets.path as string,
             config: assets.config,
           });
-          return {
-            ...result,
-            hash: assets.hash as string,
-          };
         }
 
         // Handle string path or AssetsProps
@@ -1547,31 +1636,30 @@ ${[
         let metadataAssets:
           | workers.PutScriptRequest["metadata"]["assets"]
           | undefined;
-        let keepAssets = false;
+        const keepAssets = false;
         if (assets) {
-          if (output?.hash?.assets !== assets.hash) {
-            yield* Effect.logInfo(
-              `Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`,
-            );
-            const { jwt } = yield* uploadAssets(
-              accountId,
-              name,
-              assets,
-              session,
-            );
-            metadataAssets = {
-              jwt,
-              config: assets.config,
-            };
-          } else {
-            yield* Effect.logInfo(
-              `Cloudflare Worker update: reusing existing assets for ${name}`,
-            );
-            metadataAssets = {
-              config: assets.config,
-            };
-            keepAssets = true;
-          }
+          // Always upload assets on every deploy. The "skip if hash
+          // unchanged" optimization was the source of subtle bundle/
+          // asset desync bugs (deploy succeeds but worker serves 404s
+          // because the bundle references hashed asset filenames that
+          // aren't in the still-on-Cloudflare manifest). The upload
+          // session is content-addressed on Cloudflare's side — only
+          // genuinely-new asset bytes are PUT; unchanged assets cost
+          // a manifest check and nothing else, so the optimization
+          // wasn't worth the failure mode.
+          yield* Effect.logInfo(
+            `Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`,
+          );
+          const { jwt } = yield* uploadAssets(
+            accountId,
+            name,
+            assets,
+            session,
+          );
+          metadataAssets = {
+            jwt,
+            config: assets.config,
+          };
           metadataBindings.push({
             type: "assets",
             name: "ASSETS",
@@ -1868,11 +1956,19 @@ ${[
           const input = yield* hashDirectory(props.vite);
           return input !== output.hash?.input;
         }
+        // Always recompute both hashes by walking `dist/` (assets) and
+        // re-bundling the worker. The previous short-circuit
+        // (`Effect.succeed(output.hash.assets)`) compared the cached
+        // hash to itself and could never detect drift, and the
+        // `props.assets.hash` form is the *input* (source) hash which
+        // misses non-deterministic build output (e.g. Astro/Vite
+        // shuffling content-hashed filenames between builds). The
+        // result of either shortcut was deploying a new bundle on top
+        // of stale assets and 404'ing in production. Re-walking is the
+        // only correct comparison.
         const [assetsHash, bundleHash] = yield* Effect.all(
           [
-            "assets" in output && output.hash?.assets
-              ? Effect.succeed(output.hash.assets)
-              : prepareAssets(props.assets).pipe(Effect.map((a) => a?.hash)),
+            prepareAssets(props.assets).pipe(Effect.map((a) => a?.hash)),
             prepareBundle(id, props).pipe(Effect.map((b) => b.hash)),
           ],
           { concurrency: "unbounded" },

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -0,0 +1,234 @@
+import cloudflareRolldown from "@distilled.cloud/cloudflare-rolldown-plugin";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import { flow } from "effect/Function";
+import type * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
+import type * as rolldown from "rolldown";
+import * as Artifacts from "../../Artifacts.ts";
+import * as Bundle from "../../Bundle/Bundle.ts";
+import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
+import { Self } from "../../Self.ts";
+import {
+  isDurableObjectExport,
+  type DurableObjectExport,
+} from "./DurableObjectNamespace.ts";
+import { isWorkflowExport, type WorkflowExport } from "./Workflow.ts";
+
+export interface WorkerBundleOptions {
+  id: string;
+  main: string;
+  compatibility: {
+    date: string;
+    flags: string[];
+  };
+  entry:
+    | {
+        kind: "external";
+      }
+    | {
+        kind: "effect";
+        exports: Record<string, DurableObjectExport | WorkflowExport>;
+      };
+  stack: { name: string; stage: string };
+}
+
+export const WorkerBundle = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const context = yield* Effect.context<FileSystem.FileSystem | Path.Path>();
+  const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
+
+  const makeOptions = Effect.fnUntraced(function* (
+    options: WorkerBundleOptions,
+  ) {
+    const realMain = yield* fs.realPath(options.main).pipe(
+      Effect.mapError(
+        (cause) =>
+          new Bundle.BundleError({
+            message: `Failed to find real path for bundle: ${options.main}`,
+            cause,
+          }),
+      ),
+    );
+    const inputOptions: rolldown.InputOptions = {
+      input: realMain,
+      cwd: yield* findCwdForBundle(realMain).pipe(
+        Effect.mapError(
+          (cause) =>
+            new Bundle.BundleError({
+              message: `Failed to find cwd for bundle: ${realMain}`,
+              cause,
+            }),
+        ),
+        Effect.provide(context),
+      ),
+      plugins: [
+        cloudflareRolldown({
+          compatibilityDate: options.compatibility.date,
+          compatibilityFlags: options.compatibility.flags,
+        }),
+        options.entry.kind === "effect"
+          ? virtualEntryPlugin(
+              makeEffectVirtualEntry(options.entry.exports, options.stack),
+            )
+          : undefined,
+      ],
+      checks: {
+        // Suppress unresolved import warnings for unrelated AWS packages
+        unresolvedImport: false,
+      },
+    };
+    const outputOptions: rolldown.OutputOptions = {
+      format: "esm",
+      sourcemap: "hidden",
+      minify: true,
+      keepNames: true,
+      dir: `.alchemy/bundles/${options.id}`,
+    };
+    return { inputOptions, outputOptions };
+  });
+
+  return {
+    build: flow(
+      makeOptions,
+      Effect.flatMap((resolved) =>
+        Bundle.build(resolved.inputOptions, resolved.outputOptions),
+      ),
+      Artifacts.cached("build"),
+    ),
+    watch: flow(
+      makeOptions,
+      Stream.fromEffect,
+      Stream.flatMap((resolved) =>
+        Bundle.watch(resolved.inputOptions, resolved.outputOptions),
+      ),
+    ),
+  };
+});
+
+const makeEffectVirtualEntry = (
+  exports: Record<string, DurableObjectExport | WorkflowExport>,
+  stack: { name: string; stage: string },
+) => {
+  const durableObjectClasses: string[] = [];
+  const workflowClasses: string[] = [];
+  for (const [className, entry] of Object.entries(exports)) {
+    if (isDurableObjectExport(entry)) {
+      durableObjectClasses.push(className);
+    } else if (isWorkflowExport(entry)) {
+      workflowClasses.push(className);
+    }
+  }
+  return (importPath: string) => `import * as Config from "effect/Config";
+  import * as ConfigProvider from "effect/ConfigProvider";
+  import * as Console from "effect/Console";
+  import * as Effect from "effect/Effect";
+  import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+  import * as Layer from "effect/Layer";
+  import * as Logger from "effect/Logger";
+  import * as Context from "effect/Context";
+  import * as Stream from "effect/Stream";
+  
+  import { env, DurableObject${workflowClasses.length > 0 ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
+  import { MinimumLogLevel } from "effect/References";
+  import { NodeServices } from "@effect/platform-node";
+  import { Stack } from "alchemy/Stack";
+  import { WorkerEnvironment, makeDurableObjectBridge${workflowClasses.length > 0 ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
+  
+  import entry 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 platform = Layer.mergeAll(
+  NodeServices.layer,
+  FetchHttpClient.layer,
+  // TODO(sam): wire this up to telemetry more directly
+  Logger.layer([Logger.consolePretty()]),
+  );
+  
+  const stack = Layer.succeed(
+  Stack,
+  {
+  name: "${stack.name}",
+  stage: "${stack.stage}",
+  bindings: {},
+  resources: {}
+  }
+  );
+  
+  const exportsEffect = tag.asEffect().pipe(
+  Effect.flatMap(func => func.ExecutionContext.exports),
+  Effect.map(exports => exports),
+  Effect.provide(
+  layer.pipe(
+  Layer.provideMerge(stack),
+  // TODO(sam): additional credentials?
+  Layer.provideMerge(platform),
+  Layer.provideMerge(
+  Layer.succeed(
+    ConfigProvider.ConfigProvider,
+    ConfigProvider.orElse(
+      ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
+      ConfigProvider.fromUnknown(env),
+    ),
+  )
+  ),
+  Layer.provideMerge(
+  Layer.succeed(
+    WorkerEnvironment,
+    env,
+  )
+  ),
+  Layer.provideMerge(
+  Layer.succeed(
+    MinimumLogLevel,
+    env.DEBUG ? "Debug" : "Info",
+  )
+  ),
+  )
+  ),
+  Effect.scoped
+  );
+  
+  // TODO(sam): we could kick this off during module init, but any I/O will break deploy
+  // let exportsPromise = Effect.runPromise(exportsEffect);
+  
+  // for now, we delay initializing the worker until the first request
+  let exportsPromise;
+  
+  // don't initialize the workerEffect during module init because Cloudflare does not allow I/O during module init
+  // we cache it synchronously (??=) to guarnatee only one initialization ever happens
+  const getExports = () => (exportsPromise ??= Effect.runPromise(exportsEffect))
+  const getExport = (name) => getExports().then(exports => exports[name]?.make)
+  const worker = () => getExports().then(exports => exports.default)
+  
+  export default Object.fromEntries(ExportedHandlerMethods.map(
+  method => [method, async (...args) => (await worker())[method](...args)])
+  ) satisfies Required<cf.ExportedHandler>;
+  
+  // export class proxy stubs for Durable Objects and Workflows
+  ${[
+    ...(durableObjectClasses.length > 0
+      ? [
+          "const DurableObjectBridge = makeDurableObjectBridge(DurableObject, getExport);",
+          ...durableObjectClasses.map(
+            (id) =>
+              `export class ${id} extends DurableObjectBridge("${id}") {}`,
+          ),
+        ]
+      : []),
+    ...(workflowClasses.length > 0
+      ? [
+          "const WorkflowBridgeFn = makeWorkflowBridge(WorkflowEntrypoint, getExport);",
+          ...workflowClasses.map(
+            (id) => `export class ${id} extends WorkflowBridgeFn("${id}") {}`,
+          ),
+        ]
+      : []),
+  ].join("\n")}
+  `;
+};

package/src/Cloudflare/Workers/WorkerName.ts

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import { createPhysicalName } from "../../PhysicalName.ts";
+
+export const createWorkerName = (id: string, name: string | undefined) =>
+  name
+    ? Effect.succeed(name)
+    : createPhysicalName({
+        id,
+        maxLength: 54,
+      }).pipe(Effect.map((name) => name.toLowerCase()));

package/src/Cloudflare/Workers/index.ts

@@ -7,6 +7,7 @@ export * from "./DynamicWorkerLoader.ts";
 export * from "./Fetch.ts";
 export * from "./HttpServer.ts";
 export * from "./InferEnv.ts";
+export * from "./LocalWorkerProvider.ts";
 export * from "./Request.ts";
 export * from "./Rpc.ts";
 export * from "./ScheduledEvents.ts";

package/src/Platform.ts

@@ -180,7 +180,7 @@ export const Platform = <
     string,
     | {
         env?: Record<string, any>;
-        exports?: string[];
+        exports?: string[] | Record<string, any>;
       }
     | undefined
   >,