alchemy 0.0.8 → 0.1.1

package/src/components/aws/queue.ts

@@ -0,0 +1,222 @@
+import {
+  CreateQueueCommand,
+  DeleteQueueCommand,
+  GetQueueAttributesCommand,
+  GetQueueUrlCommand,
+  SQSClient,
+} from "@aws-sdk/client-sqs";
+import { Resource } from "../../resource";
+
+export interface QueueProps {
+  queueName: string;
+  fifo?: boolean;
+  visibilityTimeout?: number;
+  messageRetentionPeriod?: number;
+  maximumMessageSize?: number;
+  delaySeconds?: number;
+  receiveMessageWaitTimeSeconds?: number;
+  contentBasedDeduplication?: boolean;
+  deduplicationScope?: "messageGroup" | "queue";
+  fifoThroughputLimit?: "perQueue" | "perMessageGroupId";
+  tags?: Record<string, string>;
+}
+
+export interface QueueOutput extends QueueProps {
+  id: string; // Same as queueName
+  arn: string;
+  url: string;
+}
+
+export class Queue extends Resource(
+  "sqs::Queue",
+  async (ctx, props: QueueProps) => {
+    const client = new SQSClient({});
+    const queueName = props.fifo ? `${props.queueName}.fifo` : props.queueName;
+
+    if (ctx.event === "delete") {
+      try {
+        // Get queue URL first
+        const urlResponse = await client.send(
+          new GetQueueUrlCommand({
+            QueueName: queueName,
+          }),
+        );
+
+        // Delete the queue
+        await 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,
+              }),
+            );
+            // If we get here, queue still exists
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          } catch (error: any) {
+            if (error.name === "QueueDoesNotExist") {
+              queueDeleted = true;
+            } else {
+              throw error;
+            }
+          }
+        }
+      } catch (error: any) {
+        if (error.name !== "QueueDoesNotExist") {
+          throw error;
+        }
+      }
+
+      return {
+        ...props,
+        id: props.queueName,
+        arn: `arn:aws:sqs:${client.config.region}:${process.env.AWS_ACCOUNT_ID}:${queueName}`,
+        url: "",
+      };
+    } else {
+      // Create queue with attributes
+      const attributes: Record<string, string> = {};
+
+      if (props.visibilityTimeout !== undefined) {
+        attributes["VisibilityTimeout"] = props.visibilityTimeout.toString();
+      }
+      if (props.messageRetentionPeriod !== undefined) {
+        attributes["MessageRetentionPeriod"] =
+          props.messageRetentionPeriod.toString();
+      }
+      if (props.maximumMessageSize !== undefined) {
+        attributes["MaximumMessageSize"] = props.maximumMessageSize.toString();
+      }
+      if (props.delaySeconds !== undefined) {
+        attributes["DelaySeconds"] = props.delaySeconds.toString();
+      }
+      if (props.receiveMessageWaitTimeSeconds !== undefined) {
+        attributes["ReceiveMessageWaitTimeSeconds"] =
+          props.receiveMessageWaitTimeSeconds.toString();
+      }
+
+      // FIFO specific attributes
+      if (props.fifo) {
+        attributes["FifoQueue"] = "true";
+        if (props.contentBasedDeduplication) {
+          attributes["ContentBasedDeduplication"] = "true";
+        }
+        if (props.deduplicationScope) {
+          attributes["DeduplicationScope"] = props.deduplicationScope;
+        }
+        if (props.fifoThroughputLimit) {
+          attributes["FifoThroughputLimit"] = props.fifoThroughputLimit;
+        }
+      }
+
+      // Convert tags to AWS format
+      const tags = props.tags
+        ? Object.entries(props.tags).reduce(
+            (acc, [key, value]) => ({ ...acc, [key]: value }),
+            {},
+          )
+        : undefined;
+
+      try {
+        // Create the queue
+        const createResponse = await client.send(
+          new CreateQueueCommand({
+            QueueName: queueName,
+            Attributes: attributes,
+            tags,
+          }),
+        );
+
+        // Get queue attributes
+        const attributesResponse = await client.send(
+          new GetQueueAttributesCommand({
+            QueueUrl: createResponse.QueueUrl,
+            AttributeNames: ["QueueArn"],
+          }),
+        );
+
+        return {
+          ...props,
+          id: props.queueName,
+          arn: attributesResponse.Attributes!.QueueArn!,
+          url: createResponse.QueueUrl!,
+        };
+      } catch (error: any) {
+        if (error.name === "QueueAlreadyExists") {
+          // Get existing queue URL
+          const urlResponse = await client.send(
+            new GetQueueUrlCommand({
+              QueueName: queueName,
+            }),
+          );
+
+          // Get queue attributes
+          const attributesResponse = await client.send(
+            new GetQueueAttributesCommand({
+              QueueUrl: urlResponse.QueueUrl,
+              AttributeNames: ["QueueArn"],
+            }),
+          );
+
+          return {
+            ...props,
+            id: props.queueName,
+            arn: attributesResponse.Attributes!.QueueArn!,
+            url: urlResponse.QueueUrl!,
+          };
+        } else if (error.name === "QueueDeletedRecently") {
+          // Queue was recently deleted, wait and retry
+          const maxRetries = 3;
+          let retryCount = 0;
+
+          while (retryCount < maxRetries) {
+            try {
+              // Wait for 60 seconds before retrying
+              await new Promise((resolve) => setTimeout(resolve, 61000));
+
+              // Retry creating the queue
+              const createResponse = await client.send(
+                new CreateQueueCommand({
+                  QueueName: queueName,
+                  Attributes: attributes,
+                  tags,
+                }),
+              );
+
+              // Get queue attributes
+              const attributesResponse = await client.send(
+                new GetQueueAttributesCommand({
+                  QueueUrl: createResponse.QueueUrl,
+                  AttributeNames: ["QueueArn"],
+                }),
+              );
+
+              return {
+                ...props,
+                id: props.queueName,
+                arn: attributesResponse.Attributes!.QueueArn!,
+                url: createResponse.QueueUrl!,
+              };
+            } catch (retryError: any) {
+              if (
+                retryError.name !== "QueueDeletedRecently" ||
+                retryCount === maxRetries - 1
+              ) {
+                throw retryError;
+              }
+              retryCount++;
+            }
+          }
+        }
+        throw error;
+      }
+    }
+  },
+) {}

