@model-ts/dynamodb 3.0.4 → 3.1.0

package/dist/cjs/__test__/client.test.js

@@ -11,7 +11,7 @@ const client = new client_1.Client({ tableName: "table" });
 const provider = provider_1.getProvider(client);
 const SIMPLE_CODEC = t.type({
     foo: t.string,
-    bar: t.number
+    bar: t.number,
 });
 class Simple extends core_1.model("Simple", SIMPLE_CODEC, provider) {
     get PK() {
@@ -273,7 +273,7 @@ describe("put", () => {
         test("it overwrites item if `ignoreExistence` is set", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             yield MultiGSI.put(new MultiGSI({ foo: "yes", bar: 42 }));
             yield expect(MultiGSI.put(new MultiGSI({ foo: "yes", bar: 42 }), {
-                IgnoreExistence: true
+                IgnoreExistence: true,
             })).resolves.toBeInstanceOf(MultiGSI);
         }));
     });
@@ -287,7 +287,7 @@ describe("get", () => {
             const item = yield new Simple({ foo: "hi", bar: 432 }).put();
             const result = yield Simple.get({
                 PK: item.keys().PK,
-                SK: item.keys().SK
+                SK: item.keys().SK,
             });
             expect(result.values()).toMatchInlineSnapshot(`
               Object {
@@ -334,8 +334,8 @@ describe("delete", () => {
                 _model: Simple,
                 key: {
                     PK: item.keys().PK,
-                    SK: item.keys().SK
-                }
+                    SK: item.keys().SK,
+                },
             });
             expect(result).toBeNull();
             expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
@@ -363,7 +363,7 @@ describe("delete", () => {
             const before = yield sandbox.snapshot();
             const result = yield Simple.delete({
                 PK: item.keys().PK,
-                SK: item.keys().SK
+                SK: item.keys().SK,
             });
             expect(result).toBeNull();
             expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
@@ -672,11 +672,12 @@ describe("applyUpdate", () => {
     }));
 });
 describe("query", () => {
-    test("it returns empty results", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-        expect(yield client.query({
-            KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
-            ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT" }
-        }, { a: A, b: B, union: Union })).toMatchInlineSnapshot(`
+    describe("via client", () => {
+        test("it returns empty results", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            expect(yield client.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT" },
+            }, { a: A, b: B, union: Union })).toMatchInlineSnapshot(`
       Object {
         "_unknown": Array [],
         "a": Array [],
@@ -687,13 +688,13 @@ describe("query", () => {
         "union": Array [],
       }
     `);
-    }));
-    test("it returns unknown results", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-        yield sandbox.seed({ PK: "abc", SK: "SORT#1", doesnt: "match" });
-        expect(yield client.query({
-            KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
-            ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" }
-        }, { a: A, b: B, union: Union })).toMatchInlineSnapshot(`
+        }));
+        test("it returns unknown results", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed({ PK: "abc", SK: "SORT#1", doesnt: "match" });
+            expect(yield client.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+            }, { a: A, b: B, union: Union })).toMatchInlineSnapshot(`
       Object {
         "_unknown": Array [
           Object {
@@ -710,20 +711,20 @@ describe("query", () => {
         "union": Array [],
       }
     `);
-    }));
-    test("it returns results", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-        yield sandbox.seed(new A({ pk: "abc", sk: "SORT#1", a: 1 }), new A({ pk: "abc", sk: "SORT#2", a: 2 }), new B({ pk: "abc", sk: "SORT#3", b: "hi" }), { PK: "abc", SK: "SORT#4", probably: "unknown" }, new C({ pk: "abc", sk: "SORT#5", c: "hi" }), new D({ pk: "abc", sk: "SORT#6", d: "hi" }));
-        const { a, b, union, _unknown, meta } = yield client.query({
-            KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
-            ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" }
-        }, { a: A, b: B, union: Union });
-        expect({
-            meta: meta,
-            _unknown: _unknown,
-            a: a.map(item => item.values()),
-            b: b.map(item => item.values()),
-            union: union.map(item => item.values())
-        }).toMatchInlineSnapshot(`
+        }));
+        test("it returns results", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "abc", sk: "SORT#1", a: 1 }), new A({ pk: "abc", sk: "SORT#2", a: 2 }), new B({ pk: "abc", sk: "SORT#3", b: "hi" }), { PK: "abc", SK: "SORT#4", probably: "unknown" }, new C({ pk: "abc", sk: "SORT#5", c: "hi" }), new D({ pk: "abc", sk: "SORT#6", d: "hi" }));
+            const { a, b, union, _unknown, meta } = yield client.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+            }, { a: A, b: B, union: Union });
+            expect({
+                meta: meta,
+                _unknown: _unknown,
+                a: a.map((item) => item.values()),
+                b: b.map((item) => item.values()),
+                union: union.map((item) => item.values()),
+            }).toMatchInlineSnapshot(`
       Object {
         "_unknown": Array [
           Object {
@@ -768,43 +769,174 @@ describe("query", () => {
         ],
       }
     `);
