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

package/dist/matching/strategies.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * v2.0.0 Person Matching Strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchStrategies = void 0;
+class MatchStrategies {
+    /**
+     * Select the best match based on strategy
+     */
+    selectBestMatch(candidates, strategy) {
+        if (candidates.length === 0) {
+            return null;
+        }
+        switch (strategy) {
+            case 'exact':
+                return this.selectExactMatch(candidates);
+            case 'fuzzy':
+                return this.selectFuzzyMatch(candidates);
+            case 'aggressive':
+                return this.selectAggressiveMatch(candidates);
+            default:
+                return this.selectFuzzyMatch(candidates);
+        }
+    }
+    /**
+     * Exact matching strategy - only return matches with very high confidence
+     */
+    selectExactMatch(candidates) {
+        // Only return matches with score >= 0.9
+        const exactMatches = candidates.filter(c => c.score >= 0.9);
+        return exactMatches.length > 0 ? exactMatches[0] : null;
+    }
+    /**
+     * Fuzzy matching strategy - return best match above threshold
+     */
+    selectFuzzyMatch(candidates) {
+        // Return best match with score >= 0.7
+        const fuzzyMatches = candidates.filter(c => c.score >= 0.7);
+        return fuzzyMatches.length > 0 ? fuzzyMatches[0] : null;
+    }
+    /**
+     * Aggressive matching strategy - return best match with lower threshold
+     */
+    selectAggressiveMatch(candidates) {
+        // Return best match with score >= 0.5
+        const aggressiveMatches = candidates.filter(c => c.score >= 0.5);
+        return aggressiveMatches.length > 0 ? aggressiveMatches[0] : null;
+    }
+    /**
+     * Get all matches above threshold for a strategy
+     */
+    getAllMatchesAboveThreshold(candidates, strategy) {
+        const threshold = this.getThreshold(strategy);
+        return candidates.filter(c => c.score >= threshold);
+    }
+    /**
+     * Get the threshold for a strategy
+     */
+    getThreshold(strategy) {
+        switch (strategy) {
+            case 'exact':
+                return 0.9;
+            case 'fuzzy':
+                return 0.7;
+            case 'aggressive':
+                return 0.5;
+            default:
+                return 0.7;
+        }
+    }
+    /**
+     * Check if a score meets the strategy threshold
+     */
+    meetsThreshold(score, strategy) {
+        return score >= this.getThreshold(strategy);
+    }
+}
+exports.MatchStrategies = MatchStrategies;

package/dist/modules/base.d.ts

@@ -0,0 +1,46 @@
+/**
+ * v2.0.0 Base Module Class
+ */
+import type { PcoHttpClient } from '../core/http';
+import type { PaginationHelper } from '../core/pagination';
+import type { PcoEventEmitter } from '../monitoring';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { ResourceObject } from '../types';
+export declare abstract class BaseModule {
+    protected httpClient: PcoHttpClient;
+    protected paginationHelper: PaginationHelper;
+    protected eventEmitter: PcoEventEmitter;
+    constructor(httpClient: PcoHttpClient, paginationHelper: PaginationHelper, eventEmitter: PcoEventEmitter);
+    /**
+     * Get a single resource
+     */
+    protected getSingle<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>): Promise<T>;
+    /**
+     * Get a list of resources
+     */
+    protected getList<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>): Promise<{
+        data: T[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Create a resource
+     */
+    protected createResource<T extends ResourceObject<string, any, any>>(endpoint: string, data: any, params?: Record<string, any>): Promise<T>;
+    /**
+     * Update a resource
+     */
+    protected updateResource<T extends ResourceObject<string, any, any>>(endpoint: string, data: any, params?: Record<string, any>): Promise<T>;
+    /**
+     * Delete a resource
+     */
+    protected deleteResource(endpoint: string, params?: Record<string, any>): Promise<void>;
+    /**
+     * Get all pages of a resource
+     */
+    protected getAllPages<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>, options?: PaginationOptions): Promise<PaginationResult<T>>;
+    /**
+     * Stream pages of a resource
+     */
+    protected streamPages<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>, options?: PaginationOptions): AsyncGenerator<T[], void, unknown>;
+}

