@rachelallyson/planning-center-people-ts 2.7.0 → 2.9.0

package/dist/modules/base.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,82 +0,0 @@
-"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/monitoring.d.ts

@@ -1,53 +0,0 @@
-/**
- * v2.0.0 Event System and Monitoring
- */
-import type { PcoEvent, EventHandler, EventType, EventEmitter } from './types/events';
-export declare class PcoEventEmitter implements EventEmitter {
-    private handlers;
-    on<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
-    off<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
-    emit<T extends PcoEvent>(event: T): void;
-    /** Remove all event handlers */
-    removeAllListeners(eventType?: EventType): void;
-    /** Get the number of listeners for an event type */
-    listenerCount(eventType: EventType): number;
-    /** Get all registered event types */
-    eventTypes(): EventType[];
-}
-/**
- * Request ID generator for tracking requests
- */
-export declare class RequestIdGenerator {
-    private counter;
-    generate(): string;
-}
-/**
- * Performance metrics collector
- */
-export declare class PerformanceMetrics {
-    private metrics;
-    record(operation: string, duration: number, success?: boolean): void;
-    getMetrics(): Record<string, {
-        count: number;
-        averageTime: number;
-        minTime: number;
-        maxTime: number;
-        errorRate: number;
-    }>;
-    reset(): void;
-}
-/**
- * Rate limit tracker
- */
-export declare class RateLimitTracker {
-    private limits;
-    update(endpoint: string, limit: number, remaining: number, resetTime: number): void;
-    getRemaining(endpoint: string): number;
-    getResetTime(endpoint: string): number;
-    isRateLimited(endpoint: string): boolean;
-    getAllLimits(): Record<string, {
-        limit: number;
-        remaining: number;
-        resetTime: number;
-    }>;
-}

package/dist/monitoring.js

@@ -1,142 +0,0 @@
-"use strict";
-/**
- * v2.0.0 Event System and Monitoring
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimitTracker = exports.PerformanceMetrics = exports.RequestIdGenerator = exports.PcoEventEmitter = void 0;
-class PcoEventEmitter {
-    constructor() {
-        this.handlers = new Map();
-    }
-    on(eventType, handler) {
-        if (!this.handlers.has(eventType)) {
-            this.handlers.set(eventType, new Set());
-        }
-        this.handlers.get(eventType).add(handler);
-    }
-    off(eventType, handler) {
-        const eventHandlers = this.handlers.get(eventType);
-        if (eventHandlers) {
-            eventHandlers.delete(handler);
-            if (eventHandlers.size === 0) {
-                this.handlers.delete(eventType);
-            }
-        }
-    }
-    emit(event) {
-        const eventHandlers = this.handlers.get(event.type);
-        if (eventHandlers) {
-            for (const handler of eventHandlers) {
-                try {
-                    handler(event);
-                }
-                catch (error) {
-                    console.error(`Error in event handler for ${event.type}:`, error);
-                }
-            }
-        }
-    }
-    /** Remove all event handlers */
-    removeAllListeners(eventType) {
-        if (eventType) {
-            this.handlers.delete(eventType);
-        }
-        else {
-            this.handlers.clear();
-        }
-    }
-    /** Get the number of listeners for an event type */
-    listenerCount(eventType) {
-        return this.handlers.get(eventType)?.size || 0;
-    }
-    /** Get all registered event types */
-    eventTypes() {
-        return Array.from(this.handlers.keys());
-    }
-}
-exports.PcoEventEmitter = PcoEventEmitter;
-/**
- * Request ID generator for tracking requests
- */
-class RequestIdGenerator {
-    constructor() {
-        this.counter = 0;
-    }
-    generate() {
-        return `req_${Date.now()}_${++this.counter}`;
-    }
-}
-exports.RequestIdGenerator = RequestIdGenerator;
-/**
- * Performance metrics collector
- */
-class PerformanceMetrics {
-    constructor() {
-        this.metrics = new Map();
-    }
-    record(operation, duration, success = true) {
-        const existing = this.metrics.get(operation) || {
-            count: 0,
-            totalTime: 0,
-            minTime: Infinity,
-            maxTime: 0,
-            errors: 0,
-        };
-        existing.count++;
-        existing.totalTime += duration;
-        existing.minTime = Math.min(existing.minTime, duration);
-        existing.maxTime = Math.max(existing.maxTime, duration);
-        if (!success) {
-            existing.errors++;
-        }
-        this.metrics.set(operation, existing);
-    }
-    getMetrics() {
-        const result = {};
-        for (const [operation, metrics] of this.metrics) {
-            result[operation] = {
-                count: metrics.count,
-                averageTime: metrics.totalTime / metrics.count,
-                minTime: metrics.minTime === Infinity ? 0 : metrics.minTime,
-                maxTime: metrics.maxTime,
-                errorRate: metrics.errors / metrics.count,
-            };
-        }
-        return result;
-    }
-    reset() {
-        this.metrics.clear();
-    }
-}
-exports.PerformanceMetrics = PerformanceMetrics;
-/**
- * Rate limit tracker
- */
-class RateLimitTracker {
-    constructor() {
-        this.limits = new Map();
-    }
-    update(endpoint, limit, remaining, resetTime) {
-        this.limits.set(endpoint, { limit, remaining, resetTime });
-    }
-    getRemaining(endpoint) {
-        const limit = this.limits.get(endpoint);
-        return limit?.remaining || 0;
-    }
-    getResetTime(endpoint) {
-        const limit = this.limits.get(endpoint);
-        return limit?.resetTime || 0;
-    }
-    isRateLimited(endpoint) {
-        const limit = this.limits.get(endpoint);
-        return limit ? limit.remaining <= 0 : false;
-    }
-    getAllLimits() {
-        const result = {};
-        for (const [endpoint, limit] of this.limits) {
-            result[endpoint] = limit;
-        }
-        return result;
-    }
-}
-exports.RateLimitTracker = RateLimitTracker;

