alchemy 2.0.0-beta.40 → 2.0.0-beta.41

package/lib/Cloudflare/Workers/Worker.js

@@ -1,51 +1,36 @@
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as zones from "@distilled.cloud/cloudflare/zones";
-import * as Cause from "effect/Cause";
 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 Layer from "effect/Layer";
-import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
-import * as Scope from "effect/Scope";
-import * as Stream from "effect/Stream";
 import { Unowned } from "../../AdoptPolicy.js";
 import { AlchemyContext } from "../../AlchemyContext.js";
 import * as Artifacts from "../../Artifacts.js";
-import * as Binding from "../../Binding.js";
 import { hashDirectory } from "../../Build/Memo.js";
 import * as Bundle from "../../Bundle/Bundle.js";
 import { isResolved } from "../../Diff.js";
-import { ExecutionContext } from "../../ExecutionContext.js";
-import * as Output from "../../Output.js";
-import { Platform, } from "../../Platform.js";
+import { Platform } from "../../Platform.js";
 import * as Provider from "../../Provider.js";
 import { Resource } from "../../Resource.js";
-import * as Serverless from "../../Serverless/index.js";
 import { Stack } from "../../Stack.js";
-import { isYieldableEffectLike } from "../../Util/effect.js";
-import { isAnalyticsEngineDataset, } from "../AnalyticsEngine/AnalyticsEngineDataset.js";
-import { isArtifacts as isArtifactsBinding, } from "../Artifacts/Artifacts.js";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.js";
-import { D1Database } from "../D1/D1Database.js";
-import { isSendEmail } from "../Email/SendEmail.js";
-import { isImages as isImagesBinding, } from "../Images/Images.js";
 import { SidecarLive } from "../Local/Sidecar.js";
 import { CloudflareLogs } from "../Logs.js";
-import { isAssets, readAssets, uploadAssets, } from "./Assets.js";
+import { readAssets, uploadAssets, } from "./Assets.js";
 import { getCompatibility } from "./Compatibility.js";
-import { isDurableObjectExport, isDurableObjectNamespaceLike, } from "./DurableObjectNamespace.js";
-import { workersHttpHandler } from "./HttpServer.js";
+import { isDurableObjectExport } from "./DurableObjectNamespace.js";
 import { LocalWorkerProvider } from "./LocalWorkerProvider.js";
 import { Request } from "./Request.js";
-import { encodeRpcError, ErrorTag, makeRpcStub, toRpcStream, } from "./Rpc.js";
 import * as Vite from "./Vite.js";
+import { bindWorkerAsyncBindings, getCronBindings, } from "./WorkerAsyncBindings.js";
 import { WorkerBundle } from "./WorkerBundle.js";
 import { createWorkerName } from "./WorkerName.js";
-const WorkerTypeId = "Cloudflare.Worker";
+import { makeWorkerRuntimeContext, } from "./WorkerRuntimeContext.js";
+export const WorkerTypeId = "Cloudflare.Worker";
 export const isWorker = (value) => typeof value === "object" &&
     value !== null &&
     "Type" in value &&
