@rachelallyson/planning-center-people-ts 2.14.1 → 3.1.0

package/dist/modules/forms.js

@@ -10,71 +10,89 @@ const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-t
  * Most operations are read-only based on API documentation
  */
 class FormsModule extends planning_center_base_ts_1.BaseModule {
-    constructor(httpClient, paginationHelper, eventEmitter) {
-        super(httpClient, paginationHelper, eventEmitter);
-    }
     /**
-     * Get all forms
+     * Get all forms across all pages
      */
     async getAll(params) {
-        return this.getList('/forms', params);
+        this.debugLog('forms.getAll', { params });
+        return this.getAllPages('/forms', {
+            where: params?.where,
+            include: params?.include,
+            order: params?.order
+        });
+    }
+    /**
+     * Get a single page of forms with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param params - List parameters including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
+     */
+    async getPage(params) {
+        this.debugLog('forms.getPage', { params });
+        return this.getList('/forms', {
+            where: params?.where,
+            include: params?.include,
+            per_page: params?.perPage,
+            page: params?.page,
+            order: params?.order
+        });
     }
     /**
      * Get a specific form by ID
      */
     async getById(id, include) {
-        const params = {};
-        if (include) {
-            params.include = include.join(',');
-        }
-        return this.getSingle(`/forms/${id}`, params);
+        this.debugLog('forms.getById', { id, include });
+        return this.getSingle(`/forms/${id}`, include);
     }
     /**
      * Get form category for a specific form
      */
     async getFormCategory(formId) {
+        this.debugLog('forms.getFormCategory', { formId });
         return this.getSingle(`/forms/${formId}/category`);
     }
     /**
      * Get form fields for a specific form
      */
     async getFormFields(formId, params) {
-        const result = await this.getList(`/forms/${formId}/fields`, params);
-        return { data: result.data };
+        this.debugLog('forms.getFormFields', { formId, params });
+        return await this.getList(`/forms/${formId}/fields`, {
+            where: params?.where,
+            include: params?.include,
+            per_page: params?.perPage,
+            page: params?.page
+        });
     }
     /**
      * Get form field options for a specific form field
      * Note: This requires the formId to get field options
      */
     async getFormFieldOptions(formId, formFieldId, params) {
-        const result = await this.getList(`/forms/${formId}/fields/${formFieldId}/options`, params);
-        return { data: result.data };
+        this.debugLog('forms.getFormFieldOptions', { formId, formFieldId, params });
+        return await this.getList(`/forms/${formId}/fields/${formFieldId}/options`, params);
     }
     /**
      * Get form submissions for a specific form
      */
     async getFormSubmissions(formId, params) {
-        const result = await this.getList(`/forms/${formId}/form_submissions`, params);
-        return { data: result.data };
+        this.debugLog('forms.getFormSubmissions', { formId, params });
+        return await this.getList(`/forms/${formId}/form_submissions`, params);
     }
     /**
      * Get a specific form submission by ID
      * Note: This requires the formId to get the submission
      */
     async getFormSubmissionById(formId, formSubmissionId, include) {
-        const params = {};
-        if (include) {
-            params.include = include.join(',');
-        }
-        return this.getSingle(`/forms/${formId}/form_submissions/${formSubmissionId}`, params);
+        this.debugLog('forms.getFormSubmissionById', { formId, formSubmissionId, include });
+        return this.getSingle(`/forms/${formId}/form_submissions/${formSubmissionId}`, include);
     }
     /**
      * Get form submission values for a specific form submission
      * Note: This requires the formId to get submission values
      */
     async getFormSubmissionValues(formId, formSubmissionId, params) {
-        const result = await this.getList(`/forms/${formId}/form_submissions/${formSubmissionId}/form_submission_values`, params);
-        return { data: result.data };
+        this.debugLog('forms.getFormSubmissionValues', { formId, formSubmissionId, params });
+        return await this.getList(`/forms/${formId}/form_submissions/${formSubmissionId}/form_submission_values`, params);
     }
 }
 exports.FormsModule = FormsModule;

