alchemy-effect 0.0.0 → 0.2.0

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

@@ -0,0 +1,280 @@
+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 { 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 TableAttrs,
+  type TableProps,
+} from "./table.ts";
+
+// 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
+> =>
+  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 tagged = yield* createTagger();
+
+      const toKeySchema = (props: TableProps) => [
+        {
+          AttributeName: props.partitionKey as string,
+          KeyType: "HASH" as const,
+        },
+        ...(props.sortKey
+          ? [
+              {
+                AttributeName: props.sortKey as string,
+                KeyType: "RANGE" as const,
+              },
+            ]
+          : []),
+      ];
+
+      const toAttributeDefinitions = (props: TableProps) =>
+        Object.entries(props.attributes)
+          .flatMap(([name, schema]) => {
+            const type = toAttributeType(schema);
+            if (isScalarAttributeType(type)) {
+              // only scalars can be included in the attribute definitions
+              return [
+                {
+                  AttributeName: name,
+                  AttributeType: type,
+                } as const,
+              ];
+            } else {
+              return [];
+            }
+          })
+          .sort((a, b) => a.AttributeName.localeCompare(b.AttributeName));
+
+      const toAttributeDefinitionsMap = (props: TableProps) =>
+        Object.fromEntries(
+          toAttributeDefinitions(props).map(
+            (def) => [def.AttributeName, def.AttributeType] as const,
+          ),
+        );
+
+      const resolveTableIfOwned = (id: string, tableName: string) =>
+        // if it already exists, let's see if it contains tags indicating we (this app+stage) owns it
+        // that would indicate we are in a partial state and can safely take control
+        dynamodb.describeTable({ TableName: tableName }).pipe(
+          Effect.flatMap((r) =>
+            dynamodb
+              .listTagsOfResource({
+                ResourceArn: r.Table?.TableArn!,
+              })
+              .pipe(
+                Effect.map((tags) => [r, tags.Tags] as const),
+                Effect.flatMap(([r, tags]) => {
+                  if (hasTags(tagged(id), tags)) {
+                    return Effect.succeed(r.Table!);
+                  }
+                  return Effect.fail(
+                    new Error("Table tags do not match expected values"),
+                  );
+                }),
+              ),
+          ),
+        );
+
+      const updateTimeToLive = (
+        tableName: string,
+        timeToLiveSpecification: TimeToLiveSpecification,
+      ) =>
+        dynamodb
+          .updateTimeToLive({
+            TableName: tableName,
+            TimeToLiveSpecification: timeToLiveSpecification!,
+          })
+          .pipe(
+            Effect.retry({
+              while: (e) => e.name === "ResourceInUseException",
+              schedule: Schedule.exponential(100),
+            }),
+          );
+
+      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;
+          }
+
+          if (
+            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)) {
+            // CloudFormation requires that editing an existing AttributeDefinition is a replace
+            if (newAttributeDefinitions[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 }) {
+          const tableName = createTableName(id, news);
+
+          const response = yield* dynamodb
+            .createTable({
+              TableName: tableName,
+              TableClass: news.tableClass,
+              KeySchema: toKeySchema(news),
+              AttributeDefinitions: toAttributeDefinitions(news),
+              BillingMode: news.billingMode ?? "PAY_PER_REQUEST",
+              SSESpecification: news.sseSpecification,
+              WarmThroughput: news.warmThroughput,
+              DeletionProtectionEnabled: news.deletionProtectionEnabled,
+              OnDemandThroughput: news.onDemandThroughput,
+              ProvisionedThroughput: news.provisionedThroughput,
+              // ResourcePolicy: (this should be determined by bindings maybe?)
+
+              // TODO(sam): this should come from Lambda.consume ?
+              // TODO(sam): that would require Lambda.consume mutates the Table declaration?
+              // StreamSpecification: news.streamSpecification,
+              Tags: [
+                { Key: "alchemy::app", Value: app.name },
+                { Key: "alchemy::stage", Value: app.stage },
+                { Key: "alchemy::id", Value: id },
+              ],
+            })
+            .pipe(
+              Effect.map((r) => r.TableDescription!),
+              Effect.retry({
+                while: (e) =>
+                  e.name === "LimitExceededException" ||
+                  e.name === "InternalServerError",
+                schedule: Schedule.exponential(100),
+              }),
+              Effect.catchTag("ResourceInUseException", () =>
+                resolveTableIfOwned(id, tableName),
+              ),
+            );
+
+          if (news.timeToLiveSpecification) {
+            yield* updateTimeToLive(tableName, news.timeToLiveSpecification);
+          }
+
+          yield* session.note(response.TableArn!);
+
+          return {
+            tableName,
+            tableId: response.TableId!,
+            tableArn: response.TableArn! as TableAttrs<TableProps>["tableArn"],
+            partitionKey: news.partitionKey,
+            sortKey: news.sortKey,
+          } satisfies TableAttrs<TableProps> as TableAttrs<any>;
+        }),
+
+        update: Effect.fn(function* ({ output, news, olds }) {
+          yield* dynamodb.updateTable({
+            TableName: output.tableName,
+            TableClass: news.tableClass,
+            AttributeDefinitions: toAttributeDefinitions(news),
+            BillingMode: news.billingMode ?? "PAY_PER_REQUEST",
+            SSESpecification: news.sseSpecification,
+            WarmThroughput: news.warmThroughput,
+            DeletionProtectionEnabled: news.deletionProtectionEnabled,
+            OnDemandThroughput: news.onDemandThroughput,
+            ProvisionedThroughput: news.provisionedThroughput,
+
+            //
+            // StreamSpecification: news.streamSpecification,
+            // TimeToLiveSpecification: news.timeToLiveSpecification,
+
+            // TODO(sam): GSIs
+            // GlobalSecondaryIndexUpdates
+
+            // TODO(sam): Global Tables
+            // MultiRegionConsistency: news.multiRegionConsistency,
+            // ReplicaUpdates: [{}]
+            // GlobalTableWitnessUpdates: [{Create}]
+          });
+
+          if (
+            news.timeToLiveSpecification &&
+            (news.timeToLiveSpecification.AttributeName !==
+              olds.timeToLiveSpecification?.AttributeName ||
+              news.timeToLiveSpecification?.Enabled !==
+                olds.timeToLiveSpecification?.Enabled)
+          ) {
+            // TODO(sam): can this run in parallel?
+            yield* updateTimeToLive(
+              output.tableName,
+              news.timeToLiveSpecification,
+            );
+          }
+
+          return output;
+        }),
+
+        delete: Effect.fn(function* ({ output }) {
+          yield* dynamodb
+            .deleteTable({
+              TableName: output.tableName,
+            })
+            .pipe(
+              Effect.timeout(1000),
+              Effect.catchTag("ResourceNotFoundException", () => Effect.void),
+              Effect.retry({
+                while: (e) =>
+                  e._tag === "ResourceInUseException" ||
+                  e._tag === "InternalServerError" ||
+                  e._tag === "TimeoutException",
+                schedule: Schedule.fixed(100),
+              }),
+            );
+
+          class TableStillExists extends Data.TaggedError("TableStillExists") {}
+
+          while (true) {
+            const table = yield* dynamodb
+              .describeTable({
+                TableName: output.tableName,
+              })
+              .pipe(
+                Effect.catchTag("ResourceNotFoundException", () => Effect.void),
+              );
+
+            if (table === undefined) {
+              break;
+            }
+          }
+        }),
+      } satisfies ProviderService<Table<string, TableProps>>;
+    }),
+  );

