alchemy-effect 0.6.0 → 0.6.2

package/src/aws/ec2/network-acl.provider.ts

@@ -1,195 +0,0 @@
-import type * as EC2 from "itty-aws/ec2";
-import * as Effect from "effect/Effect";
-import * as Schedule from "effect/Schedule";
-
-import { createTagger, createTagsList, diffTags } from "../../tags.ts";
-import { Account } from "../account.ts";
-import { Region } from "../region.ts";
-import { EC2Client } from "./client.ts";
-import {
-  type NetworkAclArn,
-  NetworkAcl,
-  type NetworkAclAttrs,
-  type NetworkAclId,
-} from "./network-acl.ts";
-import type { VpcId } from "./vpc.ts";
-
-export const networkAclProvider = () =>
-  NetworkAcl.provider.effect(
-    Effect.gen(function* () {
-      const ec2 = yield* EC2Client;
-      const region = yield* Region;
-      const accountId = yield* Account;
-      const tagged = yield* createTagger();
-
-      const createTags = (
-        id: string,
-        tags?: Record<string, string>,
-      ): Record<string, string> => ({
-        Name: id,
-        ...tagged(id),
-        ...tags,
-      });
-
-      const describeNetworkAcl = (networkAclId: string) =>
-        ec2.describeNetworkAcls({ NetworkAclIds: [networkAclId] }).pipe(
-          Effect.map((r) => r.NetworkAcls?.[0]),
-          Effect.flatMap((acl) =>
-            acl
-              ? Effect.succeed(acl)
-              : Effect.fail(new Error(`Network ACL ${networkAclId} not found`)),
-          ),
-        );
-
-      const toAttrs = (acl: EC2.NetworkAcl): NetworkAclAttrs => ({
-        networkAclId: acl.NetworkAclId as NetworkAclId,
-        networkAclArn:
-          `arn:aws:ec2:${region}:${accountId}:network-acl/${acl.NetworkAclId}` as NetworkAclArn,
-        vpcId: acl.VpcId as VpcId,
-        isDefault: acl.IsDefault ?? false,
-        ownerId: acl.OwnerId!,
-        entries: acl.Entries?.map((e) => ({
-          ruleNumber: e.RuleNumber!,
-          protocol: e.Protocol!,
-          ruleAction: e.RuleAction!,
-          egress: e.Egress!,
-          cidrBlock: e.CidrBlock,
-          ipv6CidrBlock: e.Ipv6CidrBlock,
-          icmpTypeCode: e.IcmpTypeCode
-            ? {
-                code: e.IcmpTypeCode.Code,
-                type: e.IcmpTypeCode.Type,
-              }
-            : undefined,
-          portRange: e.PortRange
-            ? {
-                from: e.PortRange.From,
-                to: e.PortRange.To,
-              }
-            : undefined,
-        })),
-        associations: acl.Associations?.map((a) => ({
-          networkAclAssociationId: a.NetworkAclAssociationId!,
-          networkAclId: a.NetworkAclId!,
-          subnetId: a.SubnetId!,
-        })),
-      });
-
-      return {
-        stables: ["networkAclId", "networkAclArn", "ownerId", "isDefault"],
-
-        read: Effect.fn(function* ({ output }) {
-          if (!output) return undefined;
-          const acl = yield* describeNetworkAcl(output.networkAclId);
-          return toAttrs(acl);
-        }),
-
-        diff: Effect.fn(function* ({ news, olds }) {
-          // VPC change requires replacement
-          if (news.vpcId !== olds.vpcId) {
-            return { action: "replace" };
-          }
-          // Tags can be updated in-place
-        }),
-
-        create: Effect.fn(function* ({ id, news, session }) {
-          yield* session.note("Creating Network ACL...");
-
-          const result = yield* ec2.createNetworkAcl({
-            VpcId: news.vpcId as string,
-            TagSpecifications: [
-              {
-                ResourceType: "network-acl",
-                Tags: createTagsList(createTags(id, news.tags)),
-              },
-            ],
-            DryRun: false,
-          });
-
-          const networkAclId = result.NetworkAcl!.NetworkAclId!;
-          yield* session.note(`Network ACL created: ${networkAclId}`);
-
-          const acl = yield* describeNetworkAcl(networkAclId);
-          return toAttrs(acl);
-        }),
-
-        update: Effect.fn(function* ({ id, news, output, session }) {
-          const networkAclId = output.networkAclId;
-
-          // Handle tag updates
-          const newTags = createTags(id, news.tags);
-          const oldTags =
-            (yield* ec2
-              .describeTags({
-                Filters: [
-                  { Name: "resource-id", Values: [networkAclId] },
-                  { Name: "resource-type", Values: ["network-acl"] },
-                ],
-              })
-              .pipe(
-                Effect.map(
-                  (r) =>
-                    Object.fromEntries(
-                      r.Tags?.map((t) => [t.Key!, t.Value!]) ?? [],
-                    ) as Record<string, string>,
-                ),
-              )) ?? {};
-
-          const { removed, upsert } = diffTags(oldTags, newTags);
-
-          if (removed.length > 0) {
-            yield* ec2.deleteTags({
-              Resources: [networkAclId],
-              Tags: removed.map((key) => ({ Key: key })),
-              DryRun: false,
-            });
-          }
-          if (upsert.length > 0) {
-            yield* ec2.createTags({
-              Resources: [networkAclId],
-              Tags: upsert,
-              DryRun: false,
-            });
-            yield* session.note("Updated tags");
-          }
-
-          const acl = yield* describeNetworkAcl(networkAclId);
-          return toAttrs(acl);
-        }),
-
-        delete: Effect.fn(function* ({ output, session }) {
-          const networkAclId = output.networkAclId;
-
-          yield* session.note(`Deleting Network ACL: ${networkAclId}`);
-
-          yield* ec2
-            .deleteNetworkAcl({
-              NetworkAclId: networkAclId,
-              DryRun: false,
-            })
-            .pipe(
-              Effect.catchTag(
-                "InvalidNetworkAclID.NotFound",
-                () => Effect.void,
-              ),
-              // Retry on dependency violations (e.g., associations still being removed)
-              Effect.retry({
-                while: (e) => {
-                  return e._tag === "DependencyViolation";
-                },
-                schedule: Schedule.exponential(1000, 1.5).pipe(
-                  Schedule.intersect(Schedule.recurs(15)),
-                  Schedule.tapOutput(([, attempt]) =>
-                    session.note(
-                      `Waiting for dependencies to clear... (attempt ${attempt + 1})`,
-                    ),
-                  ),
-                ),
-              }),
-            );
-
-          yield* session.note(`Network ACL ${networkAclId} deleted`);
-        }),
-      };
-    }),
-  );

