alchemy-effect 0.2.0 → 0.4.0

package/src/aws/ec2/internet-gateway.ts

@@ -0,0 +1,79 @@
+import type { Input } from "../../input.ts";
+import { Resource } from "../../resource.ts";
+import type { AccountID } from "../account.ts";
+import type { RegionID } from "../region.ts";
+import type { VpcId } from "./vpc.ts";
+
+export const InternetGateway = Resource<{
+  <const ID extends string, const Props extends InternetGatewayProps>(
+    id: ID,
+    props: Props,
+  ): InternetGateway<ID, Props>;
+}>("AWS.EC2.InternetGateway");
+
+export interface InternetGateway<
+  ID extends string = string,
+  Props extends InternetGatewayProps = InternetGatewayProps,
+> extends Resource<
+    "AWS.EC2.InternetGateway",
+    ID,
+    Props,
+    InternetGatewayAttrs<Input.Resolve<Props>>,
+    InternetGateway
+  > {}
+
+export type InternetGatewayId<ID extends string = string> = `igw-${ID}`;
+export const InternetGatewayId = <ID extends string>(
+  id: ID,
+): ID & InternetGatewayId<ID> => `igw-${id}` as ID & InternetGatewayId<ID>;
+
+export interface InternetGatewayProps {
+  /**
+   * The VPC to attach the internet gateway to.
+   * If provided, the internet gateway will be automatically attached to the VPC.
+   * Optional - you can create an unattached internet gateway and attach it later.
+   */
+  vpcId?: Input<VpcId>;
+
+  /**
+   * Tags to assign to the internet gateway.
+   * These will be merged with alchemy auto-tags (alchemy::app, alchemy::stage, alchemy::id).
+   */
+  tags?: Record<string, Input<string>>;
+}
+
+export interface InternetGatewayAttrs<Props extends InternetGatewayProps> {
+  /**
+   * The ID of the internet gateway.
+   */
+  internetGatewayId: InternetGatewayId;
+
+  /**
+   * The Amazon Resource Name (ARN) of the internet gateway.
+   */
+  internetGatewayArn: `arn:aws:ec2:${RegionID}:${AccountID}:internet-gateway/${this["internetGatewayId"]}`;
+
+  /**
+   * The ID of the VPC the internet gateway is attached to (if any).
+   */
+  vpcId?: Props["vpcId"];
+
+  /**
+   * The ID of the AWS account that owns the internet gateway.
+   */
+  ownerId?: string;
+
+  /**
+   * The attachments for the internet gateway.
+   */
+  attachments?: Array<{
+    /**
+     * The current state of the attachment.
+     */
+    state: "attaching" | "available" | "detaching" | "detached";
+    /**
+     * The ID of the VPC.
+     */
+    vpcId: string;
+  }>;
+}

package/src/aws/ec2/route-table-association.provider.ts

