@proteinjs/db 1.54.3 → 1.55.0

package/dist/test/reusable/StoredValueContractTests.js

@@ -0,0 +1,666 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storedValueContractTests = void 0;
+var db_1 = require("@proteinjs/db");
+var moment_1 = __importDefault(require("moment"));
+var db_query_1 = require("@proteinjs/db-query");
+var StatementConfigFactory_1 = require("../../src/StatementConfigFactory");
+var DbTestEnvironment_1 = require("../util/DbTestEnvironment");
+var storedValueContractTestTables_1 = require("../util/tables/storedValueContractTestTables");
+var columnTypesTestTables_1 = require("../util/tables/columnTypesTestTables");
+var dynamicReferenceColumnTestTables_1 = require("../util/tables/dynamicReferenceColumnTestTables");
+/**
+ * THE STORED-VALUE CONTRACT: what the row reader makes of each cell a database actually holds —
+ * written through the driver, the way a hand-run statement, an older writer or a cutover leaves
+ * it — not only what the serializer writes. One asserted law per shape, against a real database
+ * through each driver.
+ *
+ * Part 1 — a legacy column that shares a property's name. After a cutover (`tags` the text
+ * column → `tag_list` the array column, property `tags` both times) a row carries two cells: the
+ * undeclared legacy `tags` and the declared `tag_list`. The law: a stored value is seated by its
+ * COLUMN name alone, so the legacy cell — whatever it holds, whichever physical position it has —
+ * never reaches the array column's parser and never displaces the array. Both physical orders
+ * are built, because a row's keys arrive in the table's column order and the reader walks them
+ * in that order: the deployed shape (legacy first — the old column predates the new one) and the
+ * other (legacy added after).
+ *
+ * Part 2 — every shipped column × { null, undefined, well-formed, a malformed value written raw }.
+ * null reads as the column's null; undefined is refused at the write, naming the field; a
+ * well-formed value round-trips; a malformed cell is either refused by the storage type (the
+ * typed columns) or, where the storage holds text the column must parse, omitted from the record
+ * at one WARN naming table and column — never the value — while the row and the result set serve.
+ *
+ * Part 3 — a result set mixing the async road (a column whose `deserialize` answers with a
+ * promise) with a rejecting cell and a synchronous malformed cell resolves with every row served,
+ * and leaves no unhandled rejection behind.
+ */
+/** The stored value no warning may ever carry — distinctive, so a leak is unmistakable. */
+var LEGACY_WORD = 'legacyword7';
+/**
+ * The table as a pre-cutover build declared it: a text column named `tags` under the property
+ * `tags`. Derived from the live table (same prototype, same name), never registered: loading it
+ * creates — or adds — the physical `tags` column the cutover left behind.
+ */
+var legacyShapeOf = function (table) {
+    var shape = Object.create(Object.getPrototypeOf(table));
+    Object.assign(shape, table);
+    shape.columns = (0, db_1.withRecordColumns)({
+        name: new db_1.StringColumn('name'),
+        tags: new db_1.StringColumn('tags'),
+    });
+    return shape;
+};
+/** The unhandled rejections Node reported while `run` ran, counted after the loop drained twice. */
+var unhandledRejectionsDuring = function (run) { return __awaiter(void 0, void 0, void 0, function () {
+    var unhandled, listener, value;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                unhandled = 0;
+                listener = function () {
+                    unhandled++;
+                };
+                process.on('unhandledRejection', listener);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 5, 6]);
+                return [4 /*yield*/, run()];
+            case 2:
+                value = _a.sent();
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+            case 3:
+                _a.sent();
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 0); })];
+            case 4:
+                _a.sent();
+                return [2 /*return*/, { unhandled: unhandled, value: value }];
+            case 5:
+                process.off('unhandledRejection', listener);
+                return [7 /*endfinally*/];
+            case 6: return [2 /*return*/];
+        }
+    });
+}); };
+var storedValueContractTests = function (driver, transactionContextFactory, dropTable) {
+    return function () {
+        var db = new db_1.Db(driver, undefined, transactionContextFactory);
+        var testEnv = new DbTestEnvironment_1.DbTestEnvironment(driver, dropTable);
+        var memberTable = storedValueContractTestTables_1.storedValueContractTestTables.Member, memberAfterTable = storedValueContractTestTables_1.storedValueContractTestTables.MemberAfter, mixedTable = storedValueContractTestTables_1.storedValueContractTestTables.Mixed;
+        var typesTable = columnTypesTestTables_1.columnTypesTestTables.Test;
+        var statementConfigFactory = new StatementConfigFactory_1.StatementConfigFactory(driver.getDbName());
+        beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, testEnv.beforeAll()];
+                    case 1:
+                        _a.sent();
+                        // The deployed shape: the legacy `tags` column predates `tag_list`.
+                        return [4 /*yield*/, dropTable(memberTable)];
+                    case 2:
+                        // The deployed shape: the legacy `tags` column predates `tag_list`.
+                        _a.sent();
+                        return [4 /*yield*/, driver.getTableManager().loadTable(legacyShapeOf(memberTable))];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, driver.getTableManager().loadTable(memberTable)];
+                    case 4:
+                        _a.sent();
+                        // The other order: `tag_list` first, the legacy `tags` column added after it.
+                        return [4 /*yield*/, dropTable(memberAfterTable)];
+                    case 5:
+                        // The other order: `tag_list` first, the legacy `tags` column added after it.
+                        _a.sent();
+                        return [4 /*yield*/, driver.getTableManager().loadTable(memberAfterTable)];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, driver.getTableManager().loadTable(legacyShapeOf(memberAfterTable))];
+                    case 7:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, 120000);
+        afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, dropTable(memberTable)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, dropTable(memberAfterTable)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, testEnv.afterAll()];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, 120000);
+        /** The table as a statement names it for this driver: qualified with the database name where the driver needs it. */
+        var qualified = function (table, config) {
+            return "".concat(config.dbName ? "`".concat(config.dbName, "`.") : '', "`").concat(table.name, "`");
+        };
+        /** The row as the database holds it — every physical cell, keyed by column name, in column order. */
+        var storedRow = function (table, id) { return __awaiter(void 0, void 0, void 0, function () {
+            var rows;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, driver.runQuery(function (config) { return ({
+                            sql: "SELECT * FROM ".concat(qualified(table, statementConfigFactory.getStatementConfig(config)), " WHERE id = '").concat(id, "'"),
+                        }); })];
+                    case 1:
+                        rows = _a.sent();
+                        return [2 /*return*/, rows[0]];
+                }
+            });
+        }); };
+        /** A cell written past the serializer: the statement itself, handed the value as stored text (or NULL). */
+        var writeRawCell = function (table, id, columnName, value) { return __awaiter(void 0, void 0, void 0, function () {
+            var literal;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        literal = value === null ? 'NULL' : "'".concat(value, "'");
+                        return [4 /*yield*/, driver.runDml(function (config) { return ({
+                                sql: "UPDATE ".concat(qualified(table, statementConfigFactory.getStatementConfig(config)), " SET ").concat(columnName, " = ").concat(literal, " WHERE id = '").concat(id, "'"),
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        /**
+         * A cell written past the serializer into a column whose storage holds text the column must
+         * parse: the update statement the db layer itself emits, handed the cells as stored text.
+         */
+        var writeRawParsedCell = function (table, id, cells) { return __awaiter(void 0, void 0, void 0, function () {
+            var row;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        row = new db_1.QueryBuilderFactory().getQueryBuilder(table).condition({ field: 'id', operator: '=', value: id });
+                        return [4 /*yield*/, driver.runDml(function (config) {
+                                return new db_query_1.StatementFactory().update(table.name, cells, row, statementConfigFactory.getStatementConfig(config));
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        describe('part 1: a legacy column sharing a property name', function () {
+            var legacyCases = [
+                ['a bare word', LEGACY_WORD],
+                ['an empty string', ''],
+                ['NULL', null],
+            ];
+            describe.each([
+                ['the deployed shape: the legacy column before the declared one', memberTable, 'tags', 'tag_list'],
+                ['the other order: the legacy column after the declared one', memberAfterTable, 'tag_list', 'tags'],
+            ])('%s', function (_, table, firstKey, secondKey) {
+                test.each(legacyCases)('the declared array survives beside a legacy cell holding %s: a get and a query both carry it', function (_, legacy) { return __awaiter(void 0, void 0, void 0, function () {
+                    var member, stored, keys, fetched, queried;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, db.insert(table, { name: "member ".concat(legacy), tags: ['a', 'b'] })];
+                            case 1:
+                                member = _a.sent();
+                                return [4 /*yield*/, writeRawCell(table, member.id, 'tags', legacy)];
+                            case 2:
+                                _a.sent();
+                                return [4 /*yield*/, storedRow(table, member.id)];
+                            case 3:
+                                stored = _a.sent();
+                                keys = Object.keys(stored);
+                                // The premise: the row holds both cells, in the physical order this block built.
+                                expect(keys).toEqual(expect.arrayContaining(['tags', 'tag_list']));
+                                expect(keys.indexOf(firstKey)).toBeLessThan(keys.indexOf(secondKey));
+                                expect(stored['tags']).toBe(legacy);
+                                return [4 /*yield*/, db.get(table, { id: member.id })];
+                            case 4:
+                                fetched = _a.sent();
+                                expect(fetched.tags).toEqual(['a', 'b']);
+                                expect(fetched).toMatchObject({ id: member.id, name: "member ".concat(legacy) });
+                                return [4 /*yield*/, db.query(table, { id: member.id })];
+                            case 5:
+                                queried = _a.sent();
+                                expect(queried).toHaveLength(1);
+                                expect(queried[0].tags).toEqual(['a', 'b']);
+                                return [4 /*yield*/, db.delete(table, { id: member.id })];
+                            case 6:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+            });
+        });
+        describe('part 2: every shipped column × { null, undefined, well-formed, malformed raw }', function () {
+            var properties = [
+                'integerColumn',
+                'stringColumn',
+                'floatColumn',
+                'decimalColumn',
+                'booleanColumn',
+                'dateColumn',
+                'dateTimeColumn',
+                'binaryColumn',
+                'uuidColumn',
+                'passwordColumn',
+                'objectColumn',
+                'arrayColumn',
+                'referenceArrayColumn',
+                'referenceColumn',
+            ];
+            var allNull = function () {
+                return properties.reduce(function (cells, property) {
+                    var _a;
+                    return (__assign(__assign({}, cells), (_a = {}, _a[property] = null, _a)));
+                }, {});
+            };
+            describe('null', function () {
+                var fetched;
+                beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var inserted;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, db.insert(typesTable, allNull())];
+                            case 1:
+                                inserted = _a.sent();
+                                return [4 /*yield*/, db.get(typesTable, { id: inserted.id })];
+                            case 2:
+                                fetched = _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+                afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!fetched) return [3 /*break*/, 2];
+                                return [4 /*yield*/, db.delete(typesTable, { id: fetched.id })];
+                            case 1:
+                                _a.sent();
+                                _a.label = 2;
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+                test.each(properties.filter(function (property) { return property !== 'referenceArrayColumn'; }))('%s: a null cell reads as null', function (property) {
+                    expect(fetched[property]).toBeNull();
+                });
+                test('referenceArrayColumn: a null cell reads as an empty reference array', function () {
+                    expect(fetched.referenceArrayColumn).toHaveProperty('_ids', []);
+                });
+            });
+            describe('undefined', function () {
+                test("uuidColumn: undefined takes the column's default — a generated uuid", function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var inserted, fetched;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, db.insert(typesTable, __assign(__assign({}, allNull()), { uuidColumn: undefined }))];
+                            case 1:
+                                inserted = _a.sent();
+                                _a.label = 2;
+                            case 2:
+                                _a.trys.push([2, , 4, 6]);
+                                return [4 /*yield*/, db.get(typesTable, { id: inserted.id })];
+                            case 3:
+                                fetched = _a.sent();
+                                expect(fetched.uuidColumn).toMatch(/^[0-9a-f-]{36}$/);
+                                return [3 /*break*/, 6];
+                            case 4: return [4 /*yield*/, db.delete(typesTable, { id: inserted.id })];
+                            case 5:
+                                _a.sent();
+                                return [7 /*endfinally*/];
+                            case 6: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                test.each(properties.filter(function (property) { return property !== 'uuidColumn'; }))('%s: undefined is refused at the write, naming the field', function (property) { return __awaiter(void 0, void 0, void 0, function () {
+                    var _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0: return [4 /*yield*/, expect(db.insert(typesTable, __assign(__assign({}, allNull()), (_a = {}, _a[property] = undefined, _a)))).rejects.toThrow("Undefined was found for field: ".concat(typesTable.name, ".").concat(property))];
+                            case 1:
+                                _b.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+            describe('well-formed', function () {
+                var wellFormed = {
+                    integerColumn: 7,
+                    stringColumn: 'text',
+                    floatColumn: 1.5,
+                    decimalColumn: null,
+                    booleanColumn: true,
+                    dateColumn: new Date(2024, 0, 2, 12),
+                    dateTimeColumn: moment_1.default.utc('2024-01-02T03:04:05Z'),
+                    binaryColumn: null,
+                    uuidColumn: 'a4b2f5f2-2f8b-4c1e-9b2e-6d3f8a1c0e11',
+                    passwordColumn: 'stored-as-given',
+                    objectColumn: { theme: 'dark', depth: 2 },
+                    arrayColumn: ['a', 'b'],
+                    referenceArrayColumn: new db_1.ReferenceArray('reference_table', ['r1', 'r2']),
+                    referenceColumn: new db_1.Reference('reference_table', 'r3'),
+                };
+                var fetched;
+                beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var inserted;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, db.insert(typesTable, wellFormed)];
+                            case 1:
+                                inserted = _a.sent();
+                                return [4 /*yield*/, db.get(typesTable, { id: inserted.id })];
+                            case 2:
+                                fetched = _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+                afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!fetched) return [3 /*break*/, 2];
+                                return [4 /*yield*/, db.delete(typesTable, { id: fetched.id })];
+                            case 1:
+                                _a.sent();
+                                _a.label = 2;
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+                test('integerColumn round-trips', function () { return expect(fetched.integerColumn).toBe(7); });
+                test('stringColumn round-trips', function () { return expect(fetched.stringColumn).toBe('text'); });
+                test('floatColumn round-trips', function () { return expect(Number(fetched.floatColumn)).toBe(1.5); });
+                // A JS number does not bind to a NUMERIC parameter through the driver (the backend refuses the
+                // statement: "Could not parse … 2.25 as NUMERIC"); the law is unpinned until the binding is.
+                test.todo('decimalColumn round-trips (a JS number does not bind to NUMERIC through the driver)');
+                test('booleanColumn round-trips', function () { return expect(fetched.booleanColumn).toBe(true); });
+                test('dateTimeColumn round-trips to the stored instant', function () {
+                    return expect((0, moment_1.default)(fetched.dateTimeColumn).valueOf()).toBe(Date.UTC(2024, 0, 2, 3, 4, 5));
+                });
+                test('dateColumn round-trips to the stored calendar day', function () {
+                    var day = new Date(fetched.dateColumn);
+                    expect([day.getFullYear(), day.getMonth(), day.getDate()]).toEqual([2024, 0, 2]);
+                });
+                test('uuidColumn round-trips', function () { return expect(fetched.uuidColumn).toBe('a4b2f5f2-2f8b-4c1e-9b2e-6d3f8a1c0e11'); });
+                test('passwordColumn stores what it is given', function () { return expect(fetched.passwordColumn).toBe('stored-as-given'); });
+                test('objectColumn round-trips', function () { return expect(fetched.objectColumn).toEqual({ theme: 'dark', depth: 2 }); });
+                test('arrayColumn round-trips', function () { return expect(fetched.arrayColumn).toEqual(['a', 'b']); });
+                test('referenceArrayColumn round-trips its ids', function () {
+                    return expect(fetched.referenceArrayColumn).toHaveProperty('_ids', ['r1', 'r2']);
+                });
+                test('referenceColumn round-trips its id', function () { return expect(fetched.referenceColumn).toHaveProperty('_id', 'r3'); });
+            });
+            describe('a malformed value written raw through the driver', function () {
+                var legacy;
+                var intact;
+                beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, db.insert(typesTable, __assign(__assign({}, allNull()), { stringColumn: 'legacy' }))];
+                            case 1:
+                                legacy = _a.sent();
+                                return [4 /*yield*/, db.insert(typesTable, __assign(__assign({}, allNull()), { stringColumn: 'intact', arrayColumn: ['c'] }))];
+                            case 2:
+                                intact = _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+                afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, db.delete(typesTable, { id: legacy.id })];
+                            case 1:
+                                _a.sent();
+                                return [4 /*yield*/, db.delete(typesTable, { id: intact.id })];
+                            case 2:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, 60000);
+                // The storage type is the guard: a word is refused before it can be stored.
+                test.each([
+                    ['integerColumn', 'integer_column'],
+                    ['floatColumn', 'float_column'],
+                    ['decimalColumn', 'decimal_column'],
+                    ['booleanColumn', 'boolean_column'],
+                    ['dateColumn', 'date_column'],
+                    ['dateTimeColumn', 'date_time_column'],
+                ])('%s: the storage type refuses a word', function (_, columnName) { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, expect(writeRawCell(typesTable, legacy.id, columnName, LEGACY_WORD)).rejects.toThrow()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                // Text the column does not parse: whatever is stored is what is read.
+                test.each([
+                    ['stringColumn', 'string_column'],
+                    ['uuidColumn', 'uuid_column'],
+                    ['passwordColumn', 'password_column'],
+                ])('%s: a stored word reads back as stored', function (property, columnName) { return __awaiter(void 0, void 0, void 0, function () {
+                    var fetched;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, writeRawCell(typesTable, legacy.id, columnName, LEGACY_WORD)];
+                            case 1:
+                                _a.sent();
+                                return [4 /*yield*/, db.get(typesTable, { id: legacy.id })];
+                            case 2:
+                                fetched = _a.sent();
+                                expect(fetched[property]).toBe(LEGACY_WORD);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                test('referenceColumn: a stored word is the id the reference carries', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var fetched;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, writeRawCell(typesTable, legacy.id, 'reference_column', LEGACY_WORD)];
+                            case 1:
+                                _a.sent();
+                                return [4 /*yield*/, db.get(typesTable, { id: legacy.id })];
+                            case 2:
+                                fetched = _a.sent();
+                                expect(fetched.referenceColumn).toHaveProperty('_id', LEGACY_WORD);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                // Text the column parses: a cell it cannot parse is omitted — the row serves, the set resolves.
+                test('objectColumn, arrayColumn, referenceArrayColumn: an unparseable cell is omitted; the row and the set serve', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var fetched, all;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, writeRawParsedCell(typesTable, legacy.id, {
+                                    object_column: LEGACY_WORD,
+                                    array_column: LEGACY_WORD,
+                                    reference_array_column: LEGACY_WORD,
+                                })];
+                            case 1:
+                                _a.sent();
+                                return [4 /*yield*/, db.get(typesTable, { id: legacy.id })];
+                            case 2:
+                                fetched = _a.sent();
+                                expect(fetched).toMatchObject({ id: legacy.id });
+                                expect(fetched).not.toHaveProperty('objectColumn');
+                                expect(fetched).not.toHaveProperty('arrayColumn');
+                                expect(fetched).not.toHaveProperty('referenceArrayColumn');
+                                return [4 /*yield*/, db.query(typesTable, {})];
+                            case 3:
+                                all = _a.sent();
+                                expect(all.map(function (record) { return record.id; })).toEqual(expect.arrayContaining([legacy.id, intact.id]));
+                                expect(all.find(function (record) { return record.id === intact.id; })).toMatchObject({
+                                    stringColumn: 'intact',
+                                    arrayColumn: ['c'],
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                test('a dynamic reference whose companion table-name cell is empty is omitted; the row serves', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var assignments, engineers, engineer, assignment, fetched;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                assignments = dynamicReferenceColumnTestTables_1.dynamicReferenceTestTables.ProjectAssignment, engineers = dynamicReferenceColumnTestTables_1.dynamicReferenceTestTables.Engineer;
+                                return [4 /*yield*/, db.insert(engineers, { name: 'eng', yearsOfExperience: 3 })];
+                            case 1:
+                                engineer = _a.sent();
+                                return [4 /*yield*/, db.insert(assignments, {
+                                        projectName: 'p',
+                                        employeeTableName: engineers.name,
+                                        employeeRef: new db_1.Reference(engineers.name, engineer.id),
+                                        startDate: '2024-01-02',
+                                    })];
+                            case 2:
+                                assignment = _a.sent();
+                                _a.label = 3;
+                            case 3:
+                                _a.trys.push([3, , 6, 9]);
+                                return [4 /*yield*/, writeRawCell(assignments, assignment.id, 'employee_table_name', null)];
+                            case 4:
+                                _a.sent();
+                                return [4 /*yield*/, db.get(assignments, { id: assignment.id })];
+                            case 5:
+                                fetched = _a.sent();
+                                expect(fetched).toMatchObject({ id: assignment.id, projectName: 'p', startDate: '2024-01-02' });
+                                expect(fetched).not.toHaveProperty('employeeRef');
+                                return [3 /*break*/, 9];
+                            case 6: return [4 /*yield*/, driver.runDml(function (config) { return ({
+                                    sql: "DELETE FROM ".concat(qualified(assignments, statementConfigFactory.getStatementConfig(config)), " WHERE id = '").concat(assignment.id, "'"),
+                                }); })];
+                            case 7:
+                                _a.sent();
+                                return [4 /*yield*/, db.delete(engineers, { id: engineer.id })];
+                            case 8:
+                                _a.sent();
+                                return [7 /*endfinally*/];
+                            case 9: return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+        describe('part 3: a result set mixing the async road, a rejecting cell and a malformed cell', function () {
+            test('resolves with every row served, and leaves no unhandled rejection', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var plain, unreadable, malformed, _a, unhandled, records, byId, _i, records_1, record, _b, _c, record;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0: return [4 /*yield*/, db.insert(mixedTable, { title: 'plain', later: 1, tags: ['a'] })];
+                        case 1:
+                            plain = _d.sent();
+                            return [4 /*yield*/, db.insert(mixedTable, { title: 'unreadable', later: -1, tags: ['b'] })];
+                        case 2:
+                            unreadable = _d.sent();
+                            return [4 /*yield*/, db.insert(mixedTable, { title: 'malformed', later: 2, tags: ['c'] })];
+                        case 3:
+                            malformed = _d.sent();
+                            return [4 /*yield*/, writeRawParsedCell(mixedTable, malformed.id, { tags: LEGACY_WORD })];
+                        case 4:
+                            _d.sent();
+                            _d.label = 5;
+                        case 5:
+                            _d.trys.push([5, , 7, 12]);
+                            return [4 /*yield*/, unhandledRejectionsDuring(function () { return db.query(mixedTable, {}); })];
+                        case 6:
+                            _a = _d.sent(), unhandled = _a.unhandled, records = _a.value;
+                            expect(unhandled).toBe(0);
+                            byId = {};
+                            for (_i = 0, records_1 = records; _i < records_1.length; _i++) {
+                                record = records_1[_i];
+                                byId[record.id] = record;
+                            }
+                            expect(byId[plain.id]).toMatchObject({ title: 'plain', later: 1, tags: ['a'] });
+                            expect(byId[unreadable.id]).toMatchObject({ title: 'unreadable', tags: ['b'] });
+                            expect(byId[unreadable.id]).not.toHaveProperty('later');
+                            expect(byId[malformed.id]).toMatchObject({ title: 'malformed', later: 2 });
+                            expect(byId[malformed.id]).not.toHaveProperty('tags');
+                            return [3 /*break*/, 12];
+                        case 7:
+                            _b = 0, _c = [plain, unreadable, malformed];
+                            _d.label = 8;
+                        case 8:
+                            if (!(_b < _c.length)) return [3 /*break*/, 11];
+                            record = _c[_b];
+                            return [4 /*yield*/, db.delete(mixedTable, { id: record.id })];
+                        case 9:
+                            _d.sent();
+                            _d.label = 10;
+                        case 10:
+                            _b++;
+                            return [3 /*break*/, 8];
+                        case 11: return [7 /*endfinally*/];
+                        case 12: return [2 /*return*/];
+                    }
+                });
+            }); }, 60000);
+        });
+    };
+};
+exports.storedValueContractTests = storedValueContractTests;
+//# sourceMappingURL=StoredValueContractTests.js.map