alchemy-effect 0.1.0 → 0.3.0

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

@@ -5,27 +5,30 @@ import { FileSystem } from "@effect/platform";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, DotAlchemy } from "alchemy-effect";
-
 import type {
+  CreateFunctionRequest,
   CreateFunctionUrlConfigRequest,
   UpdateFunctionUrlConfigRequest,
 } from "itty-aws/lambda";
-import { AccountID } from "../account.ts";
+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 * as IAM from "../iam.ts";
-import { Region } from "../region.ts";
 import { zipCode } from "../zip.ts";
-import { FunctionClient } from "./function.client.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* FunctionClient;
+      const lambda = yield* LambdaClient;
       const iam = yield* IAM.IAMClient;
-      const accountId = yield* AccountID;
-      const region = yield* Region;
       const app = yield* App;
+      const accountId = yield* Account;
+      const region = yield* Region;
       const dotAlchemy = yield* DotAlchemy;
       const fs = yield* FileSystem.FileSystem;
 
@@ -38,6 +41,19 @@ export const functionProvider = () =>
       const createPolicyName = (id: string) =>
         `${app.name}-${app.stage}-${id}-${region}`;
 
+      const createPhysicalNames = (id: string) => {
+        const roleName = createRoleName(id);
+        const policyName = createPolicyName(id);
+        const functionName = createFunctionName(id);
+        return {
+          roleName,
+          policyName,
+          functionName,
+          roleArn: `arn:aws:iam::${accountId}:role/${roleName}`,
+          functionArn: `arn:aws:lambda:${region}:${accountId}:function:${functionName}`,
+        };
+      };
+
       const attachBindings = Effect.fn(function* ({
         roleName,
         policyName,
@@ -51,15 +67,15 @@ export const functionProvider = () =>
         functionName: string;
         bindings: Function["binding"][];
       }) {
-        const env = bindings.reduce(
-          (acc, binding) => ({ ...acc, ...binding?.env }),
-          {},
-        );
-        const policyStatements = bindings.flatMap((binding) =>
-          binding?.policyStatements?.map((stmt: IAM.PolicyStatement) => ({
-            ...stmt,
-            Sid: stmt.Sid?.replace(/[^A-Za-z0-9]+/gi, ""),
-          })),
+        const env = bindings
+          .map((binding) => binding?.env)
+          .reduce((acc, env) => ({ ...acc, ...env }), {});
+        const policyStatements = bindings.flatMap(
+          (binding) =>
+            binding?.policyStatements?.map((stmt: IAM.PolicyStatement) => ({
+              ...stmt,
+              Sid: stmt.Sid?.replace(/[^A-Za-z0-9]+/gi, ""),
+            })) ?? [],
         );
 
         if (policyStatements.length > 0) {
@@ -83,13 +99,14 @@ export const functionProvider = () =>
         return env;
       });
 
-      const createRole = Effect.fn(function* ({
+      const createRoleIfNotExists = Effect.fn(function* ({
         id,
         roleName,
       }: {
         id: string;
         roleName: string;
       }) {
+        yield* Effect.logDebug(`creating role ${id}`);
         const role = yield* iam
           .createRole({
             RoleName: roleName,
@@ -105,7 +122,7 @@ export const functionProvider = () =>
                 },
               ],
             }),
-            Tags: createTagsList(id),
+            Tags: createTagsList(tagged(id)),
           })
           .pipe(
             Effect.catchTag("EntityAlreadyExistsException", () =>
@@ -115,7 +132,7 @@ export const functionProvider = () =>
                 })
                 .pipe(
                   Effect.filterOrFail(
-                    (role) => validateTagList(tagged(id), role.Role?.Tags),
+                    (role) => hasTags(tagged(id), role.Role?.Tags),
                     () =>
                       new Error(
                         `Role ${roleName} exists but has incorrect tags`,
@@ -125,18 +142,25 @@ export const functionProvider = () =>
             ),
           );
 
-        yield* iam.attachRolePolicy({
-          RoleName: roleName,
-          PolicyArn:
-            "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole",
-        });
+        yield* Effect.logDebug(`attaching policy ${id}`);
+        yield* iam
+          .attachRolePolicy({
+            RoleName: roleName,
+            PolicyArn:
+              "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole",
+          })
+          .pipe(Effect.tapError(Effect.logDebug), Effect.tap(Effect.logDebug));
 
+        yield* Effect.logDebug(`attached policy ${id}`);
         return role;
       });
 
       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);
@@ -151,7 +175,7 @@ export const functionProvider = () =>
         );
         yield* bundle({
           // entryPoints: [props.main],
-          // we use a virtual entry point so that
+          // we use a virtual entry point so that we can pluck out the user's handler closure and only its dependencies (not the whole module)
           stdin: {
             contents: `import { ${handler} as handler } from "${file}";\nexport default handler;`,
             resolveDir: process.cwd(),
@@ -168,6 +192,7 @@ export const functionProvider = () =>
           outfile,
           minify: true,
           external: ["@aws-sdk/*", "@smithy/*"],
+          logLevel: "error",
         });
         const code = yield* fs
           .readFile(outfile)
@@ -178,40 +203,12 @@ export const functionProvider = () =>
         };
       });
 
