n8n-nodes-formbase 0.9.2 → 0.10.0

package/dist/nodes/Formbase/Formbase.node.js

@@ -1,182 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Formbase = void 0;
-const node_crypto_1 = require("node:crypto");
 const n8n_workflow_1 = require("n8n-workflow");
+const RequestDescription_1 = require("./actions/RequestDescription");
+const RequestOperations_1 = require("./actions/RequestOperations");
 const constants_1 = require("./constants");
 const FormbaseCatalog_1 = require("./FormbaseCatalog");
-const GenericFunctions_1 = require("./GenericFunctions");
+const FormbaseMethods_1 = require("./FormbaseMethods");
 const NodeErrors_1 = require("./NodeErrors");
-function fieldOption(field) {
-    const name = field.title ? `${field.title} (${field.key})` : field.key;
-    return { name, value: field.key };
-}
-function isPrefillable(field) {
-    if (field.context === true)
-        return false;
-    if (field.calculated === true)
-        return false;
-    return field.prefillable !== false;
-}
-function readPairs(context, parameter, itemIndex) {
-    var _a;
-    const collection = context.getNodeParameter(parameter, itemIndex, {});
-    const values = {};
-    for (const pair of (_a = collection.values) !== null && _a !== void 0 ? _a : []) {
-        if (!pair.key) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Every ${parameter} entry needs a field key`, { itemIndex });
-        }
-        if (pair.key in values) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Field key "${pair.key}" is listed twice in ${parameter}`, { itemIndex });
-        }
-        values[pair.key] = pair.json ? parseJsonValue(context, pair.value, `${parameter} value for "${pair.key}"`, itemIndex) : pair.value;
-    }
-    return values;
-}
-function parseJsonValue(context, value, what, itemIndex) {
-    if (typeof value !== 'string')
-        return value;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `The ${what} is not valid JSON`, { itemIndex });
-    }
-}
-function readMetadata(context, metadata, itemIndex) {
-    if (metadata === undefined || metadata === '')
-        return undefined;
-    const parsed = parseJsonValue(context, metadata, 'metadata', itemIndex);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Metadata must be a JSON object', { itemIndex });
-    }
-    return parsed;
-}
-function readExpiresAt(context, expiresAt, itemIndex) {
-    const timestamp = Date.parse(expiresAt);
-    if (Number.isNaN(timestamp)) {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Expires At "${expiresAt}" is not a date`, { itemIndex });
-    }
-    return timestamp;
-}
-function readReminders(reminders) {
-    return reminders
-        .split(',')
-        .map((offset) => offset.trim())
-        .filter((offset) => offset.length > 0);
-}
-function readResumeUrl(context, itemIndex) {
-    const resumeUrl = context.evaluateExpression('{{ $execution.resumeUrl }}', itemIndex);
-    if (typeof resumeUrl !== 'string' || resumeUrl.length === 0) {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'n8n did not provide a resume URL for this execution. Turn off "Wait for the Outcome", or run the workflow where a Wait node set to "On Webhook Call" can resume it.', { itemIndex });
-    }
-    return resumeUrl;
-}
-async function uploadDocuments(context, formId, itemIndex) {
-    var _a, _b, _c;
-    const collection = context.getNodeParameter('documents', itemIndex, {});
-    const documents = [];
-    for (const row of (_a = collection.values) !== null && _a !== void 0 ? _a : []) {
-        const binaryProperty = (_b = row.binaryProperty) === null || _b === void 0 ? void 0 : _b.trim();
-        if (!binaryProperty) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Every document needs the name of an input binary field', { itemIndex });
-        }
-        const binary = context.helpers.assertBinaryData(itemIndex, binaryProperty);
-        const bytes = await context.helpers.getBinaryDataBuffer(itemIndex, binaryProperty);
-        const name = ((_c = row.name) === null || _c === void 0 ? void 0 : _c.trim()) || binary.fileName;
-        if (!name) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `The file in "${binaryProperty}" has no file name; set a Name for it`, { itemIndex });
-        }
-        const reserved = await (0, GenericFunctions_1.formbaseApiRequest)(context, 'documents.create', {
-            formId,
-            name,
-            contentType: binary.mimeType,
-            size: bytes.length,
-            sha256: (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex'),
-        });
-        await context.helpers.httpRequest({
-            method: 'PUT',
-            url: reserved.uploadUrl,
-            body: bytes,
-            headers: { 'Content-Type': binary.mimeType },
-        });
-        documents.push({ documentId: reserved.id, ...(row.field ? { field: row.field } : {}) });
-    }
-    return documents;
-}
-async function buildCreateParams(context, itemIndex) {
-    const formId = context.getNodeParameter('formId', itemIndex);
-    const recipientEmail = context.getNodeParameter('recipientEmail', itemIndex, '');
-    const readonly = context.getNodeParameter('readonly', itemIndex, []);
-    const waitForOutcome = context.getNodeParameter('waitForOutcome', itemIndex, false);
-    const additional = context.getNodeParameter('additionalFields', itemIndex, {});
-    if (waitForOutcome && additional.callbackUrl) {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), '"Wait for the Outcome" already sets the callback URL. Turn it off to use a Callback URL of your own.', { itemIndex });
-    }
-    const callbackUrl = waitForOutcome ? readResumeUrl(context, itemIndex) : additional.callbackUrl;
-    const prefill = readPairs(context, 'prefill', itemIndex);
-    const requestContext = readPairs(context, 'context', itemIndex);
-    const metadata = readMetadata(context, additional.metadata, itemIndex);
-    const expiresAt = additional.expiresAt ? readExpiresAt(context, additional.expiresAt, itemIndex) : undefined;
-    const documents = await uploadDocuments(context, formId, itemIndex);
-    const recipient = {
-        ...(recipientEmail ? { email: recipientEmail } : {}),
-        ...(additional.recipientName ? { name: additional.recipientName } : {}),
+function createFieldLookup(context) {
+    const byForm = new Map();
+    return (formId) => {
+        const cached = byForm.get(formId);
+        if (cached)
+            return cached;
+        const fields = (0, FormbaseCatalog_1.listFields)(context, formId);
+        byForm.set(formId, fields);
+        return fields;
     };
-    return {
-        formId,
-        ...(Object.keys(recipient).length > 0 ? { recipient } : {}),
-        ...(Object.keys(prefill).length > 0 ? { prefill } : {}),
-        ...(Object.keys(requestContext).length > 0 ? { context: requestContext } : {}),
-        ...(readonly.length > 0 ? { readonly } : {}),
-        ...(documents.length > 0 ? { documents } : {}),
-        ...(additional.language ? { language: additional.language } : {}),
-        ...(additional.delivery ? { delivery: additional.delivery } : {}),
-        ...(additional.reminders !== undefined ? { reminders: readReminders(additional.reminders) } : {}),
-        ...(expiresAt !== undefined ? { expiresAt } : {}),
-        ...(additional.externalId ? { externalId: additional.externalId, idempotencyKey: additional.externalId } : {}),
-        ...(metadata ? { metadata } : {}),
-        ...(callbackUrl ? { callbackUrl } : {}),
-        ...(additional.test ? { test: true } : {}),
-    };
-}
-async function listRequests(context, itemIndex) {
-    const returnAll = context.getNodeParameter('returnAll', itemIndex);
-    const max = returnAll ? Number.POSITIVE_INFINITY : context.getNodeParameter('limit', itemIndex);
-    const scope = context.getNodeParameter('scope', itemIndex);
-    const filters = context.getNodeParameter('filters', itemIndex, {});
-    const scopeParams = scope === 'form'
-        ? { formId: context.getNodeParameter('formId', itemIndex) }
-        : { workspaceId: (await (0, FormbaseCatalog_1.readWorkspace)(context)).id };
-    return (0, FormbaseCatalog_1.collectPages)(context, 'requests.list', {
-        ...scopeParams,
-        ...(filters.status ? { status: filters.status } : {}),
-        ...(filters.outcome ? { outcome: filters.outcome } : {}),
-        ...(filters.externalId ? { externalId: filters.externalId } : {}),
-        ...(filters.includeTest ? { includeTest: true } : {}),
-    }, max);
-}
-async function runOperation(context, operation, itemIndex) {
-    if (operation === 'create') {
-        return (0, GenericFunctions_1.formbaseApiRequest)(context, 'requests.create', await buildCreateParams(context, itemIndex));
-    }
-    if (operation === 'getAll')
-        return listRequests(context, itemIndex);
-    const requestId = context.getNodeParameter('requestId', itemIndex);
-    if (operation === 'get')
-        return (0, GenericFunctions_1.formbaseApiRequest)(context, 'requests.get', { requestId });
-    if (operation === 'remind')
-        return (0, GenericFunctions_1.formbaseApiRequest)(context, 'requests.remind', { requestId });
-    if (operation === 'replayCallback') {
-        return (0, GenericFunctions_1.formbaseApiRequest)(context, 'requests.replayCallback', { requestId });
-    }
-    if (operation === 'cancel') {
-        const reason = context.getNodeParameter('reason', itemIndex, '');
-        return (0, GenericFunctions_1.formbaseApiRequest)(context, 'requests.cancel', { requestId, ...(reason ? { reason } : {}) });
-    }
-    throw new n8n_workflow_1.NodeOperationError(context.getNode(), `The operation "${String(operation)}" is not supported`, { itemIndex });
 }
-const REQUEST_ID_OPERATIONS = ['cancel', 'get', 'remind', 'replayCallback'];
 class Formbase {
     constructor() {
         this.description = {
@@ -184,7 +26,8 @@ class Formbase {
             name: 'formbase',
             icon: { light: 'file:formbase-logo.svg', dark: 'file:formbase-logo.dark.svg' },
             group: ['transform'],
-            version: 1,
+            version: [1, 2],
+            defaultVersion: 2,
             subtitle: '={{ $parameter["operation"] + ": " + $parameter["resource"] }}',
             description: 'Create, read, cancel and remind formbase requests, and pause a workflow until a customer completes one',
             defaults: {
@@ -195,588 +38,26 @@ class Formbase {
             usableAsTool: true,
             credentials: [
                 {
-                    name: constants_1.FORMBASE_OAUTH2_CREDENTIAL_NAME,
-                    required: true,
-                },
-            ],
-            properties: [
-                {
-                    displayName: 'Resource',
-                    name: 'resource',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Request',
-                            value: 'request',
-                        },
-                    ],
-                    default: 'request',
-                },
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                        },
-                    },
-                    options: [
-                        {
-                            name: 'Cancel',
-                            value: 'cancel',
-                            action: 'Cancel a request',
-                            description: 'Withdraw a pending request so its link stops working',
-                        },
-                        {
-                            name: 'Create',
-                            value: 'create',
-                            action: 'Create a request',
-                            description: 'Ask one recipient to complete a published form',
-                        },
-                        {
-                            name: 'Get',
-                            value: 'get',
-                            action: 'Get a request',
-                            description: 'Read a request, with its answers once it is completed',
-                        },
-                        {
-                            name: 'Get Many',
-                            value: 'getAll',
-                            action: 'Get many requests',
-                            description: 'List the requests of a form or of the workspace',
-                        },
-                        {
-                            name: 'Remind',
-                            value: 'remind',
-                            action: 'Remind a request recipient',
-                            description: 'Email the recipient a reminder now, outside the reminder schedule',
-                        },
-                        {
-                            name: 'Replay Callback',
-                            value: 'replayCallback',
-                            action: 'Replay a request callback',
-                            description: 'Send the callback of a completed, expired or canceled request again',
-                        },
-                    ],
-                    default: 'create',
-                },
-                {
-                    displayName: 'Form Name or ID',
-                    name: 'formId',
-                    type: 'options',
-                    typeOptions: {
-                        loadOptionsMethod: 'getForms',
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: '',
-                    required: true,
-                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                },
-                {
-                    displayName: 'Recipient Email',
-                    name: 'recipientEmail',
-                    type: 'string',
-                    placeholder: 'name@email.com',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: '',
-                    description: 'Who the request is for. Needed to send the invitation email and reminders.',
-                },
-                {
-                    displayName: 'Prefill',
-                    name: 'prefill',
-                    type: 'fixedCollection',
-                    placeholder: 'Add Answer',
-                    typeOptions: {
-                        multipleValues: true,
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: {},
-                    description: 'Initial answers the recipient sees, keyed by field key',
-                    options: [
-                        {
-                            name: 'values',
-                            displayName: 'Answer',
-                            values: [
-                                {
-                                    displayName: 'Field Name or ID',
-                                    name: 'key',
-                                    type: 'options',
-                                    typeOptions: {
-                                        loadOptionsMethod: 'getPrefillKeys',
-                                        loadOptionsDependsOn: ['formId'],
-                                    },
-                                    default: '',
-                                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                                },
-                                {
-                                    displayName: 'Value',
-                                    name: 'value',
-                                    type: 'string',
-                                    default: '',
-                                    description: 'Sent as text, or as the value it decodes to when Parse as JSON is on',
-                                },
-                                {
-                                    displayName: 'Parse as JSON',
-                                    name: 'json',
-                                    type: 'boolean',
-                                    default: false,
-                                    description: 'Whether to decode the value as JSON: a number, true or false, a list of option keys, a matrix object or the rows of a repeating group',
-                                },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Context',
-                    name: 'context',
-                    type: 'fixedCollection',
-                    placeholder: 'Add Context Value',
-                    typeOptions: {
-                        multipleValues: true,
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: {},
-                    description: 'Hidden-field values the recipient never sees or edits, keyed by field key and echoed in every callback',
-                    options: [
-                        {
-                            name: 'values',
-                            displayName: 'Context Value',
-                            values: [
-                                {
-                                    displayName: 'Field Name or ID',
-                                    name: 'key',
-                                    type: 'options',
-                                    typeOptions: {
-                                        loadOptionsMethod: 'getContextKeys',
-                                        loadOptionsDependsOn: ['formId'],
-                                    },
-                                    default: '',
-                                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                                },
-                                {
-                                    displayName: 'Value',
-                                    name: 'value',
-                                    type: 'string',
-                                    default: '',
-                                    description: 'Sent as text, or as the value it decodes to when Parse as JSON is on',
-                                },
-                                {
-                                    displayName: 'Parse as JSON',
-                                    name: 'json',
-                                    type: 'boolean',
-                                    default: false,
-                                    description: 'Whether to decode the value as JSON instead of sending it as text',
-                                },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Read-Only Field Names or IDs',
-                    name: 'readonly',
-                    type: 'multiOptions',
-                    typeOptions: {
-                        loadOptionsMethod: 'getPrefillKeys',
-                        loadOptionsDependsOn: ['formId'],
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: [],
-                    description: 'Prefilled fields the recipient may see but not change. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
-                },
-                {
-                    displayName: 'Documents',
-                    name: 'documents',
-                    type: 'fixedCollection',
-                    placeholder: 'Add Document',
-                    typeOptions: {
-                        multipleValues: true,
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: {},
-                    description: 'Files from the input item the recipient gets in the form\'s Documents block, below the documents the form already has. PDF or image, up to 25 MB each.',
-                    options: [
-                        {
-                            name: 'values',
-                            displayName: 'Document',
-                            values: [
-                                {
-                                    displayName: 'Input Binary Field',
-                                    name: 'binaryProperty',
-                                    type: 'string',
-                                    default: 'data',
-                                    required: true,
-                                    hint: 'The name of the input binary field containing the file',
-                                },
-                                {
-                                    displayName: 'Name',
-                                    name: 'name',
-                                    type: 'string',
-                                    default: '',
-                                    description: 'The name the recipient sees. Defaults to the file name.',
-                                },
-                                {
-                                    displayName: 'Documents Block Name or ID',
-                                    name: 'field',
-                                    type: 'options',
-                                    typeOptions: {
-                                        loadOptionsMethod: 'getDocumentsKeys',
-                                        loadOptionsDependsOn: ['formId'],
-                                    },
-                                    default: '',
-                                    description: 'The Documents block the file goes into. Leave empty when the form has one. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
-                                },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Wait for the Outcome',
-                    name: 'waitForOutcome',
-                    type: 'boolean',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: false,
-                    description: 'Whether to point the request callback at this execution\'s resume URL. Follow this node with a Wait node set to "On Webhook Call": the workflow resumes with the request event when the request is completed, expires or is canceled.',
-                },
-                {
-                    displayName: 'Additional Fields',
-                    name: 'additionalFields',
-                    type: 'collection',
-                    placeholder: 'Add Field',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['create'],
-                        },
-                    },
-                    default: {},
-                    options: [
-                        {
-                            displayName: 'Callback URL',
-                            name: 'callbackUrl',
-                            type: 'string',
-                            default: '',
-                            description: 'An HTTPS URL of your own that receives the signed request callback. Leave empty when Wait for the Outcome is on.',
-                        },
-                        {
-                            displayName: 'Delivery',
-                            name: 'delivery',
-                            type: 'options',
-                            options: [
-                                {
-                                    name: 'Email the Invitation',
-                                    value: 'email',
-                                    description: 'Sends the recipient the link by email; needs a recipient email',
-                                },
-                                {
-                                    name: 'None',
-                                    value: 'none',
-                                    description: 'You deliver the returned link yourself',
-                                },
-                            ],
-                            default: 'none',
-                        },
-                        {
-                            displayName: 'Expires At',
-                            name: 'expiresAt',
-                            type: 'dateTime',
-                            default: '',
-                            description: 'When the link stops working. Defaults to 30 days, at most 365.',
-                        },
-                        {
-                            displayName: 'External ID',
-                            name: 'externalId',
-                            type: 'string',
-                            default: '',
-                            description: 'Your ID for this request, such as the run or ticket it belongs to. Also used as the idempotency key, so a retried run reuses the request instead of creating a second one.',
-                        },
-                        {
-                            displayName: 'Language',
-                            name: 'language',
-                            type: 'string',
-                            default: '',
-                            placeholder: 'en',
-                            description: 'Language the form opens in and the invitation is written in; must be published for the form',
-                        },
-                        {
-                            displayName: 'Metadata',
-                            name: 'metadata',
-                            type: 'json',
-                            default: '{}',
-                            description: 'JSON object for your own bookkeeping. Never shown to the recipient, echoed in every callback.',
-                        },
-                        {
-                            displayName: 'Recipient Name',
-                            name: 'recipientName',
-                            type: 'string',
-                            default: '',
-                        },
-                        {
-                            displayName: 'Reminders',
-                            name: 'reminders',
-                            type: 'string',
-                            default: '',
-                            placeholder: '2d, 5d',
-                            description: 'Idle offsets after which to remind the recipient, comma-separated, at most five. Leave empty to send no reminders; remove the field to inherit the form\'s schedule.',
-                        },
-                        {
-                            displayName: 'Test Mode',
-                            name: 'test',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to create a test request: nothing is emailed, the callback carries test: true, and nothing counts against the quota',
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Request ID',
-                    name: 'requestId',
-                    type: 'string',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: REQUEST_ID_OPERATIONS,
-                        },
-                    },
-                    default: '',
-                    required: true,
-                    description: 'The ID formbase returned when the request was created',
-                },
-                {
-                    displayName: 'Reason',
-                    name: 'reason',
-                    type: 'string',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['cancel'],
-                        },
-                    },
-                    default: '',
-                    description: 'Why the request is withdrawn; echoed in the request.canceled callback',
-                },
-                {
-                    displayName: 'Return All',
-                    name: 'returnAll',
-                    type: 'boolean',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['getAll'],
-                        },
-                    },
-                    default: false,
-                    description: 'Whether to return all results or only up to a given limit',
-                },
-                {
-                    displayName: 'Limit',
-                    name: 'limit',
-                    type: 'number',
-                    typeOptions: {
-                        minValue: 1,
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['getAll'],
-                            returnAll: [false],
-                        },
-                    },
-                    default: 50,
-                    description: 'Max number of results to return',
-                },
-                {
-                    displayName: 'Scope',
-                    name: 'scope',
-                    type: 'options',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['getAll'],
-                        },
-                    },
-                    options: [
-                        {
-                            name: 'Form',
-                            value: 'form',
-                            description: 'The requests of one form',
-                        },
-                        {
-                            name: 'Workspace',
-                            value: 'workspace',
-                            description: 'Every request of the connected workspace',
-                        },
-                    ],
-                    default: 'form',
-                },
-                {
-                    displayName: 'Form Name or ID',
-                    name: 'formId',
-                    type: 'options',
-                    typeOptions: {
-                        loadOptionsMethod: 'getForms',
-                    },
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['getAll'],
-                            scope: ['form'],
-                        },
-                    },
-                    default: '',
+                    name: constants_1.FORMBASE_CREDENTIAL_TYPE,
                     required: true,
-                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                },
-                {
-                    displayName: 'Filters',
-                    name: 'filters',
-                    type: 'collection',
-                    placeholder: 'Add Filter',
-                    displayOptions: {
-                        show: {
-                            resource: ['request'],
-                            operation: ['getAll'],
-                        },
-                    },
-                    default: {},
-                    options: [
-                        {
-                            displayName: 'External ID',
-                            name: 'externalId',
-                            type: 'string',
-                            default: '',
-                            description: 'Only the requests created with this external ID',
-                        },
-                        {
-                            displayName: 'Include Test Requests',
-                            name: 'includeTest',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to include requests created in test mode',
-                        },
-                        {
-                            displayName: 'Outcome',
-                            name: 'outcome',
-                            type: 'options',
-                            options: [
-                                {
-                                    name: 'Approve',
-                                    value: 'approve',
-                                },
-                                {
-                                    name: 'Changes',
-                                    value: 'changes',
-                                },
-                                {
-                                    name: 'Decline',
-                                    value: 'decline',
-                                },
-                            ],
-                            default: 'approve',
-                            description: 'Only completed requests with this verdict from the decision question; takes precedence over Status',
-                        },
-                        {
-                            displayName: 'Status',
-                            name: 'status',
-                            type: 'options',
-                            options: [
-                                {
-                                    name: 'Canceled',
-                                    value: 'canceled',
-                                },
-                                {
-                                    name: 'Completed',
-                                    value: 'completed',
-                                },
-                                {
-                                    name: 'Expired',
-                                    value: 'expired',
-                                },
-                                {
-                                    name: 'Pending',
-                                    value: 'pending',
-                                },
-                            ],
-                            default: 'pending',
-                        },
-                    ],
                 },
             ],
+            properties: RequestDescription_1.requestProperties,
         };
-        this.methods = {
-            loadOptions: {
-                async getForms() {
-                    const forms = await (0, FormbaseCatalog_1.listForms)(this);
-                    return forms.map((form) => ({ name: form.name, value: form.id }));
-                },
-                async getPrefillKeys() {
-                    const formId = this.getCurrentNodeParameter('formId');
-                    if (typeof formId !== 'string' || !formId)
-                        return [];
-                    const fields = await (0, FormbaseCatalog_1.listFields)(this, formId);
-                    return fields.filter(isPrefillable).map(fieldOption);
-                },
-                async getDocumentsKeys() {
-                    const formId = this.getCurrentNodeParameter('formId');
-                    if (typeof formId !== 'string' || !formId)
-                        return [];
-                    const fields = await (0, FormbaseCatalog_1.listFields)(this, formId);
-                    return fields.filter((field) => field.type === 'documents').map(fieldOption);
-                },
-                async getContextKeys() {
-                    const formId = this.getCurrentNodeParameter('formId');
-                    if (typeof formId !== 'string' || !formId)
-                        return [];
-                    const fields = await (0, FormbaseCatalog_1.listFields)(this, formId);
-                    return fields.filter((field) => field.context === true).map(fieldOption);
-                },
-            },
-        };
+        this.methods = { loadOptions: FormbaseMethods_1.loadOptions, listSearch: FormbaseMethods_1.listSearch, resourceMapping: FormbaseMethods_1.resourceMapping };
     }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
         const operation = this.getNodeParameter('operation', 0);
+        if (!(0, RequestOperations_1.isRequestOperation)(operation)) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not supported`);
+        }
+        const run = RequestOperations_1.REQUEST_OPERATIONS[operation];
+        const fieldsOf = createFieldLookup(this);
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
             try {
-                const data = await runOperation(this, operation, itemIndex);
+                const data = await run(this, itemIndex, fieldsOf);
                 returnData.push(...this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(data), { itemData: { item: itemIndex } }));
             }
             catch (error) {