@startsimpli/funnels 0.4.11 → 0.4.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/funnels",
-  "version": "0.4.11",
+  "version": "0.4.14",
   "description": "Brutally generic filtering pipeline package for any Simpli product",
   "type": "module",
   "main": "./src/index.ts",
@@ -38,25 +38,13 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/simpli/start-simpli-api",
+    "url": "git+https://github.com/qosha1/start-simpli.git",
     "directory": "packages/funnels"
   },
   "bugs": {
-    "url": "https://github.com/simpli/start-simpli-api/issues"
-  },
-  "homepage": "https://github.com/simpli/start-simpli-api/tree/main/packages/funnels#readme",
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "type-check": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "clean": "rm -rf dist",
-    "storybook": "storybook dev -p 6006",
-    "build-storybook": "storybook build",
-    "storybook:ci": "storybook build --test"
+    "url": "https://github.com/qosha1/start-simpli/issues"
   },
+  "homepage": "https://github.com/qosha1/start-simpli/tree/main/packages/funnels#readme",
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
@@ -94,5 +82,17 @@
     "@dnd-kit/sortable": "^8.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@xyflow/react": "^12.10.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "clean": "rm -rf dist",
+    "storybook": "storybook dev -p 6006",
+    "build-storybook": "storybook build",
+    "storybook:ci": "storybook build --test"
   }
-}
+}

package/src/api/client.paths.test.ts