@@ -0,0 +1,214 @@
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
+import type { ProviderService } from "../../provider.ts";
+import { EC2Client } from "./client.ts";
+import {
+  RouteTableAssociation,
+  type RouteTableAssociationAttrs,
+  type RouteTableAssociationId,
+  type RouteTableAssociationProps,
+} from "./route-table-association.ts";
+
+export const routeTableAssociationProvider = () =>
+  RouteTableAssociation.provider.effect(
+    Effect.gen(function* () {
+      const ec2 = yield* EC2Client;
+
+      return {
+        stables: ["associationId", "subnetId", "gatewayId"],
+        diff: Effect.fn(function* ({ news, olds }) {
+          // Subnet/Gateway change requires replacement (use ReplaceRouteTableAssociation internally)
+          if (olds.subnetId !== news.subnetId) {
+            return { action: "replace" };
+          }
+          if (olds.gatewayId !== news.gatewayId) {
+            return { action: "replace" };
+          }
+          // Route table change can be done via ReplaceRouteTableAssociation
+        }),
+
+        create: Effect.fn(function* ({ news, session }) {
+          // Call AssociateRouteTable
+          const result = yield* ec2
+            .associateRouteTable({
+              RouteTableId: news.routeTableId,
+              SubnetId: news.subnetId,
+              GatewayId: news.gatewayId,
+              DryRun: false,
+            })
+            .pipe(
+              Effect.retry({
+                // Retry if route table or subnet/gateway is not yet available
+                while: (e) =>
+                  e._tag === "InvalidRouteTableID.NotFound" ||
+                  e._tag === "InvalidSubnetID.NotFound",
+                schedule: Schedule.exponential(100),
+              }),
+            );
+
+          const associationId =
+            result.AssociationId! as RouteTableAssociationId;
+          yield* session.note(
+            `Route table association created: ${associationId}`,
+          );
+
+          // Wait for association to be associated
+          yield* waitForAssociationState(
+            ec2,
+            news.routeTableId,
+            associationId,
+            "associated",
+            session,
+          );
+
+          // Return attributes
+          return {
+            associationId,
+            routeTableId: news.routeTableId,
+            subnetId: news.subnetId,
+            gatewayId: news.gatewayId,
+            associationState: {
+              state: result.AssociationState?.State ?? "associated",
+              statusMessage: result.AssociationState?.StatusMessage,
+            },
+          } satisfies RouteTableAssociationAttrs<RouteTableAssociationProps>;
+        }),
+
+        update: Effect.fn(function* ({ news, olds, output, session }) {
+          // If route table changed, use ReplaceRouteTableAssociation
+          if (news.routeTableId !== olds.routeTableId) {
+            const result = yield* ec2.replaceRouteTableAssociation({
+              AssociationId: output.associationId,
+              RouteTableId: news.routeTableId,
+              DryRun: false,
+            });
+
+            const newAssociationId =
+              result.NewAssociationId! as RouteTableAssociationId;
+            yield* session.note(
+              `Route table association replaced: ${newAssociationId}`,
+            );
+
+            // Wait for new association to be associated
+            yield* waitForAssociationState(
+              ec2,
+              news.routeTableId,
+              newAssociationId,
+              "associated",
+              session,
+            );
+
+            return {
+              associationId: newAssociationId,
+              routeTableId: news.routeTableId,
+              subnetId: news.subnetId,
+              gatewayId: news.gatewayId,
+              associationState: {
+                state: result.AssociationState?.State ?? "associated",
+                statusMessage: result.AssociationState?.StatusMessage,
+              },
+            };
+          }
+
+          // No changes needed
+          return output;
+        }),
+
+        delete: Effect.fn(function* ({ output, session }) {
+          yield* session.note(
+            `Deleting route table association: ${output.associationId}`,
+          );
+
+          // Disassociate the route table
+          yield* ec2
+            .disassociateRouteTable({
+              AssociationId: output.associationId,
+              DryRun: false,
+            })
+            .pipe(
+              Effect.tapError(Effect.log),
+              Effect.catchTag(
+                "InvalidAssociationID.NotFound",
+                () => Effect.void,
+              ),
+            );
+
+          yield* session.note(
+            `Route table association ${output.associationId} deleted successfully`,
+          );
+        }),
+      } satisfies ProviderService<RouteTableAssociation>;
+    }),
+  );
+
+/**
+ * Wait for association to reach a specific state
+ */
+const waitForAssociationState = (
+  ec2: import("itty-aws/ec2").EC2,
+  routeTableId: string,
+  associationId: string,
+  targetState:
+    | "associating"
+    | "associated"
+    | "disassociating"
+    | "disassociated",
+  session?: ScopedPlanStatusSession,
+) =>
+  Effect.retry(
+    Effect.gen(function* () {
+      const result = yield* ec2
+        .describeRouteTables({ RouteTableIds: [routeTableId] })
+        .pipe(
+          Effect.catchTag("InvalidRouteTableID.NotFound", () =>
+            Effect.succeed({ RouteTables: [] }),
+          ),
+        );
+
+      const routeTable = result.RouteTables?.[0];
+      if (!routeTable) {
+        return yield* Effect.fail(new Error("Route table not found"));
+      }
+
+      const association = routeTable.Associations?.find(
+        (a) => a.RouteTableAssociationId === associationId,
+      );
+
+      if (!association) {
+        // Association might not exist yet, retry
+        return yield* Effect.fail(new Error("Association not found"));
+      }
+
+      if (association.AssociationState?.State === targetState) {
+        return;
+      }
+
+      if (association.AssociationState?.State === "failed") {
+        return yield* Effect.fail(
+          new Error(
+            `Association failed: ${association.AssociationState.StatusMessage}`,
+          ),
+        );
+      }
+
+      // Still in progress, fail to trigger retry
+      return yield* Effect.fail(
+        new Error(`Association state: ${association.AssociationState?.State}`),
+      );
+    }),
+    {
+      schedule: Schedule.fixed(1000).pipe(
+        // Check every second
+        Schedule.intersect(Schedule.recurs(30)), // Max 30 seconds
+        Schedule.tapOutput(([, attempt]) =>
+          session
+            ? session.note(
+                `Waiting for association to be ${targetState}... (${attempt + 1}s)`,
+              )
+            : Effect.void,
+        ),
+      ),
+    },
+  );