-      const hashCode = (code: Uint8Array<ArrayBufferLike>) =>
+      const hashCode = (code: string | Uint8Array<ArrayBufferLike>) =>
         Effect.sync(() =>
           crypto.createHash("sha256").update(code).digest("hex"),
         );
 
-      const validateTagList = (
-        expectedTags: Record<string, string>,
-        tags: { Key: string; Value: string }[] | undefined,
-      ) => {
-        return Object.entries(expectedTags).every(([key, value]) =>
-          tags?.some((tag) => tag.Key === key && tag.Value === value),
-        );
-      };
-
-      const validateTags = (
-        expectedTags: Record<string, string>,
-        tags: Record<string, string> | undefined,
-      ) => {
-        return Object.entries(expectedTags).every(
-          ([key, value]) => tags?.[key] === value,
-        );
-      };
-
-      const createTagsList = (id: string) =>
-        Object.entries(tagged(id)).map(([Key, Value]) => ({
-          Key,
-          Value,
-        }));
-
-      const tagged = (id: string) => ({
-        "alchemy::app": app.name,
-        "alchemy::stage": app.stage,
-        "alchemy::id": id,
-      });
+      const tagged = yield* createTagger();
 
       const createOrUpdateFunction = Effect.fn(function* ({
         id,
@@ -222,54 +219,115 @@ export const functionProvider = () =>
         functionName,
       }: {
         id: string;
-        news: FunctionProps;
+        news: FunctionProps<any>;
         roleArn: string;
-        code: Uint8Array<ArrayBufferLike>;
-        env: Record<string, string>;
+        code: string | Uint8Array<ArrayBufferLike>;
+        env: Record<string, string> | undefined;
         functionName: string;
       }) {
-        yield* lambda
-          .createFunction({
+        yield* Effect.logDebug(`creating function ${id}`);
+        const createFunctionRequest: CreateFunctionRequest = {
+          FunctionName: functionName,
+          Handler: `index.${news.handler ?? "default"}`,
+          Role: roleArn,
+          Code: {
+            // TODO(sam): upload to assets
+            ZipFile: yield* zipCode(code),
+          },
+          Runtime: news.runtime ?? "nodejs22.x",
+          Environment: env
+            ? {
+                Variables: env,
+              }
+            : undefined,
+          Tags: tagged(id),
+        };
+
+        const getAndUpdate = lambda
+          .getFunction({
             FunctionName: functionName,
-            Handler: `index.${news.handler ?? "default"}`,
-            Role: roleArn,
-            Code: {
-              // TODO(sam): upload to assets
-              ZipFile: yield* zipCode(code),
-            },
-            Runtime: "nodejs22.x",
-            Environment: {
-              Variables: env,
-            },
-            Tags: tagged(id),
           })
           .pipe(
-            Effect.retry({
-              while: (e) =>
-                e.name === "InvalidParameterValueException" &&
-                e.message?.includes("cannot be assumed by Lambda"),
-              schedule: Schedule.exponential(10),
-            }),
-            Effect.catchTag("ResourceConflictException", () =>
-              lambda
-                .getFunction({
-                  FunctionName: functionName,
-                })
-                .pipe(
-                  Effect.flatMap((f) =>
-                    // if it exists and contains these tags, we will assume it was created by alchemy
-                    // but state was lost, so if it exists, let's adopt it
-                    validateTags(tagged(id), f.Tags)
-                      ? Effect.succeed(f.Configuration!)
-                      : Effect.fail(
-                          new Error(
-                            "Function tags do not match expected values",
-                          ),
-                        ),
-                  ),
-                ),
+            Effect.filterOrFail(
+              // if it exists and contains these tags, we will assume it was created by alchemy
+              // but state was lost, so if it exists, let's adopt it
+              (f) => hasTags(tagged(id), f.Tags),
+              () =>
+                // TODO(sam): add custom
+                new Error("Function tags do not match expected values"),
+            ),
+            Effect.flatMap(() =>
+              Effect.gen(function* () {
+                yield* Effect.logDebug(`updating function code ${id}`);
+                yield* lambda
+                  .updateFunctionCode({
+                    FunctionName: createFunctionRequest.FunctionName,
+                    Architectures: createFunctionRequest.Architectures,
+                    ZipFile: createFunctionRequest.Code.ZipFile,
+                    // TODO(sam): support uploading via S3
+                  })
+                  .pipe(
+                    Effect.retry({
+                      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}`);
+                yield* lambda
+                  .updateFunctionConfiguration({
+                    FunctionName: createFunctionRequest.FunctionName,
+                    DeadLetterConfig: createFunctionRequest.DeadLetterConfig,
+                    Description: createFunctionRequest.Description,
+                    Environment: createFunctionRequest.Environment,
+                    EphemeralStorage: createFunctionRequest.EphemeralStorage,
+                    FileSystemConfigs: createFunctionRequest.FileSystemConfigs,
+                    Handler: createFunctionRequest.Handler,
+                    ImageConfig: createFunctionRequest.ImageConfig,
+                    KMSKeyArn: createFunctionRequest.KMSKeyArn,
+                    Layers: createFunctionRequest.Layers,
+                    LoggingConfig: createFunctionRequest.LoggingConfig,
+                    MemorySize: createFunctionRequest.MemorySize,
+                    // RevisionId: "???"
+                    Role: createFunctionRequest.Role,
+                    Runtime: createFunctionRequest.Runtime,
+                    SnapStart: createFunctionRequest.SnapStart,
+                    Timeout: createFunctionRequest.Timeout,
+                    TracingConfig: createFunctionRequest.TracingConfig,
+                    VpcConfig: createFunctionRequest.VpcConfig,
+                  })
+                  .pipe(
+                    Effect.retry({
+                      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 configuration ${id}`);
+              }),
             ),
           );
+
+        yield* lambda.createFunction(createFunctionRequest).pipe(
+          Effect.tapError(Effect.logDebug),
+          Effect.retry({
+            while: (e) =>
+              e._tag === "InvalidParameterValueException" &&
+              e.message?.includes("cannot be assumed by Lambda"),
+            schedule: Schedule.exponential(10),
+          }),
+          Effect.catchTags({
+            ResourceConflictException: () => getAndUpdate,
+          }),
+        );
       });
 
       const createOrUpdateFunctionUrl = Effect.fn(function* ({
@@ -283,6 +341,7 @@ export const functionProvider = () =>
       }) {
         // TODO(sam): support AWS_IAM
         const authType = "NONE";
+        yield* Effect.logDebug(`creating function url config ${functionName}`);
         if (url) {
           const config = {
             FunctionName: functionName,
@@ -329,8 +388,12 @@ export const functionProvider = () =>
                 )
               : Effect.void,
           ]);
+          yield* Effect.logDebug(`created function url config ${functionName}`);
           return FunctionUrl;
         } else if (oldUrl) {
+          yield* Effect.logDebug(
+            `deleting function url config ${functionName}`,
+          );
           yield* Effect.all([
             lambda
               .deleteFunctionUrlConfig({
@@ -348,6 +411,7 @@ export const functionProvider = () =>
                 Effect.catchTag("ResourceNotFoundException", () => Effect.void),
               ),
           ]);
+          yield* Effect.logDebug(`deleted function url config ${functionName}`);
         }
         return undefined;
       });
@@ -362,9 +426,9 @@ export const functionProvider = () =>
         }`;
 
       return {
-        // type: "AWS.Lambda.Function",
         read: Effect.fn(function* ({ id, output }) {
           if (output) {
+            yield* Effect.logDebug(`reading function ${id}`);
             // example: refresh the function URL from the API
             return {
               ...output,
@@ -374,6 +438,12 @@ export const functionProvider = () =>
                 })
                 .pipe(
                   Effect.map((f) => f.FunctionUrl),
+                  Effect.retry({
+                    //   error: ResourceConflictException: The operation cannot be performed at this time.
+                    // An update is in progress for resource: arn:aws:lambda:us-west-2:084828582823:function:my-app-dev-Consumer-us-west-2
+                    while: (e) => e.name === "ResourceConflictException",
+                    schedule: Schedule.exponential(100),
+                  }),
                   Effect.catchTag("ResourceNotFoundException", () =>
                     Effect.succeed(undefined),
                   ),
@@ -384,22 +454,51 @@ export const functionProvider = () =>
         }),
         diff: Effect.fn(function* ({ id, olds, news, output }) {
           if (
-            output.functionName !==
-            (news.functionName ?? createFunctionName(id))
-          ) {
             // function name changed
-            return { action: "replace" };
-          }
-          if (olds.url !== news.url) {
+            output.functionName !==
+              (news.functionName ?? createFunctionName(id)) ||
             // url changed
+            olds.url !== news.url
+          ) {
             return { action: "replace" };
           }
-          const { hash } = yield* bundleCode(id, news);
-          if (output.code.hash !== hash) {
+          if (
+            output.code.hash !==
+            (yield* bundleCode(id, {
+              main: news.main,
+              handler: news.handler,
+            })).hash
+          ) {
             // code changed
             return { action: "update" };
           }
-          return { action: "noop" };
+        }),
+        precreate: Effect.fn(function* ({ id, news }) {
+          const { roleName, functionName, roleArn } = createPhysicalNames(id);
+
+          const role = yield* createRoleIfNotExists({ id, roleName });
+
+          // mock code
+          const code = "export default () => {}";
+          yield* createOrUpdateFunction({
+            id,
+            news,
+            roleArn: role.Role.Arn,
+            code,
+            functionName,
+            env: {},
+          });
+
+          return {
+            functionArn: `arn:aws:lambda:${region}:${accountId}:function:${functionName}`,
+            functionName,
+            functionUrl: undefined,
+            roleName: createRoleName(id),
+            code: {
+              hash: yield* hashCode(code),
+            },
+            roleArn,
+          } satisfies FunctionAttr<FunctionProps>;
         }),
         create: Effect.fn(function* ({ id, news, bindings, session }) {
           const roleName = createRoleName(id);
@@ -408,7 +507,7 @@ export const functionProvider = () =>
           const functionName = news.functionName ?? createFunctionName(id);
           const functionArn = `arn:aws:lambda:${region}:${accountId}:function:${functionName}`;
 
-          const role = yield* createRole({ id, roleName });
+          const role = yield* createRoleIfNotExists({ id, roleName });
 
           const env = yield* attachBindings({
             roleName,
@@ -558,6 +657,6 @@ export const functionProvider = () =>
             .pipe(Effect.catchTag("NoSuchEntityException", () => Effect.void));
           return null as any;
         }),
-      };
+      } satisfies ProviderService<Function>;
     }),
   );

package/src/aws/lambda/function.ts

@@ -1,18 +1,24 @@
-import { Policy, Runtime, type Capability } 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> {
+export interface FunctionProps<Req = unknown>
+  extends RuntimeProps<Function, Req> {
   functionName?: string;
   functionArn?: string;
   main: string;
   handler?: string;
   memory?: number;
-  runtime?: "nodejs20x" | "nodejs22x";
+  runtime?: "nodejs20.x" | "nodejs22.x";
   architecture?: "x86_64" | "arm64";
   url?: boolean;
-  bindings: Policy<Function, Extract<Req, Capability>>;
+}
+export declare namespace FunctionProps {
+  export type Simplified<Req> = FunctionProps<
+    Capability.Simplify<Extract<Req, Capability>>
+  >;
 }
 
 export type FunctionAttr<Props extends FunctionProps = FunctionProps> = {
@@ -26,14 +32,17 @@ export type FunctionAttr<Props extends FunctionProps = FunctionProps> = {
   };
 };
 
-export interface Function extends Runtime<"AWS.Lambda.Function"> {
-  props: FunctionProps;
-  attr: FunctionAttr<Extract<this["props"], FunctionProps>>;
-  binding: {
-    env: {
-      [key: string]: string;
-    };
-    policyStatements: IAM.PolicyStatement[];
+export interface FunctionBinding {
+  env?: {
+    [key: string]: string;
   };
+  policyStatements?: IAM.PolicyStatement[];
+}
+
+export interface Function extends Runtime<"AWS.Lambda.Function"> {
+  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

@@ -1,12 +1,11 @@
-export * from "./function.client.ts";
+export * from "./client.ts";
 export * from "./function.handler.ts";
 export * from "./function.invoke.ts";
 export * from "./function.provider.ts";
 export * from "./function.ts";
 export * from "./serve.ts";
-
 export * from "./consume.ts";
 
-export type * as Alchemy from "../index.ts";
-
 // export type * as lambda from "aws-lambda";
+
+import "../config.ts";

package/src/aws/lambda/serve.ts

@@ -22,7 +22,7 @@ export const serve =
       ) => Effect.Effect<FunctionURLResult, never, Req>;
     },
   ) =>
-  <const Props extends Lambda.FunctionProps<Req>>(props: Props) =>
+  <const Props extends Lambda.FunctionProps.Simplified<Req>>(props: Props) =>
     Lambda.Function(id, { handle: fetch })({
       ...props,
       url: true,

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,9 +1,15 @@
+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";
+import { App } from "../app.ts";
+import { loadProfile } from "./credentials.ts";
 
-export class Region extends Context.Tag("AWS::Region")<Region, string>() {}
+export class Region extends Context.Tag("AWS::Region")<Region, RegionID>() {}
+
+export type RegionID = string;
 
 export const of = (region: string) => Layer.succeed(Region, region);
 
@@ -17,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({
@@ -33,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/client.ts

@@ -0,0 +1,20 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+
+import { SQS } from "itty-aws/sqs";
+import { createAWSServiceClientLayer } from "../client.ts";
+import * as Credentials from "../credentials.ts";
+import * as Region from "../region.ts";
+
+export class SQSClient extends Context.Tag("AWS.SQS.Client")<
+  SQSClient,
+  SQS
+>() {}
+
+export const client = createAWSServiceClientLayer<typeof SQSClient, SQS>(
+  SQSClient,
+  SQS,
+);
+
+export const clientFromEnv = () =>
+  Layer.provide(client(), Layer.merge(Credentials.fromEnv(), Region.fromEnv()));

package/src/aws/sqs/index.ts

@@ -1,5 +1,8 @@
-export * from "./queue.client.ts";
+export * from "./client.ts";
 export * from "./queue.consume.ts";
+export * from "./queue.event-source.ts";
 export * from "./queue.provider.ts";
 export * from "./queue.send-message.ts";
 export * from "./queue.ts";
+
+import "../config.ts";