package/src/aws/dynamodb/table.ts

@@ -0,0 +1,156 @@
+import * as S from "effect/Schema";
+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,
+  Attributes extends AttributesSchema<
+    Items,
+    PartitionKey,
+    SortKey
+  > = 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;
+  deletionProtectionEnabled?: boolean;
+  onDemandThroughput?: OnDemandThroughput;
+  provisionedThroughput?: ProvisionedThroughput;
+  sseSpecification?: SSESpecification;
+  timeToLiveSpecification?: TimeToLiveSpecification;
+  warmThroughput?: WarmThroughput;
+  tableClass?: TableClass;
+}
+
+export interface TableAttrs<Props extends TableProps> {
+  tableName: Props["tableName"] extends string ? Props["tableName"] : string;
+  tableId: string;
+  tableArn: `arn:aws:dynamodb:${RegionID}:${AccountID}:table/${this["tableName"]}`;
+  partitionKey: Props["partitionKey"];
+  sortKey: Props["sortKey"];
+  // etc...
+}
+
+export type AttributesSchema<
+  Items,
+  PartitionKey extends keyof Items,
+  SortKey extends keyof Items | undefined,
+> = {
+  [k in PartitionKey | (SortKey extends undefined ? never : SortKey)]: S.Schema<
+    ToAttribute<Items[k]>
+  >;
+};
+
+export type ToAttribute<S> = S extends string
+  ? string
+  : S extends number
+    ? number
+    : S extends Uint8Array | Buffer | File | Blob
+      ? Uint8Array
+      : S;
+
+export const Table = Resource<{
+  <
+    const ID extends string,
+    const Items,
+    const Attributes extends NoInfer<
+      AttributesSchema<Items, PartitionKey, SortKey>
+    >,
+    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
+    >
+  >;
+}>("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>> {}
+
+export declare namespace Table {
+  export type PartitionKey<T extends Table> = T["props"]["partitionKey"];
+  export type SortKey<T extends Table> = T["props"]["sortKey"];
+  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];
+      }
+    : {};
+}

package/src/aws/ec2/client.ts

@@ -0,0 +1,20 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+
+import { EC2 } from "itty-aws/ec2";
+import { createAWSServiceClientLayer } from "../client.ts";
+import * as Credentials from "../credentials.ts";
+import * as Region from "../region.ts";
+
+export class EC2Client extends Context.Tag("AWS.EC2.Client")<
+  EC2Client,
+  EC2
+>() {}
+
+export const client = createAWSServiceClientLayer<typeof EC2Client, EC2>(
+  EC2Client,
+  EC2,
+);
+
+export const clientFromEnv = () =>
+  Layer.provide(client(), Layer.merge(Credentials.fromEnv(), Region.fromEnv()));

package/src/aws/ec2/index.ts

@@ -0,0 +1,3 @@
+export * from "./client.ts";
+export * from "./vpc.provider.ts";
+export * from "./vpc.ts";