@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

package/src/stack/push-entity-projection-tables.ts

@@ -1,95 +0,0 @@
-import { KUMIKO_NAME_SYMBOL } from "@cosmicdrift/kumiko-types/schema-table-types";
-import type { DbConnection } from "../db/connection";
-import type { ColumnMeta } from "../db/entity-table-meta";
-import { columnNamesOf, tableExists } from "../db/schema-inspection";
-import type { Registry } from "../engine/types";
-import { addMissingColumns, tableToMeta, unsafePushTables } from "./table-helpers";
-
-type DbHolder = { readonly db: DbConnection };
-
-// biome-ignore lint/suspicious/noConsole: stack-internal status logging
-const logInfo = (msg: string): void => console.log(msg);
-
-/**
- * Push all implicit-projection tables — one per `r.entity()` — that the
- * registry knows about. setupTestStack already handles explicit
- * projections, MSPs, and `r.storeTable()` declarations in its own loop;
- * implicit projections are the missing piece for a fresh boot.
- *
- * Idempotent via `tableExists` so a persistent dev DB
- * (`KUMIKO_DEV_DB_NAME`) reuses existing tables on reboot. One batched
- * push at the end so drizzle-kit's `generateMigration` runs once over
- * the whole missing set.
- *
- * Lives next to `setupTestStack` because both are stack-bootstrap
- * helpers that legitimately speak the `unsafe*`-DDL layer; the
- * Table-DDL Guard's stack/** allowlist is the single shared exemption
- * site. Apps still declare data via `r.entity()` / `r.storeTable()` and
- * never call this directly.
- */
-export async function pushEntityProjectionTables(
-  stack: DbHolder,
-  registry: Registry,
-): Promise<void> {
-  const seen = new Set<unknown>();
-  const missing: Record<string, unknown> = {};
-
-  for (const [projName, proj] of registry.getAllProjections()) {
-    if (!proj.isImplicit) continue;
-    if (seen.has(proj.table)) continue;
-    seen.add(proj.table);
-    const tableRec = proj.table as unknown as Record<symbol, unknown>;
-    const physical = tableRec[KUMIKO_NAME_SYMBOL] as string;
-    if (!(await tableExists(stack.db, `public.${physical}`))) {
-      missing[projName] = proj.table;
-      continue;
-    }
-    await syncExistingProjectionTable(stack, physical, proj.table);
-  }
-
-  if (Object.keys(missing).length > 0) {
-    await unsafePushTables(stack.db, missing);
-  }
-}
-
-function isUnsafeToAutoAdd(col: ColumnMeta): boolean {
-  return col.notNull && !col.primaryKey && col.defaultSql === undefined;
-}
-
-// Backfills columns a persistent dev DB predates; a required column with no
-// default can't be added safely on a table that may hold rows, so that
-// stays a boot error instead.
-async function syncExistingProjectionTable(
-  stack: DbHolder,
-  physical: string,
-  table: unknown,
-): Promise<void> {
-  const meta = tableToMeta(table);
-  const liveColumns = await columnNamesOf(stack.db, physical);
-  const missingColumns = meta.columns.filter((c) => !liveColumns.has(c.name));
-  if (missingColumns.length === 0) {
-    logInfo(`[kumiko-stack] table ${physical} already exists — skipping create`);
-    // skip: live table already has every declared column
-    return;
-  }
-
-  const unsafeColumns = missingColumns.filter(isUnsafeToAutoAdd);
-  if (unsafeColumns.length > 0) {
-    const devDbName = process.env["KUMIKO_DEV_DB_NAME"] ?? "<KUMIKO_DEV_DB_NAME>";
-    throw new Error(
-      `[kumiko-stack] table "${physical}" is missing required column(s) ` +
-        `${unsafeColumns.map((c) => `"${c.name}"`).join(", ")} with no default. ` +
-        "Auto-sync only backfills nullable columns or columns with a default on an " +
-        "existing dev DB — a required column with no default can't be added safely " +
-        `once the table may hold rows. Drop the persistent dev database "${devDbName}" ` +
-        `(e.g. \`dropdb ${devDbName}\`, adjusted for your local Postgres host/port/user) ` +
-        "so the next boot recreates it from scratch.",
-    );
-  }
-
-  logInfo(
-    `[kumiko-stack] table ${physical} is missing column(s) ` +
-      `${missingColumns.map((c) => `"${c.name}"`).join(", ")} — adding`,
-  );
-  await addMissingColumns(stack.db, physical, missingColumns);
-}

