@effect-aws/dynamodb 1.0.0

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": []
+}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@effect-aws/dynamodb",
+  "version": "1.0.0",
+  "description": "Effectful AWS DynamoDB library & functions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "github:floydspace/effect-aws",
+    "directory": "packages/dynamodb"
+  },
+  "sideEffects": [],
+  "author": {
+    "name": "Victor Korzunin",
+    "email": "ifloydrose@gmail.com"
+  },
+  "homepage": "https://floydspace.github.io/effect-aws/docs/dynamodb",
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3",
+    "@aws-sdk/lib-dynamodb": "^3",
+    "@effect-aws/commons": "^0.3.0"
+  },
+  "peerDependencies": {
+    "effect": ">=3.0.4 <4.0.0",
+    "@effect-aws/client-dynamodb": "^1.10.3"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./DynamoDBDocumentClientInstance": {
+      "types": "./dist/dts/DynamoDBDocumentClientInstance.d.ts",
+      "import": "./dist/esm/DynamoDBDocumentClientInstance.js",
+      "default": "./dist/cjs/DynamoDBDocumentClientInstance.js"
+    },
+    "./DynamoDBDocumentService": {
+      "types": "./dist/dts/DynamoDBDocumentService.d.ts",
+      "import": "./dist/esm/DynamoDBDocumentService.js",
+      "default": "./dist/cjs/DynamoDBDocumentService.js"
+    },
+    "./DynamoDBDocumentServiceConfig": {
+      "types": "./dist/dts/DynamoDBDocumentServiceConfig.d.ts",
+      "import": "./dist/esm/DynamoDBDocumentServiceConfig.js",
+      "default": "./dist/cjs/DynamoDBDocumentServiceConfig.js"
+    },
+    "./DynamoDBStore": {
+      "types": "./dist/dts/DynamoDBStore.d.ts",
+      "import": "./dist/esm/DynamoDBStore.js",
+      "default": "./dist/cjs/DynamoDBStore.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "DynamoDBDocumentClientInstance": [
+        "./dist/dts/DynamoDBDocumentClientInstance.d.ts"
+      ],
+      "DynamoDBDocumentService": [
+        "./dist/dts/DynamoDBDocumentService.d.ts"
+      ],
+      "DynamoDBDocumentServiceConfig": [
+        "./dist/dts/DynamoDBDocumentServiceConfig.d.ts"
+      ],
+      "DynamoDBStore": [
+        "./dist/dts/DynamoDBStore.d.ts"
+      ]
+    }
+  }
+}

package/src/DynamoDBDocumentClientInstance.ts

@@ -0,0 +1,34 @@
+/**
+ * @since 1.0.0
+ */
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { DynamoDBClientInstance } from "@effect-aws/client-dynamodb";
+import { Context, Effect, Layer } from "effect";
+import * as DynamoDBDocumentServiceConfig from "./DynamoDBDocumentServiceConfig.js";
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export class DynamoDBDocumentClientInstance extends Context.Tag(
+  "@effect-aws/lib-dynamodb/DynamoDBDocumentClientInstance",
+)<DynamoDBDocumentClientInstance, DynamoDBDocumentClient>() {}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = Effect.all([
+  DynamoDBClientInstance.DynamoDBClientInstance,
+  DynamoDBDocumentServiceConfig.toTranslateConfig,
+]).pipe(
+  Effect.map(([client, config]) => DynamoDBDocumentClient.from(client, config)),
+);
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = Layer.scoped(DynamoDBDocumentClientInstance, make).pipe(
+  Layer.provide(DynamoDBClientInstance.layer),
+);

package/src/DynamoDBDocumentService.ts

