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

package/dist/client-manager.d.ts

@@ -0,0 +1,66 @@
+/**
+ * v2.0.0 Client Manager with Caching
+ */
+import type { PcoClientConfig } from './types/client';
+import { PcoClient } from './client';
+export interface ClientConfigResolver {
+    (churchId: string): Promise<PcoClientConfig> | PcoClientConfig;
+}
+export declare class PcoClientManager {
+    private static instance;
+    private clientCache;
+    private configCache;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): PcoClientManager;
+    /**
+     * Get a client instance with the given configuration
+     */
+    static getClient(config: PcoClientConfig): PcoClient;
+    /**
+     * Get a client instance for a specific church with config resolution
+     */
+    static getClientForChurch(churchId: string, configResolver: ClientConfigResolver): Promise<PcoClient>;
+    /**
+     * Clear the client cache
+     */
+    static clearCache(): void;
+    /**
+     * Get a client instance with caching
+     */
+    getClient(config: PcoClientConfig): PcoClient;
+    /**
+     * Get a client instance for a specific church
+     */
+    getClientForChurch(churchId: string, configResolver: ClientConfigResolver): Promise<PcoClient>;
+    /**
+     * Clear the client cache
+     */
+    clearCache(): void;
+    /**
+     * Remove a specific client from cache
+     */
+    removeClient(config: PcoClientConfig): void;
+    /**
+     * Remove a church client from cache
+     */
+    removeChurchClient(churchId: string): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        clientCount: number;
+        configCount: number;
+        churchClients: number;
+    };
+    /**
+     * Generate a cache key for a configuration
+     */
+    private generateConfigKey;
+    /**
+     * Check if configuration has changed
+     */
+    private hasConfigChanged;
+}

package/dist/client-manager.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * v2.0.0 Client Manager with Caching
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PcoClientManager = void 0;
+const client_1 = require("./client");
+class PcoClientManager {
+    constructor() {
+        this.clientCache = new Map();
+        this.configCache = new Map();
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!PcoClientManager.instance) {
+            PcoClientManager.instance = new PcoClientManager();
+        }
+        return PcoClientManager.instance;
+    }
+    /**
+     * Get a client instance with the given configuration
+     */
+    static getClient(config) {
+        return PcoClientManager.getInstance().getClient(config);
+    }
+    /**
+     * Get a client instance for a specific church with config resolution
+     */
+    static async getClientForChurch(churchId, configResolver) {
+        return PcoClientManager.getInstance().getClientForChurch(churchId, configResolver);
+    }
+    /**
+     * Clear the client cache
+     */
+    static clearCache() {
+        PcoClientManager.getInstance().clearCache();
+    }
+    /**
+     * Get a client instance with caching
+     */
+    getClient(config) {
+        const configKey = this.generateConfigKey(config);
+        // Check if we have a cached client
+        let client = this.clientCache.get(configKey);
+        if (!client) {
+            // Create new client
+            client = new client_1.PcoClient(config);
+            this.clientCache.set(configKey, client);
+            this.configCache.set(configKey, { ...config });
+        }
+        else {
+            // Check if config has changed
+            const cachedConfig = this.configCache.get(configKey);
+            if (cachedConfig && this.hasConfigChanged(cachedConfig, config)) {
+                // Update client with new config
+                client.updateConfig(config);
+                this.configCache.set(configKey, { ...config });
+            }
+        }
+        return client;
+    }
+    /**
+     * Get a client instance for a specific church
+     */
+    async getClientForChurch(churchId, configResolver) {
+        const configKey = `church:${churchId}`;
+        // Check if we have a cached client
+        let client = this.clientCache.get(configKey);
+        if (!client) {
+            // Resolve configuration
+            const config = await configResolver(churchId);
+            // Create new client
+            client = new client_1.PcoClient(config);
+            this.clientCache.set(configKey, client);
+            this.configCache.set(configKey, { ...config });
+        }
+        return client;
+    }
+    /**
+     * Clear the client cache
+     */
+    clearCache() {
+        this.clientCache.clear();
+        this.configCache.clear();
+    }
+    /**
+     * Remove a specific client from cache
+     */
+    removeClient(config) {
+        const configKey = this.generateConfigKey(config);
+        this.clientCache.delete(configKey);
+        this.configCache.delete(configKey);
+    }
+    /**
+     * Remove a church client from cache
+     */
+    removeChurchClient(churchId) {
+        const configKey = `church:${churchId}`;
+        this.clientCache.delete(configKey);
+        this.configCache.delete(configKey);
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        const churchClients = Array.from(this.clientCache.keys()).filter(key => key.startsWith('church:')).length;
+        return {
+            clientCount: this.clientCache.size,
+            configCount: this.configCache.size,
+            churchClients,
+        };
+    }
+    /**
+     * Generate a cache key for a configuration
+     */
+    generateConfigKey(config) {
+        // Create a hash of the configuration
+        const configStr = JSON.stringify({
+            authType: config.auth.type,
+            hasAccessToken: config.auth.type === 'oauth' ? !!config.auth.accessToken : false,
+            hasRefreshToken: config.auth.type === 'oauth' ? !!config.auth.refreshToken : false,
+            hasPersonalAccessToken: config.auth.type === 'personal_access_token' ? !!config.auth.personalAccessToken : false,
+            baseURL: config.baseURL,
+            timeout: config.timeout,
+        });
+        // Simple hash function
+        let hash = 0;
+        for (let i = 0; i < configStr.length; i++) {
+            const char = configStr.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return `config:${Math.abs(hash)}`;
+    }
+    /**
+     * Check if configuration has changed
+     */
+    hasConfigChanged(oldConfig, newConfig) {
+        // Compare key configuration properties
+        if (oldConfig.auth.type !== newConfig.auth.type) {
+            return true;
+        }
+        if (oldConfig.auth.type === 'oauth' && newConfig.auth.type === 'oauth') {
+            return (oldConfig.auth.accessToken !== newConfig.auth.accessToken ||
+                oldConfig.auth.refreshToken !== newConfig.auth.refreshToken);
+        }
+        if (oldConfig.auth.type === 'personal_access_token' && newConfig.auth.type === 'personal_access_token') {
+            return oldConfig.auth.personalAccessToken !== newConfig.auth.personalAccessToken;
+        }
+        return (oldConfig.baseURL !== newConfig.baseURL ||
+            oldConfig.timeout !== newConfig.timeout);
+    }
+}
+exports.PcoClientManager = PcoClientManager;

