alchemy-effect 0.2.0 → 0.3.0

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.

package/src/aws/index.ts

@@ -1,4 +1,8 @@
 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 type { Provider } from "../provider.ts";
+
 import * as ESBuild from "../esbuild.ts";
 import * as Account from "./account.ts";
 import * as Credentials from "./credentials.ts";
@@ -10,45 +14,47 @@ 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.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,29 +5,30 @@ 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";
-import { Region } from "../region.ts";
 import { zipCode } from "../zip.ts";
 import { LambdaClient } from "./client.ts";
 import { Function, type FunctionAttr, type FunctionProps } from "./function.ts";
+import { Account } from "../account.ts";
+import { Region } from "../region.ts";
 
 export const functionProvider = () =>
   Function.provider.effect(
     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}`);
@@ -461,12 +461,19 @@ export const functionProvider = () =>
             olds.url !== news.url
           ) {
             return { action: "replace" };
-          } else if (output.code.hash !== (yield* bundleCode(id, news)).hash) {
+          }
+          if (
+            output.code.hash !==
+            (yield* bundleCode(id, {
+              main: news.main,
+              handler: news.handler,
+            })).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",
+      );
+    }),
+  );

package/src/aws/sqs/index.ts

@@ -4,3 +4,5 @@ export * from "./queue.event-source.ts";
 export * from "./queue.provider.ts";
 export * from "./queue.send-message.ts";
 export * from "./queue.ts";
+
+import "../config.ts";

package/src/aws/sqs/queue.consume.ts

@@ -1,5 +1,5 @@
-import { type Capability } from "alchemy-effect";
 import type * as lambda from "aws-lambda";
+import type { Capability } from "../../capability.ts";
 import { Queue } from "./queue.ts";
 
 export type QueueRecord<Data> = Omit<lambda.SQSRecord, "body"> & {

package/src/aws/sqs/queue.event-source.ts

@@ -1,17 +1,15 @@
-import { Binding, type From } from "alchemy-effect";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 import type * as Lambda from "itty-aws/lambda";
+import { Binding } from "../../binding.ts";
+import type { From } from "../../policy.ts";
 import { createTagger, hasTags } from "../../tags.ts";
-import { Account } from "../account.ts";
-import {
-  Function,
-  LambdaClient,
-  type FunctionBinding,
-} from "../lambda/index.ts";
-import { Region } from "../region.ts";
 import type { Consume } from "./queue.consume.ts";
 import { Queue, type QueueAttrs, type QueueProps } from "./queue.ts";
+import { Function, type FunctionBinding } from "../lambda/function.ts";
+import { LambdaClient } from "../lambda/client.ts";
+import { Account } from "../account.ts";
+import { Region } from "../region.ts";
 
 export interface QueueEventSourceProps {
   batchSize?: number;
@@ -43,10 +41,9 @@ export const QueueEventSource = Binding<
 
 export const queueEventSourceProvider = () =>
   QueueEventSource.provider.effect(
-    // @ts-expect-error
     Effect.gen(function* () {
-      const region = yield* Region;
       const accountId = yield* Account;
+      const region = yield* Region;
       const lambda = yield* LambdaClient;
       const tagged = yield* createTagger();
 
@@ -113,45 +110,26 @@ export const queueEventSourceProvider = () =>
           return undefined;
         });
 
-      const createFunctionBinding = (queue: {
-        attr: { queueArn: string };
-      }) => ({
-        // we need the policies to be present before the event source mapping is created
-        policyStatements: [
-          {
-            Sid: "AWS.SQS.Consume",
-            Effect: "Allow" as const,
-            Action: [
-              "sqs:ReceiveMessage",
-              "sqs:DeleteMessage",
-              "sqs:ChangeMessageVisibility",
-            ],
-            Resource: [queue.attr.queueArn],
-          },
-        ],
-      });
-
       return {
-        attach: ({ source: queue }) => {
-          console.log("attaching queue event source", queue.id);
-          return {
-            // we need the policies to be present before the event source mapping is created
-            policyStatements: [
-              {
-                Sid: "AWS.SQS.Consume",
-                Effect: "Allow" as const,
-                Action: [
-                  "sqs:ReceiveMessage",
-                  "sqs:DeleteMessage",
-                  "sqs:ChangeMessageVisibility",
-                  "sqs:GetQueueAttributes",
-                  "sqs:GetQueueUrl",
-                ],
-                Resource: [queue.attr.queueArn],
-              },
-            ],
-          };
-        },
+        attach: ({ source: queue, attr }) => ({
+          // TODO(sam): bit of a broken model here - we can't know the UUID until post-attach
+          uuid: attr?.uuid ?? undefined!,
+          // we need the policies to be present before the event source mapping is created
+          policyStatements: [
+            {
+              Sid: "AWS.SQS.Consume",
+              Effect: "Allow" as const,
+              Action: [
+                "sqs:ReceiveMessage",
+                "sqs:DeleteMessage",
+                "sqs:ChangeMessageVisibility",
+                "sqs:GetQueueAttributes",
+                "sqs:GetQueueUrl",
+              ],
+              Resource: [queue.attr.queueArn],
+            },
+          ],
+        }),
         postattach: Effect.fn(function* ({
           source: queue,
           props: { batchSize, maxBatchingWindow, scalingConfig } = {},
@@ -160,11 +138,6 @@ export const queueEventSourceProvider = () =>
             attr: { functionName },
           },
         }) {
-          console.log(
-            "postattaching queue event source",
-            queue.id,
-            functionName,
-          );
           const config:
             | Lambda.CreateEventSourceMappingRequest
             | Lambda.UpdateEventSourceMappingRequest = {
@@ -220,10 +193,11 @@ export const queueEventSourceProvider = () =>
                 ),
               schedule: Schedule.exponential(100),
             }),
+            Effect.orDie,
           );
           return {
             ...attr,
-            uuid: eventSourceMapping.UUID,
+            uuid: eventSourceMapping.UUID!,
           };
         }),
         detach: Effect.fn(function* ({
@@ -235,7 +209,7 @@ export const queueEventSourceProvider = () =>
         }) {
           const uuid =
             attr?.uuid ??
-            (yield* findEventSourceMapping(queue, functionName))?.UUID!;
+            (yield* findEventSourceMapping(queue, functionName))?.UUID;
           if (uuid) {
             // we found (or were aware of) the event source mapping, so we can delete it
             yield* (

package/src/aws/sqs/queue.provider.ts

@@ -1,11 +1,12 @@
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, type ProviderService } from "alchemy-effect";
-import { Account } from "../account.ts";
-import { Region } from "../region.ts";
+import { App } from "../../app.ts";
+import type { ProviderService } from "../../provider.ts";
 import { SQSClient } from "./client.ts";
 import { Queue, type QueueProps } from "./queue.ts";
+import { Region } from "../region.ts";
+import { Account } from "../account.ts";
 
 export const queueProvider = () =>
   Queue.provider.effect(
@@ -14,7 +15,13 @@ export const queueProvider = () =>
       const app = yield* App;
       const region = yield* Region;
       const accountId = yield* Account;
-      const createQueueName = (id: string, props: QueueProps) =>
+      const createQueueName = (
+        id: string,
+        props: {
+          queueName?: string | undefined;
+          fifo?: boolean;
+        },
+      ) =>
         props.queueName ??
         `${app.name}-${id}-${app.stage}${props.fifo ? ".fifo" : ""}`;
       const createAttributes = (props: QueueProps) => ({

package/src/aws/sqs/queue.send-message.ts

@@ -1,13 +1,10 @@
 import * as Effect from "effect/Effect";
 
-import {
-  Binding,
-  declare,
-  toEnvKey,
-  type Capability,
-  type To,
-} from "alchemy-effect";
-import { Function } from "../lambda/index.ts";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import { toEnvKey } from "../../env.ts";
+import { declare, type To } from "../../policy.ts";
+import { Function } from "../lambda/function.ts";
 import { SQSClient } from "./client.ts";
 import { Queue } from "./queue.ts";