@quereus/store 4.5.0 → 4.7.0

package/dist/src/common/store-module-index.js

@@ -0,0 +1,373 @@
+/**
+ * CREATE INDEX / DROP INDEX over a store-backed table, and the physical index stores
+ * they bring into (and out of) existence — including the hidden `_uc_*` stores that
+ * back a plain UNIQUE constraint, whose set is reconciled against the schema after
+ * every DDL that can change it.
+ *
+ * Fourth layer of the store-module chain:
+ *   StoreModuleBase -> StoreModuleCatalog -> StoreModuleSchemaSync -> StoreModuleIndex
+ *   -> StoreModuleAlterColumn -> StoreModuleAlter -> StoreModuleRename -> StoreModule
+ */
+import { QuereusError, StatusCode, appendIndexToTableSchema, generateDropIndexDDL, generateIndexDDL, } from '@quereus/quereus';
+import { findReusableIndexForUnique, implicitUniqueIndexName } from './implicit-unique-index.js';
+import { buildFullScanBounds, buildIndexStoreName } from './key-builder.js';
+import { StoreModuleSchemaSync } from './store-module-schema-sync.js';
+import { DEFAULT_MAX_BATCH_BYTES } from './store-module-base.js';
+import { buildIndexEntries, validateUniqueIndexOverRows } from './store-module-index-build.js';
+/**
+ * Map of `lowercased implicit index name → actual name` for every NON-DERIVED
+ * UNIQUE constraint of `schema` that needs a `_uc_*` of its own — the set of
+ * `_uc_*` stores that SHOULD exist for that schema. The diff of two such maps
+ * drives {@link reconcileImplicitUniqueIndexStores}.
+ *
+ * Reads `uniqueConstraints` for the NAMES (so it is correct whether or not
+ * `schema` is materialized) and `.indexes` for the REUSE decision, exactly as
+ * `withImplicitUniqueIndexes` does — the two must agree, or the reconcile would
+ * build a store no DML maintains, or tear down one that is still being seeked.
+ * A UC realized by an explicit index (`findReusableIndexForUnique`) contributes
+ * no entry, which is what makes `create index` / `drop index` over a constrained
+ * column a teardown / rebuild transition rather than a no-op.
+ */
+function implicitUniqueIndexNameMap(schema) {
+    const map = new Map();
+    for (const uc of schema.uniqueConstraints ?? []) {
+        if (uc.derivedFromIndex)
+            continue;
+        if (findReusableIndexForUnique(schema, uc))
+            continue;
+        const name = implicitUniqueIndexName(schema, uc);
+        map.set(name.toLowerCase(), name);
+    }
+    return map;
+}
+export class StoreModuleIndex extends StoreModuleSchemaSync {
+    /**
+     * Creates an index on a store-backed table.
+     *
+     * `rows` — an {@link EffectiveRowSource} supplied by a wrapper module (the isolation
+     * layer) — replaces this module's own rows as the set the UNIQUE duplicate check judges.
+     * When present the check runs UP FRONT, before `getIndexStore` opens the index-store
+     * directory, so a rejection leaves no directory behind; and `buildIndexEntries` then
+     * populates the physical index from this module's own (committed) rows with its in-pass
+     * dup check disabled. Those two row sets legitimately differ — the wrapper's transaction
+     * may have deleted a committed duplicate — and an index entry with no live row behind it
+     * is harmless (see the entry-resolution note in `buildIndexEntries`).
+     */
+    async createIndex(db, schemaName, tableName, indexSchema, rows) {
+        const table = this.getOrReconnectTable(db, schemaName, tableName);
+        if (!table) {
+            throw new QuereusError(`Store table '${tableName}' not found in schema '${schemaName}'`, StatusCode.NOTFOUND);
+        }
+        // Reject when this new index's physical store name already names an existing
+        // store: a sibling table's data store (`{schema}.t_idx_<x>` == sibling table
+        // `t_idx_<x>`) or another table's index store (index-vs-index, e.g.
+        // `a.b_idx_c` vs `a_idx_b.c` both → `{schema}.a_idx_b_idx_c`). The new index
+        // is not yet registered in the schema or the table's cached schema at this
+        // point, so the candidate cannot self-collide. Must precede `getIndexStore`,
+        // which opens/creates the directory that `buildIndexEntries` then writes into.
+        const indexStoreName = buildIndexStoreName(schemaName, tableName, indexSchema.name);
+        this.assertStoreNameFree(db, schemaName, indexStoreName, `index store of new index '${indexSchema.name}' on table '${schemaName}.${tableName}'`);
+        const tableSchema = table.getSchema();
+        const keyCollation = (table.getConfig().collation || 'NOCASE').toUpperCase();
+        // Reject an index whose key collations cannot key (comparator-only or
+        // unregistered names) BEFORE the physical store is created — the same DDL-time
+        // check `StoreTableBase.validateKeyCollations` applies to every index at
+        // CREATE TABLE / rehydrate, run here up front so a rejection leaves no
+        // index-store directory behind (the post-build `updateSchema` would only catch
+        // it after the store exists).
+        table.assertIndexKeyCollationsCanKey(indexSchema);
+        // Wrapper-supplied rows are the judged set. Validate BEFORE `getIndexStore` so a
+        // rejection leaves no index-store directory behind, and disable the in-pass dup
+        // check below (which would judge this module's committed rows instead).
+        if (rows && indexSchema.unique) {
+            await validateUniqueIndexOverRows(rows(), tableSchema, indexSchema, db.getKeyNormalizerResolver());
+        }
+        // Create the index store
+        const indexStore = await this.provider.getIndexStore(schemaName, tableName, indexSchema.name);
+        // Build index entries for every row the table can currently SEE — committed
+        // rows merged with this transaction's pending writes (`iterateEffectiveEntries`).
+        // The committed-only stream would leave a row inserted earlier in an open
+        // transaction unindexed, and `StoreTable.findUniqueConflictViaIndex` trusts the
+        // index to hold every live row: a `CREATE UNIQUE INDEX` would miss a pending
+        // duplicate, and a later insert colliding with that pending row would be
+        // silently ACCEPTED. Entries written here for rows that a subsequent ROLLBACK
+        // discards are harmless: both readers resolve each entry to its live row and
+        // drop it when the row is gone or no longer matches (see `scanIndex`).
+        //
+        // The store is FRESHLY created above, so any build failure — a UNIQUE violation,
+        // an IO error, or a mid-stream flush failure now that the build is chunked — must
+        // tear the whole store down. Nothing else reclaims it: SchemaManager.createIndex
+        // wraps the error but does no teardown, so without this a rejected build leaks a
+        // partial/empty index-store directory. Mirrors dropIndex's teardown.
+        try {
+            await buildIndexEntries(table.iterateEffectiveEntries(buildFullScanBounds()), indexStore, tableSchema, indexSchema, keyCollation, db.getKeyNormalizerResolver(), rows !== undefined, table.getConfig().maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES);
+        }
+        catch (buildError) {
+            // Best-effort teardown: guard it against its own throw so a teardown failure
+            // never masks the original build error the caller must see.
+            try {
+                await this.tearDownIndexStore(schemaName, tableName, table, indexSchema.name);
+            }
+            catch (teardownError) {
+                console.warn(`[StoreModule] failed to tear down index store '${indexSchema.name}' on `
+                    + `table '${schemaName}.${tableName}' after a failed CREATE INDEX: ${String(teardownError)}`);
+            }
+            throw buildError;
+        }
+        // Refresh the connected table's cached schema so subsequent DML
+        // maintains the new index (the engine's schema registry is updated
+        // separately by SchemaManager.createIndex, but the StoreTable instance
+        // holds its own reference captured at connect time). The shared
+        // appendIndexToTableSchema also synthesizes the UNIQUE → derived
+        // uniqueConstraint entry so checkUniqueConstraints enforces it; the
+        // `derivedFromIndex` tag lets StoreModule.dropIndex filter it back out
+        // symmetrically (mirrors SchemaManager.dropIndex / MemoryTableManager.dropIndex).
+        const updatedSchema = appendIndexToTableSchema(tableSchema, indexSchema);
+        table.updateSchema(updatedSchema);
+        // Authoritative catalog write: persist the table's bundle now (including the
+        // new index), so the index survives close → reopen even when the table has
+        // no rows yet and was never lazily persisted. `markDdlSaved` suppresses the
+        // later lazy table-only write on first store access (StoreTable.ddlSaved), so
+        // this is the only catalog write the createIndex produces. SchemaManager fires
+        // a follow-up `table_modified` whose listener regenerates the SAME bundle and
+        // skips (identical) — see persistCatalogIfChanged.
+        await this.saveTableDDL(updatedSchema);
+        table.markDdlSaved();
+        // The new index may now REALIZE a plain UNIQUE over the same columns, which
+        // `updateSchema` above has already dropped from the materialized enforcement
+        // schema (`findReusableIndexForUnique`). Nothing maintains that `_uc_*` any more,
+        // so tear its physical store down — leaving it would rot into a store whose
+        // entries no longer track the rows, which a later `DROP INDEX` would hand back to
+        // the constraint as if current. A no-op for every index that covers no UNIQUE —
+        // which is what keeps the DDL-commit the teardown forces (see
+        // {@link reconcileImplicitUniqueIndexStores}) off every ordinary CREATE INDEX.
+        await this.reconcileImplicitUniqueIndexStores(db, schemaName, tableName, table, tableSchema);
+        // Emit schema change event. `updatedSchema` (not the pre-create
+        // `tableSchema`) is the owner the canonical CREATE INDEX renders against —
+        // it is only read for the table's qualified name and column names, but
+        // passing the post-create schema keeps the rendering consistent with what a
+        // receiving peer regenerates when it compares definitions.
+        this.eventEmitter?.emitSchemaChange({
+            type: 'create',
+            objectType: 'index',
+            schemaName,
+            objectName: indexSchema.name,
+            ddl: generateIndexDDL(indexSchema, updatedSchema),
+        });
+    }
+    /**
+     * Drops an index on a store-backed table.
+     *
+     * Mirrors createIndex: refreshes the connected StoreTable's cached
+     * tableSchema (removing the index entry and any UNIQUE constraint
+     * synthesized from it, tagged with `derivedFromIndex`), releases the
+     * cached index-store handle, and tears down the underlying index store.
+     */
+    async dropIndex(db, schemaName, tableName, indexName) {
+        const table = this.getOrReconnectTable(db, schemaName, tableName);
+        if (!table) {
+            throw new QuereusError(`Store table '${tableName}' not found in schema '${schemaName}'`, StatusCode.NOTFOUND);
+        }
+        const tableSchema = table.getSchema();
+        const lowerIndexName = indexName.toLowerCase();
+        // Mirror SchemaManager.dropIndex: strip the index AND any UNIQUE
+        // constraint synthesized from it (tagged with `derivedFromIndex` by
+        // StoreModule.createIndex). Collapse uniqueConstraints to undefined
+        // when empty.
+        const updatedIndexes = Object.freeze((tableSchema.indexes ?? []).filter(idx => idx.name.toLowerCase() !== lowerIndexName));
+        const remainingUniqueConstraints = (tableSchema.uniqueConstraints ?? []).filter(uc => uc.derivedFromIndex?.toLowerCase() !== lowerIndexName);
+        const updatedSchema = {
+            ...tableSchema,
+            indexes: updatedIndexes,
+            uniqueConstraints: remainingUniqueConstraints.length > 0
+                ? Object.freeze(remainingUniqueConstraints)
+                : undefined,
+        };
+        // Update the cached schema BEFORE tearing down the store so that a
+        // failure of the physical drop doesn't leave the schema enforcing an
+        // index whose backing store has already been mutated.
+        table.updateSchema(updatedSchema);
+        // Rewrite the catalog bundle without the dropped index, before the physical
+        // teardown — so on reopen the index does not resurrect even if the store
+        // delete below fails. `markDdlSaved` keeps the lazy first-access save from
+        // re-writing the same bundle. SchemaManager's follow-up `table_modified`
+        // regenerates an identical bundle and skips.
+        await this.saveTableDDL(updatedSchema);
+        table.markDdlSaved();
+        // Drop the cached handle on the table side and tear down the underlying KVStore
+        // ({@link tearDownIndexStore}).
+        //
+        // Flush first: the coordinator keys buffered ops on the KVStore HANDLE, so ops
+        // this transaction queued against the index being dropped would be replayed into
+        // a closed store at commit and throw. Same posture (and same reason) as the
+        // teardown in `reconcileImplicitUniqueIndexStores` and the row-rewriting ALTER
+        // arms — see `StoreModuleBase.ddlCommitPendingOps`.
+        await this.ddlCommitPendingOps();
+        await this.tearDownIndexStore(schemaName, tableName, table, indexName);
+        // The dropped index may have been the structure REALIZING a plain UNIQUE over its
+        // columns; `updateSchema` above has re-materialized that constraint's own `_uc_*`,
+        // which has no physical store yet. Build it from the current rows so the very next
+        // insert is still enforced by a seek rather than an empty index. Deliberately AFTER
+        // the teardown: the build reads the DATA store, so the dropped index's store is
+        // dead weight by then. A no-op for every index no UNIQUE was reusing.
+        await this.reconcileImplicitUniqueIndexStores(db, schemaName, tableName, table, tableSchema);
+        this.eventEmitter?.emitSchemaChange({
+            type: 'drop',
+            objectType: 'index',
+            schemaName,
+            objectName: indexName,
+            ddl: generateDropIndexDDL(schemaName, indexName),
+        });
+    }
+    /**
+     * Clear and rebuild every secondary index of `schema` against the (already
+     * re-encoded) data store. Secondary-index keys embed the PK suffix, so they must
+     * be rewritten whenever the data-store PK key bytes change — which happens both
+     * on `ALTER PRIMARY KEY` (the PK columns change) and on an `ALTER COLUMN … SET
+     * COLLATE` on a PK member (a PK column's key collation changes). Shared by both
+     * arms so the clear-then-rebuild stays identical. `schema` must already be the
+     * post-ALTER schema (its `primaryKeyDefinition` + column collations drive the new
+     * PK-suffix encoding via {@link buildIndexEntries}). `normalizers` is the owning
+     * connection's `db.getKeyNormalizerResolver()` — see {@link buildIndexEntries}.
+     *
+     * NOTE: reads the data store committed-only and writes the index stores outside the
+     * coordinator. Sound only because every caller calls `StoreModuleBase.ddlCommitPendingOps`
+     * first, so this module's "committed" is "everything live". A caller that skips that
+     * flush would rebuild an index missing its transaction's pending rows.
+     *
+     * `skipDuplicateCheck` suppresses {@link buildIndexEntries}' in-pass UNIQUE check.
+     * Both ALTER COLUMN rebuild callers set it — the value-rewriting / key-transform
+     * arm and the PK re-key arm (`SET COLLATE` on a PK member): each runs a
+     * pre-mutation UNIQUE re-validation that already judged the ISSUING connection's
+     * effective rows (a wrapper's overlay included), and this rebuild sees only THIS
+     * module's committed rows — a set that may retain a row the wrapper's transaction
+     * has deleted, so judging it here would spuriously reject a duplicate pair the
+     * probe correctly accepted (and, worse, reject AFTER the data store was already
+     * re-keyed). Mirrors the memory module's deliberately non-enforcing base rebuild
+     * (the probe is the only guard). `ALTER PRIMARY KEY`'s rebuild still enforces:
+     * that arm has no effective-row UNIQUE probe of its own.
+     */
+    async rebuildSecondaryIndexes(schemaName, tableName, table, schema, normalizers, skipDuplicateCheck = false) {
+        const keyCollation = (table.getConfig().collation || 'NOCASE').toUpperCase();
+        const dataStore = await this.getStore(schemaName, tableName, table.getConfig());
+        const maxBatchBytes = table.getConfig().maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES;
+        for (const indexSchema of schema.indexes ?? []) {
+            const indexStore = await this.getIndexStore(schemaName, tableName, indexSchema.name);
+            // NOTE: this clear pass buffers EVERY existing index key into one batch. It holds
+            // only KEYS (no values), so its peak is far below the value-bearing build pass and
+            // is left unbounded for now. Chunking it is harder than the build: it deletes from
+            // the SAME store it iterates, so a mid-iteration flush risks iterate-while-mutate
+            // semantics that differ per provider (LevelDB snapshots its iterator; IndexedDB may
+            // not). If the index key set ever dominates memory, chunk this with a snapshot-safe
+            // re-seek, not a naive mid-iteration flush.
+            const clearBatch = indexStore.batch();
+            for await (const entry of indexStore.iterate(buildFullScanBounds())) {
+                clearBatch.delete(entry.key);
+            }
+            await clearBatch.write();
+            await buildIndexEntries(dataStore.iterate(buildFullScanBounds()), indexStore, schema, indexSchema, keyCollation, normalizers, skipDuplicateCheck, maxBatchBytes);
+        }
+    }
+    /**
+     * Build / tear down the physical index stores backing implicit UNIQUE indexes
+     * (`_uc_*`) after a DDL statement, by diffing the implicit-index NAMES the old vs
+     * new schema call for ({@link implicitUniqueIndexNameMap}):
+     *   - a name newly PRESENT (ADD CONSTRAINT UNIQUE, the target half of a
+     *     RENAME CONSTRAINT / rename of an unnamed UC's column, or a DROP INDEX that
+     *     retires the explicit index a UNIQUE was reusing) has its physical store
+     *     populated from this module's effective rows;
+     *   - a name newly ABSENT (DROP CONSTRAINT UNIQUE, the source half of a rename, or
+     *     a CREATE INDEX whose new index now realizes the UNIQUE) has its store torn
+     *     down, so nothing maintains it and a later rebuild does not reopen stale
+     *     entries.
+     *
+     * The SCHEMA entry itself is materialized/removed by `withImplicitUniqueIndexes`
+     * on the caller's `table.updateSchema`; only the physical store needs this. Called
+     * after every ALTER TABLE and after `createIndex` / `dropIndex`, and a no-op
+     * whenever the implicit-index name set is unchanged — the common case, including
+     * every PK / collation / data-type ALTER (whose same-name physical re-encode is
+     * already done by {@link rebuildSecondaryIndexes}) and every CREATE / DROP INDEX
+     * that does not cover a plain UNIQUE's columns.
+     *
+     * `oldSchema` is the pre-DDL schema: its `uniqueConstraints` give the old names and
+     * its `.indexes` the old reuse decisions. Either the engine-facing or the
+     * materialized copy works — `findReusableIndexForUnique` skips a constraint's own
+     * `_uc_*`, so a materialized input yields the same name set.
+     *
+     * NOTE: the build populates from THIS module's own effective rows (committed + this
+     * transaction's pending), never a wrapper's — mirroring `createIndex`. Under the
+     * isolation layer the wrapper's rows are what ADD CONSTRAINT's validation judged;
+     * the physical index legitimately fills from this module's committed rows and an
+     * entry with no live row behind it is harmless (both readers resolve to the live
+     * row). Duplicates were already rejected by `validateUniqueOverExistingRows` (ADD)
+     * or cannot exist (RENAME leaves data unchanged), so the in-pass check is skipped.
+     */
+    async reconcileImplicitUniqueIndexStores(db, schemaName, tableName, table, oldSchema) {
+        // Diff the constraint sets by implicit-index NAME (derived from `uniqueConstraints`,
+        // so the engine-facing schemas work directly); resolve the index SHAPE to build from
+        // the materialized enforcement schema.
+        const newSchema = table.getSchema();
+        const newMaterialized = table.getMaterializedSchema();
+        const oldNames = implicitUniqueIndexNameMap(oldSchema);
+        const newNames = implicitUniqueIndexNameMap(newSchema);
+        // Tear down each store whose implicit index no longer exists. A teardown closes
+        // and deletes a KVStore handle the module coordinator may still hold buffered ops
+        // against (pending ops are keyed on the HANDLE), and the eventual commit would
+        // write into the closed store and throw — so flush first, the same DDL-commit
+        // posture the row-rewriting ALTER arms take and what this module's declared
+        // `ddlTransactionality: 'auto-commit'` promises. Only when something is actually
+        // doomed: a pure BUILD writes index entries outside the coordinator and deletes
+        // nothing, so it must not force-commit the caller's transaction.
+        const doomed = [...oldNames].filter(([lower]) => !newNames.has(lower));
+        if (doomed.length > 0) {
+            await this.ddlCommitPendingOps();
+            for (const [, name] of doomed) {
+                await this.tearDownIndexStore(schemaName, tableName, table, name);
+            }
+        }
+        // Build each newly-materialized implicit index's store from effective rows.
+        for (const [lower, name] of newNames) {
+            if (oldNames.has(lower))
+                continue;
+            const indexSchema = (newMaterialized.indexes ?? []).find(ix => ix.name === name);
+            if (!indexSchema)
+                continue; // defensive — name is derived from the same UC set
+            // NOTE: no `assertStoreNameFree` here (unlike explicit `createIndex`): the name
+            // is engine-derived and deterministic, and the lazy first-write build path in
+            // `updateSecondaryIndexes` does not assert either — keep the two consistent.
+            // NOTE: no teardown-on-failure wrapper (unlike `createIndex`): an IO error mid-build
+            // leaves a partial `_uc_*` store while the constraint schema is already committed, so
+            // enforcement could under-report until the store is rebuilt. Tolerated because the
+            // build has no in-pass dup check (skipDuplicateCheck below) so the only failure is a
+            // genuine IO error — the same non-atomicity `rebuildSecondaryIndexes` documents; a
+            // re-run / reopen rebuilds. Add a try/catch teardown if this ever bites.
+            const keyCollation = (table.getConfig().collation || 'NOCASE').toUpperCase();
+            const indexStore = await this.provider.getIndexStore(schemaName, tableName, name);
+            await buildIndexEntries(table.iterateEffectiveEntries(buildFullScanBounds()), indexStore, newSchema, indexSchema, keyCollation, db.getKeyNormalizerResolver(), true, // dup rejection already owned by the arm (ADD validates; RENAME is data-preserving)
+            table.getConfig().maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES);
+        }
+    }
+    /**
+     * Close + delete one index's physical store: release the table's cached handle, then
+     * `deleteIndexStore` when the provider implements it (it closes the handle before
+     * removing the directory), else just `closeIndexStore`.
+     *
+     * The single teardown every path shares — `dropIndex`, `createIndex`'s build-failure
+     * rollback, the implicit `_uc_*` reconcile above, and `DROP COLUMN`'s removed-index
+     * pass (`StoreModuleAlter.alterDropColumn`). Each caller owns the surrounding
+     * posture, which deliberately differs: the DDL-commit flush (buffered ops are keyed
+     * on the KVStore HANDLE, so a doomed store's queued ops would replay into a closed
+     * store at commit — see `StoreModuleBase.ddlCommitPendingOps`) and, for
+     * `createIndex`, swallowing a teardown throw so it cannot mask the build error.
+     */
+    async tearDownIndexStore(schemaName, tableName, table, indexName) {
+        await table.releaseIndexStore(indexName);
+        if (this.provider.deleteIndexStore) {
+            await this.provider.deleteIndexStore(schemaName, tableName, indexName);
+        }
+        else {
+            await this.provider.closeIndexStore(schemaName, tableName, indexName);
+        }
+    }
+}
+//# sourceMappingURL=store-module-index.js.map

