alchemy-effect 0.2.0 → 0.3.0

package/src/aws/ec2/subnet.provider.ts

@@ -0,0 +1,358 @@
+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 { somePropsAreDifferent } from "../../diff.ts";
+import type { ProviderService } from "../../provider.ts";
+import { createTagger, createTagsList } from "../../tags.ts";
+import { EC2Client } from "./client.ts";
+import {
+  Subnet,
+  type SubnetAttrs,
+  type SubnetProps,
+  type SubnetId,
+} from "./subnet.ts";
+
+export const subnetProvider = () =>
+  Subnet.provider.effect(
+    Effect.gen(function* () {
+      const ec2 = yield* EC2Client;
+      const tagged = yield* createTagger();
+
+      return {
+        diff: Effect.fn(function* ({ news, olds }) {
+          if (
+            somePropsAreDifferent(olds, news, [
+              "vpcId",
+              "cidrBlock",
+              "availabilityZone",
+              "availabilityZoneId",
+              "ipv6CidrBlock",
+              "ipv4IpamPoolId",
+              "ipv6IpamPoolId",
+            ])
+          ) {
+            return { action: "replace" };
+          }
+        }),
+
+        create: Effect.fn(function* ({ id, news, session }) {
+          // 1. Get VPC ID from the VPC resource
+          // TODO(sam): i need to make it possible to pass Resources as input Props to Resources
+          const vpcId = news.vpcId;
+
+          // 2. Prepare tags
+          const alchemyTags = tagged(id);
+          const userTags = news.tags ?? {};
+          const allTags = { ...alchemyTags, ...userTags };
+
+          // 3. Call CreateSubnet
+          const createResult = yield* ec2
+            .createSubnet({
+              VpcId: vpcId,
+              CidrBlock: news.cidrBlock,
+              Ipv6CidrBlock: news.ipv6CidrBlock,
+              AvailabilityZone: news.availabilityZone,
+              AvailabilityZoneId: news.availabilityZoneId,
+              Ipv4IpamPoolId: news.ipv4IpamPoolId,
+              Ipv4NetmaskLength: news.ipv4NetmaskLength,
+              Ipv6IpamPoolId: news.ipv6IpamPoolId,
+              Ipv6NetmaskLength: news.ipv6NetmaskLength,
+              Ipv6Native: false, // Explicitly set to false for now
+              TagSpecifications: [
+                {
+                  ResourceType: "subnet",
+                  Tags: createTagsList(allTags),
+                },
+              ],
+              DryRun: false,
+            })
+            .pipe(
+              Effect.retry({
+                // @ts-expect-error - this is unknown to itty-aws
+                while: (e) => e._tag === "InvalidVpcID.NotFound",
+                schedule: Schedule.exponential(100),
+              }),
+            );
+
+          const subnetId = createResult.Subnet!.SubnetId! as SubnetId;
+          yield* session.note(`Subnet created: ${subnetId}`);
+
+          // 4. Modify subnet attributes if specified
+          if (news.mapPublicIpOnLaunch !== undefined) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              MapPublicIpOnLaunch: { Value: news.mapPublicIpOnLaunch },
+            });
+          }
+
+          if (news.assignIpv6AddressOnCreation !== undefined) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              AssignIpv6AddressOnCreation: {
+                Value: news.assignIpv6AddressOnCreation,
+              },
+            });
+          }
+
+          if (news.enableDns64 !== undefined) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              EnableDns64: { Value: news.enableDns64 },
+            });
+          }
+
+          if (
+            news.enableResourceNameDnsARecordOnLaunch !== undefined ||
+            news.enableResourceNameDnsAAAARecordOnLaunch !== undefined ||
+            news.hostnameType !== undefined
+          ) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              PrivateDnsHostnameTypeOnLaunch: news.hostnameType,
+              EnableResourceNameDnsARecordOnLaunch:
+                news.enableResourceNameDnsARecordOnLaunch !== undefined
+                  ? { Value: news.enableResourceNameDnsARecordOnLaunch }
+                  : undefined,
+              EnableResourceNameDnsAAAARecordOnLaunch:
+                news.enableResourceNameDnsAAAARecordOnLaunch !== undefined
+                  ? { Value: news.enableResourceNameDnsAAAARecordOnLaunch }
+                  : undefined,
+            });
+          }
+
+          // 5. Wait for subnet to be available
+          const subnet = yield* waitForSubnetAvailable(ec2, subnetId, session);
+
+          // 6. Return attributes
+          return {
+            subnetId,
+            subnetArn:
+              subnet.SubnetArn! as SubnetAttrs<SubnetProps>["subnetArn"],
+            cidrBlock: subnet.CidrBlock!,
+            vpcId: news.vpcId,
+            availabilityZone: subnet.AvailabilityZone!,
+            availabilityZoneId: subnet.AvailabilityZoneId,
+            state: subnet.State!,
+            availableIpAddressCount: subnet.AvailableIpAddressCount ?? 0,
+            mapPublicIpOnLaunch: subnet.MapPublicIpOnLaunch ?? false,
+            assignIpv6AddressOnCreation:
+              subnet.AssignIpv6AddressOnCreation ?? false,
+            defaultForAz: subnet.DefaultForAz ?? false,
+            ownerId: subnet.OwnerId,
+            ipv6CidrBlockAssociationSet:
+              subnet.Ipv6CidrBlockAssociationSet?.map((assoc) => ({
+                associationId: assoc.AssociationId!,
+                ipv6CidrBlock: assoc.Ipv6CidrBlock!,
+                ipv6CidrBlockState: {
+                  state: assoc.Ipv6CidrBlockState!.State!,
+                  statusMessage: assoc.Ipv6CidrBlockState!.StatusMessage,
+                },
+              })),
+            enableDns64: subnet.EnableDns64,
+            ipv6Native: subnet.Ipv6Native,
+            privateDnsNameOptionsOnLaunch: subnet.PrivateDnsNameOptionsOnLaunch
+              ? {
+                  hostnameType:
+                    subnet.PrivateDnsNameOptionsOnLaunch.HostnameType,
+                  enableResourceNameDnsARecord:
+                    subnet.PrivateDnsNameOptionsOnLaunch
+                      .EnableResourceNameDnsARecord,
+                  enableResourceNameDnsAAAARecord:
+                    subnet.PrivateDnsNameOptionsOnLaunch
+                      .EnableResourceNameDnsAAAARecord,
+                }
+              : undefined,
+          } satisfies SubnetAttrs<SubnetProps>;
+        }),
+
+        update: Effect.fn(function* ({ news, olds, output, session }) {
+          const subnetId = output.subnetId;
+
+          // Update MapPublicIpOnLaunch if changed
+          if (news.mapPublicIpOnLaunch !== olds.mapPublicIpOnLaunch) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              MapPublicIpOnLaunch: { Value: news.mapPublicIpOnLaunch ?? false },
+            });
+            yield* session.note("Updated map public IP on launch");
+          }
+
+          // Update AssignIpv6AddressOnCreation if changed
+          if (
+            news.assignIpv6AddressOnCreation !==
+            olds.assignIpv6AddressOnCreation
+          ) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              AssignIpv6AddressOnCreation: {
+                Value: news.assignIpv6AddressOnCreation ?? false,
+              },
+            });
+            yield* session.note("Updated assign IPv6 address on creation");
+          }
+
+          // Update EnableDns64 if changed
+          if (news.enableDns64 !== olds.enableDns64) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              EnableDns64: { Value: news.enableDns64 ?? false },
+            });
+            yield* session.note("Updated DNS64 setting");
+          }
+
+          // Update private DNS hostname settings if changed
+          if (
+            news.enableResourceNameDnsARecordOnLaunch !==
+              olds.enableResourceNameDnsARecordOnLaunch ||
+            news.enableResourceNameDnsAAAARecordOnLaunch !==
+              olds.enableResourceNameDnsAAAARecordOnLaunch ||
+            news.hostnameType !== olds.hostnameType
+          ) {
+            yield* ec2.modifySubnetAttribute({
+              SubnetId: subnetId,
+              PrivateDnsHostnameTypeOnLaunch: news.hostnameType,
+              EnableResourceNameDnsARecordOnLaunch:
+                news.enableResourceNameDnsARecordOnLaunch !== undefined
+                  ? { Value: news.enableResourceNameDnsARecordOnLaunch }
+                  : undefined,
+              EnableResourceNameDnsAAAARecordOnLaunch:
+                news.enableResourceNameDnsAAAARecordOnLaunch !== undefined
+                  ? { Value: news.enableResourceNameDnsAAAARecordOnLaunch }
+                  : undefined,
+            });
+            yield* session.note("Updated private DNS hostname settings");
+          }
+
+          // Note: Tag updates would go here if we support user tag changes
+
+          return output; // Subnet attributes don't change from these updates
+        }),
+
+        delete: Effect.fn(function* ({ output, session }) {
+          const subnetId = output.subnetId;
+
+          yield* session.note(`Deleting subnet: ${subnetId}`);
+
+          // 1. Attempt to delete subnet
+          yield* ec2
+            .deleteSubnet({
+              SubnetId: subnetId,
+              DryRun: false,
+            })
+            .pipe(
+              Effect.tapError(Effect.logDebug),
+              Effect.catchTag("InvalidSubnetID.NotFound", () => Effect.void),
+              // Retry on dependency violations (resources still being deleted)
+              Effect.retry({
+                while: (e) => {
+                  // DependencyViolation means there are still dependent resources
+                  // This can happen if ENIs/instances are being deleted concurrently
+                  return (
+                    e._tag === "ValidationError" &&
+                    e.message?.includes("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 subnet to be fully deleted
+          yield* waitForSubnetDeleted(ec2, subnetId, session);
+
+          yield* session.note(`Subnet ${subnetId} deleted successfully`);
+        }),
+      } satisfies ProviderService<Subnet>;
+    }),
+  );
+
+/**
+ * Wait for subnet to be in available state
+ */
+const waitForSubnetAvailable = (
+  ec2: EC2,
+  subnetId: string,
+  session?: ScopedPlanStatusSession,
+) =>
+  Effect.retry(
+    Effect.gen(function* () {
+      const result = yield* ec2
+        .describeSubnets({ SubnetIds: [subnetId] })
+        .pipe(
+          Effect.catchTag("InvalidSubnetID.NotFound", () =>
+            Effect.succeed({ Subnets: [] }),
+          ),
+        );
+      const subnet = result.Subnets![0];
+
+      if (subnet.State === "available") {
+        return subnet;
+      }
+
+      // Still pending, fail to trigger retry
+      return yield* Effect.fail(new Error("Subnet not yet available"));
+    }),
+    {
+      schedule: Schedule.fixed(2000).pipe(
+        // Check every 2 seconds
+        Schedule.intersect(Schedule.recurs(30)), // Max 60 seconds
+        Schedule.tapOutput(([, attempt]) =>
+          session
+            ? session.note(
+                `Waiting for subnet to be available... (${(attempt + 1) * 2}s)`,
+              )
+            : Effect.void,
+        ),
+      ),
+    },
+  );
+
+/**
+ * Wait for subnet to be deleted
+ */
+const waitForSubnetDeleted = (
+  ec2: EC2,
+  subnetId: string,
+  session: ScopedPlanStatusSession,
+) =>
+  Effect.gen(function* () {
+    yield* Effect.retry(
+      Effect.gen(function* () {
+        const result = yield* ec2
+          .describeSubnets({ SubnetIds: [subnetId] })
+          .pipe(
+            Effect.tapError(Effect.logDebug),
+            Effect.catchTag("InvalidSubnetID.NotFound", () =>
+              Effect.succeed({ Subnets: [] }),
+            ),
+          );
+
+        if (!result.Subnets || result.Subnets.length === 0) {
+          return; // Successfully deleted
+        }
+
+        // Still exists, fail to trigger retry
+        return yield* Effect.fail(new Error("Subnet 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 subnet deletion... (${(attempt + 1) * 2}s)`,
+            ),
+          ),
+        ),
+      },
+    );
+  });

package/src/aws/ec2/subnet.ts

@@ -0,0 +1,213 @@
+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 Subnet = Resource<{
+  <const ID extends string, const Props extends SubnetProps>(
+    id: ID,
+    props: Props,
+  ): Subnet<ID, Props>;
+}>("AWS.EC2.Subnet");
+
+export interface Subnet<
+  ID extends string = string,
+  Props extends SubnetProps = SubnetProps,
+> extends Resource<
+    "AWS.EC2.Subnet",
+    ID,
+    Props,
+    SubnetAttrs<Input.Resolve<Props>>,
+    Subnet
+  > {}
+
+export interface SubnetProps {
+  /**
+   * The VPC to create the subnet in.
+   */
+  vpcId: Input<VpcId>;
+
+  /**
+   * The IPv4 network range for the subnet, in CIDR notation.
+   * Required unless using IPAM.
+   * @example "10.0.1.0/24"
+   */
+  cidrBlock?: string;
+
+  /**
+   * The IPv6 network range for the subnet, in CIDR notation.
+   */
+  ipv6CidrBlock?: string;
+
+  /**
+   * The Availability Zone for the subnet.
+   * @example "us-east-1a"
+   */
+  availabilityZone?: string;
+
+  /**
+   * The ID of the Availability Zone for the subnet.
+   */
+  availabilityZoneId?: string;
+
+  /**
+   * The ID of an IPv4 IPAM pool you want to use for allocating this subnet's CIDR.
+   */
+  ipv4IpamPoolId?: string;
+
+  /**
+   * The netmask length of the IPv4 CIDR you want to allocate to this subnet from an IPAM pool.
+   */
+  ipv4NetmaskLength?: number;
+
+  /**
+   * The ID of an IPv6 IPAM pool which will be used to allocate this subnet an IPv6 CIDR.
+   */
+  ipv6IpamPoolId?: Input<string>;
+
+  /**
+   * The netmask length of the IPv6 CIDR you want to allocate to this subnet from an IPAM pool.
+   */
+  ipv6NetmaskLength?: number;
+
+  /**
+   * Whether instances launched in the subnet get public IPv4 addresses.
+   * @default false
+   */
+  mapPublicIpOnLaunch?: boolean;
+
+  /**
+   * Whether instances launched in the subnet get IPv6 addresses.
+   * @default false
+   */
+  assignIpv6AddressOnCreation?: boolean;
+
+  /**
+   * Whether DNS queries made to the Amazon-provided DNS Resolver in this subnet should return
+   * synthetic IPv6 addresses for IPv4-only destinations.
+   * @default false
+   */
+  enableDns64?: boolean;
+
+  /**
+   * Whether to enable resource name DNS A record on launch.
+   * @default false
+   */
+  enableResourceNameDnsARecordOnLaunch?: boolean;
+
+  /**
+   * Whether to enable resource name DNS AAAA record on launch.
+   * @default false
+   */
+  enableResourceNameDnsAAAARecordOnLaunch?: boolean;
+
+  /**
+   * The hostname type for EC2 instances launched into this subnet.
+   */
+  hostnameType?: EC2.HostnameType;
+
+  /**
+   * Tags to assign to the subnet.
+   * These will be merged with alchemy auto-tags (alchemy::app, alchemy::stage, alchemy::id).
+   */
+  tags?: Record<string, Input<string>>;
+}
+
+export type SubnetId<ID extends string = string> = `subnet-${ID}`;
+export const SubnetId = <ID extends string>(id: ID): ID & SubnetId<ID> =>
+  `subnet-${id}` as ID & SubnetId<ID>;
+
+export interface SubnetAttrs<Props extends SubnetProps> {
+  /**
+   * The ID of the VPC the subnet is in.
+   */
+  vpcId: Props["vpcId"];
+
+  /**
+   * The ID of the subnet.
+   */
+  subnetId: SubnetId;
+
+  /**
+   * The Amazon Resource Name (ARN) of the subnet.
+   */
+  subnetArn: `arn:aws:ec2:${RegionID}:${AccountID}:subnet/${this["subnetId"]}`;
+
+  /**
+   * The IPv4 CIDR block for the subnet.
+   */
+  cidrBlock: string;
+
+  /**
+   * The Availability Zone of the subnet.
+   */
+  availabilityZone: string;
+
+  /**
+   * The ID of the Availability Zone of the subnet.
+   */
+  availabilityZoneId?: string;
+
+  /**
+   * The current state of the subnet.
+   */
+  state: EC2.SubnetState;
+
+  /**
+   * The number of available IPv4 addresses in the subnet.
+   */
+  availableIpAddressCount: number;
+
+  /**
+   * Whether instances launched in the subnet get public IPv4 addresses.
+   */
+  mapPublicIpOnLaunch: boolean;
+
+  /**
+   * Whether instances launched in the subnet get IPv6 addresses.
+   */
+  assignIpv6AddressOnCreation: Props["assignIpv6AddressOnCreation"];
+
+  /**
+   * Whether the subnet is the default subnet for the Availability Zone.
+   */
+  defaultForAz: boolean;
+
+  /**
+   * The ID of the AWS account that owns the subnet.
+   */
+  ownerId?: string;
+
+  /**
+   * Information about the IPv6 CIDR blocks associated with the subnet.
+   */
+  ipv6CidrBlockAssociationSet?: Array<{
+    associationId: string;
+    ipv6CidrBlock: string;
+    ipv6CidrBlockState: {
+      state: EC2.SubnetCidrBlockStateCode;
+      statusMessage?: string;
+    };
+  }>;
+
+  /**
+   * Whether DNS64 is enabled for the subnet.
+   */
+  enableDns64?: boolean;
+
+  /**
+   * Whether this is an IPv6-only subnet.
+   */
+  ipv6Native?: boolean;
+
+  /**
+   * The private DNS name options on launch.
+   */
+  privateDnsNameOptionsOnLaunch?: {
+    hostnameType?: EC2.HostnameType;
+    enableResourceNameDnsARecord?: boolean;
+    enableResourceNameDnsAAAARecord?: boolean;
+  };
+}

package/src/aws/ec2/vpc.provider.ts

@@ -1,54 +1,38 @@
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, type ProviderService } from "alchemy-effect";
-import type { ScopedPlanStatusSession } from "../../apply.ts";
+import type { EC2 } from "itty-aws/ec2";
+
+import type { VpcId } from "./vpc.ts";
+import type { ScopedPlanStatusSession } from "../../cli/service.ts";
+import { somePropsAreDifferent } from "../../diff.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 { Vpc, type VpcAttrs, type VpcProps } from "./vpc.ts";
-
-import type { EC2 } from "itty-aws/ec2";
+import { Region } from "../region.ts";
+import { Account } from "../account.ts";
 
 export const vpcProvider = () =>
   Vpc.provider.effect(
     Effect.gen(function* () {
       const ec2 = yield* EC2Client;
-      const app = yield* App;
       const region = yield* Region;
       const accountId = yield* Account;
       const tagged = yield* createTagger();
 
       return {
-        diff: Effect.fn(function* ({ id, news, olds }) {
-          // 1. CIDR block changes
-          if (olds.cidrBlock !== news.cidrBlock) {
-            return { action: "replace" } as const;
-          }
-
-          // 2. Instance tenancy changes
-          if (olds.instanceTenancy !== news.instanceTenancy) {
-            return { action: "replace" } as const;
-          }
-
-          // 3. IPAM pool changes
-          if (olds.ipv4IpamPoolId !== news.ipv4IpamPoolId) {
-            return { action: "replace" } as const;
-          }
-
-          if (olds.ipv6IpamPoolId !== news.ipv6IpamPoolId) {
-            return { action: "replace" } as const;
-          }
-
-          // 4. IPv6 CIDR block changes
-          if (olds.ipv6CidrBlock !== news.ipv6CidrBlock) {
-            return { action: "replace" } as const;
-          }
-
-          // 5. IPv6 pool changes
-          if (olds.ipv6Pool !== news.ipv6Pool) {
-            return { action: "replace" } as const;
+        diff: Effect.fn(function* ({ news, olds }) {
+          if (
+            somePropsAreDifferent(olds, news, [
+              "cidrBlock",
+              "instanceTenancy",
+              "ipv4IpamPoolId",
+              "ipv6IpamPoolId",
+              "ipv6CidrBlock",
+            ])
+          ) {
+            return { action: "replace" };
           }
         }),
 
@@ -81,7 +65,7 @@ export const vpcProvider = () =>
             DryRun: false,
           });
 
-          const vpcId = createResult.Vpc!.VpcId!;
+          const vpcId = createResult.Vpc!.VpcId! as VpcId;
           yield* session.note(`VPC created: ${vpcId}`);
 
           // 3. Modify DNS attributes if specified (separate API calls)