@cosmicdrift/kumiko-bundled-features 0.113.1 → 1.0.0

package/src/sessions/__tests__/auto-revoke-binding.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import type { AppContext, SaveContext } from "@cosmicdrift/kumiko-framework/engine";
-import { bindAutoRevokeFromFeature, createSessionsFeature } from "../feature";
-
-// The postSave hook is registered unconditionally; the revoker arrives either
-// as the explicit constructor option or late-bound by run{Prod,Dev}App via
-// bindAutoRevokeOnPasswordChange. These tests pin the binding + precedence
-// semantics at the hook level — the full DB sweep is covered by
-// password-auto-revoke.integration.test.ts.
-
-const passwordChange: SaveContext = {
-  kind: "save",
-  id: "user-1",
-  data: {},
-  changes: { passwordHash: "new-hash" },
-  previous: {},
-  isNew: false,
-};
-
-// @cast-boundary test fixture — the hook never touches AppContext
-const appContext = {} as unknown as AppContext;
-
-function userPostSaveHook(feature: ReturnType<typeof createSessionsFeature>) {
-  const hook = feature.entityHooks?.postSave?.["user"]?.[0];
-  if (!hook) throw new Error("sessions feature did not register the user postSave hook");
-  return (ctx: SaveContext) => hook.fn(ctx, appContext);
-}
-
-describe("sessions auto-revoke binding", () => {
-  test("late-bound revoker fires on password change", async () => {
-    const revoker = mock(async (_userId: string) => 1);
-    const feature = createSessionsFeature();
-
-    const bind = bindAutoRevokeFromFeature(feature);
-    expect(bind).toBeDefined();
-    bind?.(revoker);
-
-    await userPostSaveHook(feature)(passwordChange);
-    expect(revoker).toHaveBeenCalledTimes(1);
-    expect(revoker).toHaveBeenCalledWith("user-1");
-  });
-
-  test("unbound hook is a silent no-op", async () => {
-    const feature = createSessionsFeature();
-    // must resolve without throwing — stateless-JWT deployments have no revoker
-    const result = await userPostSaveHook(feature)(passwordChange);
-    expect(result).toBeUndefined();
-  });
-
-  test("skips isNew and non-passwordHash changes", async () => {
-    const revoker = mock(async (_userId: string) => 1);
-    const feature = createSessionsFeature();
-    bindAutoRevokeFromFeature(feature)?.(revoker);
-
-    await userPostSaveHook(feature)({ ...passwordChange, isNew: true });
-    await userPostSaveHook(feature)({ ...passwordChange, changes: { displayName: "x" } });
-    expect(revoker).not.toHaveBeenCalled();
-  });
-
-  test("explicit constructor option wins over the runtime binding", async () => {
-    const explicit = mock(async (_userId: string) => 1);
-    const lateBound = mock(async (_userId: string) => 1);
-    const feature = createSessionsFeature({ autoRevokeOnPasswordChange: explicit });
-
-    bindAutoRevokeFromFeature(feature)?.(lateBound);
-    await userPostSaveHook(feature)(passwordChange);
-
-    expect(explicit).toHaveBeenCalledWith("user-1");
-    expect(lateBound).not.toHaveBeenCalled();
-  });
-});

package/src/shared/chunked-entity-migration.ts