@@ -0,0 +1,162 @@
+/**
+ * FunnelApiClient against an injected path family (bd startsim-pxzlf).
+ *
+ * client.test.ts covers the default (central) family and the error handling.
+ * This file covers the part that was impossible before: pointing the SAME
+ * client at the control-plane route, a tenant proxy, or a fork's own mount.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { FunnelApiClient } from './client';
+import { createFunnelPaths, foundryTenantFunnelPaths } from './paths';
+import type { ApiAdapter } from './adapter';
+
+class RecordingAdapter implements ApiAdapter {
+  public calls: { method: string; url: string; data?: unknown; params?: unknown }[] = [];
+  public nextResponse: unknown = {};
+
+  async get<T>(url: string, params?: Record<string, unknown>): Promise<T> {
+    this.calls.push({ method: 'GET', url, params });
+    return this.nextResponse as T;
+  }
+  async post<T>(url: string, data: unknown): Promise<T> {
+    this.calls.push({ method: 'POST', url, data });
+    return this.nextResponse as T;
+  }
+  async patch<T>(url: string, data: unknown): Promise<T> {
+    this.calls.push({ method: 'PATCH', url, data });
+    return this.nextResponse as T;
+  }
+  async delete<T>(url: string): Promise<T> {
+    this.calls.push({ method: 'DELETE', url });
+    return this.nextResponse as T;
+  }
+  get lastUrl(): string {
+    return this.calls[this.calls.length - 1]?.url ?? '';
+  }
+}
+
+describe('FunnelApiClient path injection', () => {
+  let adapter: RecordingAdapter;
+
+  beforeEach(() => {
+    adapter = new RecordingAdapter();
+  });
+
+  it('keeps the central family when no paths are injected — the old constructor still works', async () => {
+    const client = new FunnelApiClient(adapter, 'https://api.startsimpli.com');
+    await client.listFunnels();
+    expect(adapter.lastUrl).toBe('https://api.startsimpli.com/api/v1/funnels/');
+    await client.getFunnelRun('r1');
+    expect(adapter.lastUrl).toBe('https://api.startsimpli.com/api/v1/funnel-runs/r1/');
+  });
+
+  it('talks to a foundry control-plane route when given that family', async () => {
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+
+    await client.listFunnels({ status: 'active' });
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/');
+
+    await client.getFunnel('f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/');
+
+    await client.runFunnel('f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/run/');
+
+    await client.getFunnelRuns('f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/');
+  });
+
+  it('addresses a nested run through its funnel on the control plane', async () => {
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    await client.getFunnelRun('r1', 'f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/r1/');
+    await client.getFunnelResults('r1', { funnelId: 'f1' });
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/r1/results/');
+    await client.cancelFunnelRun('r1', 'f1');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/r1/cancel/');
+  });
+
+  it('talks through a tenant proxy prefix', async () => {
+    const client = new FunnelApiClient(
+      adapter,
+      '',
+      createFunnelPaths({
+        prefix: '/central-api/api/v1/funnels',
+        runsPrefix: '/central-api/api/v1/funnel-runs',
+      })
+    );
+    await client.listFunnels();
+    expect(adapter.lastUrl).toBe('/central-api/api/v1/funnels/');
+    await client.getFunnelRun('r1');
+    expect(adapter.lastUrl).toBe('/central-api/api/v1/funnel-runs/r1/');
+  });
+
+  it('exposes the family it was built with, so a composer can tell the surfaces apart', () => {
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    expect(client.paths.prefix).toBe('/api/v1/foundry/tenants/acme/funnels');
+  });
+});
+
+describe('FunnelApiClient.getFields', () => {
+  let adapter: RecordingAdapter;
+
+  beforeEach(() => {
+    adapter = new RecordingAdapter();
+  });
+
+  it('fetches the field registry from the family it was pointed at', async () => {
+    adapter.nextResponse = { entity_type: 'contact', fields: [] };
+    const client = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
+    await client.getFields('contact');
+    expect(adapter.lastUrl).toBe('/api/v1/foundry/tenants/acme/funnels/fields/');
+    expect(adapter.calls[0].params).toEqual({ entity_type: 'contact' });
+  });
+
+  it('normalizes the payload, whether or not the adapter camelizes it', async () => {
+    adapter.nextResponse = {
+      entity_type: 'contact',
+      fields: [
+        {
+          key: 'tag.stage_focus',
+          label: 'stage_focus',
+          category: 'Tags',
+          value_type: 'enum',
+          enum_values: ['seed'],
+          allowed_operators: ['eq', 'exists'],
+        },
+      ],
+    };
+    const client = new FunnelApiClient(adapter, '');
+    const registry = await client.getFields();
+
+    expect(registry.entityType).toBe('contact');
+    expect(registry.fields[0]).toMatchObject({
+      key: 'tag.stage_focus',
+      valueType: 'enum',
+      enumValues: ['seed'],
+      allowedOperators: ['eq', 'exists'],
+    });
+  });
+
+  it('reads a camelized payload unchanged', async () => {
+    adapter.nextResponse = {
+      entityType: 'sc_artist',
+      fields: [
+        {
+          key: 'metric.reach.followers',
+          label: 'followers',
+          category: 'Metrics',
+          valueType: 'number',
+          enumValues: [],
+          allowedOperators: ['gte', 'between'],
+        },
+      ],
+    };
+    const client = new FunnelApiClient(adapter, '');
+    const registry = await client.getFields('sc_artist');
+
+    expect(registry.entityType).toBe('sc_artist');
+    expect(registry.fields[0].allowedOperators).toEqual(['gte', 'between']);
+  });
+});

package/src/api/client.ts

@@ -8,16 +8,21 @@
  */
 
 import type { ApiAdapter } from './adapter';
+import type { FunnelPaths } from './paths';
+import { centralFunnelPaths } from './paths';
 import type {
   Funnel,
   FunnelStage,
   FunnelRun,
   FunnelResult,
+  FieldRegistry,
+  FieldDefinitionInput,
   CreateFunnelInput,
   UpdateFunnelInput,
   CreateStageInput,
   UpdateStageInput,
 } from '../types';
