alchemy 2.0.0-beta.51 → 2.0.0-beta.52

package/src/Cloudflare/Workers/WorkflowBridge.ts

@@ -1,11 +1,17 @@
+import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { ExecutionContext } from "../../ExecutionContext.ts";
+import { isScopeEjected } from "./HttpServer.ts";
+import { getWorkerExport } from "./WorkerBridge.ts";
 import {
   WorkflowEvent as WorkflowEventService,
   type WorkflowExport,
   type WorkflowImpl,
   WorkflowStep,
 } from "./Workflow.ts";
-import { getWorkerExport } from "./WorkerBridge.ts";
 
 /**
  * Create a WorkflowBridge class that extends `WorkflowEntrypoint` and
@@ -52,15 +58,50 @@ export const makeWorkflowBridge =
 
       async run(event: any, step: any): Promise<unknown> {
         const fn = await this.fn;
-        return Effect.runPromise(
+        // Each run-invocation gets a fresh ExecutionContext (scope + cache),
+        // following the same per-invocation-scope pattern as
+        // `WorkerBridge.processEvent`. `task` threads this into every step via
+        // the surrounding body context, so `@binding` helpers that need it
+        // (e.g. `Drizzle.postgres`) resolve their per-run resources inside
+        // workflow steps. The same scope is also provided as the ambient
+        // `Scope` service, matching the Worker and Durable Object bridges.
+        const scope = Scope.makeUnsafe();
+        const exit = await Effect.runPromiseExit(
           fn(event.payload).pipe(
-            Effect.provideService(
-              WorkflowEventService,
-              wrapWorkflowEvent(event),
+            Effect.provide(
+              Layer.succeed(
+                WorkflowEventService,
+                wrapWorkflowEvent(event),
+              ).pipe(
+                Layer.provideMerge(
+                  Layer.succeed(WorkflowStep, wrapWorkflowStep(step)),
+                ),
+                Layer.provideMerge(
+                  Layer.succeed(ExecutionContext, { scope, cache: {} }),
+                ),
+                Layer.provideMerge(Layer.succeed(Scope.Scope, scope)),
+              ),
             ),
-            Effect.provideService(WorkflowStep, wrapWorkflowStep(step)),
           ) as Effect.Effect<unknown>,
         );
+        // Settle the run's resources with its real exit, unless a binding
+        // ejected the scope to outlive the invocation. The workflow runtime has
+        // no `waitUntil` to detach cleanup to, so close inline — a failing
+        // finalizer (e.g. a pg pool `end()` on a dropped connection) is logged
+        // and ignored so it can't mask the run's outcome.
+        if (!isScopeEjected(scope)) {
+          await Scope.close(scope, exit).pipe(
+            Effect.ignoreCause({
+              log: "Warn",
+              message: "Workflow run scope close failed",
+            }),
+            Effect.runPromise,
+          );
+        }
+        if (Exit.isSuccess(exit)) {
+          return exit.value;
+        }
+        throw Cause.squash(exit.cause);
       }
     };
 

package/src/Cloudflare/Workers/index.ts

@@ -16,6 +16,8 @@ export * from "./Rpc.ts";
 export * from "./RpcDurableObjectNamespace.ts";
 export * from "./RpcWorker.ts";
 export * from "./ScheduledEvents.ts";
+export * from "./VersionMetadata.ts";
+export * from "./VersionMetadataBinding.ts";
 export * from "./WebSocket.ts";
 export * from "./Worker.ts";
 export * from "./WorkerBinding.ts";

package/src/Diff.ts

@@ -1,4 +1,5 @@
 import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
 import type { Input } from "./Input.ts";
 import * as Output from "./Output.ts";
 import type { BindingNode } from "./Plan.ts";
@@ -119,6 +120,12 @@ export const deepEqual = (
 
 const canonicalize = (value: unknown, stripNullish: boolean): unknown => {
   if (stripNullish && value == null) return undefined;
+  if (Redacted.isRedacted(value)) {
+    return {
+      _tag: "Redacted",
+      value: Redacted.value(value),
+    };
+  }
   if (Array.isArray(value)) {
     return value.map((v) => canonicalize(v, stripNullish));
   }

package/src/Drizzle/Postgres.ts

@@ -25,19 +25,20 @@ import { proxyChain } from "../Util/proxy-chain.ts";
  * });
  * ```
  *
- * Behind the scenes the actual connect work is wrapped in `Effect.cached`,
- * so the pool is built at most once per JS realm. Yielding the
- * connection string is also deferred until first query, so deploy /
- * plan-time invocations (where `WorkerEnvironment` isn't provided)
- * never trigger a real connection attempt.
+ * The connect work is deferred until the first query and memoized on the
+ * current `ExecutionContext` (`ctx.cache`), so the pool is built at most
+ * once per execution — a Worker `fetch`/`queue`/`scheduled` event or a
+ * Workflow run — and reused across every query and `task` step in that
+ * execution. Yielding the connection string is likewise deferred, so
+ * deploy / plan-time invocations (where `WorkerEnvironment` isn't
+ * provided) never trigger a real connection attempt.
  *
- * The PgClient pool is built against an isolated, never-closing `Scope`
- * so it outlives whatever scope this helper is yielded under. In a
- * Cloudflare Worker the surrounding `Cloudflare.Worker` runs init
- * inside `Effect.scoped`, which closes after returning the exports
- * object — without an isolated scope, the pool's `end` finalizer
- * would fire there and every subsequent request would see "Cannot
- * use a pool after end".
+ * The pool is built against the execution's `Scope` (`ctx.scope`), so its
+ * `end` finalizer fires when that scope closes — when the request / run
+ * settles, not when the `Cloudflare.Worker` init scope closes. Init runs
+ * inside `Effect.scoped` and closes after returning the exports object;
+ * building lazily against `ctx.scope` (rather than that init scope) is
+ * what keeps later requests from seeing "Cannot use a pool after end".
  *
  * @binding
  */

