alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/lib/Cloudflare/Workers/Worker.js

@@ -9,6 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import cloudflareVite from "@distilled.cloud/cloudflare-vite-plugin";
 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";
@@ -19,6 +20,7 @@ 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 { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -35,10 +37,11 @@ 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 { fromCloudflareFetcher } from "../Fetcher.js";
 import { isImages as isImagesBinding, } from "../Images/Images.js";
 import { SidecarLive } from "../Local/Sidecar.js";
 import { CloudflareLogs } from "../Logs.js";
@@ -48,7 +51,7 @@ import { isDurableObjectExport, isDurableObjectNamespaceLike, } from "./DurableO
 import { workersHttpHandler } from "./HttpServer.js";
 import { LocalWorkerProvider } from "./LocalWorkerProvider.js";
 import { Request } from "./Request.js";
-import { makeRpcStub } from "./Rpc.js";
+import { encodeRpcError, ErrorTag, makeRpcStub, toRpcStream, } from "./Rpc.js";
 import { WorkerBundle } from "./WorkerBundle.js";
 import { createWorkerName } from "./WorkerName.js";
 const WorkerTypeId = "Cloudflare.Worker";
@@ -434,8 +437,11 @@ export const Worker = Platform(WorkerTypeId, {
             for (const bindingName in props.bindings) {
                 // @ts-expect-error
                 const bindingEff = props.bindings?.[bindingName];
-                const binding = Effect.isEffect(bindingEff)
-                    ? yield* bindingEff
+                // 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)
                     ? {
@@ -453,52 +459,64 @@ export const Worker = Platform(WorkerTypeId, {
                                 type: "images",
                                 name: bindingName,
                             }
-                            : isDurableObjectNamespaceLike(binding)
+                            : isAnalyticsEngineDataset(binding)
                                 ? {
-                                    type: "durable_object_namespace",
+                                    type: "analytics_engine",
                                     name: bindingName,
-                                    className: binding.className ?? binding.name,
+                                    dataset: binding.dataset,
                                 }
-                                : binding.Type === "Cloudflare.D1Database"
+                                : isDurableObjectNamespaceLike(binding)
                                     ? {
-                                        type: "d1",
-                                        id: binding.databaseId,
+                                        type: "durable_object_namespace",
                                         name: bindingName,
+                                        className: binding.className ?? binding.name,
                                     }
-                                    : binding.Type === "Cloudflare.R2Bucket"
+                                    : binding.Type === "Cloudflare.D1Database"
                                         ? {
-                                            type: "r2_bucket",
+                                            type: "d1",
+                                            id: binding.databaseId,
                                             name: bindingName,
-                                            bucketName: binding.bucketName,
-                                            jurisdiction: binding.jurisdiction.pipe(Output.map((jurisdiction) => jurisdiction === "default"
-                                                ? undefined
-                                                : jurisdiction)),
                                         }
-                                        : binding.Type === "Cloudflare.KVNamespace"
+                                        : binding.Type === "Cloudflare.R2Bucket"
                                             ? {
-                                                type: "kv_namespace",
+                                                type: "r2_bucket",
                                                 name: bindingName,
-                                                namespaceId: binding.namespaceId,
+                                                bucketName: binding.bucketName,
+                                                jurisdiction: binding.jurisdiction.pipe(Output.map((jurisdiction) => jurisdiction === "default"
+                                                    ? undefined
+                                                    : jurisdiction)),
                                             }
-                                            : binding.Type === "Cloudflare.Queue"
+                                            : binding.Type === "Cloudflare.KVNamespace"
                                                 ? {
-                                                    type: "queue",
+                                                    type: "kv_namespace",
                                                     name: bindingName,
-                                                    queueName: binding.queueName,
+                                                    namespaceId: binding.namespaceId,
                                                 }
-                                                : binding.Type === "Cloudflare.AiGateway"
+                                                : binding.Type === "Cloudflare.Queue"
                                                     ? {
-                                                        type: "ai",
+                                                        type: "queue",
                                                         name: bindingName,
+                                                        queueName: binding.queueName,
                                                     }
-                                                    : binding.Type === "Cloudflare.Hyperdrive"
+                                                    : binding.Type === "Cloudflare.AiGateway"
                                                         ? {
-                                                            type: "hyperdrive",
+                                                            type: "ai",
                                                             name: bindingName,
-                                                            id: binding.hyperdriveId,
                                                         }
-                                                        : // TODO(sam): handle others
-                                                            undefined;
+                                                        : 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],
@@ -514,6 +532,7 @@ export const Worker = Platform(WorkerTypeId, {
         const listeners = [];
         const exports = {};
         const env = {};
+        let userShape;
         const ctx = {
             Type: WorkerTypeId,
             id,
@@ -559,7 +578,14 @@ export const Worker = Platform(WorkerTypeId, {
                     : JSON.stringify(value)));
                 return key;
             }),
-            serve: (handler) => ctx.listen(workersHttpHandler(handler)),
+            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)))),
@@ -571,6 +597,18 @@ export const Worker = Platform(WorkerTypeId, {
                     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",
@@ -582,20 +620,60 @@ export const Worker = Platform(WorkerTypeId, {
                     for (const handler of handlers) {
                         const eff = handler(event);
                         if (Effect.isEffect(eff)) {
-                            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.runPromise)
-                                .finally(() => context.waitUntil(Effect.runPromise(Scope.close(scope, Exit.void))));
+                            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,
                 };
             }),
         };
@@ -603,7 +681,10 @@ export const Worker = Platform(WorkerTypeId, {
     },
 });
 export const bindWorker = Effect.fnUntraced(function* (workerEff) {
-    const worker = Effect.isEffect(workerEff) ? yield* workerEff : 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: [
@@ -614,10 +695,12 @@ export const bindWorker = Effect.fnUntraced(function* (workerEff) {
             },
         ],
     });
-    const workerBinding = WorkerEnvironment.asEffect().pipe(Effect.map((env) => env[worker.LogicalId]));
-    const fetcher = workerBinding.pipe(Effect.map(fromCloudflareFetcher));
-    // TODO(sam): update makeRpcStub to support lazily evaluating the Effect<Fetcher>
-    return makeRpcStub(fetcher);
+    // `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);
 });
 export class BindWorkerPolicy extends Binding.Policy()("Cloudflare.Worker.Bind") {
 }
@@ -663,6 +746,9 @@ function getDurableObjectBindings(bindings, workerName) {
         ]
         : []));
 }
