alchemy-effect 0.3.0 → 0.4.0

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)`,
+            ),
+          ),
+        ),
+      },
+    );
+  });

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

@@ -0,0 +1,175 @@
+import type * as EC2 from "itty-aws/ec2";
+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 RouteTable = Resource<{
+  <const ID extends string, const Props extends RouteTableProps>(
+    id: ID,
+    props: Props,
+  ): RouteTable<ID, Props>;
+}>("AWS.EC2.RouteTable");
+
+export interface RouteTable<
+  ID extends string = string,
+  Props extends RouteTableProps = RouteTableProps,
+> extends Resource<
+    "AWS.EC2.RouteTable",
+    ID,
+    Props,
+    RouteTableAttrs<Input.Resolve<Props>>,
+    RouteTable
+  > {}
+
+export type RouteTableId<ID extends string = string> = `rtb-${ID}`;
+export const RouteTableId = <ID extends string>(
+  id: ID,
+): ID & RouteTableId<ID> => `rtb-${id}` as ID & RouteTableId<ID>;
+
+export interface RouteTableProps {
+  /**
+   * The VPC to create the route table in.
+   * Required.
+   */
+  vpcId: Input<VpcId>;
+
+  /**
+   * Tags to assign to the route table.
+   * These will be merged with alchemy auto-tags (alchemy::app, alchemy::stage, alchemy::id).
+   */
+  tags?: Record<string, Input<string>>;
+}
+
+export interface RouteTableAttrs<Props extends RouteTableProps> {
+  /**
+   * The ID of the VPC the route table is in.
+   */
+  vpcId: Props["vpcId"];
+
+  /**
+   * The ID of the route table.
+   */
+  routeTableId: RouteTableId;
+
+  /**
+   * The Amazon Resource Name (ARN) of the route table.
+   */
+  routeTableArn: `arn:aws:ec2:${RegionID}:${AccountID}:route-table/${this["routeTableId"]}`;
+
+  /**
+   * The ID of the AWS account that owns the route table.
+   */
+  ownerId?: string;
+
+  /**
+   * The associations between the route table and subnets or gateways.
+   */
+  associations?: Array<{
+    /**
+     * Whether this is the main route table for the VPC.
+     */
+    main: boolean;
+    /**
+     * The ID of the association.
+     */
+    routeTableAssociationId?: string;
+    /**
+     * The ID of the route table.
+     */
+    routeTableId?: string;
+    /**
+     * The ID of the subnet (if the association is with a subnet).
+     */
+    subnetId?: string;
+    /**
+     * The ID of the gateway (if the association is with a gateway).
+     */
+    gatewayId?: string;
+    /**
+     * The state of the association.
+     */
+    associationState?: {
+      state: EC2.RouteTableAssociationStateCode;
+      statusMessage?: string;
+    };
+  }>;
+
+  /**
+   * The routes in the route table.
+   */
+  routes?: Array<{
+    /**
+     * The IPv4 CIDR block used for the destination match.
+     */
+    destinationCidrBlock?: string;
+    /**
+     * The IPv6 CIDR block used for the destination match.
+     */
+    destinationIpv6CidrBlock?: string;
+    /**
+     * The prefix of the AWS service.
+     */
+    destinationPrefixListId?: string;
+    /**
+     * The ID of the egress-only internet gateway.
+     */
+    egressOnlyInternetGatewayId?: string;
+    /**
+     * The ID of the gateway (internet gateway or virtual private gateway).
+     */
+    gatewayId?: string;
+    /**
+     * The ID of the NAT instance.
+     */
+    instanceId?: string;
+    /**
+     * The ID of AWS account that owns the NAT instance.
+     */
+    instanceOwnerId?: string;
+    /**
+     * The ID of the NAT gateway.
+     */
+    natGatewayId?: string;
+    /**
+     * The ID of the transit gateway.
+     */
+    transitGatewayId?: string;
+    /**
+     * The ID of the local gateway.
+     */
+    localGatewayId?: string;
+    /**
+     * The ID of the carrier gateway.
+     */
+    carrierGatewayId?: string;
+    /**
+     * The ID of the network interface.
+     */
+    networkInterfaceId?: string;
+    /**
+     * Describes how the route was created.
+     */
+    origin: EC2.RouteOrigin;
+    /**
+     * The state of the route.
+     */
+    state: EC2.RouteState;
+    /**
+     * The ID of the VPC peering connection.
+     */
+    vpcPeeringConnectionId?: string;
+    /**
+     * The Amazon Resource Name (ARN) of the core network.
+     */
+    coreNetworkArn?: string;
+  }>;
+
+  /**
+   * Any virtual private gateway (VGW) propagating routes.
+   */
+  propagatingVgws?: Array<{
+    gatewayId: string;
+  }>;
+}