@proteinjs/db 1.54.3 → 1.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteinjs/db",
-  "version": "1.54.3",
+  "version": "1.55.0",
   "main": "./dist/generated/index.js",
   "types": "./dist/generated/index.d.ts",
   "exports": {
@@ -41,7 +41,7 @@
     "test": "jest --passWithNoTests"
   },
   "dependencies": {
-    "@proteinjs/db-query": "^1.11.0",
+    "@proteinjs/db-query": "^1.11.1",
     "@proteinjs/logger": "^1.2.0",
     "@proteinjs/reflection": "^1.2.0",
     "@proteinjs/serializer": "^1.1.10",
@@ -66,5 +66,5 @@
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
   },
-  "gitHead": "351cc984b09d074bf0306a82750efd99ec00654a"
+  "gitHead": "e2cb123d846e60e8cddccbca06b5076a009817ed"
 }

package/src/Record.ts

@@ -25,10 +25,26 @@ const recordColumns: Columns<Record> = {
   }),
 };
 
-class MissingFieldError extends Error {
+/** A record field no declared column owns — the one serialize failure a write omits instead of failing on. */
+export class MissingFieldError extends Error {
   constructor(tableName: string, fieldName: string) {
     super(`Table ${tableName} is missing field: ${fieldName}`);
     this.name = 'MissingFieldError';
+    // ES5 down-leveled `extends Error` loses the subclass prototype — restore it so
+    // `instanceof MissingFieldError` holds for the write-side catch.
+    Object.setPrototypeOf(this, MissingFieldError.prototype);
+  }
+}
+
+/** Two declared columns of one table share a stored name: the second would silently take the first's seat. */
+export class DuplicateColumnNameError extends Error {
+  constructor(tableName: string, columnName: string, propertyNames: [string, string]) {
+    super(
+      `(${tableName}) Columns ${propertyNames[0]} and ${propertyNames[1]} both declare the column name ` +
+        `'${columnName}'; a stored cell can have only one seat`
+    );
+    this.name = 'DuplicateColumnNameError';
+    Object.setPrototypeOf(this, DuplicateColumnNameError.prototype);
   }
 }
 
@@ -102,7 +118,13 @@ export class RecordSerializer<T extends Record> {
       try {
         const { columnName, serializedFieldValue } = await fieldSerializer.serialize(fieldPropertyName, fieldValue);
         serialized[columnName] = serializedFieldValue;
-      } catch (MissingFieldError) {
+      } catch (error) {
+        // Only a field no column owns is omitted; a column that cannot serialize its value fails
+        // the write — nothing is stored for a cell the column could not make, and the caller hears it.
+        if (!(error instanceof MissingFieldError)) {
+          throw error;
+        }
+
         omittedFields.push(fieldPropertyName);
       }
     }
@@ -132,17 +154,45 @@ export class RecordSerializer<T extends Record> {
     const plan = this.hydrationPlan();
     const records: (T | Promise<T>)[] = new Array(serializedRecords.length);
     let settles = false;
-    for (let i = 0; i < serializedRecords.length; i++) {
-      const record = this.hydrate(plan, serializedRecords[i]);
-      if (this.isPromise(record)) {
-        settles = true;
+    try {
+      for (let i = 0; i < serializedRecords.length; i++) {
+        const record = this.hydrate(plan, serializedRecords[i]);
+        if (this.isPromise(record)) {
+          settles = true;
+        }
+        records[i] = record;
       }
-      records[i] = record;
+    } catch (error) {
+      return this.failAfterSettling(records, error);
     }
 
     return settles ? Promise.all(records) : (records as T[]);
   }
 
+  /**
+   * Settle, then fail: a row (or cell) that threw synchronously fails the set — but never before
+   * every promise an earlier row or cell already created has settled. A promise left behind by a
+   * synchronous throw is observed by nobody: its rejection is an `unhandledRejection` no caller
+   * can catch. So the throw becomes the set's rejection, after the created promises settle.
+   */
+  private failAfterSettling(created: unknown[], error: unknown): Promise<never> {
+    const settling: Promise<void>[] = [];
+    for (const value of created) {
+      if (this.isPromise(value)) {
+        settling.push(
+          value.then(
+            () => undefined,
+            () => undefined
+          )
+        );
+      }
+    }
+
+    return Promise.all(settling).then(() => {
+      throw error;
+    });
+  }
+
   /** One row → one record (`deserializeAll` is the door for a result set). */
   async deserialize(serializedRecord: SerializedRecord): Promise<T> {
     return await this.hydrate(this.hydrationPlan(), serializedRecord);
@@ -164,51 +214,56 @@ export class RecordSerializer<T extends Record> {
     const record: any = {};
     let settling: Promise<void>[] | undefined;
     let omittedFields: string[] | undefined;
-    for (const columnName in prepared) {
-      const slot = plan.slotsByColumnName[columnName];
-      if (!slot) {
-        // a column exists in the db that is no longer defined in Table.columns
-        (omittedFields ??= []).push(columnName);
-        continue;
-      }
+    try {
+      for (const columnName in prepared) {
+        const slot = plan.slotsByColumnName[columnName];
+        if (!slot) {
+          // a column exists in the db that no declared column owns (a column the table no longer
+          // declares, or one a rename left behind under the property's old name)
+          (omittedFields ??= []).push(columnName);
+          continue;
+        }
 
-      const { propertyName, column } = slot;
-      const storedValue = prepared[columnName];
-      if (!column.deserialize) {
-        record[propertyName] = storedValue;
-        continue;
-      }
+        const { propertyName, column } = slot;
+        const storedValue = prepared[columnName];
+        if (!column.deserialize) {
+          record[propertyName] = storedValue;
+          continue;
+        }
 
-      if (column.deserializeOnFirstRead && storedValue !== null && storedValue !== undefined) {
-        this.defineFieldReadOnFirstRead(record, propertyName, column, storedValue);
-        continue;
-      }
+        if (column.deserializeOnFirstRead && storedValue !== null && storedValue !== undefined) {
+          this.defineFieldReadOnFirstRead(record, propertyName, column, storedValue);
+          continue;
+        }
 
-      let fieldValue: unknown;
-      try {
-        fieldValue = column.deserialize(storedValue, prepared);
-      } catch (error) {
-        this.omitCellNotDeserialized(columnName, prepared, error);
-        continue;
-      }
+        let fieldValue: unknown;
+        try {
+          fieldValue = column.deserialize(storedValue, prepared);
+        } catch (error) {
+          this.omitCellNotDeserialized(columnName, prepared, error);
+          continue;
+        }
 
-      if (this.isPromise(fieldValue)) {
-        record[propertyName] = undefined; // seats the property in column order; the value lands when it settles
-        (settling ??= []).push(
-          fieldValue.then(
-            (value) => {
-              record[propertyName] = value;
-            },
-            (error) => {
-              delete record[propertyName];
-              this.omitCellNotDeserialized(columnName, prepared, error);
-            }
-          )
-        );
-        continue;
-      }
+        if (this.isPromise(fieldValue)) {
+          record[propertyName] = undefined; // seats the property in column order; the value lands when it settles
+          (settling ??= []).push(
+            fieldValue.then(
+              (value) => {
+                record[propertyName] = value;
+              },
+              (error) => {
+                delete record[propertyName];
+                this.omitCellNotDeserialized(columnName, prepared, error);
+              }
+            )
+          );
+          continue;
+        }
 
-      record[propertyName] = fieldValue;
+        record[propertyName] = fieldValue;
+      }
+    } catch (error) {
+      return this.failAfterSettling(settling ?? [], error);
     }
 
     if (omittedFields) {
@@ -271,13 +326,18 @@ export class RecordSerializer<T extends Record> {
       require('./encryption/EncryptionRecordHooks') as typeof import('./encryption/EncryptionRecordHooks');
     const slotsByColumnName: HydrationPlan['slotsByColumnName'] = {};
     const columns: { [propertyName: string]: Column<any, any> } = this.table.columns;
-    // Seated by column name, then by property name — a stored key that is a property name
-    // resolves to that property's column first, as it always has.
+    // Seated by the declared COLUMN name alone — the name a stored row carries a cell under (a
+    // driver's rows are keyed by column name, always). A stored key that is only a property's name
+    // — a column a rename retired and left physically present — names no seat: it is omitted like
+    // any other undeclared column and never reaches a declared column's parser.
     for (const propertyName in columns) {
-      slotsByColumnName[columns[propertyName].name] = { propertyName, column: columns[propertyName] };
-    }
-    for (const propertyName in columns) {
-      slotsByColumnName[propertyName] = { propertyName, column: columns[propertyName] };
+      const columnName = columns[propertyName].name;
+      const seated = slotsByColumnName[columnName];
+      if (seated) {
+        throw new DuplicateColumnNameError(this.table.name, columnName, [seated.propertyName, propertyName]);
+      }
+
+      slotsByColumnName[columnName] = { propertyName, column: columns[propertyName] };
     }
 
     this.plan = { hooks: new EncryptionRecordHooks(), slotsByColumnName };
@@ -335,22 +395,21 @@ export class FieldSerializer<T extends Record> {
 
   async deserialize(columnName: string, serializedFieldValue: any, serializedRecord: SerializedRecord) {
     const columns: { [prop: string]: Column<any, any> } = this.table.columns;
-    let fieldPropertyName = columnName;
-    let column = columns[columnName]; // the scenario that the column name is the same as the property name
-    if (!column) {
-      for (const columnPropertyName in columns) {
-        const checkColumn = (this.table.columns as any)[columnPropertyName];
-        if (checkColumn && columnName == checkColumn.name) {
-          fieldPropertyName = columnPropertyName;
-          column = checkColumn;
-          break;
-        }
+    // One seat per stored cell: the declared column whose NAME the cell is stored under (the law
+    // `RecordSerializer` hydrates by) — never a property that merely shares the stored key's name.
+    let fieldPropertyName: string | undefined;
+    let column: Column<any, any> | undefined;
+    for (const columnPropertyName in columns) {
+      if (columnName === columns[columnPropertyName].name) {
+        fieldPropertyName = columnPropertyName;
+        column = columns[columnPropertyName];
+        break;
       }
     }
 
-    if (!column) {
-      // this is the case where a column exists in the db that is no longer defined in Table.columns
-      throw new MissingFieldError(this.table.name, fieldPropertyName);
+    if (!column || !fieldPropertyName) {
+      // this is the case where a column exists in the db that no declared column owns
+      throw new MissingFieldError(this.table.name, columnName);
     }
 
     let fieldValue = serializedFieldValue;

package/src/auth/TableServiceAuth.ts

@@ -1,7 +1,7 @@
 import { Logger } from '@proteinjs/logger';
 import { ServiceError, ServiceRefusal } from '@proteinjs/service';
 import { Table, isTable } from '../Table';
-import { TableAuth, TableAuthError } from './TableAuth';
+import { TableAuth } from './TableAuth';
 
 export class TableServiceAuth {
   private logger = new Logger({ name: this.constructor.name });

package/src/schema/TableManager.ts

@@ -419,6 +419,30 @@ export class TableManager {
     return true;
   }
 
+  /**
+   * The census, at every schema sync of an existing table: the physical columns no declared column
+   * of the table owns — a column a rename retired (`tags` beside the `tag_list` that replaced it),
+   * a column the table dropped from its declaration. Such a column is never read or altered by the
+   * schema sync and never seated by the row reader; it rides every row of the table until a
+   * migration retires it. One WARN per table naming the columns — names only, never a value.
+   */
+  private warnUndeclaredColumns(table: Table<any>, physicalColumnNames: string[]): void {
+    const declared = new Set<string>();
+    for (const columnPropertyName in table.columns) {
+      declared.add(table.columns[columnPropertyName].name);
+    }
+
+    const undeclared = physicalColumnNames.filter((columnName) => !declared.has(columnName));
+    if (undeclared.length === 0) {
+      return;
+    }
+
+    this.logger.warn({
+      message: `Physical columns no declared column owns; a migration retires them`,
+      obj: { table: table.name, columns: undeclared },
+    });
+  }
+
   private async getTableChanges(table: Table<any>) {
     const { indexesToCreate, indexesToDrop } = await this.getIndexOperations(table);
     const tableChanges: TableChanges = {
@@ -440,6 +464,7 @@ export class TableManager {
     const columnMetadata = await this.schemaMetadata.getColumnMetadata(table);
     const uniqueColumns = await this.schemaMetadata.getUniqueColumns(table);
     const foreignKeys = await this.schemaMetadata.getForeignKeys(table);
+    this.warnUndeclaredColumns(table, Object.keys(columnMetadata));
     for (const columnPropertyName in table.columns) {
       const column = table.columns[columnPropertyName];
       if (columnMetadata[column.name]) {

package/src/source/SourceRecordSyncRunner.ts

@@ -662,7 +662,7 @@ export class SourceRecordSyncRunner {
             break;
           }
         }
-      } catch (error) {
+      } catch {
         // Unresolvable from cwd — reported below.
       }
     }

package/test/SettleThenFail.test.ts

@@ -0,0 +1,167 @@
+import { Column, Table } from '../src/Table';
+import { Record, RecordSerializer, SerializedRecord, withRecordColumns } from '../src/Record';
+import { StringColumn } from '../src/Columns';
+import { EncryptionRecordHooks } from '../src/encryption/EncryptionRecordHooks';
+import { EncryptionEnvelope } from '../src/encryption/EncryptionEnvelope';
+import { DataKeyStore, DataKeyMaterial } from '../src/encryption/DataKeyStore';
+
+/**
+ * Settle, then fail. The set reader hydrates rows in order and hands them to ONE promise after the
+ * loop; a row that needs an await (a ciphertext envelope whose key is read asynchronously) is a
+ * promise in the set from the moment its hook answers. If a LATER row then throws synchronously,
+ * the loop ends before that one promise exists — and the earlier row's promise is observed by
+ * nobody: its rejection is an `unhandledRejection`, which no caller can catch and a fatal boundary
+ * turns into an exit. The law: a synchronous throw fails the set only after every promise the set
+ * already created has settled — one rejection, carrying the throw, and no unhandled rejection. The
+ * same inside one row, for its cells.
+ */
+
+interface Doc extends Record {
+  title: string;
+  later: number;
+  after: string;
+}
+
+/** A column whose `deserialize` answers with a promise: resolves the number, rejects for -1. */
+class LaterColumn implements Column<number, number> {
+  constructor(public name: string) {}
+
+  deserialize(storedValue: number | null): Promise<number | null> {
+    return storedValue === -1 ? Promise.reject(new RangeError('unreadable')) : Promise.resolve(storedValue);
+  }
+}
+
+class DocTable extends Table<Doc> {
+  public name = 'settle_doc';
+  public columns = withRecordColumns<Doc>({
+    title: new StringColumn('title'),
+    later: new LaterColumn('later'),
+    after: new StringColumn('after'),
+  });
+}
+
+const docTable = new DocTable() as Table<Doc>;
+
+const keyFor = (owner: string, version: number): DataKeyMaterial => ({
+  owner,
+  version,
+  cipherKey: Buffer.alloc(32, 7),
+  indexKey: Buffer.alloc(32, 9),
+});
+
+const storedRow = (id: string, cells: Partial<SerializedRecord> = {}): SerializedRecord => ({
+  id,
+  created: new Date(1_700_000_000_000),
+  updated: new Date(1_700_000_000_000),
+  title: `title ${id}`,
+  later: 1,
+  after: `after ${id}`,
+  ...cells,
+});
+
+/** The unhandled rejections Node reported while `run` ran, counted after the loop drained twice. */
+const unhandledRejectionsDuring = async (
+  run: () => Promise<unknown>
+): Promise<{ unhandled: number; outcome: unknown }> => {
+  let unhandled = 0;
+  const listener = () => {
+    unhandled++;
+  };
+  process.on('unhandledRejection', listener);
+  try {
+    const outcome = await run().then(
+      (value) => ({ resolved: value }),
+      (error) => ({ rejected: error })
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    return { unhandled, outcome };
+  } finally {
+    process.off('unhandledRejection', listener);
+  }
+};
+
+describe('settle, then fail', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('an envelope row whose key read rejects, beside a later row that throws synchronously: one rejection, nothing unhandled', async () => {
+    const key = keyFor('owner-1', 4);
+    jest.spyOn(DataKeyStore.prototype, 'getKeyByVersion').mockRejectedValue(new Error('key unavailable'));
+    const onDeserialize = EncryptionRecordHooks.prototype.onDeserialize;
+    jest.spyOn(EncryptionRecordHooks.prototype, 'onDeserialize').mockImplementation(function (
+      this: EncryptionRecordHooks,
+      table,
+      row
+    ) {
+      if (row.id === 'r2') {
+        throw new Error('hook failed');
+      }
+      return onDeserialize.call(this, table, row);
+    });
+    const rows = [
+      storedRow('r1', { title: new EncryptionEnvelope().encrypt('secret', key) }),
+      storedRow('r2'),
+      storedRow('r3'),
+    ];
+
+    const { unhandled, outcome } = await unhandledRejectionsDuring(async () =>
+      new RecordSerializer<Doc>(docTable).deserializeAll(rows)
+    );
+
+    expect(outcome).toEqual({ rejected: new Error('hook failed') });
+    expect(unhandled).toBe(0);
+  });
+
+  test('inside one row: a cell whose promise rejects, beside a later cell that throws synchronously', async () => {
+    // A stored value whose `then` getter throws — the one synchronous throw the duck-typed
+    // promise check can meet after a column has answered.
+    const throwingThenable = {
+      get then(): never {
+        throw new Error('not a promise after all');
+      },
+    };
+    class ThenableColumn implements Column<unknown, unknown> {
+      constructor(public name: string) {}
+
+      deserialize(): unknown {
+        return throwingThenable;
+      }
+    }
+    interface Cells extends Record {
+      later: number;
+      odd: unknown;
+    }
+    class CellsTable extends Table<Cells> {
+      public name = 'settle_cells';
+      public columns = withRecordColumns<Cells>({
+        later: new LaterColumn('later'),
+        odd: new ThenableColumn('odd'),
+      });
+    }
+    const rows = [storedRow('c1', { later: -1, odd: 'x' })];
+
+    const { unhandled, outcome } = await unhandledRejectionsDuring(async () =>
+      new RecordSerializer<Cells>(new CellsTable() as Table<Cells>).deserializeAll(rows)
+    );
+
+    expect(outcome).toEqual({ rejected: new Error('not a promise after all') });
+    expect(unhandled).toBe(0);
+  });
+
+  test('a set that mixes the async road with a rejecting cell and a synchronous cell resolves, every row served', async () => {
+    const rows = [storedRow('r1'), storedRow('r2', { later: -1 }), storedRow('r3', { later: 3 })];
+
+    const { unhandled, outcome } = await unhandledRejectionsDuring(async () =>
+      new RecordSerializer<Doc>(docTable).deserializeAll(rows)
+    );
+
+    expect(unhandled).toBe(0);
+    const records = (outcome as { resolved: Doc[] }).resolved;
+    expect(records.map((record) => record.id)).toEqual(['r1', 'r2', 'r3']);
+    expect(records[0].later).toBe(1);
+    expect(records[1]).not.toHaveProperty('later');
+    expect(records[2].later).toBe(3);
+  });
+});

package/test/StoredValueSeating.test.ts

@@ -0,0 +1,169 @@
+import { Column, Table } from '../src/Table';
+import {
+  DuplicateColumnNameError,
+  FieldSerializer,
+  MissingFieldError,
+  Record,
+  RecordSerializer,
+  SerializedRecord,
+  withRecordColumns,
+} from '../src/Record';
+import { ArrayColumn, StringColumn } from '../src/Columns';
+
+/**
+ * Where a stored cell is seated: by the declared COLUMN name alone. A stored key that is only a
+ * PROPERTY's name — the text column `tags` a cutover retired beside the array column `tag_list`
+ * that replaced it, property `tags` both times — names no seat: it never reaches the array
+ * column's parser, never displaces the array, whichever side of the real cell it lands on, and
+ * whatever it holds (a bare word, an empty string, NULL). The row reader used to seat by property
+ * name as a second pass, which is the only way an undeclared cell could reach a declared column's
+ * parser — and, iterated after the real cell, a NULL in it silently replaced the array.
+ */
+
+interface Member extends Record {
+  name: string;
+  tags: string[] | null;
+}
+
+class MemberTable extends Table<Member> {
+  public name = 'seating_member';
+  public columns = withRecordColumns<Member>({
+    name: new StringColumn('name'),
+    tags: new ArrayColumn<string>('tag_list'),
+  });
+}
+
+const memberTable = new MemberTable() as Table<Member>;
+
+type SerializerInternals = { logger: { warn: (...args: unknown[]) => void } };
+type SerializerStatics = { legacyCellsWarned: Set<string> };
+
+const LEGACY_WORD = 'legacyword7';
+
+/** Every warning a serializer logs, as the logger received it. */
+const warningsOf = (serializer: RecordSerializer<any>): unknown[][] => {
+  const calls: unknown[][] = [];
+  (serializer as unknown as SerializerInternals).logger.warn = (...args: unknown[]) => {
+    calls.push(args);
+  };
+  return calls;
+};
+
+/** A stored row in the given key order — the order a driver's row carries its cells in. */
+const rowOf = (cells: { [columnName: string]: unknown }): SerializedRecord => ({
+  id: 'm1',
+  created: new Date(1_700_000_000_000),
+  updated: new Date(1_700_000_000_000),
+  ...cells,
+});
+
+beforeEach(() => {
+  (RecordSerializer as unknown as SerializerStatics).legacyCellsWarned.clear();
+});
+
+describe('a stored key that is a property name, not a column name', () => {
+  test.each([
+    ['a bare word', LEGACY_WORD],
+    ['an empty string', ''],
+    ['NULL', null],
+  ])('iterated AFTER the declared cell, a legacy cell holding %s leaves the array in place', async (_, legacy) => {
+    const serializer = new RecordSerializer<Member>(memberTable);
+    const warnings = warningsOf(serializer);
+
+    const [record] = await serializer.deserializeAll([rowOf({ name: 'm', tag_list: '["a","b"]', tags: legacy })]);
+
+    expect(record.tags).toEqual(['a', 'b']);
+    expect(record).toMatchObject({ id: 'm1', name: 'm' });
+    // The legacy cell never reached the array column's parser: no cell-omitted warning.
+    expect(warnings).toHaveLength(0);
+  });
+
+  test.each([
+    ['a bare word', LEGACY_WORD],
+    ['an empty string', ''],
+    ['NULL', null],
+  ])('iterated BEFORE the declared cell, a legacy cell holding %s leaves the array in place', async (_, legacy) => {
+    const serializer = new RecordSerializer<Member>(memberTable);
+    const warnings = warningsOf(serializer);
+
+    const [record] = await serializer.deserializeAll([rowOf({ name: 'm', tags: legacy, tag_list: '["a","b"]' })]);
+
+    expect(record.tags).toEqual(['a', 'b']);
+    expect(warnings).toHaveLength(0);
+  });
+
+  test('a stored key equal to a column name is that column; the property name alone is nobody', async () => {
+    const fieldSerializer = new FieldSerializer<Member>(memberTable);
+
+    const seated = await fieldSerializer.deserialize('tag_list', '["a"]', {});
+    expect(seated).toEqual({ fieldPropertyName: 'tags', fieldValue: ['a'] });
+
+    await expect(fieldSerializer.deserialize('tags', LEGACY_WORD, {})).rejects.toBeInstanceOf(MissingFieldError);
+  });
+});
+
+describe('two declared columns sharing one stored name', () => {
+  test('is refused at the first hydration, naming the table and both properties', () => {
+    interface Twice extends Record {
+      first: string;
+      second: string;
+    }
+    class TwiceTable extends Table<Twice> {
+      public name = 'seating_twice';
+      public columns = withRecordColumns<Twice>({
+        first: new StringColumn('shared'),
+        second: new StringColumn('shared'),
+      });
+    }
+    const serializer = new RecordSerializer<Twice>(new TwiceTable() as Table<Twice>);
+
+    expect(() => serializer.deserializeAll([rowOf({ shared: 'x' })])).toThrow(DuplicateColumnNameError);
+    expect(() => serializer.deserializeAll([rowOf({ shared: 'x' })])).toThrow(
+      `(seating_twice) Columns first and second both declare the column name 'shared'`
+    );
+  });
+});
+
+describe('the write side', () => {
+  class RefusingColumn implements Column<string, string> {
+    constructor(public name: string) {}
+
+    async serialize(): Promise<string> {
+      throw new RangeError('cannot be stored');
+    }
+  }
+  interface Note extends Record {
+    title: string;
+    body: string;
+  }
+  class NoteTable extends Table<Note> {
+    public name = 'seating_note';
+    public columns = withRecordColumns<Note>({
+      title: new StringColumn('title'),
+      body: new RefusingColumn('body'),
+    });
+  }
+  const noteTable = new NoteTable() as Table<Note>;
+
+  test('a column that cannot serialize its value fails the write with that error', async () => {
+    const serializer = new RecordSerializer<Note>(noteTable);
+    const warnings = warningsOf(serializer);
+
+    await expect(serializer.serialize({ id: 'n1', title: 't', body: 'b' })).rejects.toThrow(
+      new RangeError('cannot be stored')
+    );
+    expect(warnings).toHaveLength(0);
+  });
+
+  test('a field no column owns is omitted from the write, and warned', async () => {
+    const serializer = new RecordSerializer<Member>(memberTable);
+    const warnings = warningsOf(serializer);
+
+    const serialized = await serializer.serialize({ id: 'm1', name: 'm', tags: ['a'], retired: 'gone' });
+
+    expect(Object.keys(serialized)).toEqual(['id', 'name', 'tag_list']);
+    expect(JSON.parse(serialized.tag_list)).toEqual(['a']);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0][0]).toMatchObject({ obj: { omittedFields: ['retired'] } });
+  });
+});