make it possible to retrieve types of the returned items when doing a…

… read transaction request

src/queryBuilders/__snapshots__/readTransactionBuilder.integration.test.ts.snap

@@ -0,0 +1,25 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`ReadTransactionBuilder > handles transaction with gets 1`] = `
+[
+  [
+    "myTable",
+    {
+      "dataTimestamp": 222,
+      "someBoolean": true,
+      "somethingElse": 2,
+      "userId": "123",
+    },
+  ],
+  [
+    "myOtherTable",
+    {
+      "userId": "123",
+    },
+  ],
+  [
+    "myTable",
+    undefined,
+  ],
+]
+`;

src/queryBuilders/readTransactionBuilder.integration.test.ts

@@ -26,7 +26,24 @@ describe("ReadTransactionBuilder", () => {
       }),
     });
 
+    trx.addItem({
+      Get: tsynamoClient
+        .getItem("myOtherTable")
+        .keys({
+          userId: "123",
+          stringTimestamp: "111",
+        })
+        .attributes(["userId"]),
+    });
+
+    trx.addItem({
+      Get: tsynamoClient.getItem("myTable").keys({
+        userId: "1111111",
+        dataTimestamp: 2222,
+      }),
+    });
+
     const result = await trx.execute();
-    console.log("result", result);
+    expect(result).toMatchSnapshot();
   });
 });

src/queryBuilders/readTransactionBuilder.ts

@@ -1,43 +1,54 @@
 import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
 import { ReadTransactionNode } from "../nodes/readTransactionNode";
 import { QueryCompiler } from "../queryCompiler";
+import { AllTuples } from "../typeHelpers";
 import { GetQueryBuilder } from "./getItemQueryBuilder";
 
-/**
- * @todo What to show as return type?
- */
 export interface ReadTransactionBuilderInterface<DDB> {
   addItem<Table extends keyof DDB, O extends DDB[Table]>(item: {
     Get: GetQueryBuilder<DDB, Table, O>;
   }): void;
 
-  execute(): Promise<unknown[]>;
+  /**
+   * The return value is an array of tuples, where the first item
+   * tells the name of the table, and the right item is the result
+   * item itself (or undefined if not found). The table can be used
+   * for discriminated union to determine the actual type of the result
+   * item.
+   */
+  execute(): Promise<AllTuples<DDB>[]>;
 }
 
 export class ReadTransactionBuilder<DDB>
   implements ReadTransactionBuilderInterface<DDB>
 {
   readonly #props: ReadTransactionBuilderProps;
+  resultTables: string[] = [];
 
   constructor(props: ReadTransactionBuilderProps) {
     this.#props = props;
   }
 
   addItem(item: { Get: GetQueryBuilder<DDB, any, any> }) {
+    this.resultTables.push(item.Get.node.table.table);
+
     this.#props.node.transactGetItems.push({
       kind: "TransactGetItemNode",
       Get: item.Get.node,
     });
   }
 
-  async execute() {
+  async execute(): Promise<AllTuples<DDB>[]> {
     const transactionCommand = this.#props.queryCompiler.compile(
       this.#props.node
     );
 
     return (
       await this.#props.ddbClient.send(transactionCommand)
-    ).Responses?.map((o) => o.Item) as unknown[];
+    ).Responses?.map((o, i) => [
+      this.resultTables[i],
+      o.Item,
+    ]) as AllTuples<DDB>[];
   }
 }
 

src/typeHelpers.ts

@@ -247,3 +247,20 @@ export type ObjectFullPaths<T> =
         never
     : // Leaf value reached, don't return anything
       never;
+
+/**
+ * Creates a tuple where the first item is the name of the table
+ * and the second item is the schema of the table.
+ */
+type DependentTuple<DDB, Table extends keyof DDB> = [
+  Table,
+  ExecuteOutput<DDB[Table]> | undefined
+];
+
+/**
+ * Generates a type that can be used for discriminated union
+ * when returning data from multiple different tables.
+ */
+export type AllTuples<DDB> = {
+  [Table in keyof DDB]: DependentTuple<DDB, Table>;
+}[keyof DDB];