package/src/stack/redis.ts

@@ -1,55 +0,0 @@
-import { generateId } from "../utils";
-import { requireEnv } from "./db";
-
-export type TestRedis = {
-  redis: import("ioredis").default;
-  // The exact REDIS_URL used to build `redis` above — for a second, unrelated
-  // connection (e.g. the test-stack's JobRunner) that needs its own client
-  // rather than sharing this one's keyPrefix. Reconstructing a URL from
-  // `redis.options` loses password/username/tls/path (pr-review
-  // kumiko-framework #1036/2) — callers needing a fresh connection should use
-  // this raw string, not rebuild one from parsed options.
-  redisUrl: string;
-  /** The per-test `keyPrefix` on `redis`, e.g. `kt:1a2b3c4d:`. */
-  keyPrefix: string;
-  /** Delete every key this test created (prefix-scoped). Replaces the old
-   *  `redis.flushdb()` — that wiped other parallel tests' BullMQ state. */
-  flushNamespace: () => Promise<void>;
-  cleanup: () => Promise<void>;
-};
-
-export async function createTestRedis(): Promise<TestRedis> {
-  const Redis = (await import("ioredis")).default;
-  const redisUrl = requireEnv("REDIS_URL");
-  // Every test gets a per-file key prefix on a shared DB (no DB-pool-of-15
-  // round-robin). Collisions at birthday-paradox rates are gone — the
-  // prefix space is unbounded. See Track B.3 in docs/plans/tests-refactor.
-  const prefix = `kt:${generateId().slice(-8)}:`;
-  const redis = new Redis(redisUrl, { keyPrefix: prefix });
-
-  async function flushNamespace(): Promise<void> {
-    // Open a prefix-less client for the scan — ioredis' keyPrefix is applied
-    // per-command but SCAN's returned keys are full names, so managing the
-    // del set with the prefix already on the connection is error-prone.
-    const raw = new Redis(redisUrl);
-    try {
-      const stream = raw.scanStream({ match: `${prefix}*`, count: 500 });
-      const keys: string[] = [];
-      for await (const batch of stream) keys.push(...batch);
-      if (keys.length > 0) await raw.del(...keys);
-    } finally {
-      raw.disconnect();
-    }
-  }
-
-  return {
-    redis,
-    redisUrl,
-    keyPrefix: prefix,
-    flushNamespace,
-    cleanup: async () => {
-      await flushNamespace();
-      redis.disconnect();
-    },
-  };
-}

package/src/stack/request-helper.ts

