@startsimpli/integrations 0.2.31 → 0.2.33

package/src/corpus/fixtures.ts

@@ -42,6 +42,7 @@ import {
   toParty,
   toSourceDocument,
 } from './entities';
+import { MAX_ID_LIST, RELATIONSHIP_FILTERS, RESERVED_PARAMS } from './entities';
 import type { TenantEntity, TenantRelationship } from './entities';
 import { splitSections, stem } from './text';
 import type {
@@ -869,11 +870,28 @@ export function createFixtureCorpusApi(options: FixtureCorpusOptions = {}): Corp
  *     search since this was written (bd startsim-768w.38.12) and a retrieval
  *     test must be written against the real semantics, but the suites that
  *     predate it are still testing what they were written to test. `source` and
- *     `party` are still accepted and ignored, exactly as `EntityViewSet` does;
- *   • `page_size` is IGNORED (`PageNumberPagination` with no
- *     `page_size_query_param`), so a caller asking for 200 gets `pageSize`;
- *   • `/api/v1/relationships/` returns every edge in the org, unfiltered,
- *     because the tenant has no `?source=` on it either.
+ *     `party` are accepted and ignored HERE, and this fixture no longer claims
+ *     that is what `EntityViewSet` does: 768w.38.12 shipped both, along with the
+ *     `applied_filters` report that names what the server narrowed by. So this
+ *     stands in for an OLDER fork — which is a useful thing to have a stand-in
+ *     for, since that is the fork `listSources` refuses to print a count for
+ *     (bd startsim-jevtu), but it is a lagging stub and not the contract;
+ *   • `page_size` IS honoured, capped at 200. It was written here as ignored,
+ *     citing a `PageNumberPagination` with no `page_size_query_param`, and that
+ *     stopped being true with `TenantPageNumberPagination` (bd
+ *     startsim-768w.38.12): "a client asking for one row to read a count got
+ *     fifty, and a client asking for two hundred to walk a graph got fifty and
+ *     no indication that its request had been overruled". A fixture that keeps
+ *     ignoring it manufactures evidence for a cap the wire does not impose;
+ *   • `/api/v1/relationships/` FILTERS — `rel_type`, `source`, `target`,
+ *     `entity` and the `__in` forms of the last three, bounded at
+ *     `MAX_ID_LIST` ids and reported in `applied_filters`. This too was written
+ *     here as "every edge in the org, unfiltered, because the tenant has no
+ *     `?source=` on it either", and bd startsim-te3r shipped `RelationshipQuery`
+ *     for exactly the read that comment was excusing. An UNRECOGNISED parameter
+ *     is still ignored and the page comes back as wide as it was — that part is
+ *     real, it is what makes an unconfirmed filter dangerous, and it is what
+ *     `applied_filters` exists to let a client detect.
  *
  * Every request is recorded, so "did the browser filter it" and "how many round
  * trips did one screen cost" are both assertable.
@@ -881,7 +899,7 @@ export function createFixtureCorpusApi(options: FixtureCorpusOptions = {}): Corp
 export function createFixtureCorpusHttp(options: {
   entities?: TenantEntity[];
   relationships?: TenantRelationship[];
-  /** Rows per page, matching the tenant's own `PAGE_SIZE`. */
+  /** Rows per page when the caller does not ask, matching the tenant's `PAGE_SIZE`. */
   pageSize?: number;
   /** Endpoints to fail, so the fail-soft paths are exercised. */
   missing?: string[];
@@ -901,15 +919,90 @@ export function createFixtureCorpusHttp(options: {
 
   function slice<T>(rows: T[], params: Record<string, unknown>) {
     const page = Number(params.page ?? 1) || 1;
-    const start = (page - 1) * pageSize;
+    // `TenantPageNumberPagination.page_size_query_param` is `page_size` and its
+    // `max_page_size` is 200 — an OVERRULED request is served at the cap, not
+    // refused, which is the behaviour a client that walks a page has to survive.
+    const asked = Number(params.page_size);
+    const size = Number.isFinite(asked) && asked > 0 ? Math.min(asked, MAX_ID_LIST) : pageSize;
+    const start = (page - 1) * size;
     return {
       count: rows.length,
-      next: start + pageSize < rows.length ? `?page=${page + 1}` : null,
+      next: start + size < rows.length ? `?page=${page + 1}` : null,
       previous: page > 1 ? `?page=${page - 1}` : null,
-      results: rows.slice(start, start + pageSize),
+      results: rows.slice(start, start + size),
     };
   }
 
+  /**
+   * `/api/v1/relationships/`, as `RelationshipQuery.apply` really answers it.
+   *
+   * THE SHAPE THAT MATTERS IS THE ONE IT REFUSES TO NARROW. A parameter this
+   * endpoint does not recognise is swept into `ignored_filters` and the page
+   * comes back exactly as wide as it was — so a fixture that returned `[]` for
+   * an unsupported filter would let a client pass here and read the whole edge
+   * table in production. Every filter below is one the server really applies,
+   * and everything else is really ignored.
+   */
+  function edgeQuery(rows: TenantRelationship[], params: Record<string, unknown>) {
+    const applied: string[] = [];
+    const ignored: string[] = [];
+    const idList = (key: string): Set<string> => {
+      const parts = String(params[key]).split(',').map((part) => part.trim()).filter(Boolean);
+      // `_uuid_list` refuses a longer list with a 400 rather than truncating it,
+      // which is what keeps `__in` from becoming an unpaginated read by another
+      // name — and what a client that chunks its ids has to be tested against.
+      if (parts.length > MAX_ID_LIST) {
+        throw Object.assign(new Error(`${key}: at most ${MAX_ID_LIST} ids`), { status: 400 });
+      }
+      return new Set(parts);
+    };
+    const typeOf = (id: unknown): string =>
+      String(entities.find((entity) => String(entity.id) === String(id))?.entity_type ?? '');
+    let out = rows;
+
+    for (const [key, field] of [['source', 'source'], ['target', 'target']] as const) {
+      if (key in params) {
+        const wanted = String(params[key]);
+        out = out.filter((edge) => String(edge[field]) === wanted);
+        applied.push(key);
+      }
+      const listed = `${key}__in`;
+      if (listed in params) {
+        const wanted = idList(listed);
+        out = out.filter((edge) => wanted.has(String(edge[field])));
+        applied.push(listed);
+      }
+    }
+    if ('entity' in params) {
+      const wanted = String(params.entity);
+      out = out.filter((edge) => String(edge.source) === wanted || String(edge.target) === wanted);
+      applied.push('entity');
+    }
+    if ('entity__in' in params) {
+      const wanted = idList('entity__in');
+      out = out.filter((edge) => wanted.has(String(edge.source)) || wanted.has(String(edge.target)));
+      applied.push('entity__in');
+    }
+    if ('rel_type' in params) {
+      const wanted = new Set(
+        String(params.rel_type).split(',').map((part) => part.trim()).filter(Boolean),
+      );
+      out = out.filter((edge) => wanted.has(String(edge.rel_type ?? edge.relType ?? '')));
+      applied.push('rel_type');
+    }
+    for (const [key, end] of [['source_type', 'source'], ['target_type', 'target']] as const) {
+      if (key in params) {
+        const wanted = String(params[key]);
+        out = out.filter((edge) => typeOf(edge[end]) === wanted);
+        applied.push(key);
+      }
+    }
+    for (const key of Object.keys(params)) {
+      if (!RESERVED_PARAMS.has(key) && !RELATIONSHIP_FILTERS.has(key)) ignored.push(key);
+    }
+    return { rows: out, applied, ignored };
+  }
+
   const http = {
     async get<T>(path: string, init?: { params?: Record<string, unknown> }): Promise<T> {
       const params = init?.params ?? {};
@@ -920,7 +1013,12 @@ export function createFixtureCorpusHttp(options: {
         throw Object.assign(new Error(`${path} responded 404`), { status: 404 });
       }
       if (path.includes('relationships')) {
-        return slice(relationships, params) as T;
+        const query = edgeQuery(relationships, params);
+        return {
+          ...slice(query.rows, params),
+          applied_filters: query.applied.slice().sort(),
+          ignored_filters: query.ignored.slice().sort(),
+        } as T;
       }
       if (path.includes('entities')) {
         const id = /entities\/(.+)$/.exec(path)?.[1];

package/src/corpus/runs.ts

@@ -303,7 +303,16 @@ export async function startExtractionRun(
   const at = now();
   const driver = request.driverId ?? options.driverId ?? defaultDriverId();
 
-  const existing = await deps.runs.readRun().catch(() => null);
+  // NOT `.catch(() => null)`. A store that could not answer is not a store that
+  // said "nothing has ever run", and this is the one place where confusing them
+  // is expensive: the branch below reads `null` as "start a new sweep", so a
+  // transient failure — or a read that could not see far enough (bd
+  // startsim-o0o6o.3) — put a SECOND driver on a live cursor, and two model
+  // calls over one document produce two items identity resolution cannot see are
+  // the same. `readRun` reports absence as `null` and everything else as a
+  // throw, precisely so this caller can tell them apart; swallowing the throw
+  // here threw that distinction away one line after it was made.
+  const existing = await deps.runs.readRun();
 
   if (existing && !COMPLETE.has(existing.status) && !request.restart) {
     if (isLeaseLive(existing, at) && existing.leaseOwner !== driver) {

package/src/corpus/types.ts

@@ -172,8 +172,22 @@ export interface MoneyEvent {
 export interface SourceFreshness {
   source: SourceKey;
   label: string;
-  /** How many documents this source has contributed to the corpus. */
-  documentCount: number;
+  /**
+   * How many documents this source has contributed to the corpus — counted OUT
+   * OF THE CORPUS, per source, and the only fact on a freshness card that is
+   * not central's connection bookkeeping (bd startsim-jevtu). That is what
+   * makes it worth its round trip: a source central reports as freshly synced
+   * that holds nothing here is the delivery hop failing, and no timestamp on
+   * the connection can say so.
+   *
+   * `null` means NOT COUNTED — the server did not confirm it narrowed by
+   * source, so the number it returned describes the whole corpus rather than
+   * this card. A screen renders nothing at all for `null`. `0` therefore means
+   * exactly what it says, which it did not before: the field was read off a
+   * connections payload that has never carried it, so every card everywhere
+   * reported `0` by accident.
+   */
+  documentCount: number | null;
   /**
    * THREE FACTS, AND CONFLATING ANY TWO OF THEM IS HOW A FRESHNESS STRIP LIES
    * (bd startsim-1cow). Central's `SubtreeConnectionsView` computes them