@proteinjs/db 1.47.3 → 1.49.0

package/src/transaction/TransactionRunner.ts

@@ -1,10 +1,32 @@
-import { getDb } from '../Db';
-import { TransactionRunnerService, getTransactionRunnerService } from '../services/TransactionRunnerService';
+import { Logger } from '@proteinjs/logger';
+import { Db, getDb } from '../Db';
+import { Table, tableByName } from '../Table';
+import { getDefaultTransactionContextFactory } from './TransactionContextFactory';
+import {
+  TransactionRunnerService,
+  TransactionRunOptions,
+  getTransactionRunnerService,
+} from '../services/TransactionRunnerService';
 import { Operation } from './Transaction';
 
 export const getTransactionRunner = () =>
   typeof self === 'undefined' ? new TransactionRunner() : (getTransactionRunnerService() as TransactionRunner);
 
+/**
+ * Runs a client `Transaction`'s operations as one server-side transaction.
+ *
+ * A write may DECLARE the rows it depends on (`options.afterRows`): rows its operations
+ * reference whose own insert may still be in flight when this request arrives — a text update
+ * released by a page that was going away while its row's insert was still being served, a child
+ * row's insert whose root (its permission source, and the owner grant that commits with the
+ * root) is still landing. Without the declaration such a write ran to completion inside the
+ * insert's window and matched nothing, silently, or was refused at the door for a grant that was
+ * a moment from existing — and the page that could have retried was gone. The server outlives
+ * the page: it waits, bounded by the db driver's per-operation deadline, for every declared row to
+ * exist AND be visible to the caller (a read as the caller sees a row exactly when the caller's
+ * grant on its scope has committed), then runs the operations. A row that never appears fails the
+ * request with a plain clause.
+ */
 export class TransactionRunner implements TransactionRunnerService {
   public serviceMetadata = {
     auth: {
@@ -12,8 +34,17 @@ export class TransactionRunner implements TransactionRunnerService {
     },
   };
 
-  async run(ops: Operation<any>[]): Promise<void> {
+  private static readonly FIRST_POLL_INTERVAL_MS = 25;
+  private static readonly MAX_POLL_INTERVAL_MS = 250;
+
+  private logger = new Logger({ name: this.constructor.name });
+
+  async run(ops: Operation<any>[], options?: TransactionRunOptions): Promise<void> {
     const db = getDb();
+    const afterRows = options?.afterRows ?? [];
+    if (afterRows.length > 0) {
+      await this.awaitRows(ops, afterRows);
+    }
 
     await db.runTransaction(async () => {
       for (const op of ops) {
@@ -21,4 +52,144 @@ export class TransactionRunner implements TransactionRunnerService {
       }
     });
   }
+
+  /**
+   * Wait until every declared row exists and is visible to the caller, bounded by the db driver's
+   * per-operation deadline (`DbDriver.getOperationDeadlineMs`), read when the write waits. The
+   * bound is the ceiling for a row that NEVER comes — the named failure, never a hang. A
+   * dependency's insert lands in hundreds of milliseconds on a healthy link and in seconds on a
+   * degraded one (a root's birth of a few dozen sequential statements has taken 13 s), and the
+   * writes released behind it by a page that is gone have no second chance. The driver's deadline
+   * is how long the deployment lets one statement of that insert run before failing it: the wait
+   * takes its measure from there — one owner for the number, configured with the database — not
+   * from a number of its own. A write that waits here holds one request and a poll, nothing else.
+   *
+   * Each poll is a single-use strong read outside any transaction, so a commit is seen the moment
+   * it lands; the interval starts short and backs off so a dependency landing in hundreds of
+   * milliseconds is caught within tens.
+   */
+  private async awaitRows(ops: Operation<any>[], afterRows: string[]): Promise<void> {
+    if (getDefaultTransactionContextFactory()?.getTransactionContext().currentTransaction) {
+      throw new Error(
+        `TransactionRunner: afterRows cannot be honoured inside an ambient transaction — its reads would see the transaction's own snapshot, never a row committed after it began`
+      );
+    }
+
+    const tablesById = TransactionRunner.rowsTheOperationsReference(ops);
+    const unknown = afterRows.filter((id) => !tablesById.has(id));
+    if (unknown.length > 0) {
+      throw new Error(
+        `TransactionRunner: afterRows names rows none of the operations reference (${unknown.join(', ')}) — the write was not run`
+      );
+    }
+
+    const db = getDb();
+    const boundMs = Db.getDefaultDbDriver().getOperationDeadlineMs();
+    const started = Date.now();
+    const deadline = started + boundMs;
+    /** Per declared id, the (table, id) rows still absent. */
+    let waiting: { id: string; tables: Table<any>[] }[] = afterRows
+      .filter((id, index) => afterRows.indexOf(id) === index)
+      .map((id) => ({ id, tables: tablesById.get(id)!.slice() }));
+    let interval = TransactionRunner.FIRST_POLL_INTERVAL_MS;
+    let polls = 0;
+    for (;;) {
+      polls += 1;
+      for (const row of waiting) {
+        const stillAbsent: Table<any>[] = [];
+        for (const table of row.tables) {
+          if (!(await db.get(table, { id: row.id } as any))) {
+            stillAbsent.push(table);
+          }
+        }
+        row.tables = stillAbsent;
+      }
+      waiting = waiting.filter((row) => row.tables.length > 0);
+      if (waiting.length === 0) {
+        const waitedMs = Date.now() - started;
+        // One line when the seam did work (the row landed while this write waited); a row that
+        // was already there is the common case and stays quiet.
+        const line = { message: `Declared rows present`, obj: { afterRows, waitedMs, polls } };
+        if (polls > 1) {
+          this.logger.info(line);
+        } else {
+          this.logger.debug(line);
+        }
+        return;
+      }
+
+      const now = Date.now();
+      if (now >= deadline) {
+        const absent = waiting.map((row) => row.tables.map((table) => `${table.name}:${row.id}`).join(', ')).join(', ');
+        this.logger.warn({
+          message: `Declared rows absent at the bound — the write was not run`,
+          obj: { absent, boundMs, waitedMs: now - started, polls },
+        });
+        throw new Error(
+          `TransactionRunner: waited ${boundMs} ms for rows this write depends on to exist and be visible to the caller; still absent: ${absent} — the write was not run (the bound is the db driver's per-operation deadline)`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(interval, deadline - now)));
+      interval = Math.min(interval * 2, TransactionRunner.MAX_POLL_INTERVAL_MS);
+    }
+  }
+
+  /**
+   * The rows the operations reference, by id → the table(s) they are read from: the permission
+   * source a row attaches to (an insert whose `permissionSource` is another row), the row an
+   * update / preserving update / membership update / delete targets. The rows the operations
+   * insert themselves are not dependencies.
+   */
+  private static rowsTheOperationsReference(ops: Operation<any>[]): Map<string, Table<any>[]> {
+    const inserted: string[] = [];
+    const referenced = new Map<string, Table<any>[]>();
+    const reference = (table: Table<any> | undefined, id: unknown) => {
+      if (!table || typeof id !== 'string') {
+        return;
+      }
+      let tables = referenced.get(id);
+      if (!tables) {
+        tables = [];
+        referenced.set(id, tables);
+      }
+      if (tables.indexOf(table) === -1) {
+        tables.push(table);
+      }
+    };
+
+    for (const op of ops) {
+      const args = op.args as unknown[];
+      const table = args[0] as Table<any> | undefined;
+      if (op.name === 'insert') {
+        const record = args[1] as
+          | { id?: string; permissionSource?: { _table?: string; _id?: string }; permissionSourceTable?: string }
+          | undefined;
+        if (record?.id) {
+          inserted.push(record.id);
+        }
+        const source = record?.permissionSource;
+        if (source?._id && source._id !== record?.id) {
+          const sourceTableName = record?.permissionSourceTable ?? source._table;
+          reference(sourceTableName ? TransactionRunner.tableNamed(sourceTableName, table) : table, source._id);
+        }
+      } else if (op.name === 'update' || op.name === 'updatePreserving') {
+        const record = args[1] as { id?: string } | undefined;
+        const query = args[2] as { id?: unknown } | undefined;
+        reference(table, record?.id ?? (query && typeof query === 'object' && 'id' in query ? query.id : undefined));
+      } else if (op.name === 'updateArrayMembership') {
+        reference(table, (args[1] as { recordId?: string } | undefined)?.recordId);
+      } else if (op.name === 'delete') {
+        const query = args[1] as { id?: unknown } | undefined;
+        reference(table, query && typeof query === 'object' ? query.id : undefined);
+      }
+    }
+
+    inserted.forEach((id) => referenced.delete(id));
+    return referenced;
+  }
+
+  /** The table a permission source lives in: the insert's own table when it names the same one. */
+  private static tableNamed(tableName: string, inserting: Table<any> | undefined): Table<any> {
+    return inserting && inserting.name === tableName ? inserting : tableByName(tableName);
+  }
 }

package/test/DurableTable.test.ts

@@ -0,0 +1,156 @@
+import { UserAuth } from '@proteinjs/user-auth';
+import { Table } from '../src/Table';
+import { withRecordColumns, Record } from '../src/Record';
+import { StringColumn } from '../src/Columns';
+import { TableAuth } from '../src/auth/TableAuth';
+import { TableServiceAuth } from '../src/auth/TableServiceAuth';
+import { MigrationTable } from '../src/tables/MigrationTable';
+
+/**
+ * A DURABLE table (`Table.durable`) keeps its rows: the delete door is closed on both apis for
+ * every caller — break-glass included, whatever `auth` declares — and the refusal is a typed 403
+ * that names the table. Everything else about the table's doors is unchanged, and a table that
+ * does not declare it keeps its delete doors exactly as declared.
+ *
+ * The house's rule: the migration ledger's rows could be selected and deleted from the record
+ * table in a deployment — they are durable records; the migration table declares it.
+ *
+ * `UserAuth` reads from a static repo; tests stub it directly per identity — no server needed.
+ */
+
+type UserAuthInternals = {
+  userRepo?: { getUser: () => { email: string; roles: string[] } };
+  permissionRolesMapping?: { getRoles: (permission: string) => string[] | undefined };
+};
+
+const setUser = (roles: string[]) => {
+  (UserAuth as unknown as UserAuthInternals).userRepo = {
+    getUser: () => ({ email: 'user@test.local', roles }),
+  };
+};
+
+const setMapping = (mapping: { [permission: string]: string[] }) => {
+  (UserAuth as unknown as UserAuthInternals).permissionRolesMapping = {
+    getRoles: (permission: string) => mapping[permission],
+  };
+};
+
+interface Entry extends Record {
+  title: string;
+}
+
+/** Every door open to the 'ledger' permission — the delete door included. */
+class OpenLedgerTable extends Table<Entry> {
+  public name = 'open_ledger_test';
+  public auth: Table<Entry>['auth'] = {
+    db: { all: { permission: 'ledger' } },
+    service: { all: { permission: 'ledger' } },
+  };
+  public columns = withRecordColumns<Entry>({
+    title: new StringColumn('title'),
+  });
+}
+
+/** The same doors, declared durable: the declared delete doors do not reopen what durability closes. */
+class DurableLedgerTable extends OpenLedgerTable {
+  public name = 'durable_ledger_test';
+  public durable = true;
+}
+
+/** Durable with no auth block at all: admin's break-glass default does not reach delete either. */
+class DurableNoAuthTable extends Table<Entry> {
+  public name = 'durable_no_auth_test';
+  public durable = true;
+  public columns = withRecordColumns<Entry>({
+    title: new StringColumn('title'),
+  });
+}
+
+/** What the refusal is, read by shape (the router reads a `ServiceRefusal` the same way). */
+const refusalOf = (act: () => unknown): { name?: string; status?: number; message?: string } | undefined => {
+  try {
+    act();
+  } catch (error: any) {
+    return { name: error?.name, status: error?.status, message: error?.message };
+  }
+  return undefined;
+};
+
+describe('a durable table keeps its rows', () => {
+  beforeEach(() => {
+    setMapping({ ledger: ['ledger-keeper'] });
+  });
+
+  afterEach(() => {
+    (UserAuth as unknown as UserAuthInternals).userRepo = undefined;
+    (UserAuth as unknown as UserAuthInternals).permissionRolesMapping = undefined;
+  });
+
+  it('the delete door refuses every caller on both apis — a 403 refusal naming the table, whatever auth declares', () => {
+    const auth = new TableAuth();
+    for (const table of [new DurableLedgerTable(), new DurableNoAuthTable()]) {
+      for (const roles of [['ledger-keeper'], ['admin']]) {
+        setUser(roles);
+        for (const api of ['db', 'service'] as const) {
+          const refusal = refusalOf(() => auth.canDelete(table, api));
+          expect(refusal).toEqual({
+            name: 'ServiceRefusal',
+            status: 403,
+            message: `Table ${table.name} is durable: its rows are never deleted`,
+          });
+          // The capability read the record surfaces derive their acts from agrees with the door.
+          expect(auth.canPerform(table, 'delete', api)).toBe(false);
+        }
+      }
+    }
+  });
+
+  it('the service door passes the refusal to the caller as it is — not a generic denial, not a failure', () => {
+    setUser(['admin']);
+    const table = new DurableLedgerTable();
+    const refusal = refusalOf(() => new TableServiceAuth().canAccess('delete', [table, { id: 'entry-1' }]));
+    expect(refusal).toEqual({
+      name: 'ServiceRefusal',
+      status: 403,
+      message: 'Table durable_ledger_test is durable: its rows are never deleted',
+    });
+  });
+
+  it('the durable table keeps every other door it declares', () => {
+    setUser(['ledger-keeper']);
+    const auth = new TableAuth();
+    const table = new DurableLedgerTable();
+    for (const api of ['db', 'service'] as const) {
+      expect(() => auth.canQuery(table, api)).not.toThrow();
+      expect(() => auth.canInsert(table, api)).not.toThrow();
+      expect(() => auth.canUpdate(table, api)).not.toThrow();
+    }
+    expect(new TableServiceAuth().canAccess('query', [table, {}])).toBe(true);
+    expect(new TableServiceAuth().canAccess('update', [table, { id: 'entry-1', title: 't' }])).toBe(true);
+  });
+
+  it('a table that does not declare it keeps its delete doors exactly as declared', () => {
+    const auth = new TableAuth();
+    const table = new OpenLedgerTable();
+
+    setUser(['ledger-keeper']);
+    for (const api of ['db', 'service'] as const) {
+      expect(() => auth.canDelete(table, api)).not.toThrow();
+      expect(auth.canPerform(table, 'delete', api)).toBe(true);
+    }
+    expect(new TableServiceAuth().canAccess('delete', [table, { id: 'entry-1' }])).toBe(true);
+
+    setUser(['someone-else']);
+    expect(() => auth.canDelete(table, 'service')).toThrow(
+      'User is not authorized to delete records from table: open_ledger_test'
+    );
+  });
+
+  it('the migration ledger is durable', () => {
+    setUser(['admin']);
+    const table = new MigrationTable();
+    const refusal = refusalOf(() => new TableServiceAuth().canAccess('delete', [table, { id: 'migration-1' }]));
+    expect(refusal?.status).toBe(403);
+    expect(refusal?.message).toBe('Table migration is durable: its rows are never deleted');
+  });
+});

package/test/MigrationAuth.test.ts

@@ -100,13 +100,15 @@ describe('migrations ride the dev permission', () => {
     }
   });
 
-  it('delete keeps its dev door (ledger hygiene stays possible)', () => {
-    setUser(['dev-crew']);
+  it('delete has no door — for anyone, break-glass included: the ledger is durable', () => {
     const auth = new TableAuth();
     const table = new MigrationTable();
-    for (const api of ['db', 'service'] as const) {
-      expect(() => auth.canDelete(table, api)).not.toThrow();
-      expect(auth.canPerform(table, 'delete', api)).toBe(true);
+    for (const roles of [['dev-crew'], ['admin']]) {
+      setUser(roles);
+      for (const api of ['db', 'service'] as const) {
+        expect(() => auth.canDelete(table, api)).toThrow('Table migration is durable: its rows are never deleted');
+        expect(auth.canPerform(table, 'delete', api)).toBe(false);
+      }
     }
   });
 });

package/test/SchemaReconcileLines.test.ts

@@ -0,0 +1,127 @@
+import { inspect } from 'util';
+import { Logger, LogLineErrors } from '@proteinjs/logger';
+import { TableManager } from '../src/schema/TableManager';
+import { TableChanges } from '../src/schema/SchemaOperations';
+import { Table } from '../src/Table';
+
+/**
+ * The schema-reconcile WARN lines (`TableManager.reconcileConcurrentSchemaChange`) carry the
+ * error a driver rejected with — never text copied out of it.
+ *
+ * A backend words a schema error itself and can quote row data in it (a unique index whose
+ * backfill meets duplicate rows names the duplicate key). A driver marks such an error so the
+ * logger prints its status and the driver's sentence in its place (`LogLineErrors`) — which the
+ * logger can only do for the error OBJECT. These lines used to interpolate the error's `details`
+ * / `message` into their own message, where nothing can recognize it.
+ *
+ * Judged at the log WRITER, as the text a writer would print, for each of the three outcomes
+ * that log: tolerated, still absent, a genuine conflict.
+ */
+
+// A fixture value shaped like row content (not a real credential).
+const VALUE = 'rst_reconcile_5d41402abc4b2a76b9719d911017c592';
+const SENTENCE =
+  'Failed when executing schema update (ALREADY_EXISTS, code 6): what the statement creates already exists';
+
+type CapturedLog = { logLevel: string; message?: string; obj?: any };
+type ManagerInternals = {
+  logger: Logger;
+  reconcileConcurrentSchemaChange(tables: Table<any>[], error: unknown): Promise<void>;
+  getTableChanges(table: Table<any>): Promise<TableChanges>;
+  delay(ms: number): Promise<void>;
+};
+
+const noChanges = (): TableChanges =>
+  ({
+    columnsToCreate: [],
+    columnsToRename: [],
+    columnsToAlter: [],
+    columnsWithForeignKeysToDrop: [],
+    columnsWithUniqueConstraintsToDrop: [],
+    indexesToCreate: [],
+    indexesToDrop: [],
+  }) as unknown as TableChanges;
+
+/** What a driver rejects with when the backend refuses a schema change — marked, as a driver marks it. */
+const backendError = () => {
+  const message = `6 ALREADY_EXISTS: Duplicate name in schema: ledger_by_email. duplicate key: {String("${VALUE}")}`;
+  const error = Object.assign(new Error(message), { code: 6, details: message });
+  LogLineErrors.mark(error, () => ({ code: 6, sentence: SENTENCE, facts: { status: 'ALREADY_EXISTS' } }));
+  return error;
+};
+
+const printedLine = (log: CapturedLog) =>
+  [log.message ?? '', inspect(log.obj, { depth: 10, maxStringLength: null }), JSON.stringify(log.obj) ?? ''].join('\n');
+
+describe('the schema-reconcile lines carry the error itself, never its text', () => {
+  const table = { name: 'ledger' } as Table<any>;
+  let captured: CapturedLog[];
+
+  const managerWhere = (live: { exists: boolean; changes: TableChanges }) => {
+    const manager = new TableManager(
+      {} as never,
+      {} as never,
+      { isAlreadyExistsError: () => true } as never,
+      { tableExists: async () => live.exists } as never
+    );
+    const internals = manager as unknown as ManagerInternals;
+    internals.logger = new Logger({
+      name: 'TableManager',
+      logWriter: { write: (log: CapturedLog) => captured.push(log) } as never,
+    });
+    internals.getTableChanges = async () => live.changes;
+    internals.delay = async () => undefined;
+    return internals;
+  };
+
+  beforeEach(() => {
+    captured = [];
+  });
+
+  const expectTheErrorNotItsText = (line: CapturedLog, error: Error) => {
+    expect(error.message).toContain(VALUE);
+    expect(printedLine(line)).not.toContain(VALUE);
+    expect(printedLine(line)).not.toContain('Duplicate name in schema');
+    expect(line.obj.error).toBeInstanceOf(Error);
+    expect(line.obj.error.message).toBe(SENTENCE);
+    expect(line.message).toContain('ledger');
+  };
+
+  test('tolerated: the table is there with the intended definition', async () => {
+    const error = backendError();
+
+    await managerWhere({ exists: true, changes: noChanges() }).reconcileConcurrentSchemaChange([table], error);
+
+    expect(captured).toHaveLength(1);
+    expect(captured[0].message).toContain('tolerated concurrent ALREADY_EXISTS');
+    expectTheErrorNotItsText(captured[0], error);
+  });
+
+  test('still absent after every re-read: the original error is thrown as it is', async () => {
+    const error = backendError();
+
+    const thrown = await managerWhere({ exists: false, changes: noChanges() })
+      .reconcileConcurrentSchemaChange([table], error)
+      .catch((each: unknown) => each);
+
+    expect(thrown).toBe(error);
+    expect(captured).toHaveLength(1);
+    expect(captured[0].message).toContain('still absent');
+    expectTheErrorNotItsText(captured[0], error);
+  });
+
+  test('a genuine conflict: the live schema differs from the intended definition', async () => {
+    const error = backendError();
+    const changes = { ...noChanges(), columnsToCreate: ['email'] } as unknown as TableChanges;
+
+    const thrown = await managerWhere({ exists: true, changes })
+      .reconcileConcurrentSchemaChange([table], error)
+      .catch((each: unknown) => each);
+
+    expect(thrown).toBe(error);
+    expect(captured).toHaveLength(1);
+    expect(captured[0].message).toContain('genuine conflict');
+    expect(captured[0].obj.remainingChanges).toEqual(changes);
+    expectTheErrorNotItsText(captured[0], error);
+  });
+});

package/test/SourceRecordLoaderQualifiedName.test.ts

@@ -0,0 +1,63 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { SourceType } from '@proteinjs/reflection';
+import { graphSerializer } from '@proteinjs/util';
+
+/**
+ * `@proteinjs/db/SourceRecordLoader` is the qualified name every source-record declaration
+ * implements (`class X implements SourceRecordLoader<T>`) and the name `getSourceRecordLoaders`
+ * resolves through the reflection registry. The generated index keeps ONE node per qualified
+ * name, so a second declaration of the name anywhere in the package's reflected sources leaves
+ * which one the artifact records to the build's file order — and the loser disappears without
+ * a trace. These tests read the artifacts the build wrote (`generated/index.ts` for the package
+ * entry, `generated/test/index.ts` for the `./test` subpath, both built from `src/`) and assert
+ * the name holds the declaration interface, not some other declaration that shares it.
+ */
+const QUALIFIED_NAME = '@proteinjs/db/SourceRecordLoader';
+const ARTIFACTS = ['generated/index.ts', 'generated/test/index.ts'];
+
+/** The fields of an emitted node value these tests read. */
+type EmittedDeclaration = { packageName: string; name: string; qualifiedName: string; sourceType: SourceType };
+type EmittedEdge = { v: string; w: string };
+
+const readArtifact = (relativePath: string) => fs.readFileSync(path.join(__dirname, '..', relativePath), 'utf8');
+
+/** The source graph exactly as the generated index hands it to `SourceRepository.merge`. */
+const emittedGraph = (artifact: string) => {
+  const literal = artifact.match(/^const sourceGraph = (".*");$/m);
+  if (!literal) {
+    throw new Error('generated index carries no serialized source graph');
+  }
+  const serialized: string = JSON.parse(literal[1]);
+  return graphSerializer.deserialize(serialized.replace(/\\'/g, "'"));
+};
+
+describe.each(ARTIFACTS)('the qualified name SourceRecordLoader in %s', (relativePath) => {
+  const artifact = readArtifact(relativePath);
+  const graph = emittedGraph(artifact);
+
+  it('names exactly one declaration of this package: the interface declarations implement', () => {
+    const qualifiedNames: string[] = graph.nodes();
+    const declarations = qualifiedNames
+      .map((qualifiedName): EmittedDeclaration | undefined => graph.node(qualifiedName))
+      .filter((node) => node?.packageName === '@proteinjs/db' && node.name === 'SourceRecordLoader');
+
+    expect(declarations).toHaveLength(1);
+    expect(declarations[0]).toMatchObject({
+      qualifiedName: QUALIFIED_NAME,
+      sourceType: SourceType.interface,
+      filePath: 'src/source/SourceRecord.ts',
+    });
+    const parents: EmittedEdge[] = graph.outEdges(QUALIFIED_NAME) ?? [];
+    expect(parents.map((edge) => [edge.w, graph.edge(edge)])).toEqual([
+      ['@proteinjs/reflection/Loadable', 'extends interface'],
+    ]);
+  });
+
+  it('links no runtime value under the name (an interface has none)', () => {
+    const linkedNames = (artifact.match(/^\t'[^']+': /gm) ?? []).map((line) => line.slice(2, -3));
+
+    expect(linkedNames).toContain('@proteinjs/db/MigrationRunner');
+    expect(linkedNames).not.toContain(QUALIFIED_NAME);
+  });
+});