-    }));
-    test("it paginates", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-        yield sandbox.seed(...Array.from({ length: 20 }).map((_, i) => new A({ pk: "abc", sk: `SORT#${String(i).padStart(2, "0")}`, a: i })), ...Array.from({ length: 20 }).map((_, i) => new B({ pk: "abc", sk: `SORT#${i + 20}`, b: "bar" })));
-        const firstPage = yield client.query({
-            KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
-            ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
-            Limit: 30
-        }, { a: A, b: B });
-        expect(firstPage.a.length).toBe(20);
-        expect(firstPage.b.length).toBe(10);
-        expect(firstPage._unknown.length).toBe(0);
-        expect(firstPage.meta.lastEvaluatedKey).not.toBeUndefined();
-        const secondPage = yield client.query({
-            KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
-            ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
-            Limit: 30,
-            ExclusiveStartKey: firstPage.meta.lastEvaluatedKey
-        }, { a: A, b: B });
-        expect(secondPage.a.length).toBe(0);
-        expect(secondPage.b.length).toBe(10);
-        expect(secondPage._unknown.length).toBe(0);
-        expect(secondPage.meta.lastEvaluatedKey).toBeUndefined();
-    }));
-    test("it fetches all pages automatically", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-        yield sandbox.seed(...Array.from({ length: 20 }).map((_, i) => new A({ pk: "abc", sk: `SORT#${String(i).padStart(2, "0")}`, a: i })), ...Array.from({ length: 20 }).map((_, i) => new B({ pk: "abc", sk: `SORT#${i + 20}`, b: "bar" })));
-        const { a, b, meta, _unknown } = yield client.query({
-            KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
-            ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
-            FetchAllPages: true,
-            // You wouldn't set a limit in a real-world use case here to optimize fetching all items.
-            Limit: 10
-        }, { a: A, b: B });
-        expect(a.length).toBe(20);
-        expect(b.length).toBe(20);
-        expect(_unknown.length).toBe(0);
-        expect(meta.lastEvaluatedKey).toBeUndefined();
-    }));
+        }));
+        test("it paginates", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(...Array.from({ length: 20 }).map((_, i) => new A({ pk: "abc", sk: `SORT#${String(i).padStart(2, "0")}`, a: i })), ...Array.from({ length: 20 }).map((_, i) => new B({ pk: "abc", sk: `SORT#${i + 20}`, b: "bar" })));
+            const firstPage = yield client.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+                Limit: 30,
+            }, { a: A, b: B });
+            expect(firstPage.a.length).toBe(20);
+            expect(firstPage.b.length).toBe(10);
+            expect(firstPage._unknown.length).toBe(0);
+            expect(firstPage.meta.lastEvaluatedKey).not.toBeUndefined();
+            const secondPage = yield client.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+                Limit: 30,
+                ExclusiveStartKey: firstPage.meta.lastEvaluatedKey,
+            }, { a: A, b: B });
+            expect(secondPage.a.length).toBe(0);
+            expect(secondPage.b.length).toBe(10);
+            expect(secondPage._unknown.length).toBe(0);
+            expect(secondPage.meta.lastEvaluatedKey).toBeUndefined();
+        }));
+        test("it fetches all pages automatically", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(...Array.from({ length: 20 }).map((_, i) => new A({ pk: "abc", sk: `SORT#${String(i).padStart(2, "0")}`, a: i })), ...Array.from({ length: 20 }).map((_, i) => new B({ pk: "abc", sk: `SORT#${i + 20}`, b: "bar" })));
+            const { a, b, meta, _unknown } = yield client.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+                FetchAllPages: true,
+                // You wouldn't set a limit in a real-world use case here to optimize fetching all items.
+                Limit: 10,
+            }, { a: A, b: B });
+            expect(a.length).toBe(20);
+            expect(b.length).toBe(20);
+            expect(_unknown.length).toBe(0);
+            expect(meta.lastEvaluatedKey).toBeUndefined();
+        }));
+    });
+    describe("via model", () => {
+        test("it returns empty results for specific model", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const result = yield A.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT" },
+            });
+            expect(result.length).toBe(0);
+            expect(result.meta).toEqual({ lastEvaluatedKey: undefined });
+        }));
+        test("it returns only matching model items", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "abc", sk: "SORT#1", a: 1 }), new A({ pk: "abc", sk: "SORT#2", a: 2 }), new B({ pk: "abc", sk: "SORT#3", b: "hi" }), { PK: "abc", SK: "SORT#4", probably: "unknown" }, new C({ pk: "abc", sk: "SORT#5", c: "hi" }));
+            const result = yield A.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+            });
+            expect(result.length).toBe(2);
+            expect(result.map((item) => item.values())).toMatchInlineSnapshot(`
+        Array [
+          Object {
+            "a": 1,
+            "pk": "abc",
+            "sk": "SORT#1",
+          },
+          Object {
+            "a": 2,
+            "pk": "abc",
+            "sk": "SORT#2",
+          },
+        ]
+      `);
+            expect(result.meta).toEqual({ lastEvaluatedKey: undefined });
+        }));
+        test("it respects query parameters", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "abc", sk: "SORT#1", a: 1 }), new A({ pk: "abc", sk: "SORT#2", a: 2 }), new A({ pk: "abc", sk: "SORT#3", a: 3 }), new A({ pk: "abc", sk: "SORT#4", a: 4 }));
+            const result = yield A.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+                Limit: 2,
+            });
+            expect(result.length).toBe(2);
+            expect(result[0].a).toBe(1);
+            expect(result[1].a).toBe(2);
+            expect(result.meta.lastEvaluatedKey).toBeDefined();
+        }));
+        test("it fetches all pages when FetchAllPages is true", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(...Array.from({ length: 15 }).map((_, i) => new A({ pk: "abc", sk: `SORT#${String(i).padStart(2, "0")}`, a: i })), 
+            // Add some B items that should be ignored
+            new B({ pk: "abc", sk: "SORT#20", b: "ignored" }), new B({ pk: "abc", sk: "SORT#21", b: "ignored" }));
+            const result = yield A.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+                FetchAllPages: true,
+                Limit: 5, // Force pagination
+            });
+            expect(result.length).toBe(15); // Only A items
+            expect(result.map((item) => item.a)).toEqual(Array.from({ length: 15 }, (_, i) => i));
+            expect(result.meta.lastEvaluatedKey).toBeUndefined();
+        }));
+        test("it works with different query conditions", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "user1", sk: "post#1", a: 1 }), new A({ pk: "user1", sk: "post#2", a: 2 }), new A({ pk: "user1", sk: "comment#1", a: 3 }), new A({ pk: "user2", sk: "post#1", a: 4 }));
+            // Query for posts only
+            const posts = yield A.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "user1", ":sk": "post#" },
+            });
+            expect(posts.length).toBe(2);
+            expect(posts.map((item) => item.a).sort()).toEqual([1, 2]);
+            // Query for all user1 items
+            const allUser1 = yield A.query({
+                KeyConditionExpression: `PK = :pk`,
+                ExpressionAttributeValues: { ":pk": "user1" },
+            });
+            expect(allUser1.length).toBe(3);
+            expect(allUser1.map((item) => item.a).sort()).toEqual([1, 2, 3]);
+        }));
+        test("it works with FilterExpression", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "test", sk: "item#1", a: 1 }), new A({ pk: "test", sk: "item#2", a: 2 }), new A({ pk: "test", sk: "item#3", a: 3 }), new A({ pk: "test", sk: "item#4", a: 4 }));
+            const result = yield A.query({
+                KeyConditionExpression: `PK = :pk`,
+                FilterExpression: `a > :min`,
+                ExpressionAttributeValues: { ":pk": "test", ":min": 2 },
+            });
+            expect(result.length).toBe(2);
+            expect(result.map((item) => item.a).sort()).toEqual([3, 4]);
+        }));
+    });
+    describe("via union", () => {
+        test("it returns empty results for union", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const result = yield Union.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT" },
+            });
+            expect(result.length).toBe(0);
+            expect(result.meta).toEqual({ lastEvaluatedKey: undefined });
+        }));
+        test("it returns only union model items", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "abc", sk: "SORT#1", a: 1 }), new B({ pk: "abc", sk: "SORT#2", b: "hi" }), new C({ pk: "abc", sk: "SORT#3", c: "c1" }), new D({ pk: "abc", sk: "SORT#4", d: "d1" }), { PK: "abc", SK: "SORT#5", unknown: "data" });
+            const result = yield Union.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+            });
+            expect(result.length).toBe(2); // Only C and D items (union members)
+            expect(result[0]).toBeInstanceOf(C);
+            expect(result[1]).toBeInstanceOf(D);
+            expect(result.meta).toEqual({ lastEvaluatedKey: undefined });
+        }));
+        test("it fetches all pages for union when FetchAllPages is true", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(...Array.from({ length: 10 }).map((_, i) => new C({
+                pk: "abc",
+                sk: `SORT#${String(i).padStart(2, "0")}`,
+                c: `c${i}`,
+            })), ...Array.from({ length: 10 }).map((_, i) => new D({
+                pk: "abc",
+                sk: `SORT#${String(i + 10).padStart(2, "0")}`,
+                d: `d${i}`,
+            })), 
+            // Add some non-union items that should be ignored
+            new A({ pk: "abc", sk: "SORT#30", a: 1 }), new B({ pk: "abc", sk: "SORT#31", b: "ignored" }));
+            const result = yield Union.query({
+                KeyConditionExpression: `PK = :pk and begins_with(SK, :sk)`,
+                ExpressionAttributeValues: { ":pk": "abc", ":sk": "SORT#" },
+                FetchAllPages: true,
+                Limit: 5, // Force pagination
+            });
+            expect(result.length).toBe(20); // Only union items (C and D)
+            expect(result.filter((item) => item instanceof C).length).toBe(10);
+            expect(result.filter((item) => item instanceof D).length).toBe(10);
+            expect(result.meta.lastEvaluatedKey).toBeUndefined();
+        }));
+    });
 });
 describe("bulk", () => {
     describe("< 100 elements (true transaction)", () => {
@@ -822,16 +954,16 @@ describe("bulk", () => {
                 new B({
                     pk: "PK#UPDATE",
                     sk: "SK#UPDATE",
-                    b: "bar"
+                    b: "bar",
                 }).operation("update", { b: "baz" }),
                 new B({
                     pk: "PK#COND",
                     sk: "SK#COND",
-                    b: "cond"
+                    b: "cond",
                 }).operation("condition", {
                     ConditionExpression: "b = :cond",
-                    ExpressionAttributeValues: { ":cond": "cond" }
-                })
+                    ExpressionAttributeValues: { ":cond": "cond" },
+                }),
             ]);
             expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
         Snapshot Diff:
@@ -935,7 +1067,7 @@ describe("bulk", () => {
                 A.operation("put", new A({ pk: "PK5", sk: "PK5", a: 5 })),
                 new B({ pk: "PK#6", sk: "SK#6", b: "baz" }).operation("put"),
                 // Fails
-                A.operation("updateRaw", { PK: "PK#nicetry", SK: "SK#nope" }, { a: 234 })
+                A.operation("updateRaw", { PK: "PK#nicetry", SK: "SK#nope" }, { a: 234 }),
             ])).rejects.toBeInstanceOf(errors_1.BulkWriteTransactionError);
             expect(yield sandbox.snapshot()).toEqual(before);
         }));