package/dist/modules/base.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * v2.0.0 Base Module Class
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModule = void 0;
+class BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        this.httpClient = httpClient;
+        this.paginationHelper = paginationHelper;
+        this.eventEmitter = eventEmitter;
+    }
+    /**
+     * Get a single resource
+     */
+    async getSingle(endpoint, params) {
+        const response = await this.httpClient.request({
+            method: 'GET',
+            endpoint,
+            params,
+        });
+        return response.data.data;
+    }
+    /**
+     * Get a list of resources
+     */
+    async getList(endpoint, params) {
+        const response = await this.httpClient.request({
+            method: 'GET',
+            endpoint,
+            params,
+        });
+        return response.data;
+    }
+    /**
+     * Create a resource
+     */
+    async createResource(endpoint, data, params) {
+        const response = await this.httpClient.request({
+            method: 'POST',
+            endpoint,
+            data,
+            params,
+        });
+        return response.data.data;
+    }
+    /**
+     * Update a resource
+     */
+    async updateResource(endpoint, data, params) {
+        const response = await this.httpClient.request({
+            method: 'PATCH',
+            endpoint,
+            data,
+            params,
+        });
+        return response.data.data;
+    }
+    /**
+     * Delete a resource
+     */
+    async deleteResource(endpoint, params) {
+        await this.httpClient.request({
+            method: 'DELETE',
+            endpoint,
+            params,
+        });
+    }
+    /**
+     * Get all pages of a resource
+     */
+    async getAllPages(endpoint, params, options) {
+        return this.paginationHelper.getAllPages(endpoint, params, options);
+    }
+    /**
+     * Stream pages of a resource
+     */
+    async *streamPages(endpoint, params, options) {
+        yield* this.paginationHelper.streamPages(endpoint, params, options);
+    }
+}
+exports.BaseModule = BaseModule;

package/dist/modules/contacts.d.ts

@@ -0,0 +1,103 @@
+/**
+ * v2.0.0 Contacts Module
+ */
+import { BaseModule } from './base';
+import type { EmailResource, EmailAttributes, PhoneNumberResource, PhoneNumberAttributes, AddressResource, AddressAttributes, SocialProfileResource, SocialProfileAttributes } from '../types';
+export declare class ContactsModule extends BaseModule {
+    /**
+     * Get all emails
+     */
+    getAllEmails(): Promise<{
+        data: EmailResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single email by ID
+     */
+    getEmailById(id: string): Promise<EmailResource>;
+    /**
+     * Create an email
+     */
+    createEmail(data: EmailAttributes): Promise<EmailResource>;
+    /**
+     * Update an email
+     */
+    updateEmail(id: string, data: Partial<EmailAttributes>): Promise<EmailResource>;
+    /**
+     * Delete an email
+     */
+    deleteEmail(id: string): Promise<void>;
+    /**
+     * Get all phone numbers
+     */
+    getAllPhoneNumbers(): Promise<{
+        data: PhoneNumberResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single phone number by ID
+     */
+    getPhoneNumberById(id: string): Promise<PhoneNumberResource>;
+    /**
+     * Create a phone number
+     */
+    createPhoneNumber(data: PhoneNumberAttributes): Promise<PhoneNumberResource>;
+    /**
+     * Update a phone number
+     */
+    updatePhoneNumber(id: string, data: Partial<PhoneNumberAttributes>): Promise<PhoneNumberResource>;
+    /**
+     * Delete a phone number
+     */
+    deletePhoneNumber(id: string): Promise<void>;
+    /**
+     * Get all addresses
+     */
+    getAllAddresses(): Promise<{
+        data: AddressResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single address by ID
+     */
+    getAddressById(id: string): Promise<AddressResource>;
+    /**
+     * Create an address
+     */
+    createAddress(data: AddressAttributes): Promise<AddressResource>;
+    /**
+     * Update an address
+     */
+    updateAddress(id: string, data: Partial<AddressAttributes>): Promise<AddressResource>;
+    /**
+     * Delete an address
+     */
+    deleteAddress(id: string): Promise<void>;
+    /**
+     * Get all social profiles
+     */
+    getAllSocialProfiles(): Promise<{
+        data: SocialProfileResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single social profile by ID
+     */
+    getSocialProfileById(id: string): Promise<SocialProfileResource>;
+    /**
+     * Create a social profile
+     */
+    createSocialProfile(data: SocialProfileAttributes): Promise<SocialProfileResource>;
+    /**
+     * Update a social profile
+     */
+    updateSocialProfile(id: string, data: Partial<SocialProfileAttributes>): Promise<SocialProfileResource>;
+    /**
+     * Delete a social profile
+     */
+    deleteSocialProfile(id: string): Promise<void>;
+}

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;
+}