@rachelallyson/planning-center-people-ts 2.12.0 → 2.12.2

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.12.2] - 2026-01-20
+
+### ✨ **New Features**
+
+- **Direct Personal Access Token Configuration**: Added support for passing `personalAccessTokenSecret` directly in config (alternative to environment variables)
+- **Flexible Authentication**: Choose between environment variables or direct config based on your needs
+
+## [2.12.1] - 2026-01-20
+
+### ✨ **New Features**
+
+- **Duplicate Prevention Integration Tests**: Added comprehensive integration tests for duplicate person prevention
+  - `duplicate-prevention-comprehensive.integration.test.ts` - Tests the bug scenario where PCO contact verification delays cause duplicates
+  - `duplicate-prevention-retry-exhaustion.integration.test.ts` - Tests retry logic when contact verification takes too long
+  - Enhanced test coverage for the retry logic that prevents duplicate person creation
+
 ## [2.12.0] - 2026-01-14
 
 ### ✨ **New Features**

package/dist/client-manager.js

@@ -151,6 +151,10 @@ class PcoClientManager {
         if (oldConfig.auth.type === 'personal_access_token' && newConfig.auth.type === 'personal_access_token') {
             return oldConfig.auth.personalAccessToken !== newConfig.auth.personalAccessToken;
         }
+        if (oldConfig.auth.type === 'basic' && newConfig.auth.type === 'basic') {
+            return (oldConfig.auth.appId !== newConfig.auth.appId ||
+                oldConfig.auth.appSecret !== newConfig.auth.appSecret);
+        }
         return (oldConfig.baseURL !== newConfig.baseURL ||
             oldConfig.timeout !== newConfig.timeout);
     }

package/dist/client.d.ts

@@ -74,6 +74,5 @@ export declare class PcoClient implements EventEmitter {
      * Get all registered event types
      */
     eventTypes(): EventType[];
-    private setupEventHandlers;
     private updateModules;
 }

package/dist/client.js

@@ -36,7 +36,6 @@ class PcoClient {
         this.reports = new reports_1.ReportsModule(this.httpClient, this.paginationHelper, this.eventEmitter);
         this.batch = new planning_center_base_ts_1.BatchExecutor(this, this.eventEmitter);
         // Set up event handlers from config
-        this.setupEventHandlers();
     }
     // EventEmitter implementation
     on(eventType, handler) {
@@ -95,24 +94,6 @@ class PcoClient {
     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);

package/dist/core/http.d.ts

@@ -49,4 +49,8 @@ export declare class PcoHttpClient {
      * Get authentication header for external services (like file uploads)
      */
     getAuthHeader(): string;
+    /**
+     * Make HTTPS request using Node.js HTTPS module (fallback when fetch is unavailable)
+     */
+    private makeHttpsRequest;
 }

package/dist/core/http.js

@@ -152,7 +152,7 @@ class PcoHttpClient {
                     catch (refreshError) {
                         console.warn('Token refresh failed:', refreshError);
                         // Call the onRefreshFailure callback
-                        await this.config.auth.onRefreshFailure(refreshError);
+                        await this.config.auth.onRefreshFailure?.(refreshError);
                         throw refreshError;
                     }
                 }
@@ -195,9 +195,20 @@ class PcoHttpClient {
     }
     addAuthentication(headers) {
         if (this.config.auth.type === 'personal_access_token') {
-            // Personal Access Tokens use HTTP Basic Auth format: app_id:secret
-            // The personalAccessToken should be in the format "app_id:secret"
-            headers.Authorization = `Basic ${Buffer.from(this.config.auth.personalAccessToken).toString('base64')}`;
+            // 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}`;
@@ -243,11 +254,11 @@ class PcoHttpClient {
         // Prepare the request body for token refresh
         const body = new URLSearchParams({
             grant_type: 'refresh_token',
-            refresh_token: this.config.auth.refreshToken,
+            refresh_token: this.config.auth.refreshToken || '',
         });
         // Add client credentials if available from the config or environment
-        const clientId = this.config.auth.clientId || process.env.PCO_APP_ID;
-        const clientSecret = this.config.auth.clientSecret || process.env.PCO_APP_SECRET;
+        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);
@@ -268,10 +279,10 @@ class PcoHttpClient {
         // 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 with the expected format
-        await this.config.auth.onRefresh({
+        // Call the onRefresh callback
+        await this.config.auth.onRefresh?.({
             accessToken: tokens.access_token,
-            refreshToken: tokens.refresh_token || this.config.auth.refreshToken,
+            refreshToken: tokens.refresh_token || this.config.auth.refreshToken
         });
     }
     updateRateLimitTracking(endpoint, headers) {
@@ -292,13 +303,58 @@ class PcoHttpClient {
      * 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') {
-            return `Basic ${Buffer.from(this.config.auth.personalAccessToken).toString('base64')}`;
+            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.d.ts

@@ -3,8 +3,10 @@ import { PcoRateLimiter } from '@rachelallyson/planning-center-base-ts';
 import { Paginated, ResourceObject, Response as JsonApiResponse } from './types';
 import { type TokenRefreshCallback, type TokenRefreshFailureCallback } from './auth';
 export interface PcoClientConfig {
-    /** Personal Access Token (for single-user apps) */
+    /** Personal Access Token Client ID (for single-user apps) */
     personalAccessToken?: string;
+    /** Personal Access Token Client Secret (alternative to PCO_PERSONAL_ACCESS_SECRET env var) */
+    personalAccessTokenSecret?: string;
     /** OAuth 2.0 Access Token (for multi-user apps) */
     accessToken?: string;
     /** OAuth 2.0 Refresh Token (for multi-user apps) */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rachelallyson/planning-center-people-ts",
-    "version": "2.12.0",
+    "version": "2.12.2",
     "description": "A strictly typed TypeScript client for Planning Center Online People API with comprehensive functionality and enhanced developer experience",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",