@@ -954,9 +1086,9 @@ describe("bulk", () => {
                 new B({
                     pk: "PK#UPDATE",
                     sk: "SK#UPDATE",
-                    b: "bar"
+                    b: "bar",
                 }).operation("update", { b: "baz" }),
-                ...Array.from({ length: 100 }).map((_, i) => new A({ pk: `PK#A${i}`, sk: `SK#A${i}`, a: i }).operation("put"))
+                ...Array.from({ length: 100 }).map((_, i) => new A({ pk: `PK#A${i}`, sk: `SK#A${i}`, a: i }).operation("put")),
             ]);
             //#region snapshot
             expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
@@ -1932,7 +2064,7 @@ describe("bulk", () => {
                 // Succeeds
                 ...Array.from({ length: 110 }).map((_, i) => new A({ pk: `PK#${i}`, sk: `SK#${i}`, a: i }).operation("put")),
                 // Fails
-                A.operation("condition", { PK: "nicetry", SK: "nope" }, { ConditionExpression: "attribute_exists(PK)" })
+                A.operation("condition", { PK: "nicetry", SK: "nope" }, { ConditionExpression: "attribute_exists(PK)" }),
             ])).rejects.toBeInstanceOf(errors_1.BulkWriteTransactionError);
             expect(yield sandbox.snapshot()).toEqual(before);
         }));
