alchemy 0.22.4 → 0.24.0

package/src/aws/policy.ts

@@ -11,6 +11,7 @@ import {
 } from "@aws-sdk/client-iam";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { retry } from "./retry.ts";
 
 /**
  * Type of effect for a policy statement
@@ -238,28 +239,34 @@ export const Policy = Resource(
     if (this.phase === "delete") {
       try {
         // List and delete all non-default versions first
-        const versions = await client.send(
-          new ListPolicyVersionsCommand({
-            PolicyArn: policyArn,
-          }),
+        const versions = await retry(() =>
+          client.send(
+            new ListPolicyVersionsCommand({
+              PolicyArn: policyArn,
+            }),
+          ),
         );
 
         for (const version of versions.Versions || []) {
           if (!version.IsDefaultVersion) {
-            await client.send(
-              new DeletePolicyVersionCommand({
-                PolicyArn: policyArn,
-                VersionId: version.VersionId,
-              }),
+            await retry(() =>
+              client.send(
+                new DeletePolicyVersionCommand({
+                  PolicyArn: policyArn,
+                  VersionId: version.VersionId,
+                }),
+              ),
             );
           }
         }
 
         // Delete the policy
-        await client.send(
-          new DeletePolicyCommand({
-            PolicyArn: policyArn,
-          }),
+        await retry(() =>
+          client.send(
+            new DeletePolicyCommand({
+              PolicyArn: policyArn,
+            }),
+          ),
         );
       } catch (error: any) {
         if (error.name !== NoSuchEntityException.name) {
@@ -270,18 +277,22 @@ export const Policy = Resource(
     }
     try {
       // Check if policy exists
-      const existingPolicy = await client.send(
-        new GetPolicyCommand({
-          PolicyArn: policyArn,
-        }),
+      const existingPolicy = await retry(() =>
+        client.send(
+          new GetPolicyCommand({
+            PolicyArn: policyArn,
+          }),
+        ),
       );
 
       // Get current policy version
-      const currentVersion = await client.send(
-        new GetPolicyVersionCommand({
-          PolicyArn: policyArn,
-          VersionId: existingPolicy.Policy!.DefaultVersionId!,
-        }),
+      const currentVersion = await retry(() =>
+        client.send(
+          new GetPolicyVersionCommand({
+            PolicyArn: policyArn,
+            VersionId: existingPolicy.Policy!.DefaultVersionId!,
+          }),
+        ),
       );
 
       const currentDocument = JSON.parse(
@@ -291,10 +302,12 @@ export const Policy = Resource(
       // If policy document changed, create new version
       if (JSON.stringify(currentDocument) !== JSON.stringify(props.document)) {
         // List versions to check if we need to delete old ones
-        const versions = await client.send(
-          new ListPolicyVersionsCommand({
-            PolicyArn: policyArn,
-          }),
+        const versions = await retry(() =>
+          client.send(
+            new ListPolicyVersionsCommand({
+              PolicyArn: policyArn,
+            }),
+          ),
         );
 
         // Delete oldest version if we have 5 versions (maximum allowed)
@@ -304,29 +317,35 @@ export const Policy = Resource(
           )[0];
 
           if (!oldestVersion.IsDefaultVersion) {
-            await client.send(
-              new DeletePolicyVersionCommand({
-                PolicyArn: policyArn,
-                VersionId: oldestVersion.VersionId!,
-              }),
+            await retry(() =>
+              client.send(
+                new DeletePolicyVersionCommand({
+                  PolicyArn: policyArn,
+                  VersionId: oldestVersion.VersionId!,
+                }),
+              ),
             );
           }
         }
 
         // Create new version
-        await client.send(
-          new CreatePolicyVersionCommand({
-            PolicyArn: policyArn,
-            PolicyDocument: JSON.stringify(props.document),
-            SetAsDefault: true,
-          }),
+        await retry(() =>
+          client.send(
+            new CreatePolicyVersionCommand({
+              PolicyArn: policyArn,
+              PolicyDocument: JSON.stringify(props.document),
+              SetAsDefault: true,
+            }),
+          ),
         );
       }
 
-      const policy = await client.send(
-        new GetPolicyCommand({
-          PolicyArn: policyArn,
-        }),
+      const policy = await retry(() =>
+        client.send(
+          new GetPolicyCommand({
+            PolicyArn: policyArn,
+          }),
+        ),
       );
 
       return this({
@@ -341,19 +360,21 @@ export const Policy = Resource(
     } catch (error: any) {
       if (error.name === "NoSuchEntity") {
         // Create new policy
-        const newPolicy = await client.send(
-          new CreatePolicyCommand({
-            PolicyName: props.policyName,
-            PolicyDocument: JSON.stringify(props.document),
-            Description: props.description,
-            Path: props.path,
-            Tags: props.tags
-              ? Object.entries(props.tags).map(([Key, Value]) => ({
-                  Key,
-                  Value,
-                }))
-              : undefined,
-          }),
+        const newPolicy = await retry(() =>
+          client.send(
+            new CreatePolicyCommand({
+              PolicyName: props.policyName,
+              PolicyDocument: JSON.stringify(props.document),
+              Description: props.description,
+              Path: props.path,
+              Tags: props.tags
+                ? Object.entries(props.tags).map(([Key, Value]) => ({
+                    Key,
+                    Value,
+                  }))
+                : undefined,
+            }),
+          ),
         );
 
         return this({

package/src/aws/queue.ts

@@ -9,6 +9,7 @@ import {
 } from "@aws-sdk/client-sqs";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
+import { retry } from "./retry.ts";
 
 /**
  * Properties for creating or updating an SQS queue
@@ -153,28 +154,34 @@ export const Queue = Resource(
     if (this.phase === "delete") {
       try {
         // Get queue URL first
-        const urlResponse = await client.send(
-          new GetQueueUrlCommand({
-            QueueName: queueName,
-          }),
+        const urlResponse = await retry(() =>
+          client.send(
+            new GetQueueUrlCommand({
+              QueueName: queueName,
+            }),
+          ),
         );
 
         // Delete the queue
-        await client.send(
-          new DeleteQueueCommand({
-            QueueUrl: urlResponse.QueueUrl,
-          }),
+        await retry(() =>
+          client.send(
+            new DeleteQueueCommand({
+              QueueUrl: urlResponse.QueueUrl,
+            }),
+          ),
         );
 
         // Wait for queue to be deleted
         let queueDeleted = false;
         while (!queueDeleted) {
           try {
-            await client.send(
-              new GetQueueUrlCommand({
-                QueueName: queueName,
-              }),
-            );
+            await retry(() => {
+              return client.send(
+                new GetQueueUrlCommand({
+                  QueueName: queueName,
+                }),
+              );
+            });
             // If we get here, queue still exists
             await new Promise((resolve) => setTimeout(resolve, 1000));
           } catch (error: any) {
@@ -186,11 +193,11 @@ export const Queue = Resource(
           }
         }
       } catch (error: any) {
+        console.log(error.message);
         if (!isQueueDoesNotExist(error)) {
           throw error;
         }
       }
-
       return this.destroy();
     }
     // Create queue with attributes
@@ -238,20 +245,26 @@ export const Queue = Resource(
 
     try {
       // Create the queue
-      const createResponse = await client.send(
-        new CreateQueueCommand({
-          QueueName: queueName,
-          Attributes: attributes,
-          tags,
-        }),
+      const createResponse = await retry(
+        () =>
+          client.send(
+            new CreateQueueCommand({
+              QueueName: queueName,
+              Attributes: attributes,
+              tags,
+            }),
+          ),
+        (err) => isQueueDeletedRecently(err),
       );
 
       // Get queue attributes
-      const attributesResponse = await client.send(
-        new GetQueueAttributesCommand({
-          QueueUrl: createResponse.QueueUrl,
-          AttributeNames: ["QueueArn"],
-        }),
+      const attributesResponse = await retry(() =>
+        client.send(
+          new GetQueueAttributesCommand({
+            QueueUrl: createResponse.QueueUrl,
+            AttributeNames: ["QueueArn"],
+          }),
+        ),
       );
 
       return this({
@@ -274,20 +287,24 @@ export const Queue = Resource(
             await new Promise((resolve) => setTimeout(resolve, 1000));
 
             // Retry creating the queue
-            const createResponse = await client.send(
-              new CreateQueueCommand({
-                QueueName: queueName,
-                Attributes: attributes,
-                tags,
-              }),
+            const createResponse = await retry(() =>
+              client.send(
+                new CreateQueueCommand({
+                  QueueName: queueName,
+                  Attributes: attributes,
+                  tags,
+                }),
+              ),
             );
 
             // Get queue attributes
-            const attributesResponse = await client.send(
-              new GetQueueAttributesCommand({
-                QueueUrl: createResponse.QueueUrl,
-                AttributeNames: ["QueueArn"],
-              }),
+            const attributesResponse = await retry(() =>
+              client.send(
+                new GetQueueAttributesCommand({
+                  QueueUrl: createResponse.QueueUrl,
+                  AttributeNames: ["QueueArn"],
+                }),
+              ),
             );
 
             return this({

package/src/aws/retry.ts

@@ -0,0 +1,38 @@
+import { withExponentialBackoff } from "../util/retry.ts";
+
+/**
+ * Check if an error is retryable (throttling/rate limiting)
+ */
+function isRetryableError(error: any): boolean {
+  if (!error) return false;
+
+  const errorCode = error.name || error.code || "";
+  const errorMessage = error.message || "";
+
+  // Check for common AWS throttling error codes and messages
+  return (
+    errorCode === "Throttling" ||
+    errorCode === "ThrottlingException" ||
+    errorCode === "TooManyRequestsException" ||
+    errorCode === "RequestLimitExceeded" ||
+    errorMessage.includes("Rate exceeded") ||
+    errorMessage.includes("throttling") ||
+    errorMessage.includes("Throttling") ||
+    errorMessage.includes("Internal server error")
+  );
+}
+
+/**
+ * Retry function with standardized parameters for AWS throttling
+ */
+export function retry<T>(
+  operation: () => Promise<T>,
+  extraIsRetryableError?: (error: any) => boolean,
+): Promise<T> {
+  return withExponentialBackoff(
+    operation,
+    (err) => isRetryableError(err) || extraIsRetryableError?.(err) || false,
+    10, // max attempts
+    1000, // initial delay ms
+  );
+}