@cosmicdrift/kumiko-framework 0.230.0 → 0.232.0

package/src/jobs/__tests__/jobs.integration.test.ts

@@ -925,6 +925,9 @@ describe("perTenant across multiple runner instances", () => {
     // A post-close 'error' here is otherwise unhandled and bun:test
     // attributes it to whichever test runs next (fw#1805).
     rawQueue.on("error", () => {});
+    // Snapshot of completed wrapper runs — declared outside try so the
+    // post-finally fan-out check can read it.
+    let drainedCalls = 0;
     try {
       // Both instances call start() → both call upsertJobScheduler() with
       // the SAME schedulerId against the SAME Redis. If that didn't dedup,
@@ -937,27 +940,38 @@ describe("perTenant across multiple runner instances", () => {
       // called upsertJobScheduler() against it. Two entries here means two
       // independent repeat timers, which would double-fire every tick.
       expect(await rawQueue.getJobSchedulersCount()).toBe(1);
-      await waitFor(() => expect(wrapperCalls).toBeGreaterThanOrEqual(1), {
-        delays: [2000, 3000, 5000],
-      });
+      // Wait for the asserted drain state while workers are still up —
+      // stop() tears down consumers, so a post-finally sleep/assert races
+      // on unprocessed children (fw#2556: expected 4, got 2). Snapshot
+      // drainedCalls inside the predicate; do not assert a post-stop
+      // log-length ceiling — in-flight children (and sequential multi-
+      // runner stop) can still append after the snapshot.
+      await waitFor(
+        () => {
+          expect(wrapperCalls).toBeGreaterThanOrEqual(1);
+          expect(log.length).toBe(wrapperCalls * tenants.length);
+          drainedCalls = wrapperCalls;
+        },
+        { delays: [2000, 3000, 5000] },
+      );
     } finally {
-      // Stop immediately after catching the first tick so no further ticks
-      // can land mid-assertion — the invariant below still holds however
-      // many ticks slipped in before stop() took effect.
       await runnerA.stop();
       await runnerB.stop();
       await rawQueue.close();
     }
-    await sleep(300); // let any in-flight children land
 
     // Secondary sanity check only — this ratio holds whether the wrapper
     // fired once or twice per tick (wrapperCalls scales with it either
     // way), so it does not by itself prove the once-per-tick invariant.
     // It only confirms each wrapper run that did happen fanned out to
-    // every tenant exactly once.
-    expect(log.length).toBe(wrapperCalls * tenants.length);
-    const seenTenants = log.map((e) => e.tenantId).sort();
-    const expectedTenants = Array.from({ length: wrapperCalls }, () => tenants)
+    // every tenant exactly once. Slice to the drained prefix so a late
+    // tick that lands during stop() cannot break the multiset check.
+    expect(log.length).toBeGreaterThanOrEqual(drainedCalls * tenants.length);
+    const seenTenants = log
+      .slice(0, drainedCalls * tenants.length)
+      .map((e) => e.tenantId)
+      .sort();
+    const expectedTenants = Array.from({ length: drainedCalls }, () => tenants)
       .flat()
       .sort();
     expect(seenTenants).toEqual(expectedTenants);
@@ -1123,23 +1137,31 @@ describe("perTenant wrapper re-run for the same trigger", () => {
       queueNamePrefix,
       getActiveTenantIds,
     });
+    let drainedCalls = 0;
     try {
       await runner.start();
       // Two distinct ticks get two distinct repeat-job ids (different
       // millis) — each must still produce its own full batch of children;
       // a wrongly cross-tick dedup would collapse the second tick's log
       // entries into the first.
-      await waitFor(() => expect(wrapperCalls).toBeGreaterThanOrEqual(2), {
-        delays: [1500, 2000, 3000],
-      });
+      await waitFor(
+        () => {
+          expect(wrapperCalls).toBeGreaterThanOrEqual(2);
+          expect(log.length).toBe(wrapperCalls * tenants.length);
+          drainedCalls = wrapperCalls;
+        },
+        { delays: [1500, 2000, 3000] },
+      );
     } finally {
       await runner.stop();
     }
-    await sleep(300); // let any in-flight children land
 
-    expect(log.length).toBe(wrapperCalls * tenants.length);
-    const seenTenants = log.map((e) => e.tenantId).sort();
-    const expectedTenants = Array.from({ length: wrapperCalls }, () => tenants)
+    expect(log.length).toBeGreaterThanOrEqual(drainedCalls * tenants.length);
+    const seenTenants = log
+      .slice(0, drainedCalls * tenants.length)
+      .map((e) => e.tenantId)
+      .sort();
+    const expectedTenants = Array.from({ length: drainedCalls }, () => tenants)
       .flat()
       .sort();
     expect(seenTenants).toEqual(expectedTenants);

package/src/search/__tests__/search-pii-derived-index.integration.test.ts

@@ -10,7 +10,7 @@ import {
   subjectIdToKey,
 } from "../../crypto";
 import { asRawClient, buildEntityTable, createEventStoreExecutor, createTenantDb } from "../../db";
-import { createEntity, createTextField, defineFeature } from "../../engine";
+import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
 import { createEventsTable } from "../../event-store";
 import { setupTestStack, type TestStack, TestUsers, unsafeCreateEntityTable } from "../../stack";
 import { purgeSearchDocumentsForSubject } from "../purge-subject";
@@ -30,6 +30,16 @@ const contactFeature = defineFeature("search-pii-probe", (r) => {
   r.entity("contact", contactEntity);
 });
 
+const ghostSearchEntity = createEntity({
+  table: "read_search_pii_ghosts_missing",
+  fields: {
+    label: createTextField({ required: true, maxLength: 100, personal: "self", find: "fuzzy" }),
+  },
+});
+const ghostSearchFeature = defineFeature("search-pii-ghost", (r) => {
+  r.entity("ghost", ghostSearchEntity);
+});
+
 let stack: TestStack;
 let kms: InMemoryKmsAdapter;
 const admin = TestUsers.admin;
@@ -161,4 +171,34 @@ describe("searchable PII derived index (#1610)", () => {
     const after = await stack.search.search(admin.tenantId, plain, { filterType: "contact" });
     expect(after.some((h) => String(h.entityId) === id)).toBe(false);
   });
+
+  test("purgeSearchDocumentsForSubject skips missing projection tables (fw#2550)", async () => {
+    const plain = "MissingTableStillPurges1610";
+    const created = await executor().create({ label: plain, note: "n" }, admin, tenantDb());
+    if (!created.isSuccess) throw new Error("create failed");
+    const id = String(created.data.id);
+    await stack.eventDispatcher?.runOnce();
+    expect(
+      (await stack.search.search(admin.tenantId, plain, { filterType: "contact" })).some(
+        (h) => String(h.entityId) === id,
+      ),
+    ).toBe(true);
+
+    const subject = { kind: "user" as const, userId: id };
+    await kms.eraseKey(subject);
+    // Ghost searchable entity never got DDL — must not abort the purge.
+    const registry = createRegistry([contactFeature, ghostSearchFeature]);
+    await expect(
+      purgeSearchDocumentsForSubject(
+        stack.db,
+        registry.features,
+        stack.search,
+        subjectIdToKey(subject),
+        subject,
+      ),
+    ).resolves.toBeUndefined();
+
+    const after = await stack.search.search(admin.tenantId, plain, { filterType: "contact" });
+    expect(after.some((h) => String(h.entityId) === id)).toBe(false);
+  });
 });

package/src/search/purge-subject.ts

@@ -15,6 +15,7 @@ import { collectSearchableSubjectFields } from "../crypto/subject-resolver";
 import type { DbRunner } from "../db/connection";
 import { resolveTableName } from "../db/entity-table-meta";
 import { executeRawQueryRead } from "../db/queries/raw-sql";
+import { tableExists } from "../db/schema-inspection";
 import type { FeatureDefinition } from "../engine/types";
 import type { EntityDefinition } from "../engine/types/fields";
 import type { EntityId, TenantId } from "../engine/types/identifiers";
@@ -139,6 +140,10 @@ export async function purgeSearchDocumentsForSubject(
       const fields = collectSearchableSubjectFields(entity);
       if (fields.length === 0) continue;
       const tableName = resolveTableName(entityName, entity, undefined);
+      // Same post-eraseKey hazard as nullBlindIndexesForSubject (fw#2550):
+      // a mounted feature without its migration must not abort the purge
+      // (and the audit event after it).
+      if (!(await tableExists(db, tableName))) continue;
       const predicate = buildSubjectPredicate(entity, fields, likePattern, subject);
       const rows = await collectMatchingRowsForEntity(
         db,

package/src/testing/__tests__/wait-for.test.ts

@@ -60,4 +60,45 @@ describe("waitFor", () => {
     );
     expect(calls).toBe(2);
   });
+
+  test("polls a boolean predicate until it returns true", async () => {
+    let calls = 0;
+    await waitFor(
+      () => {
+        calls++;
+        return calls >= 3;
+      },
+      { delays: [1, 1, 1] },
+    );
+    expect(calls).toBe(3);
+  });
+
+  test("throws a descriptive error when a predicate stays false for the whole schedule", async () => {
+    let calls = 0;
+    await expect(
+      waitFor(
+        () => {
+          calls++;
+          return false;
+        },
+        { delays: [1, 1] },
+      ),
+    ).rejects.toThrow("waitFor: condition never became true within the delay schedule");
+    expect(calls).toBe(3);
+  });
+
+  test("returns immediately for a block-style fn that returns undefined without throwing", async () => {
+    let calls = 0;
+    const events = [1];
+    const started = Date.now();
+    await waitFor(
+      () => {
+        calls++;
+        expect(events).toHaveLength(1);
+      },
+      { delays: [2000] },
+    );
+    expect(calls).toBe(1);
+    expect(Date.now() - started).toBeLessThan(500);
+  });
 });

package/src/testing/wait-for.ts

@@ -6,13 +6,18 @@
  * next try — so N delays yield N+1 attempts and the full backoff budget.
  * Throws the last assertion error if all attempts fail.
  *
- * Usage:
+ * Usage (assertion form):
  *   await waitFor(() => {
  *     expect(events).toHaveLength(1);
  *   });
+ *
+ * Usage (predicate form — a literal `false` return means "not yet", anything
+ * else, including `undefined`, counts as success):
+ *   await waitFor(() => events.length >= 4);
  */
 export async function waitFor(
-  fn: () => void | Promise<void>,
+  // biome-ignore lint/suspicious/noConfusingVoidType: void must stay in the union so the existing expect(...) block form (implicit void return) still type-checks
+  fn: () => void | boolean | Promise<void | boolean>,
   options?: { delays?: number[] },
 ): Promise<void> {
   const delays = options?.delays ?? [250, 1000, 3000];
@@ -23,9 +28,11 @@ export async function waitFor(
 
   for (let i = 0; ; i++) {
     try {
-      await fn();
-      // skip: condition already true — no further polling
-      return;
+      const result = await fn();
+      if (result !== false) {
+        // skip: condition already true — no further polling
+        return;
+      }
     } catch (err) {
       lastError = err;
     }
@@ -35,5 +42,8 @@ export async function waitFor(
     await new Promise((r) => setTimeout(r, delays[i]));
   }
 
-  throw lastError;
+  if (lastError !== undefined) {
+    throw lastError;
+  }
+  throw new Error("waitFor: condition never became true within the delay schedule");
 }