@rachelallyson/planning-center-people-ts 2.14.1 → 3.1.0

package/dist/core/http.js

@@ -1,360 +0,0 @@
-"use strict";
-/**
- * v2.0.0 HTTP Client
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PcoHttpClient = void 0;
-const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
-const planning_center_base_ts_2 = require("@rachelallyson/planning-center-base-ts");
-const planning_center_base_ts_3 = require("@rachelallyson/planning-center-base-ts");
-class PcoHttpClient {
-    constructor(config, eventEmitter) {
-        this.config = config;
-        this.eventEmitter = eventEmitter;
-        this.requestIdGenerator = new planning_center_base_ts_1.RequestIdGenerator();
-        this.performanceMetrics = new planning_center_base_ts_1.PerformanceMetrics();
-        this.rateLimitTracker = new planning_center_base_ts_1.RateLimitTracker();
-        // Initialize rate limiter
-        this.rateLimiter = new planning_center_base_ts_2.PcoRateLimiter(100, 20000); // 100 requests per 20 seconds
-    }
-    async request(options) {
-        const requestId = this.requestIdGenerator.generate();
-        const startTime = Date.now();
-        // Emit request start event
-        this.eventEmitter.emit({
-            type: 'request:start',
-            endpoint: options.endpoint,
-            method: options.method,
-            requestId,
-            timestamp: new Date().toISOString(),
-        });
-        try {
-            // Wait for rate limiter
-            await this.rateLimiter.waitForAvailability();
-            const response = await this.makeRequest(options, requestId);
-            const duration = Date.now() - startTime;
-            // Record performance metrics
-            this.performanceMetrics.record(`${options.method} ${options.endpoint}`, duration, true);
-            // Update rate limit tracking
-            this.updateRateLimitTracking(options.endpoint, response.headers);
-            // Emit request complete event
-            this.eventEmitter.emit({
-                type: 'request:complete',
-                endpoint: options.endpoint,
-                method: options.method,
-                status: response.status,
-                duration,
-                requestId,
-                timestamp: new Date().toISOString(),
-            });
-            return response;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            // Record performance metrics
-            this.performanceMetrics.record(`${options.method} ${options.endpoint}`, duration, false);
-            // Emit request error event
-            this.eventEmitter.emit({
-                type: 'request:error',
-                endpoint: options.endpoint,
-                method: options.method,
-                error: error,
-                requestId,
-                timestamp: new Date().toISOString(),
-            });
-            throw error;
-        }
-    }
-    async makeRequest(options, requestId, retryCount = 0) {
-        const baseURL = this.config.baseURL || 'https://api.planningcenteronline.com/people/v2';
-        let url = options.endpoint.startsWith('http') ? options.endpoint : `${baseURL}${options.endpoint}`;
-        // Add query parameters
-        if (options.params) {
-            const searchParams = new URLSearchParams();
-            Object.entries(options.params).forEach(([key, value]) => {
-                if (value !== undefined && value !== null) {
-                    searchParams.append(key, String(value));
-                }
-            });
-            const queryString = searchParams.toString();
-            if (queryString) {
-                url += url.includes('?') ? `&${queryString}` : `?${queryString}`;
-            }
-        }
-        // Prepare headers
-        const headers = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            ...this.config.headers,
-            ...options.headers,
-        };
-        // Add authentication
-        this.addAuthentication(headers);
-        // Prepare request options
-        const requestOptions = {
-            headers,
-            method: options.method,
-        };
-        // Add body for POST/PATCH requests
-        if ((options.method === 'POST' || options.method === 'PATCH') && options.data) {
-            // Determine resource type from endpoint
-            const resourceType = this.getResourceTypeFromEndpoint(options.endpoint);
-            // Separate attributes and relationships
-            const { relationships, ...attributes } = options.data;
-            const jsonApiData = {
-                data: {
-                    type: resourceType,
-                    attributes
-                }
-            };
-            // Add relationships if present
-            if (relationships) {
-                jsonApiData.data.relationships = relationships;
-            }
-            requestOptions.body = JSON.stringify(jsonApiData);
-        }
-        // Add timeout
-        const timeout = options.timeout || this.config.timeout || 30000;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        requestOptions.signal = controller.signal;
-        try {
-            const response = await fetch(url, requestOptions);
-            clearTimeout(timeoutId);
-            // Update rate limiter from headers
-            const rateLimitHeaders = {
-                'Retry-After': response.headers.get('retry-after') || undefined,
-                'X-PCO-API-Request-Rate-Count': response.headers.get('x-pco-api-request-rate-count') || undefined,
-                'X-PCO-API-Request-Rate-Limit': response.headers.get('x-pco-api-request-rate-limit') || undefined,
-                'X-PCO-API-Request-Rate-Period': response.headers.get('x-pco-api-request-rate-period') || undefined,
-            };
-            this.rateLimiter.updateFromHeaders(rateLimitHeaders);
-            this.rateLimiter.recordRequest();
-            // Handle 429 responses
-            if (response.status === 429) {
-                if (retryCount >= 5) {
-                    throw new Error(`Rate limit exceeded after ${retryCount} retries`);
-                }
-                await this.rateLimiter.waitForAvailability();
-                return this.makeRequest(options, requestId, retryCount + 1);
-            }
-            // Handle other errors
-            if (!response.ok) {
-                // Handle 401 errors with token refresh if available
-                if (response.status === 401 && this.config.auth.type === 'oauth') {
-                    if (retryCount >= 3) {
-                        throw new Error(`Authentication failed after ${retryCount} retries`);
-                    }
-                    try {
-                        await this.attemptTokenRefresh();
-                        return this.makeRequest(options, requestId, retryCount + 1);
-                    }
-                    catch (refreshError) {
-                        console.warn('Token refresh failed:', refreshError);
-                        // Call the onRefreshFailure callback
-                        await this.config.auth.onRefreshFailure?.(refreshError);
-                        throw refreshError;
-                    }
-                }
-                let errorData;
-                try {
-                    errorData = await response.json();
-                }
-                catch {
-                    errorData = {};
-                }
-                throw planning_center_base_ts_3.PcoApiError.fromFetchError(response, errorData);
-            }
-            // Parse response
-            if (options.method === 'DELETE') {
-                return {
-                    data: undefined,
-                    status: response.status,
-                    headers: this.extractHeaders(response),
-                    requestId,
-                    duration: 0, // Will be set by caller
-                };
-            }
-            const data = await response.json();
-            return {
-                data,
-                status: response.status,
-                headers: this.extractHeaders(response),
-                requestId,
-                duration: 0, // Will be set by caller
-            };
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            // Handle timeout/abort errors
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new Error(`Request timeout after ${timeout}ms`);
-            }
-            throw error;
-        }
-    }
-    addAuthentication(headers) {
-        if (this.config.auth.type === 'personal_access_token') {
-            // Personal Access Tokens use client_id:secret format with HTTP Basic Auth
-            // Get client ID from config (required)
-            const clientId = this.config.auth.personalAccessToken;
-            // Get client secret from config or environment (with config taking precedence)
-            const clientSecret = this.config.auth.personalAccessTokenSecret ||
-                process.env.PCO_PERSONAL_ACCESS_SECRET;
-            if (!clientId) {
-                throw new Error('personalAccessToken is required for personal access token authentication');
-            }
-            if (!clientSecret) {
-                throw new Error('personalAccessTokenSecret (in config) or PCO_PERSONAL_ACCESS_SECRET environment variable is required for personal access token authentication');
-            }
-            const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
-            headers.Authorization = `Basic ${credentials}`;
-        }
-        else if (this.config.auth.type === 'oauth') {
-            headers.Authorization = `Bearer ${this.config.auth.accessToken}`;
-        }
-        else if (this.config.auth.type === 'basic') {
-            // Basic auth with app credentials
-            const credentials = Buffer.from(`${this.config.auth.appId}:${this.config.auth.appSecret}`).toString('base64');
-            headers.Authorization = `Basic ${credentials}`;
-        }
-    }
-    getResourceTypeFromEndpoint(endpoint) {
-        // Extract resource type from endpoint
-        // /households -> Household
-        // /people -> Person
-        // /emails -> Email
-        // etc.
-        const pathParts = endpoint.split('/').filter(part => part.length > 0);
-        const resourcePath = pathParts[pathParts.length - 1];
-        // Convert kebab-case to PascalCase and make singular
-        const pascalCase = resourcePath
-            .split('-')
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-        // Make singular (remove trailing 's' if it exists and the word is longer than 3 characters)
-        if (pascalCase.endsWith('s') && pascalCase.length > 3) {
-            return pascalCase.slice(0, -1);
-        }
-        return pascalCase;
-    }
-    extractHeaders(response) {
-        const headers = {};
-        response.headers.forEach((value, key) => {
-            headers[key] = value;
-        });
-        return headers;
-    }
-    async attemptTokenRefresh() {
-        if (this.config.auth.type !== 'oauth') {
-            throw new Error('Token refresh is only available for OAuth authentication');
-        }
-        const baseURL = this.config.baseURL || 'https://api.planningcenteronline.com/people/v2';
-        const tokenUrl = baseURL.replace('/people/v2', '/oauth/token');
-        // Prepare the request body for token refresh
-        const body = new URLSearchParams({
-            grant_type: 'refresh_token',
-            refresh_token: this.config.auth.refreshToken || '',
-        });
-        // Add client credentials if available from the config or environment
-        const clientId = this.config.auth.appId || process.env.PCO_APP_ID;
-        const clientSecret = this.config.auth.appSecret || process.env.PCO_APP_SECRET;
-        if (clientId && clientSecret) {
-            body.append('client_id', clientId);
-            body.append('client_secret', clientSecret);
-        }
-        const response = await fetch(tokenUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Accept': 'application/json',
-            },
-            body: body.toString(),
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(`Token refresh failed: ${response.status} ${response.statusText}. ${JSON.stringify(errorData)}`);
-        }
-        const tokens = await response.json();
-        // Update the config with new tokens
-        this.config.auth.accessToken = tokens.access_token;
-        this.config.auth.refreshToken = tokens.refresh_token || this.config.auth.refreshToken;
-        // Call the onRefresh callback
-        await this.config.auth.onRefresh?.({
-            accessToken: tokens.access_token,
-            refreshToken: tokens.refresh_token || this.config.auth.refreshToken
-        });
-    }
-    updateRateLimitTracking(endpoint, headers) {
-        const limit = headers['x-pco-api-request-rate-limit'];
-        const remaining = headers['x-pco-api-request-rate-count'];
-        const resetTime = headers['retry-after'];
-        if (limit && remaining && resetTime) {
-            this.rateLimitTracker.update(endpoint, parseInt(limit), parseInt(remaining), Date.now() + parseInt(resetTime) * 1000);
-        }
-    }
-    getPerformanceMetrics() {
-        return this.performanceMetrics.getMetrics();
-    }
-    getRateLimitInfo() {
-        return this.rateLimitTracker.getAllLimits();
-    }
-    /**
-     * Get authentication header for external services (like file uploads)
-     */
-    getAuthHeader() {
-        // The base package's PcoHttpClient handles authentication, so this method should delegate
-        // But for backward compatibility, we'll implement it
-        if (this.config.auth.type === 'personal_access_token') {
-            const clientSecret = this.config.auth.personalAccessTokenSecret || process.env.PCO_PERSONAL_ACCESS_SECRET;
-            return `Basic ${Buffer.from(`${this.config.auth.personalAccessToken}:${clientSecret}`).toString('base64')}`;
-        }
-        else if (this.config.auth.type === 'oauth') {
-            return `Bearer ${this.config.auth.accessToken}`;
-        }
-        else if (this.config.auth.type === 'basic') {
-            return `Basic ${Buffer.from(`${this.config.auth.appId}:${this.config.auth.appSecret}`).toString('base64')}`;
-        }
-        return '';
-    }
-    /**
-     * Make HTTPS request using Node.js HTTPS module (fallback when fetch is unavailable)
-     */
-    async makeHttpsRequest(url, options) {
-        const https = require('https');
-        const urlObj = new URL(url);
-        const requestOptions = {
-            hostname: urlObj.hostname,
-            port: urlObj.port || 443,
-            path: urlObj.pathname + urlObj.search,
-            method: options.method || 'GET',
-            headers: options.headers,
-        };
-        return new Promise((resolve, reject) => {
-            const req = https.request(requestOptions, (res) => {
-                let data = '';
-                res.on('data', (chunk) => {
-                    data += chunk;
-                });
-                res.on('end', () => {
-                    // Create a response-like object
-                    const response = {
-                        ok: res.statusCode >= 200 && res.statusCode < 300,
-                        status: res.statusCode,
-                        statusText: res.statusMessage,
-                        headers: res.headers,
-                        text: () => Promise.resolve(data),
-                        json: () => Promise.resolve(JSON.parse(data)),
-                    };
-                    resolve(response);
-                });
-            });
-            req.on('error', reject);
-            if (options.body) {
-                req.write(options.body);
-            }
-            req.end();
-        });
-    }
-}
-exports.PcoHttpClient = PcoHttpClient;

