alchemy 0.22.4 → 0.24.0

package/src/aws/function.ts

@@ -19,6 +19,7 @@ import type { Context } from "../context.ts";
 import type { Bundle } from "../esbuild/bundle.ts";
 import { Resource } from "../resource.ts";
 import { ignore } from "../util/ignore.ts";
+import { retry } from "./retry.ts";
 
 /**
  * Properties for creating or updating a Lambda function
@@ -317,10 +318,12 @@ export const Function = Resource(
       // Delete function URL if it exists
       if (this.output?.url) {
         try {
-          await client.send(
-            new DeleteFunctionUrlConfigCommand({
-              FunctionName: props.functionName,
-            }),
+          await retry(() =>
+            client.send(
+              new DeleteFunctionUrlConfigCommand({
+                FunctionName: props.functionName,
+              }),
+            ),
           );
         } catch (error: any) {
           if (error.name !== "ResourceNotFoundException") {
@@ -330,10 +333,12 @@ export const Function = Resource(
       }
 
       await ignore(ResourceNotFoundException.name, () =>
-        client.send(
-          new DeleteFunctionCommand({
-            FunctionName: props.functionName,
-          }),
+        retry(() =>
+          client.send(
+            new DeleteFunctionCommand({
+              FunctionName: props.functionName,
+            }),
+          ),
         ),
       );
 
@@ -342,10 +347,12 @@ export const Function = Resource(
     let functionUrl: string | undefined;
     try {
       // Check if function exists
-      await client.send(
-        new GetFunctionCommand({
-          FunctionName: props.functionName,
-        }),
+      await retry(() =>
+        client.send(
+          new GetFunctionCommand({
+            FunctionName: props.functionName,
+          }),
+        ),
       );
 
       if (this.phase === "update") {
@@ -353,31 +360,35 @@ export const Function = Resource(
         await waitForFunctionStabilization(client, props.functionName);
 
         // Update function code
-        await client.send(
-          new UpdateFunctionCodeCommand({
-            FunctionName: props.functionName,
-            ZipFile: code,
-          }),
+        await retry(() =>
+          client.send(
+            new UpdateFunctionCodeCommand({
+              FunctionName: props.functionName,
+              ZipFile: code,
+            }),
+          ),
         );
 
         // Wait for code update to stabilize
         await waitForFunctionStabilization(client, props.functionName);
 
         // Update function configuration
-        await client.send(
-          new UpdateFunctionConfigurationCommand({
-            FunctionName: props.functionName,
-            Handler: props.handler,
-            Runtime: props.runtime,
-            Role: props.roleArn,
-            Description: props.description,
-            Timeout: props.timeout,
-            MemorySize: props.memorySize,
-            Environment: props.environment
-              ? { Variables: props.environment }
-              : undefined,
-            Layers: props.layers,
-          }),
+        await retry(() =>
+          client.send(
+            new UpdateFunctionConfigurationCommand({
+              FunctionName: props.functionName,
+              Handler: props.handler,
+              Runtime: props.runtime,
+              Role: props.roleArn,
+              Description: props.description,
+              Timeout: props.timeout,
+              MemorySize: props.memorySize,
+              Environment: props.environment
+                ? { Variables: props.environment }
+                : undefined,
+              Layers: props.layers,
+            }),
+          ),
         );
 
         // Wait for configuration update to stabilize
@@ -387,44 +398,50 @@ export const Function = Resource(
         if (props.url) {
           try {
             // Check if URL config exists already
-            const urlConfig = await client.send(
-              new GetFunctionUrlConfigCommand({
-                FunctionName: props.functionName,
-              }),
+            const urlConfig = await retry(() =>
+              client.send(
+                new GetFunctionUrlConfigCommand({
+                  FunctionName: props.functionName,
+                }),
+              ),
             );
 
             // Update URL configuration if it exists
             if (urlConfig) {
-              const updateResult = await client.send(
-                new UpdateFunctionUrlConfigCommand({
-                  FunctionName: props.functionName,
-                  AuthType: props.url.authType || "NONE",
-                  InvokeMode: props.url.invokeMode || "BUFFERED",
-                  Cors: props.url.cors
-                    ? {
-                        AllowCredentials: props.url.cors.allowCredentials,
-                        AllowHeaders: props.url.cors.allowHeaders,
-                        AllowMethods: props.url.cors.allowMethods,
-                        AllowOrigins: props.url.cors.allowOrigins,
-                        ExposeHeaders: props.url.cors.exposeHeaders,
-                        MaxAge: props.url.cors.maxAge,
-                      }
-                    : undefined,
-                }),
+              const updateResult = await retry(() =>
+                client.send(
+                  new UpdateFunctionUrlConfigCommand({
+                    FunctionName: props.functionName,
+                    AuthType: props.url!.authType || "NONE",
+                    InvokeMode: props.url!.invokeMode || "BUFFERED",
+                    Cors: props.url!.cors
+                      ? {
+                          AllowCredentials: props.url!.cors.allowCredentials,
+                          AllowHeaders: props.url!.cors.allowHeaders,
+                          AllowMethods: props.url!.cors.allowMethods,
+                          AllowOrigins: props.url!.cors.allowOrigins,
+                          ExposeHeaders: props.url!.cors.exposeHeaders,
+                          MaxAge: props.url!.cors.maxAge,
+                        }
+                      : undefined,
+                  }),
+                ),
               );
               functionUrl = updateResult.FunctionUrl;
 
               // Add public access permission for function URL
-              if (props.url.authType === "NONE") {
+              if (props.url!.authType === "NONE") {
                 try {
-                  await client.send(
-                    new AddPermissionCommand({
-                      FunctionName: props.functionName,
-                      StatementId: "FunctionURLAllowPublicAccess",
-                      Action: "lambda:InvokeFunctionUrl",
-                      Principal: "*",
-                      FunctionUrlAuthType: "NONE",
-                    }),
+                  await retry(() =>
+                    client.send(
+                      new AddPermissionCommand({
+                        FunctionName: props.functionName,
+                        StatementId: "FunctionURLAllowPublicAccess",
+                        Action: "lambda:InvokeFunctionUrl",
+                        Principal: "*",
+                        FunctionUrlAuthType: "NONE",
+                      }),
+                    ),
                   );
                 } catch (permError: any) {
                   if (!permError.message?.includes("already exists")) {
@@ -434,36 +451,40 @@ export const Function = Resource(
               }
             } else {
               // Create URL configuration if it doesn't exist
-              const createResult = await client.send(
-                new CreateFunctionUrlConfigCommand({
-                  FunctionName: props.functionName,
-                  AuthType: props.url.authType || "NONE",
-                  InvokeMode: props.url.invokeMode || "BUFFERED",
-                  Cors: props.url.cors
-                    ? {
-                        AllowCredentials: props.url.cors.allowCredentials,
-                        AllowHeaders: props.url.cors.allowHeaders,
-                        AllowMethods: props.url.cors.allowMethods,
-                        AllowOrigins: props.url.cors.allowOrigins,
-                        ExposeHeaders: props.url.cors.exposeHeaders,
-                        MaxAge: props.url.cors.maxAge,
-                      }
-                    : undefined,
-                }),
+              const createResult = await retry(() =>
+                client.send(
+                  new CreateFunctionUrlConfigCommand({
+                    FunctionName: props.functionName,
+                    AuthType: props.url!.authType || "NONE",
+                    InvokeMode: props.url!.invokeMode || "BUFFERED",
+                    Cors: props.url!.cors
+                      ? {
+                          AllowCredentials: props.url!.cors.allowCredentials,
+                          AllowHeaders: props.url!.cors.allowHeaders,
+                          AllowMethods: props.url!.cors.allowMethods,
+                          AllowOrigins: props.url!.cors.allowOrigins,
+                          ExposeHeaders: props.url!.cors.exposeHeaders,
+                          MaxAge: props.url!.cors.maxAge,
+                        }
+                      : undefined,
+                  }),
+                ),
               );
               functionUrl = createResult.FunctionUrl;
 
               // Add public access permission for function URL
-              if (props.url.authType === "NONE") {
+              if (props.url!.authType === "NONE") {
                 try {
-                  await client.send(
-                    new AddPermissionCommand({
-                      FunctionName: props.functionName,
-                      StatementId: "FunctionURLAllowPublicAccess",
-                      Action: "lambda:InvokeFunctionUrl",
-                      Principal: "*",
-                      FunctionUrlAuthType: "NONE",
-                    }),
+                  await retry(() =>
+                    client.send(
+                      new AddPermissionCommand({
+                        FunctionName: props.functionName,
+                        StatementId: "FunctionURLAllowPublicAccess",
+                        Action: "lambda:InvokeFunctionUrl",
+                        Principal: "*",
+                        FunctionUrlAuthType: "NONE",
+                      }),
+                    ),
                   );
                 } catch (permError: any) {
                   if (!permError.message?.includes("already exists")) {
@@ -475,36 +496,40 @@ export const Function = Resource(
           } catch (error: any) {
             if (error.name === "ResourceNotFoundException") {
               // Create URL configuration if it doesn't exist
-              const createResult = await client.send(
-                new CreateFunctionUrlConfigCommand({
-                  FunctionName: props.functionName,
-                  AuthType: props.url.authType || "NONE",
-                  InvokeMode: props.url.invokeMode || "BUFFERED",
-                  Cors: props.url.cors
-                    ? {
-                        AllowCredentials: props.url.cors.allowCredentials,
-                        AllowHeaders: props.url.cors.allowHeaders,
-                        AllowMethods: props.url.cors.allowMethods,
-                        AllowOrigins: props.url.cors.allowOrigins,
-                        ExposeHeaders: props.url.cors.exposeHeaders,
-                        MaxAge: props.url.cors.maxAge,
-                      }
-                    : undefined,
-                }),
+              const createResult = await retry(() =>
+                client.send(
+                  new CreateFunctionUrlConfigCommand({
+                    FunctionName: props.functionName,
+                    AuthType: props.url!.authType || "NONE",
+                    InvokeMode: props.url!.invokeMode || "BUFFERED",
+                    Cors: props.url!.cors
+                      ? {
+                          AllowCredentials: props.url!.cors.allowCredentials,
+                          AllowHeaders: props.url!.cors.allowHeaders,
+                          AllowMethods: props.url!.cors.allowMethods,
+                          AllowOrigins: props.url!.cors.allowOrigins,
+                          ExposeHeaders: props.url!.cors.exposeHeaders,
+                          MaxAge: props.url!.cors.maxAge,
+                        }
+                      : undefined,
+                  }),
+                ),
               );
               functionUrl = createResult.FunctionUrl;
 
               // Add public access permission for function URL
-              if (props.url.authType === "NONE") {
+              if (props.url!.authType === "NONE") {
                 try {
-                  await client.send(
-                    new AddPermissionCommand({
-                      FunctionName: props.functionName,
-                      StatementId: "FunctionURLAllowPublicAccess",
-                      Action: "lambda:InvokeFunctionUrl",
-                      Principal: "*",
-                      FunctionUrlAuthType: "NONE",
-                    }),
+                  await retry(() =>
+                    client.send(
+                      new AddPermissionCommand({
+                        FunctionName: props.functionName,
+                        StatementId: "FunctionURLAllowPublicAccess",
+                        Action: "lambda:InvokeFunctionUrl",
+                        Principal: "*",
+                        FunctionUrlAuthType: "NONE",
+                      }),
+                    ),
                   );
                 } catch (permError: any) {
                   if (!permError.message?.includes("already exists")) {
@@ -519,10 +544,12 @@ export const Function = Resource(
         } else if (this.output?.url) {
           // Remove URL config if it was previously set but not in current props
           try {
-            await client.send(
-              new DeleteFunctionUrlConfigCommand({
-                FunctionName: props.functionName,
-              }),
+            await retry(() =>
+              client.send(
+                new DeleteFunctionUrlConfigCommand({
+                  FunctionName: props.functionName,
+                }),
+              ),
             );
             functionUrl = undefined;
           } catch (error: any) {
@@ -540,25 +567,27 @@ export const Function = Resource(
 
         while (true) {
           try {
-            await client.send(
-              new CreateFunctionCommand({
-                FunctionName: props.functionName,
-                Code: { ZipFile: code },
-                Handler: props.handler || "index.handler",
-                Runtime: props.runtime || Runtime.nodejs20x,
-                Role: props.roleArn,
-                Description: props.description,
-                Timeout: props.timeout || 3,
-                MemorySize: props.memorySize || 128,
-                Environment: props.environment
-                  ? { Variables: props.environment }
-                  : undefined,
-                Architectures: props.architecture
-                  ? [props.architecture]
-                  : [Architecture.x86_64],
-                Tags: props.tags,
-                Layers: props.layers,
-              }),
+            await retry(() =>
+              client.send(
+                new CreateFunctionCommand({
+                  FunctionName: props.functionName,
+                  Code: { ZipFile: code },
+                  Handler: props.handler || "index.handler",
+                  Runtime: props.runtime || Runtime.nodejs20x,
+                  Role: props.roleArn,
+                  Description: props.description,
+                  Timeout: props.timeout || 3,
+                  MemorySize: props.memorySize || 128,
+                  Environment: props.environment
+                    ? { Variables: props.environment }
+                    : undefined,
+                  Architectures: props.architecture
+                    ? [props.architecture]
+                    : [Architecture.x86_64],
+                  Tags: props.tags,
+                  Layers: props.layers,
+                }),
+              ),
             );
             break; // Success - exit retry loop
           } catch (createError: any) {
@@ -583,10 +612,12 @@ export const Function = Resource(
         // Wait for function to be active
         let isCreating = true;
         while (isCreating) {
-          const config = await client.send(
-            new GetFunctionConfigurationCommand({
-              FunctionName: props.functionName,
-            }),
+          const config = await retry(() =>
+            client.send(
+              new GetFunctionConfigurationCommand({
+                FunctionName: props.functionName,
+              }),
+            ),
           );
           isCreating = config.State === "Pending";
           if (isCreating) {
@@ -594,39 +625,50 @@ export const Function = Resource(
           }
         }
 
+        // Additional stabilization check - ensure role can be used
+        // by waiting a bit more after function becomes Active
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        // Verify function is fully stable and role is usable
+        await waitForFunctionStabilization(client, props.functionName);
+
         // Create URL configuration if needed
         if (props.url) {
           try {
-            const createResult = await client.send(
-              new CreateFunctionUrlConfigCommand({
-                FunctionName: props.functionName,
-                AuthType: props.url.authType || "NONE",
-                InvokeMode: props.url.invokeMode || "BUFFERED",
-                Cors: props.url.cors
-                  ? {
-                      AllowCredentials: props.url.cors.allowCredentials,
-                      AllowHeaders: props.url.cors.allowHeaders,
-                      AllowMethods: props.url.cors.allowMethods,
-                      AllowOrigins: props.url.cors.allowOrigins,
-                      ExposeHeaders: props.url.cors.exposeHeaders,
-                      MaxAge: props.url.cors.maxAge,
-                    }
-                  : undefined,
-              }),
+            const createResult = await retry(() =>
+              client.send(
+                new CreateFunctionUrlConfigCommand({
+                  FunctionName: props.functionName,
+                  AuthType: props.url!.authType || "NONE",
+                  InvokeMode: props.url!.invokeMode || "BUFFERED",
+                  Cors: props.url!.cors
+                    ? {
+                        AllowCredentials: props.url!.cors.allowCredentials,
+                        AllowHeaders: props.url!.cors.allowHeaders,
+                        AllowMethods: props.url!.cors.allowMethods,
+                        AllowOrigins: props.url!.cors.allowOrigins,
+                        ExposeHeaders: props.url!.cors.exposeHeaders,
+                        MaxAge: props.url!.cors.maxAge,
+                      }
+                    : undefined,
+                }),
+              ),
             );
             functionUrl = createResult.FunctionUrl;
 
             // Add public access permission for function URL
-            if (props.url.authType === "NONE") {
+            if (props.url!.authType === "NONE") {
               try {
-                await client.send(
-                  new AddPermissionCommand({
-                    FunctionName: props.functionName,
-                    StatementId: "FunctionURLAllowPublicAccess",
-                    Action: "lambda:InvokeFunctionUrl",
-                    Principal: "*",
-                    FunctionUrlAuthType: "NONE",
-                  }),
+                await retry(() =>
+                  client.send(
+                    new AddPermissionCommand({
+                      FunctionName: props.functionName,
+                      StatementId: "FunctionURLAllowPublicAccess",
+                      Action: "lambda:InvokeFunctionUrl",
+                      Principal: "*",
+                      FunctionUrlAuthType: "NONE",
+                    }),
+                  ),
                 );
               } catch (permError: any) {
                 if (!permError.message?.includes("already exists")) {
@@ -645,25 +687,31 @@ export const Function = Resource(
 
     // Get complete function details
     const [_func, config] = await Promise.all([
-      client.send(
-        new GetFunctionCommand({
-          FunctionName: props.functionName,
-        }),
+      retry(() =>
+        client.send(
+          new GetFunctionCommand({
+            FunctionName: props.functionName,
+          }),
+        ),
       ),
-      client.send(
-        new GetFunctionConfigurationCommand({
-          FunctionName: props.functionName,
-        }),
+      retry(() =>
+        client.send(
+          new GetFunctionConfigurationCommand({
+            FunctionName: props.functionName,
+          }),
+        ),
       ),
     ]);
 
     // Try to get function URL if it wasn't already retrieved and URL is configured
     if (!functionUrl && (props.url || this.output?.url)) {
       try {
-        const urlConfig = await client.send(
-          new GetFunctionUrlConfigCommand({
-            FunctionName: props.functionName,
-          }),
+        const urlConfig = await retry(() =>
+          client.send(
+            new GetFunctionUrlConfigCommand({
+              FunctionName: props.functionName,
+            }),
+          ),
         );
         functionUrl = urlConfig.FunctionUrl;
       } catch (error: any) {
@@ -706,10 +754,12 @@ async function waitForFunctionStabilization(
   functionName: string,
 ) {
   while (true) {
-    const config = await client.send(
-      new GetFunctionConfigurationCommand({
-        FunctionName: functionName,
-      }),
+    const config = await retry(() =>
+      client.send(
+        new GetFunctionConfigurationCommand({
+          FunctionName: functionName,
+        }),
+      ),
     );
 
     // Check if function is in a stable state
@@ -745,9 +795,14 @@ async function zipCode(props: FunctionProps): Promise<Buffer> {
     parseFile(props.handler) +
     (props.bundle.format === "cjs" ? ".cjs" : ".mjs");
 
+  if (!fileContent || fileContent.length === 0) {
+    throw new Error("Bundle content is empty");
+  }
+
   // Create a zip buffer in memory
   const zip = new (await import("jszip")).default();
   zip.file(fileName, fileContent);
+
   return zip.generateAsync({
     type: "nodebuffer",
     compression: "DEFLATE",

package/src/aws/index.ts

@@ -6,4 +6,5 @@ export * from "./policy.ts";
 export * from "./queue.ts";
 export * from "./role.ts";
 export * from "./ses.ts";
+export * from "./ssm-parameter.ts";
 export * from "./table.ts";

package/src/aws/policy-attachment.ts

@@ -7,6 +7,7 @@ import {
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { ignore } from "../util/ignore.ts";
+import { retry } from "./retry.ts";
 
 /**
  * Properties for creating or updating a policy attachment
@@ -72,20 +73,24 @@ export const PolicyAttachment = Resource(
 
     if (this.phase === "delete") {
       await ignore(NoSuchEntityException.name, () =>
-        client.send(
-          new DetachRolePolicyCommand({
-            PolicyArn: props.policyArn,
-            RoleName: props.roleName,
-          }),
+        retry(() =>
+          client.send(
+            new DetachRolePolicyCommand({
+              PolicyArn: props.policyArn,
+              RoleName: props.roleName,
+            }),
+          ),
         ),
       );
       return this.destroy();
     }
-    await client.send(
-      new AttachRolePolicyCommand({
-        PolicyArn: props.policyArn,
-        RoleName: props.roleName,
-      }),
+    await retry(() =>
+      client.send(
+        new AttachRolePolicyCommand({
+          PolicyArn: props.policyArn,
+          RoleName: props.roleName,
+        }),
+      ),
     );
 
     return this(props);