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

package/dist/modules/fields.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * v2.0.0 Fields Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldsModule = void 0;
+const base_1 = require("./base");
+class FieldsModule extends base_1.BaseModule {
+    constructor(httpClient, paginationHelper, eventEmitter) {
+        super(httpClient, paginationHelper, eventEmitter);
+        this.fieldDefinitionCache = null;
+        this.cacheTtl = 300000; // 5 minutes
+    }
+    /**
+     * Get all field definitions with caching
+     */
+    async getAllFieldDefinitions(useCache = true) {
+        if (useCache && this.isCacheValid()) {
+            return Array.from(this.fieldDefinitionCache.byId.values());
+        }
+        const result = await this.getAllPages('/field_definitions', {
+            include: ['tab'],
+        });
+        // Update cache
+        this.updateFieldDefinitionCache(result.data);
+        return result.data;
+    }
+    /**
+     * Get a single field definition by ID
+     */
+    async getFieldDefinition(id) {
+        return this.getSingle(`/field_definitions/${id}`);
+    }
+    /**
+     * Get field definition by slug
+     */
+    async getFieldDefinitionBySlug(slug) {
+        await this.ensureCacheLoaded();
+        return this.fieldDefinitionCache?.bySlug.get(slug) || null;
+    }
+    /**
+     * Get field definition by name
+     */
+    async getFieldDefinitionByName(name) {
+        await this.ensureCacheLoaded();
+        return this.fieldDefinitionCache?.byName.get(name) || null;
+    }
+    /**
+     * Create a field definition
+     */
+    async createFieldDefinition(tabId, data) {
+        const fieldDef = await this.createResource(`/tabs/${tabId}/field_definitions`, data);
+        // Invalidate cache
+        this.invalidateCache();
+        return fieldDef;
+    }
+    /**
+     * Update a field definition
+     */
+    async updateFieldDefinition(id, data) {
+        const fieldDef = await this.updateResource(`/field_definitions/${id}`, data);
+        // Update cache
+        if (this.fieldDefinitionCache && fieldDef.attributes) {
+            this.fieldDefinitionCache.byId.set(id, fieldDef);
+            this.fieldDefinitionCache.bySlug.set(fieldDef.attributes.slug, fieldDef);
+            this.fieldDefinitionCache.byName.set(fieldDef.attributes.name, fieldDef);
+        }
+        return fieldDef;
+    }
+    /**
+     * Delete a field definition
+     */
+    async deleteFieldDefinition(id) {
+        await this.deleteResource(`/field_definitions/${id}`);
+        // Remove from cache
+        if (this.fieldDefinitionCache) {
+            const fieldDef = this.fieldDefinitionCache.byId.get(id);
+            if (fieldDef && fieldDef.attributes) {
+                this.fieldDefinitionCache.byId.delete(id);
+                this.fieldDefinitionCache.bySlug.delete(fieldDef.attributes.slug);
+                this.fieldDefinitionCache.byName.delete(fieldDef.attributes.name);
+            }
+        }
+    }
+    /**
+     * Get field options for a field definition
+     */
+    async getFieldOptions(fieldDefinitionId) {
+        return this.getList(`/field_definitions/${fieldDefinitionId}/field_options`);
+    }
+    /**
+     * Create a field option
+     */
+    async createFieldOption(fieldDefinitionId, data) {
+        return this.createResource(`/field_definitions/${fieldDefinitionId}/field_options`, data);
+    }
+    /**
+     * Get person's field data
+     */
+    async getPersonFieldData(personId) {
+        return this.getList(`/people/${personId}/field_data`);
+    }
+    /**
+     * Set a person's field value with automatic field lookup
+     */
+    async setPersonField(personId, options) {
+        const fieldDef = await this.resolveFieldDefinition(options);
+        if (!fieldDef) {
+            throw new Error(`Field definition not found for: ${options.fieldId || options.fieldSlug || options.fieldName}`);
+        }
+        return this.createPersonFieldData(personId, fieldDef.id, options.value, {
+            handleFileUploads: options.handleFileUploads ?? true,
+        });
+    }
+    /**
+     * Set a person's field value by field definition ID
+     */
+    async setPersonFieldById(personId, fieldId, value) {
+        return this.createPersonFieldData(personId, fieldId, value);
+    }
+    /**
+     * Set a person's field value by field slug
+     */
+    async setPersonFieldBySlug(personId, fieldSlug, value) {
+        const fieldDef = await this.getFieldDefinitionBySlug(fieldSlug);
+        if (!fieldDef) {
+            throw new Error(`Field definition not found for slug: ${fieldSlug}`);
+        }
+        return this.createPersonFieldData(personId, fieldDef.id, value);
+    }
+    /**
+     * Set a person's field value by field name
+     */
+    async setPersonFieldByName(personId, fieldName, value) {
+        const fieldDef = await this.getFieldDefinitionByName(fieldName);
+        if (!fieldDef) {
+            throw new Error(`Field definition not found for name: ${fieldName}`);
+        }
+        return this.createPersonFieldData(personId, fieldDef.id, value);
+    }
+    /**
+     * Create field data for a person
+     */
+    async createPersonFieldData(personId, fieldDefinitionId, value, options = {}) {
+        const { handleFileUploads = true } = options;
+        // Get field definition to determine type
+        const fieldDef = await this.getFieldDefinition(fieldDefinitionId);
+        // Check if this is a file field and handle accordingly
+        if (fieldDef.attributes && fieldDef.attributes.data_type === 'file' && handleFileUploads) {
+            return this.createPersonFileFieldData(personId, fieldDefinitionId, value);
+        }
+        // For text fields, clean the value if it's a file URL
+        const cleanValue = this.isFileUrl(value) ? this.extractFileUrl(value) : value;
+        // Check if field data already exists for this person and field
+        try {
+            const existingFieldData = await this.getPersonFieldData(personId);
+            const existingDatum = existingFieldData.data.find(datum => {
+                const fieldDefData = datum.relationships?.field_definition?.data;
+                return Array.isArray(fieldDefData)
+                    ? fieldDefData.some(fd => fd.id === fieldDefinitionId)
+                    : fieldDefData?.id === fieldDefinitionId;
+            });
+            if (existingDatum) {
+                // Update existing field data
+                return this.updateResource(`/people/${personId}/field_data/${existingDatum.id}`, { value: cleanValue });
+            }
+        }
+        catch (error) {
+            // If we can't get existing field data, continue with creation
+        }
+        return this.createResource(`/people/${personId}/field_data`, {
+            field_definition_id: fieldDefinitionId,
+            value: cleanValue,
+        });
+    }
+    /**
+     * Delete person's field data
+     */
+    async deletePersonFieldData(personId, fieldDataId) {
+        return this.deleteResource(`/people/${personId}/field_data/${fieldDataId}`);
+    }
+    /**
+     * Get all tabs
+     */
+    async getTabs() {
+        return this.getList('/tabs');
+    }
+    /**
+     * Create a tab
+     */
+    async createTab(data) {
+        return this.createResource('/tabs', data);
+    }
+    /**
+     * Update a tab
+     */
+    async updateTab(id, data) {
+        return this.updateResource(`/tabs/${id}`, data);
+    }
+    /**
+     * Delete a tab
+     */
+    async deleteTab(id) {
+        return this.deleteResource(`/tabs/${id}`);
+    }
+    /**
+     * Resolve field definition from options
+     */
+    async resolveFieldDefinition(options) {
+        if (options.fieldId) {
+            return this.getFieldDefinition(options.fieldId);
+        }
+        if (options.fieldSlug) {
+            return this.getFieldDefinitionBySlug(options.fieldSlug);
+        }
+        if (options.fieldName) {
+            return this.getFieldDefinitionByName(options.fieldName);
+        }
+        return null;
+    }
+    /**
+     * Create field data for file uploads
+     */
+    async createPersonFileFieldData(personId, fieldDefinitionId, fileUrl) {
+        // This would implement the file upload logic from the original implementation
+        // For now, return a placeholder
+        throw new Error('File upload functionality not yet implemented in v2.0');
+    }
+    /**
+     * Check if cache is valid
+     */
+    isCacheValid() {
+        if (!this.fieldDefinitionCache) {
+            return false;
+        }
+        return Date.now() - this.fieldDefinitionCache.lastUpdated < this.cacheTtl;
+    }
+    /**
+     * Ensure cache is loaded
+     */
+    async ensureCacheLoaded() {
+        if (!this.isCacheValid()) {
+            await this.getAllFieldDefinitions(false);
+        }
+    }
+    /**
+     * Update field definition cache
+     */
+    updateFieldDefinitionCache(fieldDefinitions) {
+        this.fieldDefinitionCache = {
+            byId: new Map(),
+            bySlug: new Map(),
+            byName: new Map(),
+            lastUpdated: Date.now(),
+        };
+        for (const fieldDef of fieldDefinitions) {
+            if (fieldDef.attributes) {
+                this.fieldDefinitionCache.byId.set(fieldDef.id, fieldDef);
+                this.fieldDefinitionCache.bySlug.set(fieldDef.attributes.slug, fieldDef);
+                this.fieldDefinitionCache.byName.set(fieldDef.attributes.name, fieldDef);
+            }
+        }
+    }
+    /**
+     * Invalidate cache
+     */
+    invalidateCache() {
+        this.fieldDefinitionCache = null;
+    }
+    /**
+     * Check if a value is a file URL
+     */
+    isFileUrl(value) {
+        return value.includes('s3.') || value.includes('amazonaws.com') || value.includes('<a href=');
+    }
+    /**
+     * Extract file URL from HTML markup
+     */
+    extractFileUrl(value) {
+        if (value.startsWith('http') && !value.includes('<')) {
+            return value;
+        }
+        const hrefMatch = /href=["']([^"']+)["']/.exec(value);
+        if (hrefMatch) {
+            return hrefMatch[1];
+        }
+        const urlMatch = /(https?:\/\/[^\s<>"']+)/.exec(value);
+        if (urlMatch) {
+            return urlMatch[1];
+        }
+        return value;
+    }
+}
+exports.FieldsModule = FieldsModule;

package/dist/modules/households.d.ts

@@ -0,0 +1,42 @@
+/**
+ * v2.0.0 Households Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { HouseholdResource, HouseholdAttributes } from '../types';
+export interface HouseholdListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class HouseholdsModule extends BaseModule {
+    /**
+     * Get all households
+     */
+    getAll(options?: HouseholdListOptions): Promise<{
+        data: HouseholdResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all households across all pages
+     */
+    getAllPagesPaginated(options?: HouseholdListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<HouseholdResource>>;
+    /**
+     * Get a single household by ID
+     */
+    getById(id: string, include?: string[]): Promise<HouseholdResource>;
+    /**
+     * Create a household
+     */
+    create(data: HouseholdAttributes): Promise<HouseholdResource>;
+    /**
+     * Update a household
+     */
+    update(id: string, data: Partial<HouseholdAttributes>): Promise<HouseholdResource>;
+    /**
+     * Delete a household
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/modules/households.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * v2.0.0 Households Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HouseholdsModule = void 0;
+const base_1 = require("./base");
+class HouseholdsModule extends base_1.BaseModule {
+    /**
+     * Get all households
+     */
+    async getAll(options = {}) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        if (options.perPage) {
+            params.per_page = options.perPage;
+        }
+        if (options.page) {
+            params.page = options.page;
+        }
+        return this.getList('/households', params);
+    }
+    /**
+     * Get all households across all pages
+     */
+    async getAllPagesPaginated(options = {}, paginationOptions) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        return this.getAllPages('/households', params, paginationOptions);
+    }
+    /**
+     * Get a single household by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/households/${id}`, params);
+    }
+    /**
+     * Create a household
+     */
+    async create(data) {
+        return this.createResource('/households', data);
+    }
+    /**
+     * Update a household
+     */
+    async update(id, data) {
+        return this.updateResource(`/households/${id}`, data);
+    }
+    /**
+     * Delete a household
+     */
+    async delete(id) {
+        return this.deleteResource(`/households/${id}`);
+    }
+}
+exports.HouseholdsModule = HouseholdsModule;

package/dist/modules/lists.d.ts

@@ -0,0 +1,62 @@
+/**
+ * v2.0.0 Lists Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { ListResource, ListCategoryResource, ListCategoryAttributes, PersonResource } from '../types';
+export interface ListsListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class ListsModule extends BaseModule {
+    /**
+     * Get all lists
+     */
+    getAll(options?: ListsListOptions): Promise<{
+        data: ListResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all lists across all pages
+     */
+    getAllPagesPaginated(options?: ListsListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<ListResource>>;
+    /**
+     * Get a single list by ID
+     */
+    getById(id: string, include?: string[]): Promise<ListResource>;
+    /**
+     * Get all list categories
+     */
+    getListCategories(): Promise<{
+        data: ListCategoryResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single list category by ID
+     */
+    getListCategoryById(id: string): Promise<ListCategoryResource>;
+    /**
+     * Create a new list category
+     */
+    createListCategory(data: ListCategoryAttributes): Promise<ListCategoryResource>;
+    /**
+     * Update an existing list category
+     */
+    updateListCategory(id: string, data: Partial<ListCategoryAttributes>): Promise<ListCategoryResource>;
+    /**
+     * Delete a list category
+     */
+    deleteListCategory(id: string): Promise<void>;
+    /**
+     * Get people in a list (via the people relationship)
+     */
+    getPeople(listId: string): Promise<{
+        data: PersonResource[];
+        meta?: any;
+        links?: any;
+    }>;
+}

package/dist/modules/lists.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * v2.0.0 Lists Module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListsModule = void 0;
+const base_1 = require("./base");
+class ListsModule extends base_1.BaseModule {
+    /**
+     * Get all lists
+     */
+    async getAll(options = {}) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        if (options.perPage) {
+            params.per_page = options.perPage;
+        }
+        if (options.page) {
+            params.page = options.page;
+        }
+        return this.getList('/lists', params);
+    }
+    /**
+     * Get all lists across all pages
+     */
+    async getAllPagesPaginated(options = {}, paginationOptions) {
+        const params = {};
+        if (options.where) {
+            Object.entries(options.where).forEach(([key, value]) => {
+                params[`where[${key}]`] = value;
+            });
+        }
+        if (options.include) {
+            params.include = options.include.join(',');
+        }
+        return this.getAllPages('/lists', params, paginationOptions);
+    }
+    /**
+     * Get a single list by ID
+     */
+    async getById(id, include) {
+        const params = {};
+        if (include) {
+            params.include = include.join(',');
+        }
+        return this.getSingle(`/lists/${id}`, params);
+    }
+    /**
+     * Get all list categories
+     */
+    async getListCategories() {
+        return this.getList('/list_categories');
+    }
+    /**
+     * Get a single list category by ID
+     */
+    async getListCategoryById(id) {
+        return this.getSingle(`/list_categories/${id}`);
+    }
+    /**
+     * Create a new list category
+     */
+    async createListCategory(data) {
+        return this.createResource('/list_categories', data);
+    }
+    /**
+     * Update an existing list category
+     */
+    async updateListCategory(id, data) {
+        return this.updateResource(`/list_categories/${id}`, data);
+    }
+    /**
+     * Delete a list category
+     */
+    async deleteListCategory(id) {
+        return this.deleteResource(`/list_categories/${id}`);
+    }
+    /**
+     * Get people in a list (via the people relationship)
+     */
+    async getPeople(listId) {
+        return this.getList(`/lists/${listId}/people`);
+    }
+}
+exports.ListsModule = ListsModule;

package/dist/modules/notes.d.ts

@@ -0,0 +1,74 @@
+/**
+ * v2.0.0 Notes Module
+ */
+import { BaseModule } from './base';
+import type { PaginationOptions, PaginationResult } from '../core/pagination';
+import type { NoteResource, NoteAttributes, NoteCategoryResource, NoteCategoryAttributes } from '../types';
+export interface NotesListOptions {
+    where?: Record<string, any>;
+    include?: string[];
+    perPage?: number;
+    page?: number;
+}
+export declare class NotesModule extends BaseModule {
+    /**
+     * Get all notes
+     */
+    getAll(options?: NotesListOptions): Promise<{
+        data: NoteResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get all notes across all pages
+     */
+    getAllPagesPaginated(options?: NotesListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<NoteResource>>;
+    /**
+     * Get a single note by ID
+     */
+    getById(id: string, include?: string[]): Promise<NoteResource>;
+    /**
+     * Get notes for a specific person
+     */
+    getNotesForPerson(personId: string, options?: NotesListOptions): Promise<{
+        data: NoteResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Create a note for a person
+     */
+    create(personId: string, data: NoteAttributes): Promise<NoteResource>;
+    /**
+     * Update a note
+     */
+    update(id: string, data: Partial<NoteAttributes>): Promise<NoteResource>;
+    /**
+     * Delete a note
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Get all note categories
+     */
+    getNoteCategories(): Promise<{
+        data: NoteCategoryResource[];
+        meta?: any;
+        links?: any;
+    }>;
+    /**
+     * Get a single note category by ID
+     */
+    getNoteCategoryById(id: string): Promise<NoteCategoryResource>;
+    /**
+     * Create a note category
+     */
+    createNoteCategory(data: NoteCategoryAttributes): Promise<NoteCategoryResource>;
+    /**
+     * Update a note category
+     */
+    updateNoteCategory(id: string, data: Partial<NoteCategoryAttributes>): Promise<NoteCategoryResource>;
+    /**
+     * Delete a note category
+     */
+    deleteNoteCategory(id: string): Promise<void>;
+}