alchemy-effect 0.7.0 → 0.8.0

package/src/Cloudflare/Workers/Worker.ts

@@ -24,7 +24,7 @@ import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved } from "../../Diff.ts";
 import type { HttpEffect } from "../../Http.ts";
-import type { Input } from "../../Input.ts";
+import type { Input, InputProps } from "../../Input.ts";
 import * as Output from "../../Output.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import {
@@ -39,7 +39,9 @@ import { Self } from "../../Self.ts";
 import * as Serverless from "../../Serverless/index.ts";
 import { Stack } from "../../Stack.ts";
 import { Account } from "../Account.ts";
+import { D1Database } from "../D1/D1Database.ts";
 import { CloudflareLogs } from "../Logs.ts";
+import type { R2Bucket } from "../R2/R2Bucket.ts";
 import type { AssetsConfig, AssetsProps } from "./Assets.ts";
 import * as Assets from "./Assets.ts";
 import cloudflare_workers from "./cloudflare_workers.ts";
@@ -142,7 +144,29 @@ export const ExportedHandlerMethods = [
   "queue",
 ] as const satisfies (keyof cf.ExportedHandler)[];
 
-export interface WorkerProps extends PlatformProps {
+export interface WorkerExecutionContext extends Serverless.FunctionContext {
+  export(name: string, value: any): Effect.Effect<void>;
+}
+
+export type WorkerServices = Worker | WorkerEnvironment | Request;
+
+export type WorkerShape = Main<WorkerServices>;
+
+export type WorkerBindingResource = R2Bucket | D1Database;
+
+export type WorkerBindings = {
+  [bindingName in string]: WorkerBindingResource;
+};
+
+export type WorkerBindingProps = {
+  [bindingName in string]:
+    | WorkerBindingResource
+    | Effect.Effect<WorkerBindingResource, any, any>;
+};
+
+export interface WorkerProps<
+  Bindings extends WorkerBindingProps = any,
+> extends PlatformProps {
   /**
    * Worker name override. If omitted, Alchemy derives a deterministic physical
    * name from the stack, stage, and logical ID.
@@ -185,19 +209,12 @@ export interface WorkerProps extends PlatformProps {
   placement?: WorkerPlacement;
   env?: Record<string, any>;
   exports?: string[];
+  bindings?: Bindings;
 }
 
-export interface WorkerExecutionContext extends Serverless.FunctionContext {
-  export(name: string, value: any): Effect.Effect<void>;
-}
-
-export type WorkerServices = Worker | WorkerEnvironment | Request;
-
-export type WorkerShape = Main<WorkerServices>;
-
-export interface Worker extends Resource<
+export type Worker<Bindings extends WorkerBindings = any> = Resource<
   WorkerTypeId,
-  WorkerProps,
+  WorkerProps<Bindings>,
   {
     workerId: string;
     workerName: string;
@@ -215,7 +232,7 @@ export interface Worker extends Resource<
     bindings: WorkerBinding[];
     containers?: { className: string }[];
   }
-> {}
+>;
 
 /**
  * A Cloudflare Worker host with deploy-time binding support and runtime export
@@ -238,105 +255,165 @@ export const Worker: Platform<
   WorkerServices,
   WorkerShape,
   WorkerExecutionContext
-> = Platform(WorkerTypeId, (id: string): WorkerExecutionContext => {
-  const listeners: Effect.Effect<Serverless.FunctionListener>[] = [];
-  const exports: Record<string, any> = {};
-  const env: Record<string, any> = {};
-
-  const ctx = {
-    Type: WorkerTypeId,
-    id,
-    env,
-    get: (key: string) =>
-      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);
-            if (!Redacted.isRedacted(value)) {
-              return Redacted.make(value.value);
+> & {
+  <const Bindings extends WorkerBindingProps>(
+    id: string,
+    props: InputProps<WorkerProps<Bindings>>,
+  ): Effect.Effect<
+    Worker<{
+      [B in keyof Bindings]: Bindings[B] extends Effect.Effect<
+        infer T extends WorkerBindingResource,
+        any,
+        any
+      >
+        ? T
+        : Extract<Bindings[B], WorkerBindingResource>;
+    }>
+  >;
+} = Platform(WorkerTypeId, {
+  onCreate: Effect.fnUntraced(function* (
+    resource: Worker,
+    props: InputProps<WorkerProps<WorkerBindingProps>>,
+  ) {
+    if (props.bindings) {
+      for (const bindingName in props.bindings) {
+        // @ts-expect-error
+        const bindingEff = props.bindings?.[bindingName] as
+          | WorkerBindingResource
+          | Effect.Effect<WorkerBindingResource>;
+        const binding = Effect.isEffect(bindingEff)
+          ? yield* bindingEff
+          : bindingEff;
+
+        const bindingMeta: InputProps<WorkerBinding> | undefined =
+          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,
+                    ),
+                  ),
+                }
+              : // TODO(sam): handle others
+                undefined;
+
+        if (bindingMeta) {
+          yield* resource.bind`${bindingName}`({
+            bindings: [bindingMeta],
+          });
+        }
+      }
+    }
+  }),
+  createExecutionContext: (id: string): WorkerExecutionContext => {
+    const listeners: Effect.Effect<Serverless.FunctionListener>[] = [];
+    const exports: Record<string, any> = {};
+    const env: Record<string, any> = {};
+
+    const ctx = {
+      Type: WorkerTypeId,
+      id,
+      env,
+      get: (key: string) =>
+        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);
+              if (!Redacted.isRedacted(value)) {
+                return Redacted.make(value.value);
+              }
+              return value;
+            } catch {
+              return json;
             }
-            return value;
-          } catch {
-            return json;
-          }
+          }),
+        ) as any,
+      set: (id: string, output: Output.Output) =>
+        Effect.sync(() => {
+          const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          env[key] = output.pipe(
+            Output.map((value) =>
+              Redacted.isRedacted(value)
+                ? JSON.stringify({
+                    _tag: "Redacted",
+                    value: Redacted.value(value),
+                  })
+                : JSON.stringify(value),
+            ),
+          );
+          return key;
         }),
-      ) as any,
-    set: (id: string, output: Output.Output) =>
-      Effect.sync(() => {
-        const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(
-          Output.map((value) =>
-            Redacted.isRedacted(value)
-              ? JSON.stringify({
-                  _tag: "Redacted",
-                  value: Redacted.value(value),
-                })
-              : JSON.stringify(value),
-          ),
-        );
-        return key;
-      }),
-    serve: <Req = never>(handler: HttpEffect<Req>) =>
-      ctx.listen(workersHttpHandler(handler)),
-    listen: ((
-      handler:
-        | Serverless.FunctionListener
-        | Effect.Effect<Serverless.FunctionListener>,
-    ) =>
-      Effect.sync(() =>
-        Effect.isEffect(handler)
-          ? listeners.push(handler)
-          : listeners.push(Effect.succeed(handler)),
-      )) as any as Serverless.FunctionContext["listen"],
-    export: (name: string, value: any) =>
-      Effect.sync(() => {
-        exports[name] = value;
-      }),
-    exports: Effect.gen(function* () {
-      const handlers = yield* Effect.all(listeners, {
-        concurrency: "unbounded",
-      });
-      const handle =
-        (type: WorkerEvent["type"]) =>
-        (request: any, env: unknown, context: cf.ExecutionContext) => {
-          const event: WorkerEvent = {
-            kind: "Cloudflare.Workers.WorkerEvent",
-            type,
-            input: request,
-            env,
-            context,
-          };
-          for (const handler of handlers) {
-            const eff = handler(event);
-            if (Effect.isEffect(eff)) {
-              return eff.pipe(
-                Effect.provide(Layer.succeed(ExecutionContext, context)),
-                Effect.runPromise,
-              );
+      serve: <Req = never>(handler: HttpEffect<Req>) =>
+        ctx.listen(workersHttpHandler(handler)),
+      listen: ((
+        handler:
+          | Serverless.FunctionListener
+          | Effect.Effect<Serverless.FunctionListener>,
+      ) =>
+        Effect.sync(() =>
+          Effect.isEffect(handler)
+            ? listeners.push(handler)
+            : listeners.push(Effect.succeed(handler)),
+        )) as any as Serverless.FunctionContext["listen"],
+      export: (name: string, value: any) =>
+        Effect.sync(() => {
+          exports[name] = value;
+        }),
+      exports: Effect.gen(function* () {
+        const handlers = yield* Effect.all(listeners, {
+          concurrency: "unbounded",
+        });
+        const handle =
+          (type: WorkerEvent["type"]) =>
+          (request: any, env: unknown, context: cf.ExecutionContext) => {
+            const event: WorkerEvent = {
+              kind: "Cloudflare.Workers.WorkerEvent",
+              type,
+              input: request,
+              env,
+              context,
+            };
+            for (const handler of handlers) {
+              const eff = handler(event);
+              if (Effect.isEffect(eff)) {
+                return eff.pipe(
+                  Effect.provide(Layer.succeed(ExecutionContext, context)),
+                  Effect.runPromise,
+                );
+              }
             }
-          }
-          return Promise.reject(new Error("No event handler found"));
+            return Promise.reject(new Error("No event handler found"));
+          };
+        return {
+          ...exports,
+          default: Object.fromEntries(
+            ExportedHandlerMethods.map((method) => [method, handle(method)]),
+          ),
         };
-      return {
-        ...exports,
-        default: Object.fromEntries(
-          ExportedHandlerMethods.map((method) => [method, handle(method)]),
-        ),
-      };
-    }),
-  };
-  return ctx;
+      }),
+    };
+    return ctx;
+  },
 });
 
 export const bindWorker = Effect.fnUntraced(function* <Shape, Req = never>(

package/src/Cloudflare/Workers/index.ts

@@ -4,6 +4,7 @@ export * from "./DurableObject.ts";
 export * from "./DynamicWorker.ts";
 export * from "./Fetch.ts";
 export * from "./HttpServer.ts";
+export * from "./InferEnv.ts";
 export * from "./Request.ts";
 export * from "./Rpc.ts";
 export * from "./WebSocket.ts";

package/src/Cloudflare/index.ts

@@ -1,8 +1,8 @@
 export * from "./Container.ts";
 export * from "./D1/index.ts";
-export * as KV from "./KV/index.ts";
+export * from "./KV/index.ts";
 export * from "./Providers.ts";
-export * as R2 from "./R2/index.ts";
+export * from "./R2/index.ts";
 export * from "./StageConfig.ts";
 export * from "./Website/index.ts";
 export * from "./Workers/index.ts";

package/src/Plan.ts

@@ -148,8 +148,13 @@ export type Plan<Output = any> = {
   output: Output;
 };
 
+export interface MakePlanOptions {
+  force?: boolean;
+}
+
 export const make = <A>(
   stack: StackSpec<A>,
+  options: MakePlanOptions = {},
 ): Effect.Effect<Plan<A>, never, State> =>
   // @ts-expect-error
   ensureArtifactStore(
@@ -486,6 +491,13 @@ export const make = <A>(
                           : "noop",
                     } as UpdateDiff | NoopDiff),
                 ),
+                Effect.map((diff) =>
+                  options.force && diff.action === "noop"
+                    ? ({
+                        action: "update",
+                      } satisfies UpdateDiff)
+                    : diff,
+                ),
               );
 
               if (oldState.status === "creating") {

package/src/Platform.ts

@@ -23,7 +23,6 @@ import { Self } from "./Self.ts";
 import type { Stack, StackServices } from "./Stack.ts";
 import type { Stage } from "./Stage.ts";
 import { effectClass } from "./Util/effect.ts";
-import type { IsAny } from "./Util/types.ts";
 
 export interface PlatformProps {
   /**
@@ -85,7 +84,6 @@ export interface Platform<
         | Exclude<PropsReq | InitReq, Services | PlatformServices>
       >;
       new (_: never): MakeShape<Shape, BaseShape>;
-      promise(): PlatformPromise<Self>;
       of(shape: Shape & MainShape): MakeShape<Shape, BaseShape>;
     };
   };
@@ -108,7 +106,6 @@ export interface Platform<
       | Exclude<InitReq, Services | PlatformServices>
     > & {
       new (_: never): MakeShape<Shape, BaseShape>;
-      promise(): PlatformPromise<Self>;
     };
     <Shape, PropsReq = never>(
       id: string,
@@ -129,7 +126,6 @@ export interface Platform<
         | Exclude<PropsReq | InitReq, Services | PlatformServices>
       >;
       new (_: never): MakeShape<Shape, BaseShape>;
-      promise(): PlatformPromise<Self>;
     } & (<InitReq extends Services | PlatformServices = never>(
         impl: Effect.Effect<Shape, never, InitReq>,
       ) => Effect.Effect<
@@ -140,18 +136,18 @@ export interface Platform<
         | Exclude<InitReq, Services | PlatformServices>
       >);
   };
-  <PropsReq = never, InitReq extends Services | PlatformServices = never>(
-    id: string,
-    props:
-      | InputProps<Resource["Props"]>
-      | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
-  ): Effect.Effect<
-    Resource,
-    never,
-    | Provider<Resource>
-    | PropsReq
-    | Exclude<InitReq, Services | PlatformServices>
-  >;
+  // <PropsReq = never, InitReq extends Services | PlatformServices = never>(
+  //   id: string,
+  //   props:
+  //     | InputProps<Resource["Props"]>
+  //     | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
+  // ): Effect.Effect<
+  //   Resource,
+  //   never,
+  //   | Provider<Resource>
+  //   | PropsReq
+  //   | Exclude<InitReq, Services | PlatformServices>
+  // >;
   <
     Shape extends MainShape,
     PropsReq = never,
@@ -168,9 +164,7 @@ export interface Platform<
     | Provider<Resource>
     | PropsReq
     | Exclude<InitReq, Services | PlatformServices>
-  > & {
-    promise(): PlatformPromise<Shape>;
-  };
+  >;
 }
 
 type MakeShape<Shape, BaseShape> = Shape extends never | undefined | void
@@ -188,7 +182,10 @@ export const Platform = <
   >,
 >(
   type: R["Type"],
-  createExecutionContext: (id: string) => BaseExecutionContext,
+  hooks: {
+    createExecutionContext: (id: string) => BaseExecutionContext;
+    onCreate?: (resource: R, props: any) => Effect.Effect<void>;
+  },
 ): any => {
   type Props = any;
   type Impl = Effect.Effect<any>;
@@ -213,7 +210,7 @@ export const Platform = <
     } else if (!impl) {
       const cls = makeClass(id, props);
       const asEffect = () =>
-        !isTag
+        (!isTag
           ? // this is a non-tagged resource yielded without providing an implementation
             // e.g.
             // yield* Cloudflare.Worker("id", { main: "./src/worker.ts" })
@@ -236,7 +233,15 @@ export const Platform = <
                 onNone: () => resource(id, props),
                 onSome: Effect.succeed,
               }),
-            );
+            )
+        ).pipe(
+          Effect.flatMap(
+            (resource) =>
+              hooks
+                .onCreate?.(resource as R, props)
+                .pipe(Effect.map(() => resource)) ?? Effect.succeed(resource),
+          ),
+        );
       return Object.assign(
         function (impl: Impl) {
           return cls.asEffect().pipe(Effect.provide(cls.make(impl)));
@@ -249,6 +254,8 @@ export const Platform = <
         cls,
         {
           asEffect,
+          // @ts-expect-error
+          pipe: (...args: any[]) => asEffect().pipe(...args),
           [Symbol.iterator]: () => new SingleShotGen({ asEffect }),
         },
       );
@@ -289,7 +296,7 @@ export const Platform = <
           Effect.flatMap(
             Effect.all([
               Effect.isEffect(props) ? props : Effect.succeed(props ?? {}),
-              Effect.sync(() => createExecutionContext(id)),
+              Effect.sync(() => hooks.createExecutionContext(id)),
               Effect.services<never>(),
             ]),
             Effect.fnUntraced(function* ([
@@ -298,7 +305,15 @@ export const Platform = <
               outerServices,
             ]) {
               const instance = Object.assign(
-                yield* resource(id, props as any),
+                yield* resource(id, props as any).pipe(
+                  Effect.flatMap(
+                    (resource) =>
+                      hooks
+                        .onCreate?.(resource, props)
+                        .pipe(Effect.map(() => resource)) ??
+                      Effect.succeed(resource),
+                  ),
+                ),
                 executionContext,
               );
 
@@ -365,34 +380,3 @@ export const Platform = <
   }) as any;
   return instance;
 };
-
-/**
- * Bridge between the Effect and the Promise.
- *
- * Only map types if needed.
- *
- * TODO(sam): probably over engineering? Maybe just let the user run into the wall of Effect.runPromise and fix? Good friction is good!
- */
-export type PlatformPromise<Shape> = [
-  HasRequirements<Extract<Shape[keyof Shape], Effect.Effect<any, any, any>>>,
-  Effect.Services<Extract<Shape[keyof Shape], Effect.Effect<any, any, any>>>,
-] extends [true, never]
-  ? Promise<Shape>
-  : Promise<{
-      [key in keyof Shape]: Shape[key] extends (
-        ...args: infer Args
-      ) => Effect.Effect<infer A, infer Err, any>
-        ? (...args: Args) => Effect.Effect<A, Err, never>
-        : Shape[key] extends Effect.Effect<infer A, infer Err, infer Req>
-          ? Req extends never
-            ? Shape[key]
-            : Effect.Effect<A, Err, never>
-          : Shape[key];
-    }>;
-
-type HasRequirements<E extends Effect.Effect<any, any, any>> =
-  IsAny<Effect.Services<E>> extends true
-    ? true
-    : Effect.Services<E> extends never
-      ? false
-      : true;

package/src/Test/Vitest.ts

@@ -148,7 +148,10 @@ const deriveStackName = (testPath: string, suffix: string) => {
 const runWithContext = <A, Err>(
   stackName: string,
   effect: Effect.Effect<A, Err, Provided>,
-  options: { state?: Layer.Layer<State.State, never, Stack.Stack> } = {},
+  options: {
+    state?: Layer.Layer<State.State, never, Stack.Stack>;
+    providers?: boolean;
+  } = {},
 ): Effect.Effect<
   A,
   aws.Credentials.CredentialsError | Config.ConfigError | Err,
@@ -194,7 +197,9 @@ const runWithContext = <A, Err>(
   }).pipe(
     Effect.provide(
       Layer.provideMerge(
-        Layer.mergeAll(awsProviders, cfProviders),
+        options.providers === false
+          ? Layer.empty
+          : Layer.mergeAll(awsProviders, cfProviders),
         Layer.provideMerge(alchemy, platform),
       ),
     ),
@@ -216,6 +221,7 @@ export function test(
   options: {
     timeout?: number;
     state?: Layer.Layer<State.State, never, Stack.Stack>;
+    providers?: boolean;
   },
   testCase: Effect.Effect<void, any, Provided>,
 ): void;
@@ -232,6 +238,7 @@ export function test(
         {
           timeout?: number;
           state?: Layer.Layer<State.State, never, Stack.Stack>;
+          providers?: boolean;
         },
         Effect.Effect<void, any, Provided>,
       ]
@@ -253,6 +260,7 @@ export namespace test {
     options: {
       timeout?: number;
       state?: Layer.Layer<State.State, never, Stack.Stack>;
+      providers?: boolean;
     },
     testCase: Effect.Effect<void, any, Provided>,
   ): void;
@@ -269,6 +277,7 @@ export namespace test {
           {
             timeout?: number;
             state?: Layer.Layer<State.State, never, Stack.Stack>;
+            providers?: boolean;
           },
           Effect.Effect<void, any, Provided>,
         ]
@@ -287,6 +296,7 @@ export namespace test {
             {
               timeout?: number;
               state?: Layer.Layer<State.State, never, Stack.Stack>;
+              providers?: boolean;
             },
             Effect.Effect<void, any, Provided>,
           ]
@@ -436,6 +446,7 @@ export function skip(
   options: {
     timeout?: number;
     state?: Layer.Layer<State.State, never, Stack.Stack>;
+    providers?: boolean;
   },
   testCase: Effect.Effect<void, any, Provided>,
 ): void;
@@ -452,6 +463,7 @@ export function skip(
         {
           timeout?: number;
           state?: Layer.Layer<State.State, never, Stack.Stack>;
+          providers?: boolean;
         },
         Effect.Effect<void, any, Provided>,
       ]
@@ -470,6 +482,7 @@ export function skipIf(condition: boolean) {
           {
             timeout?: number;
             state?: Layer.Layer<State.State, never, Stack.Stack>;
+            providers?: boolean;
           },
           Effect.Effect<void, any, Provided>,
         ]

package/src/Util/effect.ts

@@ -55,3 +55,27 @@ export const taggedFunction = <
     },
     toString: () => `${tag.toString()}.${fn.name}`,
   });
+
+export type UnwrapEffect<T> =
+  T extends Effect.Effect<infer A, any, any> ? A : T;
+
+export type ToEffectInterface<T> = {
+  raw: T;
+} & {
+  [K in keyof T]: T[K] extends (...args: any[]) => any
+    ? (...args: Parameters<T[K]>) => Effect.Effect<Awaited<ReturnType<T[K]>>>
+    : T[K];
+};
+
+export const toEffectInterface = <T extends object>(raw: T) =>
+  ({
+    raw,
+    ...Object.fromEntries(
+      Object.entries(raw).map(([key, value]) => [
+        key,
+        typeof value === "function"
+          ? (...args: any[]) => Effect.tryPromise(async () => value(...args))
+          : value,
+      ]),
+    ),
+  }) as ToEffectInterface<T>;