alchemy-effect 0.2.0 → 0.3.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,26 @@ 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;
-          }
-
+        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 +150,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 +190,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 +253,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 +271,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,7 @@
 export * from "./client.ts";
+export * from "./subnet.provider.ts";
+export * from "./subnet.ts";
 export * from "./vpc.provider.ts";
 export * from "./vpc.ts";
+
+import "../config.ts";