package/dist/client.d.ts

@@ -0,0 +1,71 @@
+/**
+ * v2.0.0 Main PcoClient Class
+ */
+import type { PcoClientConfig } from './types/client';
+import type { EventEmitter } from './types/events';
+import { PeopleModule } from './modules/people';
+import { FieldsModule } from './modules/fields';
+import { WorkflowsModule } from './modules/workflows';
+import { ContactsModule } from './modules/contacts';
+import { HouseholdsModule } from './modules/households';
+import { NotesModule } from './modules/notes';
+import { ListsModule } from './modules/lists';
+import { BatchExecutor } from './batch';
+export declare class PcoClient implements EventEmitter {
+    people: PeopleModule;
+    fields: FieldsModule;
+    workflows: WorkflowsModule;
+    contacts: ContactsModule;
+    households: HouseholdsModule;
+    notes: NotesModule;
+    lists: ListsModule;
+    batch: BatchExecutor;
+    private httpClient;
+    private paginationHelper;
+    private eventEmitter;
+    private config;
+    constructor(config: PcoClientConfig);
+    on<T extends import('./types/events').PcoEvent>(eventType: T['type'], handler: import('./types/events').EventHandler<T>): void;
+    off<T extends import('./types/events').PcoEvent>(eventType: T['type'], handler: import('./types/events').EventHandler<T>): void;
+    emit<T extends import('./types/events').PcoEvent>(event: T): void;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): PcoClientConfig;
+    /**
+     * Update the configuration
+     */
+    updateConfig(updates: Partial<PcoClientConfig>): void;
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics(): Record<string, {
+        count: number;
+        averageTime: number;
+        minTime: number;
+        maxTime: number;
+        errorRate: number;
+    }>;
+    /**
+     * Get rate limit information
+     */
+    getRateLimitInfo(): Record<string, {
+        limit: number;
+        remaining: number;
+        resetTime: number;
+    }>;
+    /**
+     * Clear all event listeners
+     */
+    removeAllListeners(eventType?: import('./types/events').EventType): void;
+    /**
+     * Get the number of listeners for an event type
+     */
+    listenerCount(eventType: import('./types/events').EventType): number;
+    /**
+     * Get all registered event types
+     */
+    eventTypes(): import('./types/events').EventType[];
+    private setupEventHandlers;
+    private updateModules;
+}

