@hobokengrace/n8n-nodes-pco 0.1.0

package/dist/tests/generator.test.js

@@ -0,0 +1,622 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const entrypoint = __importStar(require("../index"));
+const config_1 = require("../src/generator/config");
+const openapi_1 = require("../src/generator/openapi");
+const generatedNodeClasses = config_1.generatedProductConfigs.map((config) => entrypoint[config.className]);
+function collectDisplayNames(value, labels = []) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectDisplayNames(item, labels);
+        return labels;
+    }
+    if (!value || typeof value !== 'object')
+        return labels;
+    const record = value;
+    if (typeof record.displayName === 'string')
+        labels.push(record.displayName);
+    for (const nestedValue of Object.values(record))
+        collectDisplayNames(nestedValue, labels);
+    return labels;
+}
+(0, vitest_1.describe)('generated Planning Center nodes', () => {
+    (0, vitest_1.it)('exposes required n8n descriptions for generated products', () => {
+        const nodes = generatedNodeClasses.map((NodeClass) => new NodeClass());
+        (0, vitest_1.expect)(nodes.map((node) => node.description.displayName)).toEqual(config_1.generatedProductConfigs.map((config) => config.displayName));
+        nodes.forEach((node, index) => {
+            const config = config_1.generatedProductConfigs[index];
+            (0, vitest_1.expect)(node.description.credentials).toEqual([{ name: 'planningCenterPatApi', required: true }]);
+            (0, vitest_1.expect)(node.description.icon).toBe(`file:${config.product}.svg`);
+            (0, vitest_1.expect)(node.description.properties.some((property) => property.name === 'resource')).toBe(true);
+            (0, vitest_1.expect)(node.description.properties.some((property) => property.name === 'operation')).toBe(true);
+        });
+    });
+    (0, vitest_1.it)('records metadata summaries for generated products', async () => {
+        const summaries = await Promise.all(config_1.generatedProductConfigs.map(openapi_1.buildProductGeneration));
+        (0, vitest_1.expect)(summaries.map((summary) => summary.product).sort()).toEqual(config_1.generatedProductConfigs.map((config) => config.product).sort());
+        for (const summary of summaries) {
+            (0, vitest_1.expect)(summary.operationCount).toBeGreaterThan(0);
+            (0, vitest_1.expect)(summary.resourceCount).toBeGreaterThan(0);
+            (0, vitest_1.expect)(summary.exclusions).toEqual([]);
+            (0, vitest_1.expect)(summary.operations.some((operation) => operation.path.startsWith(`/${summary.product}/v2`))).toBe(true);
+        }
+    });
+    (0, vitest_1.it)('defaults each generated resource to a read operation when one exists', async () => {
+        const summaries = await Promise.all(config_1.generatedProductConfigs.map(openapi_1.buildProductGeneration));
+        for (const summary of summaries) {
+            const operationsByResource = new Map();
+            for (const operation of summary.operations) {
+                operationsByResource.set(operation.resource, [...(operationsByResource.get(operation.resource) ?? []), operation]);
+            }
+            for (const [resource, operations] of operationsByResource) {
+                if (operations.some((operation) => operation.method === 'GET')) {
+                    (0, vitest_1.expect)(operations[0].method, `${summary.product}:${resource}`).toBe('GET');
+                }
+            }
+        }
+    });
+    (0, vitest_1.it)('does not treat singleton GET responses as paginated lists', async () => {
+        const currentConfig = config_1.generatedProductConfigs.find((config) => config.product === 'current');
+        (0, vitest_1.expect)(currentConfig).toBeDefined();
+        const summary = await (0, openapi_1.buildProductGeneration)(currentConfig);
+        const getMeOperation = summary.operations.find((operation) => operation.id === 'getMe');
+        const currentNode = new entrypoint.PlanningCenterCurrent();
+        const propertyNames = currentNode.description.properties.map((property) => property.name);
+        (0, vitest_1.expect)(getMeOperation).toMatchObject({
+            isList: false,
+            operation: 'Get Me',
+            path: '/current/v2/me',
+        });
+        (0, vitest_1.expect)(propertyNames).not.toContain('getMe_returnAll');
+        (0, vitest_1.expect)(propertyNames).not.toContain('getMe_limit');
+    });
+    (0, vitest_1.it)('derives friendly operation labels from HTTP method and path shape', async () => {
+        const peopleConfig = config_1.generatedProductConfigs.find((config) => config.product === 'people');
+        const givingConfig = config_1.generatedProductConfigs.find((config) => config.product === 'giving');
+        const servicesConfig = config_1.generatedProductConfigs.find((config) => config.product === 'services');
+        (0, vitest_1.expect)(peopleConfig).toBeDefined();
+        (0, vitest_1.expect)(givingConfig).toBeDefined();
+        (0, vitest_1.expect)(servicesConfig).toBeDefined();
+        const [peopleSummary, givingSummary, servicesSummary] = await Promise.all([
+            (0, openapi_1.buildProductGeneration)(peopleConfig),
+            (0, openapi_1.buildProductGeneration)(givingConfig),
+            (0, openapi_1.buildProductGeneration)(servicesConfig),
+        ]);
+        const operations = Object.fromEntries(peopleSummary.operations.map((operation) => [operation.id, operation.operation]));
+        const givingOperations = Object.fromEntries(givingSummary.operations.map((operation) => [operation.id, operation.operation]));
+        const servicesOperations = Object.fromEntries(servicesSummary.operations.map((operation) => [operation.id, operation.operation]));
+        (0, vitest_1.expect)(operations.getFormsFormIdFormSubmissions).toBe('List Form Submissions (via Form)');
+        (0, vitest_1.expect)(operations.getFormsFormIdFormSubmissionsFormSubmissionId).toBe('Get Form Submission (via Form)');
+        (0, vitest_1.expect)(operations.postFormsFormIdFormSubmissions).toBe('Create Form Submission (via Form)');
+        (0, vitest_1.expect)(operations.patchFormsFormIdFormSubmissionsFormSubmissionIdPersonPersonId).toBe('Update Person (via Form Submission)');
+        (0, vitest_1.expect)(operations.deleteFormsFormIdFormSubmissionsFormSubmissionIdPersonPersonId).toBe('Delete Person (via Form Submission)');
+        (0, vitest_1.expect)(operations.getFormsFormIdFormSubmissionsFormSubmissionIdFormSubmissionValues).toBe('List Form Submission Values (via Form Submission)');
+        (0, vitest_1.expect)(operations.getFormsFormIdFormSubmissionsFormSubmissionIdFormSubmissionValuesFormSubmissionValueId).toBe('Get Form Submission Value (via Form Submission)');
+        (0, vitest_1.expect)(operations.getPeople).toBe('List People');
+        (0, vitest_1.expect)(operations.getHouseholdsHouseholdIdPeople).toBe('List People (via Household)');
+        (0, vitest_1.expect)(operations.getListsListIdPeople).toBe('List People (via List)');
+        (0, vitest_1.expect)(operations.getPeoplePersonId).toBe('Get Person');
+        (0, vitest_1.expect)(operations.getPeoplePersonIdWorkflowCardsWorkflowCardIdPersonPersonId).toBe('Get Person (via Workflow Card)');
+        (0, vitest_1.expect)(operations.getMaritalStatusesMaritalStatusId).toBe('Get Marital Status');
+        (0, vitest_1.expect)(givingOperations.getCampusesCampusId).toBe('Get Campus');
+        (0, vitest_1.expect)(servicesOperations.getFoldersFolderIdFoldersFolderId).toBe('Get Folder (via Folder)');
+    });
+    (0, vitest_1.it)('renders selected operation subtitles from endpoint descriptions while preserving operation IDs', () => {
+        const node = new entrypoint.PlanningCenterPeople();
+        const operationProperty = node.description.properties.find((property) => property.name === 'operation' && property.options?.some((option) => option.value === 'getPeople'));
+        (0, vitest_1.expect)(node.description.subtitle).not.toBe('={{$parameter["operation"]}}');
+        (0, vitest_1.expect)(node.description.subtitle).toContain('$parameter["operation"]');
+        (0, vitest_1.expect)(node.description.subtitle).toContain('"getPeople":"GET /people"');
+        (0, vitest_1.expect)(operationProperty?.options).toEqual(vitest_1.expect.arrayContaining([
+            vitest_1.expect.objectContaining({
+                name: 'List People',
+                value: 'getPeople',
+                description: 'GET /people',
+            }),
+        ]));
+    });
+    (0, vitest_1.it)('does not emit duplicate operation labels within a product', async () => {
+        const summaries = await Promise.all(config_1.productConfigs.map(openapi_1.buildProductGeneration));
+        for (const summary of summaries) {
+            const operationsByLabel = new Map();
+            for (const operation of summary.operations) {
+                operationsByLabel.set(operation.operation, [
+                    ...(operationsByLabel.get(operation.operation) ?? []),
+                    `${operation.method} ${operation.path}`,
+                ]);
+            }
+            const duplicateLabels = [...operationsByLabel.entries()]
+                .filter(([, paths]) => paths.length > 1)
+                .map(([label, paths]) => `${label}: ${paths.join(', ')}`);
+            (0, vitest_1.expect)(duplicateLabels, summary.product).toEqual([]);
+        }
+    });
+    (0, vitest_1.it)('renders only useful query filters for form submission lists', async () => {
+        const peopleConfig = config_1.generatedProductConfigs.find((config) => config.product === 'people');
+        (0, vitest_1.expect)(peopleConfig).toBeDefined();
+        const summary = await (0, openapi_1.buildProductGeneration)(peopleConfig);
+        const operation = summary.operations.find((candidate) => candidate.id === 'getFormsFormIdFormSubmissions');
+        (0, vitest_1.expect)(operation).toBeDefined();
+        const queryParameters = operation.queryParameters.map((parameter) => parameter.sourceName);
+        (0, vitest_1.expect)(queryParameters).toContain('where[created_at]');
+        (0, vitest_1.expect)(queryParameters).toContain('where[created_at][gte]');
+        (0, vitest_1.expect)(queryParameters).toContain('where[updated_at][lte]');
+        (0, vitest_1.expect)(queryParameters).toContain('where[submitter_name]');
+        (0, vitest_1.expect)(queryParameters).toContain('where[person][id]');
+        (0, vitest_1.expect)(queryParameters).toContain('include');
+        (0, vitest_1.expect)(queryParameters).toContain('order');
+        (0, vitest_1.expect)(queryParameters).not.toContain('where[form][id]');
+        (0, vitest_1.expect)(queryParameters).not.toContain('where[person][addresses][city]');
+        (0, vitest_1.expect)(queryParameters).not.toContain('where[form][campus][updated_at]');
+        (0, vitest_1.expect)(queryParameters).not.toContain('fields[FormSubmission]');
+        (0, vitest_1.expect)(queryParameters).not.toContain('per_page');
+        (0, vitest_1.expect)(queryParameters).not.toContain('offset');
+        (0, vitest_1.expect)(queryParameters.length).toBeLessThan(20);
+        const queryOptions = Object.fromEntries(operation.queryOptions.map((option) => [option.name, option]));
+        (0, vitest_1.expect)(queryOptions.wherecreatedAtFilter).toMatchObject({
+            displayName: 'Created At',
+            group: 'filter',
+            kind: 'operator',
+        });
+        (0, vitest_1.expect)(queryOptions.wherecreatedAtFilter.operators).toEqual([
+            { name: 'Equals', value: 'eq', sourceName: 'where[created_at]' },
+            { name: 'Greater Than', value: 'gt', sourceName: 'where[created_at][gt]' },
+            { name: 'Greater Than Or Equal', value: 'gte', sourceName: 'where[created_at][gte]' },
+            { name: 'Less Than', value: 'lt', sourceName: 'where[created_at][lt]' },
+            { name: 'Less Than Or Equal', value: 'lte', sourceName: 'where[created_at][lte]' },
+        ]);
+        (0, vitest_1.expect)(queryOptions.wherepersonid).toMatchObject({
+            displayName: 'Person ID',
+            group: 'filter',
+            kind: 'single',
+            sourceName: 'where[person][id]',
+        });
+        (0, vitest_1.expect)(queryOptions.include).toMatchObject({
+            displayName: 'Include',
+            group: 'include',
+            kind: 'single',
+            sourceName: 'include',
+        });
+        (0, vitest_1.expect)(queryOptions.order).toMatchObject({
+            displayName: 'Order',
+            group: 'order',
+            kind: 'single',
+            sourceName: 'order',
+            valueOptions: vitest_1.expect.arrayContaining([
+                { name: 'Created At Ascending', value: 'created_at' },
+                { name: 'Created At Descending', value: '-created_at' },
+            ]),
+        });
+    });
+    (0, vitest_1.it)('renders grouped query options as multi-value fixed collections', () => {
+        const node = new entrypoint.PlanningCenterPeople();
+        const filterProperty = node.description.properties.find((property) => property.name === 'getFormsFormIdFormSubmissions_filter');
+        const orderProperty = node.description.properties.find((property) => property.name === 'getFormsFormIdFormSubmissions_order');
+        const includeProperty = node.description.properties.find((property) => property.name === 'getFormsFormIdFormSubmissions_include');
+        (0, vitest_1.expect)(filterProperty).toMatchObject({
+            displayName: 'Filter',
+            placeholder: 'Filter by',
+            typeOptions: { multipleValues: true },
+        });
+        (0, vitest_1.expect)(orderProperty).toMatchObject({
+            displayName: 'Order',
+            placeholder: 'Order by',
+            typeOptions: { multipleValues: true },
+        });
+        (0, vitest_1.expect)(includeProperty).toMatchObject({
+            displayName: 'Include',
+            placeholder: 'Include data',
+            typeOptions: { multipleValues: true },
+        });
+        const orderOption = orderProperty.options.find((option) => option.name === 'order');
+        const orderValue = orderOption.values.find((value) => value.name === 'value');
+        (0, vitest_1.expect)(orderValue).toMatchObject({
+            displayName: 'Value',
+            name: 'value',
+            type: 'options',
+            options: vitest_1.expect.arrayContaining([
+                { name: 'Created At Ascending', value: 'created_at' },
+                { name: 'Created At Descending', value: '-created_at' },
+            ]),
+            default: '',
+        });
+    });
+    (0, vitest_1.it)('renders lookup-enabled fields as searchable resource locators with manual ID mode', () => {
+        const node = new entrypoint.PlanningCenterGroups();
+        const groupTypeProperty = node.description.properties.find((property) => property.name === 'getGroupTypesGroupTypeIdGroups_groupTypeId');
+        (0, vitest_1.expect)(groupTypeProperty).toMatchObject({
+            displayName: 'Group Type ID',
+            type: 'resourceLocator',
+            default: { mode: 'list', value: '' },
+            modes: [
+                vitest_1.expect.objectContaining({
+                    displayName: 'List',
+                    name: 'list',
+                    type: 'list',
+                    typeOptions: vitest_1.expect.objectContaining({ searchable: true, searchListMethod: vitest_1.expect.any(String) }),
+                }),
+                vitest_1.expect.objectContaining({ displayName: 'ID', name: 'id', type: 'string' }),
+            ],
+        });
+    });
+    (0, vitest_1.it)('infers lookup metadata for supported single-ID fields and defers multi-ID fields', async () => {
+        const groupsConfig = config_1.generatedProductConfigs.find((config) => config.product === 'groups');
+        (0, vitest_1.expect)(groupsConfig).toBeDefined();
+        const summary = await (0, openapi_1.buildProductGeneration)(groupsConfig);
+        const operations = Object.fromEntries(summary.operations.map((operation) => [operation.id, operation]));
+        const groupTypeGroups = operations.getGroupTypesGroupTypeIdGroups;
+        const campusGroups = operations.getCampusesCampusIdGroups;
+        const campusGroupPatch = operations.patchCampusesCampusIdGroupsGroupId;
+        (0, vitest_1.expect)(groupTypeGroups.pathParameters.find((field) => field.sourceName === 'group_type_id')?.lookup).toMatchObject({
+            sourcePath: '/groups/v2/group_types',
+            parentBindings: [],
+            resultLimit: 25,
+        });
+        (0, vitest_1.expect)(operations.getCampuses.queryOptions.find((option) => option.sourceName === 'where[id]')?.lookup).toMatchObject({
+            sourcePath: '/groups/v2/campuses',
+            searchFilter: 'where[name]',
+        });
+        (0, vitest_1.expect)(campusGroups.queryOptions.find((option) => option.sourceName === 'where[group_type][id]')?.lookup).toMatchObject({
+            sourcePath: '/groups/v2/group_types',
+        });
+        (0, vitest_1.expect)(campusGroupPatch.attributeFields.find((field) => field.sourceName === 'group_type_id')?.lookup).toBeDefined();
+        (0, vitest_1.expect)(campusGroupPatch.relationshipFields.find((field) => field.relationshipName === 'group_type')?.lookup).toBeDefined();
+        (0, vitest_1.expect)(campusGroupPatch.attributeFields.find((field) => field.sourceName === 'tag_ids')?.lookup).toBeUndefined();
+        (0, vitest_1.expect)(summary.operations.flatMap((operation) => operation.relationshipFields).filter((field) => field.multiple && field.lookup)).toEqual([]);
+    });
+    (0, vitest_1.it)('infers split-name lookup metadata for Giving people without a combined search filter', async () => {
+        const givingConfig = config_1.generatedProductConfigs.find((config) => config.product === 'giving');
+        (0, vitest_1.expect)(givingConfig).toBeDefined();
+        const summary = await (0, openapi_1.buildProductGeneration)(givingConfig);
+        const operation = summary.operations.find((candidate) => candidate.id === 'getPeoplePersonIdDonations');
+        const lookup = operation?.pathParameters.find((field) => field.sourceName === 'person_id')?.lookup;
+        (0, vitest_1.expect)(operation?.operation).toBe('List Donations (via Person)');
+        (0, vitest_1.expect)(lookup).toMatchObject({
+            sourcePath: '/giving/v2/people',
+            searchFilter: undefined,
+            splitNameSearch: {
+                firstNameFilter: 'where[first_name]',
+                lastNameFilter: 'where[last_name]',
+            },
+        });
+        (0, vitest_1.expect)(lookup?.labelFields).toEqual([
+            'name',
+            'full_name',
+            'display_name',
+            'search_name',
+            'path_name',
+            'first_name last_name',
+            'given_name last_name',
+            'nickname last_name',
+            'title',
+            'subject',
+            'label',
+        ]);
+    });
+    (0, vitest_1.it)('uses generated list-search methods with limits, search filters, labels, and parent bindings', async () => {
+        const node = new entrypoint.PlanningCenterGroups();
+        const httpRequest = vitest_1.vi.fn().mockResolvedValue({
+            data: [
+                { id: '1', type: 'Campus', attributes: { name: 'North' } },
+                { id: '2', type: 'Campus', attributes: { title: 'Fallback Title' } },
+            ],
+        });
+        const context = {
+            getCredentials: vitest_1.vi.fn().mockResolvedValue({
+                applicationId: 'app-id',
+                secret: 'secret',
+                baseUrl: 'https://api.example.test',
+            }),
+            getNode: () => ({ name: 'Planning Center Groups', type: 'planningCenterGroups' }),
+            getNodeParameter: vitest_1.vi.fn((name, fallback) => {
+                if (name === 'getCampusesCampusIdGroupsGroupId_campusId')
+                    return { __rl: true, mode: 'list', value: '12' };
+                return fallback;
+            }),
+            helpers: { httpRequest },
+        };
+        await (0, vitest_1.expect)(node.methods.listSearch.searchGetCampusesCampusIdGroupsGroupIdGroupId.call(context, 'small')).resolves.toEqual({
+            results: [
+                { name: 'North (1)', value: '1' },
+                { name: 'Fallback Title (2)', value: '2' },
+            ],
+        });
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            url: 'https://api.example.test/groups/v2/campuses/12/groups',
+            qs: { per_page: 25, 'where[name]': 'small' },
+        }));
+        context.getNodeParameter = vitest_1.vi.fn((_name, fallback) => fallback);
+        httpRequest.mockClear();
+        await (0, vitest_1.expect)(node.methods.listSearch.searchGetCampusesCampusIdGroupsGroupIdGroupId.call(context, 'small')).resolves.toEqual({
+            results: [],
+        });
+        (0, vitest_1.expect)(httpRequest).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('uses bounded split-name lookup search for Giving person locators', async () => {
+        const node = new entrypoint.PlanningCenterGiving();
+        const firstNamePeople = Array.from({ length: 24 }, (_, index) => ({
+            id: String(index + 1),
+            type: 'Person',
+            attributes: { first_name: `First${index + 1}`, last_name: 'Match' },
+        }));
+        const httpRequest = vitest_1.vi.fn((request) => {
+            if (request.qs?.['where[first_name]']) {
+                return Promise.resolve({ data: firstNamePeople });
+            }
+            if (request.qs?.['where[last_name]']) {
+                return Promise.resolve({
+                    data: [
+                        { id: '2', type: 'Person', attributes: { first_name: 'Duplicate', last_name: 'Match' } },
+                        { id: '25', type: 'Person', attributes: { first_name: 'Last25', last_name: 'Match' } },
+                        { id: '26', type: 'Person', attributes: { first_name: 'Last26', last_name: 'Match' } },
+                    ],
+                });
+            }
+            return Promise.resolve({ data: [] });
+        });
+        const context = {
+            getCredentials: vitest_1.vi.fn().mockResolvedValue({
+                applicationId: 'app-id',
+                secret: 'secret',
+                baseUrl: 'https://api.example.test',
+            }),
+            getNode: () => ({ name: 'Planning Center Giving', type: 'planningCenterGiving' }),
+            getNodeParameter: vitest_1.vi.fn((_name, fallback) => fallback),
+            helpers: { httpRequest },
+        };
+        await (0, vitest_1.expect)(node.methods.listSearch.searchGetPeoplePersonIdDonationsPersonId.call(context, 'Ada Lovelace')).resolves.toEqual({
+            results: [
+                ...firstNamePeople.map((person) => ({ name: `${person.attributes.first_name} ${person.attributes.last_name} (${person.id})`, value: person.id })),
+                { name: 'Last25 Match (25)', value: '25' },
+            ],
+        });
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(httpRequest).toHaveBeenNthCalledWith(1, vitest_1.expect.objectContaining({
+            url: 'https://api.example.test/giving/v2/people',
+            qs: { per_page: 25, 'where[first_name]': 'Ada' },
+        }));
+        (0, vitest_1.expect)(httpRequest).toHaveBeenNthCalledWith(2, vitest_1.expect.objectContaining({
+            url: 'https://api.example.test/giving/v2/people',
+            qs: { per_page: 25, 'where[last_name]': 'Lovelace' },
+        }));
+        httpRequest.mockClear();
+        await node.methods.listSearch.searchGetPeoplePersonIdDonationsPersonId.call(context, 'Ada');
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(httpRequest).toHaveBeenNthCalledWith(1, vitest_1.expect.objectContaining({ qs: { per_page: 25, 'where[first_name]': 'Ada' } }));
+        (0, vitest_1.expect)(httpRequest).toHaveBeenNthCalledWith(2, vitest_1.expect.objectContaining({ qs: { per_page: 25, 'where[last_name]': 'Ada' } }));
+    });
+    (0, vitest_1.it)('uses one unfiltered request for initial Giving person locator results', async () => {
+        const node = new entrypoint.PlanningCenterGiving();
+        const httpRequest = vitest_1.vi.fn().mockResolvedValue({
+            data: [{ id: '1', type: 'Person', attributes: { first_name: 'Ada', last_name: 'Lovelace' } }],
+        });
+        const context = {
+            getCredentials: vitest_1.vi.fn().mockResolvedValue({
+                applicationId: 'app-id',
+                secret: 'secret',
+                baseUrl: 'https://api.example.test',
+            }),
+            getNode: () => ({ name: 'Planning Center Giving', type: 'planningCenterGiving' }),
+            getNodeParameter: vitest_1.vi.fn((_name, fallback) => fallback),
+            helpers: { httpRequest },
+        };
+        await (0, vitest_1.expect)(node.methods.listSearch.searchGetPeoplePersonIdDonationsPersonId.call(context, '')).resolves.toEqual({
+            results: [{ name: 'Ada Lovelace (1)', value: '1' }],
+        });
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            url: 'https://api.example.test/giving/v2/people',
+            qs: { per_page: 25 },
+        }));
+    });
+    (0, vitest_1.it)('executes lookup-enabled path, query, attribute, and relationship fields as IDs', async () => {
+        const node = new entrypoint.PlanningCenterGroups();
+        const httpRequest = vitest_1.vi.fn().mockResolvedValue({ data: { id: '34', type: 'Group' } });
+        const context = {
+            continueOnFail: () => false,
+            getCredentials: vitest_1.vi.fn().mockResolvedValue({
+                applicationId: 'app-id',
+                secret: 'secret',
+                baseUrl: 'https://api.example.test',
+            }),
+            getInputData: () => [{ json: {} }],
+            getNode: () => ({ name: 'Planning Center Groups', type: 'planningCenterGroups' }),
+            getNodeParameter: vitest_1.vi.fn((name, _itemIndex, fallback) => {
+                if (name === 'resource')
+                    return 'Campus';
+                if (name === 'operation')
+                    return 'patchCampusesCampusIdGroupsGroupId';
+                if (name === 'patchCampusesCampusIdGroupsGroupId_campusId')
+                    return { __rl: true, mode: 'list', value: '12' };
+                if (name === 'patchCampusesCampusIdGroupsGroupId_groupId')
+                    return { __rl: true, mode: 'id', value: '34' };
+                if (name === 'patchCampusesCampusIdGroupsGroupId_include')
+                    return { include: [{ value: 'group_type' }] };
+                if (name === 'bodyMode')
+                    return 'fields';
+                if (name === 'patchCampusesCampusIdGroupsGroupId_groupTypeId')
+                    return { __rl: true, mode: 'list', value: '56' };
+                if (name === 'patchCampusesCampusIdGroupsGroupId_groupTypeIds')
+                    return { __rl: true, mode: 'list', value: '78' };
+                if (name === 'additionalQueryParameters')
+                    return fallback;
+                return fallback;
+            }),
+            helpers: { httpRequest },
+        };
+        await (0, vitest_1.expect)(node.execute.call(context)).resolves.toEqual([[vitest_1.expect.objectContaining({ json: vitest_1.expect.any(Object) })]]);
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            method: 'PATCH',
+            url: 'https://api.example.test/groups/v2/campuses/12/groups/34',
+            qs: { include: 'group_type' },
+            body: {
+                data: {
+                    type: 'Campus',
+                    attributes: { group_type_id: '56' },
+                    relationships: { group_type: { data: { type: 'GroupType', id: '78' } } },
+                },
+            },
+        }));
+    });
+    (0, vitest_1.it)('labels assignable attributes and relationships explicitly in body fields', () => {
+        const node = new entrypoint.PlanningCenterPeople();
+        const labelsByName = Object.fromEntries(node.description.properties
+            .filter((property) => String(property.name).startsWith('patchFieldDataFieldDatumId_fieldDefinition'))
+            .map((property) => [property.name, property.displayName]));
+        (0, vitest_1.expect)(labelsByName).toMatchObject({
+            patchFieldDataFieldDatumId_fieldDefinitionId: 'Attribute: Field Definition ID',
+            patchFieldDataFieldDatumId_fieldDefinitionIds: 'Relationship: Field Definition ID',
+        });
+    });
+    (0, vitest_1.it)('normalizes identifier acronym capitalization across generated labels', async () => {
+        const summaries = await Promise.all(config_1.generatedProductConfigs.map(openapi_1.buildProductGeneration));
+        const mixedCaseIdentifierToken = /\bId(?:s)?\b/;
+        const summaryLabels = summaries.flatMap((summary) => summary.operations.flatMap((operation) => [
+            ...operation.pathParameters.map((field) => `${summary.product}:${operation.id}:path:${field.displayName}`),
+            ...operation.queryParameters.map((field) => `${summary.product}:${operation.id}:query:${field.displayName}`),
+            ...operation.attributeFields.map((field) => `${summary.product}:${operation.id}:attribute:${field.displayName}`),
+            ...operation.relationshipFields.map((field) => `${summary.product}:${operation.id}:relationship:${field.displayName}`),
+            ...operation.queryOptions.map((option) => `${summary.product}:${operation.id}:option:${option.displayName}`),
+            ...operation.queryOptions.flatMap((option) => (option.valueOptions ?? []).map((valueOption) => `${summary.product}:${operation.id}:value-option:${valueOption.name}`)),
+        ]));
+        const nodeLabels = generatedNodeClasses
+            .map((NodeClass) => new NodeClass())
+            .flatMap((node) => collectDisplayNames(node.description.properties).map((label) => `${node.description.name}:${label}`));
+        const mixedCaseLabels = [...summaryLabels, ...nodeLabels].filter((entry) => mixedCaseIdentifierToken.test(entry));
+        (0, vitest_1.expect)(mixedCaseLabels).toEqual([]);
+    });
+    (0, vitest_1.it)('executes form submission list when optional numeric query filters are unset', async () => {
+        const node = new entrypoint.PlanningCenterPeople();
+        const httpRequest = vitest_1.vi.fn().mockResolvedValue({ data: [] });
+        const missingNumberParameter = 'getFormsFormIdFormSubmissions_wherepersongrade';
+        const context = {
+            continueOnFail: () => false,
+            getCredentials: vitest_1.vi.fn().mockResolvedValue({
+                applicationId: 'app-id',
+                secret: 'secret',
+                baseUrl: 'https://api.example.test',
+            }),
+            getInputData: () => [{ json: {} }],
+            getNode: () => ({ name: 'Planning Center People', type: 'planningCenterPeople' }),
+            getNodeParameter: vitest_1.vi.fn((name, _itemIndex, fallback) => {
+                if (name === 'resource')
+                    return 'Form';
+                if (name === 'operation')
+                    return 'getFormsFormIdFormSubmissions';
+                if (name === 'getFormsFormIdFormSubmissions_formId')
+                    return '123';
+                if (name === 'getFormsFormIdFormSubmissions_filter')
+                    return fallback;
+                if (name === 'getFormsFormIdFormSubmissions_order')
+                    return fallback;
+                if (name === 'getFormsFormIdFormSubmissions_include')
+                    return fallback;
+                if (name === 'additionalQueryParameters')
+                    return fallback;
+                if (name === 'getFormsFormIdFormSubmissions_returnAll')
+                    return false;
+                if (name === 'getFormsFormIdFormSubmissions_limit')
+                    return 1;
+                if (name === missingNumberParameter && fallback === undefined) {
+                    throw new Error(`Could not get parameter "${missingNumberParameter}"`);
+                }
+                return fallback;
+            }),
+            helpers: { httpRequest },
+        };
+        await (0, vitest_1.expect)(node.execute.call(context)).resolves.toEqual([[]]);
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            url: 'https://api.example.test/people/v2/forms/123/form_submissions',
+            qs: { per_page: 1 },
+        }));
+    });
+    (0, vitest_1.it)('maps selected query options to Planning Center query parameters', async () => {
+        const node = new entrypoint.PlanningCenterPeople();
+        const httpRequest = vitest_1.vi.fn().mockResolvedValue({ data: [] });
+        const context = {
+            continueOnFail: () => false,
+            getCredentials: vitest_1.vi.fn().mockResolvedValue({
+                applicationId: 'app-id',
+                secret: 'secret',
+                baseUrl: 'https://api.example.test',
+            }),
+            getInputData: () => [{ json: {} }],
+            getNode: () => ({ name: 'Planning Center People', type: 'planningCenterPeople' }),
+            getNodeParameter: vitest_1.vi.fn((name, _itemIndex, fallback) => {
+                if (name === 'resource')
+                    return 'Form';
+                if (name === 'operation')
+                    return 'getFormsFormIdFormSubmissions';
+                if (name === 'getFormsFormIdFormSubmissions_formId')
+                    return '123';
+                if (name === 'getFormsFormIdFormSubmissions_filter') {
+                    return {
+                        wherecreatedAtFilter: [
+                            { operator: 'gte', value: '2026-01-01T00:00:00Z' },
+                            { operator: 'lte', value: '2026-01-31T23:59:59Z' },
+                        ],
+                        wherepersonid: [{ value: '456' }],
+                    };
+                }
+                if (name === 'getFormsFormIdFormSubmissions_order')
+                    return { order: [{ value: '-created_at' }] };
+                if (name === 'getFormsFormIdFormSubmissions_include')
+                    return { include: [{ value: 'person' }] };
+                if (name === 'additionalQueryParameters')
+                    return fallback;
+                if (name === 'getFormsFormIdFormSubmissions_returnAll')
+                    return false;
+                if (name === 'getFormsFormIdFormSubmissions_limit')
+                    return 1;
+                return fallback;
+            }),
+            helpers: { httpRequest },
+        };
+        await (0, vitest_1.expect)(node.execute.call(context)).resolves.toEqual([[]]);
+        (0, vitest_1.expect)(httpRequest).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            qs: {
+                per_page: 1,
+                'where[created_at][gte]': '2026-01-01T00:00:00Z',
+                'where[created_at][lte]': '2026-01-31T23:59:59Z',
+                'where[person][id]': '456',
+                include: 'person',
+                order: '-created_at',
+            },
+        }));
+    });
+});
+//# sourceMappingURL=generator.test.js.map