@@ -1956,7 +2088,7 @@ describe("batchGet", () => {
             two: A.operation("get", { PK: "PK#2", SK: "SK#2" }),
             three: A.operation("get", { PK: "PK#3", SK: "SK#3" }),
             four: A.operation("get", { PK: "PK#4", SK: "SK#4" }),
-            duplicate: A.operation("get", { PK: "PK#1", SK: "SK#1" })
+            duplicate: A.operation("get", { PK: "PK#1", SK: "SK#1" }),
         })).rejects.toBeInstanceOf(errors_1.ItemNotFoundError);
     }));
     test("it returns individual errors", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
@@ -1966,7 +2098,7 @@ describe("batchGet", () => {
             two: A.operation("get", { PK: "PK#2", SK: "SK#2" }),
             duplicate: A.operation("get", { PK: "PK#1", SK: "SK#1" }),
             error: A.operation("get", { PK: "PK#error", SK: "SK#error" }),
-            error2: A.operation("get", { PK: "PK#error2", SK: "SK#error2" })
+            error2: A.operation("get", { PK: "PK#error2", SK: "SK#error2" }),
         }, { individualErrors: true });
         expect(result.one).toBeInstanceOf(A);
         expect(result.two).toBeInstanceOf(A);
@@ -1980,7 +2112,7 @@ describe("batchGet", () => {
             two: A.operation("get", { PK: "PK#2", SK: "SK#2" }),
             three: A.operation("get", { PK: "PK#3", SK: "SK#3" }),
             four: A.operation("get", { PK: "PK#4", SK: "SK#4" }),
-            duplicate: A.operation("get", { PK: "PK#1", SK: "SK#1" })
+            duplicate: A.operation("get", { PK: "PK#1", SK: "SK#1" }),
         });
         expect(Object.fromEntries(Object.entries(results).map(([key, val]) => [key, val.values()]))).toMatchInlineSnapshot(`
       Object {
@@ -2026,20 +2158,20 @@ describe("load", () => {
             yield sandbox.seed(item);
             yield item.softDelete();
             const recovered = yield client.load(A.operation("get", { PK: "PK#1", SK: "SK#1" }), {
-                recover: true
+                recover: true,
             });
             expect(recovered).toBeInstanceOf(A);
             expect(recovered.isDeleted).toBe(true);
         }));
         test("it throws if no item or soft deleted item exists", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             yield expect(client.load(A.operation("get", { PK: "PK", SK: "SK" }), {
-                recover: true
+                recover: true,
             })).rejects.toBeInstanceOf(errors_1.ItemNotFoundError);
         }));
         test("it returns null instead of throwing if no item or soft deleted item exists", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             yield expect(client.load(A.operation("get", { PK: "PK", SK: "SK" }), {
                 recover: true,
-                null: true
+                null: true,
             })).resolves.toBeNull();
         }));
         test("it fetches >100 items", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
@@ -2090,8 +2222,8 @@ describe("load", () => {
             yield sandbox.seed(...items);
             const results = yield Promise.all(items.map(({ PK, SK }, i) => Union.load({ PK, SK })));
             expect(results.length).toBe(234);
-            expect(results.filter(item => item instanceof C).length).toBe(123);
-            expect(results.filter(item => item instanceof D).length).toBe(111);
+            expect(results.filter((item) => item instanceof C).length).toBe(123);
+            expect(results.filter((item) => item instanceof D).length).toBe(111);
             expect(spy).toHaveBeenCalledTimes(3);
             spy.mockReset();
             spy.mockRestore();
@@ -2136,8 +2268,8 @@ describe("loadMany", () => {
             yield sandbox.seed(...items);
             const results = yield Union.loadMany(items.map(({ PK, SK }) => ({ PK, SK })));
             expect(results.length).toBe(234);
-            expect(results.filter(item => item instanceof C).length).toBe(123);
-            expect(results.filter(item => item instanceof D).length).toBe(111);
+            expect(results.filter((item) => item instanceof C).length).toBe(123);
+            expect(results.filter((item) => item instanceof D).length).toBe(111);
             expect(spy).toHaveBeenCalledTimes(3);
             spy.mockReset();
             spy.mockRestore();
@@ -2152,7 +2284,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield client.paginate(C, {}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2167,7 +2299,7 @@ describe("paginate", () => {
             expect(page1.edges[19].node.c).toBe("19");
             const page2 = yield client.paginate(C, { after: page1.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2182,7 +2314,7 @@ describe("paginate", () => {
             expect(page2.edges[19].node.c).toBe("39");
             const page3 = yield client.paginate(C, { after: page2.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page3.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2198,7 +2330,7 @@ describe("paginate", () => {
             // Backwards
             const backwardsPage2 = yield client.paginate(C, { before: page3.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2213,7 +2345,7 @@ describe("paginate", () => {
             expect(backwardsPage2.edges[19].node.c).toBe("39");
             const backwardsPage1 = yield client.paginate(C, { before: backwardsPage2.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2235,7 +2367,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield client.paginate(Union, {}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2250,7 +2382,7 @@ describe("paginate", () => {
             expect(page1.edges[19].node.SK).toBe("019");
             const page2 = yield client.paginate(Union, { after: page1.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2265,7 +2397,7 @@ describe("paginate", () => {
             expect(page2.edges[19].node.SK).toBe("039");
             const page3 = yield client.paginate(Union, { after: page2.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page3.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2281,7 +2413,7 @@ describe("paginate", () => {
             // Backwards
             const backwardsPage2 = yield client.paginate(Union, { before: page3.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2296,7 +2428,7 @@ describe("paginate", () => {
             expect(backwardsPage2.edges[19].node.SK).toBe("039");
             const backwardsPage1 = yield client.paginate(Union, { before: backwardsPage2.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2316,7 +2448,7 @@ describe("paginate", () => {
             // Forwards
             const page = yield client.paginate(C, { first: 10 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2336,7 +2468,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield client.paginate(C, { first: 60 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2352,26 +2484,26 @@ describe("paginate", () => {
         }));
         test("it respects custom pagination default", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             client.paginationOptions = {
-                default: 40
+                default: 40,
             };
             const items = Array.from({ length: 50 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
             yield sandbox.seed(...items);
             const page = yield client.paginate(C, {}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.edges.length).toBe(40);
             delete client.paginationOptions;
         }));
         test("it respects custom pagination limit", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             client.paginationOptions = {
-                limit: 100
+                limit: 100,
             };
             const items = Array.from({ length: 120 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
             yield sandbox.seed(...items);
             const page = yield client.paginate(C, { first: 110 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.edges.length).toBe(100);
             delete client.paginationOptions;
@@ -2384,7 +2516,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield C.paginate({}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2399,7 +2531,7 @@ describe("paginate", () => {
             expect(page1.edges[19].node.c).toBe("19");
             const page2 = yield C.paginate({ after: page1.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2414,7 +2546,7 @@ describe("paginate", () => {
             expect(page2.edges[19].node.c).toBe("39");
             const page3 = yield C.paginate({ after: page2.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page3.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2430,7 +2562,7 @@ describe("paginate", () => {
             // Backwards
             const backwardsPage2 = yield C.paginate({ before: page3.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2445,7 +2577,7 @@ describe("paginate", () => {
             expect(backwardsPage2.edges[19].node.c).toBe("39");
             const backwardsPage1 = yield C.paginate({ before: backwardsPage2.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2465,7 +2597,7 @@ describe("paginate", () => {
             // Forwards
             const page = yield C.paginate({ first: 10 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2485,7 +2617,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield C.paginate({ first: 60 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2501,26 +2633,26 @@ describe("paginate", () => {
         }));
         test("it respects custom pagination default", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             client.paginationOptions = {
-                default: 40
+                default: 40,
             };
             const items = Array.from({ length: 50 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
             yield sandbox.seed(...items);
             const page = yield C.paginate({}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.edges.length).toBe(40);
             delete client.paginationOptions;
         }));
         test("it respects custom pagination limit", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             client.paginationOptions = {
-                limit: 100
+                limit: 100,
             };
             const items = Array.from({ length: 120 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
             yield sandbox.seed(...items);
             const page = yield C.paginate({ first: 110 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.edges.length).toBe(100);
             delete client.paginationOptions;
@@ -2535,7 +2667,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield Union.paginate({}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2550,7 +2682,7 @@ describe("paginate", () => {
             expect(page1.edges[19].node.SK).toBe("019");
             const page2 = yield Union.paginate({ after: page1.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2565,7 +2697,7 @@ describe("paginate", () => {
             expect(page2.edges[19].node.SK).toBe("039");
             const page3 = yield Union.paginate({ after: page2.pageInfo.endCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page3.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2581,7 +2713,7 @@ describe("paginate", () => {
             // Backwards
             const backwardsPage2 = yield Union.paginate({ before: page3.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2596,7 +2728,7 @@ describe("paginate", () => {
             expect(backwardsPage2.edges[19].node.SK).toBe("039");
             const backwardsPage1 = yield Union.paginate({ before: backwardsPage2.pageInfo.startCursor }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2618,7 +2750,7 @@ describe("paginate", () => {
             // Forwards
             const page = yield Union.paginate({ first: 10 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2640,7 +2772,7 @@ describe("paginate", () => {
             // Forwards
             const page1 = yield Union.paginate({ first: 60 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page1.pageInfo).toMatchInlineSnapshot(`
         Object {
@@ -2656,46 +2788,46 @@ describe("paginate", () => {
         }));
         test("it respects custom pagination default", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             client.paginationOptions = {
-                default: 40
+                default: 40,
             };
             const items = Array.from({ length: 50 }).map((_, i) => i > 30
                 ? new C({
                     pk: "PK",
                     sk: String(i).padStart(3, "0"),
-                    c: String(i)
+                    c: String(i),
                 })
                 : new D({
                     pk: "PK",
                     sk: String(i).padStart(3, "0"),
-                    d: String(i)
+                    d: String(i),
                 }));
             yield sandbox.seed(...items);
             const page = yield Union.paginate({}, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.edges.length).toBe(40);
             delete client.paginationOptions;
         }));
         test("it respects custom pagination limit", () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
             client.paginationOptions = {
-                limit: 100
+                limit: 100,
             };
             const items = Array.from({ length: 110 }).map((_, i) => i > 30
                 ? new C({
                     pk: "PK",
                     sk: String(i).padStart(3, "0"),
-                    c: String(i)
+                    c: String(i),
                 })
                 : new D({
                     pk: "PK",
                     sk: String(i).padStart(3, "0"),
-                    d: String(i)
+                    d: String(i),
                 }));
             yield sandbox.seed(...items);
             const page = yield Union.paginate({ first: 110 }, {
                 KeyConditionExpression: "PK = :pk",
-                ExpressionAttributeValues: { ":pk": "PK" }
+                ExpressionAttributeValues: { ":pk": "PK" },
             });
             expect(page.edges.length).toBe(100);
             delete client.paginationOptions;