@rachelallyson/planning-center-people-ts 1.0.0 → 2.0.0

package/dist/people/fields.d.ts

@@ -0,0 +1,62 @@
+import { PcoClientState } from '../core';
+import type { ErrorContext } from '../error-handling';
+import { FieldDataList, FieldDataSingle, FieldDefinitionsList, FieldDefinitionSingle, FieldOptionAttributes, FieldOptionSingle, FieldOptionsList, TabsList } from '../types';
+/**
+ * Delete field data for a person
+ */
+export declare function deletePersonFieldData(client: PcoClientState, personId: string, fieldDataId: string, context?: Partial<ErrorContext>): Promise<void>;
+/**
+ * Get field data for a person (custom fields)
+ */
+export declare function getPersonFieldData(client: PcoClientState, personId: string, context?: Partial<ErrorContext>): Promise<FieldDataList>;
+/**
+ * Get field definitions
+ */
+export declare function getFieldDefinitions(client: PcoClientState, params?: {
+    include?: string[];
+    per_page?: number;
+    page?: number;
+    filter?: string;
+    order?: string;
+}, context?: Partial<ErrorContext>): Promise<FieldDefinitionsList>;
+/**
+ * Get a single field definition by ID
+ */
+export declare function getFieldDefinition(client: PcoClientState, fieldId: string, params?: {
+    include?: string[];
+}, context?: Partial<ErrorContext>): Promise<FieldDefinitionSingle>;
+/**
+ * Get field options for a field definition
+ */
+export declare function getFieldOptions(client: PcoClientState, fieldDefinitionId: string, context?: Partial<ErrorContext>): Promise<FieldOptionsList>;
+/**
+ * Create a field option for a field definition
+ */
+export declare function createFieldOption(client: PcoClientState, fieldDefinitionId: string, data: Partial<FieldOptionAttributes>, context?: Partial<ErrorContext>): Promise<FieldOptionSingle>;
+/**
+ * Get tabs
+ */
+export declare function getTabs(client: PcoClientState, params?: {
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<TabsList>;
+/**
+ * Create a field definition
+ */
+export declare function createFieldDefinition(client: PcoClientState, tabId: string, data: {
+    name: string;
+    data_type: string;
+    sequence?: number;
+    slug?: string;
+    config?: string | Record<string, any>;
+}, context?: Partial<ErrorContext>): Promise<FieldDefinitionSingle>;
+/**
+ * Delete a field definition
+ */
+export declare function deleteFieldDefinition(client: PcoClientState, fieldDefinitionId: string, context?: Partial<ErrorContext>): Promise<void>;
+/**
+ * Create field data for a person with automatic file upload handling
+ * Determines field type and uses appropriate creation method
+ */
+export declare function createPersonFieldData(client: PcoClientState, personId: string, fieldId: string, value: string, context?: Partial<ErrorContext>): Promise<FieldDataSingle>;

package/dist/people/fields.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePersonFieldData = deletePersonFieldData;
+exports.getPersonFieldData = getPersonFieldData;
+exports.getFieldDefinitions = getFieldDefinitions;
+exports.getFieldDefinition = getFieldDefinition;
+exports.getFieldOptions = getFieldOptions;
+exports.createFieldOption = createFieldOption;
+exports.getTabs = getTabs;
+exports.createFieldDefinition = createFieldDefinition;
+exports.deleteFieldDefinition = deleteFieldDefinition;
+exports.createPersonFieldData = createPersonFieldData;
+const core_1 = require("../core");
+const error_handling_1 = require("../error-handling");
+const helpers_1 = require("../helpers");
+/**
+ * Create field data for a person (internal)
+ */
+async function createPersonFieldDataInternal(client, personId, fieldDefinitionId, value, context) {
+    return (0, core_1.post)(client, `/people/${personId}/field_data`, {
+        field_definition_id: fieldDefinitionId,
+        value,
+    }, undefined, {
+        ...context,
+        endpoint: `/people/${personId}/field_data`,
+        method: 'POST',
+        personId,
+    });
+}
+/**
+ * Delete field data for a person
+ */
+async function deletePersonFieldData(client, personId, fieldDataId, context) {
+    return (0, core_1.del)(client, `/people/${personId}/field_data/${fieldDataId}`, undefined, {
+        ...context,
+        endpoint: `/people/${personId}/field_data/${fieldDataId}`,
+        method: 'DELETE',
+        personId,
+    });
+}
+/**
+ * Get field data for a person (custom fields)
+ */
+async function getPersonFieldData(client, personId, context) {
+    return (0, core_1.getList)(client, `/people/${personId}/field_data`, undefined, {
+        ...context,
+        endpoint: `/people/${personId}/field_data`,
+        method: 'GET',
+        personId,
+    });
+}
+/**
+ * Upload a file to PCO and create field data (internal)
+ */
+async function createPersonFileFieldDataInternal(client, personId, fieldDefinitionId, fileUrl, context) {
+    return (0, error_handling_1.withErrorBoundary)(async () => {
+        // Dynamic import with error handling for optional dependencies
+        let axios;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            axios = require('axios');
+        }
+        catch (error) {
+            throw new Error('axios package is required for file uploads. Please install it: npm install axios');
+        }
+        // Extract filename from URL
+        const urlParts = fileUrl.split('/');
+        const filename = urlParts[urlParts.length - 1] ?? 'file';
+        // Extract file extension
+        const extension = filename.includes('.')
+            ? (filename.split('.').pop() ?? '')
+            : '';
+        // Get MIME type from file extension
+        const getMimeType = (ext) => {
+            const mimeTypes = {
+                csv: 'text/csv',
+                doc: 'application/msword',
+                docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                gif: 'image/gif',
+                jpeg: 'image/jpeg',
+                jpg: 'image/jpeg',
+                pdf: 'application/pdf',
+                png: 'image/png',
+                txt: 'text/plain',
+                xls: 'application/vnd.ms-excel',
+                xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            };
+            return mimeTypes[ext.toLowerCase()] || 'application/octet-stream';
+        };
+        // Download the file from the provided URL
+        const fileResponse = await axios.default.get(fileUrl, {
+            responseType: 'arraybuffer',
+            timeout: 30000, // 30 second timeout
+        });
+        // Step 1: Upload to PCO's upload service first
+        let FormDataConstructor;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const FormDataModule = require('form-data');
+            // Handle different export patterns
+            FormDataConstructor = FormDataModule.default || FormDataModule;
+        }
+        catch (error) {
+            throw new Error('form-data package is required for file uploads. Please install it: npm install form-data');
+        }
+        const uploadFormData = new FormDataConstructor();
+        uploadFormData.append('file', fileResponse.data, {
+            contentType: getMimeType(extension),
+            filename,
+        });
+        // Create a separate axios instance for the upload service with the same auth
+        const uploadAxios = axios.default.create({
+            headers: {
+                Authorization: client.config.accessToken
+                    ? `Bearer ${client.config.accessToken}`
+                    : `Basic ${Buffer.from(`${client.config.appId}:${client.config.appSecret}`).toString('base64')}`,
+            },
+        });
+        const uploadResponse = await uploadAxios.post('https://upload.planningcenteronline.com/v2/files', uploadFormData, {
+            headers: uploadFormData.getHeaders(),
+            timeout: 60000,
+        });
+        // Step 2: Get the file UUID from the response
+        const fileUUID = uploadResponse.data?.data?.[0]?.id;
+        if (!fileUUID) {
+            throw new Error('Failed to get file UUID from upload response');
+        }
+        // Step 3: Use the UUID to assign the file to the field
+        return createPersonFieldDataInternal(client, personId, fieldDefinitionId, fileUUID, {
+            ...context,
+            endpoint: `/people/${personId}/field_data`,
+            metadata: {
+                ...context?.metadata,
+                operation: 'create_file_field_data',
+                originalFileUrl: fileUrl,
+                uploadedFileUUID: fileUUID,
+            },
+            method: 'POST',
+        });
+    }, {
+        ...context,
+        category: error_handling_1.ErrorCategory.EXTERNAL_API,
+        severity: error_handling_1.ErrorSeverity.HIGH,
+    });
+}
+/**
+ * Get field definitions
+ */
+async function getFieldDefinitions(client, params, context) {
+    return (0, core_1.getList)(client, '/field_definitions', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/field_definitions',
+        method: 'GET',
+    });
+}
+/**
+ * Get a single field definition by ID
+ */
+async function getFieldDefinition(client, fieldId, params, context) {
+    return (0, core_1.getSingle)(client, `/field_definitions/${fieldId}`, (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: `/field_definitions/${fieldId}`,
+        method: 'GET',
+    });
+}
+/**
+ * Get field options for a field definition
+ */
+async function getFieldOptions(client, fieldDefinitionId, context) {
+    return (0, core_1.getList)(client, `/field_definitions/${fieldDefinitionId}/field_options`, undefined, {
+        ...context,
+        endpoint: `/field_definitions/${fieldDefinitionId}/field_options`,
+        fieldDefinitionId,
+        method: 'GET',
+    });
+}
+/**
+ * Create a field option for a field definition
+ */
+async function createFieldOption(client, fieldDefinitionId, data, context) {
+    return (0, core_1.post)(client, `/field_definitions/${fieldDefinitionId}/field_options`, data, undefined, {
+        ...context,
+        endpoint: `/field_definitions/${fieldDefinitionId}/field_options`,
+        fieldDefinitionId,
+        method: 'POST',
+    });
+}
+/**
+ * Get tabs
+ */
+async function getTabs(client, params, context) {
+    return (0, core_1.getList)(client, '/tabs', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/tabs',
+        method: 'GET',
+    });
+}
+/**
+ * Create a field definition
+ */
+async function createFieldDefinition(client, tabId, data, context) {
+    return (0, core_1.post)(client, `/tabs/${tabId}/field_definitions`, data, undefined, {
+        ...context,
+        endpoint: `/tabs/${tabId}/field_definitions`,
+        method: 'POST',
+    });
+}
+/**
+ * Delete a field definition
+ */
+async function deleteFieldDefinition(client, fieldDefinitionId, context) {
+    return (0, core_1.del)(client, `/field_definitions/${fieldDefinitionId}`, undefined, {
+        ...context,
+        endpoint: `/field_definitions/${fieldDefinitionId}`,
+        method: 'DELETE',
+        fieldDefinitionId,
+    });
+}
+/**
+ * Helper function to check if a field definition has a data_type attribute
+ */
+function hasDataType(fieldDef) {
+    return fieldDef && typeof fieldDef.data_type === 'string';
+}
+/**
+ * Create field data for a person with automatic file upload handling
+ * Determines field type and uses appropriate creation method
+ */
+async function createPersonFieldData(client, personId, fieldId, value, context) {
+    // Get field definition to determine type
+    // Get field definition by ID - try direct fetch first, then search in ordered list
+    let fieldDef;
+    // First try direct fetch
+    const singleFieldDef = await getFieldDefinition(client, fieldId, { include: [] }, {
+        ...context,
+        metadata: {
+            ...context?.metadata,
+            operation: 'get_field_definition_direct',
+        },
+    });
+    fieldDef = singleFieldDef.data || undefined;
+    // If direct fetch fails, search through the list ordered by creation date (newest first)
+    if (!fieldDef) {
+        const fieldDefinition = await getFieldDefinitions(client, {
+            include: [],
+            // Include deleted fields in case the field was soft-deleted
+            filter: 'include_deleted',
+            per_page: 200, // Get more fields to ensure we find the one we need
+            order: '-created_at', // Order by creation date, newest first
+        }, {
+            ...context,
+            metadata: {
+                ...context?.metadata,
+                operation: 'get_field_definition_list',
+            },
+        });
+        // Find the specific field definition
+        fieldDef = fieldDefinition.data?.find(f => f.id === fieldId);
+        if (!fieldDef) {
+            // Debug: log available field IDs to help troubleshoot
+            const availableIds = fieldDefinition.data?.map(f => f.id) || [];
+            console.log(`Field definition not found for field ID: ${fieldId}`);
+            console.log(`Available field definition IDs: ${availableIds.slice(0, 10).join(', ')}${availableIds.length > 10 ? '...' : ''}`);
+            console.log(`Total field definitions found: ${fieldDefinition.data?.length || 0}`);
+            throw new Error(`Field definition not found for field ID: ${fieldId}`);
+        }
+    }
+    // Check if this is a file field
+    if (hasDataType(fieldDef.attributes) && fieldDef.attributes.data_type === 'file') {
+        // This is a file field - always use file upload
+        const fileUrl = (0, helpers_1.isFileUpload)(value) ? (0, helpers_1.extractFileUrl)(value) : value;
+        return createPersonFileFieldDataInternal(client, personId, fieldId, fileUrl, {
+            ...context,
+            endpoint: `/people/${personId}/field_data`,
+            metadata: {
+                ...context?.metadata,
+                operation: 'create_file_field_data',
+            },
+            method: 'POST',
+        });
+    }
+    // This is a text field - clean the value if it's a file URL
+    const cleanValue = (0, helpers_1.isFileUpload)(value) ? (0, helpers_1.extractFileUrl)(value) : value;
+    return createPersonFieldDataInternal(client, personId, fieldId, cleanValue, {
+        ...context,
+        endpoint: `/people/${personId}/field_data`,
+        metadata: {
+            ...context?.metadata,
+            operation: 'create_text_field_data',
+        },
+        method: 'POST',
+    });
+}