+import { normalizeFieldDefinition } from '../types';
 
 /**
  * List filters for funnels
@@ -89,7 +94,12 @@ export interface PreviewResult<TEntity = any> {
  * Usage:
  * ```ts
  * const adapter = new FetchAdapter({ headers: { 'Authorization': 'Bearer token' } });
- * const client = new FunnelApiClient(adapter, 'https://api.example.com');
+ *
+ * // the central API
+ * const client = new FunnelApiClient(adapter, 'https://api.startsimpli.com');
+ *
+ * // a foundry's funnels on the control plane (startsim-9xbz2)
+ * const tenant = new FunnelApiClient(adapter, '', foundryTenantFunnelPaths('acme'));
  *
  * const funnels = await client.listFunnels({ status: 'active' });
  * const funnel = await client.getFunnel('funnel-123');
@@ -97,12 +107,17 @@ export interface PreviewResult<TEntity = any> {
  * ```
  */
 export class FunnelApiClient {
+  /** The path family this client talks to. Readable, so a caller can log it. */
+  public readonly paths: FunnelPaths;
+
   constructor(
     private adapter: ApiAdapter,
-    private baseUrl: string
+    private baseUrl: string,
+    paths: FunnelPaths = centralFunnelPaths
   ) {
     // Remove trailing slash
     this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.paths = paths;
   }
 
   /**
@@ -126,7 +141,7 @@ export class FunnelApiClient {
     filters?: FunnelListFilters
   ): Promise<PaginatedResponse<Funnel<TEntity>>> {
     return this.adapter.get<PaginatedResponse<Funnel<TEntity>>>(
-      this.url('/api/v1/funnels/'),
+      this.url(this.paths.list()),
       filters
     );
   }
@@ -139,7 +154,7 @@ export class FunnelApiClient {
    * @throws ApiError with status 404 if not found
    */
   async getFunnel<TEntity = any>(id: string): Promise<Funnel<TEntity>> {
-    return this.adapter.get<Funnel<TEntity>>(this.url(`/api/v1/funnels/${id}/`));
+    return this.adapter.get<Funnel<TEntity>>(this.url(this.paths.detail(id)));
   }
 
   /**
@@ -152,7 +167,7 @@ export class FunnelApiClient {
   async createFunnel<TEntity = any>(
     data: CreateFunnelInput<TEntity>
   ): Promise<Funnel<TEntity>> {
-    return this.adapter.post<Funnel<TEntity>>(this.url('/api/v1/funnels/'), data);
+    return this.adapter.post<Funnel<TEntity>>(this.url(this.paths.list()), data);
   }
 
   /**
@@ -168,7 +183,7 @@ export class FunnelApiClient {
     data: Partial<UpdateFunnelInput<TEntity>>
   ): Promise<Funnel<TEntity>> {
     return this.adapter.patch<Funnel<TEntity>>(
-      this.url(`/api/v1/funnels/${id}/`),
+      this.url(this.paths.detail(id)),
       data
     );
   }
@@ -180,7 +195,7 @@ export class FunnelApiClient {
    * @throws ApiError with status 404 if not found
    */
   async deleteFunnel(id: string): Promise<void> {
-    return this.adapter.delete<void>(this.url(`/api/v1/funnels/${id}/`));
+    return this.adapter.delete<void>(this.url(this.paths.detail(id)));
   }
 
   // ============================================================================
@@ -200,7 +215,7 @@ export class FunnelApiClient {
     data: CreateStageInput<TEntity>
   ): Promise<FunnelStage<TEntity>> {
     return this.adapter.post<FunnelStage<TEntity>>(
-      this.url(`/api/v1/funnels/${funnelId}/stages/`),
+      this.url(this.paths.stages(funnelId)),
       data
     );
   }
@@ -220,7 +235,7 @@ export class FunnelApiClient {
     data: Partial<UpdateStageInput<TEntity>>
   ): Promise<FunnelStage<TEntity>> {
     return this.adapter.patch<FunnelStage<TEntity>>(
-      this.url(`/api/v1/funnels/${funnelId}/stages/${stageId}/`),
+      this.url(this.paths.stage(funnelId, stageId)),
       data
     );
   }
@@ -234,7 +249,7 @@ export class FunnelApiClient {
    */
   async deleteStage(funnelId: string, stageId: string): Promise<void> {
     return this.adapter.delete<void>(
-      this.url(`/api/v1/funnels/${funnelId}/stages/${stageId}/`)
+      this.url(this.paths.stage(funnelId, stageId))
     );
   }
 
@@ -258,7 +273,7 @@ export class FunnelApiClient {
     }
   ): Promise<FunnelRun> {
     return this.adapter.post<FunnelRun>(
-      this.url(`/api/v1/funnels/${funnelId}/run/`),
+      this.url(this.paths.run(funnelId)),
       options || {}
     );
   }
@@ -281,7 +296,7 @@ export class FunnelApiClient {
     }
   ): Promise<PaginatedResponse<FunnelRun>> {
     return this.adapter.get<PaginatedResponse<FunnelRun>>(
-      this.url(`/api/v1/funnels/${funnelId}/runs/`),
+      this.url(this.paths.runs(funnelId)),
       filters
     );
   }
