@startsimpli/integrations 0.2.9 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.9",
+  "version": "0.2.13",
   "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/__tests__/corpus-tracker.test.tsx

@@ -247,6 +247,33 @@ describe('TrackerPage — what is outstanding', () => {
     render(<TrackerPage api={makeApi({ rows: [] })} scope={SCOPE} now={NOW} />);
     expect(await screen.findByText(/Nothing has been pulled out of your meetings yet/)).toBeInTheDocument();
   });
+
+  it('does NOT say the workspace is empty when a VIEW is empty', async () => {
+    // Browser-verified failure on the deployed tenant: the Overdue tab said
+    // "Nothing has been pulled out of your meetings yet" over ninety-seven open
+    // items, because nothing carried a due date. Advice that is false is worse
+    // than no advice.
+    const rows = [commitment({ externalId: 'commit:x', title: 'An open item' })];
+    const api: CommitmentTrackerApi = {
+      async listCommitments(query: CommitmentQuery = {}) {
+        // The server filters: the overdue query matches nothing, an unfiltered
+        // count-only probe still reports the workspace has rows.
+        const filtered = Boolean(query.dueBefore);
+        return {
+          count: filtered ? 0 : rows.length,
+          next: null, previous: null,
+          results: filtered ? [] : rows,
+          appliedFilters: ['status', 'dueBefore'],
+        };
+      },
+    };
+    render(<TrackerPage api={api} scope={SCOPE} now={NOW} />);
+    await screen.findByText('An open item');
+    await userEvent.click(screen.getByRole('tab', { name: 'Overdue' }));
+
+    expect(await screen.findByText(/Nothing matches this view/)).toBeInTheDocument();
+    expect(screen.queryByText(/Nothing has been pulled out of your meetings yet/)).not.toBeInTheDocument();
+  });
 });
 
 describe('TrackerPage — running the extraction', () => {

package/src/components/pages/TrackerPage.tsx

@@ -113,6 +113,18 @@ export function TrackerPage({
   const [error, setError] = React.useState('');
   const [run, setRun] = React.useState<ExtractionResult | null>(null);
   const [running, setRunning] = React.useState(false);
+  /**
+   * Does this workspace hold ANY commitments at all?
+   *
+   * Now that the server really filters, an empty page means one of two very
+   * different things and the screen owes the difference: "nothing has been
+   * pulled in yet" is advice, and saying it to somebody with ninety-seven open
+   * items and nothing overdue is simply false. Browser-verified on the deployed
+   * tenant — the Overdue tab said "Nothing has been pulled out of your meetings
+   * yet" over a corpus of ninety-seven. Resolved with ONE unfiltered
+   * count-only read, and only when a view comes back empty.
+   */
+  const [workspaceHasAny, setWorkspaceHasAny] = React.useState<boolean | null>(null);
 
   const query = React.useMemo<CommitmentQuery>(
     () => ({
@@ -136,6 +148,15 @@ export function TrackerPage({
       const page = await apiRef.current.listCommitments(query);
       setRows(page.results);
       setApplied(page.appliedFilters ?? []);
+      if (page.results.length > 0) {
+        setWorkspaceHasAny(true);
+      } else {
+        const any = await apiRef.current
+          .listCommitments({ pageSize: 1 })
+          .then((probe) => probe.count > 0)
+          .catch(() => null);
+        setWorkspaceHasAny(any);
+      }
     } catch (err) {
       setRows([]);
       setError(failureMessage(err));
@@ -249,9 +270,9 @@ export function TrackerPage({
 
         {!loading && visible.length === 0 ? (
           <p className={cn.muted}>
-            {rows.length === 0
+            {workspaceHasAny === false
               ? 'Nothing has been pulled out of your meetings yet. Connect a source, then run “Pull from meetings”.'
-              : 'Nothing matches this view. Everything here is either closed or filtered out.'}
+              : 'Nothing matches this view. Your other tabs may still have items.'}
           </p>
         ) : null}
 

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[]),
       };
     },