package/dist/modules/households.d.ts

@@ -2,39 +2,37 @@
  * v2.0.0 Households Module
  */
 import { BaseModule } from '@rachelallyson/planning-center-base-ts';
-import type { PaginationOptions, PaginationResult } from '@rachelallyson/planning-center-base-ts';
-import type { HouseholdResource, HouseholdAttributes } from '../types';
-export interface HouseholdListOptions {
-    where?: Record<string, any>;
-    include?: string[];
-    perPage?: number;
-    page?: number;
-}
+import type { HouseholdResource, HouseholdAttributes, Meta, TopLevelLinks } from '../types';
+import type { HouseholdListOptions, HouseholdPageOptions } from '../types/api-options';
+export type { HouseholdListOptions };
 export declare class HouseholdsModule extends BaseModule {
     /**
-     * Get all households
+     * Get all households across all pages
      */
-    getAll(options?: HouseholdListOptions): Promise<{
-        data: HouseholdResource[];
-        meta?: any;
-        links?: any;
-    }>;
+    getAll(options?: HouseholdListOptions): Promise<import("@rachelallyson/planning-center-base-ts").PaginationResult<HouseholdResource, import("@rachelallyson/planning-center-base-ts").ResourceObject<string, any, any>, Record<string, never>>>;
     /**
-     * Get all households across all pages
+     * Get a single page of households with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param options - List options including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
      */
-    getAllPagesPaginated(options?: HouseholdListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<HouseholdResource>>;
+    getPage(options?: HouseholdPageOptions): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Household", HouseholdAttributes, import("../types").HouseholdRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
+    }>;
     /**
      * Get a single household by ID
      */
-    getById(id: string, include?: string[]): Promise<HouseholdResource>;
+    getById(id: string, include?: string[]): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Household", HouseholdAttributes, import("../types").HouseholdRelationships>>;
     /**
      * Create a household
      */
-    create(data: HouseholdAttributes): Promise<HouseholdResource>;
+    create(data: HouseholdAttributes): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Household", HouseholdAttributes, import("../types").HouseholdRelationships>>;
     /**
      * Update a household
      */
-    update(id: string, data: Partial<HouseholdAttributes>): Promise<HouseholdResource>;
+    update(id: string, data: Partial<HouseholdAttributes>): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Household", HouseholdAttributes, import("../types").HouseholdRelationships>>;
     /**
      * Delete a household
      */

package/dist/modules/households.js

@@ -7,67 +7,58 @@ exports.HouseholdsModule = void 0;
 const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 class HouseholdsModule extends planning_center_base_ts_1.BaseModule {
     /**
-     * Get all households
+     * Get all households across all pages
      */
     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);
+        this.debugLog('households.getAll', { options });
+        return await this.getAllPages('/households', {
+            where: options.where,
+            include: options.include,
+            order: options.order
+        });
     }
     /**
-     * Get all households across all pages
+     * Get a single page of households with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param options - List options including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
      */
-    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);
+    async getPage(options = {}) {
+        this.debugLog('households.getPage', { options });
+        return this.getList('/households', {
+            where: options.where,
+            include: options.include,
+            per_page: options.perPage,
+            page: options.page,
+            order: options.order
+        });
     }
     /**
      * Get a single household by ID
      */
     async getById(id, include) {
-        const params = {};
-        if (include) {
-            params.include = include.join(',');
-        }
-        return this.getSingle(`/households/${id}`, params);
+        this.debugLog('households.getById', { id, include });
+        return this.getSingle(`/households/${id}`, include);
     }
     /**
      * Create a household
      */
     async create(data) {
+        this.debugLog('households.create', { data });
         return this.createResource('/households', data);
     }
     /**
      * Update a household
      */
     async update(id, data) {
+        this.debugLog('households.update', { id, data });
         return this.updateResource(`/households/${id}`, data);
     }
     /**
      * Delete a household
      */
     async delete(id) {
+        this.debugLog('households.delete', { id });
         return this.deleteResource(`/households/${id}`);
     }
 }

