@model-ts/dynamodb 1.0.0 → 1.2.0

package/dist/esm/__test__/client-with-cursor-encryption.test.js

@@ -0,0 +1,1909 @@
+import { __awaiter } from "tslib";
+import * as t from "io-ts";
+import { model, RuntimeTypeValidationError, union } from "@model-ts/core";
+import { createSandbox } from "../sandbox";
+import { Client } from "../client";
+import { getProvider } from "../provider";
+import { KeyExistsError, ItemNotFoundError, ConditionalCheckFailedError, RaceConditionError, BulkWriteTransactionError } from "../errors";
+const client = new Client({
+    tableName: "table",
+    cursorEncryptionKey: Buffer.from("0tpsnnd7+k7xD5pMxK9TXAEkB6c/GYkkW3HEy7ZKBOs=", "base64")
+});
+const provider = getProvider(client);
+const SIMPLE_CODEC = t.type({
+    foo: t.string,
+    bar: t.number
+});
+class Simple extends model("Simple", SIMPLE_CODEC, provider) {
+    get PK() {
+        return `PK#${this.foo}`;
+    }
+    get SK() {
+        return `SK#${this.bar}`;
+    }
+}
+class SingleGSI extends model("SingleGSI", SIMPLE_CODEC, provider) {
+    get PK() {
+        return `PK#${this.foo}`;
+    }
+    get SK() {
+        return `SK#${this.bar}`;
+    }
+    get GSI2PK() {
+        return `GSI2PK#${this.foo}${this.foo}`;
+    }
+    get GSI2SK() {
+        return `GSI2SK#FIXED`;
+    }
+}
+class MultiGSI extends model("MultiGSI", SIMPLE_CODEC, provider) {
+    get PK() {
+        return `PK#${this.foo}`;
+    }
+    get SK() {
+        return `SK#${this.bar}`;
+    }
+    get GSI2PK() {
+        return `GSI2PK#${this.foo}${this.foo}`;
+    }
+    get GSI2SK() {
+        return `GSI2SK#FIXED`;
+    }
+    get GSI3PK() {
+        return `GSI3PK#FIXED`;
+    }
+    get GSI3SK() {
+        return `GSI3SK#${this.bar}${this.bar}`;
+    }
+    get GSI4PK() {
+        return `GSI4PK#FIXED`;
+    }
+    get GSI4SK() {
+        return `GSI4SK#${this.bar}${this.bar}`;
+    }
+    get GSI5PK() {
+        return `GSI5PK#FIXED`;
+    }
+    get GSI5SK() {
+        return `GSI5SK#${this.bar}${this.bar}`;
+    }
+}
+class A extends model("A", t.type({ pk: t.string, sk: t.string, a: t.number }), provider) {
+    get PK() {
+        return this.pk;
+    }
+    get SK() {
+        return this.sk;
+    }
+}
+class B extends model("B", t.type({ pk: t.string, sk: t.string, b: t.string }), provider) {
+    get PK() {
+        return this.pk;
+    }
+    get SK() {
+        return this.sk;
+    }
+}
+class C extends model("C", t.type({ pk: t.string, sk: t.string, c: t.string }), provider) {
+    get PK() {
+        return this.pk;
+    }
+    get SK() {
+        return this.sk;
+    }
+}
+class D extends model("D", t.type({ pk: t.string, sk: t.string, d: t.string }), provider) {
+    get PK() {
+        return this.pk;
+    }
+    get SK() {
+        return this.sk;
+    }
+}
+class Union extends union([C, D], provider) {
+}
+let sandbox;
+beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+    sandbox = yield createSandbox(client);
+}));
+describe("put", () => {
+    describe("via instance", () => {
+        test("it inserts a simple model", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield new Simple({ foo: "hi", bar: 42 }).put();
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {}
+        + Object {
+        +   "PK#hi__SK#42": Object {
+        +     "PK": "PK#hi",
+        +     "SK": "SK#42",
+        +     "_docVersion": 0,
+        +     "_tag": "Simple",
+        +     "bar": 42,
+        +     "foo": "hi",
+        +   },
+        + }
+      `);
+        }));
+        test("it inserts a model with single gsi", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield new SingleGSI({ foo: "yes", bar: 42 }).put();
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {}
+        + Object {
+        +   "PK#yes__SK#42": Object {
+        +     "GSI2PK": "GSI2PK#yesyes",
+        +     "GSI2SK": "GSI2SK#FIXED",
+        +     "PK": "PK#yes",
+        +     "SK": "SK#42",
+        +     "_docVersion": 0,
+        +     "_tag": "SingleGSI",
+        +     "bar": 42,
+        +     "foo": "yes",
+        +   },
+        + }
+      `);
+        }));
+        test("it inserts a model with multiple gsi", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield new MultiGSI({ foo: "yes", bar: 42 }).put();
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {}
+        + Object {
+        +   "PK#yes__SK#42": Object {
+        +     "GSI2PK": "GSI2PK#yesyes",
+        +     "GSI2SK": "GSI2SK#FIXED",
+        +     "GSI3PK": "GSI3PK#FIXED",
+        +     "GSI3SK": "GSI3SK#4242",
+        +     "GSI4PK": "GSI4PK#FIXED",
+        +     "GSI4SK": "GSI4SK#4242",
+        +     "GSI5PK": "GSI5PK#FIXED",
+        +     "GSI5SK": "GSI5SK#4242",
+        +     "PK": "PK#yes",
+        +     "SK": "SK#42",
+        +     "_docVersion": 0,
+        +     "_tag": "MultiGSI",
+        +     "bar": 42,
+        +     "foo": "yes",
+        +   },
+        + }
+      `);
+        }));
+        test("it throws KeyExistsError if item exists", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield new MultiGSI({ foo: "yes", bar: 42 }).put();
+            yield expect(new MultiGSI({ foo: "yes", bar: 42 }).put()).rejects.toBeInstanceOf(KeyExistsError);
+        }));
+        test("it overwrites item if `ignoreExistence` is set", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield new MultiGSI({ foo: "yes", bar: 42 }).put();
+            yield expect(new MultiGSI({ foo: "yes", bar: 42 }).put({ IgnoreExistence: true })).resolves.toBeInstanceOf(MultiGSI);
+        }));
+    });
+    describe("via model", () => {
+        test("it inserts a simple model", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield Simple.put(new Simple({ foo: "hi", bar: 42 }));
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {}
+        + Object {
+        +   "PK#hi__SK#42": Object {
+        +     "PK": "PK#hi",
+        +     "SK": "SK#42",
+        +     "_docVersion": 0,
+        +     "_tag": "Simple",
+        +     "bar": 42,
+        +     "foo": "hi",
+        +   },
+        + }
+      `);
+        }));
+        test("it inserts a model with single gsi", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield SingleGSI.put(new SingleGSI({ foo: "yes", bar: 42 }));
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {}
+        + Object {
+        +   "PK#yes__SK#42": Object {
+        +     "GSI2PK": "GSI2PK#yesyes",
+        +     "GSI2SK": "GSI2SK#FIXED",
+        +     "PK": "PK#yes",
+        +     "SK": "SK#42",
+        +     "_docVersion": 0,
+        +     "_tag": "SingleGSI",
+        +     "bar": 42,
+        +     "foo": "yes",
+        +   },
+        + }
+      `);
+        }));
+        test("it inserts a model with multiple gsi", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield MultiGSI.put(new MultiGSI({ foo: "yes", bar: 42 }));
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {}
+        + Object {
+        +   "PK#yes__SK#42": Object {
+        +     "GSI2PK": "GSI2PK#yesyes",
+        +     "GSI2SK": "GSI2SK#FIXED",
+        +     "GSI3PK": "GSI3PK#FIXED",
+        +     "GSI3SK": "GSI3SK#4242",
+        +     "GSI4PK": "GSI4PK#FIXED",
+        +     "GSI4SK": "GSI4SK#4242",
+        +     "GSI5PK": "GSI5PK#FIXED",
+        +     "GSI5SK": "GSI5SK#4242",
+        +     "PK": "PK#yes",
+        +     "SK": "SK#42",
+        +     "_docVersion": 0,
+        +     "_tag": "MultiGSI",
+        +     "bar": 42,
+        +     "foo": "yes",
+        +   },
+        + }
+      `);
+        }));
+        test("it throws KeyExistsError if item exists", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield MultiGSI.put(new MultiGSI({ foo: "yes", bar: 42 }));
+            yield expect(new MultiGSI({ foo: "yes", bar: 42 }).put()).rejects.toBeInstanceOf(KeyExistsError);
+        }));
+        test("it overwrites item if `ignoreExistence` is set", () => __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
+            })).resolves.toBeInstanceOf(MultiGSI);
+        }));
+    });
+});
+describe("get", () => {
+    describe("via model", () => {
+        test("it throws `ItemNotFoundError` if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(Simple.get({ PK: "any", SK: "thing" })).rejects.toBeInstanceOf(ItemNotFoundError);
+        }));
+        test("it returns the item", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const result = yield Simple.get({
+                PK: item.keys().PK,
+                SK: item.keys().SK
+            });
+            expect(result.values()).toMatchInlineSnapshot(`
+              Object {
+                "bar": 432,
+                "foo": "hi",
+              }
+          `);
+            expect(result.encode()).toEqual(item.encode());
+        }));
+        test("it throws `RuntimeTypeError` if item can't be decoded", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed({ PK: "A", SK: "A", c: 324 });
+            yield expect(Simple.get({ PK: "A", SK: "A" })).rejects.toBeInstanceOf(RuntimeTypeValidationError);
+        }));
+    });
+    describe("via union", () => {
+        test("it throws `ItemNotFoundError` if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(Union.get({ PK: "any", SK: "thing" })).rejects.toBeInstanceOf(ItemNotFoundError);
+        }));
+        test("it returns the item", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new C({ pk: "PK#0", sk: "SK#0", c: "0" }).put();
+            const result = yield Union.get(item.keys());
+            expect(result).toBeInstanceOf(C);
+            expect(result.values()).toMatchInlineSnapshot(`
+        Object {
+          "c": "0",
+          "pk": "PK#0",
+          "sk": "SK#0",
+        }
+      `);
+        }));
+        test("it throws `RuntimeTypeError` if item can't be decoded", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed({ PK: "A", SK: "A", a: 324 });
+            yield expect(Union.get({ PK: "A", SK: "A" })).rejects.toBeInstanceOf(RuntimeTypeValidationError);
+        }));
+    });
+});
+describe("delete", () => {
+    describe("via client", () => {
+        test("it deletes the item and returns null", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const before = yield sandbox.snapshot();
+            const result = yield client.delete({
+                _operation: "delete",
+                _model: Simple,
+                key: {
+                    PK: item.keys().PK,
+                    SK: item.keys().SK
+                }
+            });
+            expect(result).toBeNull();
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {
+        -   "PK#hi__SK#432": Object {
+        -     "PK": "PK#hi",
+        -     "SK": "SK#432",
+        -     "_docVersion": 0,
+        -     "_tag": "Simple",
+        -     "bar": 432,
+        -     "foo": "hi",
+        -   },
+        - }
+        + Object {}
+      `);
+        }));
+    });
+    describe("via model", () => {
+        test("it deletes the item and returns null", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const before = yield sandbox.snapshot();
+            const result = yield Simple.delete({
+                PK: item.keys().PK,
+                SK: item.keys().SK
+            });
+            expect(result).toBeNull();
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {
+        -   "PK#hi__SK#432": Object {
+        -     "PK": "PK#hi",
+        -     "SK": "SK#432",
+        -     "_docVersion": 0,
+        -     "_tag": "Simple",
+        -     "bar": 432,
+        -     "foo": "hi",
+        -   },
+        - }
+        + Object {}
+      `);
+        }));
+    });
+    describe("via instance", () => {
+        test("it deletes the item and returns null", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const before = yield sandbox.snapshot();
+            const result = yield item.delete();
+            expect(result).toBeNull();
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        - Object {
+        -   "PK#hi__SK#432": Object {
+        -     "PK": "PK#hi",
+        -     "SK": "SK#432",
+        -     "_docVersion": 0,
+        -     "_tag": "Simple",
+        -     "bar": 432,
+        -     "foo": "hi",
+        -   },
+        - }
+        + Object {}
+      `);
+        }));
+    });
+});
+describe("softDelete", () => {
+    describe("via client", () => {
+        test("it soft-deletes the item", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const withGSI = yield new MultiGSI({ foo: "hello", bar: 42 }).put();
+            const before = yield sandbox.snapshot();
+            const simpleResult = yield client.softDelete(item);
+            const withGSIResult = yield client.softDelete(withGSI);
+            expect(simpleResult.values()).toMatchInlineSnapshot(`
+        Object {
+          "bar": 432,
+          "foo": "hi",
+        }
+      `);
+            expect(withGSIResult.values()).toMatchInlineSnapshot(`
+        Object {
+          "bar": 42,
+          "foo": "hello",
+        }
+      `);
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        @@ -1,25 +1,27 @@
+          Object {
+        -   "PK#hello__SK#42": Object {
+        -     "GSI2PK": "GSI2PK#hellohello",
+        -     "GSI2SK": "GSI2SK#FIXED",
+        -     "GSI3PK": "GSI3PK#FIXED",
+        -     "GSI3SK": "GSI3SK#4242",
+        -     "GSI4PK": "GSI4PK#FIXED",
+        -     "GSI4SK": "GSI4SK#4242",
+        -     "GSI5PK": "GSI5PK#FIXED",
+        -     "GSI5SK": "GSI5SK#4242",
+        -     "PK": "PK#hello",
+        -     "SK": "SK#42",
+        +   "$$DELETED$$PK#hello__$$DELETED$$SK#42": Object {
+        +     "GSI2PK": "$$DELETED$$GSI2PK#hellohello",
+        +     "GSI2SK": "$$DELETED$$GSI2SK#FIXED",
+        +     "GSI3PK": "$$DELETED$$GSI3PK#FIXED",
+        +     "GSI3SK": "$$DELETED$$GSI3SK#4242",
+        +     "GSI4PK": "$$DELETED$$GSI4PK#FIXED",
+        +     "GSI4SK": "$$DELETED$$GSI4SK#4242",
+        +     "GSI5PK": "$$DELETED$$GSI5PK#FIXED",
+        +     "GSI5SK": "$$DELETED$$GSI5SK#4242",
+        +     "PK": "$$DELETED$$PK#hello",
+        +     "SK": "$$DELETED$$SK#42",
+        +     "_deletedAt": "2021-05-01T08:00:00.000Z",
+              "_docVersion": 0,
+              "_tag": "MultiGSI",
+              "bar": 42,
+              "foo": "hello",
+            },
+        -   "PK#hi__SK#432": Object {
+        -     "PK": "PK#hi",
+        -     "SK": "SK#432",
+        +   "$$DELETED$$PK#hi__$$DELETED$$SK#432": Object {
+        +     "PK": "$$DELETED$$PK#hi",
+        +     "SK": "$$DELETED$$SK#432",
+        +     "_deletedAt": "2021-05-01T08:00:00.000Z",
+              "_docVersion": 0,
+              "_tag": "Simple",
+              "bar": 432,
+              "foo": "hi",
+            },
+      `);
+        }));
+    });
+    describe("via model", () => {
+        test("it soft-deletes the item", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const before = yield sandbox.snapshot();
+            const result = yield Simple.softDelete(item);
+            expect(result.values()).toMatchInlineSnapshot(`
+        Object {
+          "bar": 432,
+          "foo": "hi",
+        }
+      `);
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        @@ -1,9 +1,10 @@
+          Object {
+        -   "PK#hi__SK#432": Object {
+        -     "PK": "PK#hi",
+        -     "SK": "SK#432",
+        +   "$$DELETED$$PK#hi__$$DELETED$$SK#432": Object {
+        +     "PK": "$$DELETED$$PK#hi",
+        +     "SK": "$$DELETED$$SK#432",
+        +     "_deletedAt": "2021-05-01T08:00:00.000Z",
+              "_docVersion": 0,
+              "_tag": "Simple",
+              "bar": 432,
+              "foo": "hi",
+            },
+      `);
+        }));
+    });
+    describe("via instance", () => {
+        test("it soft-deletes the item", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new Simple({ foo: "hi", bar: 432 }).put();
+            const before = yield sandbox.snapshot();
+            const result = yield item.softDelete();
+            expect(result.values()).toMatchInlineSnapshot(`
+        Object {
+          "bar": 432,
+          "foo": "hi",
+        }
+      `);
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        @@ -1,9 +1,10 @@
+          Object {
+        -   "PK#hi__SK#432": Object {
+        -     "PK": "PK#hi",
+        -     "SK": "SK#432",
+        +   "$$DELETED$$PK#hi__$$DELETED$$SK#432": Object {
+        +     "PK": "$$DELETED$$PK#hi",
+        +     "SK": "$$DELETED$$SK#432",
+        +     "_deletedAt": "2021-05-01T08:00:00.000Z",
+              "_docVersion": 0,
+              "_tag": "Simple",
+              "bar": 432,
+              "foo": "hi",
+            },
+      `);
+        }));
+    });
+});
+describe("updateRaw", () => {
+    test("it throws `ItemNotFoundError` if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(Simple.updateRaw({ PK: "not", SK: "existent" }, { foo: "new foo" })).rejects.toBeInstanceOf(ItemNotFoundError);
+    }));
+    test("it throws `ConditionalCheckFailedError` if custom condition expression fails", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(Simple.updateRaw({ PK: "not", SK: "existent" }, { foo: "new foo" }, { ConditionExpression: "PK = somethingelse" })).rejects.toBeInstanceOf(ConditionalCheckFailedError);
+    }));
+    test("IT DOES NOT UPDATE KEYS AUTOMATICALLY", () => __awaiter(void 0, void 0, void 0, function* () {
+        const item = yield new Simple({ foo: "old", bar: 43 }).put();
+        const result = yield Simple.updateRaw({ PK: item.PK, SK: item.SK }, { foo: "new foo" });
+        // NOTE: although the result of updateRaw seems to hold the correct keys, it's important to note
+        // that it is not reflected in the DB!
+        expect(result.PK).toEqual(`PK#new foo`);
+        expect(yield sandbox.snapshot()).toMatchInlineSnapshot(`
+      Object {
+        "PK#old__SK#43": Object {
+          "PK": "PK#old",
+          "SK": "SK#43",
+          "_docVersion": 0,
+          "_tag": "Simple",
+          "bar": 43,
+          "foo": "new foo",
+        },
+      }
+    `);
+    }));
+});
+describe("update", () => {
+    describe("in-place", () => {
+        class InPlace extends model("InPlace", t.type({ foo: t.string, bar: t.number }), provider) {
+            get PK() {
+                return "FIXEDPK";
+            }
+            get SK() {
+                return "FIXEDSK";
+            }
+        }
+        test("it puts the item if it wasn't stored before", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = new InPlace({ foo: "hello", bar: 1 });
+            yield item.update({ foo: "ciao" });
+            expect(yield sandbox.snapshot()).toMatchInlineSnapshot(`
+        Object {
+          "FIXEDPK__FIXEDSK": Object {
+            "PK": "FIXEDPK",
+            "SK": "FIXEDSK",
+            "_docVersion": 1,
+            "_tag": "InPlace",
+            "bar": 1,
+            "foo": "ciao",
+          },
+        }
+      `);
+        }));
+        test("it throws `RaceConditionError` if item was manipulated inbetween", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new InPlace({ foo: "hello", bar: 1 }).put();
+            yield item.update({ foo: "ciao" });
+            yield expect(item.update({ foo: "good luck" })).rejects.toBeInstanceOf(RaceConditionError);
+        }));
+        test("it updates an item in-place", () => __awaiter(void 0, void 0, void 0, function* () {
+            const item = yield new InPlace({ foo: "hello", bar: 1 }).put();
+            const before = yield sandbox.snapshot();
+            expect((yield item.update({ foo: "ciao" })).values())
+                .toMatchInlineSnapshot(`
+        Object {
+          "bar": 1,
+          "foo": "ciao",
+        }
+      `);
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+          Object {
+            "FIXEDPK__FIXEDSK": Object {
+              "PK": "FIXEDPK",
+              "SK": "FIXEDSK",
+        -     "_docVersion": 0,
+        +     "_docVersion": 1,
+              "_tag": "InPlace",
+              "bar": 1,
+        -     "foo": "hello",
+        +     "foo": "ciao",
+            },
+          }
+      `);
+        }));
+    });
+});
+describe("applyUpdate", () => {
+    test("it returns the updated item and update operation", () => __awaiter(void 0, void 0, void 0, function* () {
+        const item = yield new A({ pk: "PK", sk: "SK", a: 1 }).put();
+        const before = yield sandbox.snapshot();
+        const [updatedItem, updateOp] = item.applyUpdate({ a: 2 });
+        expect(updatedItem.values()).toMatchInlineSnapshot(`
+      Object {
+        "a": 2,
+        "pk": "PK",
+        "sk": "SK",
+      }
+    `);
+        yield client.bulk([updateOp]);
+        expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+      Snapshot Diff:
+      - First value
+      + Second value
+
+        Object {
+          "PK__SK": Object {
+            "PK": "PK",
+            "SK": "SK",
+      -     "_docVersion": 0,
+      +     "_docVersion": 1,
+            "_tag": "A",
+      -     "a": 1,
+      +     "a": 2,
+            "pk": "PK",
+            "sk": "SK",
+          },
+        }
+    `);
+    }));
+});
+describe("query", () => {
+    test("it returns empty results", () => __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 [],
+        "b": Array [],
+        "meta": Object {
+          "lastEvaluatedKey": undefined,
+        },
+        "union": Array [],
+      }
+    `);
+    }));
+    test("it returns unknown results", () => __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 {
+            "PK": "abc",
+            "SK": "SORT#1",
+            "doesnt": "match",
+          },
+        ],
+        "a": Array [],
+        "b": Array [],
+        "meta": Object {
+          "lastEvaluatedKey": undefined,
+        },
+        "union": Array [],
+      }
+    `);
+    }));
+    test("it returns results", () => __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 {
+            "PK": "abc",
+            "SK": "SORT#4",
+            "probably": "unknown",
+          },
+        ],
+        "a": Array [
+          Object {
+            "a": 1,
+            "pk": "abc",
+            "sk": "SORT#1",
+          },
+          Object {
+            "a": 2,
+            "pk": "abc",
+            "sk": "SORT#2",
+          },
+        ],
+        "b": Array [
+          Object {
+            "b": "hi",
+            "pk": "abc",
+            "sk": "SORT#3",
+          },
+        ],
+        "meta": Object {
+          "lastEvaluatedKey": undefined,
+        },
+        "union": Array [
+          Object {
+            "c": "hi",
+            "pk": "abc",
+            "sk": "SORT#5",
+          },
+          Object {
+            "d": "hi",
+            "pk": "abc",
+            "sk": "SORT#6",
+          },
+        ],
+      }
+    `);
+    }));
+    test("it paginates", () => __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", () => __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("bulk", () => {
+    describe("< 25 elements (true transaction)", () => {
+        test("it succeeds", () => __awaiter(void 0, void 0, void 0, function* () {
+            const softDeleteTarget = new B({ pk: "PK#3", sk: "SK#3", b: "bar" });
+            yield sandbox.seed(new A({ pk: "PK#1", sk: "SK#1", a: 1 }), new A({ pk: "PK#2", sk: "SK#2", a: 2 }), softDeleteTarget, new B({ pk: "PK#UPDATE", sk: "SK#UPDATE", b: "bar" }), new B({ pk: "PK#COND", sk: "SK#COND", b: "cond" }));
+            const before = yield sandbox.snapshot();
+            yield client.bulk([
+                new A({ pk: "PK4", sk: "PK4", a: 4 }).operation("put"),
+                A.operation("put", new A({ pk: "PK5", sk: "PK5", a: 5 })),
+                new B({ pk: "PK6", sk: "SK6", b: "baz" }).operation("put"),
+                A.operation("updateRaw", { PK: "PK#1", SK: "SK#1" }, { a: -1 }),
+                new A({ pk: "PK#2", sk: "SK#2", a: 2 }).operation("delete"),
+                B.operation("softDelete", softDeleteTarget),
+                new B({
+                    pk: "PK#UPDATE",
+                    sk: "SK#UPDATE",
+                    b: "bar"
+                }).operation("update", { b: "baz" }),
+                new B({
+                    pk: "PK#COND",
+                    sk: "SK#COND",
+                    b: "cond"
+                }).operation("condition", {
+                    ConditionExpression: "b = :cond",
+                    ExpressionAttributeValues: { ":cond": "cond" }
+                })
+            ]);
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        @@ -1,32 +1,24 @@
+          Object {
+        +   "$$DELETED$$PK#3__$$DELETED$$SK#3": Object {
+        +     "PK": "$$DELETED$$PK#3",
+        +     "SK": "$$DELETED$$SK#3",
+        +     "_deletedAt": "2021-05-01T08:00:00.000Z",
+        +     "_docVersion": 0,
+        +     "_tag": "B",
+        +     "b": "bar",
+        +     "pk": "PK#3",
+        +     "sk": "SK#3",
+        +   },
+            "PK#1__SK#1": Object {
+              "PK": "PK#1",
+              "SK": "SK#1",
+              "_docVersion": 0,
+              "_tag": "A",
+        -     "a": 1,
+        +     "a": -1,
+              "pk": "PK#1",
+              "sk": "SK#1",
+        -   },
+        -   "PK#2__SK#2": Object {
+        -     "PK": "PK#2",
+        -     "SK": "SK#2",
+        -     "_docVersion": 0,
+        -     "_tag": "A",
+        -     "a": 2,
+        -     "pk": "PK#2",
+        -     "sk": "SK#2",
+        -   },
+        -   "PK#3__SK#3": Object {
+        -     "PK": "PK#3",
+        -     "SK": "SK#3",
+        -     "_docVersion": 0,
+        -     "_tag": "B",
+        -     "b": "bar",
+        -     "pk": "PK#3",
+        -     "sk": "SK#3",
+            },
+            "PK#COND__SK#COND": Object {
+              "PK": "PK#COND",
+              "SK": "SK#COND",
+              "_docVersion": 0,
+        @@ -36,12 +28,39 @@
+              "sk": "SK#COND",
+            },
+            "PK#UPDATE__SK#UPDATE": Object {
+              "PK": "PK#UPDATE",
+              "SK": "SK#UPDATE",
+        -     "_docVersion": 0,
+        +     "_docVersion": 1,
+              "_tag": "B",
+        -     "b": "bar",
+        +     "b": "baz",
+              "pk": "PK#UPDATE",
+              "sk": "SK#UPDATE",
+        +   },
+        +   "PK4__PK4": Object {
+        +     "PK": "PK4",
+        +     "SK": "PK4",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 4,
+        +     "pk": "PK4",
+        +     "sk": "PK4",
+        +   },
+        +   "PK5__PK5": Object {
+        +     "PK": "PK5",
+        +     "SK": "PK5",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 5,
+        +     "pk": "PK5",
+        +     "sk": "PK5",
+        +   },
+        +   "PK6__SK6": Object {
+        +     "PK": "PK6",
+        +     "SK": "SK6",
+        +     "_docVersion": 0,
+        +     "_tag": "B",
+        +     "b": "baz",
+        +     "pk": "PK6",
+        +     "sk": "SK6",
+            },
+          }
+      `);
+        }));
+        test("it fails", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "PK#1", sk: "SK#1", a: 1 }), new A({ pk: "PK#2", sk: "SK#2", a: 2 }), new B({ pk: "PK#3", sk: "SK#3", b: "bar" }), new B({ pk: "PK#UPDATE", sk: "SK#UPDATE", b: "bar" }), new B({ pk: "PK#COND", sk: "SK#COND", b: "cond" }));
+            const before = yield sandbox.snapshot();
+            yield expect(client.bulk([
+                // Succeed
+                new A({ pk: "PK#4", sk: "PK#4", a: 4 }).operation("put"),
+                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 })
+            ])).rejects.toBeInstanceOf(BulkWriteTransactionError);
+            expect(yield sandbox.snapshot()).toEqual(before);
+        }));
+    });
+    describe("> 25 items (pseudo transaction)", () => {
+        test("it succeeds", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield sandbox.seed(new A({ pk: "PK#1", sk: "SK#1", a: 1 }), new A({ pk: "PK#2", sk: "SK#2", a: 2 }), new B({ pk: "PK#3", sk: "SK#3", b: "bar" }));
+            const before = yield sandbox.snapshot();
+            yield client.bulk([
+                new A({ pk: "PK4", sk: "PK4", a: 4 }).operation("put"),
+                A.operation("put", new A({ pk: "PK5", sk: "PK5", a: 5 })),
+                new B({ pk: "PK6", sk: "SK6", b: "baz" }).operation("put"),
+                A.operation("updateRaw", { PK: "PK#1", SK: "SK#1" }, { a: -1 }),
+                new A({ pk: "PK#2", sk: "SK#2", a: 2 }).operation("delete"),
+                B.operation("delete", { PK: "PK#3", SK: "SK#3" }),
+                new B({
+                    pk: "PK#UPDATE",
+                    sk: "SK#UPDATE",
+                    b: "bar"
+                }).operation("update", { b: "baz" }),
+                ...Array.from({ length: 25 }).map((_, i) => new A({ pk: `PK#A${i}`, sk: `SK#A${i}`, a: i }).operation("put"))
+            ]);
+            //#region snapshot
+            expect(yield sandbox.diff(before)).toMatchInlineSnapshot(`
+        Snapshot Diff:
+        - First value
+        + Second value
+
+        @@ -2,28 +2,271 @@
+            "PK#1__SK#1": Object {
+              "PK": "PK#1",
+              "SK": "SK#1",
+              "_docVersion": 0,
+              "_tag": "A",
+        -     "a": 1,
+        +     "a": -1,
+              "pk": "PK#1",
+              "sk": "SK#1",
+        +   },
+        +   "PK#A0__SK#A0": Object {
+        +     "PK": "PK#A0",
+        +     "SK": "SK#A0",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 0,
+        +     "pk": "PK#A0",
+        +     "sk": "SK#A0",
+        +   },
+        +   "PK#A10__SK#A10": Object {
+        +     "PK": "PK#A10",
+        +     "SK": "SK#A10",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 10,
+        +     "pk": "PK#A10",
+        +     "sk": "SK#A10",
+        +   },
+        +   "PK#A11__SK#A11": Object {
+        +     "PK": "PK#A11",
+        +     "SK": "SK#A11",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 11,
+        +     "pk": "PK#A11",
+        +     "sk": "SK#A11",
+        +   },
+        +   "PK#A12__SK#A12": Object {
+        +     "PK": "PK#A12",
+        +     "SK": "SK#A12",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 12,
+        +     "pk": "PK#A12",
+        +     "sk": "SK#A12",
+        +   },
+        +   "PK#A13__SK#A13": Object {
+        +     "PK": "PK#A13",
+        +     "SK": "SK#A13",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 13,
+        +     "pk": "PK#A13",
+        +     "sk": "SK#A13",
+        +   },
+        +   "PK#A14__SK#A14": Object {
+        +     "PK": "PK#A14",
+        +     "SK": "SK#A14",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 14,
+        +     "pk": "PK#A14",
+        +     "sk": "SK#A14",
+            },
+        -   "PK#2__SK#2": Object {
+        -     "PK": "PK#2",
+        -     "SK": "SK#2",
+        +   "PK#A15__SK#A15": Object {
+        +     "PK": "PK#A15",
+        +     "SK": "SK#A15",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 15,
+        +     "pk": "PK#A15",
+        +     "sk": "SK#A15",
+        +   },
+        +   "PK#A16__SK#A16": Object {
+        +     "PK": "PK#A16",
+        +     "SK": "SK#A16",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 16,
+        +     "pk": "PK#A16",
+        +     "sk": "SK#A16",
+        +   },
+        +   "PK#A17__SK#A17": Object {
+        +     "PK": "PK#A17",
+        +     "SK": "SK#A17",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 17,
+        +     "pk": "PK#A17",
+        +     "sk": "SK#A17",
+        +   },
+        +   "PK#A18__SK#A18": Object {
+        +     "PK": "PK#A18",
+        +     "SK": "SK#A18",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 18,
+        +     "pk": "PK#A18",
+        +     "sk": "SK#A18",
+        +   },
+        +   "PK#A19__SK#A19": Object {
+        +     "PK": "PK#A19",
+        +     "SK": "SK#A19",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 19,
+        +     "pk": "PK#A19",
+        +     "sk": "SK#A19",
+        +   },
+        +   "PK#A1__SK#A1": Object {
+        +     "PK": "PK#A1",
+        +     "SK": "SK#A1",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 1,
+        +     "pk": "PK#A1",
+        +     "sk": "SK#A1",
+        +   },
+        +   "PK#A20__SK#A20": Object {
+        +     "PK": "PK#A20",
+        +     "SK": "SK#A20",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 20,
+        +     "pk": "PK#A20",
+        +     "sk": "SK#A20",
+        +   },
+        +   "PK#A21__SK#A21": Object {
+        +     "PK": "PK#A21",
+        +     "SK": "SK#A21",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 21,
+        +     "pk": "PK#A21",
+        +     "sk": "SK#A21",
+        +   },
+        +   "PK#A22__SK#A22": Object {
+        +     "PK": "PK#A22",
+        +     "SK": "SK#A22",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 22,
+        +     "pk": "PK#A22",
+        +     "sk": "SK#A22",
+        +   },
+        +   "PK#A23__SK#A23": Object {
+        +     "PK": "PK#A23",
+        +     "SK": "SK#A23",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 23,
+        +     "pk": "PK#A23",
+        +     "sk": "SK#A23",
+        +   },
+        +   "PK#A24__SK#A24": Object {
+        +     "PK": "PK#A24",
+        +     "SK": "SK#A24",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 24,
+        +     "pk": "PK#A24",
+        +     "sk": "SK#A24",
+        +   },
+        +   "PK#A2__SK#A2": Object {
+        +     "PK": "PK#A2",
+        +     "SK": "SK#A2",
+              "_docVersion": 0,
+              "_tag": "A",
+              "a": 2,
+        -     "pk": "PK#2",
+        -     "sk": "SK#2",
+        +     "pk": "PK#A2",
+        +     "sk": "SK#A2",
+        +   },
+        +   "PK#A3__SK#A3": Object {
+        +     "PK": "PK#A3",
+        +     "SK": "SK#A3",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 3,
+        +     "pk": "PK#A3",
+        +     "sk": "SK#A3",
+        +   },
+        +   "PK#A4__SK#A4": Object {
+        +     "PK": "PK#A4",
+        +     "SK": "SK#A4",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 4,
+        +     "pk": "PK#A4",
+        +     "sk": "SK#A4",
+        +   },
+        +   "PK#A5__SK#A5": Object {
+        +     "PK": "PK#A5",
+        +     "SK": "SK#A5",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 5,
+        +     "pk": "PK#A5",
+        +     "sk": "SK#A5",
+        +   },
+        +   "PK#A6__SK#A6": Object {
+        +     "PK": "PK#A6",
+        +     "SK": "SK#A6",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 6,
+        +     "pk": "PK#A6",
+        +     "sk": "SK#A6",
+        +   },
+        +   "PK#A7__SK#A7": Object {
+        +     "PK": "PK#A7",
+        +     "SK": "SK#A7",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 7,
+        +     "pk": "PK#A7",
+        +     "sk": "SK#A7",
+        +   },
+        +   "PK#A8__SK#A8": Object {
+        +     "PK": "PK#A8",
+        +     "SK": "SK#A8",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 8,
+        +     "pk": "PK#A8",
+        +     "sk": "SK#A8",
+        +   },
+        +   "PK#A9__SK#A9": Object {
+        +     "PK": "PK#A9",
+        +     "SK": "SK#A9",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 9,
+        +     "pk": "PK#A9",
+        +     "sk": "SK#A9",
+            },
+        -   "PK#3__SK#3": Object {
+        -     "PK": "PK#3",
+        -     "SK": "SK#3",
+        +   "PK#UPDATE__SK#UPDATE": Object {
+        +     "PK": "PK#UPDATE",
+        +     "SK": "SK#UPDATE",
+        +     "_docVersion": 1,
+        +     "_tag": "B",
+        +     "b": "baz",
+        +     "pk": "PK#UPDATE",
+        +     "sk": "SK#UPDATE",
+        +   },
+        +   "PK4__PK4": Object {
+        +     "PK": "PK4",
+        +     "SK": "PK4",
+        +     "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 4,
+        +     "pk": "PK4",
+        +     "sk": "PK4",
+        +   },
+        +   "PK5__PK5": Object {
+        +     "PK": "PK5",
+        +     "SK": "PK5",
+              "_docVersion": 0,
+        +     "_tag": "A",
+        +     "a": 5,
+        +     "pk": "PK5",
+        +     "sk": "PK5",
+        +   },
+        +   "PK6__SK6": Object {
+        +     "PK": "PK6",
+        +     "SK": "SK6",
+        +     "_docVersion": 0,
+              "_tag": "B",
+        -     "b": "bar",
+        -     "pk": "PK#3",
+        -     "sk": "SK#3",
+        +     "b": "baz",
+        +     "pk": "PK6",
+        +     "sk": "SK6",
+            },
+          }
+      `);
+            //#endregion
+        }));
+        test("it fails and rolls back", () => __awaiter(void 0, void 0, void 0, function* () {
+            const before = yield sandbox.snapshot();
+            yield expect(client.bulk([
+                // Succeeds
+                ...Array.from({ length: 40 }).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)" })
+            ])).rejects.toBeInstanceOf(BulkWriteTransactionError);
+            expect(yield sandbox.snapshot()).toEqual(before);
+        }));
+    });
+});
+describe("batchGet", () => {
+    class A extends model("A", t.type({ pk: t.string, sk: t.string, a: t.number }), provider) {
+        get PK() {
+            return this.pk;
+        }
+        get SK() {
+            return this.sk;
+        }
+    }
+    test("it fetches an empty record", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(yield client.batchGet({})).toEqual({});
+    }));
+    test("it throws if some items don't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(client.batchGet({
+            one: A.operation("get", { PK: "PK#1", SK: "SK#1" }),
+            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" })
+        })).rejects.toBeInstanceOf(ItemNotFoundError);
+    }));
+    test("it returns individual errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield sandbox.seed(new A({ pk: "PK#1", sk: "SK#1", a: 1 }), new A({ pk: "PK#2", sk: "SK#2", a: 2 }));
+        const result = yield client.batchGet({
+            one: A.operation("get", { PK: "PK#1", SK: "SK#1" }),
+            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" })
+        }, { individualErrors: true });
+        expect(result.one).toBeInstanceOf(A);
+        expect(result.two).toBeInstanceOf(A);
+        expect(result.duplicate).toBeInstanceOf(A);
+        expect(result.error).toBeInstanceOf(ItemNotFoundError);
+    }));
+    test("it fetches <=100 entries in one go", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield sandbox.seed(new A({ pk: "PK#1", sk: "SK#1", a: 1 }), new A({ pk: "PK#2", sk: "SK#2", a: 2 }), new A({ pk: "PK#3", sk: "SK#3", a: 3 }), new A({ pk: "PK#4", sk: "SK#4", a: 4 }));
+        const results = yield client.batchGet({
+            one: A.operation("get", { PK: "PK#1", SK: "SK#1" }),
+            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" })
+        });
+        expect(Object.fromEntries(Object.entries(results).map(([key, val]) => [key, val.values()]))).toMatchInlineSnapshot(`
+      Object {
+        "duplicate": Object {
+          "a": 1,
+          "pk": "PK#1",
+          "sk": "SK#1",
+        },
+        "four": Object {
+          "a": 4,
+          "pk": "PK#4",
+          "sk": "SK#4",
+        },
+        "one": Object {
+          "a": 1,
+          "pk": "PK#1",
+          "sk": "SK#1",
+        },
+        "three": Object {
+          "a": 3,
+          "pk": "PK#3",
+          "sk": "SK#3",
+        },
+        "two": Object {
+          "a": 2,
+          "pk": "PK#2",
+          "sk": "SK#2",
+        },
+      }
+    `);
+    }));
+});
+describe("load", () => {
+    describe("client", () => {
+        test("it throws if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(client.load(A.operation("get", { PK: "PK", SK: "SK" }))).rejects.toBeInstanceOf(ItemNotFoundError);
+        }));
+        test("it returns null instead of throwing if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(client.load(A.operation("get", { PK: "PK", SK: "SK" }), { null: true })).resolves.toBeNull();
+        }));
+        test("it fetches >100 items", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 234 }).map((_, i) => i < 100
+                ? new A({ pk: String(i), sk: String(i), a: i })
+                : new B({ pk: String(i), sk: String(i), b: String(i) }));
+            const spy = jest.spyOn(client, "batchGet");
+            yield sandbox.seed(...items);
+            const results = yield Promise.all(items.map(({ PK, SK }, i) => i < 100
+                ? client.load(A.operation("get", { PK, SK }))
+                : client.load(B.operation("get", { PK, SK }))));
+            expect(results.length).toBe(234);
+            expect(spy).toHaveBeenCalledTimes(3);
+            spy.mockReset();
+            spy.mockRestore();
+        }));
+    });
+    describe("model", () => {
+        test("it throws if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(A.load({ PK: "PK", SK: "SK" })).rejects.toBeInstanceOf(ItemNotFoundError);
+        }));
+        test("it returns null instead of throwing if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(A.load({ PK: "PK", SK: "SK" }, { null: true })).resolves.toBeNull();
+        }));
+        test("it fetches >100 items", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 234 }).map((_, i) => new A({ pk: String(i), sk: String(i), a: i }));
+            const spy = jest.spyOn(client, "batchGet");
+            yield sandbox.seed(...items);
+            const results = yield Promise.all(items.map(({ PK, SK }, i) => A.load({ PK, SK })));
+            expect(results.length).toBe(234);
+            expect(spy).toHaveBeenCalledTimes(3);
+            spy.mockReset();
+            spy.mockRestore();
+        }));
+    });
+    describe("union", () => {
+        test("it throws if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(Union.load({ PK: "PK", SK: "SK" })).rejects.toBeInstanceOf(ItemNotFoundError);
+        }));
+        test("it returns null instead of throwing if item doesn't exist", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(Union.load({ PK: "PK", SK: "SK" }, { null: true })).resolves.toBeNull();
+        }));
+        test("it fetches >100 items", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 234 }).map((_, i) => i < 123
+                ? new C({ pk: String(i), sk: String(i), c: String(i) })
+                : new D({ pk: String(i), sk: String(i), d: String(i) }));
+            const spy = jest.spyOn(client, "batchGet");
+            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(spy).toHaveBeenCalledTimes(3);
+            spy.mockReset();
+            spy.mockRestore();
+        }));
+    });
+});
+describe("loadMany", () => {
+    describe("client", () => {
+        test("it fetches >100 items", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 234 }).map((_, i) => i < 100
+                ? new A({ pk: String(i), sk: String(i), a: i })
+                : new B({ pk: String(i), sk: String(i), b: String(i) }));
+            const spy = jest.spyOn(client, "batchGet");
+            yield sandbox.seed(...items);
+            const results = yield client.loadMany(items.map(({ PK, SK }, i) => i < 100
+                ? A.operation("get", { PK, SK })
+                : B.operation("get", { PK, SK })));
+            expect(results.length).toBe(234);
+            expect(spy).toHaveBeenCalledTimes(3);
+            spy.mockReset();
+            spy.mockRestore();
+        }));
+    });
+    describe("model", () => {
+        test("it fetches >100 items", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 234 }).map((_, i) => new A({ pk: String(i), sk: String(i), a: i }));
+            const spy = jest.spyOn(client, "batchGet");
+            yield sandbox.seed(...items);
+            const results = yield A.loadMany(items.map(({ PK, SK }) => ({ PK, SK })));
+            expect(results.length).toBe(234);
+            expect(spy).toHaveBeenCalledTimes(3);
+            spy.mockReset();
+            spy.mockRestore();
+        }));
+    });
+    describe("union", () => {
+        test("it fetches >100 items", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 234 }).map((_, i) => i < 123
+                ? new C({ pk: String(i), sk: String(i), c: String(i) })
+                : new D({ pk: String(i), sk: String(i), d: String(i) }));
+            const spy = jest.spyOn(client, "batchGet");
+            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(spy).toHaveBeenCalledTimes(3);
+            spy.mockReset();
+            spy.mockRestore();
+        }));
+    });
+});
+describe("paginate", () => {
+    describe("client", () => {
+        test("it paginates a regular model", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield client.paginate(C, {}, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(20);
+            expect(page1.edges[0].node.c).toBe("0");
+            expect(page1.edges[19].node.c).toBe("19");
+            const page2 = yield client.paginate(C, { after: page1.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(page2.edges.length).toBe(20);
+            expect(page2.edges[0].node.c).toBe("20");
+            expect(page2.edges[19].node.c).toBe("39");
+            const page3 = yield client.paginate(C, { after: page2.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page3.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoLvfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKv1n9aOeA8=",
+}
+`);
+            expect(page3.edges.length).toBe(20);
+            expect(page3.edges[0].node.c).toBe("40");
+            expect(page3.edges[19].node.c).toBe("59");
+            // Backwards
+            const backwardsPage2 = yield client.paginate(C, { before: page3.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": true,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(backwardsPage2.edges.length).toBe(20);
+            expect(backwardsPage2.edges[0].node.c).toBe("20");
+            expect(backwardsPage2.edges[19].node.c).toBe("39");
+            const backwardsPage1 = yield client.paginate(C, { before: backwardsPage2.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(backwardsPage1.edges.length).toBe(20);
+            expect(backwardsPage1.edges[0].node.c).toBe("0");
+            expect(backwardsPage1.edges[19].node.c).toBe("19");
+        }));
+        test("it paginates a union model", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => i > 30
+                ? new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) })
+                : new D({ pk: "PK", sk: String(i).padStart(3, "0"), d: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield client.paginate(Union, {}, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(20);
+            expect(page1.edges[0].node.SK).toBe("000");
+            expect(page1.edges[19].node.SK).toBe("019");
+            const page2 = yield client.paginate(Union, { after: page1.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(page2.edges.length).toBe(20);
+            expect(page2.edges[0].node.SK).toBe("020");
+            expect(page2.edges[19].node.SK).toBe("039");
+            const page3 = yield client.paginate(Union, { after: page2.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page3.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoLvfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKv1n9aOeA8=",
+}
+`);
+            expect(page3.edges.length).toBe(20);
+            expect(page3.edges[0].node.SK).toBe("040");
+            expect(page3.edges[19].node.SK).toBe("059");
+            // Backwards
+            const backwardsPage2 = yield client.paginate(Union, { before: page3.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": true,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(backwardsPage2.edges.length).toBe(20);
+            expect(backwardsPage2.edges[0].node.SK).toBe("020");
+            expect(backwardsPage2.edges[19].node.SK).toBe("039");
+            const backwardsPage1 = yield client.paginate(Union, { before: backwardsPage2.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(backwardsPage1.edges.length).toBe(20);
+            expect(backwardsPage1.edges[0].node.SK).toBe("000");
+            expect(backwardsPage1.edges[19].node.SK).toBe("019");
+        }));
+        test("it respects a limit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page = yield client.paginate(C, { first: 10 }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page.edges.length).toBe(10);
+            expect(page.edges[0].node.c).toBe("0");
+            expect(page.edges[9].node.c).toBe("9");
+        }));
+        test("it doesn't exceed the max limit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield client.paginate(C, { first: 60 }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKvfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(50);
+            expect(page1.edges[0].node.c).toBe("0");
+            expect(page1.edges[49].node.c).toBe("49");
+        }));
+    });
+    describe("model", () => {
+        test("it paginates a regular model", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield C.paginate({}, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(20);
+            expect(page1.edges[0].node.c).toBe("0");
+            expect(page1.edges[19].node.c).toBe("19");
+            const page2 = yield C.paginate({ after: page1.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(page2.edges.length).toBe(20);
+            expect(page2.edges[0].node.c).toBe("20");
+            expect(page2.edges[19].node.c).toBe("39");
+            const page3 = yield C.paginate({ after: page2.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page3.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoLvfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKv1n9aOeA8=",
+}
+`);
+            expect(page3.edges.length).toBe(20);
+            expect(page3.edges[0].node.c).toBe("40");
+            expect(page3.edges[19].node.c).toBe("59");
+            // Backwards
+            const backwardsPage2 = yield C.paginate({ before: page3.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": true,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(backwardsPage2.edges.length).toBe(20);
+            expect(backwardsPage2.edges[0].node.c).toBe("20");
+            expect(backwardsPage2.edges[19].node.c).toBe("39");
+            const backwardsPage1 = yield C.paginate({ before: backwardsPage2.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(backwardsPage1.edges.length).toBe(20);
+            expect(backwardsPage1.edges[0].node.c).toBe("0");
+            expect(backwardsPage1.edges[19].node.c).toBe("19");
+        }));
+        test("it respects a limit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page = yield C.paginate({ first: 10 }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page.edges.length).toBe(10);
+            expect(page.edges[0].node.c).toBe("0");
+            expect(page.edges[9].node.c).toBe("9");
+        }));
+        test("it doesn't exceed the max limit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield C.paginate({ first: 60 }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKvfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(50);
+            expect(page1.edges[0].node.c).toBe("0");
+            expect(page1.edges[49].node.c).toBe("49");
+        }));
+    });
+    describe("union", () => {
+        test("it paginates a union model", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => i > 30
+                ? new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) })
+                : new D({ pk: "PK", sk: String(i).padStart(3, "0"), d: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield Union.paginate({}, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(20);
+            expect(page1.edges[0].node.SK).toBe("000");
+            expect(page1.edges[19].node.SK).toBe("019");
+            const page2 = yield Union.paginate({ after: page1.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(page2.edges.length).toBe(20);
+            expect(page2.edges[0].node.SK).toBe("020");
+            expect(page2.edges[19].node.SK).toBe("039");
+            const page3 = yield Union.paginate({ after: page2.pageInfo.endCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page3.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoLvfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKv1n9aOeA8=",
+}
+`);
+            expect(page3.edges.length).toBe(20);
+            expect(page3.edges[0].node.SK).toBe("040");
+            expect(page3.edges[19].node.SK).toBe("059");
+            // Backwards
+            const backwardsPage2 = yield Union.paginate({ before: page3.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage2.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo5Xfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": true,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo4X1n9aOeA8=",
+}
+`);
+            expect(backwardsPage2.edges.length).toBe(20);
+            expect(backwardsPage2.edges[0].node.SK).toBe("020");
+            expect(backwardsPage2.edges[19].node.SK).toBe("039");
+            const backwardsPage1 = yield Union.paginate({ before: backwardsPage2.pageInfo.startCursor }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(backwardsPage1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo7vfn9aOeA8=",
+  "hasNextPage": false,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(backwardsPage1.edges.length).toBe(20);
+            expect(backwardsPage1.edges[0].node.SK).toBe("000");
+            expect(backwardsPage1.edges[19].node.SK).toBe("019");
+        }));
+        test("it respects a limit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => i > 30
+                ? new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) })
+                : new D({ pk: "PK", sk: String(i).padStart(3, "0"), d: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page = yield Union.paginate({ first: 10 }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6vfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page.edges.length).toBe(10);
+            expect(page.edges[0].node.SK).toBe("000");
+            expect(page.edges[9].node.SK).toBe("009");
+        }));
+        test("it doesn't exceed the max limit", () => __awaiter(void 0, void 0, void 0, function* () {
+            const items = Array.from({ length: 60 }).map((_, i) => i > 30
+                ? new C({ pk: "PK", sk: String(i).padStart(3, "0"), c: String(i) })
+                : new D({ pk: "PK", sk: String(i).padStart(3, "0"), d: String(i) }));
+            yield sandbox.seed(...items);
+            // Forwards
+            const page1 = yield Union.paginate({ first: 60 }, {
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: { ":pk": "PK" }
+            });
+            expect(page1.pageInfo).toMatchInlineSnapshot(`
+Object {
+  "endCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOoKvfn9aOeA8=",
+  "hasNextPage": true,
+  "hasPreviousPage": false,
+  "startCursor": "cC4wNVXawu0oBvB8vqW4J/RG6hbr3ndOo6v1n9aOeA8=",
+}
+`);
+            expect(page1.edges.length).toBe(50);
+            expect(page1.edges[0].node.SK).toBe("000");
+            expect(page1.edges[49].node.SK).toBe("049");
+        }));
+    });
+});
+//# sourceMappingURL=client-with-cursor-encryption.test.js.map