@rachelallyson/planning-center-people-ts 1.1.0 → 2.1.0

package/dist/modules/contacts.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * v2.0.0 Contacts Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactsModule = void 0;
+const base_1 = require("./base");
+class ContactsModule extends base_1.BaseModule {
+    /**
+     * Get all emails
+     */
+    async getAllEmails() {
+        return this.getList('/emails');
+    }
+    /**
+     * Get a single email by ID
+     */
+    async getEmailById(id) {
+        return this.getSingle(`/emails/${id}`);
+    }
+    /**
+     * Create an email
+     */
+    async createEmail(data) {
+        return this.createResource('/emails', data);
+    }
+    /**
+     * Update an email
+     */
+    async updateEmail(id, data) {
+        return this.updateResource(`/emails/${id}`, data);
+    }
+    /**
+     * Delete an email
+     */
+    async deleteEmail(id) {
+        return this.deleteResource(`/emails/${id}`);
+    }
+    /**
+     * Get all phone numbers
+     */
+    async getAllPhoneNumbers() {
+        return this.getList('/phone_numbers');
+    }
+    /**
+     * Get a single phone number by ID
+     */
+    async getPhoneNumberById(id) {
+        return this.getSingle(`/phone_numbers/${id}`);
+    }
+    /**
+     * Create a phone number
+     */
+    async createPhoneNumber(data) {
+        return this.createResource('/phone_numbers', data);
+    }
+    /**
+     * Update a phone number
+     */
+    async updatePhoneNumber(id, data) {
+        return this.updateResource(`/phone_numbers/${id}`, data);
+    }
+    /**
+     * Delete a phone number
+     */
+    async deletePhoneNumber(id) {
+        return this.deleteResource(`/phone_numbers/${id}`);
+    }
+    /**
+     * Get all addresses
+     */
+    async getAllAddresses() {
+        return this.getList('/addresses');
+    }
+    /**
+     * Get a single address by ID
+     */
+    async getAddressById(id) {
+        return this.getSingle(`/addresses/${id}`);
+    }
+    /**
+     * Create an address
+     */
+    async createAddress(data) {
+        return this.createResource('/addresses', data);
+    }
+    /**
+     * Update an address
+     */
+    async updateAddress(id, data) {
+        return this.updateResource(`/addresses/${id}`, data);
+    }
+    /**
+     * Delete an address
+     */
+    async deleteAddress(id) {
+        return this.deleteResource(`/addresses/${id}`);
+    }
+    /**
+     * Get all social profiles
+     */
+    async getAllSocialProfiles() {
+        return this.getList('/social_profiles');
+    }
+    /**
+     * Get a single social profile by ID
+     */
+    async getSocialProfileById(id) {
+        return this.getSingle(`/social_profiles/${id}`);
+    }
+    /**
+     * Create a social profile
+     */
+    async createSocialProfile(data) {
+        return this.createResource('/social_profiles', data);
+    }
+    /**
+     * Update a social profile
+     */
+    async updateSocialProfile(id, data) {
+        return this.updateResource(`/social_profiles/${id}`, data);
+    }
+    /**
+     * Delete a social profile
+     */
+    async deleteSocialProfile(id) {
+        return this.deleteResource(`/social_profiles/${id}`);
+    }
+}
+exports.ContactsModule = ContactsModule;

package/dist/modules/fields.d.ts