package/dist/modules/lists.d.ts

@@ -2,51 +2,53 @@
  * v2.0.0 Lists Module
  */
 import { BaseModule } from '@rachelallyson/planning-center-base-ts';
-import type { PaginationOptions, PaginationResult } from '@rachelallyson/planning-center-base-ts';
-import type { ListResource, ListCategoryResource, ListCategoryAttributes, PersonResource } from '../types';
-export interface ListsListOptions {
-    where?: Record<string, any>;
-    include?: string[];
-    perPage?: number;
-    page?: number;
-}
+import type { ListResource, ListAttributes, ListCategoryAttributes, Meta, TopLevelLinks } from '../types';
+import type { ListListOptions, ListPageOptions } from '../types/api-options';
+export type ListsListOptions = ListListOptions;
 export declare class ListsModule extends BaseModule {
     /**
-     * Get all lists
+     * Get all lists across all pages
      */
-    getAll(options?: ListsListOptions): Promise<{
-        data: ListResource[];
-        meta?: any;
-        links?: any;
-    }>;
+    getAll(options?: ListsListOptions): Promise<import("@rachelallyson/planning-center-base-ts").PaginationResult<ListResource, import("@rachelallyson/planning-center-base-ts").ResourceObject<string, any, any>, Record<string, never>>>;
     /**
-     * Get all lists across all pages
+     * Get a single page of lists with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param options - List options including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
      */
-    getAllPagesPaginated(options?: ListsListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<ListResource>>;
+    getPage(options?: ListPageOptions): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"List", ListAttributes, {}, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
+    }>;
     /**
      * Get a single list by ID
      */
-    getById(id: string, include?: string[]): Promise<ListResource>;
+    getById(id: string, include?: string[]): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"List", ListAttributes, {}>>;
     /**
      * Get all list categories
+     * @param options - Optional pagination options
      */
-    getListCategories(): Promise<{
-        data: ListCategoryResource[];
-        meta?: any;
-        links?: any;
+    getListCategories(options?: {
+        perPage?: number;
+        page?: number;
+    }): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"ListCategory", ListCategoryAttributes, import("../types").ListCategoryRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Get a single list category by ID
      */
-    getListCategoryById(id: string): Promise<ListCategoryResource>;
+    getListCategoryById(id: string): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"ListCategory", ListCategoryAttributes, import("../types").ListCategoryRelationships>>;
     /**
      * Create a new list category
      */
-    createListCategory(data: ListCategoryAttributes): Promise<ListCategoryResource>;
+    createListCategory(data: Partial<ListCategoryAttributes>): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"ListCategory", ListCategoryAttributes, import("../types").ListCategoryRelationships>>;
     /**
      * Update an existing list category
      */
-    updateListCategory(id: string, data: Partial<ListCategoryAttributes>): Promise<ListCategoryResource>;
+    updateListCategory(id: string, data: Partial<ListCategoryAttributes>): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"ListCategory", ListCategoryAttributes, import("../types").ListCategoryRelationships>>;
     /**
      * Delete a list category
      */
@@ -55,12 +57,20 @@ export declare class ListsModule extends BaseModule {
      * Get people in a list (via the people relationship)
      */
     getPeople(listId: string): Promise<{
-        data: PersonResource[];
-        meta?: any;
-        links?: any;
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Person", import("../types").PersonAttributes, import("../types").PersonRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
+    }>;
+    /**
+     * Get rules for a list (GET /people/v2/lists/:id/rules)
+     */
+    getRules(listId: string): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Rule", import("../types").ListRuleAttributes, import("../types").ListRuleRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Run a List to update its results
      */
-    run(listId: string): Promise<ListResource>;
+    refresh(listId: string): Promise<ListResource | import("@rachelallyson/planning-center-base-ts").FlattenedResource<"List", ListAttributes, {}>>;
 }

package/dist/modules/lists.js

@@ -7,56 +7,49 @@ exports.ListsModule = void 0;
 const planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
 class ListsModule extends planning_center_base_ts_1.BaseModule {
     /**
-     * Get all lists
+     * Get all lists across all pages
      */
     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);
+        this.debugLog('lists.getAll', { options });
+        return await this.getAllPages('/lists', {
+            where: options.where,
+            include: options.include,
+            order: options.order
+        });
     }
     /**
-     * Get all lists across all pages
+     * Get a single page of lists with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param options - List options including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
      */
-    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);
+    async getPage(options = {}) {
+        this.debugLog('lists.getPage', { options });
+        return this.getList('/lists', {
+            where: options.where,
+            include: options.include,
+            per_page: options.perPage,
+            page: options.page,
+            order: options.order
+        });
     }
     /**
      * Get a single list by ID
      */
     async getById(id, include) {
-        const params = {};
-        if (include) {
-            params.include = include.join(',');
-        }
-        return this.getSingle(`/lists/${id}`, params);
+        this.debugLog('lists.getById', { id, include });
+        return this.getSingle(`/lists/${id}`, include);
     }
     /**
      * Get all list categories
+     * @param options - Optional pagination options
      */
