@rachelallyson/planning-center-people-ts 2.14.0 → 3.0.0

package/dist/modules/workflows.js

@@ -7,94 +7,89 @@ exports.WorkflowsModule = void 0;
 const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 class WorkflowsModule extends planning_center_base_ts_1.BaseModule {
     /**
-     * Get all workflows
+     * Get all workflows across all pages
      */
     async getAll(options = {}) {
-        const params = {};
-        if (options.where) {
-            Object.entries(options.where).forEach(([key, value]) => {
-                params[`where[${key}]`] = value;
-            });
-        }
-        if (options.include) {
-            params.include = options.include.join(',');
-        }
-        if (options.perPage) {
-            params.per_page = options.perPage;
-        }
-        if (options.page) {
-            params.page = options.page;
-        }
-        return this.getList('/workflows', params);
+        this.debugLog('workflows.getAll', { options });
+        return await this.getAllPages('/workflows', {
+            where: options.where,
+            include: options.include,
+            order: options.order
+        });
     }
     /**
-     * Get all workflows across all pages
+     * Get a single page of workflows with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param options - List options including where, include, perPage, and page
+     * @returns A single page of results with meta and links for pagination
      */
-    async getAllPagesPaginated(options = {}, paginationOptions) {
-        const params = {};
-        if (options.where) {
-            Object.entries(options.where).forEach(([key, value]) => {
-                params[`where[${key}]`] = value;
-            });
-        }
-        if (options.include) {
-            params.include = options.include.join(',');
-        }
-        return this.getAllPages('/workflows', params, paginationOptions);
+    async getPage(options = {}) {
+        this.debugLog('workflows.getPage', { options });
+        return this.getList('/workflows', {
+            where: options.where,
+            include: options.include,
+            per_page: options.perPage,
+            page: options.page,
+            order: options.order
+        });
     }
     /**
      * Get a single workflow by ID
      */
     async getById(id, include) {
-        const params = {};
-        if (include) {
-            params.include = include.join(',');
-        }
-        return this.getSingle(`/workflows/${id}`, params);
+        this.debugLog('workflows.getById', { id, include });
+        return this.getSingle(`/workflows/${id}`, include);
     }
     /**
      * Create a workflow
      */
     async create(data) {
+        this.debugLog('workflows.create', { data });
         return this.createResource('/workflows', data);
     }
     /**
      * Update a workflow
      */
     async update(id, data) {
+        this.debugLog('workflows.update', { id, data });
         return this.updateResource(`/workflows/${id}`, data);
     }
     /**
      * Delete a workflow
      */
     async delete(id) {
+        this.debugLog('workflows.delete', { id });
         return this.deleteResource(`/workflows/${id}`);
     }
     /**
      * Get workflow cards for a person
+     * @param personId - The person ID
+     * @param options - Optional pagination options
      */
-    async getPersonWorkflowCards(personId) {
-        return this.getList(`/people/${personId}/workflow_cards`);
+    async getPersonWorkflowCards(personId, options) {
+        this.debugLog('workflows.getPersonWorkflowCards', { personId, options });
+        return this.getList(`/people/${personId}/workflow_cards`, options);
     }
     /**
      * Add a person to a workflow with smart duplicate detection
      */
     async addPersonToWorkflow(personId, workflowId, options = {}) {
+        this.debugLog('workflows.addPersonToWorkflow', { personId, workflowId, options });
         const { skipIfExists = true, skipIfActive = true } = options;
         // Check for existing workflow cards if requested
         if (skipIfExists || skipIfActive) {
             const existingCards = await this.getPersonWorkflowCards(personId);
             const existingCard = existingCards.data.find(card => {
-                const workflowData = card.relationships?.workflow?.data;
+                const workflowData = card?.workflow?.data;
                 return workflowData && !Array.isArray(workflowData) && workflowData.id === workflowId;
             });
-            if (existingCard && existingCard.attributes) {
+            if (existingCard) {
                 // Check if card is completed or removed
-                if (skipIfExists && (existingCard.attributes.completed_at || existingCard.attributes.removed_at)) {
+                if (skipIfExists && (existingCard.completed_at || existingCard.removed_at)) {
                     throw new Error(`Person already has a completed/removed card in this workflow`);
                 }
                 // Check if card is active
-                if (skipIfActive && !existingCard.attributes.completed_at && !existingCard.attributes.removed_at) {
+                if (skipIfActive && !existingCard.completed_at && !existingCard.removed_at) {
                     throw new Error(`Person already has an active card in this workflow`);
                 }
             }
@@ -114,6 +109,7 @@ class WorkflowsModule extends planning_center_base_ts_1.BaseModule {
      * Create a workflow card
      */
     async createWorkflowCard(workflowId, personId) {
+        this.debugLog('workflows.createWorkflowCard', { workflowId, personId });
         return this.createResource(`/workflows/${workflowId}/cards`, {
             person_id: personId,
         });
@@ -122,6 +118,7 @@ class WorkflowsModule extends planning_center_base_ts_1.BaseModule {
      * Update a workflow card
      */
     async updateWorkflowCard(workflowCardId, data, personId) {
+        this.debugLog('workflows.updateWorkflowCard', { workflowCardId, data, personId });
         // If personId is provided, use the person-specific endpoint
         if (personId) {
             return this.updateResource(`/people/${personId}/workflow_cards/${workflowCardId}`, data);
@@ -133,30 +130,21 @@ class WorkflowsModule extends planning_center_base_ts_1.BaseModule {
      * Get workflow card notes
      */
     async getWorkflowCardNotes(personId, workflowCardId) {
+        this.debugLog('workflows.getWorkflowCardNotes', { personId, workflowCardId });
         return this.getList(`/people/${personId}/workflow_cards/${workflowCardId}/notes`);
     }
     /**
      * Create a workflow card note
      */
     async createWorkflowCardNote(personId, workflowCardId, data) {
+        this.debugLog('workflows.createWorkflowCardNote', { personId, workflowCardId, data });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/notes`, data);
     }
-    /**
-     * Update a workflow card note
-     */
-    async updateWorkflowCardNote(personId, workflowCardId, noteId, data) {
-        return this.updateResource(`/people/${personId}/workflow_cards/${workflowCardId}/notes/${noteId}`, data);
-    }
-    /**
-     * Delete a workflow card note
-     */
-    async deleteWorkflowCardNote(personId, workflowCardId, noteId) {
-        return this.deleteResource(`/people/${personId}/workflow_cards/${workflowCardId}/notes/${noteId}`);
-    }
     /**
      * Create a workflow card with a note
      */
     async createWorkflowCardWithNote(workflowId, personId, noteData) {
+        this.debugLog('workflows.createWorkflowCardWithNote', { workflowId, personId, noteData });
         const workflowCard = await this.createWorkflowCard(workflowId, personId);
         const note = await this.createWorkflowCardNote(personId, workflowCard.id, noteData);
         return { workflowCard, note };
@@ -165,48 +153,56 @@ class WorkflowsModule extends planning_center_base_ts_1.BaseModule {
      * Move a workflow card back to the previous step
      */
     async goBackWorkflowCard(personId, workflowCardId) {
+        this.debugLog('workflows.goBackWorkflowCard', { personId, workflowCardId });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/go_back`, {});
     }
     /**
      * Move a workflow card to the next step
      */
     async promoteWorkflowCard(personId, workflowCardId) {
+        this.debugLog('workflows.promoteWorkflowCard', { personId, workflowCardId });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/promote`, {});
     }
     /**
      * Remove a workflow card
      */
     async removeWorkflowCard(personId, workflowCardId) {
+        this.debugLog('workflows.removeWorkflowCard', { personId, workflowCardId });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/remove`, {});
     }
     /**
      * Restore a workflow card
      */
     async restoreWorkflowCard(personId, workflowCardId) {
+        this.debugLog('workflows.restoreWorkflowCard', { personId, workflowCardId });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/restore`, {});
     }
     /**
      * Send an email to the subject of the workflow card
      */
     async sendEmailWorkflowCard(personId, workflowCardId, data) {
+        this.debugLog('workflows.sendEmailWorkflowCard', { personId, workflowCardId, data });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/send_email`, data);
     }
     /**
      * Move a workflow card to the next step without completing the current step
      */
     async skipStepWorkflowCard(personId, workflowCardId) {
+        this.debugLog('workflows.skipStepWorkflowCard', { personId, workflowCardId });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/skip_step`, {});
     }
     /**
      * Snooze a workflow card for a specific duration
      */
     async snoozeWorkflowCard(personId, workflowCardId, data) {
+        this.debugLog('workflows.snoozeWorkflowCard', { personId, workflowCardId, data });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/snooze`, data);
     }
     /**
      * Unsnooze a workflow card
      */
     async unsnoozeWorkflowCard(personId, workflowCardId) {
+        this.debugLog('workflows.unsnoozeWorkflowCard', { personId, workflowCardId });
         return this.createResource(`/people/${personId}/workflow_cards/${workflowCardId}/unsnooze`, {});
     }
     /**
@@ -214,7 +210,8 @@ class WorkflowsModule extends planning_center_base_ts_1.BaseModule {
      */
     formatNoteTemplate(template, variables) {
         return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-            return variables[key] || match;
+            const value = variables[key];
+            return value !== undefined ? String(value) : match;
         });
     }
 }

package/dist/performance.d.ts

@@ -4,16 +4,20 @@
  * This module provides utilities for optimizing performance when working
  * with large datasets and high-volume API operations.
  */
-import type { PcoClientState } from './core';
-import type { EmailResource, PersonResource, PhoneNumberResource } from './types';
+import type { PcoClient } from './client';
+import type { EmailResource, PersonResource, PhoneNumberResource, PeopleList } from './types';
+import type { PersonListOptions, PersonWhereClause } from './types/api-options';
 /**
- * Process items in batches to avoid overwhelming the API
+ * Process items in batches to avoid overwhelming the API.
+ * Pass `client` in options to log batch progress when debug is enabled.
  */
-export declare function processInBatches<T, R>(items: T[], batchSize: number, processor: (batch: T[]) => Promise<R[]>): Promise<R[]>;
+export declare function processInBatches<T, R>(items: T[], batchSize: number, processor: (batch: T[]) => Promise<R[]>, options?: {
+    client?: PcoClient;
+}): Promise<R[]>;
 /**
  * Batch fetch person details with related data
  */
-export declare function batchFetchPersonDetails(client: PcoClientState, personIds: string[], options?: {
+export declare function batchFetchPersonDetails(client: PcoClient, personIds: string[], options?: {
     includeEmails?: boolean;
     includePhones?: boolean;
     batchSize?: number;
@@ -35,11 +39,11 @@ export declare class ApiCache {
 /**
  * Cached version of getPeople with configurable TTL
  */
-export declare function getCachedPeople(client: PcoClientState, cache: ApiCache, params?: any, ttlMs?: number): Promise<any>;
+export declare function getCachedPeople(client: PcoClient, cache: ApiCache, params?: PersonListOptions, ttlMs?: number): Promise<PeopleList>;
 /**
  * Efficiently fetch all pages of data with progress tracking
  */
-export declare function fetchAllPages<T>(client: PcoClientState, fetchFunction: (page: number, perPage: number) => Promise<{
+export declare function fetchAllPages<T>(client: PcoClient, fetchFunction: (page: number, perPage: number) => Promise<{
     data: T[];
     links?: {
         next?: string;
@@ -55,16 +59,16 @@ export declare function fetchAllPages<T>(client: PcoClientState, fetchFunction:
 /**
  * Stream large datasets with backpressure control
  */
-export declare function streamPeopleData(client: PcoClientState, options?: {
+export declare function streamPeopleData(client: PcoClient, options?: {
     perPage?: number;
     maxConcurrent?: number;
-    where?: Record<string, any>;
+    where?: PersonWhereClause;
     include?: string[];
 }): AsyncGenerator<PersonResource[], void, unknown>;
 /**
  * Process large datasets without loading everything into memory
  */
-export declare function processLargeDataset<T, R>(client: PcoClientState, fetchFunction: (page: number, perPage: number) => Promise<{
+export declare function processLargeDataset<T, R>(client: PcoClient, fetchFunction: (page: number, perPage: number) => Promise<{
     data: T[];
     links?: {
         next?: string;

package/dist/performance.js

@@ -14,17 +14,29 @@ exports.fetchAllPages = fetchAllPages;
 exports.streamPeopleData = streamPeopleData;
 exports.processLargeDataset = processLargeDataset;
 exports.monitorPerformance = monitorPerformance;
-const people_1 = require("./people");
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 // ===== Batch Processing =====
 /**
- * Process items in batches to avoid overwhelming the API
+ * Process items in batches to avoid overwhelming the API.
+ * Pass `client` in options to log batch progress when debug is enabled.
  */
-async function processInBatches(items, batchSize, processor) {
+async function processInBatches(items, batchSize, processor, options) {
+    const logger = options?.client && typeof options.client.getConfig === 'function'
+        ? (0, planning_center_base_ts_1.createDebugLogger)(options.client.getConfig())
+        : null;
+    if (logger?.enabled) {
+        logger.log('performance.processInBatches', { itemCount: items.length, batchSize, batchCount: Math.ceil(items.length / batchSize) });
+    }
     const results = [];
     for (let i = 0; i < items.length; i += batchSize) {
         const batch = items.slice(i, i + batchSize);
+        const batchIndex = Math.floor(i / batchSize) + 1;
+        if (logger?.enabled)
+            logger.log('performance.processInBatches batch start', { batchIndex, batchSize: batch.length });
         const batchResults = await processor(batch);
         results.push(...batchResults);
+        if (logger?.enabled)
+            logger.log('performance.processInBatches batch complete', { batchIndex, resultCount: batchResults.length, totalSoFar: results.length });
         // Add a small delay between batches to respect rate limits
         if (i + batchSize < items.length) {
             await new Promise(resolve => setTimeout(resolve, 100));
@@ -36,31 +48,35 @@ async function processInBatches(items, batchSize, processor) {
  * Batch fetch person details with related data
  */
 async function batchFetchPersonDetails(client, personIds, options = {}) {
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(typeof client.getConfig === 'function'
+        ? client.getConfig()
+        : undefined);
+    if (logger.enabled)
+        logger.log('performance.batchFetchPersonDetails', { personCount: personIds.length, options });
     const { batchSize = 10, includeEmails = true, includePhones = true, } = options;
     const results = new Map();
     await processInBatches(personIds, batchSize, async (batch) => {
         const batchResults = await Promise.all(batch.map(async (personId) => {
-            const personPromise = (0, people_1.getPeople)(client, {
-                per_page: 1,
-                where: { id: personId },
-            });
-            const promises_array = [personPromise];
-            if (includeEmails) {
-                promises_array.push((0, people_1.getPersonEmails)(client, personId));
-            }
-            if (includePhones) {
-                promises_array.push((0, people_1.getPersonPhoneNumbers)(client, personId));
-            }
-            const responses = await Promise.all(promises_array);
-            const person = responses[0].data[0];
+            const personPromise = client.people.getById(personId);
+            const emailPromise = includeEmails ? client.people.getEmails(personId) : null;
+            const phonePromise = includePhones ? client.people.getPhoneNumbers(personId) : null;
+            const promises = [personPromise];
+            if (emailPromise)
+                promises.push(emailPromise);
+            if (phonePromise)
+                promises.push(phonePromise);
+            const responses = await Promise.all(promises);
+            const person = responses[0];
             if (!person)
                 return null;
             const result = { person };
-            if (includeEmails) {
-                result.emails = responses[1]?.data || [];
+            if (includeEmails && emailPromise) {
+                const emailsResponse = await emailPromise;
+                result.emails = emailsResponse.data || [];
             }
-            if (includePhones) {
-                result.phoneNumbers = responses[includeEmails ? 2 : 1]?.data || [];
+            if (includePhones && phonePromise) {
+                const phonesResponse = await phonePromise;
+                result.phoneNumbers = phonesResponse.data || [];
             }
             return { personId, result };
         }));
@@ -70,7 +86,7 @@ async function batchFetchPersonDetails(client, personIds, options = {}) {
             }
         });
         return batchResults; // Return for processInBatches
-    });
+    }, { client });
     return results;
 }
 // ===== Caching =====
@@ -111,12 +127,17 @@ exports.ApiCache = ApiCache;
  * Cached version of getPeople with configurable TTL
  */
 async function getCachedPeople(client, cache, params = {}, ttlMs = 300000) {
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(typeof client.getConfig === 'function'
+        ? client.getConfig()
+        : undefined);
+    if (logger.enabled)
+        logger.log('performance.getCachedPeople', { params, ttlMs });
     const cacheKey = `people:${JSON.stringify(params)}`;
     const cached = cache.get(cacheKey);
     if (cached) {
         return cached;
     }
-    const result = await (0, people_1.getPeople)(client, params);
+    const result = await client.people.getAll(params);
     cache.set(cacheKey, result, ttlMs);
     return result;
 }
@@ -125,6 +146,11 @@ async function getCachedPeople(client, cache, params = {}, ttlMs = 300000) {
  * Efficiently fetch all pages of data with progress tracking
  */
 async function fetchAllPages(client, fetchFunction, options = {}) {
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(typeof client.getConfig === 'function'
+        ? client.getConfig()
+        : undefined);
+    if (logger.enabled)
+        logger.log('performance.fetchAllPages', { options });
     const { maxPages = 1000, onProgress, perPage = 100 } = options;
     const allData = [];
     let page = 1;
@@ -152,6 +178,11 @@ async function fetchAllPages(client, fetchFunction, options = {}) {
  * Stream large datasets with backpressure control
  */
 async function* streamPeopleData(client, options = {}) {
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(typeof client.getConfig === 'function'
+        ? client.getConfig()
+        : undefined);
+    if (logger.enabled)
+        logger.log('performance.streamPeopleData', { options });
     const { include = [], maxConcurrent = 3, perPage = 50, where = {} } = options;
     let page = 1;
     let hasMore = true;
@@ -159,10 +190,10 @@ async function* streamPeopleData(client, options = {}) {
     while (hasMore) {
         await semaphore.acquire();
         try {
-            const response = await (0, people_1.getPeople)(client, {
-                include,
+            const response = await client.people.getPage({
+                include: include,
                 page,
-                per_page: perPage,
+                perPage,
                 where,
             });
             yield response.data;
@@ -203,6 +234,11 @@ class Semaphore {
  * Process large datasets without loading everything into memory
  */
 async function processLargeDataset(client, fetchFunction, processor, options = {}) {
+    const logger = (0, planning_center_base_ts_1.createDebugLogger)(typeof client.getConfig === 'function'
+        ? client.getConfig()
+        : undefined);
+    if (logger.enabled)
+        logger.log('performance.processLargeDataset', { options });
     const { maxMemoryItems = 1000, onBatchProcessed, perPage = 100 } = options;
     const allResults = [];
     let page = 1;

package/dist/testing/recorder.js

@@ -37,6 +37,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestRecorder = void 0;
+const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 class RequestRecorder {
@@ -133,7 +134,11 @@ class RequestRecorder {
             fs.writeFileSync(this.config.recordPath, JSON.stringify(session, null, 2));
         }
         catch (error) {
-            console.error('Failed to save recording session:', error);
+            const logger = (0, planning_center_base_ts_1.createDebugLogger)(this.config.getConfig?.());
+            if (logger.enabled)
+                logger.log('recorder  failed to save recording session', { error: String(error) });
+            else
+                console.error('Failed to save recording session:', error);
         }
     }
     /**
@@ -148,7 +153,11 @@ class RequestRecorder {
             return JSON.parse(content);
         }
         catch (error) {
-            console.error('Failed to load recording session:', error);
+            const logger = (0, planning_center_base_ts_1.createDebugLogger)(this.config.getConfig?.());
+            if (logger.enabled)
+                logger.log('recorder  failed to load recording session', { error: String(error) });
+            else
+                console.error('Failed to load recording session:', error);
             return null;
         }
     }

package/dist/testing/simple-builders.d.ts

@@ -1,21 +1,23 @@
 /**
  * Simplified Mock Response Builders for Testing
+ *
+ * Builders return flattened shape (same as API): attributes and relationships at top level.
  */
 export declare class SimpleMockResponseBuilder {
     /**
-     * Build a simple mock person resource
+     * Build a simple mock person resource (flattened shape)
      */
     static person(overrides?: any): any;
     /**
-     * Build a simple mock email resource
+     * Build a simple mock email resource (flattened shape)
      */
     static email(overrides?: any): any;
     /**
-     * Build a simple mock phone number resource
+     * Build a simple mock phone number resource (flattened shape)
      */
     static phoneNumber(overrides?: any): any;
     /**
-     * Build a simple mock workflow resource
+     * Build a simple mock workflow resource (flattened shape)
      */
     static workflow(overrides?: any): any;
     /**

package/dist/testing/simple-builders.js

@@ -1,85 +1,72 @@
 "use strict";
 /**
  * Simplified Mock Response Builders for Testing
+ *
+ * Builders return flattened shape (same as API): attributes and relationships at top level.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleMockResponseBuilder = void 0;
 class SimpleMockResponseBuilder {
     /**
-     * Build a simple mock person resource
+     * Build a simple mock person resource (flattened shape)
      */
     static person(overrides = {}) {
+        const id = overrides.id || `person_${Date.now()}`;
         return {
             type: 'Person',
-            id: overrides.id || `person_${Date.now()}`,
-            attributes: {
-                id: overrides.id || `person_${Date.now()}`,
-                first_name: overrides.first_name || 'John',
-                last_name: overrides.last_name || 'Doe',
-                status: 'active',
-                ...overrides,
-            },
-            relationships: {
-                emails: { data: [] },
-                phone_numbers: { data: [] },
-                field_data: { data: [] },
-                workflow_cards: { data: [] },
-                household: { data: null },
-            },
+            id,
+            first_name: overrides.first_name ?? 'John',
+            last_name: overrides.last_name ?? 'Doe',
+            status: 'active',
+            ...overrides,
+            emails: [],
+            phone_numbers: [],
+            field_data: [],
+            workflow_cards: [],
+            household: null,
         };
     }
     /**
-     * Build a simple mock email resource
+     * Build a simple mock email resource (flattened shape)
      */
     static email(overrides = {}) {
+        const id = overrides.id || `email_${Date.now()}`;
         return {
             type: 'Email',
-            id: overrides.id || `email_${Date.now()}`,
-            attributes: {
-                id: overrides.id || `email_${Date.now()}`,
-                address: overrides.address || 'john@example.com',
-                location: 'Home',
-                primary: true,
-                ...overrides,
-            },
-            relationships: {
-                person: { data: { type: 'Person', id: 'person_123' } },
-            },
+            id,
+            address: overrides.address ?? 'john@gmail.com',
+            location: 'Home',
+            primary: true,
+            ...overrides,
+            person: { type: 'Person', id: 'person_123' },
         };
     }
     /**
-     * Build a simple mock phone number resource
+     * Build a simple mock phone number resource (flattened shape)
      */
     static phoneNumber(overrides = {}) {
+        const id = overrides.id || `phone_${Date.now()}`;
         return {
             type: 'PhoneNumber',
-            id: overrides.id || `phone_${Date.now()}`,
-            attributes: {
-                id: overrides.id || `phone_${Date.now()}`,
-                number: overrides.number || '555-1234',
-                location: 'Mobile',
-                primary: true,
-                ...overrides,
-            },
-            relationships: {
-                person: { data: { type: 'Person', id: 'person_123' } },
-            },
+            id,
+            number: overrides.number ?? '555-1234',
+            location: 'Mobile',
+            primary: true,
+            ...overrides,
+            person: { type: 'Person', id: 'person_123' },
         };
     }
     /**
-     * Build a simple mock workflow resource
+     * Build a simple mock workflow resource (flattened shape)
      */
     static workflow(overrides = {}) {
+        const id = overrides.id || `workflow_${Date.now()}`;
         return {
             type: 'Workflow',
-            id: overrides.id || `workflow_${Date.now()}`,
-            attributes: {
-                id: overrides.id || `workflow_${Date.now()}`,
-                name: overrides.name || 'New Member Workflow',
-                description: overrides.description || 'Workflow for new members',
-                ...overrides,
-            },
-            relationships: {},
+            id,
+            name: overrides.name ?? 'New Member Workflow',
+            description: overrides.description ?? 'Workflow for new members',
+            ...overrides,
         };
     }
     /**

package/dist/testing/types.d.ts

@@ -141,6 +141,10 @@ export interface RecordingConfig {
     filter?: (endpoint: string, method: string) => boolean;
     /** Transform recorded responses */
     transform?: (response: any) => any;
+    /** Optional getConfig for debug logging (e.g. when recording client has debug) */
+    getConfig?: () => {
+        debug?: boolean | import('@rachelallyson/planning-center-base-ts').PcoDebugOptions;
+    };
 }
 export interface RecordedRequest {
     endpoint: string;