@@ -0,0 +1,157 @@
+/**
+ * v2.0.0 Fields Module
+ */
+import { BaseModule } from './base';
+import type { PcoHttpClient } from '../core/http';
+import type { PaginationHelper } from '../core/pagination';
+import type { PcoEventEmitter } from '../monitoring';
+import type { FieldDefinitionResource, FieldDefinitionAttributes, FieldDatumResource, FieldOptionResource, FieldOptionAttributes, TabResource, TabAttributes } from '../types';
+export interface FieldDefinitionCache {
+    byId: Map<string, FieldDefinitionResource>;
+    bySlug: Map<string, FieldDefinitionResource>;
+    byName: Map<string, FieldDefinitionResource>;
+    lastUpdated: number;
+}
+export interface FieldSetOptions {
+    /** Field definition ID */
+    fieldId?: string;
+    /** Field definition slug */
+    fieldSlug?: string;
+    /** Field definition name */
+    fieldName?: string;
+    /** Value to set */
+    value: string;
+    /** Whether to handle file uploads automatically */
+    handleFileUploads?: boolean;
+}
+export declare class FieldsModule extends BaseModule {
+    private fieldDefinitionCache;
+    private cacheTtl;
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get all field definitions with caching
+     */
+    getAllFieldDefinitions(useCache?: boolean): Promise<FieldDefinitionResource[]>;
+    /**
+     * Get a single field definition by ID
+     */
+    getFieldDefinition(id: string): Promise<FieldDefinitionResource>;
+    /**
+     * Get field definition by slug
+     */
+    getFieldDefinitionBySlug(slug: string): Promise<FieldDefinitionResource | null>;
+    /**
+     * Get field definition by name
+     */
+    getFieldDefinitionByName(name: string): Promise<FieldDefinitionResource | null>;
+    /**
+     * Create a field definition
+     */
+    createFieldDefinition(tabId: string, data: FieldDefinitionAttributes): Promise<FieldDefinitionResource>;
+    /**
+     * Update a field definition
+     */
+    updateFieldDefinition(id: string, data: Partial<FieldDefinitionAttributes>): Promise<FieldDefinitionResource>;
+    /**
+     * Delete a field definition
+     */
+    deleteFieldDefinition(id: string): Promise<void>;
+    /**
+     * Get field options for a field definition
+     */
+    getFieldOptions(fieldDefinitionId: string): Promise<{
+        data: FieldOptionResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Create a field option
+     */
+    createFieldOption(fieldDefinitionId: string, data: FieldOptionAttributes): Promise<FieldOptionResource>;
+    /**
+     * Get person's field data
+     */
+    getPersonFieldData(personId: string): Promise<{
+        data: FieldDatumResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Set a person's field value with automatic field lookup
+     */
+    setPersonField(personId: string, options: FieldSetOptions): Promise<FieldDatumResource>;
+    /**
+     * Set a person's field value by field definition ID
+     */
+    setPersonFieldById(personId: string, fieldId: string, value: string): Promise<FieldDatumResource>;
+    /**
+     * Set a person's field value by field slug
+     */
+    setPersonFieldBySlug(personId: string, fieldSlug: string, value: string): Promise<FieldDatumResource>;
+    /**
+     * Set a person's field value by field name
+     */
+    setPersonFieldByName(personId: string, fieldName: string, value: string): Promise<FieldDatumResource>;
+    /**
+     * Create field data for a person
+     */
+    createPersonFieldData(personId: string, fieldDefinitionId: string, value: string, options?: {
+        handleFileUploads?: boolean;
+    }): Promise<FieldDatumResource>;
+    /**
+     * Delete person's field data
+     */
+    deletePersonFieldData(personId: string, fieldDataId: string): Promise<void>;
+    /**
+     * Get all tabs
+     */
+    getTabs(): Promise<{
+        data: TabResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Create a tab
+     */
+    createTab(data: TabAttributes): Promise<TabResource>;
+    /**
+     * Update a tab
+     */
+    updateTab(id: string, data: Partial<TabAttributes>): Promise<TabResource>;
+    /**
+     * Delete a tab
+     */
+    deleteTab(id: string): Promise<void>;
+    /**
+     * Resolve field definition from options
+     */
+    private resolveFieldDefinition;
+    /**
+     * Create field data for file uploads
+     */
+    private createPersonFileFieldData;
+    /**
+     * Check if cache is valid
+     */
+    private isCacheValid;
+    /**
+     * Ensure cache is loaded
+     */
+    private ensureCacheLoaded;
+    /**
+     * Update field definition cache
+     */
+    private updateFieldDefinitionCache;
+    /**
+     * Invalidate cache
+     */
+    private invalidateCache;
+    /**
+     * Check if a value is a file URL
+     */
+    private isFileUrl;
+    /**
+     * Extract file URL from HTML markup
+     */
+    private extractFileUrl;
+}

package/dist/modules/fields.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * v2.0.0 Fields Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldsModule = void 0;
+const base_1 = require("./base");
+class FieldsModule extends base_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+        this.fieldDefinitionCache = null;
+        this.cacheTtl = 300000; // 5 minutes
+    }
+    /**
+     * Get all field definitions with caching
+     */
+    async getAllFieldDefinitions(useCache = true) {
+        if (useCache && this.isCacheValid()) {
+            return Array.from(this.fieldDefinitionCache.byId.values());
+        }
+        const result = await this.getAllPages('/field_definitions', {
+            include: ['tab'],
+        });
+        // Update cache
+        this.updateFieldDefinitionCache(result.data);
+        return result.data;
+    }
+    /**
+     * Get a single field definition by ID
+     */
+    async getFieldDefinition(id) {
+        return this.getSingle(`/field_definitions/${id}`);
+    }
+    /**
+     * Get field definition by slug
+     */
+    async getFieldDefinitionBySlug(slug) {
+        await this.ensureCacheLoaded();
+        return this.fieldDefinitionCache?.bySlug.get(slug) || null;
+    }
+    /**
+     * Get field definition by name
+     */
+    async getFieldDefinitionByName(name) {
+        await this.ensureCacheLoaded();
+        return this.fieldDefinitionCache?.byName.get(name) || null;
+    }
+    /**
+     * Create a field definition
+     */
+    async createFieldDefinition(tabId, data) {
+        const fieldDef = await this.createResource(`/tabs/${tabId}/field_definitions`, data);
+        // Invalidate cache
+        this.invalidateCache();
+        return fieldDef;
+    }
+    /**
+     * Update a field definition
+     */
+    async updateFieldDefinition(id, data) {
+        const fieldDef = await this.updateResource(`/field_definitions/${id}`, data);
+        // Update cache
+        if (this.fieldDefinitionCache && fieldDef.attributes) {
+            this.fieldDefinitionCache.byId.set(id, fieldDef);
+            this.fieldDefinitionCache.bySlug.set(fieldDef.attributes.slug, fieldDef);
+            this.fieldDefinitionCache.byName.set(fieldDef.attributes.name, fieldDef);
+        }
+        return fieldDef;
+    }
+    /**
+     * Delete a field definition
+     */
+    async deleteFieldDefinition(id) {
+        await this.deleteResource(`/field_definitions/${id}`);
+        // Remove from cache
+        if (this.fieldDefinitionCache) {
+            const fieldDef = this.fieldDefinitionCache.byId.get(id);
+            if (fieldDef && fieldDef.attributes) {
+                this.fieldDefinitionCache.byId.delete(id);
+                this.fieldDefinitionCache.bySlug.delete(fieldDef.attributes.slug);
+                this.fieldDefinitionCache.byName.delete(fieldDef.attributes.name);
+            }
+        }
+    }
+    /**
+     * Get field options for a field definition
+     */
+    async getFieldOptions(fieldDefinitionId) {
+        return this.getList(`/field_definitions/${fieldDefinitionId}/field_options`);
+    }
+    /**
+     * Create a field option
+     */
+    async createFieldOption(fieldDefinitionId, data) {
+        return this.createResource(`/field_definitions/${fieldDefinitionId}/field_options`, data);
+    }
+    /**
+     * Get person's field data
+     */
+    async getPersonFieldData(personId) {
+        return this.getList(`/people/${personId}/field_data`);
+    }
+    /**
+     * Set a person's field value with automatic field lookup
+     */
+    async setPersonField(personId, options) {
+        const fieldDef = await this.resolveFieldDefinition(options);
+        if (!fieldDef) {
+            throw new Error(`Field definition not found for: ${options.fieldId || options.fieldSlug || options.fieldName}`);
+        }
+        return this.createPersonFieldData(personId, fieldDef.id, options.value, {
+            handleFileUploads: options.handleFileUploads ?? true,
+        });
+    }
+    /**
+     * Set a person's field value by field definition ID
+     */
+    async setPersonFieldById(personId, fieldId, value) {
+        return this.createPersonFieldData(personId, fieldId, value);
+    }
+    /**
+     * Set a person's field value by field slug
+     */
+    async setPersonFieldBySlug(personId, fieldSlug, value) {
+        const fieldDef = await this.getFieldDefinitionBySlug(fieldSlug);
+        if (!fieldDef) {
+            throw new Error(`Field definition not found for slug: ${fieldSlug}`);
+        }
+        return this.createPersonFieldData(personId, fieldDef.id, value);
+    }
+    /**
+     * Set a person's field value by field name
+     */
+    async setPersonFieldByName(personId, fieldName, value) {
+        const fieldDef = await this.getFieldDefinitionByName(fieldName);
+        if (!fieldDef) {
+            throw new Error(`Field definition not found for name: ${fieldName}`);
+        }
+        return this.createPersonFieldData(personId, fieldDef.id, value);
+    }
+    /**
+     * Create field data for a person
+     */
+    async createPersonFieldData(personId, fieldDefinitionId, value, options = {}) {
+        const { handleFileUploads = true } = options;
+        // Get field definition to determine type
+        const fieldDef = await this.getFieldDefinition(fieldDefinitionId);
+        // Check if this is a file field and handle accordingly
+        if (fieldDef.attributes && fieldDef.attributes.data_type === 'file' && handleFileUploads) {
+            return this.createPersonFileFieldData(personId, fieldDefinitionId, value);
+        }
+        // For text fields, clean the value if it's a file URL
+        const cleanValue = this.isFileUrl(value) ? this.extractFileUrl(value) : value;
+        // Check if field data already exists for this person and field
+        try {
+            const existingFieldData = await this.getPersonFieldData(personId);
+            const existingDatum = existingFieldData.data.find(datum => {
+                const fieldDefData = datum.relationships?.field_definition?.data;
+                return Array.isArray(fieldDefData)
+                    ? fieldDefData.some(fd => fd.id === fieldDefinitionId)
+                    : fieldDefData?.id === fieldDefinitionId;
+            });
+            if (existingDatum) {
+                // Update existing field data
+                return this.updateResource(`/people/${personId}/field_data/${existingDatum.id}`, { value: cleanValue });
+            }
+        }
+        catch (error) {
+            // If we can't get existing field data, continue with creation
+        }
+        return this.createResource(`/people/${personId}/field_data`, {
+            field_definition_id: fieldDefinitionId,
+            value: cleanValue,
+        });
+    }
+    /**
+     * Delete person's field data
+     */
+    async deletePersonFieldData(personId, fieldDataId) {
+        return this.deleteResource(`/people/${personId}/field_data/${fieldDataId}`);
+    }
+    /**
+     * Get all tabs
+     */
+    async getTabs() {
+        return this.getList('/tabs');
+    }
+    /**
+     * Create a tab
+     */
+    async createTab(data) {
+        return this.createResource('/tabs', data);
+    }
+    /**
+     * Update a tab
+     */
+    async updateTab(id, data) {
+        return this.updateResource(`/tabs/${id}`, data);
+    }
+    /**
+     * Delete a tab
+     */
+    async deleteTab(id) {
+        return this.deleteResource(`/tabs/${id}`);
+    }
+    /**
+     * Resolve field definition from options
+     */
+    async resolveFieldDefinition(options) {
+        if (options.fieldId) {
+            return this.getFieldDefinition(options.fieldId);
+        }
+        if (options.fieldSlug) {
+            return this.getFieldDefinitionBySlug(options.fieldSlug);
+        }
+        if (options.fieldName) {
+            return this.getFieldDefinitionByName(options.fieldName);
+        }
+        return null;
+    }
+    /**
+     * Create field data for file uploads
+     */
+    async createPersonFileFieldData(personId, fieldDefinitionId, fileUrl) {
+        // This would implement the file upload logic from the original implementation
+        // For now, return a placeholder
+        throw new Error('File upload functionality not yet implemented in v2.0');
+    }
+    /**
+     * Check if cache is valid
+     */
+    isCacheValid() {
+        if (!this.fieldDefinitionCache) {
+            return false;
+        }
+        return Date.now() - this.fieldDefinitionCache.lastUpdated < this.cacheTtl;
+    }
+    /**
+     * Ensure cache is loaded
+     */
+    async ensureCacheLoaded() {
+        if (!this.isCacheValid()) {
+            await this.getAllFieldDefinitions(false);
+        }
+    }
+    /**
+     * Update field definition cache
+     */
+    updateFieldDefinitionCache(fieldDefinitions) {
+        this.fieldDefinitionCache = {
+            byId: new Map(),
+            bySlug: new Map(),
+            byName: new Map(),
+            lastUpdated: Date.now(),
+        };
+        for (const fieldDef of fieldDefinitions) {
+            if (fieldDef.attributes) {
+                this.fieldDefinitionCache.byId.set(fieldDef.id, fieldDef);
+                this.fieldDefinitionCache.bySlug.set(fieldDef.attributes.slug, fieldDef);
+                this.fieldDefinitionCache.byName.set(fieldDef.attributes.name, fieldDef);
+            }
+        }
+    }
+    /**
+     * Invalidate cache
+     */
+    invalidateCache() {
+        this.fieldDefinitionCache = null;
+    }
+    /**
+     * Check if a value is a file URL
+     */
+    isFileUrl(value) {
+        return value.includes('s3.') || value.includes('amazonaws.com') || value.includes('<a href=');
+    }
+    /**
+     * Extract file URL from HTML markup
+     */
+    extractFileUrl(value) {
+        if (value.startsWith('http') && !value.includes('<')) {
+            return value;
+        }
+        const hrefMatch = /href=["']([^"']+)["']/.exec(value);
+        if (hrefMatch) {
+            return hrefMatch[1];
+        }
+        const urlMatch = /(https?:\/\/[^\s<>"']+)/.exec(value);
+        if (urlMatch) {
+            return urlMatch[1];
+        }
+        return value;
+    }
+}
+exports.FieldsModule = FieldsModule;

package/dist/modules/households.d.ts

@@ -0,0 +1,42 @@
+/**
+ * v2.0.0 Households Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { HouseholdResource, HouseholdAttributes } from '../types';
+export interface HouseholdListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class HouseholdsModule extends BaseModule {
+    /**
+     * Get all households
+     */
+    getAll(options?: HouseholdListOptions): Promise<{
+        data: HouseholdResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all households across all pages
+     */
+    getAllPagesPaginated(options?: HouseholdListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<HouseholdResource>>;
+    /**
+     * Get a single household by ID
+     */
+    getById(id: string, include?: string[]): Promise<HouseholdResource>;
+    /**
+     * Create a household
+     */
+    create(data: HouseholdAttributes): Promise<HouseholdResource>;
+    /**
+     * Update a household
+     */
+    update(id: string, data: Partial<HouseholdAttributes>): Promise<HouseholdResource>;
+    /**
+     * Delete a household
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/modules/households.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * v2.0.0 Households Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HouseholdsModule = void 0;
+const base_1 = require("./base");
+class HouseholdsModule extends base_1.BaseModule {
+    /**
+     * Get all households
+     */
+    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('/households', params);
+    }
+    /**
+     * Get all households across all pages
+     */
+    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('/households', params, paginationOptions);
+    }
+    /**
+     * Get a single household by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/households/${id}`, params);
+    }
+    /**
+     * Create a household
+     */
+    async create(data) {
+        return this.createResource('/households', data);
+    }
+    /**
+     * Update a household
+     */
+    async update(id, data) {
+        return this.updateResource(`/households/${id}`, data);
+    }
+    /**
+     * Delete a household
+     */
+    async delete(id) {
+        return this.deleteResource(`/households/${id}`);
+    }
+}
+exports.HouseholdsModule = HouseholdsModule;