package/dist/src/common/store-module-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-module-index.js","sourceRoot":"","sources":["../../../src/common/store-module-index.ts"],"names":[],"mappings":"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"}

package/dist/src/common/store-module-rename.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ALTER TABLE ... RENAME TO: the two-phase table rename. The first phase relocates the
+ * physical data / index / stats stores and writes the new catalog entry while leaving
+ * the old entry in place; the second, called by the engine once every dependent object
+ * has been rewritten, drains those dependent catalog writes and only then drops it.
+ *
+ * Seventh layer of the store-module chain:
+ *   StoreModuleBase -> StoreModuleCatalog -> StoreModuleSchemaSync -> StoreModuleIndex
+ *   -> StoreModuleAlterColumn -> StoreModuleAlter -> StoreModuleRename -> StoreModule
+ */
+import type { Database } from '@quereus/quereus';
+import { StoreModuleAlter } from './store-module-alter.js';
+export declare abstract class StoreModuleRename extends StoreModuleAlter {
+    /**
+     * Rename a store-backed table.
+     *
+     * Drops every in-memory reference to the old name (so the coordinator, open
+     * handles, and cached StoreTable instance don't linger with stale paths),
+     * delegates physical storage relocation to the provider, then rewrites the
+     * persistent catalog DDL under the new key. After this returns, the next
+     * access to `newName` will reconnect via `connect()` and open fresh stores
+     * against the moved directories.
+     */
+    renameTable(db: Database, schemaName: string, oldName: string, newName: string, ddl?: string): Promise<void>;
+    /**
+     * Second phase of a two-phase RENAME TABLE (see {@link renameTable}). The engine calls
+     * this at the END of ALTER TABLE ... RENAME TO — AFTER its `propagateTableRename` has
+     * rewritten every dependent object that named `oldName` and enqueued their corrective
+     * catalog writes onto `StoreModuleBase.persistQueue`. `renameTable` deliberately left `oldName`'s
+     * catalog entry in place; here we drain those dependent writes to durability and only
+     * THEN drop the old entry. During the window both entries coexist on disk, so every
+     * dependent resolves against one of them and every intermediate catalog set rehydrates
+     * into a working database.
+     *
+     * The old-entry delete rides `persistQueue` behind the dependents' already-enqueued
+     * writes (FIFO), so it can only run after them, and the drain below awaits the whole
+     * chain. Errors are swallowed+logged (the `StoreModuleBase.enqueuePersist` contract): a failed
+     * delete leaves the old entry present — a visible, droppable orphan, strictly safer
+     * than a dependent stranded against a vanished table.
+     *
+     * NOTE: full cross-table atomicity — bundling this old-entry delete together with every
+     * dependent rewrite into one `provider.beginAtomicBatch` commit — would eliminate even
+     * the transient two-entry window (and the physical-move orphan `renameTableStores`
+     * leaves), but only on atomic providers, and the dependent set is known only to the
+     * engine post-propagate. That is the atomic-provider hardening path; out of scope here.
+     */
+    finalizeRename(_db: Database, schemaName: string, oldName: string, _newName: string): Promise<void>;
+}
+//# sourceMappingURL=store-module-rename.d.ts.map

package/dist/src/common/store-module-rename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-module-rename.d.ts","sourceRoot":"","sources":["../../../src/common/store-module-rename.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAiC,MAAM,kBAAkB,CAAC;AAUhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAI3D,8BAAsB,iBAAkB,SAAQ,gBAAgB;IAC/D;;;;;;;;;OASG;IACG,WAAW,CAChB,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACV,OAAO,CAAC,IAAI,CAAC;IAgPhB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,cAAc,CACnB,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;CAIhB"}