【TypeScript】DynamoDBでもトランザクション用の汎用的なサービスクラスを作りたい

// TransactionManagerインターフェース（ドメイン層）
type TransactionManager = {
+ runInTransaction<T>(
+   operation: (tx?: unknown) => Promise<Result<T, E>>,
+ ): Promise<Result<T, E>>;
};

// Prismaによる実装（インフラ層）
class PrismaTransactionManager implements TransactionManager {
  async runInTransaction<T>(
    operation: (tx?: unknown) => Promise<Result<T, E>>,
  ): Promise<Result<T, E>> {
+   return await prisma.$transaction(async (tx) => {
+     return await operation(tx);
+   });
  }
}

// ユースケースでの使用例
await transactionManager.runInTransaction(async (tx) => {
 await userRepository.save(updatedUser, tx);
 await subscriptionRepository.save(canceledSubscription, tx);
 return createSuccess(undefined);
});

src/
├── domain/
│   └── support/
│       └── transaction-service/
│           ├── index.ts       # インターフェース定義
│           └── dummy.ts       # テスト用ダミー実装
└── infrastructure/
    └── transaction/
        └── dynamodb-transaction-service.ts  # DynamoDB実装

/**
 * トランザクション対応エンティティの種別
 */
export type EntityType = "user" | "membershipCard";

/**
 * トランザクション対象のエンティティ
 */
export type TransactableEntity = User | MembershipCard;

/**
 * トランザクションで実行する操作
 * - put: エンティティの作成/更新
 * - delete: エンティティの削除
 */
+export type TransactionItem =
+ | { operation: "put"; entity: TransactableEntity }
+ | { operation: "delete"; entity: TransactableEntity };

/**
 * トランザクションサービス
 */
export type TransactionService = {
  /**
   * トランザクションを実行する
   *
   * @param items トランザクション対象のアイテム
   * @throws トランザクション失敗時、またはアイテム数が上限を超えた場合にエラーをスロー
   */
+ execute(items: TransactionItem[]): Promise<void>;
};

const MAX_TRANSACT_ITEMS = 100;

export class DynamoDBTransactionServiceImpl implements TransactionService {
  readonly #ddbDoc: DynamoDBDocumentClient;
  readonly #tableNames: Record<EntityType, string>;
  readonly #logger: Logger;

  constructor({ ddbDoc, tableNames, logger }: DynamoDBTransactionServiceProps) {
    this.#ddbDoc = ddbDoc;
    this.#tableNames = tableNames;
    this.#logger = logger;
  }

  async execute(items: TransactionItem[]): Promise<void> {
    this.#logger.info("トランザクション開始", {
      itemCount: items.length,
    });

    if (items.length === 0) {
      this.#logger.debug("トランザクションアイテムが空のためスキップ");
      return;
    }

    if (items.length > MAX_TRANSACT_ITEMS) {
      throw new DatabaseError(
        "トランザクションアイテム数が上限を超えています",
        {
          cause: {
            itemCount: items.length,
            maxTransactItems: MAX_TRANSACT_ITEMS,
          },
        },
      );
    }

+   const transactItems = items.map((item) => this.#toTransactWriteItem(item));

+   await this.#ddbDoc.send(
+     new TransactWriteCommand({ TransactItems: transactItems }),
+   );

    this.#logger.debug("トランザクション完了", {
      itemCount: items.length,
    });
  }

  /**
   * TransactionItem → DynamoDB TransactWriteItem 変換
   */
+ #toTransactWriteItem(item: TransactionItem) {
+   const { tableName, ddbItem, key } = this.#resolveEntityInfo(item.entity);

    switch (item.operation) {
      case "put":
        return {
          Put: {
            TableName: tableName,
            Item: ddbItem,
          },
        };
      case "delete":
        return {
          Delete: {
            TableName: tableName,
            Key: key,
          },
        };
    }
  }

  /**
   * エンティティからテーブル名、DynamoDB Item、Keyを解決する
   */
+ #resolveEntityInfo(entity: TransactableEntity) {
    if (entity instanceof User) {
      return {
        tableName: this.#tableNames.user,
        ddbItem: userDdbItemFromDomain(entity),
        key: { userId: entity.userId },
      };
    }

    if (entity instanceof BaseMembershipCard) {
      return {
        tableName: this.#tableNames.membershipCard,
        ddbItem: membershipCardDdbItemFromDomain(entity),
        key: {
          userId: entity.userId,
          facilityCodeCreatedAt: generateFacilityCodeCreatedAt(
            entity.facilityCode,
            dateToIsoString(entity.createdAt),
          ),
        },
      };
    }

    // 新しいエンティティを追加した場合はここでコンパイルエラーになる
+   throw new ExhaustiveError(entity);
  }
}

// トランザクションアイテムを構築
const transactionItems: TransactionItem[] = [
 // 本会員証: inactive に変更して put
 { operation: "put", entity: inactiveMembershipCard },
 // 仮会員証: delete
 ...temporaryCards.map(
   (card): TransactionItem => ({ operation: "delete", entity: card }),
 ),
];

// トランザクションで会員証を保存・削除
+await this.#transactionService.execute(transactionItems);