@@ -423,342 +408,11 @@ export const ExportedHandlerMethods = [
  * ```
  */
 export const Worker = Platform(WorkerTypeId, {
-    onCreate: Effect.fnUntraced(function* (resource, props) {
-        if (props.bindings) {
-            for (const bindingName in props.bindings) {
-                // @ts-expect-error
-                const bindingEff = props.bindings?.[bindingName];
-                // Bindings can be passed as a plain resource value, an Effect that
-                // yields a resource, or an effect-class (e.g. a `Cloudflare.Worker`
-                // class). Resolve the yieldable forms before deriving binding metadata.
-                const binding = isYieldableEffectLike(bindingEff)
-                    ? (yield* bindingEff)
-                    : bindingEff;
-                const bindingMeta = isAssets(binding)
-                    ? {
-                        type: "assets",
-                        name: bindingName,
-                    }
-                    : isArtifactsBinding(binding)
-                        ? {
-                            type: "artifacts",
-                            name: bindingName,
-                            namespace: binding.namespace,
-                        }
-                        : isImagesBinding(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;
-                if (bindingMeta) {
-                    yield* resource.bind `${bindingName}`({
-                        bindings: [bindingMeta],
-                    });
-                }
-                else {
-                    return yield* Effect.die(`Unknown binding type: ${bindingName}`);
-                }
-            }
-        }
-    }),
-    createRuntimeContext: (id) => {
-        const listeners = [];
-        const exports = {};
-        const env = {};
-        let userShape;
-        const ctx = {
-            Type: WorkerTypeId,
-            id,
-            env,
-            get: (key) => 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`)), Effect.map((json) => {
-                try {
-                    const value = JSON.parse(json);
-                    // The `set` path serializes Redacted values as
-                    // `{_tag: "Redacted", value: ...}`. After JSON.parse the
-                    // result is a plain object — `Redacted.isRedacted` would
-                    // always return `false` on it — so detect the marker shape
-                    // and rebuild the Redacted wrapper. Plain values pass
-                    // through unchanged.
-                    if (value !== null &&
-                        typeof value === "object" &&
-                        value._tag === "Redacted" &&
-                        "value" in value) {
-                        return Redacted.make(value.value);
-                    }
-                    return value;
-                }
-                catch {
-                    return json;
-                }
-            })),
-            set: (id, 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
-                // payload still carries the `{_tag: "Redacted", …}` marker so the
-                // runtime `get` accessor can rebuild the wrapper after Cloudflare
-                // hands the binding back as a plain string.
-                env[key] = output.pipe(Output.map((value) => Redacted.isRedacted(value)
-                    ? Redacted.make(JSON.stringify({
-                        _tag: "Redacted",
-                        value: Redacted.value(value),
-                    }))
-                    : JSON.stringify(value)));
-                return key;
-            }),
-            serve: (handler, options) => {
-                // Capture the user's full default-export shape so `exports` can
-                // expose any non-handler methods on it as RPC methods on the
-                // deployed `WorkerEntrypoint` subclass — see `__rpc__` below.
-                if (options?.shape)
-                    userShape = options.shape;
-                return ctx.listen(workersHttpHandler(handler));
-            },
-            listen: ((handler) => Effect.sync(() => Effect.isEffect(handler)
-                ? listeners.push(handler)
-                : listeners.push(Effect.succeed(handler)))),
-            export: (name, value) => Effect.sync(() => {
-                exports[name] = value;
-            }),
-            exports: Effect.gen(function* () {
-                const handlers = yield* Effect.all(listeners, {
-                    concurrency: "unbounded",
-                });
-                const services = yield* Effect.context();
-                // Provide the per-request runtime layer (services + `WorkerExecutionContext`
-                // + a fresh `ExecutionContext`/`Scope`) to a user effect, then run it.
-                // This is the bridge between Cloudflare's request-time callback and
-                // the user's Effect-native handler. Used by both the standard
-                // `handle()` dispatch (fetch/scheduled/…) and the per-RPC dispatchers
-                // below — keeping them on a single layer-provision path.
-                const runUserEffect = (eff, context) => {
-                    const scope = Scope.makeUnsafe();
-                    return eff
-                        .pipe(Effect.provideContext(services), Scope.provide(scope), Effect.provide(Layer.succeed(WorkerExecutionContext, context)), Effect.provide(Layer.succeed(ExecutionContext, { scope, cache: {} })), Effect.runPromiseExit)
-                        .finally(() => context.waitUntil(Effect.runPromise(Scope.close(scope, Exit.void))));
-                };
-                const handle = (type) => (request, env, context) => {
-                    const event = {
-                        kind: "Cloudflare.Workers.WorkerEvent",
-                        type,
-                        input: request,
-                        env,
-                        context,
-                    };
-                    for (const handler of handlers) {
-                        const eff = handler(event);
-                        if (Effect.isEffect(eff)) {
-                            return runUserEffect(eff, context).then((exit) => {
-                                if (exit._tag === "Success")
-                                    return exit.value;
-                                throw Cause.squash(exit.cause);
-                            });
-                        }
-                    }
-                    return Promise.reject(new Error("No event handler found"));
-                };
-                // RPC method dispatchers — one per non-handler method on the user's
-                // shape. Each dispatcher is invoked by the WorkerEntrypoint bridge
-                // as `dispatcher(args, ctx)`: `args` are the user-facing call args,
-                // `ctx` is the `this.ctx` that Cloudflare hands the bridge per RPC
-                // request. The dispatcher runs the user effect with the same runtime
-                // layer the fetch path uses, then envelope-encodes the result so
-                // `Effect.fail` round-trips as `RpcErrorEnvelope` and `Stream` as
-                // `RpcStreamEnvelope` (consumers wrap the binding with
-                // `toPromiseApi`/`bindWorker` to decode).
-                const exportedHandlerSet = new Set(ExportedHandlerMethods);
-                const rpcDispatchers = {};
-                if (userShape) {
-                    for (const [name, value] of Object.entries(userShape)) {
-                        if (exportedHandlerSet.has(name))
-                            continue;
-                        if (typeof value !== "function")
-                            continue;
-                        rpcDispatchers[name] = async (args, context) => {
-                            const result = value(...args);
-                            if (!Effect.isEffect(result))
-                                return result;
-                            const exit = await runUserEffect(result, context);
-                            if (exit._tag === "Success") {
-                                if (Stream.isStream(exit.value)) {
-                                    return await Effect.runPromise(toRpcStream(exit.value));
-                                }
-                                return exit.value;
-                            }
-                            const failReason = exit.cause.reasons.find(Cause.isFailReason);
-                            if (failReason) {
-                                return {
-                                    _tag: ErrorTag,
-                                    error: encodeRpcError(failReason.error),
-                                };
-                            }
-                            const dieReason = exit.cause.reasons.find(Cause.isDieReason);
-                            throw (dieReason?.defect ??
-                                new Error("RPC method failed with an unexpected cause"));
-                        };
-                    }
-                }
-                return {
-                    ...exports,
-                    default: Object.fromEntries(ExportedHandlerMethods.map((method) => [method, handle(method)])),
-                    __rpc__: rpcDispatchers,
-                };
-            }),
-        };
-        return ctx;
-    },
-});
-export const bindWorker = Effect.fnUntraced(function* (workerEff) {
-    // Worker classes and regular Effects are both yieldable here.
-    const worker = isYieldableEffectLike(workerEff)
-        ? yield* workerEff
-        : workerEff;
-    const self = yield* Worker;
-    yield* self.bind `${worker}`({
-        bindings: [
-            {
-                type: "service",
-                name: worker.LogicalId,
-                service: worker.workerName,
-            },
-        ],
-    });
-    // `bindWorker` runs at *init* phase (both at plantime and at runtime
-    // cold-start). `WorkerEnvironment` only exists at exec phase on the
-    // deployed worker, so we hand `makeRpcStub` an `Effect<stub>` that
-    // resolves the binding lazily on each method call.
-    const stubEff = WorkerEnvironment.pipe(Effect.map((env) => env[worker.LogicalId]));
-    return makeRpcStub(stubEff);
+    onCreate: bindWorkerAsyncBindings,
+    createRuntimeContext: makeWorkerRuntimeContext,
 });