@@ -290,11 +305,13 @@ export class FunnelApiClient {
    * Get single run detail
    *
    * @param runId - Run ID
+   * @param funnelId - Required only on a path family that nests runs under
+   *   their funnel (the control plane); ignored on the central family.
    * @returns Funnel run detail
    * @throws ApiError with status 404 if not found
    */
-  async getFunnelRun(runId: string): Promise<FunnelRun> {
-    return this.adapter.get<FunnelRun>(this.url(`/api/v1/funnel-runs/${runId}/`));
+  async getFunnelRun(runId: string, funnelId?: string): Promise<FunnelRun> {
+    return this.adapter.get<FunnelRun>(this.url(this.paths.runDetail(runId, funnelId)));
   }
 
   /**
@@ -311,11 +328,14 @@ export class FunnelApiClient {
       matched?: boolean;
       page?: number;
       pageSize?: number;
+      /** Required only on a family that nests runs under their funnel. */
+      funnelId?: string;
     }
   ): Promise<PaginatedResponse<FunnelResult<TEntity>>> {
+    const { funnelId, ...query } = filters ?? {};
     return this.adapter.get<PaginatedResponse<FunnelResult<TEntity>>>(
-      this.url(`/api/v1/funnel-runs/${runId}/results/`),
-      filters
+      this.url(this.paths.runResults(runId, funnelId)),
+      query
     );
   }
 