@@ -0,0 +1,377 @@
+/**
+ * @since 1.0.0
+ */
+import type { DynamoDBClientConfig } from "@aws-sdk/client-dynamodb";
+import type {
+  BatchExecuteStatementCommandInput,
+  BatchExecuteStatementCommandOutput,
+  BatchGetCommandInput,
+  BatchGetCommandOutput,
+  BatchWriteCommandInput,
+  BatchWriteCommandOutput,
+  DeleteCommandInput,
+  DeleteCommandOutput,
+  DynamoDBDocumentClient,
+  ExecuteStatementCommandInput,
+  ExecuteStatementCommandOutput,
+  ExecuteTransactionCommandInput,
+  ExecuteTransactionCommandOutput,
+  GetCommandInput,
+  GetCommandOutput,
+  PutCommandInput,
+  PutCommandOutput,
+  QueryCommandInput,
+  QueryCommandOutput,
+  ScanCommandInput,
+  ScanCommandOutput,
+  TransactGetCommandInput,
+  TransactGetCommandOutput,
+  TransactWriteCommandInput,
+  TransactWriteCommandOutput,
+  TranslateConfig,
+  UpdateCommandInput,
+  UpdateCommandOutput,
+} from "@aws-sdk/lib-dynamodb";
+import {
+  BatchExecuteStatementCommand,
+  BatchGetCommand,
+  BatchWriteCommand,
+  DeleteCommand,
+  ExecuteStatementCommand,
+  ExecuteTransactionCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  ScanCommand,
+  TransactGetCommand,
+  TransactWriteCommand,
+  UpdateCommand,
+} from "@aws-sdk/lib-dynamodb";
+import type {
+  ConditionalCheckFailedError,
+  DuplicateItemError,
+  IdempotentParameterMismatchError,
+  InternalServerError,
+  InvalidEndpointError,
+  ItemCollectionSizeLimitExceededError,
+  ProvisionedThroughputExceededError,
+  RequestLimitExceededError,
+  ResourceNotFoundError,
+  SdkError,
+  TransactionCanceledError,
+  TransactionConflictError,
+  TransactionInProgressError,
+} from "@effect-aws/client-dynamodb";
+import { DynamoDBServiceConfig } from "@effect-aws/client-dynamodb";
+import { type HttpHandlerOptions, Service } from "@effect-aws/commons";
+import type { Cause } from "effect";
+import { Effect, Layer } from "effect";
+import * as Instance from "./DynamoDBDocumentClientInstance.js";
+import * as DynamoDBDocumentServiceConfig from "./DynamoDBDocumentServiceConfig.js";
+
+const commands = {
+  BatchExecuteStatementCommand,
+  BatchGetCommand,
+  BatchWriteCommand,
+  DeleteCommand,
+  ExecuteStatementCommand,
+  ExecuteTransactionCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  ScanCommand,
+  TransactGetCommand,
+  TransactWriteCommand,
+  UpdateCommand,
+};
+
+interface DynamoDBDocumentService$ {
+  readonly _: unique symbol;
+
+  /**
+   * @see {@link BatchExecuteStatementCommand}
+   */
+  batchExecuteStatement(
+    args: BatchExecuteStatementCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    BatchExecuteStatementCommandOutput,
+    Cause.TimeoutException | SdkError | InternalServerError | RequestLimitExceededError
+  >;
+
+  /**
+   * @see {@link BatchGetCommand}
+   */
+  batchGet(
+    args: BatchGetCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    BatchGetCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | InternalServerError
+    | InvalidEndpointError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+  >;
+
+  /**
+   * @see {@link BatchWriteCommand}
+   */
+  batchWrite(
+    args: BatchWriteCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    BatchWriteCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | InternalServerError
+    | InvalidEndpointError
+    | ItemCollectionSizeLimitExceededError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+  >;
+
+  /**
+   * @see {@link DeleteCommand}
+   */
+  delete(
+    args: DeleteCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    DeleteCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | ConditionalCheckFailedError
+    | InternalServerError
+    | InvalidEndpointError
+    | ItemCollectionSizeLimitExceededError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionConflictError
+  >;
+
+  /**
+   * @see {@link ExecuteStatementCommand}
+   */
+  executeStatement(
+    args: ExecuteStatementCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    ExecuteStatementCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | ConditionalCheckFailedError
+    | DuplicateItemError
+    | InternalServerError
+    | ItemCollectionSizeLimitExceededError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionConflictError
+  >;
+
+  /**
+   * @see {@link ExecuteTransactionCommand}
+   */
+  executeTransaction(
+    args: ExecuteTransactionCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    ExecuteTransactionCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | IdempotentParameterMismatchError
+    | InternalServerError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionCanceledError
+    | TransactionInProgressError
+  >;
+
+  /**
+   * @see {@link GetCommand}
+   */
+  get(
+    args: GetCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    GetCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | InternalServerError
+    | InvalidEndpointError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+  >;
+
+  /**
+   * @see {@link PutCommand}
+   */
+  put(
+    args: PutCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    PutCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | ConditionalCheckFailedError
+    | InternalServerError
+    | InvalidEndpointError
+    | ItemCollectionSizeLimitExceededError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionConflictError
+  >;
+
+  /**
+   * @see {@link QueryCommand}
+   */
+  query(
+    args: QueryCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    QueryCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | InternalServerError
+    | InvalidEndpointError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+  >;
+
+  /**
+   * @see {@link ScanCommand}
+   */
+  scan(
+    args: ScanCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    ScanCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | InternalServerError
+    | InvalidEndpointError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+  >;
+
+  /**
+   * @see {@link TransactGetCommand}
+   */
+  transactGet(
+    args: TransactGetCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    TransactGetCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | InternalServerError
+    | InvalidEndpointError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionCanceledError
+  >;
+
+  /**
+   * @see {@link TransactWriteCommand}
+   */
+  transactWrite(
+    args: TransactWriteCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    TransactWriteCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | IdempotentParameterMismatchError
+    | InternalServerError
+    | InvalidEndpointError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionCanceledError
+    | TransactionInProgressError
+  >;
+
+  /**
+   * @see {@link UpdateCommand}
+   */
+  update(
+    args: UpdateCommandInput,
+    options?: HttpHandlerOptions,
+  ): Effect.Effect<
+    UpdateCommandOutput,
+    | Cause.TimeoutException
+    | SdkError
+    | ConditionalCheckFailedError
+    | InternalServerError
+    | InvalidEndpointError
+    | ItemCollectionSizeLimitExceededError
+    | ProvisionedThroughputExceededError
+    | RequestLimitExceededError
+    | ResourceNotFoundError
+    | TransactionConflictError
+  >;
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeDynamoDBDocumentService = Effect.gen(function*() {
+  const client = yield* Instance.DynamoDBDocumentClientInstance;
+
+  return yield* Service.fromClientAndCommands<DynamoDBDocumentService$>(client, commands, {
+    resolveClientConfig: DynamoDBServiceConfig.toDynamoDBClientConfig,
+  });
+});
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export class DynamoDBDocumentService extends Effect.Tag(
+  "@effect-aws/lib-dynamodb/DynamoDBDocumentService",
+)<DynamoDBDocumentService, DynamoDBDocumentService$>() {
+  static readonly defaultLayer = Layer.effect(this, makeDynamoDBDocumentService).pipe(Layer.provide(Instance.layer));
+  static readonly layer = (config: DynamoDBDocumentService.Config) =>
+    Layer.effect(this, makeDynamoDBDocumentService).pipe(
+      Layer.provide(Instance.layer),
+      Layer.provide(DynamoDBDocumentServiceConfig.setDynamoDBDocumentServiceConfig(config)),
+    );
+  static readonly baseLayer = (
+    evaluate: (defaultConfig: DynamoDBClientConfig) => DynamoDBDocumentClient,
+  ) =>
+    Layer.effect(this, makeDynamoDBDocumentService).pipe(
+      Layer.provide(
+        Layer.effect(
+          Instance.DynamoDBDocumentClientInstance,
+          Effect.map(DynamoDBServiceConfig.toDynamoDBClientConfig, evaluate),
+        ),
+      ),
+    );
+}
+
+/**
+ * @since 1.0.0
+ */
+export declare namespace DynamoDBDocumentService {
+  /**
+   * @since 1.0.0
+   */
+  export type Config = TranslateConfig;
+
+  /**
+   * @since 1.0.0
+   */
+  export type Type = DynamoDBDocumentService$;
+}

package/src/DynamoDBDocumentServiceConfig.ts

@@ -0,0 +1,43 @@
+/**
+ * @since 1.0.0
+ */
+import type { TranslateConfig } from "@aws-sdk/lib-dynamodb";
+import { Effect, FiberRef, Layer } from "effect";
+import { dual } from "effect/Function";
+import { globalValue } from "effect/GlobalValue";
+import type { DynamoDBDocumentService } from "./DynamoDBDocumentService.js";
+
+/**
+ * @since 1.0.0
+ * @category dynamodb service config
+ */
+const currentDynamoDBDocumentServiceConfig = globalValue(
+  "@effect-aws/lib-dynamodb/currentDynamoDBDocumentServiceConfig",
+  () => FiberRef.unsafeMake<DynamoDBDocumentService.Config>({}),
+);
+
+/**
+ * @since 1.0.0
+ * @category dynamodb service config
+ */
+export const withDynamoDBDocumentServiceConfig: {
+  (config: DynamoDBDocumentService.Config): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  <A, E, R>(effect: Effect.Effect<A, E, R>, config: DynamoDBDocumentService.Config): Effect.Effect<A, E, R>;
+} = dual(
+  2,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, config: DynamoDBDocumentService.Config): Effect.Effect<A, E, R> =>
+    Effect.locally(effect, currentDynamoDBDocumentServiceConfig, config),
+);
+
+/**
+ * @since 1.0.0
+ * @category dynamodb service config
+ */
+export const setDynamoDBDocumentServiceConfig = (config: DynamoDBDocumentService.Config) =>
+  Layer.locallyScoped(currentDynamoDBDocumentServiceConfig, config);
+
+/**
+ * @since 1.0.0
+ * @category adapters
+ */
+export const toTranslateConfig: Effect.Effect<TranslateConfig> = FiberRef.get(currentDynamoDBDocumentServiceConfig);

package/src/DynamoDBStore.ts

@@ -0,0 +1,131 @@
+/**
+ * @since 1.0.0
+ */
+import { Config, Effect, Layer } from "effect";
+import { DynamoDBDocumentService } from "./DynamoDBDocumentService.js";
+
+type WithoutTableNameInArgs = {
+  [K in keyof Omit<DynamoDBDocumentService.Type, "_">]: Parameters<
+    DynamoDBDocumentService.Type[K]
+  >[0] extends { TableName?: string } ? (
+      args: Omit<Parameters<DynamoDBDocumentService.Type[K]>[0], "TableName">,
+      options?: Parameters<DynamoDBDocumentService.Type[K]>[1],
+    ) => Effect.Effect<
+      Effect.Effect.Success<
+        ReturnType<DynamoDBDocumentService.Type[K]>
+      > extends { Item?: infer Item } ? Item | undefined
+        : Effect.Effect.Success<
+          ReturnType<DynamoDBDocumentService.Type[K]>
+        > extends { Items?: infer Items } ? Items
+        : Effect.Effect.Success<
+          ReturnType<DynamoDBDocumentService.Type[K]>
+        > extends { Attributes?: infer Attributes } ? Attributes | undefined
+        : never,
+      Effect.Effect.Error<ReturnType<DynamoDBDocumentService.Type[K]>>,
+      Effect.Effect.Context<ReturnType<DynamoDBDocumentService.Type[K]>>
+    >
+    : never;
+};
+
+type WithoutTableNameInBatchRequest = {
+  [K in keyof Omit<DynamoDBDocumentService.Type, "_">]: Parameters<
+    DynamoDBDocumentService.Type[K]
+  >[0] extends { RequestItems?: { [key: string]: infer RequestItems } } ? (
+      args: RequestItems,
+      options?: Parameters<DynamoDBDocumentService.Type[K]>[1],
+    ) => ReturnType<DynamoDBDocumentService.Type[K]>
+    : never;
+};
+
+type OmitNeverProps<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeDynamoDBStore = Effect.fn(function*(props: DynamoDBStore.Config) {
+  const ddb = yield* DynamoDBDocumentService;
+
+  return {
+    scan: (args) =>
+      ddb
+        .scan({ TableName: props.tableName, ...args })
+        .pipe(Effect.map(({ Items }) => Items ?? [])),
+    query: (args) =>
+      ddb
+        .query({ TableName: props.tableName, ...args })
+        .pipe(Effect.map(({ Items }) => Items ?? [])),
+    get: (args) =>
+      ddb
+        .get({ TableName: props.tableName, Key: args?.Key })
+        .pipe(Effect.map(({ Item }) => Item)),
+    put: (args) =>
+      ddb
+        .put({ TableName: props.tableName, ...args })
+        .pipe(Effect.map(({ Attributes }) => Attributes)),
+    batchWrite: (items) => ddb.batchWrite({ RequestItems: { [props.tableName]: items } }),
+    batchPut: (items) =>
+      ddb.batchWrite({
+        RequestItems: {
+          [props.tableName]: items.map((Item) => ({ PutRequest: { Item } })),
+        },
+      }),
+    batchDelete: (keys) =>
+      ddb.batchWrite({
+        RequestItems: {
+          [props.tableName]: keys.map((Key) => ({ DeleteRequest: { Key } })),
+        },
+      }),
+    batchGet: (items) => ddb.batchGet({ RequestItems: { [props.tableName]: items } }),
+    update: (args) =>
+      ddb
+        .update({ TableName: props.tableName, ...args })
+        .pipe(Effect.map(({ Attributes }) => Attributes)),
+    delete: (args) =>
+      ddb
+        .delete({ TableName: props.tableName, ...args })
+        .pipe(Effect.map(({ Attributes }) => Attributes)),
+  } satisfies DynamoDBStore.Type;
+});
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export class DynamoDBStore extends Effect.Tag("@pms/common/DynamoDBStore")<
+  DynamoDBStore,
+  DynamoDBStore.Type
+>() {
+  static layer = (props: DynamoDBStore.Config) => Layer.effect(this, makeDynamoDBStore(props));
+  static layerConfig = (config: Config.Config.Wrap<DynamoDBStore.Config>) =>
+    Layer.effect(this, Config.unwrap(config).pipe(Effect.flatMap(makeDynamoDBStore)));
+}
+
+/**
+ * @since 1.0.0
+ */
+export declare namespace DynamoDBStore {
+  /**
+   * @since 1.0.0
+   */
+  export type Config = {
+    readonly tableName: string;
+  };
+
+  /**
+   * @since 1.0.0
+   */
+  export type Type =
+    & OmitNeverProps<WithoutTableNameInArgs>
+    & OmitNeverProps<WithoutTableNameInBatchRequest>
+    & {
+      batchPut: (
+        items: Array<Record<string, any>>,
+      ) => ReturnType<DynamoDBDocumentService.Type["batchWrite"]>;
+      batchDelete: (
+        keys: Array<Record<string, any>>,
+      ) => ReturnType<DynamoDBDocumentService.Type["batchWrite"]>;
+    };
+}