@rachelallyson/planning-center-people-ts 2.12.1 → 2.13.0

package/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.13.0] - 2026-01-20
+
+### ✨ **New Features**
+
+- **🎯 Lenient Age Preference Filtering**: Added `agePreferenceLenient` option for flexible age-based filtering
+  - When `agePreferenceLenient: true`, age preferences only filter profiles that have birthdates
+  - Profiles without birthdates are included regardless of `agePreference` setting
+  - Prevents false negatives when searching for existing people with incomplete age data
+  - Backward compatible - default behavior remains strict filtering (only `agePreference: 'any'` includes profiles without birthdates)
+
+## [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**

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/dist/helpers.d.ts

@@ -35,6 +35,7 @@ export declare function matchesAgeCriteria(birthdate: string | undefined, criter
     minAge?: number;
     maxAge?: number;
     birthYear?: number;
+    agePreferenceLenient?: boolean;
 }): boolean;
 /**
  * Calculate birth year from age

package/dist/helpers.js

@@ -103,8 +103,13 @@ function isChild(birthdate) {
  */
 function matchesAgeCriteria(birthdate, criteria) {
     const age = calculateAgeSafe(birthdate);
-    // If no birthdate, only match if preference is 'any'
+    // If no birthdate, match based on lenient setting
     if (age === null) {
+        if (criteria.agePreferenceLenient) {
+            // Lenient mode: include profiles without birthdates regardless of agePreference
+            return true;
+        }
+        // Strict mode (default): only match if preference is 'any'
         return criteria.agePreference === 'any' || criteria.agePreference === undefined;
     }
     // Check age preference

package/dist/matching/matcher.js

@@ -377,7 +377,8 @@ class PersonMatcher {
                 agePreference: options.agePreference,
                 minAge: options.minAge,
                 maxAge: options.maxAge,
-                birthYear: options.birthYear
+                birthYear: options.birthYear,
+                agePreferenceLenient: options.agePreferenceLenient
             });
         });
     }

package/dist/matching/scoring.js

@@ -164,7 +164,8 @@ class MatchScorer {
             agePreference: options.agePreference,
             minAge: options.minAge,
             maxAge: options.maxAge,
-            birthYear: options.birthYear
+            birthYear: options.birthYear,
+            agePreferenceLenient: options.agePreferenceLenient
         });
         if (!matches) {
             return 0; // No match

package/dist/modules/people.d.ts

@@ -70,6 +70,12 @@ export interface PersonMatchOptions {
     addMissingContactInfo?: boolean;
     /** Age preference filter: 'adults' (18+), 'children' (<18), or 'any' */
     agePreference?: 'adults' | 'children' | 'any';
+    /**
+     * When true, age preference filters only apply to profiles with birthdates.
+     * Profiles without birthdates are included regardless of agePreference.
+     * When false (default), profiles without birthdates only match when agePreference is 'any'.
+     */
+    agePreferenceLenient?: boolean;
     /** Minimum age filter */
     minAge?: number;
     /** Maximum age filter */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rachelallyson/planning-center-people-ts",
-    "version": "2.12.1",
+    "version": "2.13.0",
     "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",