alchemy 2.0.0-beta.42 → 2.0.0-beta.44

package/src/Cloudflare/Local.ts

@@ -0,0 +1,23 @@
+import * as Layer from "effect/Layer";
+import * as RpcServer from "../Local/RpcServer.ts";
+import { CloudflareAuth } from "./Auth/AuthProvider.ts";
+import * as CloudflareEnvironment from "./CloudflareEnvironment.ts";
+import * as Credentials from "./Credentials.ts";
+import {
+  LocalWorkerProvider,
+  localRuntimeServices,
+} from "./Workers/LocalWorkerProvider.ts";
+
+const cloudflareServices = Layer.provide(
+  Layer.merge(
+    Credentials.fromAuthProvider(),
+    CloudflareEnvironment.fromProfile(),
+  ),
+  CloudflareAuth,
+);
+
+LocalWorkerProvider().pipe(
+  Layer.provide(localRuntimeServices({ port: 1337 })),
+  Layer.provide(cloudflareServices),
+  RpcServer.launch,
+);

package/src/Cloudflare/Providers.ts

@@ -32,6 +32,7 @@ import * as Tunnel from "./Tunnel/index.ts";
 import * as VpcService from "./VpcService/index.ts";
 import * as Workers from "./Workers/index.ts";
 import * as Workflows from "./Workers/Workflow.ts";
+import * as Zaraz from "./Zaraz/index.ts";
 
 export { Credentials } from "@distilled.cloud/cloudflare/Credentials";
 
@@ -84,6 +85,7 @@ export const providers = () =>
       Workers.FetchPolicy,
       Workers.Worker,
       Workflows.WorkflowResource,
+      Zaraz.ZarazConfig,
     ]),
   ).pipe(
     Layer.provide(
@@ -122,6 +124,7 @@ export const providers = () =>
         Workers.FetchPolicyLive,
         Workers.WorkerProvider(),
         Workflows.WorkflowProvider(),
+        Zaraz.ZarazConfigProvider(),
       ),
     ),
     Layer.provideMerge(

package/src/Cloudflare/Queue/QueueBinding.ts

@@ -2,21 +2,22 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { Queue } from "./Queue.ts";
 
 export interface QueueSender {
-  raw: Effect.Effect<any, never, WorkerEnvironment>;
+  raw: Effect.Effect<any, never, RuntimeContext>;
   send(
     body: unknown,
     options?: { contentType?: "json" | "text" },
-  ): Effect.Effect<void, QueueSendError, WorkerEnvironment>;
+  ): Effect.Effect<void, QueueSendError, RuntimeContext>;
   sendBatch(
     messages: ReadonlyArray<{
       body: unknown;
       contentType?: "json" | "text";
     }>,
-  ): Effect.Effect<void, QueueSendError, WorkerEnvironment>;
+  ): Effect.Effect<void, QueueSendError, RuntimeContext>;
 }
 
 import * as Data from "effect/Data";