package/dist/core/pagination.d.ts

@@ -1,34 +0,0 @@
-/**
- * v2.0.0 Pagination Utilities
- */
-import type { ResourceObject, Paginated } from '../types';
-import type { PcoHttpClient } from './http';
-export interface PaginationOptions {
-    /** Maximum number of pages to fetch */
-    maxPages?: number;
-    /** Items per page */
-    perPage?: number;
-    /** Progress callback */
-    onProgress?: (current: number, total: number) => void;
-    /** Delay between requests in milliseconds */
-    delay?: number;
-}
-export interface PaginationResult<T> {
-    data: T[];
-    totalCount: number;
-    pagesFetched: number;
-    duration: number;
-}
-export declare class PaginationHelper {
-    private httpClient;
-    constructor(httpClient: PcoHttpClient);
-    getAllPages<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>, options?: PaginationOptions): Promise<PaginationResult<T>>;
-    getPage<T extends ResourceObject<string, any, any>>(endpoint: string, page?: number, perPage?: number, params?: Record<string, any>): Promise<Paginated<T>>;
-    streamPages<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>, options?: PaginationOptions): AsyncGenerator<T[], void, unknown>;
-    /**
-     * Get all pages with parallel processing for better performance
-     */
-    getAllPagesParallel<T extends ResourceObject<string, any, any>>(endpoint: string, params?: Record<string, any>, options?: PaginationOptions & {
-        maxConcurrency?: number;
-    }): Promise<PaginationResult<T>>;
-}