@@ -326,13 +346,46 @@ export class FunnelApiClient {
    * @returns Updated run with status 'cancelled'
    * @throws ApiError with status 404 if not found, 400 if already completed
    */
-  async cancelFunnelRun(runId: string): Promise<FunnelRun> {
+  async cancelFunnelRun(runId: string, funnelId?: string): Promise<FunnelRun> {
     return this.adapter.post<FunnelRun>(
-      this.url(`/api/v1/funnel-runs/${runId}/cancel/`),
+      this.url(this.paths.runCancel(runId, funnelId)),
       {}
     );
   }
 
+  // ============================================================================
+  // Field Registry
+  // ============================================================================
+
+  /**
+   * Fetch the field registry that describes which keys a rule may name.
+   *
+   * This is what a rule editor should be driven by — the server's own resolver
+   * registry (backend/apps/funnels/resolvers/registry.py), not a hand-written
+   * per-app list that drifts from it.
+   *
+   * The payload is normalized, so the same call works whether the injected
+   * adapter camelizes keys (the @startsimpli/api FetchWrapper does) or hands
+   * back the raw snake_case body (FetchAdapter does).
+   *
+   * @param entityType - Optional: only the fields that apply to this entity type
+   */
+  async getFields(entityType?: string): Promise<FieldRegistry> {
+    const response = await this.adapter.get<{
+      entity_type?: string | null;
+      entityType?: string | null;
+      fields?: FieldDefinitionInput[];
+    }>(
+      this.url(this.paths.fields()),
+      entityType ? { entity_type: entityType } : undefined
+    );
+
+    return {
+      entityType: response.entityType ?? response.entity_type ?? null,
+      fields: (response.fields ?? []).map(normalizeFieldDefinition),
+    };
+  }
+
   // ============================================================================
   // Client-Side Preview (Local Evaluation)
   // ============================================================================
@@ -378,7 +431,7 @@ export class FunnelApiClient {
     sampleEntities: TEntity[]
   ): Promise<PreviewResult<TEntity>> {
     return this.adapter.post<PreviewResult<TEntity>>(
-      this.url(`/api/v1/funnels/${funnelId}/preview/`),
+      this.url(this.paths.preview(funnelId)),
       { entities: sampleEntities }
     );
   }

package/src/api/index.ts

@@ -15,6 +15,17 @@ export { createApiError, isApiError } from './adapter';
 export { FetchAdapter } from './default-adapter';
 export type { FetchAdapterConfig } from './default-adapter';
 
+// Path families — the surfaces the same client can talk to (bd startsim-pxzlf)
+export {
+  createFunnelPaths,
+  centralFunnelPaths,
+  foundryTenantFunnelPaths,
+  proxiedCentralFunnelPaths,
+  DEFAULT_FUNNEL_PATH_PREFIX,
+  DEFAULT_FUNNEL_RUNS_PATH_PREFIX,
+} from './paths';
+export type { FunnelPaths, FunnelPathsOptions } from './paths';
+
 // Client
 export { FunnelApiClient } from './client';
 export type {

package/src/api/paths.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Tests for the injectable funnel path family (bd startsim-pxzlf).
+ *
+ * The same client has to talk to four surfaces that differ ONLY in their URL
+ * prefix and, for the control plane, in whether a run is addressed globally or
+ * under its funnel:
+ *
+ *   central        /api/v1/funnels/…           + /api/v1/funnel-runs/<id>/
+ *   control plane  /api/v1/foundry/tenants/<slug>/funnels/… (runs nested)
+ *   tenant proxy   /central-api/api/v1/funnels/… (a prefix on the central family)
+ *   a fork's own   whatever the fork mounted
+ *
+ * Hardcoding '/api/v1/funnels' in the client (api/client.ts before this change)
+ * made the first the only one reachable.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  createFunnelPaths,
+  centralFunnelPaths,
+  foundryTenantFunnelPaths,
+  DEFAULT_FUNNEL_PATH_PREFIX,
+} from './paths';
+
+describe('centralFunnelPaths', () => {
+  it('is the /api/v1/funnels family the client used to hardcode', () => {
+    expect(centralFunnelPaths.list()).toBe('/api/v1/funnels/');
+    expect(centralFunnelPaths.detail('f1')).toBe('/api/v1/funnels/f1/');
+    expect(centralFunnelPaths.stages('f1')).toBe('/api/v1/funnels/f1/stages/');
+    expect(centralFunnelPaths.stage('f1', 's1')).toBe('/api/v1/funnels/f1/stages/s1/');
+    expect(centralFunnelPaths.run('f1')).toBe('/api/v1/funnels/f1/run/');
+    expect(centralFunnelPaths.runs('f1')).toBe('/api/v1/funnels/f1/runs/');
+    expect(centralFunnelPaths.preview('f1')).toBe('/api/v1/funnels/f1/preview/');
+    expect(centralFunnelPaths.fields()).toBe('/api/v1/funnels/fields/');
+  });
+
+  it('addresses a run globally, because the central API does', () => {
+    // config/api_router.py registers funnel-runs as its own router entry.
+    expect(centralFunnelPaths.runDetail('r1')).toBe('/api/v1/funnel-runs/r1/');
+    expect(centralFunnelPaths.runResults('r1')).toBe('/api/v1/funnel-runs/r1/results/');
+    expect(centralFunnelPaths.runCancel('r1')).toBe('/api/v1/funnel-runs/r1/cancel/');
+  });
+
+  it('exposes its prefix so callers can see which surface they are on', () => {
+    expect(centralFunnelPaths.prefix).toBe(DEFAULT_FUNNEL_PATH_PREFIX);
+  });
+});
+
+describe('createFunnelPaths', () => {
+  it('defaults to the central family', () => {
+    const paths = createFunnelPaths();
+    expect(paths.list()).toBe(centralFunnelPaths.list());
+    expect(paths.runDetail('r1')).toBe(centralFunnelPaths.runDetail('r1'));
+  });
+
+  it('mounts the whole family under a prefix — a tenant proxy', () => {
+    const paths = createFunnelPaths({ prefix: '/central-api/api/v1/funnels' });
+    expect(paths.list()).toBe('/central-api/api/v1/funnels/');
+    expect(paths.detail('f1')).toBe('/central-api/api/v1/funnels/f1/');
+    expect(paths.fields()).toBe('/central-api/api/v1/funnels/fields/');
+  });
+
+  it('takes the runs prefix separately, since runs need not live under funnels', () => {
+    const paths = createFunnelPaths({
+      prefix: '/central-api/api/v1/funnels',
+      runsPrefix: '/central-api/api/v1/funnel-runs',
+    });
+    expect(paths.runDetail('r1')).toBe('/central-api/api/v1/funnel-runs/r1/');
+    expect(paths.runCancel('r1')).toBe('/central-api/api/v1/funnel-runs/r1/cancel/');
+  });
+
+  it('nests runs under their funnel when asked (the control-plane shape)', () => {
+    const paths = createFunnelPaths({
+      prefix: '/api/v1/foundry/tenants/acme/funnels',
+      nestRuns: true,
+    });
+    expect(paths.runDetail('r1', 'f1')).toBe(
+      '/api/v1/foundry/tenants/acme/funnels/f1/runs/r1/'
+    );
+    expect(paths.runResults('r1', 'f1')).toBe(
+      '/api/v1/foundry/tenants/acme/funnels/f1/runs/r1/results/'
+    );
+  });
+
+  it('refuses a nested run address with no funnel, instead of building a wrong URL', () => {
+    const paths = createFunnelPaths({ prefix: '/api/v1/x/funnels', nestRuns: true });
+    expect(() => paths.runDetail('r1')).toThrow(/funnel/i);
+  });
+
+  it('normalizes a prefix given with or without a trailing slash', () => {
+    const withSlash = createFunnelPaths({ prefix: '/api/v1/funnels/' });
+    const without = createFunnelPaths({ prefix: '/api/v1/funnels' });
+    expect(withSlash.list()).toBe(without.list());
+    expect(withSlash.detail('f1')).toBe(without.detail('f1'));
+  });
+
+  it('URL-encodes ids so a slug or an id with a slash cannot escape the family', () => {
+    const paths = createFunnelPaths();
+    expect(paths.detail('a/b')).toBe('/api/v1/funnels/a%2Fb/');
+  });
+});
+
+describe('foundryTenantFunnelPaths', () => {
+  it('is the control-plane family for one foundry (startsim-9xbz2)', () => {
+    const paths = foundryTenantFunnelPaths('acme');
+    expect(paths.list()).toBe('/api/v1/foundry/tenants/acme/funnels/');
+    expect(paths.detail('f1')).toBe('/api/v1/foundry/tenants/acme/funnels/f1/');
+    expect(paths.run('f1')).toBe('/api/v1/foundry/tenants/acme/funnels/f1/run/');
+    expect(paths.runs('f1')).toBe('/api/v1/foundry/tenants/acme/funnels/f1/runs/');
+    expect(paths.fields()).toBe('/api/v1/foundry/tenants/acme/funnels/fields/');
+  });
+
+  it('nests runs under the funnel, which is how the nested viewset addresses them', () => {
+    const paths = foundryTenantFunnelPaths('acme');
+    expect(paths.runDetail('r1', 'f1')).toBe(
+      '/api/v1/foundry/tenants/acme/funnels/f1/runs/r1/'
+    );
+  });
+
+  it('encodes the slug', () => {
+    expect(foundryTenantFunnelPaths('a b').list()).toBe(
+      '/api/v1/foundry/tenants/a%20b/funnels/'
+    );
+  });
+});