package/dist/rate-limiter.d.ts

@@ -1,79 +0,0 @@
-/**
- * PCO Rate Limiter
- *
- * Planning Center Online has the following rate limits:
- * - 100 requests per 20 seconds (subject to change)
- * - Rate limit headers are returned on every response
- * - 429 responses include Retry-After header
- * - Limits and time periods can change dynamically
- *
- * This rate limiter tracks requests and enforces these limits.
- */
-export interface RateLimitInfo {
-    limit: number;
-    remaining: number;
-    resetTime: number;
-    retryAfter?: number;
-}
-export interface RateLimitHeaders {
-    'X-PCO-API-Request-Rate-Limit'?: string;
-    'X-PCO-API-Request-Rate-Period'?: string;
-    'X-PCO-API-Request-Rate-Count'?: string;
-    'Retry-After'?: string;
-}
-export declare class PcoRateLimiter {
-    private requestCount;
-    private windowStart;
-    private readonly defaultLimit;
-    private readonly defaultWindow;
-    private limit;
-    private windowMs;
-    constructor(limit?: number, windowMs?: number);
-    /**
-     * Check if a request can be made
-     */
-    canMakeRequest(): boolean;
-    /**
-     * Record a request
-     */
-    recordRequest(): void;
-    /**
-     * Get time until next window reset
-     */
-    getTimeUntilReset(): number;
-    /**
-     * Get current rate limit info
-     */
-    getRateLimitInfo(): RateLimitInfo;
-    /**
-     * Update rate limit info from response headers
-     */
-    updateFromHeaders(headers: RateLimitHeaders): void;
-    /**
-     * Wait until a request can be made
-     */
-    waitForAvailability(): Promise<void>;
-    /**
-     * Update the sliding window
-     */
-    private updateWindow;
-    /**
-     * Parse rate limit error details from 429 response
-     */
-    static parseRateLimitError(errorDetail: string): {
-        current: number;
-        limit: number;
-        period: number;
-    } | null;
-    /**
-     * Get debug information
-     */
-    getDebugInfo(): {
-        canMakeRequest: boolean;
-        limit: number;
-        requestCount: number;
-        timeUntilReset: number;
-        windowMs: number;
-        windowStart: number;
-    };
-}

package/dist/rate-limiter.js

