@startsimpli/integrations 0.2.9 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Provider-agnostic types, API clients, hooks, and UI primitives for email + calendar integrations across StartSimpli apps.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/corpus-storage.test.ts

@@ -367,6 +367,29 @@ describe('listCommitments speaks the tenant data API’s own filter language', (
     expect(page.appliedFilters).not.toContain('owner');
   });
 
+  it('believes the server through the CAMELCASE client too', async () => {
+    // `@startsimpli/api` converts every response key snake_case -> camelCase, so
+    // in a browser the tenant's `applied_filters` arrives as `appliedFilters`.
+    // Reading only one spelling put "this workspace's data API did not filter by
+    // status" on a deployed screen while the server was demonstrably filtering
+    // by status. Same lesson as accepting `document_id` in a citation.
+    const seen: Array<Record<string, unknown>> = [];
+    const api = createCorpusApi({
+      http: {
+        async get<T>(_path: string, options?: { params?: Record<string, unknown> }): Promise<T> {
+          seen.push(options?.params ?? {});
+          return { count: 0, next: null, previous: null, results: [],
+                   appliedFilters: ['attr.status__in'], ignoredFilters: [] } as T;
+        },
+      },
+      scope: { orgId: 'tandem' },
+      supportedFilters: [],
+    });
+    const page = await api.listCommitments({ status: ['open', 'blocked'] });
+    expect(page.appliedFilters).toEqual(['status']);
+    expect(seen[0]['attr.status__in']).toBe('open,blocked');
+  });
+
   it('falls back to the declared list on a server that does not report', async () => {
     const { api } = client(undefined);
     const page = await api.listCommitments({ status: 'open' });

package/src/corpus/client.ts

@@ -125,7 +125,22 @@ interface DrfPage<T> {
  */
 interface ServerFilterReport {
   applied_filters?: string[];
+  /**
+   * BOTH SPELLINGS, and this is not defensive padding — it is the difference
+   * between the banner telling the truth and telling a lie.
+   *
+   * `@startsimpli/api`'s fetch wrapper converts every response key from
+   * snake_case to camelCase by default (`transformKeys`), so the tenant's
+   * `applied_filters` reaches this adapter as `appliedFilters` in the browser
+   * and as `applied_filters` from a plain server-side `fetch`. Reading only one
+   * made the deployed Tracker report "this workspace's data API did not filter
+   * by status" while the server was, verifiably, filtering by status. Same
+   * lesson as `resolveCitations` accepting `document_id`: the tolerance belongs
+   * at the seam.
+   */
+  appliedFilters?: string[];
   ignored_filters?: string[];
+  ignoredFilters?: string[];
   search_backend?: string;
 }
 
@@ -170,6 +185,22 @@ const FILTER_PARAMS: Array<[keyof CommitmentQuery, string[]]> = [
   ['search', ['search']],
 ];
 
+/** Which server parameter carries which `DocumentQuery` key. */
+const DOCUMENT_FILTER_PARAMS: Array<[keyof DocumentQuery, string[]]> = [
+  ['search', ['search']],
+  ['source', ['source', 'attr.source']],
+  ['partyId', ['party', 'related_to']],
+  ['occurredAfter', ['occurred_after', 'attr.occurred_at__gte']],
+  ['occurredBefore', ['occurred_before', 'attr.occurred_at__lte']],
+];
+
+function reportedDocumentFilters(query: DocumentQuery, applied: string[]): string[] {
+  const server = new Set(applied);
+  return DOCUMENT_FILTER_PARAMS.filter(
+    ([key, names]) => Boolean(query[key]) && names.some((name) => server.has(name)),
+  ).map(([key]) => key);
+}
+
 /** Translate the server's report back into the composer's vocabulary. */
 function reportedFilters(query: CommitmentQuery, applied: string[]): string[] {
   const server = new Set(applied);
@@ -227,15 +258,20 @@ export function createCorpusApi(options: CreateCorpusApiOptions): CorpusApi & Co
     query: DocumentQuery,
     map: (entity: TenantEntity) => T,
   ): Promise<CorpusPage<T>> {
-    const response = await http.get<DrfPage<TenantEntity>>(entities, {
+    const response = await http.get<DrfPage<TenantEntity> & ServerFilterReport>(entities, {
       params: params(query, type),
     });
+    // The SERVER's own report wins here too — the Library was reading a
+    // hardcoded list while the tenant had learned to filter.
+    const reported = response.applied_filters ?? response.appliedFilters;
     return {
       count: response.count ?? response.results?.length ?? 0,
       next: response.next ?? null,
       previous: response.previous ?? null,
       results: (response.results ?? []).map(map),
-      appliedFilters: appliedFilters(query, supportedFilters),
+      appliedFilters: reported
+        ? reportedDocumentFilters(query, reported)
+        : appliedFilters(query, supportedFilters as string[]),
     };
   }
 
@@ -344,6 +380,7 @@ export function createCorpusApi(options: CreateCorpusApiOptions): CorpusApi & Co
     async listCommitments(query: CommitmentQuery = {}): Promise<CorpusPage<Commitment>> {
       const params = commitmentParams(query, types.commitment);
       const response = await http.get<DrfPage<TenantEntity> & ServerFilterReport>(entities, { params });
+      const reported = response.applied_filters ?? response.appliedFilters;
       return {
         count: response.count ?? response.results?.length ?? 0,
         next: response.next ?? null,
@@ -355,8 +392,8 @@ export function createCorpusApi(options: CreateCorpusApiOptions): CorpusApi & Co
         // do — and cannot claim a gap that has since been closed. The static
         // `supportedFilters` list is only the fallback for a deployment old
         // enough not to report.
-        appliedFilters: response.applied_filters
-          ? reportedFilters(query, response.applied_filters)
+        appliedFilters: reported
+          ? reportedFilters(query, reported)
           : appliedFilters(query as DocumentQuery, supportedFilters as string[]),
       };
     },