@@ -1,89 +0,0 @@
-// Shared loop for chunked, idempotent row migrations (secrets KEK rotation,
-// config re-encrypt, future entity-field re-encrypts). Owns the operational
-// mechanics — abort signal, deadline, failure circuit-breaker, batch
-// accounting — while the caller owns the domain: what a batch is and how a
-// single row migrates.
-//
-// Contract notes:
-//   - nextBatch() returning an empty array ends the run ("done"). Callers
-//     whose batch query re-evaluates (WHERE kek_version != current) converge
-//     naturally; full-scan callers return their one batch, then [].
-//   - migrateRow returns "migrated" | "skipped" (already current, lost a
-//     version_conflict race) | "failed" (counted against maxFailures);
-//     throws count as "failed" too and go through onRowError.
-//   - Rows that keep failing MAY be re-served by a re-evaluating nextBatch —
-//     the circuit-breaker (maxFailures) is what terminates that loop, same
-//     semantics the secrets rotate job always had.
-
-export type MigrationRowOutcome = "migrated" | "skipped" | "failed";
-
-export type ChunkedMigrationStopReason = "done" | "timeout" | "signal" | "too_many_failures";
-
-export type ChunkedMigrationResult = {
-  readonly migrated: number;
-  readonly skipped: number;
-  readonly failed: number;
-  readonly batchesProcessed: number;
-  readonly stoppedReason: ChunkedMigrationStopReason;
-};
-
-export type ChunkedMigrationOptions<Row> = {
-  readonly nextBatch: () => Promise<readonly Row[]>;
-  readonly migrateRow: (row: Row) => Promise<MigrationRowOutcome>;
-  readonly maxFailures: number;
-  // Epoch ms; Number.POSITIVE_INFINITY for no time bound.
-  readonly deadlineAt: number;
-  readonly signal?: AbortSignal | undefined;
-  readonly onRowError?: (row: Row, err: unknown) => void;
-};
-
-export async function runChunkedMigration<Row>(
-  opts: ChunkedMigrationOptions<Row>,
-): Promise<ChunkedMigrationResult> {
-  let migrated = 0;
-  let skipped = 0;
-  let failed = 0;
-  let batchesProcessed = 0;
-  let stoppedReason: ChunkedMigrationStopReason = "done";
-
-  outer: while (true) {
-    if (opts.signal?.aborted) {
-      stoppedReason = "signal";
-      break;
-    }
-    if (Date.now() >= opts.deadlineAt) {
-      stoppedReason = "timeout";
-      break;
-    }
-
-    const batch = await opts.nextBatch();
-    if (batch.length === 0) break;
-
-    batchesProcessed++;
-
-    if (failed >= opts.maxFailures) {
-      stoppedReason = "too_many_failures";
-      break;
-    }
-
-    for (const row of batch) {
-      if (failed >= opts.maxFailures) {
-        stoppedReason = "too_many_failures";
-        break outer;
-      }
-      let outcome: MigrationRowOutcome;
-      try {
-        outcome = await opts.migrateRow(row);
-      } catch (err) {
-        opts.onRowError?.(row, err);
-        failed++;
-        continue;
-      }
-      if (outcome === "migrated") migrated++;
-      else if (outcome === "skipped") skipped++;
-      else failed++;
-    }
-  }
-
-  return { migrated, skipped, failed, batchesProcessed, stoppedReason };
-}

package/src/shared/index.ts

@@ -1,7 +0,0 @@
-export {
-  type ChunkedMigrationOptions,
-  type ChunkedMigrationResult,
-  type ChunkedMigrationStopReason,
-  type MigrationRowOutcome,
-  runChunkedMigration,
-} from "./chunked-entity-migration";

package/src/tags/__tests__/schemas.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { assignTagPayloadSchema } from "../schemas";
-
-// 456/3: tagAssignmentAggregateId joins tenantId/tagId/entityType/entityId
-// with "|" to derive the stream id — a literal "|" in entityType/entityId
-// could shift tuple boundaries and collide with an unrelated combination.
-describe("assignTagPayloadSchema — no pipe in entityType/entityId", () => {
-  test("accepts normal values", () => {
-    const parsed = assignTagPayloadSchema.safeParse({
-      tagId: "tag-1",
-      entityType: "credit",
-      entityId: "entity-1",
-    });
-    expect(parsed.success).toBe(true);
-  });
-
-  test("rejects a pipe in entityType", () => {
-    const parsed = assignTagPayloadSchema.safeParse({
-      tagId: "tag-1",
-      entityType: "credit|forged",
-      entityId: "entity-1",
-    });
-    expect(parsed.success).toBe(false);
-  });
-
-  test("rejects a pipe in entityId", () => {
-    const parsed = assignTagPayloadSchema.safeParse({
-      tagId: "tag-1",
-      entityType: "credit",
-      entityId: "entity|forged",
-    });
-    expect(parsed.success).toBe(false);
-  });
-});

package/src/tags/web/__tests__/tag-manager.test.tsx