package/dist/core/pagination.js

@@ -1,178 +0,0 @@
-"use strict";
-/**
- * v2.0.0 Pagination Utilities
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginationHelper = void 0;
-class PaginationHelper {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-    }
-    async getAllPages(endpoint, params = {}, options = {}) {
-        // Ensure endpoint is a string
-        if (typeof endpoint !== 'string') {
-            throw new Error(`Expected endpoint to be a string, got ${typeof endpoint}`);
-        }
-        const { maxPages = 1000, perPage = 100, onProgress, delay = 50, } = options;
-        const startTime = Date.now();
-        const allData = [];
-        let page = 1;
-        let hasMore = true;
-        let totalCount = 0;
-        while (hasMore && page <= maxPages) {
-            const response = await this.httpClient.request({
-                method: 'GET',
-                endpoint,
-                params: {
-                    ...params,
-                    page,
-                    per_page: perPage,
-                },
-            });
-            if (response.data.data && Array.isArray(response.data.data)) {
-                allData.push(...response.data.data);
-            }
-            if (response.data.meta?.total_count) {
-                totalCount = Number(response.data.meta.total_count) || 0;
-            }
-            // Check if we have a next link and if it's different from current page
-            const nextLink = response.data.links?.next;
-            hasMore = !!nextLink;
-            // Additional safeguard: if we're getting the same page repeatedly, break the loop
-            if (hasMore && nextLink && nextLink.includes(`page=${page}`)) {
-                console.warn(`Pagination loop detected: next link points to same page ${page}. Breaking loop.`);
-                hasMore = false;
-            }
-            page++;
-            if (onProgress) {
-                onProgress(allData.length, totalCount || allData.length);
-            }
-            // Add delay between requests to respect rate limits
-            if (hasMore && delay > 0) {
-                await new Promise(resolve => setTimeout(resolve, delay));
-            }
-        }
-        return {
-            data: allData,
-            totalCount,
-            pagesFetched: page - 1,
-            duration: Date.now() - startTime,
-        };
-    }
-    async getPage(endpoint, page = 1, perPage = 100, params = {}) {
-        const response = await this.httpClient.request({
-            method: 'GET',
-            endpoint,
-            params: {
-                ...params,
-                page,
-                per_page: perPage,
-            },
-        });
-        return response.data;
-    }
-    async *streamPages(endpoint, params = {}, options = {}) {
-        const { maxPages = 1000, perPage = 100, delay = 50, } = options;
-        let page = 1;
-        let hasMore = true;
-        while (hasMore && page <= maxPages) {
-            const response = await this.httpClient.request({
-                method: 'GET',
-                endpoint,
-                params: {
-                    ...params,
-                    page,
-                    per_page: perPage,
-                },
-            });
-            if (response.data.data && Array.isArray(response.data.data)) {
-                yield response.data.data;
-            }
-            // Check if we have a next link and if it's different from current page
-            const nextLink = response.data.links?.next;
-            hasMore = !!nextLink;
-            // Additional safeguard: if we're getting the same page repeatedly, break the loop
-            if (hasMore && nextLink && nextLink.includes(`page=${page}`)) {
-                console.warn(`Pagination loop detected: next link points to same page ${page}. Breaking loop.`);
-                hasMore = false;
-            }
-            page++;
-            if (hasMore && delay > 0) {
-                await new Promise(resolve => setTimeout(resolve, delay));
-            }
-        }
-    }
-    /**
-     * Get all pages with parallel processing for better performance
-     */
-    async getAllPagesParallel(endpoint, params = {}, options = {}) {
-        const { maxPages = 1000, perPage = 100, maxConcurrency = 3, onProgress, } = options;
-        const startTime = Date.now();
-        // First, get the first page to determine total count
-        const firstPage = await this.getPage(endpoint, 1, perPage, params);
-        const totalCount = Number(firstPage.meta?.total_count) || 0;
-        const totalPages = Math.min(Math.ceil(totalCount / perPage), maxPages);
-        const allData = [...(firstPage.data || [])];
-        if (totalPages <= 1) {
-            return {
-                data: allData,
-                totalCount,
-                pagesFetched: 1,
-                duration: Date.now() - startTime,
-            };
-        }
-        // Process remaining pages in parallel batches
-        const remainingPages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
-        const semaphore = new Semaphore(maxConcurrency);
-        const pagePromises = remainingPages.map(async (pageNum) => {
-            await semaphore.acquire();
-            try {
-                const page = await this.getPage(endpoint, pageNum, perPage, params);
-                return page.data || [];
-            }
-            finally {
-                semaphore.release();
-            }
-        });
-        const pageResults = await Promise.all(pagePromises);
-        for (const pageData of pageResults) {
-            allData.push(...pageData);
-            if (onProgress) {
-                onProgress(allData.length, totalCount);
-            }
-        }
-        return {
-            data: allData,
-            totalCount,
-            pagesFetched: totalPages,
-            duration: Date.now() - startTime,
-        };
-    }
-}
-exports.PaginationHelper = PaginationHelper;
-/**
- * Semaphore for controlling concurrency
- */
-class Semaphore {
-    constructor(permits) {
-        this.waiting = [];
-        this.permits = permits;
-    }
-    async acquire() {
-        if (this.permits > 0) {
-            this.permits--;
-            return;
-        }
-        return new Promise(resolve => {
-            this.waiting.push(resolve);
-        });
-    }
-    release() {
-        this.permits++;
-        if (this.waiting.length > 0) {
-            const resolve = this.waiting.shift();
-            this.permits--;
-            resolve();
-        }
-    }
-}