package/src/aws/ec2/route-table-association.ts

@@ -0,0 +1,82 @@
+import type * as EC2 from "itty-aws/ec2";
+import type { Input } from "../../input.ts";
+import { Resource } from "../../resource.ts";
+import type { RouteTableId } from "./route-table.ts";
+import type { SubnetId } from "./subnet.ts";
+
+export const RouteTableAssociation = Resource<{
+  <const ID extends string, const Props extends RouteTableAssociationProps>(
+    id: ID,
+    props: Props,
+  ): RouteTableAssociation<ID, Props>;
+}>("AWS.EC2.RouteTableAssociation");
+
+export interface RouteTableAssociation<
+  ID extends string = string,
+  Props extends RouteTableAssociationProps = RouteTableAssociationProps,
+> extends Resource<
+    "AWS.EC2.RouteTableAssociation",
+    ID,
+    Props,
+    RouteTableAssociationAttrs<Input.Resolve<Props>>,
+    RouteTableAssociation
+  > {}
+
+export type RouteTableAssociationId<ID extends string = string> =
+  `rtbassoc-${ID}`;
+export const RouteTableAssociationId = <ID extends string>(
+  id: ID,
+): ID & RouteTableAssociationId<ID> =>
+  `rtbassoc-${id}` as ID & RouteTableAssociationId<ID>;
+
+export interface RouteTableAssociationProps {
+  /**
+   * The ID of the route table.
+   * Required.
+   */
+  routeTableId: Input<RouteTableId>;
+
+  /**
+   * The ID of the subnet to associate with the route table.
+   * Either subnetId or gatewayId is required, but not both.
+   */
+  subnetId?: Input<SubnetId>;
+
+  /**
+   * The ID of the gateway (internet gateway or virtual private gateway) to associate with the route table.
+   * Either subnetId or gatewayId is required, but not both.
+   */
+  gatewayId?: Input<string>;
+}
+
+export interface RouteTableAssociationAttrs<
+  Props extends RouteTableAssociationProps,
+> {
+  /**
+   * The ID of the association.
+   */
+  associationId: RouteTableAssociationId;
+
+  /**
+   * The ID of the route table.
+   */
+  routeTableId: Props["routeTableId"];
+
+  /**
+   * The ID of the subnet (if the association is with a subnet).
+   */
+  subnetId?: Props["subnetId"];
+
+  /**
+   * The ID of the gateway (if the association is with a gateway).
+   */
+  gatewayId?: Props["gatewayId"];
+
+  /**
+   * The state of the association.
+   */
+  associationState: {
+    state: EC2.RouteTableAssociationStateCode;
+    statusMessage?: string;
+  };
+}

package/src/aws/ec2/route-table.provider.ts

