alchemy-effect 0.2.0 → 0.4.0

package/src/aws/ec2/vpc.provider.ts

@@ -1,64 +1,54 @@
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, type ProviderService } from "alchemy-effect";
-import type { ScopedPlanStatusSession } from "../../apply.ts";
-import { createTagger, createTagsList } from "../../tags.ts";
+import type { EC2 } from "itty-aws/ec2";
+
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
+import { somePropsAreDifferent } from "../../diff.ts";
+import type { ProviderService } from "../../provider.ts";
+import { createTagger, createTagsList, diffTags } from "../../tags.ts";
 import { Account } from "../account.ts";
 import { Region } from "../region.ts";
 import { EC2Client } from "./client.ts";
+import type { VpcId } from "./vpc.ts";
 import { Vpc, type VpcAttrs, type VpcProps } from "./vpc.ts";
 
-import type { EC2 } from "itty-aws/ec2";
-
 export const vpcProvider = () =>
   Vpc.provider.effect(
     Effect.gen(function* () {
       const ec2 = yield* EC2Client;
-      const app = yield* App;
       const region = yield* Region;
       const accountId = yield* Account;
       const tagged = yield* createTagger();
 
-      return {
-        diff: Effect.fn(function* ({ id, news, olds }) {
-          // 1. CIDR block changes
-          if (olds.cidrBlock !== news.cidrBlock) {
-            return { action: "replace" } as const;
-          }
-
-          // 2. Instance tenancy changes
-          if (olds.instanceTenancy !== news.instanceTenancy) {
-            return { action: "replace" } as const;
-          }
-
-          // 3. IPAM pool changes
-          if (olds.ipv4IpamPoolId !== news.ipv4IpamPoolId) {
-            return { action: "replace" } as const;
-          }
-
-          if (olds.ipv6IpamPoolId !== news.ipv6IpamPoolId) {
-            return { action: "replace" } as const;
-          }
+      const createTags = (
+        id: string,
+        tags?: Record<string, string>,
+      ): Record<string, string> => ({
+        Name: id,
+        ...tagged(id),
+        ...tags,
+      });
 
-          // 4. IPv6 CIDR block changes
-          if (olds.ipv6CidrBlock !== news.ipv6CidrBlock) {
-            return { action: "replace" } as const;
-          }
-
-          // 5. IPv6 pool changes
-          if (olds.ipv6Pool !== news.ipv6Pool) {
-            return { action: "replace" } as const;
+      return {
+        stables: ["vpcId", "vpcArn", "ownerId", "isDefault"],
+        diff: Effect.fn(function* ({ news, olds }) {
+          if (
+            somePropsAreDifferent(olds, news, [
+              "cidrBlock",
+              "instanceTenancy",
+              "ipv4IpamPoolId",
+              "ipv6IpamPoolId",
+              "ipv6CidrBlock",
+            ])
+          ) {
+            return { action: "replace" };
           }
         }),
-
         create: Effect.fn(function* ({ id, news, session }) {
-          // 1. Prepare tags
-          const alchemyTags = tagged(id);
-          const userTags = news.tags ?? {};
-          const allTags = { ...alchemyTags, ...userTags };
+          const tags = createTags(id, news.tags);
 
-          // 2. Call CreateVpc
+          // 1. Call CreateVpc
           const createResult = yield* ec2.createVpc({
             // TODO(sam): add all properties
             AmazonProvidedIpv6CidrBlock: news.amazonProvidedIpv6CidrBlock,
@@ -75,16 +65,16 @@ export const vpcProvider = () =>
             TagSpecifications: [
               {
                 ResourceType: "vpc",
-                Tags: createTagsList(allTags),
+                Tags: createTagsList(tags),
               },
             ],
             DryRun: false,
           });
 
-          const vpcId = createResult.Vpc!.VpcId!;
+          const vpcId = createResult.Vpc!.VpcId! as VpcId;
           yield* session.note(`VPC created: ${vpcId}`);
 
-          // 3. Modify DNS attributes if specified (separate API calls)
+          // 2. Modify DNS attributes if specified (separate API calls)
           yield* ec2.modifyVpcAttribute({
             VpcId: vpcId,
             EnableDnsSupport: { Value: news.enableDnsSupport ?? true },
@@ -132,10 +122,11 @@ export const vpcProvider = () =>
                 ipv6Pool: assoc.Ipv6Pool,
               }),
             ),
+            tags,
           } satisfies VpcAttrs<VpcProps>;
         }),
 
-        update: Effect.fn(function* ({ news, olds, output, session }) {
+        update: Effect.fn(function* ({ id, news, olds, output, session }) {
           const vpcId = output.vpcId;
 
           // Only DNS and metrics settings can be updated
@@ -157,9 +148,29 @@ export const vpcProvider = () =>
             yield* session.note("Updated DNS hostnames");
           }
 
-          // Note: Tag updates would go here if we support user tag changes
+          // Handle user tag updates
+          const newTags = createTags(id, news.tags);
+          const oldTags = output.tags ?? {};
+          const { removed, upsert } = diffTags(oldTags, newTags);
+          if (removed.length > 0) {
+            yield* ec2.deleteTags({
+              Resources: [vpcId],
+              Tags: removed.map((key) => ({ Key: key })),
+              DryRun: false,
+            });
+          }
+          if (upsert.length > 0) {
+            yield* ec2.createTags({
+              Resources: [vpcId],
+              Tags: upsert,
+              DryRun: false,
+            });
+          }
 
-          return output; // VPC attributes don't change from these updates
+          return {
+            ...output,
+            tags: newTags,
+          }; // VPC attributes don't change from these updates
         }),
 
         delete: Effect.fn(function* ({ output, session }) {
@@ -181,10 +192,7 @@ export const vpcProvider = () =>
                 while: (e) => {
                   // DependencyViolation means there are still dependent resources
                   // This can happen if subnets/IGW are being deleted concurrently
-                  return (
-                    e._tag === "ValidationError" &&
-                    e.message?.includes("DependencyViolation")
-                  );
+                  return e._tag === "DependencyViolation";
                 },
                 schedule: Schedule.exponential(1000, 1.5).pipe(
                   Schedule.intersect(Schedule.recurs(10)), // Try up to 10 times

package/src/aws/ec2/vpc.ts

@@ -1,4 +1,5 @@
 import type * as EC2 from "itty-aws/ec2";
+import type { Input } from "../../input.ts";
 import { Resource } from "../../resource.ts";
 import type { AccountID } from "../account.ts";
 import type { RegionID } from "../region.ts";
@@ -13,7 +14,17 @@ export const Vpc = Resource<{
 export interface Vpc<
   ID extends string = string,
   Props extends VpcProps = VpcProps,
-> extends Resource<"AWS.EC2.VPC", ID, Props, VpcAttrs<Props>> {}
+> extends Resource<
+    "AWS.EC2.VPC",
+    ID,
+    Props,
+    VpcAttrs<Input.Resolve<Props>>,
+    Vpc
+  > {}
+
+export type VpcId = `vpc-${string}`;
+export const VpcId = <const S extends string>(value: S): S & VpcId =>
+  value as S & VpcId;
 
 export interface VpcProps {
   /**
@@ -26,7 +37,7 @@ export interface VpcProps {
   /**
    * The ID of an IPv4 IPAM pool you want to use for allocating this VPC's CIDR.
    */
-  ipv4IpamPoolId?: string;
+  ipv4IpamPoolId?: Input<string>;
 
   /**
    * The netmask length of the IPv4 CIDR you want to allocate to this VPC from an IPAM pool.
@@ -36,7 +47,7 @@ export interface VpcProps {
   /**
    * The ID of an IPv6 IPAM pool which will be used to allocate this VPC an IPv6 CIDR.
    */
-  ipv6IpamPoolId?: string;
+  ipv6IpamPoolId?: Input<string>;
 
   /**
    * The netmask length of the IPv6 CIDR you want to allocate to this VPC from an IPAM pool.
@@ -51,12 +62,12 @@ export interface VpcProps {
   /**
    * The ID of an IPv6 address pool from which to allocate the IPv6 CIDR block.
    */
-  ipv6Pool?: string;
+  ipv6Pool?: Input<string>;
 
   /**
    * The Availability Zone or Local Zone Group name for the IPv6 CIDR block.
    */
-  ipv6CidrBlockNetworkBorderGroup?: string;
+  ipv6CidrBlockNetworkBorderGroup?: Input<string>;
 
   /**
    * The tenancy options for instances launched into the VPC.
@@ -85,14 +96,14 @@ export interface VpcProps {
    * Tags to assign to the VPC.
    * These will be merged with alchemy auto-tags (alchemy::app, alchemy::stage, alchemy::id).
    */
-  tags?: Record<string, string>;
+  tags?: Record<string, Input<string>>;
 }
 
-export interface VpcAttrs<Props extends VpcProps> {
+export interface VpcAttrs<_Props extends VpcProps = VpcProps> {
   /**
    * The ID of the VPC.
    */
-  vpcId: string;
+  vpcId: VpcId;
 
   /**
    * The Amazon Resource Name (ARN) of the VPC.
@@ -149,4 +160,6 @@ export interface VpcAttrs<Props extends VpcProps> {
     networkBorderGroup?: string;
     ipv6Pool?: string;
   }>;
+
+  tags?: Record<string, string>;
 }

package/src/aws/index.ts

@@ -1,4 +1,7 @@
 import * as Layer from "effect/Layer";
+
+// oxlint-disable-next-line no-unused-vars - needed or else provider types are transitively resolved through DynamoDB.Provider<..> lol
+
 import * as ESBuild from "../esbuild.ts";
 import * as Account from "./account.ts";
 import * as Credentials from "./credentials.ts";
@@ -10,45 +13,51 @@ import * as Region from "./region.ts";
 import * as S3 from "./s3.ts";
 import * as SQS from "./sqs/index.ts";
 import * as STS from "./sts.ts";
-// TODO(sam): should this be named?
-export * from "./profile.ts";
 
-export const providers = Layer.mergeAll(
-  Layer.provide(
-    Layer.provideMerge(Lambda.functionProvider(), ESBuild.layer()),
+export { loadProfile, loadSSOCredentials } from "./credentials.ts";
+
+import "./config.ts";
+
+export const resources = () =>
+  Layer.mergeAll(
+    DynamoDB.tableProvider(),
+    EC2.internetGatewayProvider(),
+    EC2.routeProvider(),
+    EC2.routeTableAssociationProvider(),
+    EC2.routeTableProvider(),
+    EC2.subnetProvider(),
+    EC2.vpcProvider(),
+    Lambda.functionProvider(),
+    SQS.queueProvider(),
+  );
+
+export const bindings = () =>
+  Layer.mergeAll(
+    DynamoDB.getItemFromLambdaFunction(),
+    SQS.queueEventSourceProvider(),
+    SQS.sendMessageFromLambdaFunction(),
+  );
+
+export const clients = () =>
+  Layer.mergeAll(
+    DynamoDB.client(),
+    EC2.client(),
+    IAM.client(),
     Lambda.client(),
-  ),
-  Layer.provide(SQS.queueProvider(), SQS.client()),
-  Layer.provide(DynamoDB.tableProvider(), DynamoDB.client()),
-  Layer.provide(EC2.vpcProvider(), EC2.client()),
-);
-
-export const bindings = Layer.mergeAll(
-  //
-  SQS.sendMessageFromLambdaFunction(),
-  SQS.queueEventSourceProvider(),
-  DynamoDB.getItemFromLambdaFunction(),
-);
-
-export const clients = Layer.mergeAll(
-  STS.client(),
-  IAM.client(),
-  S3.client(),
-  SQS.client(),
-  Lambda.client(),
-  DynamoDB.client(),
-  EC2.client(),
-);
-
-export const defaultProviders = providers.pipe(
-  Layer.provideMerge(bindings),
-  Layer.provideMerge(Account.fromIdentity()),
-  Layer.provideMerge(clients),
-);
-
-export const live = defaultProviders.pipe(
-  Layer.provide(Region.fromEnv()),
-  Layer.provide(Credentials.fromSSO()),
-);
-
-export default live;
+    S3.client(),
+    SQS.client(),
+    // STS.client(),
+  );
+
+export const utils = () => Layer.mergeAll(ESBuild.layer());
+
+export const providers = () =>
+  resources().pipe(
+    Layer.provideMerge(bindings()),
+    Layer.provideMerge(clients()),
+    Layer.provideMerge(utils()),
+    Layer.provideMerge(Account.fromStageConfig()),
+    Layer.provideMerge(STS.client()),
+    Layer.provideMerge(Region.fromStageConfig()),
+    Layer.provideMerge(Credentials.fromStageConfig()),
+  );

package/src/aws/lambda/consume.ts

@@ -1,5 +1,3 @@
-import type { From } from "alchemy-effect";
-import { declare } from "alchemy-effect";
 import type {
   Context as LambdaContext,
   SQSBatchResponse,
@@ -7,11 +5,14 @@ import type {
 } from "aws-lambda";
 import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
-import * as SQS from "../sqs/index.ts";
+import { declare, type From } from "../../policy.ts";
 import * as Lambda from "./function.ts";
+import type { Queue } from "../sqs/queue.ts";
+import type { Consume, QueueEvent } from "../sqs/queue.consume.ts";
+import { QueueEventSource } from "../sqs/queue.event-source.ts";
 
 export const consume =
-  <Q extends SQS.Queue, ID extends string, Req>(
+  <Q extends Queue, ID extends string, Req>(
     id: ID,
     {
       queue,
@@ -19,7 +20,7 @@ export const consume =
     }: {
       queue: Q;
       handle: (
-        event: SQS.QueueEvent<Q["props"]["schema"]["Type"]>,
+        event: QueueEvent<Q["props"]["schema"]["Type"]>,
         context: LambdaContext,
       ) => Effect.Effect<SQSBatchResponse | void, never, Req>;
     },
@@ -30,7 +31,7 @@ export const consume =
   }: Props) =>
     Lambda.Function(id, {
       handle: Effect.fn(function* (event: SQSEvent, context: LambdaContext) {
-        yield* declare<SQS.Consume<From<Q>>>();
+        yield* declare<Consume<From<Q>>>();
         const records = yield* Effect.all(
           event.Records.map(
             Effect.fn(function* (record) {
@@ -60,4 +61,4 @@ export const consume =
           ],
         } satisfies SQSBatchResponse;
       }),
-    })({ ...props, bindings: bindings.and(SQS.QueueEventSource(queue)) });
+    })({ ...props, bindings: bindings.and(QueueEventSource(queue)) });

package/src/aws/lambda/function.handler.ts

@@ -1,6 +1,6 @@
-import type { Capability } from "alchemy-effect";
 import type { Context as LambdaContext } from "aws-lambda";
 import * as Effect from "effect/Effect";
+import type { Capability } from "../../capability.ts";
 
 type Handler = (
   event: any,

package/src/aws/lambda/function.invoke.ts

@@ -1,6 +1,10 @@
 import * as Effect from "effect/Effect";
 
-import { $, Binding, type Capability, declare, toEnvKey } from "alchemy-effect";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import { toEnvKey } from "../../env.ts";
+import { declare, type On } from "../../policy.ts";
+import type { $ } from "../../$.ts";
 import { LambdaClient } from "./client.ts";
 import { Function } from "./function.ts";
 
@@ -8,7 +12,7 @@ export interface InvokeFunction<Resource = unknown>
   extends Capability<"AWS.Lambda.InvokeFunction", Resource> {}
 
 export const InvokeFunction = Binding<
-  <F extends Function>(func: F) => Binding<Function, InvokeFunction<$<F>>>
+  <F extends Function>(func: F) => Binding<Function, InvokeFunction<On<F>>>
 >(Function, "AWS.Lambda.InvokeFunction");
 
 export const invoke = <F extends Function>(func: F, input: any) =>

package/src/aws/lambda/function.provider.ts

@@ -5,13 +5,14 @@ import { FileSystem } from "@effect/platform";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, DotAlchemy, type ProviderService } from "alchemy-effect";
-
 import type {
   CreateFunctionRequest,
   CreateFunctionUrlConfigRequest,
   UpdateFunctionUrlConfigRequest,
 } from "itty-aws/lambda";
+import { App } from "../../app.ts";
+import { DotAlchemy } from "../../dot-alchemy.ts";
+import type { ProviderService } from "../../provider.ts";
 import { createTagger, createTagsList, hasTags } from "../../tags.ts";
 import { Account } from "../account.ts";
 import * as IAM from "../iam.ts";
@@ -25,9 +26,9 @@ export const functionProvider = () =>
     Effect.gen(function* () {
       const lambda = yield* LambdaClient;
       const iam = yield* IAM.IAMClient;
+      const app = yield* App;
       const accountId = yield* Account;
       const region = yield* Region;
-      const app = yield* App;
       const dotAlchemy = yield* DotAlchemy;
       const fs = yield* FileSystem.FileSystem;
 
@@ -68,7 +69,7 @@ export const functionProvider = () =>
       }) {
         const env = bindings
           .map((binding) => binding?.env)
-          .reduce((acc, env) => ({ ...acc, ...(env ?? {}) }), {});
+          .reduce((acc, env) => ({ ...acc, ...env }), {});
         const policyStatements = bindings.flatMap(
           (binding) =>
             binding?.policyStatements?.map((stmt: IAM.PolicyStatement) => ({
@@ -156,7 +157,10 @@ export const functionProvider = () =>
 
       const bundleCode = Effect.fn(function* (
         id: string,
-        props: FunctionProps,
+        props: {
+          main: string;
+          handler?: string;
+        },
       ) {
         const handler = props.handler ?? "default";
         let file = path.relative(process.cwd(), props.main);
@@ -215,7 +219,7 @@ export const functionProvider = () =>
         functionName,
       }: {
         id: string;
-        news: FunctionProps;
+        news: FunctionProps<any>;
         roleArn: string;
         code: string | Uint8Array<ArrayBufferLike>;
         env: Record<string, string> | undefined;
@@ -264,17 +268,13 @@ export const functionProvider = () =>
                   })
                   .pipe(
                     Effect.retry({
-                      while: (e) => {
-                        console.log({ e });
-                        return (
-                          e._tag === "ResourceConflictException" ||
-                          (e._tag === "InvalidParameterValueException" &&
-                            e.message?.includes(
-                              "The role defined for the function cannot be assumed by Lambda.",
-                            ))
-                        );
-                      },
-                      schedule: Schedule.fixed(100),
+                      while: (e) =>
+                        e._tag === "ResourceConflictException" ||
+                        (e._tag === "InvalidParameterValueException" &&
+                          e.message?.includes(
+                            "The role defined for the function cannot be assumed by Lambda.",
+                          )),
+                      schedule: Schedule.exponential(100),
                     }),
                   );
                 yield* Effect.logDebug(`updated function code ${id}`);
@@ -426,6 +426,28 @@ export const functionProvider = () =>
         }`;
 
       return {
+        stables: ["functionArn", "functionName", "roleName"],
+        diff: Effect.fn(function* ({ id, olds, news, output }) {
+          if (
+            // function name changed
+            output.functionName !==
+              (news.functionName ?? createFunctionName(id)) ||
+            // url changed
+            olds.url !== news.url
+          ) {
+            return { action: "replace" };
+          }
+          if (
+            output.code.hash !==
+            (yield* bundleCode(id, {
+              main: news.main,
+              handler: news.handler,
+            })).hash
+          ) {
+            // code changed
+            return { action: "update" };
+          }
+        }),
         read: Effect.fn(function* ({ id, output }) {
           if (output) {
             yield* Effect.logDebug(`reading function ${id}`);
@@ -452,21 +474,8 @@ export const functionProvider = () =>
           }
           return output;
         }),
-        diff: Effect.fn(function* ({ id, olds, news, output }) {
-          if (
-            // function name changed
-            output.functionName !==
-              (news.functionName ?? createFunctionName(id)) ||
-            // url changed
-            olds.url !== news.url
-          ) {
-            return { action: "replace" };
-          } else if (output.code.hash !== (yield* bundleCode(id, news)).hash) {
-            // code changed
-            return { action: "update" };
-          }
-        }),
-        precreate: Effect.fn(function* ({ id, news, session }) {
+
+        precreate: Effect.fn(function* ({ id, news }) {
           const { roleName, functionName, roleArn } = createPhysicalNames(id);
 
           const role = yield* createRoleIfNotExists({ id, roleName });

package/src/aws/lambda/function.ts

@@ -1,9 +1,11 @@
-import { Runtime, type Capability, type RuntimeProps } from "alchemy-effect";
+import type { Capability } from "../../capability.ts";
+import { Runtime, type RuntimeProps } from "../../runtime.ts";
 import type * as IAM from "../iam.ts";
 
 export type { Context } from "aws-lambda";
 
-export interface FunctionProps<Req = any> extends RuntimeProps<Function, Req> {
+export interface FunctionProps<Req = unknown>
+  extends RuntimeProps<Function, Req> {
   functionName?: string;
   functionArn?: string;
   main: string;
@@ -38,8 +40,9 @@ export interface FunctionBinding {
 }
 
 export interface Function extends Runtime<"AWS.Lambda.Function"> {
-  props: FunctionProps;
-  attr: FunctionAttr<Extract<this["props"], FunctionProps>>;
+  props: FunctionProps<any>;
+  attr: FunctionAttr<Extract<this["props"], FunctionProps<any>>>;
   binding: FunctionBinding;
+  base: Function;
 }
 export const Function = Runtime("AWS.Lambda.Function")<Function>();

package/src/aws/lambda/index.ts

@@ -7,3 +7,5 @@ export * from "./serve.ts";
 export * from "./consume.ts";
 
 // export type * as lambda from "aws-lambda";
+
+import "../config.ts";

package/src/aws/profile.ts

@@ -1,6 +1,3 @@
 import * as Context from "effect/Context";
 
-export class AwsProfile extends Context.Tag("AWS::Profile")<
-  AwsProfile,
-  string
->() {}
+export class Profile extends Context.Tag("AWS::Profile")<Profile, string>() {}

package/src/aws/region.ts

@@ -1,12 +1,16 @@
+import * as Config from "effect/Config";
+import * as Option from "effect/Option";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-
-export type RegionID = string;
+import { App } from "../app.ts";
+import { loadProfile } from "./credentials.ts";
 
 export class Region extends Context.Tag("AWS::Region")<Region, RegionID>() {}
 
+export type RegionID = string;
+
 export const of = (region: string) => Layer.succeed(Region, region);
 
 export const fromEnvOrElse = (region: string) =>
@@ -19,11 +23,16 @@ export class EnvironmentVariableNotSet extends Data.TaggedError(
   variable: string;
 }> {}
 
+export const AWS_REGION = Config.string("AWS_REGION");
+
+const tryGetAWSRegion = () =>
+  Config.option(AWS_REGION).pipe(Effect.map(Option.getOrUndefined));
+
 export const fromEnv = () =>
   Layer.effect(
     Region,
     Effect.gen(function* () {
-      const region = process.env.AWS_REGION;
+      const region = yield* tryGetAWSRegion();
       if (!region) {
         return yield* Effect.fail(
           new EnvironmentVariableNotSet({
@@ -35,3 +44,33 @@ export const fromEnv = () =>
       return region;
     }),
   );
+
+export class AWSStageConfigRegionMissing extends Data.TaggedError(
+  "AWSStageConfigMissing",
+)<{
+  message: string;
+  stage: string;
+}> {}
+
+export const fromStageConfig = () =>
+  Layer.effect(
+    Region,
+    Effect.gen(function* () {
+      const app = yield* App;
+      if (app.config.aws?.region) {
+        return app.config.aws.region;
+      } else if (app.config.aws?.profile) {
+        const profile = yield* loadProfile(app.config.aws.profile);
+        if (profile.region) {
+          return profile.region;
+        }
+      }
+      const region = yield* tryGetAWSRegion();
+      if (region) {
+        return region;
+      }
+      return yield* Effect.dieMessage(
+        "No AWS region found in stage config, SSO profile, or environment variable",
+      );
+    }),
+  );