alchemy-effect 0.5.0 → 0.6.2

package/src/AWS/DynamoDB/TransactGetItems.ts

@@ -0,0 +1,154 @@
+import * as DynamoDB from "@distilled.cloud/aws/dynamodb";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Table } from "./Table.ts";
+
+type TransactGetItemsTables = [Table, ...Table[]];
+
+type NativeTransactGet = NonNullable<
+  NonNullable<DynamoDB.TransactGetItemsInput["TransactItems"]>[number]["Get"]
+>;
+
+const sortTables = (tables: TransactGetItemsTables) =>
+  [
+    ...new Map(
+      tables.map((table) => [table.LogicalId, table] as const),
+    ).values(),
+  ].sort((a, b) =>
+    a.LogicalId.localeCompare(b.LogicalId),
+  ) as TransactGetItemsTables;
+
+export interface TransactGet extends Omit<NativeTransactGet, "TableName"> {
+  Table: string;
+}
+
+export interface TransactGetItemsRequest extends Omit<
+  DynamoDB.TransactGetItemsInput,
+  "TransactItems"
+> {
+  TransactItems: Array<{
+    Get: TransactGet;
+  }>;
+}
+
+/**
+ * Runtime binding for `dynamodb:TransactGetItems`.
+ *
+ * Bind this operation to one or more tables and identify each table in the
+ * request with the bound table's `LogicalId`.
+ *
+ * @section Reading Data
+ * @example Read Items Transactionally
+ * ```typescript
+ * const transactGetItems = yield* TransactGetItems.bind(
+ *   sourceTable,
+ *   archiveTable,
+ * );
+ *
+ * const response = yield* transactGetItems({
+ *   TransactItems: [
+ *     {
+ *       Get: {
+ *         Table: sourceTable.LogicalId,
+ *         Key: { pk: { S: "user#1" }, sk: { S: "profile" } },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export class TransactGetItems extends Binding.Service<
+  TransactGetItems,
+  (
+    ...tables: TransactGetItemsTables
+  ) => Effect.Effect<
+    (
+      request: TransactGetItemsRequest,
+    ) => Effect.Effect<
+      DynamoDB.TransactGetItemsOutput,
+      DynamoDB.TransactGetItemsError
+    >
+  >
+>()("AWS.DynamoDB.TransactGetItems") {}
+
+export const TransactGetItemsLive = Layer.effect(
+  TransactGetItems,
+  Effect.gen(function* () {
+    const Policy = yield* TransactGetItemsPolicy;
+    const transactGetItems = yield* DynamoDB.transactGetItems;
+
+    return Effect.fn(function* (...tables: TransactGetItemsTables) {
+      const sortedTables = sortTables(tables);
+      const tableNames = new Map(
+        yield* Effect.forEach(sortedTables, (table) =>
+          Effect.gen(function* () {
+            return [table.LogicalId, yield* table.tableName] as const;
+          }),
+        ),
+      );
+
+      const getTableName = (tableId: string) => {
+        const TableName = tableNames.get(tableId);
+        if (!TableName) {
+          throw new Error(
+            `TransactGetItems request references unbound table '${tableId}'`,
+          );
+        }
+        return TableName;
+      };
+
+      yield* Policy(...sortedTables);
+
+      return Effect.fn(function* (request: TransactGetItemsRequest) {
+        const transactItems = yield* Effect.forEach(
+          request.TransactItems,
+          ({ Get }) =>
+            Effect.gen(function* () {
+              return {
+                Get: {
+                  ...Get,
+                  TableName: yield* getTableName(Get.Table),
+                },
+              };
+            }),
+        );
+
+        return yield* transactGetItems({
+          ...request,
+          TransactItems: transactItems,
+        });
+      });
+    });
+  }),
+);
+
+export class TransactGetItemsPolicy extends Binding.Policy<
+  TransactGetItemsPolicy,
+  (...tables: TransactGetItemsTables) => Effect.Effect<void>
+>()("AWS.DynamoDB.TransactGetItems") {}
+
+export const TransactGetItemsPolicyLive = TransactGetItemsPolicy.layer.succeed(
+  Effect.fn(function* (host, ...tables: TransactGetItemsTables) {
+    const sortedTables = sortTables(tables);
+
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.DynamoDB.TransactGetItems(${sortedTables}))`(
+        {
+          policyStatements: [
+            {
+              Effect: "Allow",
+              Action: ["dynamodb:GetItem"],
+              Resource: sortedTables.map((table) => table.tableArn),
+            },
+          ],
+        },
+      );
+    } else {
+      return yield* Effect.die(
+        `TransactGetItemsPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/DynamoDB/TransactWriteItems.ts

@@ -0,0 +1,216 @@
+import * as DynamoDB from "@distilled.cloud/aws/dynamodb";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Table } from "./Table.ts";
+
+type TransactWriteItemsTables = [Table, ...Table[]];
+
+type NativeTransactWriteItem = NonNullable<
+  DynamoDB.TransactWriteItemsInput["TransactItems"]
+>[number];
+
+type NativeConditionCheck = NonNullable<
+  NativeTransactWriteItem["ConditionCheck"]
+>;
+type NativeDelete = NonNullable<NativeTransactWriteItem["Delete"]>;
+type NativePut = NonNullable<NativeTransactWriteItem["Put"]>;
+type NativeUpdate = NonNullable<NativeTransactWriteItem["Update"]>;
+
+const sortTables = (tables: TransactWriteItemsTables) =>
+  [
+    ...new Map(
+      tables.map((table) => [table.LogicalId, table] as const),
+    ).values(),
+  ].sort((a, b) =>
+    a.LogicalId.localeCompare(b.LogicalId),
+  ) as TransactWriteItemsTables;
+
+export interface BoundConditionCheck extends Omit<
+  NativeConditionCheck,
+  "TableName"
+> {
+  Table: string;
+}
+
+export interface BoundDelete extends Omit<NativeDelete, "TableName"> {
+  Table: string;
+}
+
+export interface BoundPut extends Omit<NativePut, "TableName"> {
+  Table: string;
+}
+
+export interface BoundUpdate extends Omit<NativeUpdate, "TableName"> {
+  Table: string;
+}
+
+export interface BoundTransactWriteItem {
+  ConditionCheck?: BoundConditionCheck;
+  Delete?: BoundDelete;
+  Put?: BoundPut;
+  Update?: BoundUpdate;
+}
+
+export interface TransactWriteItemsRequest extends Omit<
+  DynamoDB.TransactWriteItemsInput,
+  "TransactItems"
+> {
+  TransactItems: Array<BoundTransactWriteItem>;
+}
+
+/**
+ * Runtime binding for `dynamodb:TransactWriteItems`.
+ *
+ * Bind this operation to one or more tables and identify each item's target
+ * table by the bound table's `LogicalId`.
+ *
+ * @section Writing Data
+ * @example Write Items Transactionally
+ * ```typescript
+ * const transactWriteItems = yield* TransactWriteItems.bind(
+ *   sourceTable,
+ *   archiveTable,
+ * );
+ *
+ * yield* transactWriteItems({
+ *   TransactItems: [
+ *     {
+ *       Put: {
+ *         Table: sourceTable.LogicalId,
+ *         Item: { pk: { S: "user#1" }, sk: { S: "profile" } },
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export class TransactWriteItems extends Binding.Service<
+  TransactWriteItems,
+  (
+    ...tables: TransactWriteItemsTables
+  ) => Effect.Effect<
+    (
+      request: TransactWriteItemsRequest,
+    ) => Effect.Effect<
+      DynamoDB.TransactWriteItemsOutput,
+      DynamoDB.TransactWriteItemsError
+    >
+  >
+>()("AWS.DynamoDB.TransactWriteItems") {}
+
+export const TransactWriteItemsLive = Layer.effect(
+  TransactWriteItems,
+  Effect.gen(function* () {
+    const Policy = yield* TransactWriteItemsPolicy;
+    const transactWriteItems = yield* DynamoDB.transactWriteItems;
+
+    return Effect.fn(function* (...tables: TransactWriteItemsTables) {
+      const sortedTables = sortTables(tables);
+      const tableNames = new Map(
+        yield* Effect.forEach(sortedTables, (table) =>
+          Effect.gen(function* () {
+            return [table.LogicalId, yield* table.tableName] as const;
+          }),
+        ),
+      );
+
+      const getTableName = (tableId: string) => {
+        const TableName = tableNames.get(tableId);
+        if (!TableName) {
+          throw new Error(
+            `TransactWriteItems request references unbound table '${tableId}'`,
+          );
+        }
+        return TableName;
+      };
+
+      yield* Policy(...sortedTables);
+
+      return Effect.fn(function* (request: TransactWriteItemsRequest) {
+        const transactItems = yield* Effect.forEach(
+          request.TransactItems,
+          (item) =>
+            Effect.gen(function* () {
+              if (item.ConditionCheck) {
+                return {
+                  ConditionCheck: {
+                    ...item.ConditionCheck,
+                    TableName: yield* getTableName(item.ConditionCheck.Table),
+                  },
+                };
+              }
+              if (item.Delete) {
+                return {
+                  Delete: {
+                    ...item.Delete,
+                    TableName: yield* getTableName(item.Delete.Table),
+                  },
+                };
+              }
+              if (item.Put) {
+                return {
+                  Put: {
+                    ...item.Put,
+                    TableName: yield* getTableName(item.Put.Table),
+                  },
+                };
+              }
+              if (item.Update) {
+                return {
+                  Update: {
+                    ...item.Update,
+                    TableName: yield* getTableName(item.Update.Table),
+                  },
+                };
+              }
+              throw new Error(
+                "TransactWriteItems request item must include one DynamoDB operation",
+              );
+            }),
+        );
+
+        return yield* transactWriteItems({
+          ...request,
+          TransactItems: transactItems,
+        });
+      });
+    });
+  }),
+);
+
+export class TransactWriteItemsPolicy extends Binding.Policy<
+  TransactWriteItemsPolicy,
+  (...tables: TransactWriteItemsTables) => Effect.Effect<void>
+>()("AWS.DynamoDB.TransactWriteItems") {}
+
+export const TransactWriteItemsPolicyLive =
+  TransactWriteItemsPolicy.layer.succeed(
+    Effect.fn(function* (host, ...tables: TransactWriteItemsTables) {
+      const sortedTables = sortTables(tables);
+
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.DynamoDB.TransactWriteItems(${sortedTables}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: [
+                  "dynamodb:ConditionCheckItem",
+                  "dynamodb:DeleteItem",
+                  "dynamodb:PutItem",
+                  "dynamodb:UpdateItem",
+                ],
+                Resource: sortedTables.map((table) => table.tableArn),
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `TransactWriteItemsPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/DynamoDB/UpdateItem.ts

@@ -0,0 +1,67 @@
+import * as DynamoDB from "@distilled.cloud/aws/dynamodb";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Table } from "./Table.ts";
+
+export interface UpdateItemRequest extends Omit<
+  DynamoDB.UpdateItemInput,
+  "TableName"
+> {}
+
+export class UpdateItem extends Binding.Service<
+  UpdateItem,
+  <T extends Table>(
+    table: T,
+  ) => Effect.Effect<
+    (
+      request: UpdateItemRequest,
+    ) => Effect.Effect<DynamoDB.UpdateItemOutput, DynamoDB.UpdateItemError>
+  >
+>()("AWS.DynamoDB.UpdateItem") {}
+
+export const UpdateItemLive = Layer.effect(
+  UpdateItem,
+  Effect.gen(function* () {
+    const Policy = yield* UpdateItemPolicy;
+    const updateItem = yield* DynamoDB.updateItem;
+
+    return Effect.fn(function* <T extends Table>(table: T) {
+      const TableName = yield* table.tableName;
+      yield* Policy(table);
+      return Effect.fn(function* (request: UpdateItemRequest) {
+        const tableName = yield* TableName;
+        return yield* updateItem({
+          ...request,
+          TableName: tableName,
+        });
+      });
+    });
+  }),
+);
+
+export class UpdateItemPolicy extends Binding.Policy<
+  UpdateItemPolicy,
+  <T extends Table>(table: T) => Effect.Effect<void>
+>()("AWS.DynamoDB.UpdateItem") {}
+
+export const UpdateItemPolicyLive = UpdateItemPolicy.layer.succeed(
+  Effect.fn(function* (host, table) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.DynamoDB.UpdateItem(${table}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["dynamodb:UpdateItem"],
+            Resource: [table.tableArn],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `UpdateItemPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/DynamoDB/UpdateTimeToLive.ts

@@ -0,0 +1,71 @@
+import * as DynamoDB from "@distilled.cloud/aws/dynamodb";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Table } from "./Table.ts";
+
+export interface UpdateTimeToLiveRequest extends Omit<
+  DynamoDB.UpdateTimeToLiveInput,
+  "TableName"
+> {}
+
+export class UpdateTimeToLive extends Binding.Service<
+  UpdateTimeToLive,
+  <T extends Table>(
+    table: T,
+  ) => Effect.Effect<
+    (
+      request: UpdateTimeToLiveRequest,
+    ) => Effect.Effect<
+      DynamoDB.UpdateTimeToLiveOutput,
+      DynamoDB.UpdateTimeToLiveError
+    >
+  >
+>()("AWS.DynamoDB.UpdateTimeToLive") {}
+
+export const UpdateTimeToLiveLive = Layer.effect(
+  UpdateTimeToLive,
+  Effect.gen(function* () {
+    const Policy = yield* UpdateTimeToLivePolicy;
+    const updateTimeToLive = yield* DynamoDB.updateTimeToLive;
+
+    return Effect.fn(function* <T extends Table>(table: T) {
+      const TableName = yield* table.tableName;
+      yield* Policy(table);
+      return Effect.fn(function* (request: UpdateTimeToLiveRequest) {
+        return yield* updateTimeToLive({
+          ...request,
+          TableName: yield* TableName,
+        });
+      });
+    });
+  }),
+);
+
+export class UpdateTimeToLivePolicy extends Binding.Policy<
+  UpdateTimeToLivePolicy,
+  <T extends Table>(table: T) => Effect.Effect<void>
+>()("AWS.DynamoDB.UpdateTimeToLive") {}
+
+export const UpdateTimeToLivePolicyLive = UpdateTimeToLivePolicy.layer.succeed(
+  Effect.fn(function* (host, table) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.DynamoDB.UpdateTimeToLive(${table}))`(
+        {
+          policyStatements: [
+            {
+              Effect: "Allow",
+              Action: ["dynamodb:UpdateTimeToLive"],
+              Resource: [table.tableArn],
+            },
+          ],
+        },
+      );
+    } else {
+      return yield* Effect.die(
+        `UpdateTimeToLivePolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/DynamoDB/index.ts

@@ -0,0 +1,24 @@
+export * from "./AttributeValue.ts";
+export * from "./BatchExecuteStatement.ts";
+export * from "./BatchGetItem.ts";
+export * from "./BatchWriteItem.ts";
+export * from "./DeleteItem.ts";
+export * from "./DescribeTable.ts";
+export * from "./DescribeTimeToLive.ts";
+export * from "./ExecuteStatement.ts";
+export * from "./ExecuteTransaction.ts";
+export * as Expr from "./Expr.ts";
+export * from "./GetItem.ts";
+export * from "./ListTables.ts";
+export * from "./ListTagsOfResource.ts";
+export * from "./ProjectionExpression.ts";
+export * from "./PutItem.ts";
+export * from "./Query.ts";
+export * from "./RestoreTableToPointInTime.ts";
+export * from "./Scan.ts";
+export * from "./Stream.ts";
+export * from "./Table.ts";
+export * from "./TransactGetItems.ts";
+export * from "./TransactWriteItems.ts";
+export * from "./UpdateItem.ts";
+export * from "./UpdateTimeToLive.ts";