package/src/components/aws/role.ts

@@ -0,0 +1,245 @@
+import {
+  CreateRoleCommand,
+  DeleteRoleCommand,
+  DeleteRolePolicyCommand,
+  EntityAlreadyExistsException,
+  GetRoleCommand,
+  IAMClient,
+  NoSuchEntityException,
+  PutRolePolicyCommand,
+  type Tag,
+  TagRoleCommand,
+  UpdateAssumeRolePolicyCommand,
+  UpdateRoleCommand,
+} from "@aws-sdk/client-iam";
+import { ignore } from "../../error";
+import { type Context, Resource } from "../../resource";
+import type { PolicyDocument } from "./policy";
+
+export interface RoleProps {
+  roleName: string;
+  assumeRolePolicy: PolicyDocument;
+  description?: string;
+  path?: string;
+  maxSessionDuration?: number;
+  permissionsBoundary?: string;
+  policies?: Array<{
+    policyName: string;
+    policyDocument: PolicyDocument;
+  }>;
+  managedPolicyArns?: string[];
+  tags?: Record<string, string>;
+}
+
+export interface RoleOutput extends RoleProps {
+  id: string; // Same as roleName
+  arn: string;
+  uniqueId: string; // Unique identifier for the role
+  roleId: string; // The stable and unique string identifying the role
+  createDate: Date;
+}
+
+export class Role extends Resource(
+  "iam::Role",
+  async (ctx: Context<RoleOutput>, props: RoleProps): Promise<RoleOutput> => {
+    const client = new IAMClient({});
+
+    if (ctx.event === "delete") {
+      // Delete any inline policies first
+      if (props.policies) {
+        for (const policy of props.policies) {
+          await ignore(NoSuchEntityException.name, () =>
+            client.send(
+              new DeleteRolePolicyCommand({
+                RoleName: props.roleName,
+                PolicyName: policy.policyName,
+              }),
+            ),
+          );
+        }
+      }
+
+      await ignore(NoSuchEntityException.name, () =>
+        client.send(
+          new DeleteRoleCommand({
+            RoleName: props.roleName,
+          }),
+        ),
+      );
+      return {
+        ...props,
+        id: props.roleName,
+        arn: `arn:aws:iam::${process.env.AWS_ACCOUNT_ID}:role/${props.roleName}`,
+        uniqueId: "",
+        roleId: "",
+        createDate: new Date(),
+      };
+    }
+
+    const assumeRolePolicyDocument = JSON.stringify(props.assumeRolePolicy);
+    let role;
+
+    try {
+      if (ctx.event === "create") {
+        // Try to create the role
+        await client.send(
+          new CreateRoleCommand({
+            RoleName: props.roleName,
+            AssumeRolePolicyDocument: assumeRolePolicyDocument,
+            Description: props.description,
+            Path: props.path,
+            MaxSessionDuration: props.maxSessionDuration,
+            PermissionsBoundary: props.permissionsBoundary,
+            Tags: [
+              ...Object.entries(props.tags || {}).map(([Key, Value]) => ({
+                Key,
+                Value,
+              })),
+              {
+                Key: "alchemy_stage",
+                Value: ctx.stage,
+              },
+              {
+                Key: "alchemy_resource",
+                Value: ctx.resourceID,
+              },
+            ],
+          }),
+        );
+      }
+    } catch (error: any) {
+      if (
+        error instanceof EntityAlreadyExistsException &&
+        ctx.event === "create"
+      ) {
+        // Check if we were the ones who created it
+        const existingRole = await client.send(
+          new GetRoleCommand({
+            RoleName: props.roleName,
+          }),
+        );
+        const roleTags =
+          existingRole.Role?.Tags?.reduce(
+            (acc, tag) => {
+              acc[tag.Key!] = tag.Value!;
+              return acc;
+            },
+            {} as Record<string, string>,
+          ) || {};
+
+        if (
+          roleTags.alchemy_stage !== ctx.stage ||
+          roleTags.alchemy_resource !== ctx.resourceID
+        ) {
+          throw error;
+        }
+      } else if (error.name !== NoSuchEntityException.name) {
+        throw error;
+      }
+    }
+
+    // Get or update the role
+    role = await client.send(
+      new GetRoleCommand({
+        RoleName: props.roleName,
+      }),
+    );
+
+    // Update assume role policy if it changed
+    if (role.Role?.AssumeRolePolicyDocument !== assumeRolePolicyDocument) {
+      await client.send(
+        new UpdateAssumeRolePolicyCommand({
+          RoleName: props.roleName,
+          PolicyDocument: assumeRolePolicyDocument,
+        }),
+      );
+    }
+
+    // Update role description and max session duration if they changed
+    if (
+      role.Role?.Description !== props.description ||
+      role.Role?.MaxSessionDuration !== props.maxSessionDuration
+    ) {
+      await client.send(
+        new UpdateRoleCommand({
+          RoleName: props.roleName,
+          Description: props.description,
+          MaxSessionDuration: props.maxSessionDuration,
+        }),
+      );
+    }
+
+    // Update tags
+    const newTags = {
+      ...props.tags,
+      alchemy_stage: ctx.stage,
+      alchemy_resource: ctx.resourceID,
+    };
+    const tags: Tag[] = Object.entries(newTags).map(([Key, Value]) => ({
+      Key,
+      Value,
+    }));
+    await client.send(
+      new TagRoleCommand({
+        RoleName: props.roleName,
+        Tags: tags,
+      }),
+    );
+
+    // Handle policy changes
+    const previousPolicies =
+      ctx.event === "update" ? ctx.output.policies || [] : [];
+    const currentPolicies = props.policies || [];
+
+    // Delete policies that were removed
+    for (const oldPolicy of previousPolicies) {
+      if (
+        !currentPolicies.some(
+          (p: { policyName: string }) => p.policyName === oldPolicy.policyName,
+        )
+      ) {
+        await ignore(NoSuchEntityException.name, () =>
+          client.send(
+            new DeleteRolePolicyCommand({
+              RoleName: props.roleName,
+              PolicyName: oldPolicy.policyName,
+            }),
+          ),
+        );
+      }
+    }
+
+    // Update or create policies
+    for (const policy of currentPolicies) {
+      const oldPolicy = previousPolicies.find(
+        (p) => p.policyName === policy.policyName,
+      );
+      if (
+        !oldPolicy ||
+        JSON.stringify(oldPolicy.policyDocument) !==
+          JSON.stringify(policy.policyDocument)
+      ) {
+        await client.send(
+          new PutRolePolicyCommand({
+            RoleName: props.roleName,
+            PolicyName: policy.policyName,
+            PolicyDocument: JSON.stringify(policy.policyDocument),
+          }),
+        );
+      }
+    }
+
+    if (!role?.Role) {
+      throw new Error(`Failed to create or update role ${props.roleName}`);
+    }
+
+    return {
+      ...props,
+      id: props.roleName,
+      arn: role.Role.Arn!,
+      uniqueId: role.Role.RoleId!,
+      roleId: role.Role.RoleId!,
+      createDate: role.Role.CreateDate!,
+    };
+  },
+) {}