@@ -1,298 +0,0 @@
-import type { Hono } from "hono";
-import type { SessionCreator } from "../api/auth-routes";
-import type { JwtHelper } from "../api/jwt";
-import type { SessionUser } from "../engine/types";
-
-export type BatchCommand = { type: string; payload: unknown };
-
-type WireErrorBody = {
-  readonly code?: string;
-  readonly details?: {
-    readonly causeName?: string;
-    readonly causeMessage?: string;
-    readonly causeStack?: string;
-  };
-};
-
-function formatFailure(kind: "write" | "query", type: string, body: unknown): string {
-  const parsed = body as {
-    isSuccess?: boolean;
-    error?: WireErrorBody | string;
-  };
-  const code =
-    (typeof parsed.error === "object" ? parsed.error?.code : undefined) ??
-    (typeof parsed.error === "string" ? parsed.error : "unknown");
-  const details =
-    typeof parsed.error === "object" && parsed.error?.details !== undefined
-      ? parsed.error.details
-      : undefined;
-  const causeMessage =
-    details && typeof details === "object" && "causeMessage" in details
-      ? String((details as { causeMessage?: unknown }).causeMessage ?? "")
-      : "";
-  const causeName =
-    details && typeof details === "object" && "causeName" in details
-      ? String((details as { causeName?: unknown }).causeName ?? "")
-      : "";
-  if (code === "internal_error" && (causeMessage || causeName)) {
-    return `Expected ${kind} "${type}" to succeed but got error: ${code} (${causeName}: ${causeMessage})`;
-  }
-  if (details !== undefined) {
-    return `Expected ${kind} "${type}" to succeed but got error: ${code} — ${JSON.stringify(details)}`;
-  }
-  return `Expected ${kind} "${type}" to succeed but got error: ${code}`;
-}
-
-export type RequestHelper = {
-  write: (
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-    requestId?: string,
-  ) => Promise<Response>;
-  query: (type: string, payload: unknown, user: SessionUser) => Promise<Response>;
-  command: (type: string, payload: unknown, user: SessionUser) => Promise<Response>;
-  batch: (
-    commands: readonly BatchCommand[],
-    user: SessionUser,
-    requestId?: string,
-  ) => Promise<Response>;
-  raw: (
-    method: string,
-    path: string,
-    body?: unknown,
-    headers?: Record<string, string>,
-  ) => Promise<Response>;
-
-  /** write + json + assert isSuccess — returns data directly */
-  writeOk: <T = Record<string, unknown>>(
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-    requestId?: string,
-  ) => Promise<T>;
-  /** write + json + assert isSuccess === false — returns the structured
-   *  WriteErrorInfo with `httpStatus` filled in from the HTTP response. */
-  writeErr: (
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-  ) => Promise<import("../errors").WriteErrorInfo>;
-  /** query + json — returns data directly */
-  queryOk: <T = unknown>(type: string, payload: unknown, user: SessionUser) => Promise<T>;
-  /** query + json + assert the response is an error — returns the structured
-   *  WriteErrorInfo with `httpStatus` filled in from the HTTP response. */
-  queryErr: (
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-  ) => Promise<import("../errors").WriteErrorInfo>;
-
-  /** write + additional HTTP headers (e.g. X-Correlation-ID). Returns the
-   *  raw Response so callers can assert on status + headers + body as needed. */
-  writeWithHeaders: (
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-    extraHeaders: Record<string, string>,
-  ) => Promise<Response>;
-  /** query + additional HTTP headers (e.g. X-Forwarded-For). Returns the raw
-   *  Response so callers can assert on status + headers + body as needed. */
-  queryWithHeaders: (
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-    extraHeaders: Record<string, string>,
-  ) => Promise<Response>;
-};
-
-export type RequestHelperOptions = {
-  // When sessionChecker is wired (sessions feature), JWTs without jti are
-  // rejected as no_sid. Seed/test helpers that only jwt.sign(user) need a
-  // live sid — create one via the same sessionCreator login uses (#1372).
-  readonly sessionCreator?: SessionCreator;
-};
-
-export function createRequestHelper(
-  app: Hono,
-  jwt: JwtHelper,
-  options: RequestHelperOptions = {},
-): RequestHelper {
-  // sid per (user.id, tenantId), not one mint per authHeader() call:
-  // sessionCreator opens a live session row, so an unmemoized call mints a
-  // fresh one on every request a test makes for the same user — tests
-  // asserting on session counts / massRevoker / revokeAllOthers behavior
-  // then see extra live sids that have nothing to do with what they're
-  // testing. Keyed on tenantId too — the same user.id can hold sessions in
-  // more than one tenant, and sessionCreator writes the row scoped to
-  // `user.tenantId` (session-callbacks.ts), so a user.id-only key would
-  // hand a cross-tenant test its wrong tenant's sid.
-  // Cache the Promise (not the settled sid) so two concurrent authHeader
-  // calls for the same key share one mint instead of racing on a miss.
-  const sidByUserKey = new Map<string, Promise<string>>();
-
-  async function authHeader(user: SessionUser): Promise<Record<string, string>> {
-    let forJwt = user;
-    if (options.sessionCreator && !user.sid) {
-      const key = `${user.id}:${user.tenantId}`;
-      let sidPromise = sidByUserKey.get(key);
-      if (sidPromise === undefined) {
-        sidPromise = options.sessionCreator(user, { ip: "test", userAgent: "request-helper" });
-        sidByUserKey.set(key, sidPromise);
-      }
-      const sid = await sidPromise;
-      forJwt = { ...user, sid };
-    }
-    const token = await jwt.sign(forJwt);
-    return { Authorization: `Bearer ${token}` };
-  }
-
-  async function req(
-    method: string,
-    path: string,
-    body?: unknown,
-    headers?: Record<string, string>,
-  ): Promise<Response> {
-    const init: RequestInit = {
-      method,
-      headers: { "Content-Type": "application/json", ...headers },
-    };
-    if (body) init.body = JSON.stringify(body);
-    return app.request(path, init);
-  }
-
-  async function writeRaw(
-    type: string,
-    payload: unknown,
-    user: SessionUser,
-    requestId?: string,
-  ): Promise<Response> {
-    const headers = await authHeader(user);
-    return req("POST", "/api/write", { type, payload, requestId }, headers);
-  }
-
-  async function queryRaw(type: string, payload: unknown, user: SessionUser): Promise<Response> {
-    const headers = await authHeader(user);
-    return req("POST", "/api/query", { type, payload }, headers);
-  }
-
-  return {
-    write: writeRaw,
-    query: queryRaw,
-
-    async command(type, payload, user) {
-      const headers = await authHeader(user);
-      return req("POST", "/api/command", { type, payload }, headers);
-    },
-
-    async batch(commands, user, requestId) {
-      const headers = await authHeader(user);
-      return req("POST", "/api/batch", { commands, requestId }, headers);
-    },
-
-    raw: req,
-
-    async writeOk<T = Record<string, unknown>>(
-      type: string,
-      payload: unknown,
-      user: SessionUser,
-      requestId?: string,
-    ): Promise<T> {
-      const res = await writeRaw(type, payload, user, requestId);
-      // wire-body shape direkt nach JSON.parse — Caller-Code prüft danach
-      // selber ob isSuccess/error/data tatsächlich da sind.
-      const rawBody = await res.json();
-      const body = rawBody as {
-        // @cast-boundary engine-bridge
-        isSuccess?: boolean;
-        data?: unknown;
-        error?: { code?: string } | string;
-      };
-      // Success path still has { isSuccess: true, data }. Error responses now
-      // follow the error-contract shape { error: { code, i18nKey, ... } } with
-      // a 4xx/5xx status — no isSuccess flag. Detect either.
-      if (body.isSuccess !== true) {
-        throw new Error(formatFailure("write", type, body));
-      }
-      return body.data as T; // @cast-boundary engine-bridge
-    },
-
-    async writeErr(
-      type: string,
-      payload: unknown,
-      user: SessionUser,
-    ): Promise<import("../errors").WriteErrorInfo> {
-      const res = await writeRaw(type, payload, user);
-      const rawErrorBody = await res.json();
-      const body = rawErrorBody as {
-        // @cast-boundary engine-bridge
-        isSuccess?: boolean;
-        error?: Omit<import("../errors").WriteErrorInfo, "httpStatus">;
-      };
-      if (body.isSuccess === true) {
-        throw new Error(`Expected write "${type}" to fail but it succeeded`);
-      }
-      const wire = body.error;
-      if (!wire || typeof wire !== "object" || typeof wire.code !== "string") {
-        throw new Error(
-          `Expected error response for "${type}" but got unexpected shape: ${JSON.stringify(body)}`,
-        );
-      }
-      // The wire body doesn't carry httpStatus (it would be redundant with
-      // the HTTP response status). Fill it in from res.status so callers can
-      // assert against either code OR status without a second request round.
-      return { ...wire, httpStatus: res.status };
-    },
-
-    async queryOk<T = unknown>(type: string, payload: unknown, user: SessionUser): Promise<T> {
-      const res = await queryRaw(type, payload, user);
-      const rawBody = await res.json();
-      const body = rawBody as {
-        // @cast-boundary engine-bridge
-        data?: unknown;
-        error?: WireErrorBody | string;
-      };
-      // res.ok mirrors writeOk's isSuccess assertion — belt-and-suspenders
-      // in case a future non-dispatcher rejection skips the error-contract shape.
-      if (!res.ok || body.error !== undefined) {
-        throw new Error(`${formatFailure("query", type, body)} [HTTP ${res.status}]`);
-      }
-      return body.data as T; // @cast-boundary engine-bridge
-    },
-
-    async queryErr(
-      type: string,
-      payload: unknown,
-      user: SessionUser,
-    ): Promise<import("../errors").WriteErrorInfo> {
-      const res = await queryRaw(type, payload, user);
-      const rawErrorBody = await res.json();
-      const body = rawErrorBody as {
-        // @cast-boundary engine-bridge
-        error?: Omit<import("../errors").WriteErrorInfo, "httpStatus">;
-      };
-      if (res.ok) {
-        throw new Error(`Expected query "${type}" to fail but it succeeded`);
-      }
-      const wire = body.error;
-      if (!wire || typeof wire !== "object" || typeof wire.code !== "string") {
-        throw new Error(
-          `Expected error response for "${type}" but got unexpected shape: ${JSON.stringify(body)}`,
-        );
-      }
-      // Same rationale as writeErr: the wire body has no httpStatus (it would
-      // be redundant with the HTTP response status), so fill it in here.
-      return { ...wire, httpStatus: res.status };
-    },
-
-    async writeWithHeaders(type, payload, user, extraHeaders) {
-      const authHeaders = await authHeader(user);
-      return req("POST", "/api/write", { type, payload }, { ...authHeaders, ...extraHeaders });
-    },
-
-    async queryWithHeaders(type, payload, user, extraHeaders) {
-      const authHeaders = await authHeader(user);
-      return req("POST", "/api/query", { type, payload }, { ...authHeaders, ...extraHeaders });
-    },
-  };
-}