@@ -1,64 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-import {
-  createStaticLocaleResolver,
-  LocaleProvider,
-  PrimitivesProvider,
-} from "@cosmicdrift/kumiko-renderer";
-import { defaultPrimitives } from "@cosmicdrift/kumiko-renderer-web";
-import { fireEvent, render, screen } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { defaultTranslations } from "../i18n";
-import { TagManager } from "../tag-manager";
-
-type TagRow = { id: string; name: string; color?: string; scope?: string; version: number };
-
-let catalogRows: readonly TagRow[] = [];
-
-beforeEach(() => {
-  catalogRows = [{ id: "t1", name: "urgent", color: "#ef4444", version: 1 }];
-});
-
-const dispatchSpy = mock(async () => ({ isSuccess: true, data: undefined }));
-
-const actual_renderer = await import("@cosmicdrift/kumiko-renderer");
-mock.module("@cosmicdrift/kumiko-renderer", () => ({
-  ...actual_renderer,
-  useDispatcher: mock(() => ({ write: dispatchSpy, query: mock(), batch: mock() })),
-  useQuery: mock(() => ({
-    data: { rows: catalogRows },
-    loading: false,
-    error: null,
-    refetch: mock(),
-  })),
-}));
-
-function Wrapper({ children }: { readonly children: ReactNode }): ReactNode {
-  return (
-    <LocaleProvider resolver={createStaticLocaleResolver()} fallbackBundles={[defaultTranslations]}>
-      <PrimitivesProvider value={defaultPrimitives}>{children}</PrimitivesProvider>
-    </LocaleProvider>
-  );
-}
-
-// 695/4: saveEdit silently no-ops on an empty trimmed name — the Save button
-// must reflect that in its disabled state, not just in the click handler.
-describe("TagManager — edit Save button", () => {
-  test("Save is disabled once the name is cleared to empty/whitespace", () => {
-    render(
-      <Wrapper>
-        <TagManager />
-      </Wrapper>,
-    );
-    fireEvent.click(screen.getByTestId("tag-manager-edit-btn-t1"));
-
-    const save = screen.getByTestId("tag-manager-save-t1") as HTMLButtonElement;
-    expect(save.disabled).toBe(false);
-
-    const nameInput = document.getElementById("tag-edit-name-t1") as HTMLInputElement;
-    fireEvent.change(nameInput, { target: { value: "   " } });
-    expect(save.disabled).toBe(true);
-
-    fireEvent.change(nameInput, { target: { value: "renamed" } });
-    expect(save.disabled).toBe(false);
-  });
-});

package/src/user/__tests__/stream-tenant-backfill.integration.test.ts

