alchemy-effect 0.2.0 → 0.4.0

package/src/aws/dynamodb/table.provider.ts

@@ -1,18 +1,18 @@
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schedule from "effect/Schedule";
 
-import { App, type Provider, type ProviderService } from "alchemy-effect";
 import type { TimeToLiveSpecification } from "itty-aws/dynamodb";
+import { App } from "../../app.ts";
+import type { Input } from "../../input.ts";
+import type { Provider, ProviderService } from "../../provider.ts";
 import { createTagger, hasTags } from "../../tags.ts";
-import { Account } from "../account.ts";
-import { Region } from "../region.ts";
 import { isScalarAttributeType, toAttributeType } from "./attribute-value.ts";
 import { DynamoDBClient } from "./client.ts";
 import {
   Table,
   type AnyTable,
+  type AttributesSchema,
   type TableAttrs,
   type TableProps,
 } from "./table.ts";
@@ -20,23 +20,22 @@ import {
 // we add an explict type to simplify the Layer type errors because the Table interface has a lot of type args
 export const tableProvider = (): Layer.Layer<
   Provider<AnyTable>,
-  any,
-  App | DynamoDBClient | Region | Account
+  never,
+  App | DynamoDBClient
 > =>
   Table.provider.effect(
-    // @ts-expect-error
     Effect.gen(function* () {
       const dynamodb = yield* DynamoDBClient;
       const app = yield* App;
-      const region = yield* Region;
-      const accountId = yield* Account;
 
-      const createTableName = (id: string, props: TableProps) =>
-        props.tableName ?? `${app.name}-${id}-${app.stage}`;
+      const createTableName = (
+        id: string,
+        props: Input.ResolveProps<TableProps>,
+      ) => props.tableName ?? `${app.name}-${id}-${app.stage}`;
 
       const tagged = yield* createTagger();
 
-      const toKeySchema = (props: TableProps) => [
+      const toKeySchema = (props: Input.ResolveProps<TableProps>) => [
         {
           AttributeName: props.partitionKey as string,
           KeyType: "HASH" as const,
@@ -51,8 +50,10 @@ export const tableProvider = (): Layer.Layer<
           : []),
       ];
 
-      const toAttributeDefinitions = (props: TableProps) =>
-        Object.entries(props.attributes)
+      const toAttributeDefinitions = (
+        attributes: AttributesSchema<any, any, any>,
+      ) =>
+        Object.entries(attributes)
           .flatMap(([name, schema]) => {
             const type = toAttributeType(schema);
             if (isScalarAttributeType(type)) {
@@ -69,9 +70,11 @@ export const tableProvider = (): Layer.Layer<
           })
           .sort((a, b) => a.AttributeName.localeCompare(b.AttributeName));
 
-      const toAttributeDefinitionsMap = (props: TableProps) =>
+      const toAttributeDefinitionsMap = (
+        attributes: AttributesSchema<any, any, any>,
+      ) =>
         Object.fromEntries(
-          toAttributeDefinitions(props).map(
+          toAttributeDefinitions(attributes).map(
             (def) => [def.AttributeName, def.AttributeType] as const,
           ),
         );
@@ -83,6 +86,7 @@ export const tableProvider = (): Layer.Layer<
           Effect.flatMap((r) =>
             dynamodb
               .listTagsOfResource({
+                // oxlint-disable-next-line no-non-null-asserted-optional-chain
                 ResourceArn: r.Table?.TableArn!,
               })
               .pipe(
@@ -116,34 +120,27 @@ export const tableProvider = (): Layer.Layer<
           );
 
       return {
-        diff: Effect.fn(function* ({ id, news, olds }) {
-          const oldTableName = createTableName(id, olds);
-          const newTableName = createTableName(id, news);
-          if (oldTableName !== newTableName) {
-            // TODO(sam): if the name is hard-coded, REPLACE is impossible - we need a suffix
-            return { action: "replace" } as const;
-          }
-
+        stables: ["tableName", "tableId", "tableArn"],
+        diff: Effect.fn(function* ({ news, olds }) {
           if (
+            // TODO(sam): if the name is hard-coded, REPLACE is impossible - we need a suffix
+            news.tableName !== olds.tableName ||
             olds.partitionKey !== news.partitionKey ||
             olds.sortKey !== news.sortKey
           ) {
             return { action: "replace" } as const;
           }
-          const oldAttributeDefinitions = toAttributeDefinitionsMap(olds);
-          const newAttributeDefinitions = toAttributeDefinitionsMap(news);
-          for (const [name, type] of Object.entries(oldAttributeDefinitions)) {
+          const oldAttrs = toAttributeDefinitionsMap(olds.attributes);
+          const newAttrs = toAttributeDefinitionsMap(news.attributes);
+          for (const [name, type] of Object.entries(oldAttrs)) {
             // CloudFormation requires that editing an existing AttributeDefinition is a replace
-            if (newAttributeDefinitions[name] !== type) {
+            if (newAttrs[name] !== type) {
               return { action: "replace" } as const;
             }
           }
-
           // TODO(sam):
           // Replacements:
           // 1. if you change ImportSourceSpecification
-
-          return { action: "noop" } as const;
         }),
 
         create: Effect.fn(function* ({ id, news, session }) {
@@ -154,7 +151,7 @@ export const tableProvider = (): Layer.Layer<
               TableName: tableName,
               TableClass: news.tableClass,
               KeySchema: toKeySchema(news),
-              AttributeDefinitions: toAttributeDefinitions(news),
+              AttributeDefinitions: toAttributeDefinitions(news.attributes),
               BillingMode: news.billingMode ?? "PAY_PER_REQUEST",
               SSESpecification: news.sseSpecification,
               WarmThroughput: news.warmThroughput,
@@ -194,17 +191,19 @@ export const tableProvider = (): Layer.Layer<
           return {
             tableName,
             tableId: response.TableId!,
-            tableArn: response.TableArn! as TableAttrs<TableProps>["tableArn"],
+            tableArn: response.TableArn! as TableAttrs<
+              Input.Resolve<TableProps>
+            >["tableArn"],
             partitionKey: news.partitionKey,
             sortKey: news.sortKey,
-          } satisfies TableAttrs<TableProps> as TableAttrs<any>;
+          } satisfies TableAttrs<Input.Resolve<TableProps>> as TableAttrs<any>;
         }),
 
         update: Effect.fn(function* ({ output, news, olds }) {
           yield* dynamodb.updateTable({
             TableName: output.tableName,
             TableClass: news.tableClass,
-            AttributeDefinitions: toAttributeDefinitions(news),
+            AttributeDefinitions: toAttributeDefinitions(news.attributes),
             BillingMode: news.billingMode ?? "PAY_PER_REQUEST",
             SSESpecification: news.sseSpecification,
             WarmThroughput: news.warmThroughput,
@@ -255,12 +254,10 @@ export const tableProvider = (): Layer.Layer<
                   e._tag === "ResourceInUseException" ||
                   e._tag === "InternalServerError" ||
                   e._tag === "TimeoutException",
-                schedule: Schedule.fixed(100),
+                schedule: Schedule.exponential(100),
               }),
             );
 
-          class TableStillExists extends Data.TaggedError("TableStillExists") {}
-
           while (true) {
             const table = yield* dynamodb
               .describeTable({
@@ -275,6 +272,6 @@ export const tableProvider = (): Layer.Layer<
             }
           }
         }),
-      } satisfies ProviderService<Table<string, TableProps>>;
+      } satisfies ProviderService<Table<string, TableProps<unknown>>>;
     }),
   );

package/src/aws/dynamodb/table.ts

@@ -1,13 +1,13 @@
 import * as S from "effect/Schema";
+import type { Input } from "../../input.ts";
 import { Resource } from "../../resource.ts";
 import type { type } from "../../type.ts";
 import type { AccountID } from "../account.ts";
 import type { RegionID } from "../region.ts";
-
 import type * as DynamoDB from "itty-aws/dynamodb";
 
 export interface TableProps<
-  Items = any,
+  Items extends any = any,
   Attributes extends AttributesSchema<
     Items,
     PartitionKey,
@@ -15,42 +15,23 @@ export interface TableProps<
   > = AttributesSchema<Items, keyof Items, keyof Items | undefined>,
   PartitionKey extends keyof Items = keyof Items,
   SortKey extends keyof Items | undefined = keyof Items | undefined,
-  BillingMode extends DynamoDB.BillingMode = DynamoDB.BillingMode,
-  SSESpecification extends DynamoDB.SSESpecification | undefined =
-    | DynamoDB.SSESpecification
-    | undefined,
-  TimeToLiveSpecification extends
-    | DynamoDB.TimeToLiveSpecification
-    | undefined = DynamoDB.TimeToLiveSpecification | undefined,
-  WarmThroughput extends DynamoDB.WarmThroughput | undefined =
-    | DynamoDB.WarmThroughput
-    | undefined,
-  OnDemandThroughput extends DynamoDB.OnDemandThroughput | undefined =
-    | DynamoDB.OnDemandThroughput
-    | undefined,
-  ProvisionedThroughput extends DynamoDB.ProvisionedThroughput | undefined =
-    | DynamoDB.ProvisionedThroughput
-    | undefined,
-  TableClass extends DynamoDB.TableClass | undefined =
-    | DynamoDB.TableClass
-    | undefined,
 > {
   items: type<Items>;
-  tableName?: string;
   attributes: Attributes;
   partitionKey: PartitionKey;
   sortKey?: SortKey;
-  billingMode?: BillingMode;
+  tableName?: string | undefined;
+  billingMode?: DynamoDB.BillingMode;
   deletionProtectionEnabled?: boolean;
-  onDemandThroughput?: OnDemandThroughput;
-  provisionedThroughput?: ProvisionedThroughput;
-  sseSpecification?: SSESpecification;
-  timeToLiveSpecification?: TimeToLiveSpecification;
-  warmThroughput?: WarmThroughput;
-  tableClass?: TableClass;
+  onDemandThroughput?: DynamoDB.OnDemandThroughput;
+  provisionedThroughput?: DynamoDB.ProvisionedThroughput;
+  sseSpecification?: DynamoDB.SSESpecification;
+  timeToLiveSpecification?: DynamoDB.TimeToLiveSpecification;
+  warmThroughput?: DynamoDB.WarmThroughput;
+  tableClass?: DynamoDB.TableClass;
 }
 
-export interface TableAttrs<Props extends TableProps> {
+export interface TableAttrs<Props extends Input.Resolve<TableProps>> {
   tableName: Props["tableName"] extends string ? Props["tableName"] : string;
   tableId: string;
   tableArn: `arn:aws:dynamodb:${RegionID}:${AccountID}:table/${this["tableName"]}`;
@@ -86,71 +67,35 @@ export const Table = Resource<{
     >,
     const PartitionKey extends keyof Items,
     const SortKey extends keyof Items | undefined = undefined,
-    const BillingMode extends DynamoDB.BillingMode = "PAY_PER_REQUEST",
-    const SSESpecification extends
-      | DynamoDB.SSESpecification
-      | undefined = undefined,
-    const TimeToLiveSpecification extends
-      | DynamoDB.TimeToLiveSpecification
-      | undefined = undefined,
-    const WarmThroughput extends
-      | DynamoDB.WarmThroughput
-      | undefined = undefined,
-    const OnDemandThroughput extends
-      | DynamoDB.OnDemandThroughput
-      | undefined = undefined,
-    const ProvisionedThroughput extends
-      | DynamoDB.ProvisionedThroughput
-      | undefined = undefined,
-    const TableClass extends DynamoDB.TableClass | undefined = undefined,
   >(
     id: ID,
-    props: TableProps<
-      Items,
-      Attributes,
-      PartitionKey,
-      SortKey,
-      BillingMode,
-      SSESpecification,
-      TimeToLiveSpecification,
-      WarmThroughput,
-      OnDemandThroughput,
-      ProvisionedThroughput,
-      TableClass
-    >,
-  ): Table<
-    ID,
-    TableProps<
-      Items,
-      Attributes,
-      PartitionKey,
-      SortKey,
-      BillingMode,
-      SSESpecification,
-      TimeToLiveSpecification,
-      WarmThroughput,
-      OnDemandThroughput,
-      ProvisionedThroughput,
-      TableClass
-    >
-  >;
+    props: TableProps<Items, Attributes, PartitionKey, SortKey>,
+  ): Table<ID, TableProps<Items, Attributes, PartitionKey, SortKey>>;
 }>("AWS.DynamoDB.Table");
 
 export interface AnyTable extends Table<string, any> {}
 
 export interface Table<
   ID extends string = string,
-  Props extends TableProps = TableProps,
-> extends Resource<"AWS.DynamoDB.Table", ID, Props, TableAttrs<Props>> {}
+  Props extends TableProps<any, any, any, any> = TableProps<any, any, any, any>,
+> extends Resource<
+    "AWS.DynamoDB.Table",
+    ID,
+    Props,
+    TableAttrs<Input.Resolve<Props>>,
+    Table
+  > {}
 
 export declare namespace Table {
   export type PartitionKey<T extends Table> = T["props"]["partitionKey"];
   export type SortKey<T extends Table> = T["props"]["sortKey"];
+  export type Items<T extends Table> = T["props"]["items"];
   export type Key<T extends Table> = {
-    [K in PartitionKey<T>]: T["props"]["attributes"][K];
-  } & SortKey<T> extends infer S extends string
-    ? {
-        [K in S]: T["props"]["attributes"][K];
-      }
-    : {};
+    [K in PartitionKey<T>]: InstanceType<T["props"]["items"]>[K];
+  } & {
+    [K in Exclude<SortKey<T>, undefined>]: Exclude<
+      InstanceType<T["props"]["items"]>[K],
+      undefined
+    >;
+  };
 }

package/src/aws/ec2/index.ts

@@ -1,3 +1,15 @@
 export * from "./client.ts";
+export * from "./internet-gateway.provider.ts";
+export * from "./internet-gateway.ts";
+export * from "./route-table-association.provider.ts";
+export * from "./route-table-association.ts";
+export * from "./route-table.provider.ts";
+export * from "./route-table.ts";
+export * from "./route.provider.ts";
+export * from "./route.ts";
+export * from "./subnet.provider.ts";
+export * from "./subnet.ts";
 export * from "./vpc.provider.ts";
 export * from "./vpc.ts";
+
+import "../config.ts";

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

@@ -0,0 +1,316 @@
+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 {
+  InternetGateway,
+  type InternetGatewayAttrs,
+  type InternetGatewayId,
+  type InternetGatewayProps,
+} from "./internet-gateway.ts";
+
+export const internetGatewayProvider = () =>
+  InternetGateway.provider.effect(
+    Effect.gen(function* () {
+      const ec2 = yield* EC2Client;
+      const region = yield* Region;
+      const accountId = yield* Account;
+      const tagged = yield* createTagger();
+
+      return {
+        stables: ["internetGatewayId", "internetGatewayArn", "ownerId"],
+        diff: Effect.fn(function* ({ news, olds }) {
+          // VPC attachment change can be handled via attach/detach (update)
+          // No properties require replacement
+        }),
+
+        create: Effect.fn(function* ({ id, news, session }) {
+          // 1. Prepare tags
+          const alchemyTags = tagged(id);
+          const userTags = news.tags ?? {};
+          const allTags = { ...alchemyTags, ...userTags };
+
+          // 2. Call CreateInternetGateway
+          const createResult = yield* ec2.createInternetGateway({
+            TagSpecifications: [
+              {
+                ResourceType: "internet-gateway",
+                Tags: createTagsList(allTags),
+              },
+            ],
+            DryRun: false,
+          });
+
+          const internetGatewayId = createResult.InternetGateway!
+            .InternetGatewayId! as InternetGatewayId;
+          yield* session.note(`Internet gateway created: ${internetGatewayId}`);
+
+          // 3. Attach to VPC if specified
+          if (news.vpcId) {
+            yield* ec2
+              .attachInternetGateway({
+                InternetGatewayId: internetGatewayId,
+                VpcId: news.vpcId,
+              })
+              .pipe(
+                Effect.retry({
+                  // Retry if VPC is not yet available
+                  while: (e) => e._tag === "InvalidVpcID.NotFound",
+                  schedule: Schedule.exponential(100),
+                }),
+              );
+            yield* session.note(`Attached to VPC: ${news.vpcId}`);
+          }
+
+          // 4. Describe to get full details
+          const igw = yield* describeInternetGateway(
+            ec2,
+            internetGatewayId,
+            session,
+          );
+
+          // 5. Return attributes
+          return {
+            internetGatewayId,
+            internetGatewayArn:
+              `arn:aws:ec2:${region}:${accountId}:internet-gateway/${internetGatewayId}` as InternetGatewayAttrs<InternetGatewayProps>["internetGatewayArn"],
+            vpcId: news.vpcId,
+            ownerId: igw.OwnerId,
+            attachments: igw.Attachments?.map((a) => ({
+              state: a.State! as
+                | "attaching"
+                | "available"
+                | "detaching"
+                | "detached",
+              vpcId: a.VpcId!,
+            })),
+          } satisfies InternetGatewayAttrs<InternetGatewayProps>;
+        }),
+
+        update: Effect.fn(function* ({ news, olds, output, session }) {
+          const internetGatewayId = output.internetGatewayId;
+
+          // Handle VPC attachment changes
+          if (news.vpcId !== olds.vpcId) {
+            // Detach from old VPC if was attached
+            if (olds.vpcId) {
+              yield* ec2
+                .detachInternetGateway({
+                  InternetGatewayId: internetGatewayId,
+                  VpcId: olds.vpcId,
+                })
+                .pipe(
+                  Effect.catchTag("Gateway.NotAttached", () => Effect.void),
+                );
+              yield* session.note(`Detached from VPC: ${olds.vpcId}`);
+            }
+
+            // Attach to new VPC if specified
+            if (news.vpcId) {
+              yield* ec2
+                .attachInternetGateway({
+                  InternetGatewayId: internetGatewayId,
+                  VpcId: news.vpcId,
+                })
+                .pipe(
+                  Effect.retry({
+                    while: (e) => e._tag === "InvalidVpcID.NotFound",
+                    schedule: Schedule.exponential(100),
+                  }),
+                );
+              yield* session.note(`Attached to VPC: ${news.vpcId}`);
+            }
+          }
+
+          // Handle tag updates
+          if (
+            JSON.stringify(news.tags ?? {}) !== JSON.stringify(olds.tags ?? {})
+          ) {
+            const alchemyTags = tagged(output.internetGatewayId);
+            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: [internetGatewayId],
+                Tags: tagsToDelete.map((key) => ({ Key: key })),
+              });
+            }
+
+            // Create/update tags
+            yield* ec2.createTags({
+              Resources: [internetGatewayId],
+              Tags: createTagsList(allTags),
+            });
+
+            yield* session.note("Updated tags");
+          }
+
+          // Re-describe to get current state
+          const igw = yield* describeInternetGateway(
+            ec2,
+            internetGatewayId,
+            session,
+          );
+
+          return {
+            ...output,
+            vpcId: news.vpcId,
+            attachments: igw.Attachments?.map((a) => ({
+              state: a.State! as
+                | "attaching"
+                | "available"
+                | "detaching"
+                | "detached",
+              vpcId: a.VpcId!,
+            })),
+          };
+        }),
+
+        delete: Effect.fn(function* ({ output, session }) {
+          const internetGatewayId = output.internetGatewayId;
+
+          yield* session.note(
+            `Deleting internet gateway: ${internetGatewayId}`,
+          );
+
+          // 1. Detach from all VPCs first
+          if (output.attachments && output.attachments.length > 0) {
+            for (const attachment of output.attachments) {
+              yield* ec2
+                .detachInternetGateway({
+                  InternetGatewayId: internetGatewayId,
+                  VpcId: attachment.vpcId,
+                })
+                .pipe(
+                  Effect.tapError(Effect.logDebug),
+                  Effect.catchTag("Gateway.NotAttached", () => Effect.void),
+                  Effect.catchTag(
+                    "InvalidInternetGatewayID.NotFound",
+                    () => Effect.void,
+                  ),
+                );
+              yield* session.note(`Detached from VPC: ${attachment.vpcId}`);
+            }
+          }
+
+          // 2. Delete the internet gateway
+          yield* ec2
+            .deleteInternetGateway({
+              InternetGatewayId: internetGatewayId,
+              DryRun: false,
+            })
+            .pipe(
+              Effect.tapError(Effect.logDebug),
+              Effect.catchTag(
+                "InvalidInternetGatewayID.NotFound",
+                () => Effect.void,
+              ),
+              // Retry on dependency violations
+              Effect.retry({
+                while: (e) => {
+                  return (
+                    e._tag === "DependencyViolation" ||
+                    (e._tag === "ValidationError" &&
+                      e.message?.includes("DependencyViolation"))
+                  );
+                },
+                schedule: Schedule.exponential(1000, 1.5).pipe(
+                  Schedule.intersect(Schedule.recurs(10)),
+                  Schedule.tapOutput(([, attempt]) =>
+                    session.note(
+                      `Waiting for dependencies to clear... (attempt ${attempt + 1})`,
+                    ),
+                  ),
+                ),
+              }),
+            );
+
+          // 3. Wait for internet gateway to be fully deleted
+          yield* waitForInternetGatewayDeleted(ec2, internetGatewayId, session);
+
+          yield* session.note(
+            `Internet gateway ${internetGatewayId} deleted successfully`,
+          );
+        }),
+      } satisfies ProviderService<InternetGateway>;
+    }),
+  );
+
+/**
+ * Describe an internet gateway by ID
+ */
+const describeInternetGateway = (
+  ec2: EC2,
+  internetGatewayId: string,
+  _session?: ScopedPlanStatusSession,
+) =>
+  Effect.gen(function* () {
+    const result = yield* ec2
+      .describeInternetGateways({ InternetGatewayIds: [internetGatewayId] })
+      .pipe(
+        Effect.catchTag("InvalidInternetGatewayID.NotFound", () =>
+          Effect.succeed({ InternetGateways: [] }),
+        ),
+      );
+
+    const igw = result.InternetGateways?.[0];
+    if (!igw) {
+      return yield* Effect.fail(new Error("Internet gateway not found"));
+    }
+    return igw;
+  });
+
+/**
+ * Wait for internet gateway to be deleted
+ */
+const waitForInternetGatewayDeleted = (
+  ec2: EC2,
+  internetGatewayId: string,
+  session: ScopedPlanStatusSession,
+) =>
+  Effect.gen(function* () {
+    yield* Effect.retry(
+      Effect.gen(function* () {
+        const result = yield* ec2
+          .describeInternetGateways({ InternetGatewayIds: [internetGatewayId] })
+          .pipe(
+            Effect.tapError(Effect.logDebug),
+            Effect.catchTag("InvalidInternetGatewayID.NotFound", () =>
+              Effect.succeed({ InternetGateways: [] }),
+            ),
+          );
+
+        if (!result.InternetGateways || result.InternetGateways.length === 0) {
+          return; // Successfully deleted
+        }
+
+        // Still exists, fail to trigger retry
+        return yield* Effect.fail(new Error("Internet gateway still exists"));
+      }),
+      {
+        schedule: Schedule.fixed(2000).pipe(
+          Schedule.intersect(Schedule.recurs(15)),
+          Schedule.tapOutput(([, attempt]) =>
+            session.note(
+              `Waiting for internet gateway deletion... (${(attempt + 1) * 2}s)`,
+            ),
+          ),
+        ),
+      },
+    );
+  });