package/src/stack/table-helpers.ts

@@ -1,175 +0,0 @@
-import {
-  KUMIKO_META_SYMBOL,
-  KUMIKO_NAME_SYMBOL,
-} from "@cosmicdrift/kumiko-types/schema-table-types";
-import type { DbConnection } from "../db/connection";
-import { pgTypeToSqlType } from "../db/dialect";
-import type { ColumnMeta, EntityTableMeta } from "../db/entity-table-meta";
-import {
-  alterTableAddColumn,
-  createIndexIfNotExists,
-  executeDdlStatement,
-} from "../db/queries/ddl";
-import { truncateTablesRestartIdentity } from "../db/queries/test-stack";
-import { renderTableDdl } from "../db/render-ddl";
-import { tableExists } from "../db/schema-inspection";
-import { buildEntityTable, toTableName } from "../db/table-builder";
-import type { EventDispatcher } from "../pipeline";
-
-function tableNameOf(table: unknown): string {
-  if (typeof table !== "object" || table === null) {
-    throw new Error("table-helpers: table is not a SchemaTable object");
-  }
-  const rec = table as Record<string | symbol, unknown>;
-  if (typeof rec[KUMIKO_NAME_SYMBOL] === "string") return rec[KUMIKO_NAME_SYMBOL] as string;
-  if (typeof (rec as { tableName?: unknown }).tableName === "string") {
-    return (rec as { tableName: string }).tableName;
-  }
-  throw new Error("table-helpers: table has no name");
-}
-
-/**
- * Bypass: creates an entity-table directly without going through the
- * full registry. Reserved for framework-internal meta-tables and
- * test setup — apps declare data via `r.entity(...)`.
- */
-export async function unsafeCreateEntityTable(
-  db: DbConnection,
-  entity: import("../engine/types").EntityDefinition,
-  entityName?: string,
-): Promise<void> {
-  const table = buildEntityTable(entityName ?? "entity", entity);
-  await unsafePushTables(db, { [entityName ?? "entity"]: table });
-}
-
-export async function unsafeEnsureEntityTable(
-  db: DbConnection,
-  entity: import("../engine/types").EntityDefinition,
-  entityName?: string,
-): Promise<boolean> {
-  const resolvedName = entity.table ?? toTableName(entityName ?? "entity");
-  if (await tableExists(db, `public.${resolvedName}`)) return false;
-  await unsafeCreateEntityTable(db, entity, entityName);
-  return true;
-}
-
-// Tables produced by the native dialect already carry EntityTableMeta-shape
-// (source/columns/indexes). renderTableDdl converts that to CREATE TABLE +
-// CREATE INDEX statements executed via db/queries/test-stack.
-function isMetaShape(v: unknown): v is EntityTableMeta {
-  return (
-    typeof v === "object" &&
-    v !== null &&
-    typeof (v as EntityTableMeta).tableName === "string" &&
-    Array.isArray((v as EntityTableMeta).columns) &&
-    Array.isArray((v as EntityTableMeta).indexes) &&
-    ((v as EntityTableMeta).source === "managed" || (v as EntityTableMeta).source === "unmanaged")
-  );
-}
-
-export function tableToMeta(table: unknown): EntityTableMeta {
-  // table() spreads column handles as enumerable props, so a field named
-  // `columns`/`tableName`/`source`/… shadows the matching meta key — read the
-  // canonical meta from the unshadowable symbol when present.
-  if (table !== null && typeof table === "object") {
-    const fromSymbol = (table as Record<symbol, unknown>)[KUMIKO_META_SYMBOL];
-    if (isMetaShape(fromSymbol)) return fromSymbol;
-  }
-  if (isMetaShape(table)) return table;
-  throw new Error("unsafePushTables: argument is not a SchemaTable / EntityTableMeta");
-}
-
-/** Applies ALTER TABLE ADD COLUMN for exactly the given columns. */
-export async function addMissingColumns(
-  db: DbConnection,
-  tableName: string,
-  columns: readonly ColumnMeta[],
-): Promise<void> {
-  for (const col of columns) {
-    const type = renderColumnType(col);
-    const notNull = col.notNull && !col.primaryKey ? " NOT NULL" : "";
-    const defaultClause = col.defaultSql !== undefined ? ` DEFAULT ${col.defaultSql}` : "";
-    await alterTableAddColumn(db, tableName, col.name, type, defaultClause, notNull);
-  }
-}
-
-/**
- * Bypass: pushes table definitions to the database directly. Produces
- * CREATE TABLE IF NOT EXISTS + CREATE INDEX statements via renderTableDdl
- * and executes them via db/queries/test-stack. Idempotent re-runs are safe.
- *
- * Reserved for framework-internal meta-tables + test setup. App-defined
- * entities go through `kumiko schema apply` (committed SQL files).
- */
-export async function unsafePushTables(
-  db: DbConnection,
-  tables: Record<string, unknown>,
-  prevTables?: Record<string, unknown>,
-): Promise<void> {
-  const prevMetas = new Map<string, EntityTableMeta>();
-  if (prevTables) {
-    for (const [key, table] of Object.entries(prevTables)) {
-      const meta = tableToMeta(table);
-      prevMetas.set(key, meta);
-    }
-  }
-
-  for (const [key, table] of Object.entries(tables)) {
-    const meta = tableToMeta(table);
-    const prev = prevMetas.get(key);
-
-    if (prev) {
-      const prevCols = new Set(prev.columns.map((c) => c.name));
-      const newCols = meta.columns.filter((c) => !prevCols.has(c.name));
-      await addMissingColumns(db, meta.tableName, newCols);
-      const prevIdxNames = new Set(prev.indexes.map((i) => i.name));
-      for (const idx of meta.indexes) {
-        if (!prevIdxNames.has(idx.name)) {
-          const kind = idx.unique ? "UNIQUE INDEX" : "INDEX";
-          const colList = idx.columns.map((c) => `"${c}"`).join(", ");
-          await createIndexIfNotExists(db, kind, idx.name, meta.tableName, colList, idx.whereSql);
-        }
-      }
-    } else {
-      const statements = renderTableDdl(meta);
-      for (const stmt of statements) {
-        await executeDdlStatement(db, stmt);
-      }
-    }
-  }
-}
-
-// @wrapper-known semantic-alias
-function renderColumnType(col: ColumnMeta): string {
-  return pgTypeToSqlType(col.pgType);
-}
-
-/**
- * Wipes event store + framework-state + the given feature read-models in
- * one TRUNCATE, then re-registers the event-consumer state rows. Used in
- * test beforeEach-hooks to return the stack to a clean slate without
- * rebuilding it.
- */
-export async function resetEventStore(
-  stack: { db: unknown; eventDispatcher?: EventDispatcher },
-  extraTables: readonly (unknown | string)[] = [],
-): Promise<void> {
-  // A pass the dispatcher's own timer/LISTEN already started (from a
-  // preceding test) may still be writing into the tables truncated below —
-  // drain it first so the TRUNCATE never races a write it didn't cause.
-  if (stack.eventDispatcher) {
-    await stack.eventDispatcher.drain();
-  }
-  const frameworkTables = [
-    "kumiko_events",
-    "kumiko_event_consumers",
-    "kumiko_archived_streams",
-    "kumiko_snapshots",
-    "kumiko_projections",
-  ];
-  const extraNames = extraTables.map((t) => (typeof t === "string" ? t : tableNameOf(t)));
-  await truncateTablesRestartIdentity(stack.db, [...frameworkTables, ...extraNames]);
-  if (stack.eventDispatcher) {
-    await stack.eventDispatcher.ensureRegistered();
-  }
-}