@@ -0,0 +1,306 @@
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+
+import type { EC2 } from "itty-aws/ec2";
+
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
+import type { ProviderService } from "../../provider.ts";
+import { createTagger, createTagsList } from "../../tags.ts";
+import { Account } from "../account.ts";
+import { Region } from "../region.ts";
+import { EC2Client } from "./client.ts";
+import {
+  RouteTable,
+  type RouteTableAttrs,
+  type RouteTableId,
+  type RouteTableProps,
+} from "./route-table.ts";
+
+export const routeTableProvider = () =>
+  RouteTable.provider.effect(
+    Effect.gen(function* () {
+      const ec2 = yield* EC2Client;
+      const region = yield* Region;
+      const accountId = yield* Account;
+      const tagged = yield* createTagger();
+
+      return {
+        stables: ["routeTableId", "ownerId", "routeTableArn", "vpcId"],
+        diff: Effect.fn(function* ({ news, olds }) {
+          // VpcId change requires replacement
+          if (olds.vpcId !== news.vpcId) {
+            return { action: "replace" };
+          }
+          // Tags can be updated in-place
+        }),
+
+        create: Effect.fn(function* ({ id, news, session }) {
+          // 1. Prepare tags
+          const alchemyTags = tagged(id);
+          const userTags = news.tags ?? {};
+          const allTags = { ...alchemyTags, ...userTags };
+
+          // 2. Call CreateRouteTable
+          const createResult = yield* ec2
+            .createRouteTable({
+              VpcId: news.vpcId,
+              TagSpecifications: [
+                {
+                  ResourceType: "route-table",
+                  Tags: createTagsList(allTags),
+                },
+              ],
+              DryRun: false,
+            })
+            .pipe(
+              Effect.retry({
+                // Retry if VPC is not yet available
+                while: (e) => e._tag === "InvalidVpcID.NotFound",
+                schedule: Schedule.exponential(100),
+              }),
+            );
+
+          const routeTableId = createResult.RouteTable!
+            .RouteTableId! as RouteTableId;
+          yield* session.note(`Route table created: ${routeTableId}`);
+
+          // 3. Describe to get full details
+          const routeTable = yield* describeRouteTable(
+            ec2,
+            routeTableId,
+            session,
+          );
+
+          // 4. Return attributes
+          return {
+            routeTableId,
+            routeTableArn:
+              `arn:aws:ec2:${region}:${accountId}:route-table/${routeTableId}` as RouteTableAttrs<RouteTableProps>["routeTableArn"],
+            vpcId: news.vpcId,
+            ownerId: routeTable.OwnerId,
+            associations: routeTable.Associations?.map((assoc) => ({
+              main: assoc.Main ?? false,
+              routeTableAssociationId: assoc.RouteTableAssociationId,
+              routeTableId: assoc.RouteTableId,
+              subnetId: assoc.SubnetId,
+              gatewayId: assoc.GatewayId,
+              associationState: assoc.AssociationState
+                ? {
+                    state: assoc.AssociationState.State!,
+                    statusMessage: assoc.AssociationState.StatusMessage,
+                  }
+                : undefined,
+            })),
+            routes: routeTable.Routes?.map((route) => ({
+              destinationCidrBlock: route.DestinationCidrBlock,
+              destinationIpv6CidrBlock: route.DestinationIpv6CidrBlock,
+              destinationPrefixListId: route.DestinationPrefixListId,
+              egressOnlyInternetGatewayId: route.EgressOnlyInternetGatewayId,
+              gatewayId: route.GatewayId,
+              instanceId: route.InstanceId,
+              instanceOwnerId: route.InstanceOwnerId,
+              natGatewayId: route.NatGatewayId,
+              transitGatewayId: route.TransitGatewayId,
+              localGatewayId: route.LocalGatewayId,
+              carrierGatewayId: route.CarrierGatewayId,
+              networkInterfaceId: route.NetworkInterfaceId,
+              origin: route.Origin!,
+              state: route.State!,
+              vpcPeeringConnectionId: route.VpcPeeringConnectionId,
+              coreNetworkArn: route.CoreNetworkArn,
+            })),
+            propagatingVgws: routeTable.PropagatingVgws?.map((vgw) => ({
+              gatewayId: vgw.GatewayId!,
+            })),
+          } satisfies RouteTableAttrs<RouteTableProps>;
+        }),
+
+        update: Effect.fn(function* ({ news, olds, output, session }) {
+          const routeTableId = output.routeTableId;
+
+          // Handle tag updates
+          if (
+            JSON.stringify(news.tags ?? {}) !== JSON.stringify(olds.tags ?? {})
+          ) {
+            const alchemyTags = tagged(output.routeTableId);
+            const userTags = news.tags ?? {};
+            const allTags = { ...alchemyTags, ...userTags };
+
+            // Delete old tags that are no longer present
+            const oldTagKeys = Object.keys(olds.tags ?? {});
+            const newTagKeys = Object.keys(news.tags ?? {});
+            const tagsToDelete = oldTagKeys.filter(
+              (key) => !newTagKeys.includes(key),
+            );
+
+            if (tagsToDelete.length > 0) {
+              yield* ec2.deleteTags({
+                Resources: [routeTableId],
+                Tags: tagsToDelete.map((key) => ({ Key: key })),
+              });
+            }
+
+            // Create/update tags
+            yield* ec2.createTags({
+              Resources: [routeTableId],
+              Tags: createTagsList(allTags),
+            });
+
+            yield* session.note("Updated tags");
+          }
+
+          // Re-describe to get current state
+          const routeTable = yield* describeRouteTable(
+            ec2,
+            routeTableId,
+            session,
+          );
+
+          return {
+            ...output,
+            associations: routeTable.Associations?.map((assoc) => ({
+              main: assoc.Main ?? false,
+              routeTableAssociationId: assoc.RouteTableAssociationId,
+              routeTableId: assoc.RouteTableId,
+              subnetId: assoc.SubnetId,
+              gatewayId: assoc.GatewayId,
+              associationState: assoc.AssociationState
+                ? {
+                    state: assoc.AssociationState.State!,
+                    statusMessage: assoc.AssociationState.StatusMessage,
+                  }
+                : undefined,
+            })),
+            routes: routeTable.Routes?.map((route) => ({
+              destinationCidrBlock: route.DestinationCidrBlock,
+              destinationIpv6CidrBlock: route.DestinationIpv6CidrBlock,
+              destinationPrefixListId: route.DestinationPrefixListId,
+              egressOnlyInternetGatewayId: route.EgressOnlyInternetGatewayId,
+              gatewayId: route.GatewayId,
+              instanceId: route.InstanceId,
+              instanceOwnerId: route.InstanceOwnerId,
+              natGatewayId: route.NatGatewayId,
+              transitGatewayId: route.TransitGatewayId,
+              localGatewayId: route.LocalGatewayId,
+              carrierGatewayId: route.CarrierGatewayId,
+              networkInterfaceId: route.NetworkInterfaceId,
+              origin: route.Origin!,
+              state: route.State!,
+              vpcPeeringConnectionId: route.VpcPeeringConnectionId,
+              coreNetworkArn: route.CoreNetworkArn,
+            })),
+            propagatingVgws: routeTable.PropagatingVgws?.map((vgw) => ({
+              gatewayId: vgw.GatewayId!,
+            })),
+          };
+        }),
+
+        delete: Effect.fn(function* ({ output, session }) {
+          const routeTableId = output.routeTableId;
+
+          yield* session.note(`Deleting route table: ${routeTableId}`);
+
+          // 1. Attempt to delete route table
+          yield* ec2
+            .deleteRouteTable({
+              RouteTableId: routeTableId,
+              DryRun: false,
+            })
+            .pipe(
+              Effect.tapError(Effect.logDebug),
+              Effect.catchTag(
+                "InvalidRouteTableID.NotFound",
+                () => Effect.void,
+              ),
+              // Retry on dependency violations (associations still being deleted)
+              Effect.retry({
+                // DependencyViolation means there are still dependent resources
+                while: (e) => {
+                  return e._tag === "DependencyViolation";
+                },
+                schedule: Schedule.exponential(1000, 1.5).pipe(
+                  Schedule.intersect(Schedule.recurs(10)), // Try up to 10 times
+                  Schedule.tapOutput(([, attempt]) =>
+                    session.note(
+                      `Waiting for dependencies to clear... (attempt ${attempt + 1})`,
+                    ),
+                  ),
+                ),
+              }),
+            );
+
+          // 2. Wait for route table to be fully deleted
+          yield* waitForRouteTableDeleted(ec2, routeTableId, session);
+
+          yield* session.note(
+            `Route table ${routeTableId} deleted successfully`,
+          );
+        }),
+      } satisfies ProviderService<RouteTable>;
+    }),
+  );
+
+/**
+ * Describe a route table by ID
+ */
+const describeRouteTable = (
+  ec2: EC2,
+  routeTableId: string,
+  _session?: ScopedPlanStatusSession,
+) =>
+  Effect.gen(function* () {
+    const result = yield* ec2
+      .describeRouteTables({ RouteTableIds: [routeTableId] })
+      .pipe(
+        Effect.catchTag("InvalidRouteTableID.NotFound", () =>
+          Effect.succeed({ RouteTables: [] }),
+        ),
+      );
+
+    const routeTable = result.RouteTables?.[0];
+    if (!routeTable) {
+      return yield* Effect.fail(new Error("Route table not found"));
+    }
+    return routeTable;
+  });
+
+/**
+ * Wait for route table to be deleted
+ */
+const waitForRouteTableDeleted = (
+  ec2: EC2,
+  routeTableId: string,
+  session: ScopedPlanStatusSession,
+) =>
+  Effect.gen(function* () {
+    yield* Effect.retry(
+      Effect.gen(function* () {
+        const result = yield* ec2
+          .describeRouteTables({ RouteTableIds: [routeTableId] })
+          .pipe(
+            Effect.tapError(Effect.logDebug),
+            Effect.catchTag("InvalidRouteTableID.NotFound", () =>
+              Effect.succeed({ RouteTables: [] }),
+            ),
+          );
+
+        if (!result.RouteTables || result.RouteTables.length === 0) {
+          return; // Successfully deleted
+        }
+
+        // Still exists, fail to trigger retry
+        return yield* Effect.fail(new Error("Route table still exists"));
+      }),
+      {
+        schedule: Schedule.fixed(2000).pipe(
+          // Check every 2 seconds
+          Schedule.intersect(Schedule.recurs(15)), // Max 30 seconds
+          Schedule.tapOutput(([, attempt]) =>
+            session.note(
+              `Waiting for route table deletion... (${(attempt + 1) * 2}s)`,
+            ),
+          ),
+        ),
+      },
+    );
+  });