alchemy 2.0.0-beta.30 → 2.0.0-beta.31

package/src/AWS/EC2/Route.ts

@@ -149,103 +149,71 @@ export const RouteProvider = () =>
           // Target change can be done via ReplaceRoute (update)
         }),
 
-        create: Effect.fn(function* ({ news, session }) {
-          // Call CreateRoute
-          yield* ec2
-            .createRoute({
-              RouteTableId: news.routeTableId,
-              DestinationCidrBlock: news.destinationCidrBlock,
-              DestinationIpv6CidrBlock: news.destinationIpv6CidrBlock,
-              DestinationPrefixListId: news.destinationPrefixListId,
-              GatewayId: news.gatewayId,
-              NatGatewayId: news.natGatewayId,
-              InstanceId: news.instanceId,
-              NetworkInterfaceId: news.networkInterfaceId,
-              VpcPeeringConnectionId: news.vpcPeeringConnectionId,
-              TransitGatewayId: news.transitGatewayId,
-              LocalGatewayId: news.localGatewayId,
-              CarrierGatewayId: news.carrierGatewayId,
-              EgressOnlyInternetGatewayId: news.egressOnlyInternetGatewayId,
-              CoreNetworkArn: news.coreNetworkArn,
-              VpcEndpointId: news.vpcEndpointId,
-              DryRun: false,
-            })
-            .pipe(
-              Effect.retry({
-                // Retry if route table is not yet available
-                while: (e) => e._tag === "InvalidRouteTableID.NotFound",
-                schedule: Schedule.exponential(100),
-              }),
-            );
-
+        reconcile: Effect.fn(function* ({ news, session }) {
           const dest =
             news.destinationCidrBlock ||
             news.destinationIpv6CidrBlock ||
             news.destinationPrefixListId ||
             "unknown";
-          yield* session.note(`Route created: ${dest}`);
-
-          // Describe to get route details
-          const route = yield* describeRoute(news.routeTableId, news);
 
-          // Return attributes
-          return {
-            routeTableId: news.routeTableId,
-            destinationCidrBlock: news.destinationCidrBlock,
-            destinationIpv6CidrBlock: news.destinationIpv6CidrBlock,
-            destinationPrefixListId: news.destinationPrefixListId,
-            origin: route?.Origin ?? "CreateRoute",
-            state: route?.State ?? "active",
-            gatewayId: route?.GatewayId,
-            natGatewayId: route?.NatGatewayId,
-            instanceId: route?.InstanceId,
-            networkInterfaceId: route?.NetworkInterfaceId,
-            vpcPeeringConnectionId: route?.VpcPeeringConnectionId,
-            transitGatewayId: route?.TransitGatewayId,
-            localGatewayId: route?.LocalGatewayId,
-            carrierGatewayId: route?.CarrierGatewayId,
-            egressOnlyInternetGatewayId: route?.EgressOnlyInternetGatewayId,
-            coreNetworkArn: route?.CoreNetworkArn,
-          };
-        }),
-
-        update: Effect.fn(function* ({ news, output, session }) {
-          // Use ReplaceRoute to update the target
-          yield* ec2
-            .replaceRoute({
-              RouteTableId: news.routeTableId,
-              DestinationCidrBlock: news.destinationCidrBlock,
-              DestinationIpv6CidrBlock: news.destinationIpv6CidrBlock,
-              DestinationPrefixListId: news.destinationPrefixListId,
-              GatewayId: news.gatewayId,
-              NatGatewayId: news.natGatewayId,
-              InstanceId: news.instanceId,
-              NetworkInterfaceId: news.networkInterfaceId,
-              VpcPeeringConnectionId: news.vpcPeeringConnectionId,
-              TransitGatewayId: news.transitGatewayId,
-              LocalGatewayId: news.localGatewayId,
-              CarrierGatewayId: news.carrierGatewayId,
-              EgressOnlyInternetGatewayId: news.egressOnlyInternetGatewayId,
-              CoreNetworkArn: news.coreNetworkArn,
-              DryRun: false,
-            })
-            .pipe(
+          const targetParams = {
+            RouteTableId: news.routeTableId,
+            DestinationCidrBlock: news.destinationCidrBlock,
+            DestinationIpv6CidrBlock: news.destinationIpv6CidrBlock,
+            DestinationPrefixListId: news.destinationPrefixListId,
+            GatewayId: news.gatewayId,
+            NatGatewayId: news.natGatewayId,
+            InstanceId: news.instanceId,
+            NetworkInterfaceId: news.networkInterfaceId,
+            VpcPeeringConnectionId: news.vpcPeeringConnectionId,
+            TransitGatewayId: news.transitGatewayId,
+            LocalGatewayId: news.localGatewayId,
+            CarrierGatewayId: news.carrierGatewayId,
+            EgressOnlyInternetGatewayId: news.egressOnlyInternetGatewayId,
+            CoreNetworkArn: news.coreNetworkArn,
+            DryRun: false,
+          } as const;
+
+          // Observe — Routes are identified by (routeTableId, destination).
+          // Look the route up in the route table to decide between create
+          // (missing) and replaceRoute (target drift).
+          const observed = yield* describeRoute(news.routeTableId, news);
+
+          // Ensure / Sync — CreateRoute when missing, ReplaceRoute swaps the
+          // target on an existing route in-place.
+          if (observed === undefined) {
+            yield* ec2
+              .createRoute({
+                ...targetParams,
+                VpcEndpointId: news.vpcEndpointId,
+              })
+              .pipe(
+                Effect.retry({
+                  while: (e) => e._tag === "InvalidRouteTableID.NotFound",
+                  schedule: Schedule.exponential(100),
+                }),
+              );
+            yield* session.note(`Route created: ${dest}`);
+          } else {
+            yield* ec2.replaceRoute(targetParams).pipe(
               Effect.tapError(Effect.log),
               Effect.retry({
                 while: (e) => e._tag === "InvalidRouteTableID.NotFound",
                 schedule: Schedule.exponential(100),
               }),
             );
+            yield* session.note(`Route target updated: ${dest}`);
+          }
 
-          yield* session.note("Route target updated");
-
-          // Describe to get updated route details
+          // Re-read final state.
           const route = yield* describeRoute(news.routeTableId, news);
-
           return {
-            ...output,
-            origin: route?.Origin ?? output.origin,
-            state: route?.State ?? output.state,
+            routeTableId: news.routeTableId,
+            destinationCidrBlock: news.destinationCidrBlock,
+            destinationIpv6CidrBlock: news.destinationIpv6CidrBlock,
+            destinationPrefixListId: news.destinationPrefixListId,
+            origin: route?.Origin ?? "CreateRoute",
+            state: route?.State ?? "active",
             gatewayId: route?.GatewayId,
             natGatewayId: route?.NatGatewayId,
             instanceId: route?.InstanceId,

package/src/AWS/EC2/RouteTable.ts

@@ -9,7 +9,7 @@ import { isResolved } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import type { Providers } from "../Providers.ts";
-import { createInternalTags, createTagsList } from "../../Tags.ts";
+import { createInternalTags, createTagsList, diffTags } from "../../Tags.ts";
 import type { AccountID } from "../Environment.ts";
 import { AWSEnvironment } from "../Environment.ts";
 import type { RegionID } from "../Region.ts";
@@ -191,123 +191,78 @@ export const RouteTableProvider = () =>
           // Tags can be updated in-place
         }),
 
-        create: Effect.fn(function* ({ id, news, session }) {
-          // 1. Prepare tags
+        reconcile: Effect.fn(function* ({ id, news, output, session }) {
           const alchemyTags = yield* createInternalTags(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(routeTableId, session);
-
-          // 4. Return attributes
-          return {
-            routeTableId,
-            routeTableArn:
-              `arn:aws:ec2:${region}:${accountId}:route-table/${routeTableId}` as `arn:aws:ec2:${RegionID}:${AccountID}:route-table/${string}`,
-            vpcId: news.vpcId as 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!,
-            })),
-          };
-        }),
-
-        update: Effect.fn(function* ({ id, news, olds, output, session }) {
-          const routeTableId = output.routeTableId;
-
-          // Handle tag updates
-          if (
-            JSON.stringify(news.tags ?? {}) !== JSON.stringify(olds.tags ?? {})
-          ) {
-            const alchemyTags = yield* createInternalTags(id);
-            const userTags = news.tags ?? {};
-            const allTags = { ...alchemyTags, ...userTags };
+          const desiredTags = { ...alchemyTags, ...(news.tags ?? {}) };
+
+          // Observe — find the route table via cached id, else fall through
+          // to create.
+          let routeTable: ec2.RouteTable | undefined;
+          if (output?.routeTableId) {
+            const lookup = yield* ec2
+              .describeRouteTables({ RouteTableIds: [output.routeTableId] })
+              .pipe(
+                Effect.catchTag("InvalidRouteTableID.NotFound", () =>
+                  Effect.succeed({ RouteTables: [] }),
+                ),
+              );
+            routeTable = lookup.RouteTables?.[0];
+          }
 
-            // 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),
-            );
+          // Ensure — create the route table when missing.
+          if (routeTable === undefined) {
+            const createResult = yield* ec2
+              .createRouteTable({
+                VpcId: news.vpcId,
+                TagSpecifications: [
+                  {
+                    ResourceType: "route-table",
+                    Tags: createTagsList(desiredTags),
+                  },
+                ],
+                DryRun: false,
+              })
+              .pipe(
+                Effect.retry({
+                  while: (e) => e._tag === "InvalidVpcID.NotFound",
+                  schedule: Schedule.exponential(100),
+                }),
+              );
+            const newId = createResult.RouteTable!
+              .RouteTableId! as RouteTableId;
+            yield* session.note(`Route table created: ${newId}`);
+            routeTable = yield* describeRouteTable(newId, session);
+          }
 
-            if (tagsToDelete.length > 0) {
-              yield* ec2.deleteTags({
-                Resources: [routeTableId],
-                Tags: tagsToDelete.map((key) => ({ Key: key })),
-              });
-            }
+          const routeTableId = routeTable.RouteTableId! as RouteTableId;
 
-            // Create/update tags
+          // Sync tags — observed cloud tags vs desired.
+          const currentTags = Object.fromEntries(
+            (routeTable.Tags ?? []).map((t) => [t.Key!, t.Value!]),
+          ) as Record<string, string>;
+          const { removed, upsert } = diffTags(currentTags, desiredTags);
+          if (removed.length > 0) {
+            yield* ec2.deleteTags({
+              Resources: [routeTableId],
+              Tags: removed.map((key) => ({ Key: key })),
+            });
+          }
+          if (upsert.length > 0) {
             yield* ec2.createTags({
               Resources: [routeTableId],
-              Tags: createTagsList(allTags),
+              Tags: upsert,
             });
-
-            yield* session.note("Updated tags");
           }
 
-          // Re-describe to get current state
-          const routeTable = yield* describeRouteTable(routeTableId, session);
-
+          // Re-read final state.
+          const final = yield* describeRouteTable(routeTableId, session);
           return {
-            ...output,
-            associations: routeTable.Associations?.map((assoc) => ({
+            routeTableId,
+            routeTableArn:
+              `arn:aws:ec2:${region}:${accountId}:route-table/${routeTableId}` as `arn:aws:ec2:${RegionID}:${AccountID}:route-table/${string}`,
+            vpcId: news.vpcId as VpcId,
+            ownerId: final.OwnerId,
+            associations: final.Associations?.map((assoc) => ({
               main: assoc.Main ?? false,
               routeTableAssociationId: assoc.RouteTableAssociationId,
               routeTableId: assoc.RouteTableId,
@@ -320,7 +275,7 @@ export const RouteTableProvider = () =>
                   }
                 : undefined,
             })),
-            routes: routeTable.Routes?.map((route) => ({
+            routes: final.Routes?.map((route) => ({
               destinationCidrBlock: route.DestinationCidrBlock,
               destinationIpv6CidrBlock: route.DestinationIpv6CidrBlock,
               destinationPrefixListId: route.DestinationPrefixListId,
@@ -338,7 +293,7 @@ export const RouteTableProvider = () =>
               vpcPeeringConnectionId: route.VpcPeeringConnectionId,
               coreNetworkArn: route.CoreNetworkArn,
             })),
-            propagatingVgws: routeTable.PropagatingVgws?.map((vgw) => ({
+            propagatingVgws: final.PropagatingVgws?.map((vgw) => ({
               gatewayId: vgw.GatewayId!,
             })),
           };

package/src/AWS/EC2/RouteTableAssociation.ts

@@ -95,75 +95,112 @@ export const RouteTableAssociationProvider = () =>
           // 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(
-            news.routeTableId,
-            associationId,
-            "associated",
-            session,
-          );
+        reconcile: Effect.fn(function* ({ news, output, session }) {
+          // Observe — try the cached associationId first; if the association
+          // was disassociated out-of-band, fall through to AssociateRouteTable.
+          let observed:
+            | {
+                associationId: string;
+                routeTableId: string;
+                subnetId?: string;
+                gatewayId?: string;
+                state?: EC2.RouteTableAssociationStateCode;
+                statusMessage?: string;
+              }
+            | undefined;
+          if (output?.associationId) {
+            const lookup = yield* ec2
+              .describeRouteTables({
+                Filters: [
+                  {
+                    Name: "association.route-table-association-id",
+                    Values: [output.associationId],
+                  },
+                ],
+              })
+              .pipe(
+                Effect.catchTag("InvalidRouteTableID.NotFound", () =>
+                  Effect.succeed({ RouteTables: [] }),
+                ),
+              );
+            for (const rt of lookup.RouteTables ?? []) {
+              const assoc = rt.Associations?.find(
+                (a) => a.RouteTableAssociationId === output.associationId,
+              );
+              if (assoc) {
+                observed = {
+                  associationId: assoc.RouteTableAssociationId!,
+                  routeTableId: assoc.RouteTableId!,
+                  subnetId: assoc.SubnetId,
+                  gatewayId: assoc.GatewayId,
+                  state: assoc.AssociationState?.State,
+                  statusMessage: assoc.AssociationState?.StatusMessage,
+                };
+                break;
+              }
+            }
+          }
 
-          // Return attributes
-          return {
-            associationId,
-            routeTableId: news.routeTableId as RouteTableId,
-            subnetId: news.subnetId as SubnetId | undefined,
-            gatewayId: news.gatewayId as string | undefined,
-            associationState: {
-              state: result.AssociationState?.State ?? "associated",
-              statusMessage: result.AssociationState?.StatusMessage,
-            },
-          };
-        }),
+          // Ensure — no existing association ⇒ AssociateRouteTable.
+          if (observed === undefined) {
+            const result = yield* ec2
+              .associateRouteTable({
+                RouteTableId: news.routeTableId,
+                SubnetId: news.subnetId,
+                GatewayId: news.gatewayId,
+                DryRun: false,
+              })
+              .pipe(
+                Effect.retry({
+                  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}`,
+            );
+            yield* waitForAssociationState(
+              news.routeTableId,
+              associationId,
+              "associated",
+              session,
+            );
+            return {
+              associationId,
+              routeTableId: news.routeTableId as RouteTableId,
+              subnetId: news.subnetId as SubnetId | undefined,
+              gatewayId: news.gatewayId as string | undefined,
+              associationState: {
+                state: result.AssociationState?.State ?? "associated",
+                statusMessage: result.AssociationState?.StatusMessage,
+              },
+            };
+          }
 
-        update: Effect.fn(function* ({ news, olds, output, session }) {
-          // If route table changed, use ReplaceRouteTableAssociation
-          if (news.routeTableId !== olds.routeTableId) {
+          // Sync — drift in routeTableId is patched in place by
+          // ReplaceRouteTableAssociation. Subnet/gateway changes are
+          // intercepted upstream by `diff` as a replacement.
+          if (observed.routeTableId !== (news.routeTableId as string)) {
             const result = yield* ec2.replaceRouteTableAssociation({
-              AssociationId: output.associationId,
+              AssociationId: observed.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(
               news.routeTableId,
               newAssociationId,
               "associated",
               session,
             );
-
             return {
               associationId: newAssociationId,
               routeTableId: news.routeTableId as RouteTableId,
@@ -176,8 +213,17 @@ export const RouteTableAssociationProvider = () =>
             };
           }
 
-          // No changes needed
-          return output;
+          // Already in the desired state — just report it.
+          return {
+            associationId: observed.associationId as RouteTableAssociationId,
+            routeTableId: observed.routeTableId as RouteTableId,
+            subnetId: observed.subnetId as SubnetId | undefined,
+            gatewayId: observed.gatewayId,
+            associationState: {
+              state: observed.state ?? "associated",
+              statusMessage: observed.statusMessage,
+            },
+          };
         }),
 
         delete: Effect.fn(function* ({ output, session }) {