package/src/components/aws/table.ts

@@ -0,0 +1,172 @@
+import {
+  CreateTableCommand,
+  DeleteTableCommand,
+  DescribeTableCommand,
+  DynamoDBClient,
+  type KeySchemaElement,
+  ResourceInUseException,
+  ResourceNotFoundException,
+} from "@aws-sdk/client-dynamodb";
+import { ignore } from "../../error";
+import { type Context, Resource } from "../../resource";
+
+export interface TableProps {
+  tableName: string;
+  partitionKey: {
+    name: string;
+    type: "S" | "N" | "B";
+  };
+  sortKey?: {
+    name: string;
+    type: "S" | "N" | "B";
+  };
+  billingMode?: "PROVISIONED" | "PAY_PER_REQUEST";
+  readCapacity?: number;
+  writeCapacity?: number;
+  tags?: Record<string, string>;
+}
+
+export interface TableOutput extends TableProps {
+  id: string; // Same as tableName
+  arn: string;
+  streamArn?: string;
+  tableId: string;
+}
+
+export class Table extends Resource(
+  "dynamo::Table",
+  async (
+    ctx: Context<TableOutput>,
+    props: TableProps,
+  ): Promise<TableOutput> => {
+    const client = new DynamoDBClient({});
+
+    if (ctx.event === "delete") {
+      await ignore(ResourceNotFoundException.name, () =>
+        client.send(
+          new DeleteTableCommand({
+            TableName: props.tableName,
+          }),
+        ),
+      );
+
+      // Wait for table to be deleted
+      let tableDeleted = false;
+      while (!tableDeleted) {
+        try {
+          await client.send(
+            new DescribeTableCommand({
+              TableName: props.tableName,
+            }),
+          );
+          // If we get here, table still exists
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        } catch (error) {
+          if (error instanceof ResourceNotFoundException) {
+            tableDeleted = true;
+          } else {
+            throw error;
+          }
+        }
+      }
+
+      return {
+        ...props,
+        id: props.tableName,
+        arn: `arn:aws:dynamodb:${client.config.region}:${process.env.AWS_ACCOUNT_ID}:table/${props.tableName}`,
+        tableId: "",
+      };
+    } else {
+      try {
+        const attributeDefinitions = [
+          {
+            AttributeName: props.partitionKey.name,
+            AttributeType: props.partitionKey.type,
+          },
+        ];
+
+        const keySchema: KeySchemaElement[] = [
+          {
+            AttributeName: props.partitionKey.name,
+            KeyType: "HASH",
+          },
+        ];
+
+        if (props.sortKey) {
+          attributeDefinitions.push({
+            AttributeName: props.sortKey.name,
+            AttributeType: props.sortKey.type,
+          });
+          keySchema.push({
+            AttributeName: props.sortKey.name,
+            KeyType: "RANGE",
+          });
+        }
+
+        await client.send(
+          new CreateTableCommand({
+            TableName: props.tableName,
+            AttributeDefinitions: attributeDefinitions,
+            KeySchema: keySchema,
+            BillingMode: props.billingMode || "PAY_PER_REQUEST",
+            ProvisionedThroughput:
+              props.billingMode === "PROVISIONED"
+                ? {
+                    ReadCapacityUnits: props.readCapacity || 5,
+                    WriteCapacityUnits: props.writeCapacity || 5,
+                  }
+                : undefined,
+            Tags: props.tags
+              ? Object.entries(props.tags).map(([Key, Value]) => ({
+                  Key,
+                  Value,
+                }))
+              : undefined,
+          }),
+        );
+
+        // Wait for table to be active
+        let tableActive = false;
+        let tableDescription;
+        while (!tableActive) {
+          const response = await client.send(
+            new DescribeTableCommand({
+              TableName: props.tableName,
+            }),
+          );
+          tableActive = response.Table?.TableStatus === "ACTIVE";
+          if (tableActive) {
+            tableDescription = response.Table;
+          } else {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          }
+        }
+
+        return {
+          ...props,
+          id: props.tableName,
+          arn: tableDescription!.TableArn!,
+          streamArn: tableDescription!.LatestStreamArn,
+          tableId: tableDescription!.TableId!,
+        };
+      } catch (error) {
+        if (error instanceof ResourceInUseException) {
+          // Table already exists, get its details
+          const response = await client.send(
+            new DescribeTableCommand({
+              TableName: props.tableName,
+            }),
+          );
+          return {
+            ...props,
+            id: props.tableName,
+            arn: response.Table!.TableArn!,
+            streamArn: response.Table!.LatestStreamArn,
+            tableId: response.Table!.TableId!,
+          };
+        }
+        throw error;
+      }
+    }
+  },
+) {}