@@ -1,137 +0,0 @@
-"use strict";
-/**
- * PCO Rate Limiter
- *
- * Planning Center Online has the following rate limits:
- * - 100 requests per 20 seconds (subject to change)
- * - Rate limit headers are returned on every response
- * - 429 responses include Retry-After header
- * - Limits and time periods can change dynamically
- *
- * This rate limiter tracks requests and enforces these limits.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PcoRateLimiter = void 0;
-class PcoRateLimiter {
-    constructor(limit, windowMs) {
-        this.requestCount = 0;
-        this.windowStart = Date.now();
-        this.defaultLimit = 100; // requests per 20 seconds
-        this.defaultWindow = 20000; // 20 seconds in milliseconds
-        this.limit = limit || this.defaultLimit;
-        this.windowMs = windowMs || this.defaultWindow;
-    }
-    /**
-     * Check if a request can be made
-     */
-    canMakeRequest() {
-        this.updateWindow();
-        return this.requestCount < this.limit;
-    }
-    /**
-     * Record a request
-     */
-    recordRequest() {
-        this.updateWindow();
-        this.requestCount++;
-    }
-    /**
-     * Get time until next window reset
-     */
-    getTimeUntilReset() {
-        this.updateWindow();
-        const now = Date.now();
-        return Math.max(0, this.windowStart + this.windowMs - now);
-    }
-    /**
-     * Get current rate limit info
-     */
-    getRateLimitInfo() {
-        this.updateWindow();
-        return {
-            limit: this.limit,
-            remaining: Math.max(0, this.limit - this.requestCount),
-            resetTime: this.windowStart + this.windowMs,
-        };
-    }
-    /**
-     * Update rate limit info from response headers
-     */
-    updateFromHeaders(headers) {
-        if (headers['X-PCO-API-Request-Rate-Limit']) {
-            this.limit = parseInt(headers['X-PCO-API-Request-Rate-Limit'], 10);
-        }
-        if (headers['X-PCO-API-Request-Rate-Period']) {
-            // Update window period from server (in seconds, convert to milliseconds)
-            const periodSeconds = parseInt(headers['X-PCO-API-Request-Rate-Period'], 10);
-            if (!isNaN(periodSeconds)) {
-                this.windowMs = periodSeconds * 1000;
-            }
-        }
-        if (headers['X-PCO-API-Request-Rate-Count']) {
-            this.requestCount = parseInt(headers['X-PCO-API-Request-Rate-Count'], 10);
-        }
-        if (headers['Retry-After']) {
-            const retryAfter = parseInt(headers['Retry-After'], 10);
-            if (!isNaN(retryAfter)) {
-                // If we get a retry-after, it means we hit the limit
-                // Reset the window to start after the retry period
-                this.windowStart = Date.now() + retryAfter * 1000;
-                this.requestCount = 0;
-            }
-        }
-    }
-    /**
-     * Wait until a request can be made
-     */
-    async waitForAvailability() {
-        if (this.canMakeRequest()) {
-            return;
-        }
-        const waitTime = this.getTimeUntilReset();
-        if (waitTime > 0) {
-            await new Promise(resolve => setTimeout(resolve, waitTime));
-        }
-    }
-    /**
-     * Update the sliding window
-     */
-    updateWindow() {
-        const now = Date.now();
-        const windowEnd = this.windowStart + this.windowMs;
-        if (now >= windowEnd) {
-            // Reset the window
-            this.windowStart = now;
-            this.requestCount = 0;
-        }
-    }
-    /**
-     * Parse rate limit error details from 429 response
-     */
-    static parseRateLimitError(errorDetail) {
-        // Parse error like "Rate limit exceeded: 118 of 100 requests per 20 seconds"
-        const match = errorDetail.match(/Rate limit exceeded: (\d+) of (\d+) requests per (\d+) seconds/);
-        if (match) {
-            return {
-                current: parseInt(match[1], 10),
-                limit: parseInt(match[2], 10),
-                period: parseInt(match[3], 10)
-            };
-        }
-        return null;
-    }
-    /**
-     * Get debug information
-     */
-    getDebugInfo() {
-        return {
-            canMakeRequest: this.canMakeRequest(),
-            limit: this.limit,
-            requestCount: this.requestCount,
-            timeUntilReset: this.getTimeUntilReset(),
-            windowMs: this.windowMs,
-            windowStart: this.windowStart,
-        };
-    }
-}
-exports.PcoRateLimiter = PcoRateLimiter;

package/dist/types/batch.d.ts