package/src/aws/ec2/network-acl.ts

@@ -1,102 +0,0 @@
-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 NetworkAcl = Resource<{
-  <const ID extends string, const Props extends NetworkAclProps>(
-    id: ID,
-    props: Props,
-  ): NetworkAcl<ID, Props>;
-}>("AWS.EC2.NetworkAcl");
-
-export interface NetworkAcl<
-  ID extends string = string,
-  Props extends NetworkAclProps = NetworkAclProps,
-> extends Resource<
-  "AWS.EC2.NetworkAcl",
-  ID,
-  Props,
-  NetworkAclAttrs<Input.Resolve<Props>>,
-  NetworkAcl
-> {}
-
-export type NetworkAclId<ID extends string = string> = `acl-${ID}`;
-export const NetworkAclId = <ID extends string>(
-  id: ID,
-): ID & NetworkAclId<ID> => `acl-${id}` as ID & NetworkAclId<ID>;
-
-export interface NetworkAclProps {
-  /**
-   * The VPC to create the network ACL in.
-   */
-  vpcId: Input<VpcId>;
-
-  /**
-   * Tags to assign to the network ACL.
-   */
-  tags?: Record<string, Input<string>>;
-}
-
-export type NetworkAclArn<ID extends NetworkAclId = NetworkAclId> =
-  `arn:aws:ec2:${RegionID}:${AccountID}:network-acl/${ID}`;
-
-export interface NetworkAclAttrs<
-  Props extends Input.Resolve<NetworkAclProps> = Input.Resolve<NetworkAclProps>,
-> {
-  /**
-   * The ID of the network ACL.
-   */
-  networkAclId: NetworkAclId;
-
-  /**
-   * The Amazon Resource Name (ARN) of the network ACL.
-   */
-  networkAclArn: NetworkAclArn<this["networkAclId"]>;
-
-  /**
-   * The ID of the VPC for the network ACL.
-   */
-  vpcId: Props["vpcId"];
-
-  /**
-   * Whether this is the default network ACL for the VPC.
-   */
-  isDefault: boolean;
-
-  /**
-   * The ID of the AWS account that owns the network ACL.
-   */
-  ownerId: string;
-
-  /**
-   * The entries (rules) in the network ACL.
-   */
-  entries?: Array<{
-    ruleNumber: number;
-    protocol: string;
-    ruleAction: EC2.RuleAction;
-    egress: boolean;
-    cidrBlock?: string;
-    ipv6CidrBlock?: string;
-    icmpTypeCode?: {
-      code?: number;
-      type?: number;
-    };
-    portRange?: {
-      from?: number;
-      to?: number;
-    };
-  }>;
-
-  /**
-   * The associations between the network ACL and subnets.
-   */
-  associations?: Array<{
-    networkAclAssociationId: string;
-    networkAclId: string;
-    subnetId: string;
-  }>;
-}

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

@@ -1,213 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schedule from "effect/Schedule";
-
-import type { ScopedPlanStatusSession } from "../../cli/service.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`,
-          );
-        }),
-      };
-    }),
-  );
-
-/**
- * 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

@@ -1,82 +0,0 @@
-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;
-  };
-}