+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:")) {
@@ -687,9 +773,11 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
     const createScriptSubdomain = yield* workers.createScriptSubdomain;
     const deleteScript = yield* workers.deleteScript;
     const getScriptSubdomain = yield* workers.getScriptSubdomain;
+    const getScriptSchedule = yield* workers.getScriptSchedule;
     const getScriptSettings = yield* workers.getScriptScriptAndVersionSetting;
     const getSubdomain = yield* workers.getSubdomain;
     const putScript = yield* workers.putScript;
+    const putScriptSchedule = yield* workers.putScriptSchedule;
     const putDomain = yield* workers.putDomain;
     const listDomains = yield* workers.listDomains;
     const deleteDomain = yield* workers.deleteDomain;
@@ -724,6 +812,32 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
     const normalizeDomains = (domain) => domain === undefined
         ? []
         : Array.from(new Set((Array.isArray(domain) ? domain : [domain]).map(toPunycode)));
+    const normalizeCrons = (crons) => Array.from(new Set(crons ?? []));
+    const getWorkerCrons = (scriptName) => getScriptSchedule({
+        accountId,
+        scriptName,
+    }).pipe(Effect.map((response) => normalizeCrons(response.schedules.map((schedule) => schedule.cron))), Effect.catchTag("WorkerNotFound", () => Effect.succeed([])));
+    const reconcileCrons = (scriptName, desired, previous, session) => Effect.gen(function* () {
+        const live = yield* getWorkerCrons(scriptName);
+        const desiredSorted = [...desired].sort();
+        const liveSorted = [...live].sort();
+        const changed = desiredSorted.length !== liveSorted.length ||
+            desiredSorted.some((cron, index) => cron !== liveSorted[index]);
+        if (!changed)
+            return live;
+        if (desired.length > 0 || previous.length > 0 || live.length > 0) {
+            yield* session.note(`Reconciling Cron Triggers (${desired.length}) ...`);
+        }
+        const result = yield* putScriptSchedule({
+            accountId,
+            scriptName,
+            body: desired.map((cron) => ({ cron })),
+        }).pipe(Effect.retry({
+            while: (error) => error?._tag === "WorkerNotFound",
+            schedule: Schedule.exponential(200).pipe(Schedule.both(Schedule.recurs(15))),
+        }));
+        return normalizeCrons(result.schedules.map((schedule) => schedule.cron));
+    });
     /**
      * Infer the Cloudflare Zone ID for a given hostname by listing the
      * account's zones and matching the hostname against each zone's name —
@@ -1315,6 +1429,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             yield* session.note(`Reconciling custom domains (${desiredDomains.length}) ...`);
         }
         const domains = yield* reconcileDomains(name, desiredDomains, previousDomains);
+        const crons = yield* reconcileCrons(name, normalizeCrons([...getCronBindings(bindings), ...(news.crons ?? [])]), output?.crons ?? [], session);
         return {
             workerId: worker.id ?? name,
             workerName: name,
@@ -1326,6 +1441,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
             durableObjectNamespaces,
             accountId,
             domains,
+            crons,
             hash,
         };
     });
@@ -1372,7 +1488,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
     });
     return Worker.Provider.of({
         stables: ["workerId", "workerName"],
-        diff: Effect.fnUntraced(function* ({ id, news, olds, output }) {
+        diff: Effect.fnUntraced(function* ({ id, news, olds, output, newBindings, }) {
             if (!isResolved(news))
                 return undefined;
             if ((output?.accountId ?? accountId) !== accountId) {
@@ -1394,7 +1510,18 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 .sort();
             const domainsChanged = newDomains.length !== oldDomains.length ||
                 newDomains.some((d, i) => d !== oldDomains[i]);
-            if (domainsChanged || (yield* hasChanged(id, news, output))) {
+            const newCrons = normalizeCrons([
+                ...(Array.isArray(newBindings)
+                    ? getCronBindings(newBindings)
+                    : []),
+                ...(news.crons ?? []),
+            ]).sort();
+            const oldCrons = [...(output?.crons ?? [])].sort();
+            const cronsChanged = newCrons.length !== oldCrons.length ||
+                newCrons.some((cron, index) => cron !== oldCrons[index]);
+            if (domainsChanged ||
+                cronsChanged ||
+                (yield* hasChanged(id, news, output))) {
                 return {
                     action: "update",
                     stables: oldWorkerName === workerName ? ["workerName"] : undefined,
@@ -1476,7 +1603,19 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                             type: "application/javascript+module",
                         }),
                     ],
-                });
+                }).pipe(
+                // Cloudflare's PUT /workers/scripts/{name} intermittently
+                // returns code 10002 / "An unknown error has occurred" on the
+                // first put for a fresh worker name. Surfaced as the shared
+                // `InternalServerError` upstream (alchemy-run/distilled#290).
+                // Also match `UnknownCloudflareError` for older
+                // @distilled.cloud/cloudflare versions that haven't picked
+                // up the patch yet.
+                Effect.retry({
+                    while: (e) => e._tag === "InternalServerError" ||
+                        e._tag === "UnknownCloudflareError",
+                    schedule: Schedule.exponential(1000).pipe(Schedule.both(Schedule.recurs(5))),
+                }));
                 if (doClasses.length > 0) {
                     ({ durableObjectNamespaces } =
                         yield* getWorkerSettingsWithDurableObjects(name, doClasses));
@@ -1495,6 +1634,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 durableObjectNamespaces,
                 accountId,
                 domains: [],
+                crons: [],
             };
         }),
         read: Effect.fnUntraced(function* ({ id, output, olds }) {
@@ -1522,6 +1662,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                     service: workerName,
                 }).pipe(Effect.map((r) => r.result ?? [])),
             ]);
+            const crons = yield* getWorkerCrons(workerName);
             yield* Effect.logInfo(`Cloudflare Worker read: found ${workerName}`);
             const attrs = {
                 accountId,
@@ -1536,6 +1677,7 @@ export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(funct
                 domains: domainsList.flatMap((d) => d.id && d.hostname && d.zoneId
                     ? [{ id: d.id, hostname: d.hostname, zoneId: d.zoneId }]
                     : []),
+                crons,
             };
             // Centralized ownership decision: the engine routes `read`'s
             // return value based on `AdoptPolicy`. We hand it the attrs