-export class BindWorkerPolicy extends Binding.Policy()("Cloudflare.Worker.Bind") {
-}
-export const BindWorkerPolicyLive = BindWorkerPolicy.layer.succeed(Effect.fn(function* (host, worker) {
-    if (isWorker(host)) {
-        yield* host.bind `${worker}`({
-            bindings: [
-                {
-                    type: "service",
-                    name: worker.LogicalId,
-                    service: worker.workerName,
-                },
-            ],
-        });
-    }
-    else {
-        return yield* Effect.die(new Error(`BindWorkerPolicy does not support runtime '${host.Type}'`));
-    }
-}));
 class MissingDurableObjectNamespaces extends Data.TaggedError("MissingDurableObjectNamespaces") {
 }
-function bumpMigrationTagVersion(oldTag) {
-    if (!oldTag)
-        return undefined;
-    const version = oldTag.match(/^(alchemy:)?v(\d+)$/)?.[2];
-    if (!version)
-        return "alchemy:v1";
-    return `alchemy:v${parseInt(version, 10) + 1}`;
-}
-function getDurableObjectBindings(bindings, workerName) {
-    return bindings.flatMap((binding) => (binding.data.bindings ?? []).flatMap((item) => item.type === "durable_object_namespace" &&
-        "className" in item &&
-        item.className &&
-        (!("scriptName" in item) ||
-            !item.scriptName ||
-            item.scriptName === workerName)
-        ? [
-            {
-                logicalId: binding.sid,
-                bindingName: item.name,
-                className: item.className,
-            },
-        ]
-        : []));
-}
-export function getCronBindings(bindings) {
-    return Array.from(new Set(bindings.flatMap((b) => b.data.crons ?? [])));
-}
-function getDurableObjectTagMap(tags) {
-    return Object.fromEntries(tags.flatMap((tag) => {
-        if (!tag.startsWith("alchemy:do:")) {
-            return [];
-        }
-        const parts = tag.split(":");
-        const logicalId = parts[2];
-        const className = parts.slice(3).join(":");
-        return logicalId && className ? [[logicalId, className]] : [];
-    }));
-}
 const selectLayer = (input) => Layer.unwrap(AlchemyContext.useSync((context) => context.dev ? input.dev() : input.live()));
 export const WorkerProvider = () => selectLayer({
     live: LiveWorkerProvider,
@@ -1677,6 +1331,12 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             yield* deleteScript({
                 accountId: output.accountId,
                 scriptName: output.workerName,
+                // Force teardown of queue consumers, durable object classes, and
+                // service bindings hanging off this worker. Without `force`, those
+                // conditions raise QueueConsumerConflict / ServiceBindingConflict
+                // and leave the script in CF. Alchemy is the source of truth for
+                // the worker, so we want a hard delete on teardown.
+                force: true,
             }).pipe(Effect.catchTag("WorkerNotFound", () => Effect.void));
         }),
         tail: ({ output }) => telemetry.tailScript({
@@ -1719,4 +1379,39 @@ const contentTypeFromExtension = (extension) => {
             return "application/octet-stream";
     }
 };
+function bumpMigrationTagVersion(oldTag) {
+    if (!oldTag)
+        return undefined;
+    const version = oldTag.match(/^(alchemy:)?v(\d+)$/)?.[2];
+    if (!version)
+        return "alchemy:v1";
+    return `alchemy:v${parseInt(version, 10) + 1}`;
+}
+function getDurableObjectBindings(bindings, workerName) {
+    return bindings.flatMap((binding) => (binding.data.bindings ?? []).flatMap((item) => item.type === "durable_object_namespace" &&
+        "className" in item &&
+        item.className &&
+        (!("scriptName" in item) ||
+            !item.scriptName ||
+            item.scriptName === workerName)
+        ? [
+            {
+                logicalId: binding.sid,
+                bindingName: item.name,
+                className: item.className,
+            },
+        ]
+        : []));
+}
+function getDurableObjectTagMap(tags) {
+    return Object.fromEntries(tags.flatMap((tag) => {
+        if (!tag.startsWith("alchemy:do:")) {
+            return [];
+        }
+        const parts = tag.split(":");
+        const logicalId = parts[2];
+        const className = parts.slice(3).join(":");
+        return logicalId && className ? [[logicalId, className]] : [];
+    }));
+}
 //# sourceMappingURL=Worker.js.map