package/src/Drizzle/Schema.ts

@@ -1,7 +1,7 @@
-import * as crypto from "node:crypto";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as crypto from "node:crypto";
 import { isResolved } from "../Diff.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
@@ -45,7 +45,7 @@ export type Schema = Resource<
   "Drizzle.Schema",
   SchemaProps,
   {
-    /** Absolute path to the migrations directory. */
+    /** Path to the migrations directory, relative to the current working directory. */
     out: string;
     /**
      * sha256 of the latest snapshot.json. Stable across deploys when the
@@ -117,6 +117,12 @@ export const SchemaProvider = () =>
       const resolveOut = (p: SchemaProps) =>
         path.resolve(process.cwd(), p.out ?? "./migrations");
 
+      // The `out` attribute is exposed as a path relative to the current
+      // working directory so that persisted state stays portable across
+      // machines/checkouts. Internal filesystem ops always use the absolute
+      // `resolveOut` form.
+      const relativeOut = (abs: string) => path.relative(process.cwd(), abs);
+
       const resolveSchema = (p: SchemaProps) =>
         path.resolve(process.cwd(), p.schema);
 
@@ -241,7 +247,7 @@ export const SchemaProvider = () =>
           const migrations = yield* listMigrationDirs(out);
           const latest = yield* readLatestSnapshot(out);
           return {
-            out,
+            out: relativeOut(out),
             snapshotHash: latest?.hash ?? sha(JSON.stringify(cur)),
             migrations,
           };
@@ -256,8 +262,12 @@ export const SchemaProvider = () =>
           // `schema.out` as an unresolved Output during plan and cascade
           // into spurious updates of their own.
           const { sqlStatements } = yield* detectDrift(news);
-          if (sqlStatements.length === 0) return undefined;
-          return { action: "update" } as const;
+          // Originally `output.out` was an absolute path, which is not portable.
+          // So, we trigger an update to migrate existing resources.
+          // This is safe because `regenerate` is idempotent.
+          return sqlStatements.length > 0 || path.isAbsolute(output.out)
+            ? { action: "update" }
+            : undefined;
         }),
         read: Effect.fn(function* ({ olds, output }) {
           if (!output) return undefined;
@@ -267,7 +277,7 @@ export const SchemaProvider = () =>
           const latest = yield* readLatestSnapshot(out);
           const migrations = yield* listMigrationDirs(out);
           return {
-            out,
+            out: relativeOut(out),
             snapshotHash: latest?.hash ?? output.snapshotHash,
             migrations,
           };

package/src/Local/RpcSerialization.ts

@@ -89,7 +89,7 @@ export const unwrapRpcHandlers = <T extends Record<string, any>>(
   ) as RpcUnwrapped<T>;
 };
 
-const serializeError = Schema.encodeSync(Schema.Defect);
+const serializeError = Schema.encodeSync(Schema.Defect());
 
 const wrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
   handler: RpcEffectHandler<Args, Success, Error>,
@@ -107,7 +107,10 @@ const wrapRpcEffectHandler = <Args extends Array<any>, Success, Error>(
         cause: exit.cause.reasons.map((reason): RpcSerializedCause<Error> => {
           switch (reason._tag) {
             case "Fail":
-              return { _tag: "Fail", error: serializeError(reason.error) };
+              return {
+                _tag: "Fail",
+                error: serializeError(reason.error) as Error,
+              };
             case "Die":
               return { _tag: "Die", defect: serializeError(reason.defect) };
             case "Interrupt":

package/src/Platform.ts

@@ -2,13 +2,12 @@ import * as ConfigError from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
+import * as Effectable from "effect/Effectable";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import type { Scope } from "effect/Scope";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
-import { SingleShotGen } from "effect/Utils";
 import type { PolicyLike } from "./Binding.ts";
 import type { Dependencies } from "./Dependencies.ts";
 import type { ExecutionContext } from "./ExecutionContext.ts";
@@ -225,7 +224,7 @@ export const Platform = <
         constructor(id, props, impl, true);
     } else if (!impl) {
       const cls = makeClass(id, props);
-      const asEffect = () =>
+      const evaluate = () =>
         (!isTag
           ? // this is a non-tagged resource yielded without providing an implementation
             // e.g.
@@ -272,7 +271,7 @@ export const Platform = <
         );
       return Object.assign(
         function (impl: Impl) {
-          return cls.asEffect().pipe(Effect.provide(cls.make(impl)));
+          return cls.Self.pipe(Effect.provide(cls.make(impl)));
         },
         // we splice in the Effect so this can be yielded to indicate a non-Effect native instance
         // e.g. here, we yield it - in this case we don't want to provide an implementation
@@ -280,42 +279,29 @@ export const Platform = <
         //  main: "./src/worker.ts"
         // });
         cls,
-        {
-          asEffect,
-          // @ts-expect-error
-          pipe: (...args: any[]) => asEffect().pipe(...args),
-          [Symbol.iterator]: () => new SingleShotGen(asEffect()),
-        },
+        // Spread the Effect prototype LAST so it overrides the evaluate copied
+        // from `cls`: yielding this no-impl form bridges to the (possibly
+        // non-Effect-native) resource rather than resolving the Self tag.
+        Effectable.Prototype({
+          label: `${type}<${id}>`,
+          evaluate,
+        }),
       );
     } else {
       // impl was provided inline, this is a non-tagged eager instance
       // e.g.
       // export default Cloudflare.Worker("id", { main: "./src/worker.ts" }, Effect.gen(function* () { .. })
       const cls = makeClass(id, props);
-      return cls.asEffect().pipe(Effect.provide(cls.make(impl)), effectClass);
+      return cls.Self.pipe(Effect.provide(cls.make(impl)), effectClass);
     }
   };
 
   const makeClass = (id: string, props: Props) => {
-    return class Platform {
+    class Platform {
       static readonly Self = Self(`${type}<${id}>`);
       static readonly Platform = Context.Service<Platform, Platform>(
         `Platform<${type}<${id}>>`,
       );
-      static [Symbol.iterator](): Iterator<
-        Effect.Effect<void, never, Self>,
-        Resource,
-        void
-      > {
-        return new SingleShotGen(this.asEffect()) as any;
-      }
-      static asEffect() {
-        return this.Self;
-      }
-      static pipe(...args: any[]) {
-        // @ts-expect-error
-        return pipe(this, ...args);
-      }
       static of = (shape: any) => shape;
       static make = (impl: Impl) => {
         // build the Layer once for the root Self
@@ -460,13 +446,31 @@ export const Platform = <
           SelfLayer,
         );
       };
-    };
+    }
+    // Make the platform class itself a real Effect: `yield* MyWorker` resolves
+    // the Self tag. Replaces the hand-rolled asEffect/pipe/[Symbol.iterator].
+    return Object.assign(
+      Platform,
+      Effectable.Prototype({
+        label: `${type}<${id}>`,
+        evaluate: () => Platform.Self,
+      }),
+    );
   };
 
-  const instance = Object.assign(constructor, resource, {
-    Platform: Platform,
-    asEffect: () => resource.Self,
-    ...methods,
-  }) as any;
+  const instance = Object.assign(
+    constructor,
+    resource,
+    // Spread the Effect prototype LAST so it overrides any evaluate inherited
+    // from `resource`; `yield* Cloudflare.Worker` resolves the resource Self.
+    Effectable.Prototype({
+      label: `${type}`,
+      evaluate: () => resource.Self,
+    }),
+    {
+      Platform: Platform,
+      ...methods,
+    },
+  ) as any;
   return instance;
 };

package/src/Resource.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
+import * as Effectable from "effect/Effectable";
 import * as Option from "effect/Option";
-import { pipeArguments, type Pipeable } from "effect/Pipeable";
-import { SingleShotGen } from "effect/Utils";
+import type { Pipeable } from "effect/Pipeable";
 import { AdoptPolicy } from "./AdoptPolicy.ts";
 import { toFqn } from "./FQN.ts";
 import type { Input, InputProps } from "./Input.ts";
@@ -287,17 +287,6 @@ export function Resource<R extends ResourceLike>(
   const ProviderTag = Provider(type);
 
   const Service = {
-    [Symbol.iterator]() {
-      return new SingleShotGen(this.asEffect());
-    },
-    pipe() {
-      return pipeArguments(this, arguments);
-    },
-    asEffect() {
-      return Effect.succeed((id: string, props: R["Props"]) =>
-        constructor(id, props),
-      );
-    },
     /**
      * Build a typed reference to a deployed instance of this resource
      * — in the current stack/stage by default, or in another via
@@ -323,6 +312,16 @@ export function Resource<R extends ResourceLike>(
         ? Object.assign(ResourceClass, args[0])
         : constructor(...(args as [string, R["Props"]])),
     Service,
+    // Make the constructor itself a real Effect: `yield* MyResource` resolves
+    // to the constructor function (same as the old `asEffect()`), and
+    // `Effect.isEffect(MyResource)` is now true so `Effect.all`/`forEach` work.
+    Effectable.Prototype({
+      label: `Resource<${type}>`,
+      evaluate: () =>
+        Effect.succeed((id: string, props: R["Props"]) =>
+          constructor(id, props),
+        ),
+    }),
   ) as any;
 
   return ResourceClass;

package/src/Runtime.ts

@@ -7,6 +7,7 @@
  */
 
 import * as Layer from "effect/Layer";
+import { asEffect } from "./Util/types.ts";
 
 /**
  * Resolve the user's default-export entrypoint into a `Layer` for the
@@ -14,7 +15,7 @@ import * as Layer from "effect/Layer";
  *
  * `entrypoint` may be any of:
  *   - a `Layer` factory (`{ build: (...) => ... }`) — used as-is
- *   - an effect-class with `asEffect()` (Alchemy `Platform`/`Worker` shape)
+ *   - an Alchemy `Platform`/`Worker` construct (now a real `Effect`)
  *   - a plain `Effect`
  *
  * Centralized so the inline ternary doesn't have to be re-emitted into
@@ -29,10 +30,5 @@ export const makeEntrypointLayer = (
   if (typeof entrypoint?.build === "function") {
     return entrypoint;
   }
-  return Layer.effect(
-    tag,
-    typeof entrypoint?.asEffect === "function"
-      ? entrypoint.asEffect()
-      : entrypoint,
-  );
+  return Layer.effect(tag, asEffect(entrypoint));
 };

package/src/Util/effect.ts

@@ -1,7 +1,6 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { pipeArguments } from "effect/Pipeable";
-import { SingleShotGen } from "effect/Utils";
+import * as Effectable from "effect/Effectable";
 
 export type EffectClass<Shape, A, Err = never, Req = never> = Effect.Effect<
   A,
@@ -22,18 +21,15 @@ export const effectClass: {
   impl === undefined
     ? (innerImpl: any) => effectClass(innerImpl)
     : (Object.assign(
-        class {
-          static asEffect() {
-            return impl;
-          }
-          static [Symbol.iterator]() {
-            return new SingleShotGen(this.asEffect());
-          }
-          static pipe(...fns: any) {
-            return pipeArguments(this, fns);
-          }
-        },
-        impl,
+        class {},
+        // Spreading the Effect prototype onto the class (static side) makes the
+        // class itself a real Effect — `Effect.isEffect(X)` is true, so
+        // `Effect.all([X])` / `Effect.forEach` work — and subclasses
+        // (`class Y extends effectClass(impl)`) inherit the protocol statically.
+        Effectable.Prototype({
+          label: "alchemy/EffectClass",
+          evaluate: () => impl,
+        }),
       ) as unknown as EffectClass<any, any, any, any>)) as any;
 
 export const taggedFunction = <
@@ -43,10 +39,10 @@ export const taggedFunction = <
   tag: Tag,
   fn: Fn,
 ): Tag & Fn => {
+  // The Proxy below forwards every Effect-protocol key to `tag` (already an
+  // Effect), so `asEffect`/`[Symbol.iterator]`/`pipe` need no explicit
+  // override — only `toString` diverges.
   const overrides = {
-    asEffect: () => tag,
-    [Symbol.iterator]: () => tag[Symbol.iterator](),
-    pipe: (...fns: any[]) => pipeArguments(tag, fns as any),
     toString: () => `${tag.toString()}.${fn.name}`,
   };
 

package/src/Util/poll.ts

@@ -27,7 +27,6 @@ export const poll = Effect.fn("poll")(
     effect: Effect.Effect<A, E, R>;
     predicate: (value: A) => boolean;
     schedule?: Schedule.Schedule<unknown, unknown, never>;
-    times?: number;
   }) =>
     input.effect.pipe(
       Effect.filterOrFail(
@@ -40,8 +39,9 @@ export const poll = Effect.fn("poll")(
       ),
       Effect.retry({
         while: isPredicateFailed,
-        schedule: input.schedule ?? Schedule.spaced("3 seconds"),
-        times: input.times ?? 50,
+        schedule:
+          input.schedule ??
+          Schedule.both(Schedule.spaced("5 seconds"), Schedule.recurs(50)),
       }),
     ),
 );