alchemy-effect 0.7.0 → 0.8.0

package/bin/alchemy-effect.ts

@@ -93,6 +93,13 @@ const yes = Flag.boolean("yes").pipe(
   Flag.withDefault(false),
 );
 
+const force = Flag.boolean("force").pipe(
+  Flag.withDescription(
+    "Force updates for resources that would otherwise no-op",
+  ),
+  Flag.withDefault(false),
+);
+
 const fileLogger = Effect.fnUntraced(function* (
   ...segments: ReadonlyArray<string>
 ) {
@@ -142,6 +149,7 @@ const deployCommand = Command.make(
   "deploy",
   {
     dryRun,
+    force,
     main,
     envFile,
     stage,
@@ -186,6 +194,7 @@ const execStack = Effect.fn(function* ({
   stage,
   envFile,
   dryRun = false,
+  force = false,
   yes = false,
   destroy = false,
 }: {
@@ -193,6 +202,7 @@ const execStack = Effect.fn(function* ({
   stage: string;
   envFile: Option.Option<string>;
   dryRun?: boolean;
+  force?: boolean;
   yes?: boolean;
   destroy?: boolean;
 }) {
@@ -244,6 +254,7 @@ const execStack = Effect.fn(function* ({
                 output: {},
               }
             : stack,
+          { force },
         );
         if (dryRun) {
           yield* cli.displayPlan(updatePlan);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy-effect",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",

package/src/AWS/AutoScaling/LaunchTemplate.ts

@@ -162,10 +162,11 @@ export const LaunchTemplate: Platform<
   LaunchTemplateServices,
   LaunchTemplateShape,
   LaunchTemplateExecutionContext
-> = Platform(
-  "AWS.AutoScaling.LaunchTemplate",
-  createEc2HostExecutionContext("AWS.AutoScaling.LaunchTemplate"),
-);
+> = Platform("AWS.AutoScaling.LaunchTemplate", {
+  createExecutionContext: createEc2HostExecutionContext(
+    "AWS.AutoScaling.LaunchTemplate",
+  ),
+});
 
 export const LaunchTemplateProvider = () =>
   LaunchTemplate.provider.effect(

package/src/AWS/EC2/Instance.ts

@@ -304,10 +304,9 @@ export const Instance: Platform<
   InstanceServices,
   InstanceShape,
   InstanceExecutionContext
-> = Platform(
-  "AWS.EC2.Instance",
-  createEc2HostExecutionContext("AWS.EC2.Instance"),
-);
+> = Platform("AWS.EC2.Instance", {
+  createExecutionContext: createEc2HostExecutionContext("AWS.EC2.Instance"),
+});
 
 export const InstanceProvider = () =>
   Instance.provider.effect(

package/src/AWS/ECS/Task.ts

@@ -174,43 +174,45 @@ export const Task: Platform<
   TaskServices,
   TaskShape,
   TaskExecutionContext
-> = Platform("AWS.ECS.Task", (id): TaskExecutionContext => {
-  const runners: Effect.Effect<void, never, any>[] = [];
-  const env: Record<string, any> = {};
-
-  return {
-    Type: "AWS.ECS.Task",
-    id,
-    env,
-    set: (bindingId: string, output: Output.Output) =>
-      Effect.sync(() => {
-        const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
-        return key;
-      }),
-    get: <T>(key: string) =>
-      Config.string(key)
-        .asEffect()
-        .pipe(
-          Effect.flatMap((value) =>
-            Effect.try({
-              try: () => JSON.parse(value) as T,
-              catch: (error) => error as Error,
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
+> = Platform("AWS.ECS.Task", {
+  createExecutionContext: (id): TaskExecutionContext => {
+    const runners: Effect.Effect<void, never, any>[] = [];
+    const env: Record<string, any> = {};
+
+    return {
+      Type: "AWS.ECS.Task",
+      id,
+      env,
+      set: (bindingId: string, output: Output.Output) =>
+        Effect.sync(() => {
+          const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          return key;
+        }),
+      get: <T>(key: string) =>
+        Config.string(key)
+          .asEffect()
+          .pipe(
+            Effect.flatMap((value) =>
+              Effect.try({
+                try: () => JSON.parse(value) as T,
+                catch: (error) => error as Error,
               }),
             ),
+            Effect.catch((cause) =>
+              Effect.die(
+                new Error(`Failed to get environment variable: ${key}`, {
+                  cause,
+                }),
+              ),
+            ),
           ),
-        ),
-    run: (effect: Effect.Effect<void, never, any>) =>
-      Effect.sync(() => {
-        runners.push(effect);
-      }),
-  };
+      run: (effect: Effect.Effect<void, never, any>) =>
+        Effect.sync(() => {
+          runners.push(effect);
+        }),
+    };
+  },
 });
 
 export const TaskProvider = () =>

package/src/AWS/Lambda/Function.ts

@@ -9,7 +9,6 @@ import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
-import * as Path from "effect/Path";
 import * as Schedule from "effect/Schedule";
 import * as ServiceMap from "effect/ServiceMap";
 import * as Stream from "effect/Stream";
@@ -139,76 +138,78 @@ export const Function: Platform<
   FunctionServices,
   FunctionShape,
   Serverless.FunctionContext
-> = Platform(FunctionTypeId, (id: string): Serverless.FunctionContext => {
-  const listeners: Effect.Effect<Serverless.FunctionListener>[] = [];
-  const env: Record<string, any> = {};
-
-  const ctx = {
-    Type: FunctionTypeId,
-    id,
-    env,
-    set: (id: string, output: Output.Output) =>
-      Effect.sync(() => {
-        const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
-        return key;
-      }),
-    get: <T>(key: string) =>
-      Config.string(key)
-        .asEffect()
-        .pipe(
-          Effect.flatMap((val) =>
-            Effect.try({
-              try: () => JSON.parse(val) as T,
-              catch: () => val, // assume it's just a string
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
+> = Platform(FunctionTypeId, {
+  createExecutionContext: (id: string): Serverless.FunctionContext => {
+    const listeners: Effect.Effect<Serverless.FunctionListener>[] = [];
+    const env: Record<string, any> = {};
+
+    const ctx = {
+      Type: FunctionTypeId,
+      id,
+      env,
+      set: (id: string, output: Output.Output) =>
+        Effect.sync(() => {
+          const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          return key;
+        }),
+      get: <T>(key: string) =>
+        Config.string(key)
+          .asEffect()
+          .pipe(
+            Effect.flatMap((val) =>
+              Effect.try({
+                try: () => JSON.parse(val) as T,
+                catch: () => val, // assume it's just a string
               }),
             ),
+            Effect.catch((cause) =>
+              Effect.die(
+                new Error(`Failed to get environment variable: ${key}`, {
+                  cause,
+                }),
+              ),
+            ),
           ),
-        ),
-    serve: (handler: HttpEffect) =>
-      ctx.listen(makeFunctionHttpHandler(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"],
-    exports: Effect.sync(() => ({
-      // construct an Effect that produces the Function's entrypoint
-      // Effect<(event, context) => Promise<any>>
-      handler: Effect.map(
-        Effect.all(listeners, {
-          concurrency: "unbounded",
-        }),
-        (handlers) =>
-          async (event: any, context: lambda.Context): Promise<any> => {
-            console.log({ event, handlers });
-            for (const handler of handlers) {
-              const eff = handler(event);
-              if (Effect.isEffect(eff)) {
-                return await eff.pipe(
-                  Effect.provideService(HandlerContext, context),
-                  Effect.tap(Effect.logDebug),
-                  Effect.runPromise,
-                );
+      serve: (handler: HttpEffect) =>
+        ctx.listen(makeFunctionHttpHandler(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"],
+      exports: Effect.sync(() => ({
+        // construct an Effect that produces the Function's entrypoint
+        // Effect<(event, context) => Promise<any>>
+        handler: Effect.map(
+          Effect.all(listeners, {
+            concurrency: "unbounded",
+          }),
+          (handlers) =>
+            async (event: any, context: lambda.Context): Promise<any> => {
+              console.log({ event, handlers });
+              for (const handler of handlers) {
+                const eff = handler(event);
+                if (Effect.isEffect(eff)) {
+                  return await eff.pipe(
+                    Effect.provideService(HandlerContext, context),
+                    Effect.tap(Effect.logDebug),
+                    Effect.runPromise,
+                  );
+                }
               }
-            }
-            throw new Error("No event handler found");
-          },
-      ),
-    })),
-  };
-  return ctx;
+              throw new Error("No event handler found");
+            },
+        ),
+      })),
+    };
+    return ctx;
+  },
 });
 
 export const FunctionProvider = () =>
@@ -218,7 +219,6 @@ export const FunctionProvider = () =>
       const accountId = yield* Account;
       const region = yield* Region;
       const fs = yield* FileSystem.FileSystem;
-      const path = yield* Path.Path;
       const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
       const alchemyEnv = {
         ALCHEMY_STACK_NAME: stack.name,

package/src/Binding.ts

@@ -28,15 +28,22 @@ export interface Service<
   extends ServiceMap.Service<Self, Shape>, ServiceLike {
   readonly key: Identifier;
   new (_: never): ServiceShape<Identifier, Shape>;
-  bind: (
-    ...args: Parameters<Shape>
+  bind: <Req = never>(
+    ...args: BindParameters<Parameters<Shape>, Req>
   ) => Effect.Effect<
     Effect.Success<ReturnType<Shape>>,
     Effect.Error<ReturnType<Shape>>,
-    Self | Effect.Services<ReturnType<Shape>>
+    Self | Effect.Services<ReturnType<Shape>> | Req
   >;
 }
 
+type BindParameters<
+  Parameters extends any[],
+  Req = never,
+> = Parameters extends [infer First, ...infer Rest]
+  ? [First | Effect.Effect<First, never, Req>, ...BindParameters<Rest, Req>]
+  : [];
+
 /**
  * Creates a runtime binding service.
  *

package/src/Cloudflare/Container.ts

@@ -268,80 +268,82 @@ export const Container: Platform<
   ContainerShape,
   Server.ProcessContext,
   Container
-> = Platform("Cloudflare.Container", (id: string): Server.ProcessContext => {
-  const runners: Effect.Effect<void, never, any>[] = [];
-  const env: Record<string, any> = {};
+> = Platform("Cloudflare.Container", {
+  createExecutionContext: (id: string): Server.ProcessContext => {
+    const runners: Effect.Effect<void, never, any>[] = [];
+    const env: Record<string, any> = {};
 
-  const serve = <Req = never>(handler: HttpEffect<Req>) =>
-    Effect.sync(() => {
-      runners.push(
-        Effect.gen(function* () {
-          const httpServer = yield* Effect.serviceOption(HttpServer).pipe(
-            Effect.map(Option.getOrUndefined),
-          );
-          if (httpServer) {
-            yield* httpServer.serve(handler);
-            yield* Effect.never;
-          } else {
-            // this should only happen at plantime, validate?
-          }
-        }).pipe(Effect.orDie),
-      );
-    });
-
-  return {
-    Type: ContainerTypeId,
-    LogicalId: id,
-    id,
-    env,
-    set: (bindingId: string, output: Output.Output) =>
+    const serve = <Req = never>(handler: HttpEffect<Req>) =>
       Effect.sync(() => {
-        const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
-        return key;
-      }),
-    get: <T>(key: string) =>
-      Config.string(key)
-        .asEffect()
-        .pipe(
-          Effect.flatMap((value) =>
-            Effect.try({
-              try: () => JSON.parse(value) as T,
-              catch: (error) => error as Error,
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
+        runners.push(
+          Effect.gen(function* () {
+            const httpServer = yield* Effect.serviceOption(HttpServer).pipe(
+              Effect.map(Option.getOrUndefined),
+            );
+            if (httpServer) {
+              yield* httpServer.serve(handler);
+              yield* Effect.never;
+            } else {
+              // this should only happen at plantime, validate?
+            }
+          }).pipe(Effect.orDie),
+        );
+      });
+
+    return {
+      Type: ContainerTypeId,
+      LogicalId: id,
+      id,
+      env,
+      set: (bindingId: string, output: Output.Output) =>
+        Effect.sync(() => {
+          const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          return key;
+        }),
+      get: <T>(key: string) =>
+        Config.string(key)
+          .asEffect()
+          .pipe(
+            Effect.flatMap((value) =>
+              Effect.try({
+                try: () => JSON.parse(value) as T,
+                catch: (error) => error as Error,
               }),
             ),
+            Effect.catch((cause) =>
+              Effect.die(
+                new Error(`Failed to get environment variable: ${key}`, {
+                  cause,
+                }),
+              ),
+            ),
           ),
-        ),
-    run: ((effect: Effect.Effect<void, never, any>) =>
-      Effect.sync(() => {
-        runners.push(effect);
-      })) as unknown as Server.ProcessContext["run"],
-    serve,
-    exports: Effect.sync(() => ({
-      default: Effect.all(
-        runners.map((eff) =>
-          Effect.forever(
-            eff.pipe(
-              // Log and ignore errors (daemon mode, it should just re-run)
-              Effect.tapError((err) => Effect.logError(err)),
-              Effect.ignore,
-              // TODO(sam): ignore cause? for now, let that actually kill the server
-              // Effect.ignoreCause
+      run: ((effect: Effect.Effect<void, never, any>) =>
+        Effect.sync(() => {
+          runners.push(effect);
+        })) as unknown as Server.ProcessContext["run"],
+      serve,
+      exports: Effect.sync(() => ({
+        default: Effect.all(
+          runners.map((eff) =>
+            Effect.forever(
+              eff.pipe(
+                // Log and ignore errors (daemon mode, it should just re-run)
+                Effect.tapError((err) => Effect.logError(err)),
+                Effect.ignore,
+                // TODO(sam): ignore cause? for now, let that actually kill the server
+                // Effect.ignoreCause
+              ),
             ),
           ),
+          {
+            concurrency: "unbounded",
+          },
         ),
-        {
-          concurrency: "unbounded",
-        },
-      ),
-    })),
-  } as Server.ProcessContext;
+      })),
+    } as Server.ProcessContext;
+  },
 });
 
 export const bindContainer = Effect.fnUntraced(function* <Shape, Req = never>(
@@ -637,7 +639,6 @@ export const ContainerProvider = () =>
       });
 
       const bundleProgram = Effect.fnUntraced(function* ({
-        id,
         main,
         runtime,
         handler = "default",

package/src/Cloudflare/D1/D1Database.ts

@@ -123,6 +123,38 @@ export const DatabaseProvider = (): Layer<
             return { action: "update" } as const;
           }
         }),
+        read: Effect.fn(function* ({ id, output, olds }) {
+          if (output?.databaseId) {
+            return yield* getDb({
+              accountId: output.accountId,
+              databaseId: output.databaseId,
+            }).pipe(
+              Effect.map((db) => ({
+                databaseId: db.uuid ?? output.databaseId,
+                databaseName: db.name ?? output.databaseName,
+                jurisdiction: output.jurisdiction,
+                readReplication: db.readReplication ?? undefined,
+                accountId: output.accountId,
+              })),
+              Effect.catchTag("DatabaseNotFound", () =>
+                Effect.succeed(undefined),
+              ),
+            );
+          }
+          const name = yield* createDatabaseName(id, olds?.name);
+          const dbs = yield* listDbs({ accountId, name });
+          const match = dbs.result.find((db) => db.name === name);
+          if (match) {
+            return {
+              databaseId: match.uuid!,
+              databaseName: match.name ?? name,
+              jurisdiction: (olds?.jurisdiction ?? "default") as Jurisdiction,
+              readReplication: olds?.readReplication,
+              accountId,
+            };
+          }
+          return undefined;
+        }),
         create: Effect.fn(function* ({ id, news = {} }) {
           const name = yield* createDatabaseName(id, news.name);
           const jurisdiction = news.jurisdiction ?? "default";
@@ -185,38 +217,6 @@ export const DatabaseProvider = (): Layer<
             databaseId: output.databaseId,
           }).pipe(Effect.catchTag("DatabaseNotFound", () => Effect.void));
         }),
-        read: Effect.fn(function* ({ id, output, olds }) {
-          if (output?.databaseId) {
-            return yield* getDb({
-              accountId: output.accountId,
-              databaseId: output.databaseId,
-            }).pipe(
-              Effect.map((db) => ({
-                databaseId: db.uuid ?? output.databaseId,
-                databaseName: db.name ?? output.databaseName,
-                jurisdiction: output.jurisdiction,
-                readReplication: db.readReplication ?? undefined,
-                accountId: output.accountId,
-              })),
-              Effect.catchTag("DatabaseNotFound", () =>
-                Effect.succeed(undefined),
-              ),
-            );
-          }
-          const name = yield* createDatabaseName(id, olds?.name);
-          const dbs = yield* listDbs({ accountId, name });
-          const match = dbs.result.find((db) => db.name === name);
-          if (match) {
-            return {
-              databaseId: match.uuid!,
-              databaseName: match.name ?? name,
-              jurisdiction: (olds?.jurisdiction ?? "default") as Jurisdiction,
-              readReplication: olds?.readReplication,
-              accountId,
-            };
-          }
-          return undefined;
-        }),
       };
     }),
   );

package/src/Cloudflare/KV/Delete.ts

@@ -3,12 +3,14 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export class Delete extends Binding.Service<
   Delete,
-  (namespace: Namespace) => Effect.Effect<(key: string) => Effect.Effect<void>>
+  (
+    namespace: KVNamespace,
+  ) => Effect.Effect<(key: string) => Effect.Effect<void>>
 >()("Cloudflare.KV.Delete") {}
 
 export const DeleteLive = Layer.effect(
@@ -17,7 +19,7 @@ export const DeleteLive = Layer.effect(
     const Policy = yield* DeletePolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -32,7 +34,7 @@ export const DeleteLive = Layer.effect(
 
 export class DeletePolicy extends Binding.Policy<
   DeletePolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.Delete") {}
 
 export const DeletePolicyLive = DeletePolicy.layer.succeed(NamespaceBinding);

package/src/Cloudflare/KV/Get.ts

@@ -3,13 +3,13 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
-import type { Namespace } from "./Namespace.ts";
-import { NamespaceBinding } from "./NamespaceBinding.ts";
+import type { KVNamespace } from "./KVNamespace.ts";
+import { NamespaceBinding } from "./KVNamespaceBinding.ts";
 
 export class Get extends Binding.Service<
   Get,
   (
-    namespace: Namespace,
+    namespace: KVNamespace,
   ) => Effect.Effect<(key: string) => Effect.Effect<string | null>>
 >()("Cloudflare.KV.Get") {}
 
@@ -19,7 +19,7 @@ export const GetLive = Layer.effect(
     const Policy = yield* GetPolicy;
     const env = yield* WorkerEnvironment;
 
-    return Effect.fn(function* (namespace: Namespace) {
+    return Effect.fn(function* (namespace: KVNamespace) {
       yield* Policy(namespace);
       const kvNamespace = (env as Record<string, runtime.KVNamespace>)[
         namespace.LogicalId
@@ -34,7 +34,7 @@ export const GetLive = Layer.effect(
 
 export class GetPolicy extends Binding.Policy<
   GetPolicy,
-  (namespace: Namespace) => Effect.Effect<void>
+  (namespace: KVNamespace) => Effect.Effect<void>
 >()("Cloudflare.KV.Get") {}
 
 export const GetPolicyLive = GetPolicy.layer.succeed(NamespaceBinding);