@startsimpli/integrations 0.2.33 → 0.2.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "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__/connection-activity.test.tsx

@@ -0,0 +1,160 @@
+/**
+ * THE CONNECTION CARD SAYS WHY A RUN FAILED (bd startsim-ei8gm.2, part 2).
+ *
+ * `ConnectionRun.error_message` has been DECLARED in this package's own types
+ * for as long as the endpoint has existed, and no component in
+ * `packages/integrations` or `apps/foundry` has ever read it. `connectionRuns`
+ * is likewise required on both api interfaces and called by nothing. So the
+ * activity endpoint that `#375` just taught to answer a real reason for source
+ * runs has no reader at all: a failed run does not render as a status word — it
+ * does not render.
+ *
+ * ONE COMPOSER, TWO SURFACES. `ConnectionsPage` is mounted by the control plane
+ * (`apps/foundry`'s `<ConnectionsPage api={api.foundry} foundrySlug={slug} />`)
+ * and by a tenant member's own screen in `personal` mode. The disclosure is
+ * gated on the VERB EXISTING — the rule the file already applies to Workflows
+ * and Settings — so an app pinned to an older `@startsimpli/api` degrades to no
+ * control rather than to a button whose handler is `undefined`.
+ *
+ * NOTHING IS SCRUBBED HERE. The text arrives already redacted against that
+ * connection's stored credential plus the platform app_secret
+ * (`apps/connectors/services/surface.py::_reason_reader` ->
+ * `dispatch.redaction_list`), and a run whose reason could not be proven clean
+ * arrives as a sentence saying so. A second redaction path in the browser would
+ * be a second thing to get wrong, and the browser does not hold the secrets to
+ * do it with.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { ConnectionsPage } from '../components/pages/ConnectionsPage';
+import type { ConnectionsApi, ConnectionRun } from '../components/pages/types';
+
+const CATALOG = {
+  results: [
+    {
+      key: 'granola', name: 'Granola', description: 'Meeting notes',
+      logo_url: '', docs_url: '', capabilities: ['poll'], auth_mode: 'api_key',
+      credential_schema: { version: 1, fields: [] },
+      config_schema: { version: 1, fields: [] },
+      record_types: [], supports_webhooks: false,
+      availability: { available: true, reason: '' },
+    },
+  ],
+};
+
+const CONNECTED = {
+  results: [
+    {
+      id: 'c1', public_id: 'pub1', name: 'Tandem Granola',
+      connector_key: 'granola', connector_name: 'Granola',
+      external_account_id: '', account_label: 'tandem',
+      capabilities_enabled: ['poll'], config: {}, status: 'connected',
+      health: 'ok', auth_mode: 'api_key',
+    },
+  ],
+  permissions: { view: true, manage: true, issue_tokens: true },
+};
+
+/** What production held, verbatim, for each of the twenty failed polls. */
+const THE_REAL_REASON =
+  'connector_granola poll failed on page 1: [config_error] the response '
+  + 'exceeded the 262144-byte cap and was aborted [granola]';
+
+const RUNS: ConnectionRun[] = [
+  {
+    id: 'r-new', kind: 'destination_run', object_id: 'd1', name: 'Corpus delivery',
+    status: 'completed', run_type: 'scheduled',
+    occurred_at: '2026-08-27T04:24:08Z', error_message: '',
+  },
+  {
+    id: 'r-old', kind: 'source_run', object_id: 's1', name: 'granola-poll',
+    status: 'failed', run_type: 'incremental',
+    occurred_at: '2026-08-12T20:21:46Z', error_message: THE_REAL_REASON,
+  },
+];
+
+function stubApi(overrides: Partial<ConnectionsApi> = {}): ConnectionsApi {
+  return {
+    connectorCatalog: vi.fn().mockResolvedValue(CATALOG),
+    connections: vi.fn().mockResolvedValue(CONNECTED),
+    connect: vi.fn(),
+    checkConnection: vi.fn().mockResolvedValue({ ok: true, account_label: '', detail: '' }),
+    disconnect: vi.fn(),
+    connectionChoices: vi.fn(),
+    wireTarget: vi.fn(),
+    confirmTarget: vi.fn(),
+    connectionActions: vi.fn(),
+    invokeConnectionAction: vi.fn(),
+    connectionRuns: vi.fn().mockResolvedValue({ results: RUNS }),
+    updateConnection: vi.fn(),
+    rotateCredential: vi.fn(),
+    ...overrides,
+  } as unknown as ConnectionsApi;
+}
+
+async function openActivity(api: ConnectionsApi = stubApi()) {
+  render(<ConnectionsPage api={api} foundrySlug="tandem" />);
+  const button = await screen.findByRole('button', { name: /activity/i });
+  await userEvent.click(button);
+  return api;
+}
+
+describe('ConnectionCard — recent activity', () => {
+  it('has a control at all, which is the whole of the gap', async () => {
+    render(<ConnectionsPage api={stubApi()} foundrySlug="tandem" />);
+
+    expect(await screen.findByRole('button', { name: /activity/i })).toBeInTheDocument();
+  });
+
+  it('reads the runs endpoint that nothing has ever called', async () => {
+    const api = await openActivity();
+
+    await waitFor(() => expect(api.connectionRuns).toHaveBeenCalledWith('tandem', 'c1'));
+  });
+
+  it('renders the reason a failed run gives, not only its status word', async () => {
+    await openActivity();
+
+    expect(await screen.findByText(/262144-byte cap/)).toBeInTheDocument();
+  });
+
+  it('names which leg the run belongs to, since the card merges three tables', async () => {
+    await openActivity();
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).toHaveTextContent(/granola-poll/);
+    expect(activity).toHaveTextContent(/Corpus delivery/);
+  });
+
+  it('invents no reason for a run that succeeded', async () => {
+    await openActivity(stubApi({
+      connectionRuns: vi.fn().mockResolvedValue({ results: [RUNS[0]] }),
+    }) as ConnectionsApi);
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).not.toHaveTextContent(/262144/);
+  });
+
+  it('says so when there is no activity, rather than rendering an empty box', async () => {
+    await openActivity(stubApi({
+      connectionRuns: vi.fn().mockResolvedValue({ results: [] }),
+    }) as ConnectionsApi);
+
+    const activity = await screen.findByRole('group', { name: /recent activity/i });
+    expect(activity).toHaveTextContent(/no runs yet/i);
+  });
+
+  it('offers no control when the client is too old to have the verb', async () => {
+    // Apps consume `@startsimpli/*` as PUBLISHED packages, so a client pinned
+    // to an older `@startsimpli/api` is a normal state of the world. The gate
+    // is the verb existing — the same rule Workflows and Settings use.
+    const api = stubApi();
+    delete (api as Partial<ConnectionsApi>).connectionRuns;
+    render(<ConnectionsPage api={api} foundrySlug="tandem" />);
+
+    await screen.findByText('Tandem Granola');
+    expect(screen.queryByRole('button', { name: /activity/i })).not.toBeInTheDocument();
+  });
+});