@@ -1,50 +0,0 @@
-/**
- * v2.0.0 Batch Operations Types
- */
-export interface BatchOperation {
-    type: string;
-    data?: any;
-    dependencies?: string[];
-    [key: string]: any;
-}
-export interface BatchResult<T = any> {
-    index: number;
-    operation: BatchOperation;
-    success: boolean;
-    data?: T;
-    error?: Error;
-}
-export interface BatchOptions {
-    /** Continue processing other operations if one fails */
-    continueOnError?: boolean;
-    /** Maximum number of operations to run in parallel */
-    maxConcurrency?: number;
-    /** Enable automatic rollback on failure */
-    enableRollback?: boolean;
-    /** Callback for each completed operation */
-    onOperationComplete?: (result: BatchResult) => void;
-    /** Callback for batch completion */
-    onBatchComplete?: (results: BatchResult[]) => void;
-}
-export interface BatchSummary {
-    total: number;
-    successful: number;
-    failed: number;
-    successRate: number;
-    duration: number;
-    results: BatchResult[];
-}
-export interface OperationReference {
-    /** Reference to a previous operation result using $index.path syntax */
-    reference: string;
-    /** The operation index being referenced */
-    index: number;
-    /** The path within the result object */
-    path: string;
-}
-export interface ResolvedBatchOperation extends BatchOperation {
-    /** Resolved data with references replaced */
-    resolvedData?: any;
-    /** Dependencies on other operations */
-    dependencies?: string[];
-}

package/dist/types/batch.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * v2.0.0 Batch Operations Types
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/events.d.ts

@@ -1,85 +0,0 @@
-/**
- * v2.0.0 Event System Types
- */
-export type EventType = 'request:start' | 'request:complete' | 'request:error' | 'auth:success' | 'auth:failure' | 'auth:refresh' | 'rate:limit' | 'rate:available' | 'cache:hit' | 'cache:miss' | 'cache:set' | 'cache:invalidate' | 'error';
-export interface BaseEvent {
-    type: EventType;
-    timestamp: string;
-    requestId?: string;
-}
-export interface RequestStartEvent extends BaseEvent {
-    type: 'request:start';
-    endpoint: string;
-    method: string;
-    requestId: string;
-}
-export interface RequestCompleteEvent extends BaseEvent {
-    type: 'request:complete';
-    endpoint: string;
-    method: string;
-    status: number;
-    duration: number;
-    requestId: string;
-}
-export interface RequestErrorEvent extends BaseEvent {
-    type: 'request:error';
-    endpoint: string;
-    method: string;
-    error: Error;
-    requestId: string;
-}
-export interface AuthSuccessEvent extends BaseEvent {
-    type: 'auth:success';
-    authType: 'oauth' | 'basic';
-}
-export interface AuthFailureEvent extends BaseEvent {
-    type: 'auth:failure';
-    authType: 'oauth' | 'basic';
-    error: Error;
-}
-export interface AuthRefreshEvent extends BaseEvent {
-    type: 'auth:refresh';
-    authType: 'oauth';
-    success: boolean;
-}
-export interface RateLimitEvent extends BaseEvent {
-    type: 'rate:limit';
-    limit: number;
-    remaining: number;
-    resetTime: string;
-}
-export interface RateAvailableEvent extends BaseEvent {
-    type: 'rate:available';
-    limit: number;
-    remaining: number;
-}
-export interface CacheHitEvent extends BaseEvent {
-    type: 'cache:hit';
-    key: string;
-}
-export interface CacheMissEvent extends BaseEvent {
-    type: 'cache:miss';
-    key: string;
-}
-export interface CacheSetEvent extends BaseEvent {
-    type: 'cache:set';
-    key: string;
-    ttl?: number;
-}
-export interface CacheInvalidateEvent extends BaseEvent {
-    type: 'cache:invalidate';
-    key: string;
-}
-export interface ErrorEvent extends BaseEvent {
-    type: 'error';
-    error: Error;
-    operation: string;
-    context?: Record<string, any>;
-}
-export type PcoEvent = RequestStartEvent | RequestCompleteEvent | RequestErrorEvent | AuthSuccessEvent | AuthFailureEvent | AuthRefreshEvent | RateLimitEvent | RateAvailableEvent | CacheHitEvent | CacheMissEvent | CacheSetEvent | CacheInvalidateEvent | ErrorEvent;
-export type EventHandler<T extends PcoEvent = PcoEvent> = (event: T) => void | Promise<void>;
-export interface EventEmitter {
-    on<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
-    off<T extends PcoEvent>(eventType: T['type'], handler: EventHandler<T>): void;
-    emit<T extends PcoEvent>(event: T): void;
-}

package/dist/types/events.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * v2.0.0 Event System Types
- */
-Object.defineProperty(exports, "__esModule", { value: true });