package/dist/people/contacts.d.ts

@@ -1,43 +0,0 @@
-import { PcoClientState } from '../core';
-import type { ErrorContext } from '@rachelallyson/planning-center-base-ts';
-import { AddressAttributes, AddressesList, AddressSingle, EmailAttributes, EmailSingle, EmailsList, PhoneNumberAttributes, PhoneNumberSingle, PhoneNumbersList, SocialProfileAttributes, SocialProfileSingle, SocialProfilesList } from '../types';
-/**
- * Get all emails for a person
- */
-export declare function getPersonEmails(client: PcoClientState, personId: string, context?: Partial<ErrorContext>): Promise<EmailsList>;
-/**
- * Create an email for a person
- */
-export declare function createPersonEmail(client: PcoClientState, personId: string, data: Partial<EmailAttributes>, context?: Partial<ErrorContext>): Promise<EmailSingle>;
-/**
- * Get all phone numbers for a person
- */
-export declare function getPersonPhoneNumbers(client: PcoClientState, personId: string, context?: Partial<ErrorContext>): Promise<PhoneNumbersList>;
-/**
- * Create a phone number for a person
- */
-export declare function createPersonPhoneNumber(client: PcoClientState, personId: string, data: Partial<PhoneNumberAttributes>, context?: Partial<ErrorContext>): Promise<PhoneNumberSingle>;
-/**
- * Get all addresses for a person
- */
-export declare function getPersonAddresses(client: PcoClientState, personId: string, context?: Partial<ErrorContext>): Promise<AddressesList>;
-/**
- * Create an address for a person
- */
-export declare function createPersonAddress(client: PcoClientState, personId: string, data: Partial<AddressAttributes>, context?: Partial<ErrorContext>): Promise<AddressSingle>;
-/**
- * Update an address for a person
- */
-export declare function updatePersonAddress(client: PcoClientState, personId: string, addressId: string, data: Partial<AddressAttributes>, context?: Partial<ErrorContext>): Promise<AddressSingle>;
-/**
- * Get social profiles for a person
- */
-export declare function getPersonSocialProfiles(client: PcoClientState, personId: string, context?: Partial<ErrorContext>): Promise<SocialProfilesList>;
-/**
- * Create a social profile for a person
- */
-export declare function createPersonSocialProfile(client: PcoClientState, personId: string, data: Partial<SocialProfileAttributes>, context?: Partial<ErrorContext>): Promise<SocialProfileSingle>;
-/**
- * Delete a social profile
- */
-export declare function deleteSocialProfile(client: PcoClientState, socialProfileId: string, context?: Partial<ErrorContext>): Promise<void>;