package/dist/client.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * v2.0.0 Main PcoClient Class
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PcoClient = void 0;
+const monitoring_1 = require("./monitoring");
+const http_1 = require("./core/http");
+const pagination_1 = require("./core/pagination");
+const people_1 = require("./modules/people");
+const fields_1 = require("./modules/fields");
+const workflows_1 = require("./modules/workflows");
+const contacts_1 = require("./modules/contacts");
+const households_1 = require("./modules/households");
+const notes_1 = require("./modules/notes");
+const lists_1 = require("./modules/lists");
+const batch_1 = require("./batch");
+class PcoClient {
+    constructor(config) {
+        this.config = config;
+        this.eventEmitter = new monitoring_1.PcoEventEmitter();
+        this.httpClient = new http_1.PcoHttpClient(config, this.eventEmitter);
+        this.paginationHelper = new pagination_1.PaginationHelper(this.httpClient);
+        // Initialize modules
+        this.people = new people_1.PeopleModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.fields = new fields_1.FieldsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.workflows = new workflows_1.WorkflowsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.contacts = new contacts_1.ContactsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.households = new households_1.HouseholdsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.notes = new notes_1.NotesModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.lists = new lists_1.ListsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.batch = new batch_1.BatchExecutor(this, this.eventEmitter);
+        // Set up event handlers from config
+        this.setupEventHandlers();
+    }
+    // EventEmitter implementation
+    on(eventType, handler) {
+        this.eventEmitter.on(eventType, handler);
+    }
+    off(eventType, handler) {
+        this.eventEmitter.off(eventType, handler);
+    }
+    emit(event) {
+        this.eventEmitter.emit(event);
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update the configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        // Recreate HTTP client with new config
+        this.httpClient = new http_1.PcoHttpClient(this.config, this.eventEmitter);
+        this.paginationHelper = new pagination_1.PaginationHelper(this.httpClient);
+        // Update modules with new HTTP client
+        this.updateModules();
+    }
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics() {
+        return this.httpClient.getPerformanceMetrics();
+    }
+    /**
+     * Get rate limit information
+     */
+    getRateLimitInfo() {
+        return this.httpClient.getRateLimitInfo();
+    }
+    /**
+     * Clear all event listeners
+     */
+    removeAllListeners(eventType) {
+        this.eventEmitter.removeAllListeners(eventType);
+    }
+    /**
+     * Get the number of listeners for an event type
+     */
+    listenerCount(eventType) {
+        return this.eventEmitter.listenerCount(eventType);
+    }
+    /**
+     * Get all registered event types
+     */
+    eventTypes() {
+        return this.eventEmitter.eventTypes();
+    }
+    setupEventHandlers() {
+        // Set up config event handlers
+        if (this.config.events?.onError) {
+            this.on('error', this.config.events.onError);
+        }
+        if (this.config.events?.onAuthFailure) {
+            this.on('auth:failure', this.config.events.onAuthFailure);
+        }
+        if (this.config.events?.onRequestStart) {
+            this.on('request:start', this.config.events.onRequestStart);
+        }
+        if (this.config.events?.onRequestComplete) {
+            this.on('request:complete', this.config.events.onRequestComplete);
+        }
+        if (this.config.events?.onRateLimit) {
+            this.on('rate:limit', this.config.events.onRateLimit);
+        }
+    }
+    updateModules() {
+        // Recreate modules with new HTTP client
+        this.people = new people_1.PeopleModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.fields = new fields_1.FieldsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.workflows = new workflows_1.WorkflowsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.contacts = new contacts_1.ContactsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.households = new households_1.HouseholdsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.notes = new notes_1.NotesModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.lists = new lists_1.ListsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
+        this.batch = new batch_1.BatchExecutor(this, this.eventEmitter);
+    }
+}
+exports.PcoClient = PcoClient;

package/dist/core/http.d.ts

@@ -0,0 +1,48 @@
+/**
+ * v2.0.0 HTTP Client
+ */
+import type { PcoClientConfig } from '../types/client';
+import { PcoEventEmitter } from '../monitoring';
+export interface HttpRequestOptions {
+    method: string;
+    endpoint: string;
+    data?: any;
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+    requestId: string;
+    duration: number;
+}
+export declare class PcoHttpClient {
+    private config;
+    private eventEmitter;
+    private requestIdGenerator;
+    private performanceMetrics;
+    private rateLimitTracker;
+    private rateLimiter;
+    constructor(config: PcoClientConfig, eventEmitter: PcoEventEmitter);
+    request<T = any>(options: HttpRequestOptions): Promise<HttpResponse<T>>;
+    private makeRequest;
+    private addAuthentication;
+    private getResourceTypeFromEndpoint;
+    private extractHeaders;
+    private attemptTokenRefresh;
+    private updateRateLimitTracking;
+    getPerformanceMetrics(): Record<string, {
+        count: number;
+        averageTime: number;
+        minTime: number;
+        maxTime: number;
+        errorRate: number;
+    }>;
+    getRateLimitInfo(): Record<string, {
+        limit: number;
+        remaining: number;
+        resetTime: number;
+    }>;
+}