alchemy 2.0.0-beta.23 → 2.0.0-beta.24

package/src/Cloudflare/Workers/Worker.ts

@@ -22,6 +22,8 @@ import { pathToFileURL } from "node:url";
 import type * as rolldown from "rolldown";
 import Sonda from "sonda/rolldown";
 import type * as vite from "vite";
+import { AdoptPolicy } from "../../AdoptPolicy.ts";
+import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
 import {
@@ -53,6 +55,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 +75,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 +970,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* () {
@@ -1094,27 +1121,83 @@ export const WorkerProvider = () =>
 
           if (desired.length === 0) return [];
 
+          const adoptEnabled = yield* Effect.serviceOption(AdoptPolicy).pipe(
+            Effect.map(Option.getOrElse(() => false)),
+          );
+
           const zoneCache = new Map<string, string>();
+
+          /**
+           * Attach `hostname` to `scriptName`, recovering from a "hostname
+           * already in use" conflict when adoption is enabled.
+           *
+           * The Cloudflare API rejects a `PUT /workers/domains` whose
+           * hostname is already registered (even when the existing entry
+           * points at the same Worker, which is exactly what happens
+           * after a state-store wipe). The SDK surfaces this as the
+           * unmatched `UnknownCloudflareError` channel because there's
+           * no dedicated error tag for it. With adoption opted-in we
+           * list domains for the hostname; if the existing entry
+           * already targets *this* Worker we adopt it in place. We
+           * never transfer a hostname off another Worker — that would
+           * silently re-route someone else's traffic.
+           */
+          const attachDomain = Effect.fnUntraced(function* (hostname: string) {
+            const zoneId = yield* inferZoneIdForHostname(hostname, zoneCache);
+            return yield* putDomain({
+              accountId,
+              hostname,
+              service: scriptName,
+              zoneId,
+            }).pipe(
+              Effect.map((res) => ({
+                hostname,
+                id: res.id ?? "",
+                zoneId: res.zoneId ?? zoneId,
+              })),
+              Effect.catchTag("UnknownCloudflareError", (err) =>
+                adoptEnabled && /already in use/i.test(err.message)
+                  ? adoptDomainIfSameService(hostname, zoneId, err)
+                  : Effect.fail(err),
+              ),
+            );
+          });
+
+          const adoptDomainIfSameService = Effect.fnUntraced(function* (
+            hostname: string,
+            zoneId: string,
+            originalError: { message: string },
+          ) {
+            const existing = yield* listDomains({
+              accountId,
+              hostname,
+            }).pipe(
+              Effect.map((r) =>
+                (r.result ?? []).find((d) => d.hostname === hostname),
+              ),
+            );
+            if (existing?.id && existing.service === scriptName) {
+              return {
+                hostname,
+                id: existing.id,
+                zoneId: existing.zoneId ?? zoneId,
+              };
+            }
+            // The hostname exists but on a different Worker. Refuse to
+            // hijack it; surface a more actionable message than the raw
+            // Cloudflare error.
+            return yield* Effect.die(
+              new Error(
+                `Cannot attach hostname '${hostname}' to Worker '${scriptName}': ` +
+                  `it is already attached to Worker '${existing?.service ?? "<unknown>"}'. ` +
+                  `Detach it from that Worker first, or pick a different hostname. ` +
+                  `(Cloudflare reported: ${originalError.message})`,
+              ),
+            );
+          });
+
           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;

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
   >,

package/src/Sidecar/Lock.ts

@@ -0,0 +1,190 @@
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schedule from "effect/Schedule";
+import * as Schema from "effect/Schema";
+import type * as Scope from "effect/Scope";
+import * as RpcPaths from "./RpcPaths.ts";
+
+export class LockError extends Schema.TaggedErrorClass<LockError>()(
+  "LockError",
+  {
+    reason: Schema.Literals([
+      "Cancelled",
+      "Conflict",
+      "Invalid",
+      "Timeout",
+      "PlatformError",
+    ]),
+    message: Schema.String,
+    cause: Schema.optional(Schema.DefectWithStack),
+  },
+) {}
+
+export class Lock extends Context.Service<
+  Lock,
+  {
+    readonly check: Effect.Effect<boolean>;
+    readonly acquire: Effect.Effect<
+      Fiber.Fiber<number, LockError>,
+      LockError,
+      Scope.Scope
+    >;
+  }
+>()("Lock") {}
+
+const LOCK_TTL = Duration.seconds(10);
+const TOUCH_INTERVAL = Duration.seconds(1);
+
+const make = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const paths = yield* RpcPaths.RpcPaths;
+
+  const readLockFile = fs.readFileString(paths.lock).pipe(
+    Effect.mapError(
+      (e) =>
+        new LockError({
+          reason: "PlatformError",
+          message:
+            e.reason._tag === "NotFound"
+              ? "Lock file not found"
+              : "Failed to read lock file",
+          cause: e,
+        }),
+    ),
+    Effect.flatMap((text) => {
+      const pid = Number.parseInt(text);
+      return Number.isNaN(pid)
+        ? Effect.fail(
+            new LockError({
+              reason: "Invalid",
+              message: "Lock file is invalid",
+            }),
+          )
+        : Effect.succeed(pid);
+    }),
+  );
+
+  const isLockProcessAlive = readLockFile.pipe(
+    Effect.flatMap((pid) =>
+      Effect.sync(() => {
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch {
+          return false;
+        }
+      }),
+    ),
+    Effect.orElseSucceed(() => false),
+  );
+
+  const isLockFileStale = fs.stat(paths.lock).pipe(
+    Effect.map((stat) => {
+      const mtime = Option.getOrElse(stat.mtime, () => new Date(0));
+      return mtime.getTime() < Date.now() - Duration.toMillis(LOCK_TTL);
+    }),
+    Effect.orElseSucceed(() => true),
+  );
+
+  const isLockValid = Effect.zipWith(
+    isLockProcessAlive,
+    isLockFileStale,
+    (alive, stale) => alive && !stale,
+    {
+      concurrent: true,
+    },
+  );
+
+  const makeLockFile = fs
+    .writeFileString(paths.lock, process.pid.toString(), { flag: "wx" })
+    .pipe(
+      Effect.mapError((e) =>
+        e.reason._tag === "AlreadyExists"
+          ? new LockError({
+              reason: "Conflict",
+              message: "Lock already held by another process",
+            })
+          : new LockError({
+              reason: "PlatformError",
+              message: "Failed to create lock file",
+              cause: e,
+            }),
+      ),
+    );
+
+  const assertOwnLock = readLockFile.pipe(
+    Effect.flatMap((pid) =>
+      pid === process.pid
+        ? Effect.void
+        : Effect.fail(
+            new LockError({
+              reason: "Conflict",
+              message: "Lock not held by this process",
+            }),
+          ),
+    ),
+  );
+
+  const removeLock = fs.remove(paths.lock, { force: true }).pipe(
+    Effect.mapError(
+      (e) =>
+        new LockError({
+          reason: "PlatformError",
+          message: "Failed to remove lock file",
+          cause: e,
+        }),
+    ),
+  );
+
+  const releaseLock = assertOwnLock.pipe(Effect.andThen(() => removeLock));
+
+  const acquireLock = makeLockFile.pipe(
+    Effect.catchIf(
+      (e) => e.reason === "Conflict",
+      (e) =>
+        isLockValid.pipe(
+          Effect.flatMap((valid) =>
+            valid
+              ? Effect.fail(e)
+              : removeLock.pipe(Effect.andThen(() => makeLockFile)),
+          ),
+        ),
+    ),
+  );
+
+  const touchLock = assertOwnLock.pipe(
+    Effect.flatMap(() => {
+      const now = Date.now();
+      return fs.utimes(paths.lock, now, now).pipe(
+        Effect.mapError(
+          (e) =>
+            new LockError({
+              reason: "PlatformError",
+              message: "Failed to update lock file",
+              cause: e,
+            }),
+        ),
+      );
+    }),
+  );
+
+  return Lock.of({
+    check: isLockValid,
+    acquire: acquireLock.pipe(
+      Effect.flatMap(() =>
+        touchLock.pipe(
+          Effect.repeat(Schedule.spaced(TOUCH_INTERVAL)),
+          Effect.ensuring(releaseLock.pipe(Effect.ignore)),
+          Effect.forkScoped,
+        ),
+      ),
+    ),
+  });
+});
+
+export const LockLive = Layer.effect(Lock, make);