@quereus/quereus 4.5.0 → 4.7.0

package/dist/src/runtime/emit/alter-schema-event.js

@@ -0,0 +1,87 @@
+/**
+ * Raises the public schema-change event for one `ALTER TABLE` arm on the ENGINE's own path —
+ * i.e. only when the owning module ships no event emitter of its own and some listener needs
+ * the event. Both halves of that decision stay in
+ * `SchemaManager.emitAutoSchemaEventIfNeeded`, the single gate every auto event passes
+ * through; re-deciding either half here is what opens the double-emit hazard the store
+ * package's `database-events.spec.ts` guards against.
+ *
+ * Every arm calls this at its TAIL — after the catalog swap and the internal
+ * `changeNotifier.notifyChange` — deliberately unlike the modules that emit for themselves,
+ * which emit from inside `module.alterTable` and so before the engine's catalog swap. An arm
+ * that fails after the module call (the ADD COLUMN inline-constraint revert, an
+ * `assertRenameDependentsPersistable` refusal) must announce nothing at all: announcing a
+ * change that then unwound is worse than the intra-statement ordering drift, and that drift
+ * is unobservable — each arm produces exactly one event and delivery is batched to commit.
+ *
+ * The tail placement gives the engine's own path that silence for free. A module emitting
+ * from mid-statement cannot have it for free, so both paths get it from
+ * {@link withStatementScopedSchemaEvents} below, which every ALTER statement runs under.
+ *
+ * Unlike the other auto events (see the NOTE on `emitAutoSchemaEventIfNeeded`), the ALTER
+ * ones DO carry `ddl`: the planner renders the statement's canonical, schema-qualified SQL
+ * once at plan-build time (`AlterTableNode.sql` / `AddConstraintNode.sql`) and every arm
+ * passes it here, so a memory-backed and a store-backed alteration announce the same
+ * string — the text a sync peer re-executes. A rename also carries `oldObjectName`, since
+ * `objectName` names only the NEW table and a receiver could not otherwise tell which of
+ * its tables the event is about.
+ */
+export function emitAlterSchemaEvent(rctx, tableSchema, event) {
+    rctx.db.schemaManager.emitAutoSchemaEventIfNeeded(tableSchema.vtabModuleName, {
+        ...event,
+        schemaName: tableSchema.schemaName,
+    });
+}
+/**
+ * Runs one whole `ALTER TABLE` statement with its schema events made RETRACTABLE: if `fn`
+ * throws, every schema event batched since the call is dropped before the error propagates,
+ * so a statement that unwound announces nothing at all.
+ *
+ * The other half of the "one event per statement, on the success path only" rule that
+ * {@link emitAlterSchemaEvent} implements — hence the shared home. The engine's own arms
+ * satisfy the rule by construction (they emit at their tail, past any throw), but a backend
+ * that emits for ITSELF cannot: it emits from inside `module.alterTable`, which is not the
+ * end of the statement. `ADD COLUMN … <inline constraint>` then installs each constraint
+ * through further module calls, and a failure there runs `revertAddColumn` — by which point
+ * the module's announcement, carrying the statement's SQL, is already sitting in the
+ * transaction's batch. A syncing peer that executed that SQL really would add the column,
+ * diverging from the device where the statement failed.
+ *
+ * Wrapped at the STATEMENT boundary rather than around the ADD COLUMN revert: ADD COLUMN is
+ * only the arm with a demonstrated leak, and every other arm has post-module-call work of its
+ * own (`propagateTableRename`, `module.finalizeRename`, `propagateColumnRename`, the
+ * materialized-view re-registration) that can open the same window later.
+ *
+ * Call it INSIDE the arm's `run()` — after `assertDdlTransactionPolicy` and
+ * `await db._ensureTransaction()`, so the mark is taken with batching already on. Retraction
+ * is a no-op without a batch, which is correct: the events were delivered synchronously and
+ * nothing can call them back.
+ *
+ * Only the SCHEMA channel is retracted — see
+ * {@link DatabaseEventEmitter.discardSchemaEventsSince} for why touching the data channel
+ * here would swallow earlier statements' committed writes.
+ *
+ * ALTER is the only statement family scoped this way. The object-lifecycle statements are
+ * not, and `create table … maintained as` demonstrably leaks the same way (it announces the
+ * backing table's create, then a drop, when filling the table fails) — tracked as
+ * `bug-failed-maintained-create-announces-create-and-drop`, whose first question is whether
+ * this wrapper should move up to cover every DDL statement boundary instead.
+ *
+ * NOTE: nothing nests these scopes today (the one ALTER arm that runs nested SQL —
+ * the ALTER PRIMARY KEY shadow rebuild — does it under `withPublicEventsSuppressed`, so it
+ * batches no events at all). If an arm ever did nest one, the outer failure would retract the
+ * inner statement's events too, which is the wanted reading: the outer statement unwound, so
+ * everything it did announces nothing.
+ */
+export async function withStatementScopedSchemaEvents(rctx, fn) {
+    const emitter = rctx.db._getEventEmitter();
+    const watermark = emitter.beginSchemaEventScope();
+    try {
+        return await fn();
+    }
+    catch (err) {
+        emitter.discardSchemaEventsSince(watermark);
+        throw err;
+    }
+}
+//# sourceMappingURL=alter-schema-event.js.map

package/dist/src/runtime/emit/alter-schema-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-schema-event.js","sourceRoot":"","sources":["../../../../src/runtime/emit/alter-schema-event.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,oBAAoB,CACnC,IAAoB,EACpB,WAAwB,EACxB,KAA4B;IAE5B,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,2BAA2B,CAAC,WAAW,CAAC,cAAc,EAAE;QAC7E,GAAG,KAAK;QACR,UAAU,EAAE,WAAW,CAAC,UAAU;KAClC,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACpD,IAAoB,EACpB,EAAoB;IAEpB,MAAM,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,gBAAgB,EAAE,CAAC;IAC3C,MAAM,SAAS,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAClD,IAAI,CAAC;QACJ,OAAO,MAAM,EAAE,EAAE,CAAC;IACnB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACd,OAAO,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC;QAC5C,MAAM,GAAG,CAAC;IACX,CAAC;AACF,CAAC"}

package/dist/src/runtime/emit/alter-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alter-table.d.ts","sourceRoot":"","sources":["../../../../src/runtime/emit/alter-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAqC,MAAM,yCAAyC,CAAC;AACjH,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAM9D,OAAO,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAsCrF,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,WAAW,CAuItF;AAu3CD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EAAE,EAC1B,QAAQ,EAAE,0BAA0B,EAAE,GACpC,MAAM,CAuCR"}
+{"version":3,"file":"alter-table.d.ts","sourceRoot":"","sources":["../../../../src/runtime/emit/alter-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAqC,MAAM,yCAAyC,CAAC;AACjH,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,aAAa,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAM9D,OAAO,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AA8CrF,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,GAAG,WAAW,CAkJtF;AAqpDD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EAAE,EAC1B,QAAQ,EAAE,0BAA0B,EAAE,GACpC,MAAM,CAuCR"}