@@ -68,12 +69,12 @@ export const QueueBindingLive = Layer.effect(
   QueueBinding,
   Effect.gen(function* () {
     const bind = yield* QueueBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (queue: Queue) {
       yield* bind(queue);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map((env) => (env as Record<string, any>)[queue.LogicalId]),
+      const raw = Effect.sync(
+        () => (env as Record<string, any>)[queue.LogicalId],
       );
 
       const tryPromise = <T>(

package/src/Cloudflare/R2/R2BucketBinding.ts

@@ -6,6 +6,7 @@ import * as Stream from "effect/Stream";
 import * as Binding from "../../Binding.ts";
 import * as Output from "../../Output.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { getRawStream } from "../../Util/Stream.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { R2Bucket } from "./R2Bucket.ts";
@@ -66,18 +67,18 @@ export type R2UploadedPart = runtime.R2UploadedPart;
 export interface R2UploadPartOptions extends runtime.R2UploadPartOptions {}
 
 export interface R2BucketClient {
-  raw: Effect.Effect<runtime.R2Bucket, never, WorkerEnvironment>;
-  head(key: string): Effect.Effect<R2Object | null, R2Error, WorkerEnvironment>;
+  raw: Effect.Effect<runtime.R2Bucket, never, RuntimeContext>;
+  head(key: string): Effect.Effect<R2Object | null, R2Error, RuntimeContext>;
   get(
     key: string,
     options: R2GetOptions & {
       onlyIf: runtime.R2Conditional | Headers;
     },
-  ): Effect.Effect<R2ObjectBody | R2Object | null, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2ObjectBody | R2Object | null, R2Error, RuntimeContext>;
   get(
     key: string,
     options?: R2GetOptions,
-  ): Effect.Effect<R2ObjectBody | null, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2ObjectBody | null, R2Error, RuntimeContext>;
   put<Err = never>(
     key: string,
     value:
@@ -92,7 +93,7 @@ export interface R2BucketClient {
       onlyIf: R2Conditional | Headers;
       contentLength?: number;
     },
-  ): Effect.Effect<R2Object | null, R2Error | Err, WorkerEnvironment>;
+  ): Effect.Effect<R2Object | null, R2Error | Err, RuntimeContext>;
   put<Err = never>(
     key: string,
     value:
@@ -103,7 +104,7 @@ export interface R2BucketClient {
       | null
       | Blob,
     options?: R2PutOptions,
-  ): Effect.Effect<R2Object, R2Error | Err, WorkerEnvironment>;
+  ): Effect.Effect<R2Object, R2Error | Err, RuntimeContext>;
   put<Err = never>(
     key: string,
     value:
@@ -117,21 +118,19 @@ export interface R2BucketClient {
     options: R2PutOptions & {
       contentLength: number;
     },
-  ): Effect.Effect<R2Object, R2Error | Err, WorkerEnvironment>;
-  delete(
-    keys: string | string[],
-  ): Effect.Effect<void, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2Object, R2Error | Err, RuntimeContext>;
+  delete(keys: string | string[]): Effect.Effect<void, R2Error, RuntimeContext>;
   list(
     options?: R2ListOptions,
-  ): Effect.Effect<R2Objects, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2Objects, R2Error, RuntimeContext>;
   createMultipartUpload(
     key: string,
     options?: R2MultipartOptions,
-  ): Effect.Effect<R2MultipartUpload, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2MultipartUpload, R2Error, RuntimeContext>;
   resumeMultipartUpload(
     key: string,
     uploadId: string,
-  ): Effect.Effect<R2MultipartUpload, R2Error, WorkerEnvironment>;
+  ): Effect.Effect<R2MultipartUpload, R2Error, RuntimeContext>;
 }
 
 export class R2BucketBinding extends Binding.Service<
@@ -143,14 +142,12 @@ export const R2BucketBindingLive = Layer.effect(
   R2BucketBinding,
   Effect.gen(function* () {
     const bind = yield* R2BucketBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (bucket: R2Bucket) {
       yield* bind(bucket);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) => (env as Record<string, runtime.R2Bucket>)[bucket.LogicalId],
-        ),
+      const raw = Effect.sync(
+        () => (env as Record<string, runtime.R2Bucket>)[bucket.LogicalId]!,
       );
       const tryPromise = <T>(fn: () => Promise<T>): Effect.Effect<T, R2Error> =>
         Effect.tryPromise({
@@ -164,7 +161,7 @@ export const R2BucketBindingLive = Layer.effect(
 
       const use = <T>(
         fn: (raw: runtime.R2Bucket) => Promise<T>,
-      ): Effect.Effect<T, R2Error, WorkerEnvironment> =>
+      ): Effect.Effect<T, R2Error> =>
         raw.pipe(Effect.flatMap((raw) => tryPromise(() => fn(raw))));
 
       const wrapR2Object = (object: runtime.R2Object): R2Object => ({

package/src/Cloudflare/SecretsStore/SecretBinding.ts

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { Secret } from "./Secret.ts";
 
@@ -21,16 +22,16 @@ export class SecretError extends Data.TaggedError("SecretError")<{
 export interface SecretClient extends Effect.Effect<
   string,
   SecretError,
-  WorkerEnvironment
+  RuntimeContext
 > {
   /**
    * Effect that resolves to the raw Cloudflare `SecretsStoreSecret` binding.
    */
-  raw: Effect.Effect<runtime.SecretsStoreSecret, never, WorkerEnvironment>;
+  raw: Effect.Effect<runtime.SecretsStoreSecret, never, RuntimeContext>;
   /**
    * Read the current value of the secret.
    */
-  get(): Effect.Effect<string, SecretError, WorkerEnvironment>;
+  get(): Effect.Effect<string, SecretError, RuntimeContext>;
 }
 
 export class SecretBinding extends Binding.Service<
@@ -42,17 +43,13 @@ export const SecretBindingLive = Layer.effect(
   SecretBinding,
   Effect.gen(function* () {
     const bind = yield* SecretBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (secret: Secret) {
       yield* bind(secret);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) =>
-            (env as Record<string, runtime.SecretsStoreSecret>)[
-              secret.LogicalId
-            ],
-        ),
+      const raw = Effect.sync(
+        () =>
+          (env as Record<string, runtime.SecretsStoreSecret>)[secret.LogicalId],
       );
       const tryPromise = <T>(
         fn: () => Promise<T>,
@@ -66,8 +63,9 @@ export const SecretBindingLive = Layer.effect(
             }),
         });
 
-      const getEffect: Effect.Effect<string, SecretError, WorkerEnvironment> =
-        raw.pipe(Effect.flatMap((raw) => tryPromise(() => raw.get())));
+      const getEffect: Effect.Effect<string, SecretError> = raw.pipe(
+        Effect.flatMap((raw) => tryPromise(() => raw.get())),
+      );
 
       return Object.assign(
         Effect.suspend(() => getEffect),

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -81,7 +81,6 @@ export const makeDurableObjectBridge =
 
         return new Proxy(this, {
           get: (target, prop) => {
-            console.log(target, prop, prop in target);
             const bind = (f: any) =>
               typeof f === "function" ? f.bind(target) : f;
             if (typeof prop !== "string") return bind((target as any)[prop]);

package/src/Cloudflare/Workers/DurableObjectNamespace.ts

@@ -1,12 +1,12 @@
 import type * as cf from "@cloudflare/workers-types";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
 import type { HttpServerError } from "effect/unstable/http/HttpServerError";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
+import { ALCHEMY_PHASE } from "../../Phase.ts";
 import type { PlatformServices } from "../../Platform.ts";
 import { effectClass, taggedFunction } from "../../Util/effect.ts";
 import { DurableObjectState } from "./DurableObjectState.ts";
@@ -589,12 +589,12 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
                 ],
               });
 
-              const binding = yield* Effect.serviceOption(
+              const binding = yield* Effect.all([
                 WorkerEnvironment,
-              ).pipe(
-                Effect.map(Option.getOrUndefined),
-                Effect.flatMap((env) => {
-                  if (env === undefined) {
+                ALCHEMY_PHASE,
+              ]).pipe(
+                Effect.flatMap(([env, phase]) => {
+                  if (env === undefined || phase === "plan") {
                     // should be fine to return undefined here (it is only undefined at plantime)
                     return Effect.succeed(undefined);
                   }

package/src/Cloudflare/Workers/DynamicWorkerLoader.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
+import { ALCHEMY_PHASE } from "../../Phase.ts";
 import { fromCloudflareFetcher, type Fetcher } from "../Fetcher.ts";
 import { makeRpcStub } from "./Rpc.ts";
 import { Worker, WorkerEnvironment } from "./Worker.ts";
@@ -162,10 +162,9 @@ export const DynamicWorkerLoader = Effect.fnUntraced(function* (name: string) {
     bindings: [{ type: "worker_loader", name } as any],
   });
 
-  const binding = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-    Effect.map(Option.getOrUndefined),
-    Effect.flatMap((env) => {
-      if (env === undefined) {
+  const binding = yield* Effect.all([WorkerEnvironment, ALCHEMY_PHASE]).pipe(
+    Effect.flatMap(([env, phase]) => {
+      if (env === undefined || phase === "plan") {
         return Effect.succeed(undefined as any);
       }
       const loader = env[name];