package/dist/people/households.d.ts

@@ -0,0 +1,15 @@
+import { PcoClientState } from '../core';
+import type { ErrorContext } from '../error-handling';
+import { HouseholdSingle, HouseholdsList } from '../types';
+/**
+ * Get all households
+ */
+export declare function getHouseholds(client: PcoClientState, params?: {
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<HouseholdsList>;
+/**
+ * Get a single household by ID
+ */
+export declare function getHousehold(client: PcoClientState, id: string, include?: string[], context?: Partial<ErrorContext>): Promise<HouseholdSingle>;

package/dist/people/households.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHouseholds = getHouseholds;
+exports.getHousehold = getHousehold;
+const core_1 = require("../core");
+const helpers_1 = require("../helpers");
+/**
+ * Get all households
+ */
+async function getHouseholds(client, params, context) {
+    return (0, core_1.getList)(client, '/households', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/households',
+        method: 'GET',
+    });
+}
+/**
+ * Get a single household by ID
+ */
+async function getHousehold(client, id, include, context) {
+    const params = {};
+    if (include) {
+        params.include = include.join(',');
+    }
+    return (0, core_1.getSingle)(client, `/households/${id}`, params, {
+        ...context,
+        endpoint: `/households/${id}`,
+        householdId: id,
+        method: 'GET',
+    });
+}

package/dist/people/index.d.ts

@@ -0,0 +1,8 @@
+export * from './core';
+export * from './contacts';
+export * from './fields';
+export * from './households';
+export * from './lists';
+export * from './notes';
+export * from './workflows';
+export * from './organization';

package/dist/people/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all people-related functions from their respective modules
+__exportStar(require("./core"), exports);
+__exportStar(require("./contacts"), exports);
+__exportStar(require("./fields"), exports);
+__exportStar(require("./households"), exports);
+__exportStar(require("./lists"), exports);
+__exportStar(require("./notes"), exports);
+__exportStar(require("./workflows"), exports);
+__exportStar(require("./organization"), exports);

package/dist/people/lists.d.ts

@@ -0,0 +1,30 @@
+import { PcoClientState } from '../core';
+import type { ErrorContext } from '../error-handling';
+import { ListCategoriesList, ListSingle, ListsList } from '../types';
+/**
+ * Get all lists
+ */
+export declare function getLists(client: PcoClientState, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<ListsList>;
+/**
+ * Get a single list
+ */
+export declare function getListById(client: PcoClientState, listId: string, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<ListSingle>;
+/**
+ * Get all list categories
+ */
+export declare function getListCategories(client: PcoClientState, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<ListCategoriesList>;

package/dist/people/lists.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLists = getLists;
+exports.getListById = getListById;
+exports.getListCategories = getListCategories;
+const core_1 = require("../core");
+const helpers_1 = require("../helpers");
+/**
+ * Get all lists
+ */
+async function getLists(client, params, context) {
+    return (0, core_1.getList)(client, '/lists', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/lists',
+        method: 'GET',
+    });
+}
+/**
+ * Get a single list
+ */
+async function getListById(client, listId, params, context) {
+    return (0, core_1.getSingle)(client, `/lists/${listId}`, (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: `/lists/${listId}`,
+        method: 'GET',
+    });
+}
+/**
+ * Get all list categories
+ */
+async function getListCategories(client, params, context) {
+    return (0, core_1.getList)(client, '/list_categories', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/list_categories',
+        method: 'GET',
+    });
+}

package/dist/people/notes.d.ts

@@ -0,0 +1,30 @@
+import { PcoClientState } from '../core';
+import type { ErrorContext } from '../error-handling';
+import { NoteCategoriesList, NoteSingle, NotesList } from '../types';
+/**
+ * Get all notes
+ */
+export declare function getNotes(client: PcoClientState, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<NotesList>;
+/**
+ * Get a single note
+ */
+export declare function getNote(client: PcoClientState, noteId: string, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<NoteSingle>;
+/**
+ * Get all note categories
+ */
+export declare function getNoteCategories(client: PcoClientState, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<NoteCategoriesList>;

package/dist/people/notes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNotes = getNotes;
+exports.getNote = getNote;
+exports.getNoteCategories = getNoteCategories;
+const core_1 = require("../core");
+const helpers_1 = require("../helpers");
+/**
+ * Get all notes
+ */
+async function getNotes(client, params, context) {
+    return (0, core_1.getList)(client, '/notes', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/notes',
+        method: 'GET',
+    });
+}
+/**
+ * Get a single note
+ */
+async function getNote(client, noteId, params, context) {
+    return (0, core_1.getSingle)(client, `/notes/${noteId}`, (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: `/notes/${noteId}`,
+        method: 'GET',
+    });
+}
+/**
+ * Get all note categories
+ */
+async function getNoteCategories(client, params, context) {
+    return (0, core_1.getList)(client, '/note_categories', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/note_categories',
+        method: 'GET',
+    });
+}

package/dist/people/organization.d.ts

@@ -0,0 +1,12 @@
+import { PcoClientState } from '../core';
+import type { ErrorContext } from '../error-handling';
+import { OrganizationSingle } from '../types';
+/**
+ * Get organization information
+ */
+export declare function getOrganization(client: PcoClientState, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<OrganizationSingle>;

package/dist/people/organization.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrganization = getOrganization;
+const core_1 = require("../core");
+const helpers_1 = require("../helpers");
+/**
+ * Get organization information
+ */
+async function getOrganization(client, params, context) {
+    return (0, core_1.getSingle)(client, '/', (0, helpers_1.buildQueryParams)(params), {
+        ...context,
+        endpoint: '/',
+        method: 'GET',
+    });
+}

package/dist/people/workflows.d.ts

@@ -0,0 +1,37 @@
+import { PcoClientState } from '../core';
+import type { ErrorContext } from '../error-handling';
+import { WorkflowCardNoteAttributes, WorkflowCardNoteSingle, WorkflowCardNotesList, WorkflowCardSingle, WorkflowCardsList, WorkflowSingle, WorkflowsList } from '../types';
+/**
+ * List notes for a workflow card
+ */
+export declare function getWorkflowCardNotes(client: PcoClientState, personId: string, workflowCardId: string, context?: Partial<ErrorContext>): Promise<WorkflowCardNotesList>;
+/**
+ * Create a note for a workflow card
+ */
+export declare function createWorkflowCardNote(client: PcoClientState, personId: string, workflowCardId: string, data: Partial<WorkflowCardNoteAttributes>, context?: Partial<ErrorContext>): Promise<WorkflowCardNoteSingle>;
+/**
+ * List workflow cards for a person
+ */
+export declare function getWorkflowCards(client: PcoClientState, personId: string, context?: Partial<ErrorContext>): Promise<WorkflowCardsList>;
+/**
+ * Create a workflow card in a workflow for a person
+ */
+export declare function createWorkflowCard(client: PcoClientState, workflowId: string, personId: string, context?: Partial<ErrorContext>): Promise<WorkflowCardSingle>;
+/**
+ * Get all workflows
+ */
+export declare function getWorkflows(client: PcoClientState, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<WorkflowsList>;
+/**
+ * Get a single workflow
+ */
+export declare function getWorkflow(client: PcoClientState, workflowId: string, params?: {
+    where?: Record<string, any>;
+    include?: string[];
+    per_page?: number;
+    page?: number;
+}, context?: Partial<ErrorContext>): Promise<WorkflowSingle>;