-    async getListCategories() {
-        return this.getList('/list_categories');
+    async getListCategories(options) {
+        this.debugLog('lists.getListCategories', { options });
+        return this.getList('/list_categories', options ? {
+            per_page: options.perPage,
+            page: options.page,
+        } : undefined);
     }
     /**
      * Get a single list category by ID
@@ -88,15 +81,42 @@ class ListsModule extends planning_center_base_ts_1.BaseModule {
     async getPeople(listId) {
         return this.getList(`/lists/${listId}/people`);
     }
+    /**
+     * Get rules for a list (GET /people/v2/lists/:id/rules)
+     */
+    async getRules(listId) {
+        this.debugLog('lists.getRules', { listId });
+        return this.getList(`/lists/${listId}/rules`);
+    }
     /**
      * Run a List to update its results
      */
-    async run(listId) {
-        const response = await this.httpClient.request({
-            method: 'POST',
-            endpoint: `/lists/${listId}/run`,
-        });
-        return response.data.data;
+    async refresh(listId) {
+        this.debugLog('lists.refresh', { listId });
+        try {
+            const response = await this.httpClient.request({
+                method: 'POST',
+                endpoint: `/lists/${listId}/run`,
+            });
+            // If response has data, return it; otherwise return the list by ID
+            if (response.data?.data) {
+                return response.data.data;
+            }
+            // If no data in response (204 No Content or empty response), return the list itself
+            return this.getById(listId);
+        }
+        catch (error) {
+            // The run endpoint may return an empty response (204 No Content)
+            // If we get a JSON parse error, try to get the list by ID instead
+            if (error && typeof error === 'object' && 'message' in error) {
+                const errorMessage = error?.message;
+                if (typeof errorMessage === 'string' && (errorMessage.includes('JSON') || errorMessage.includes('Unexpected end'))) {
+                    // Return the list itself as the result
+                    return this.getById(listId);
+                }
+            }
+            throw error;
+        }
     }
 }
 exports.ListsModule = ListsModule;

package/dist/modules/notes.d.ts

@@ -2,71 +2,73 @@
  * v2.0.0 Notes Module
  */
 import { BaseModule } from '@rachelallyson/planning-center-base-ts';
-import type { PaginationOptions, PaginationResult } from '@rachelallyson/planning-center-base-ts';
-import type { NoteResource, NoteAttributes, NoteCategoryResource, NoteCategoryAttributes } from '../types';
-export interface NotesListOptions {
-    where?: Record<string, any>;
-    include?: string[];
-    perPage?: number;
-    page?: number;
-}
+import type { NoteResource, NoteAttributes, NoteCategoryAttributes, Meta, TopLevelLinks } from '../types';
+import type { NoteListOptions, NotePageOptions } from '../types/api-options';
+export type NotesListOptions = NoteListOptions;
 export declare class NotesModule extends BaseModule {
     /**
-     * Get all notes
+     * Get all notes across all pages
      */
-    getAll(options?: NotesListOptions): Promise<{
-        data: NoteResource[];
-        meta?: any;
-        links?: any;
-    }>;
+    getAll(options?: NotesListOptions): Promise<import("@rachelallyson/planning-center-base-ts").PaginationResult<NoteResource, import("@rachelallyson/planning-center-base-ts").ResourceObject<string, any, any>, Record<string, never>>>;
     /**
-     * Get all notes across all pages
+     * Get a single page of notes with optional filtering and pagination control
+     * Use this when you need a specific page or want to limit the number of results
+     * @param options - List options including where, include, perPage, page, and order
+     * @returns A single page of results with meta and links for pagination
      */
-    getAllPagesPaginated(options?: NotesListOptions, paginationOptions?: PaginationOptions): Promise<PaginationResult<NoteResource>>;
+    getPage(options?: NotePageOptions): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Note", NoteAttributes, import("../types").NoteRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
+    }>;
     /**
      * Get a single note by ID
      */
-    getById(id: string, include?: string[]): Promise<NoteResource>;
+    getById(id: string, include?: string[]): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Note", NoteAttributes, import("../types").NoteRelationships>>;
     /**
      * Get notes for a specific person
      */
-    getNotesForPerson(personId: string, options?: NotesListOptions): Promise<{
-        data: NoteResource[];
-        meta?: any;
-        links?: any;
+    getNotesForPerson(personId: string, options?: NotePageOptions): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Note", NoteAttributes, import("../types").NoteRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Create a note for a person
      */
-    create(personId: string, data: NoteAttributes): Promise<NoteResource>;
+    create(personId: string, data: NoteAttributes): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Note", NoteAttributes, import("../types").NoteRelationships>>;
     /**
      * Update a note
      */
-    update(id: string, data: Partial<NoteAttributes>): Promise<NoteResource>;
+    update(id: string, data: Partial<NoteAttributes>): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"Note", NoteAttributes, import("../types").NoteRelationships>>;
     /**
      * Delete a note
      */
     delete(id: string): Promise<void>;
     /**
      * Get all note categories
+     * @param options - Optional pagination options
      */
-    getNoteCategories(): Promise<{
-        data: NoteCategoryResource[];
-        meta?: any;
-        links?: any;
+    getNoteCategories(options?: {
+        perPage?: number;
+        page?: number;
+    }): Promise<{
+        data: import("@rachelallyson/planning-center-base-ts").FlattenedResource<"NoteCategory", NoteCategoryAttributes, import("../types").NoteCategoryRelationships, Record<string, never>>[];
+        meta?: Meta;
+        links?: TopLevelLinks;
     }>;
     /**
      * Get a single note category by ID
      */
-    getNoteCategoryById(id: string): Promise<NoteCategoryResource>;
+    getNoteCategoryById(id: string): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"NoteCategory", NoteCategoryAttributes, import("../types").NoteCategoryRelationships>>;
     /**
      * Create a note category
      */
-    createNoteCategory(data: NoteCategoryAttributes): Promise<NoteCategoryResource>;
+    createNoteCategory(data: Partial<NoteCategoryAttributes>): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"NoteCategory", NoteCategoryAttributes, import("../types").NoteCategoryRelationships>>;
     /**
      * Update a note category
      */
-    updateNoteCategory(id: string, data: Partial<NoteCategoryAttributes>): Promise<NoteCategoryResource>;
+    updateNoteCategory(id: string, data: Partial<NoteCategoryAttributes>): Promise<import("@rachelallyson/planning-center-base-ts").FlattenedResource<"NoteCategory", NoteCategoryAttributes, import("../types").NoteCategoryRelationships>>;
     /**
      * Delete a note category
      */