|
| 1 | +// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license. |
| 2 | + |
| 3 | +/** |
| 4 | + * [#16570] `initObjects` and `registerObjectMetadata` accept `indexes` — the |
| 5 | + * key they have always READ — spelled as a **fresh object literal**. |
| 6 | + * |
| 7 | + * ## The defect this pins |
| 8 | + * |
| 9 | + * Both entry points declared `Array<{ name; fields?; tenancy? }>`, with no |
| 10 | + * `indexes`. The key was read one call deep anyway, through an `as any`, in |
| 11 | + * `registerManagedObjectMetadata`: |
| 12 | + * |
| 13 | + * ```ts |
| 14 | + * this.managedObjectIndexes.set(tableName, (obj as any).indexes); |
| 15 | + * ``` |
| 16 | + * |
| 17 | + * and `managedObjectIndexes` is what `syncDeclaredIndexes` renders every |
| 18 | + * declared UNIQUE from — so the driver's whole index-sync path was driven by a |
| 19 | + * key its own signature said did not exist. `detectManagedDrift`, on the same |
| 20 | + * class, had always declared `indexes?: any[]`: the two halves of one class |
| 21 | + * disagreed about the shape of the same input. That is the shape #4311 already |
| 22 | + * fixed for `tenancy`, and the comment it left above `initObjects` described |
| 23 | + * `indexes` word for word. |
| 24 | + * |
| 25 | + * ## Why the FORM of this pin is the whole point |
| 26 | + * |
| 27 | + * TypeScript's excess-property check fires on a **fresh object literal** and |
| 28 | + * not on one bound to a variable first, so the same object was accepted or |
| 29 | + * rejected by where it was spelled: |
| 30 | + * |
| 31 | + * ```ts |
| 32 | + * await driver.initObjects([{ ...bare, indexes: [] }]); // TS2353 |
| 33 | + * const withoutIndex = { ...bare, indexes: [] }; |
| 34 | + * await driver.initObjects([withoutIndex]); // accepted |
| 35 | + * ``` |
| 36 | + * |
| 37 | + * Every existing caller in this package happened to bind first — one of them |
| 38 | + * (`sql-driver-11794-richtext-text-family.test.ts`) even wrote the workaround |
| 39 | + * down: *"Hoisted (not an inline literal) … `indexes` rides through |
| 40 | + * `initObjects` beyond its narrow parameter type"*. So the package typechecked |
| 41 | + * green for a reason unrelated to correctness, and a **variable-bound pin |
| 42 | + * cannot go red on this defect** — it measures nothing. Every call below is |
| 43 | + * therefore an inline literal in argument position, which is what makes |
| 44 | + * `tsc --noEmit` (this package's `typecheck` script) the instrument that |
| 45 | + * measures it: revert either signature and these lines stop compiling with |
| 46 | + * |
| 47 | + * TS2353: Object literal may only specify known properties, and 'indexes' |
| 48 | + * does not exist in type '{ name: string; fields?: Record<string, any> |
| 49 | + * | undefined; tenancy?: any; }'. |
| 50 | + * |
| 51 | + * The runtime assertions are the other half: they prove the key is not merely |
| 52 | + * *admitted* by the type but still *read* — recorded in `managedObjectIndexes` |
| 53 | + * (§1), rendered into a physical UNIQUE (§2), and cleared when withdrawn (§3). |
| 54 | + * A signature relaxation that quietly stopped reading the key would pass the |
| 55 | + * compile leg alone. |
| 56 | + * |
| 57 | + * Runs on the always-available in-memory SQLite cell: the defect is in a |
| 58 | + * parameter type and in the registry it feeds, neither of which is |
| 59 | + * dialect-specific. |
| 60 | + */ |
| 61 | + |
| 62 | +import { describe, it, expect, afterEach } from 'vitest'; |
| 63 | +import { SqlDriver } from './sql-driver.js'; |
| 64 | +import { dialectCell } from './live-dialect-matrix.testkit.js'; |
| 65 | + |
| 66 | +const SQLITE = dialectCell('sqlite'); |
| 67 | + |
| 68 | +/** |
| 69 | + * The un-indexed base object, deliberately WITHOUT `indexes` — every call site |
| 70 | + * below spreads it and writes `indexes` inline, so the literal being checked is |
| 71 | + * fresh in argument position. `tenancy: { enabled: false }` keeps the declared |
| 72 | + * UNIQUE on the plain (non-tenant-scoped) path, and the bounded `maxLength` |
| 73 | + * keeps `v` a keyable varchar rather than an unbounded TEXT. |
| 74 | + */ |
| 75 | +const bareObject = (name: string) => ({ |
| 76 | + name, |
| 77 | + tenancy: { enabled: false }, |
| 78 | + fields: { v: { type: 'text', maxLength: 64 } }, |
| 79 | +}); |
| 80 | + |
| 81 | +/** What the driver recorded for `table`, read off the protected registry. */ |
| 82 | +const recordedIndexes = (driver: SqlDriver, table: string): unknown => |
| 83 | + (driver as unknown as { managedObjectIndexes: Map<string, unknown> }).managedObjectIndexes.get(table); |
| 84 | + |
| 85 | +describe('initObjects / registerObjectMetadata accept `indexes` as a fresh object literal (#16570)', () => { |
| 86 | + let driver: SqlDriver | undefined; |
| 87 | + afterEach(async () => { |
| 88 | + await driver?.disconnect().catch(() => {}); |
| 89 | + driver = undefined; |
| 90 | + }); |
| 91 | + |
| 92 | + it('§1 registerObjectMetadata: the inline literal compiles AND the key is recorded', async () => { |
| 93 | + const T = 'os16570_register'; |
| 94 | + driver = new SqlDriver(SQLITE.config()); |
| 95 | + const declared = [{ fields: ['v'], unique: true as const, name: `uniq_${T}_v` }]; |
| 96 | + |
| 97 | + // Fresh literal in argument position — not hoisted to a variable first. |
| 98 | + driver.registerObjectMetadata([{ ...bareObject(T), indexes: declared }]); |
| 99 | + |
| 100 | + expect(recordedIndexes(driver, T)).toEqual(declared); |
| 101 | + }); |
| 102 | + |
| 103 | + it('§2 initObjects: the inline literal compiles AND the declared UNIQUE is physically synced', async () => { |
| 104 | + const T = 'os16570_init'; |
| 105 | + driver = new SqlDriver(SQLITE.config()); |
| 106 | + |
| 107 | + // Fresh literal in argument position. |
| 108 | + await driver.initObjects([ |
| 109 | + { ...bareObject(T), indexes: [{ fields: ['v'], unique: true as const, name: `uniq_${T}_v` }] }, |
| 110 | + ]); |
| 111 | + |
| 112 | + const knex = (driver as unknown as { knex: (t: string) => any }).knex; |
| 113 | + await knex(T).insert({ id: 'a', v: 'same' }); |
| 114 | + // If `indexes` had been dropped at authoring time — the silent failure mode |
| 115 | + // this card is about — this second row would be accepted. |
| 116 | + await expect(knex(T).insert({ id: 'b', v: 'same' })).rejects.toThrow(); |
| 117 | + }); |
| 118 | + |
| 119 | + it('§3 initObjects: the exact `{ ...bare, indexes: [] }` spelling from the card compiles, and withdraws the entry', async () => { |
| 120 | + const T = 'os16570_withdraw'; |
| 121 | + driver = new SqlDriver(SQLITE.config()); |
| 122 | + const bare = bareObject(T); |
| 123 | + |
| 124 | + await driver.initObjects([{ ...bare, indexes: [{ fields: ['v'], unique: true as const, name: `uniq_${T}_v` }] }]); |
| 125 | + expect(recordedIndexes(driver, T)).toHaveLength(1); |
| 126 | + |
| 127 | + // The spelling named in the card, verbatim: an empty array must CLEAR the |
| 128 | + // entry, not leave the previous one standing. |
| 129 | + await driver.initObjects([{ ...bare, indexes: [] }]); |
| 130 | + expect(recordedIndexes(driver, T)).toEqual([]); |
| 131 | + }); |
| 132 | +}); |
0 commit comments