@@ -1,186 +0,0 @@
-// #762 — backfillUserStreamTenants: pre-#497 user streams live on the
-// creating tenant; post-#497 the executor addresses SYSTEM_TENANT_ID, so
-// legacy users version-conflict on every write (password-reset collapses to
-// invalid_token). The backfill retenants + renumbers per aggregate in global
-// id order — including the split-stream case the raw #497-changeset SQL
-// crashes on (legacy tenant v1..n AND post-#497 SYSTEM events for the same
-// aggregate → events_aggregate_version_uq violation).
-
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
-import { createEventStoreExecutor, createTenantDb } from "@cosmicdrift/kumiko-framework/db";
-import {
-  createSystemUser,
-  SYSTEM_TENANT_ID,
-  type TenantId,
-} from "@cosmicdrift/kumiko-framework/engine";
-import { append, createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
-import {
-  createTestDb,
-  type TestDb,
-  unsafeCreateEntityTable,
-} from "@cosmicdrift/kumiko-framework/stack";
-import { backfillUserStreamTenants } from "../db/queries/stream-tenant-backfill";
-import { userEntity, userTable } from "../schema/user";
-
-const T1 = "00000000-0000-4000-8000-000000000011" as TenantId;
-const LEGACY_USER = "aaaaaaaa-0000-4000-8000-000000000001";
-const SPLIT_USER = "aaaaaaaa-0000-4000-8000-000000000002";
-const MODERN_USER = "aaaaaaaa-0000-4000-8000-000000000003";
-
-let testDb: TestDb;
-
-const executor = createEventStoreExecutor(userTable, userEntity, { entityName: "user" });
-
-beforeAll(async () => {
-  testDb = await createTestDb();
-  await unsafeCreateEntityTable(testDb.db, userEntity, "user");
-  await createEventsTable(testDb.db);
-});
-
-afterAll(async () => {
-  await testDb.cleanup();
-});
-
-beforeEach(async () => {
-  await asRawClient(testDb.db).unsafe(
-    `TRUNCATE kumiko_events, kumiko_snapshots, kumiko_archived_streams, read_users RESTART IDENTITY CASCADE`,
-  );
-});
-
-async function appendUserEvent(
-  aggregateId: string,
-  tenantId: TenantId,
-  expectedVersion: number,
-  type: string,
-  payload: Record<string, unknown>,
-): Promise<void> {
-  await append(testDb.db, {
-    aggregateId,
-    aggregateType: "user",
-    tenantId,
-    expectedVersion,
-    type,
-    payload,
-    metadata: { userId: "test-migrator" },
-  });
-}
-
-async function streamRows(
-  aggregateId: string,
-): Promise<ReadonlyArray<{ tenant_id: string; version: number; type: string }>> {
-  return (await asRawClient(testDb.db).unsafe(
-    `SELECT "tenant_id", "version", "type" FROM "kumiko_events"
-      WHERE "aggregate_id" = $1::uuid ORDER BY "id" ASC`,
-    [aggregateId],
-  )) as ReadonlyArray<{ tenant_id: string; version: number; type: string }>;
-}
-
-function seedUserRow(id: string, tenantId: TenantId, version: number) {
-  return asRawClient(testDb.db).unsafe(
-    `INSERT INTO "read_users" ("id", "tenant_id", "email", "display_name", "locale", "password_hash", "status", "version")
-     VALUES ($1::uuid, $2::uuid, $3, 'Legacy', 'de', 'x', 'active', $4)`,
-    [id, tenantId, `${id.slice(0, 8)}@example.com`, version],
-  );
-}
-
-describe("backfillUserStreamTenants (#762)", () => {
-  test("legacy stream: retenanted to SYSTEM, versions contiguous, executor write works again", async () => {
-    await appendUserEvent(LEGACY_USER, T1, 0, "user.created", { email: "l@example.com" });
-    await appendUserEvent(LEGACY_USER, T1, 1, "user.updated", { changes: { displayName: "L" } });
-    await seedUserRow(LEGACY_USER, T1, 2);
-
-    const result = await backfillUserStreamTenants(testDb.db);
-    expect(result.aggregatesMigrated).toBe(1);
-    expect(result.eventsMigrated).toBe(2);
-    expect(result.failed).toHaveLength(0);
-
-    const rows = await streamRows(LEGACY_USER);
-    expect(rows.map((r) => r.tenant_id)).toEqual([SYSTEM_TENANT_ID, SYSTEM_TENANT_ID]);
-    expect(rows.map((r) => r.version)).toEqual([1, 2]);
-
-    // The actual #762 symptom: an optimistic-locked executor update with the
-    // row version now targets a stream that HAS that version — no conflict.
-    const tdb = createTenantDb(testDb.db, SYSTEM_TENANT_ID, "system");
-    const writeRes = await executor.update(
-      { id: LEGACY_USER, version: 2, changes: { displayName: "After" } },
-      createSystemUser(SYSTEM_TENANT_ID),
-      tdb,
-    );
-    expect(writeRes.isSuccess).toBe(true);
-  });
-
-  test("split stream (legacy + post-#497 SYSTEM events) merges in global id order", async () => {
-    // Legacy: created + updated on T1 (v1, v2). Then a post-#497 lifecycle
-    // write appended v1 on SYSTEM — the split the raw changeset-SQL trips on.
-    await appendUserEvent(SPLIT_USER, T1, 0, "user.created", { email: "s@example.com" });
-    await appendUserEvent(SPLIT_USER, T1, 1, "user.updated", { changes: { a: 1 } });
-    await appendUserEvent(SPLIT_USER, SYSTEM_TENANT_ID, 0, "user.updated", {
-      changes: { status: "restricted" },
-    });
-    await seedUserRow(SPLIT_USER, T1, 2);
-
-    const result = await backfillUserStreamTenants(testDb.db);
-    expect(result.aggregatesMigrated).toBe(1);
-    expect(result.eventsMigrated).toBe(3);
-    expect(result.failed).toHaveLength(0);
-
-    const rows = await streamRows(SPLIT_USER);
-    expect(rows.map((r) => r.tenant_id)).toEqual([
-      SYSTEM_TENANT_ID,
-      SYSTEM_TENANT_ID,
-      SYSTEM_TENANT_ID,
-    ]);
-    // Renumbered by global event id: created, updated(T1), updated(SYSTEM).
-    expect(rows.map((r) => r.version)).toEqual([1, 2, 3]);
-    expect(rows[0]?.type).toBe("user.created");
-  });
-
-  test("idempotent: second run finds nothing; modern SYSTEM streams untouched", async () => {
-    await appendUserEvent(MODERN_USER, SYSTEM_TENANT_ID, 0, "user.created", {
-      email: "m@example.com",
-    });
-    await appendUserEvent(LEGACY_USER, T1, 0, "user.created", { email: "l@example.com" });
-
-    const first = await backfillUserStreamTenants(testDb.db);
-    expect(first.aggregatesMigrated).toBe(1);
-
-    const second = await backfillUserStreamTenants(testDb.db);
-    expect(second.aggregatesMigrated).toBe(0);
-    expect(second.eventsMigrated).toBe(0);
-
-    const modern = await streamRows(MODERN_USER);
-    expect(modern).toHaveLength(1);
-    expect(modern[0]?.version).toBe(1);
-  });
-
-  test("stale snapshots dropped, archived-stream marker moves to SYSTEM", async () => {
-    await appendUserEvent(LEGACY_USER, T1, 0, "user.created", { email: "l@example.com" });
-    await asRawClient(testDb.db).unsafe(
-      `INSERT INTO "kumiko_snapshots" ("aggregate_id", "aggregate_type", "tenant_id", "version", "state")
-       VALUES ($1::uuid, 'user', $2::uuid, 1, '{}'::jsonb)`,
-      [LEGACY_USER, T1],
-    );
-    await asRawClient(testDb.db).unsafe(
-      `INSERT INTO "kumiko_archived_streams" ("tenant_id", "aggregate_id", "aggregate_type", "archived_by")
-       VALUES ($1::uuid, $2::uuid, 'user', 'test')`,
-      [T1, LEGACY_USER],
-    );
-
-    const result = await backfillUserStreamTenants(testDb.db);
-    expect(result.failed).toHaveLength(0);
-
-    const snapshots = (await asRawClient(testDb.db).unsafe(
-      `SELECT count(*)::int AS n FROM "kumiko_snapshots" WHERE "aggregate_id" = $1::uuid`,
-      [LEGACY_USER],
-    )) as ReadonlyArray<{ n: number }>;
-    expect(snapshots[0]?.n).toBe(0);
-
-    const archived = (await asRawClient(testDb.db).unsafe(
-      `SELECT "tenant_id" FROM "kumiko_archived_streams" WHERE "aggregate_id" = $1::uuid`,
-      [LEGACY_USER],
-    )) as ReadonlyArray<{ tenant_id: string }>;
-    expect(archived).toHaveLength(1);
-    expect(archived[0]?.tenant_id).toBe(SYSTEM_TENANT_ID);
-  });
-});

package/src/user/db/queries/stream-tenant-backfill.ts

@@ -1,112 +0,0 @@
-// #762 — one-time migration tooling for pre-#497 user event streams.
-//
-// #497 made `user` a systemStream entity: every executor op addresses the
-// stream on SYSTEM_TENANT_ID. Streams created before that live on whichever
-// tenant created them ("scattered"), so post-#497 writes version-conflict
-// against the empty SYSTEM stream. The raw UPDATE documented in the #497
-// changeset breaks as soon as an aggregate has BOTH a legacy stream and
-// post-#497 SYSTEM events (split stream — e.g. a skipOptimisticLock
-// lifecycle write appended v1 on SYSTEM while v1..n live on the old
-// tenant): retenanting then trips events_aggregate_version_uq.
-//
-// This tool merges per aggregate: all user events, ordered by global event
-// id, are renumbered 1..n and retenanted to SYSTEM_TENANT_ID — two-phase
-// version writes (negative interim values) dodge the unique index while the
-// per-aggregate transaction is in flight. Snapshots of migrated aggregates
-// are dropped (version numbering changed; the next snapshotting load
-// recreates them); archived-stream markers move with the stream.
-//
-// Idempotent: the candidate query only matches aggregates that still have
-// non-SYSTEM events. One failing aggregate does not abort the run — the
-// rest of the estate migrates, failures are reported.
-//
-// After a run, rebuild the user projection so read_users.tenant_id reflects
-// the stream move: rebuildProjection("user:projection:user-entity", ...) or
-// the jobs:job:projection-rebuild job.
-
-import { asRawClient, transaction } from "@cosmicdrift/kumiko-framework/bun-db";
-import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
-
-export type UserStreamBackfillResult = {
-  readonly aggregatesMigrated: number;
-  readonly eventsMigrated: number;
-  readonly failed: ReadonlyArray<{ readonly aggregateId: string; readonly error: string }>;
-};
-
-export async function backfillUserStreamTenants(
-  db: DbConnection,
-): Promise<UserStreamBackfillResult> {
-  const candidates = (await asRawClient(db).unsafe(
-    `SELECT DISTINCT "aggregate_id" FROM "kumiko_events"
-      WHERE "aggregate_type" = 'user' AND "tenant_id" <> $1::uuid`,
-    [SYSTEM_TENANT_ID],
-  )) as ReadonlyArray<{ aggregate_id: string }>;
-
-  let aggregatesMigrated = 0;
-  let eventsMigrated = 0;
-  const failed: Array<{ aggregateId: string; error: string }> = [];
-
-  for (const { aggregate_id } of candidates) {
-    try {
-      eventsMigrated += await migrateAggregate(db, aggregate_id);
-      aggregatesMigrated++;
-    } catch (e) {
-      failed.push({
-        aggregateId: aggregate_id,
-        error: e instanceof Error ? e.message : String(e),
-      });
-    }
-  }
-  return { aggregatesMigrated, eventsMigrated, failed };
-}
-
-async function migrateAggregate(db: DbConnection, aggregateId: string): Promise<number> {
-  return transaction(db, async (tx) => {
-    const raw = asRawClient(tx);
-    // Global id order = commit-adjacent replay order; merges a split stream
-    // (legacy tenant + SYSTEM) into one consistent version sequence.
-    const events = (await raw.unsafe(
-      `SELECT "id" FROM "kumiko_events"
-        WHERE "aggregate_type" = 'user' AND "aggregate_id" = $1::uuid
-        ORDER BY "id" ASC
-        FOR UPDATE`,
-      [aggregateId],
-    )) as ReadonlyArray<{ id: bigint | string }>;
-
-    // Phase 1: negative interim versions — real versions are always >= 1, so
-    // nothing can collide with events_aggregate_version_uq mid-migration.
-    for (const [i, ev] of events.entries()) {
-      await raw.unsafe(
-        `UPDATE "kumiko_events" SET "tenant_id" = $1::uuid, "version" = $2 WHERE "id" = $3`,
-        [SYSTEM_TENANT_ID, -(i + 1), ev.id],
-      );
-    }
-    // Phase 2: final contiguous 1..n.
-    for (const [i, ev] of events.entries()) {
-      await raw.unsafe(`UPDATE "kumiko_events" SET "version" = $1 WHERE "id" = $2`, [i + 1, ev.id]);
-    }
-
-    // Version numbering changed → any snapshot of this aggregate is stale.
-    await raw.unsafe(`DELETE FROM "kumiko_snapshots" WHERE "aggregate_id" = $1::uuid`, [
-      aggregateId,
-    ]);
-
-    // Archived markers key on (tenant_id, aggregate_id) — move them with the
-    // stream, keeping an existing SYSTEM marker if both exist.
-    await raw.unsafe(
-      `INSERT INTO "kumiko_archived_streams" ("tenant_id", "aggregate_id", "aggregate_type", "archived_at", "archived_by", "reason")
-        SELECT $1::uuid, "aggregate_id", "aggregate_type", "archived_at", "archived_by", "reason"
-          FROM "kumiko_archived_streams"
-         WHERE "aggregate_id" = $2::uuid AND "tenant_id" <> $1::uuid
-        ON CONFLICT DO NOTHING`,
-      [SYSTEM_TENANT_ID, aggregateId],
-    );
-    await raw.unsafe(
-      `DELETE FROM "kumiko_archived_streams" WHERE "aggregate_id" = $1::uuid AND "tenant_id" <> $2::uuid`,
-      [aggregateId, SYSTEM_TENANT_ID],
-    );
-
-    return events.length;
-  });
-}