@lilremark/n8n-nodes-twenty-dynamic 2.2.10

package/dist/nodes/Twenty/Twenty.node.js

@@ -0,0 +1,1629 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Twenty = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const TwentyApi_client_1 = require("./TwentyApi.client");
+const FieldTransformation_1 = require("./FieldTransformation");
+const operations_1 = require("./operations");
+function buildSmartFilter(searchQuery, resource) {
+    const isAdvancedSyntax = /\w+(\.\w+)?\[.+\]:/.test(searchQuery);
+    if (isAdvancedSyntax) {
+        return searchQuery;
+    }
+    const searchValue = searchQuery.trim();
+    const escapedValue = searchValue.replace(/"/g, '\\"');
+    if (resource === 'person') {
+        return `or(name.firstName[ilike]:"%${escapedValue}%",name.lastName[ilike]:"%${escapedValue}%")`;
+    }
+    return `name[ilike]:"%${escapedValue}%"`;
+}
+class Twenty {
+    constructor() {
+        this.description = {
+            displayName: 'Twenty CRM - Dynamic',
+            name: 'twenty',
+            icon: 'file:twenty.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with Twenty CRM - supporting standard and custom data models - dynamically adapts to your database schema.',
+            defaults: {
+                name: 'Twenty CRM - Dynamic',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'twentyApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Database Group',
+                    name: 'resourceGroup',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'All Databases',
+                            value: 'all',
+                            description: 'Show all available databases in your Twenty CRM workspace',
+                        },
+                        {
+                            name: 'Custom Databases',
+                            value: 'custom',
+                            description: 'Your user-created custom databases with your own data models',
+                        },
+                        {
+                            name: 'Standard Databases',
+                            value: 'standard',
+                            description: 'Your core Twenty CRM databases (Company, Person, Opportunity, etc.)',
+                        },
+                        {
+                            name: 'System Databases',
+                            value: 'system',
+                            description: 'Hidden Twenty system databases not normally accessible to users - Advanced use only',
+                        },
+                    ],
+                    default: 'standard',
+                    required: true,
+                    description: 'Filter databases by group to narrow down the selection',
+                },
+                {
+                    displayName: 'Database Name or ID',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    typeOptions: {
+                        loadOptionsMethod: 'getResources',
+                        loadOptionsDependsOn: ['resourceGroup'],
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a new record',
+                            action: 'Create a record',
+                        },
+                        {
+                            name: 'Create Many',
+                            value: 'createMany',
+                            description: 'Create multiple new records at once',
+                            action: 'Create many records',
+                        },
+                        {
+                            name: 'Create or Update',
+                            value: 'upsert',
+                            description: 'Create a new record, or update the current one if it already exists (upsert)',
+                            action: 'Create or update a record',
+                        },
+                        {
+                            name: 'Create or Update Many',
+                            value: 'upsertMany',
+                            description: 'Create or update multiple records at once',
+                            action: 'Create or update many records',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a record by ID',
+                            action: 'Delete a record',
+                        },
+                        {
+                            name: 'Delete Many',
+                            value: 'deleteMany',
+                            description: 'Delete multiple records by IDs',
+                            action: 'Delete many records',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Retrieve a single record by ID',
+                            action: 'Get a record',
+                        },
+                        {
+                            name: 'Get Many',
+                            value: 'getMany',
+                            description: 'Retrieve multiple records by IDs',
+                            action: 'Get many records',
+                        },
+                        {
+                            name: 'List/Search',
+                            value: 'findMany',
+                            description: 'Get multiple records with optional filters',
+                            action: 'List records',
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            description: 'Update an existing record',
+                            action: 'Update a record',
+                        },
+                        {
+                            name: 'Update Many',
+                            value: 'updateMany',
+                            description: 'Update multiple records at once',
+                            action: 'Update many records',
+                        },
+                    ],
+                    default: 'create',
+                    required: true,
+                },
+                {
+                    displayName: 'Record',
+                    name: 'recordId',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['get'],
+                        },
+                    },
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            placeholder: 'Select a record...',
+                            typeOptions: {
+                                searchListMethod: 'getRecordsForDatabase',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'By URL',
+                            name: 'url',
+                            type: 'string',
+                            placeholder: 'https://app.twenty.com/objects/companies/123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: 'https?://.*?/objects/[^/]+/([a-f0-9-]{36})',
+                                        errorMessage: 'Not a valid Twenty record URL',
+                                    },
+                                },
+                            ],
+                            extractValue: {
+                                type: 'regex',
+                                regex: 'https?://.*?/objects/[^/]+/([a-f0-9-]{36})',
+                            },
+                        },
+                        {
+                            displayName: 'By ID',
+                            name: 'id',
+                            type: 'string',
+                            placeholder: 'e.g., 123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: '^[a-f0-9-]{36}$',
+                                        errorMessage: 'Not a valid UUID',
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                    description: 'The record to retrieve from the selected database',
+                },
+                {
+                    displayName: 'Record',
+                    name: 'recordIdDelete',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['delete'],
+                        },
+                    },
+                    description: 'The record to delete from the selected database. ⚠️ Delete operations are permanent and cannot be undone.',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            hint: 'Select a record from the dropdown list',
+                            typeOptions: {
+                                searchListMethod: 'getRecordsForDatabase',
+                                searchable: true,
+                                searchFilterRequired: false,
+                            },
+                        },
+                        {
+                            displayName: 'By URL',
+                            name: 'url',
+                            type: 'string',
+                            hint: 'Paste the record URL from Twenty CRM',
+                            placeholder: 'https://app.twenty.com/objects/people/123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: 'https?://.*?/objects/[^/]+/[a-f0-9-]{36}',
+                                        errorMessage: 'Not a valid Twenty CRM record URL',
+                                    },
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'By ID',
+                            name: 'id',
+                            type: 'string',
+                            hint: 'Enter the record UUID directly',
+                            placeholder: '123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: '^[a-f0-9-]{36}$',
+                                        errorMessage: 'Not a valid UUID',
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Record',
+                    name: 'recordIdUpdate',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['update'],
+                        },
+                    },
+                    description: 'The record to update in the selected database',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            hint: 'Select a record from the dropdown list',
+                            typeOptions: {
+                                searchListMethod: 'getRecordsForDatabase',
+                                searchable: true,
+                                searchFilterRequired: false,
+                            },
+                        },
+                        {
+                            displayName: 'By URL',
+                            name: 'url',
+                            type: 'string',
+                            hint: 'Paste the record URL from Twenty CRM',
+                            placeholder: 'https://app.twenty.com/objects/people/123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: 'https?://.*?/objects/[^/]+/[a-f0-9-]{36}',
+                                        errorMessage: 'Not a valid Twenty CRM record URL',
+                                    },
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'By ID',
+                            name: 'id',
+                            type: 'string',
+                            hint: 'Enter the record UUID directly',
+                            placeholder: '123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: '^[a-f0-9-]{36}$',
+                                        errorMessage: 'Not a valid UUID',
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Match By',
+                    name: 'upsertMode',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['upsert'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Record ID',
+                            value: 'id',
+                            description: 'Match by record UUID (if you already know the ID)',
+                        },
+                        {
+                            name: 'Unique Field',
+                            value: 'field',
+                            description: 'Match by a unique field (e.g., email for people, domain for companies)',
+                        },
+                    ],
+                    default: 'field',
+                    description: 'How to determine if a record already exists',
+                },
+                {
+                    displayName: 'Record',
+                    name: 'recordIdUpsert',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['upsert'],
+                            upsertMode: ['id'],
+                        },
+                    },
+                    description: 'The record to update if it exists. If not found, a new record will be created with the provided fields.',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            hint: 'Select a record from the dropdown list',
+                            typeOptions: {
+                                searchListMethod: 'getRecordsForDatabase',
+                                searchable: true,
+                                searchFilterRequired: false,
+                            },
+                        },
+                        {
+                            displayName: 'By URL',
+                            name: 'url',
+                            type: 'string',
+                            hint: 'Paste the record URL from Twenty CRM',
+                            placeholder: 'https://app.twenty.com/objects/people/123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: 'https?://.*?/objects/[^/]+/[a-f0-9-]{36}',
+                                        errorMessage: 'Not a valid Twenty CRM record URL',
+                                    },
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'By ID',
+                            name: 'id',
+                            type: 'string',
+                            hint: 'Enter the record UUID directly',
+                            placeholder: '123e4567-e89b-12d3-a456-426614174000',
+                            validation: [
+                                {
+                                    type: 'regex',
+                                    properties: {
+                                        regex: '^[a-f0-9-]{36}$',
+                                        errorMessage: 'Not a valid UUID',
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Match Field Name or ID',
+                    name: 'upsertMatchField',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getFieldsForResource',
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['upsert'],
+                            upsertMode: ['field'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                    placeholder: 'Select a unique field (e.g., email)',
+                },
+                {
+                    displayName: 'Match Value',
+                    name: 'upsertMatchValue',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['upsert'],
+                            upsertMode: ['field'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The value to search for in the match field',
+                    placeholder: 'e.g., john@example.com',
+                },
+                {
+                    displayName: 'Input Data',
+                    name: 'bulkData',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            operation: ['createMany', 'getMany', 'updateMany', 'deleteMany', 'upsertMany'],
+                        },
+                    },
+                    default: '[]',
+                    required: true,
+                    description: 'Array of data for bulk operation. Format varies by operation - see documentation.',
+                    placeholder: '[{"field1": "value1"}, {"field1": "value2"}]',
+                    hint: 'Provide array of objects. For Create Many: array of field objects. For Get/Delete Many: array of IDs. For Update/Upsert Many: array of objects with id/matchValue and fields.',
+                },
+                {
+                    displayName: 'Match Field Name or ID',
+                    name: 'upsertManyMatchField',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getFieldsForResource',
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['upsertMany'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                    placeholder: 'Select a unique field (e.g., email)',
+                    hint: 'The unique field to match records on. Each item in Input Data should have a matchValue for this field.',
+                },
+                {
+                    displayName: 'Fields',
+                    name: 'fields',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['create', 'update', 'upsert'],
+                        },
+                    },
+                    default: {},
+                    placeholder: 'Add Field',
+                    description: 'The fields to set on the record',
+                    options: [
+                        {
+                            name: 'field',
+                            displayName: 'Field',
+                            values: [
+                                {
+                                    displayName: 'Field Name or ID',
+                                    name: 'fieldName',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getFieldsForResource',
+                                    },
+                                    default: '',
+                                    description: 'The name of the field to set. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                                },
+                                {
+                                    displayName: 'Field Type',
+                                    name: 'fieldType',
+                                    type: 'hidden',
+                                    default: '={{$parameter["&fieldName"].split("|")[1]}}',
+                                    description: 'Auto-detected field type from Twenty CRM schema. Extracted from fieldName value.',
+                                },
+                                {
+                                    displayName: 'Boolean Value',
+                                    name: 'fieldBooleanValue',
+                                    type: 'options',
+                                    options: [
+                                        {
+                                            name: 'True',
+                                            value: true,
+                                        },
+                                        {
+                                            name: 'False',
+                                            value: false,
+                                        },
+                                    ],
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['boolean'],
+                                        },
+                                    },
+                                    default: false,
+                                    description: 'Select True or False',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'fieldValue',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['simple'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'The value to set for this field',
+                                    placeholder: 'Enter value',
+                                },
+                                {
+                                    displayName: 'First Name',
+                                    name: 'firstName',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['fullName'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'First name / given name',
+                                    placeholder: 'John',
+                                },
+                                {
+                                    displayName: 'Last Name',
+                                    name: 'lastName',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['fullName'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Last name / family name',
+                                    placeholder: 'Doe',
+                                },
+                                {
+                                    displayName: 'URL',
+                                    name: 'primaryLinkUrl',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['link'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'The complete URL',
+                                    placeholder: 'https://example.com',
+                                },
+                                {
+                                    displayName: 'Label',
+                                    name: 'primaryLinkLabel',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['link'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Display label for the URL',
+                                    placeholder: 'example.com',
+                                },
+                                {
+                                    displayName: 'Amount',
+                                    name: 'currencyAmount',
+                                    type: 'number',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['currency'],
+                                        },
+                                    },
+                                    default: 0,
+                                    description: 'Amount in your currency (will be converted to micros automatically)',
+                                    placeholder: '100000',
+                                },
+                                {
+                                    displayName: 'Currency Code',
+                                    name: 'currencyCode',
+                                    type: 'options',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['currency'],
+                                        },
+                                    },
+                                    options: [
+                                        { name: 'Australian Dollar (AUD)', value: 'AUD' },
+                                        { name: 'British Pound (GBP)', value: 'GBP' },
+                                        { name: 'Canadian Dollar (CAD)', value: 'CAD' },
+                                        { name: 'Chinese Yuan (CNY)', value: 'CNY' },
+                                        { name: 'Euro (EUR)', value: 'EUR' },
+                                        { name: 'Japanese Yen (JPY)', value: 'JPY' },
+                                        { name: 'Swiss Franc (CHF)', value: 'CHF' },
+                                        { name: 'US Dollar (USD)', value: 'USD' },
+                                    ],
+                                    default: 'USD',
+                                    description: 'Three-letter currency code',
+                                },
+                                {
+                                    displayName: 'Street Address 1',
+                                    name: 'addressStreet1',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Primary street address',
+                                    placeholder: '123 Main Street',
+                                },
+                                {
+                                    displayName: 'Street Address 2',
+                                    name: 'addressStreet2',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Apartment, suite, unit, etc. (optional).',
+                                    placeholder: 'Suite 100',
+                                },
+                                {
+                                    displayName: 'City',
+                                    name: 'addressCity',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'City or locality',
+                                    placeholder: 'New York',
+                                },
+                                {
+                                    displayName: 'Postal Code',
+                                    name: 'addressPostcode',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'ZIP or postal code',
+                                    placeholder: '10001',
+                                },
+                                {
+                                    displayName: 'State / Province',
+                                    name: 'addressState',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'State, province, or region',
+                                    placeholder: 'NY',
+                                },
+                                {
+                                    displayName: 'Country',
+                                    name: 'addressCountry',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Country name',
+                                    placeholder: 'United States',
+                                },
+                                {
+                                    displayName: 'Latitude',
+                                    name: 'addressLat',
+                                    type: 'number',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: undefined,
+                                    description: 'Geographic latitude (optional)',
+                                    placeholder: '40.7128',
+                                },
+                                {
+                                    displayName: 'Longitude',
+                                    name: 'addressLng',
+                                    type: 'number',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['address'],
+                                        },
+                                    },
+                                    default: undefined,
+                                    description: 'Geographic longitude (optional)',
+                                    placeholder: '-74.0060',
+                                },
+                                {
+                                    displayName: 'Primary Email',
+                                    name: 'primaryEmail',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['emails'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Primary email address',
+                                    placeholder: 'john@example.com',
+                                },
+                                {
+                                    displayName: 'Primary Phone Number',
+                                    name: 'primaryPhoneNumber',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['phones'],
+                                        },
+                                    },
+                                    default: '',
+                                    placeholder: '+1-555-0123',
+                                },
+                                {
+                                    displayName: 'Country Code',
+                                    name: 'primaryPhoneCountryCode',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['phones'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Two-letter country code (ISO 3166-1 alpha-2)',
+                                    placeholder: 'US',
+                                },
+                                {
+                                    displayName: 'Calling Code',
+                                    name: 'primaryPhoneCallingCode',
+                                    type: 'string',
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['phones'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'International calling code with plus sign',
+                                    placeholder: '+1',
+                                },
+                                {
+                                    displayName: 'Value Name or ID',
+                                    name: 'fieldSelectValue',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getOptionsForSelectField',
+                                        loadOptionsDependsOn: ['fieldName'],
+                                    },
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['select'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                                },
+                                {
+                                    displayName: 'Values Names or IDs',
+                                    name: 'fieldMultiSelectValue',
+                                    type: 'multiOptions',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getOptionsForSelectField',
+                                        loadOptionsDependsOn: ['fieldName'],
+                                    },
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['multiSelect'],
+                                        },
+                                    },
+                                    default: [],
+                                    description: 'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                                },
+                                {
+                                    displayName: 'Markdown',
+                                    name: 'markdown',
+                                    type: 'string',
+                                    typeOptions: { rows: 4 },
+                                    displayOptions: {
+                                        show: {
+                                            fieldType: ['richText'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Content in Markdown format',
+                                    placeholder: '## Heading\n\nYour content here...',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 1,
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['findMany'],
+                        },
+                    },
+                    default: 50,
+                    description: 'Max number of results to return',
+                },
+                {
+                    displayName: 'Search Query',
+                    name: 'searchQuery',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['findMany'],
+                        },
+                    },
+                    default: '',
+                    placeholder: 'Type a search term or use advanced syntax...',
+                    description: 'Search records by name. Just type a word (e.g., "google") to search by name. For Person database, searches both first and last name automatically. For advanced filtering, use Twenty filter syntax: field[operator]:value (e.g., createdAt[gte]:"2024-01-01"). Operators: eq, neq, like, ilike, gt, gte, lt, lte, in, startsWith, is. Combine with and()/or()/not(). Leave empty to return all records.',
+                },
+                {
+                    displayName: 'Order By Field Name or ID',
+                    name: 'orderByField',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getFieldsForOrderBy',
+                    },
+                    displayOptions: {
+                        show: {
+                            operation: ['findMany'],
+                        },
+                    },
+                    default: '',
+                    description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>',
+                },
+                {
+                    displayName: 'Order Direction',
+                    name: 'orderByDirection',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['findMany'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Ascending (Nulls First)',
+                            value: 'AscNullsFirst',
+                        },
+                        {
+                            name: 'Ascending (Nulls Last)',
+                            value: 'AscNullsLast',
+                        },
+                        {
+                            name: 'Descending (Nulls First)',
+                            value: 'DescNullsFirst',
+                        },
+                        {
+                            name: 'Descending (Nulls Last)',
+                            value: 'DescNullsLast',
+                        },
+                    ],
+                    default: 'AscNullsFirst',
+                    description: 'Sort direction for results',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getResources() {
+                    try {
+                        let resourceGroup = 'all';
+                        try {
+                            resourceGroup = this.getCurrentNodeParameter('resourceGroup');
+                        }
+                        catch {
+                            resourceGroup = 'all';
+                        }
+                        const schema = await TwentyApi_client_1.getCachedSchema.call(this, false);
+                        let filteredObjects = schema.objects;
+                        switch (resourceGroup) {
+                            case 'all':
+                                filteredObjects = schema.objects;
+                                break;
+                            case 'standard':
+                                filteredObjects = schema.objects.filter(obj => obj.isCustom === false && obj.isSystem === false && obj.isActive === true);
+                                break;
+                            case 'system':
+                                filteredObjects = schema.objects.filter(obj => obj.isSystem === true && obj.isCustom === false);
+                                break;
+                            case 'custom':
+                                filteredObjects = schema.objects.filter(obj => obj.isCustom === true);
+                                break;
+                            default:
+                                filteredObjects = schema.objects;
+                        }
+                        const options = filteredObjects.map((obj) => ({
+                            name: obj.labelSingular,
+                            value: obj.nameSingular,
+                            description: obj.isCustom ? '(Custom Database)' : '(Standard Database)',
+                        }));
+                        options.sort((a, b) => {
+                            var _a, _b;
+                            const aIsCustom = ((_a = a.description) === null || _a === void 0 ? void 0 : _a.includes('Custom')) || false;
+                            const bIsCustom = ((_b = b.description) === null || _b === void 0 ? void 0 : _b.includes('Custom')) || false;
+                            if (aIsCustom === bIsCustom) {
+                                return a.name.localeCompare(b.name);
+                            }
+                            return aIsCustom ? 1 : -1;
+                        });
+                        return options;
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load databases from Twenty CRM. Please check your credentials and connection. Error: ${error.message}`);
+                    }
+                },
+                async getFieldsForResource() {
+                    try {
+                        const resource = this.getCurrentNodeParameter('resource');
+                        if (!resource) {
+                            return [];
+                        }
+                        let operation = '';
+                        try {
+                            operation = this.getCurrentNodeParameter('operation');
+                        }
+                        catch {
+                        }
+                        const schema = await TwentyApi_client_1.getCachedSchema.call(this, false);
+                        const objectMeta = schema.objects.find((obj) => obj.nameSingular === resource);
+                        const metadataFields = (objectMeta === null || objectMeta === void 0 ? void 0 : objectMeta.fields) || [];
+                        const graphqlFields = await TwentyApi_client_1.getDataSchemaForObject.call(this, resource);
+                        const fieldMap = new Map();
+                        graphqlFields.forEach((field) => {
+                            fieldMap.set(field.name, {
+                                ...field,
+                                source: 'graphql',
+                            });
+                        });
+                        metadataFields.forEach((field) => {
+                            fieldMap.set(field.name, {
+                                ...field,
+                                source: 'metadata',
+                            });
+                        });
+                        const allFields = Array.from(fieldMap.values());
+                        const EXCLUDED_FIELD_TYPES = new Set([
+                            'RELATION', 'MORPH_RELATION',
+                            'ACTOR',
+                            'TS_VECTOR',
+                            'POSITION',
+                            'FILES',
+                        ]);
+                        const isCreateOrUpdate = operation === 'create' || operation === 'update';
+                        const filteredFields = allFields.filter((field) => {
+                            var _a;
+                            if (field.isActive === false)
+                                return false;
+                            if (EXCLUDED_FIELD_TYPES.has(field.type))
+                                return false;
+                            if ((_a = field.type) === null || _a === void 0 ? void 0 : _a.endsWith('Connection'))
+                                return false;
+                            if (isCreateOrUpdate)
+                                return field.isWritable;
+                            return true;
+                        });
+                        const mapTwentyTypeToN8nType = (twentyType) => {
+                            const typeMap = {
+                                'SELECT': 'select',
+                                'MULTI_SELECT': 'multiSelect',
+                                'FULL_NAME': 'fullName',
+                                'LINKS': 'link',
+                                'CURRENCY': 'currency',
+                                'ADDRESS': 'address',
+                                'FullName': 'fullName',
+                                'Links': 'link',
+                                'Currency': 'currency',
+                                'Address': 'address',
+                                'EMAILS': 'emails',
+                                'PHONES': 'phones',
+                                'RICH_TEXT': 'richText',
+                                'BOOLEAN': 'boolean',
+                                'TEXT': 'simple',
+                                'NUMBER': 'simple',
+                                'DATE_TIME': 'simple',
+                                'DATE': 'simple',
+                                'UUID': 'simple',
+                                'RAW_JSON': 'simple',
+                                'RELATION': 'relation',
+                                'MORPH_RELATION': 'relation',
+                                'ACTOR': 'simple',
+                                'POSITION': 'simple',
+                                'TS_VECTOR': 'simple',
+                                'FILES': 'simple',
+                            };
+                            return typeMap[twentyType] || 'simple';
+                        };
+                        const mapGraphQLTypeToN8nType = (graphqlType) => {
+                            if (graphqlType.startsWith('LIST<') && graphqlType.includes('Enum')) {
+                                return 'multiSelect';
+                            }
+                            if (graphqlType.includes('Enum')) {
+                                return 'select';
+                            }
+                            return mapTwentyTypeToN8nType(graphqlType);
+                        };
+                        const options = filteredFields.map((field) => {
+                            const n8nType = field.source === 'metadata'
+                                ? mapTwentyTypeToN8nType(field.type)
+                                : mapGraphQLTypeToN8nType(field.type);
+                            return {
+                                name: (0, TwentyApi_client_1.getCleanFieldLabel)(field.label, field.name),
+                                value: `${field.name}|${n8nType}`,
+                                description: field.type,
+                            };
+                        });
+                        options.sort((a, b) => {
+                            const aValue = String(a.value);
+                            const bValue = String(b.value);
+                            if (aValue.startsWith('name|'))
+                                return -1;
+                            if (bValue.startsWith('name|'))
+                                return 1;
+                            const aIsStandard = ['id', 'createdAt', 'updatedAt', 'deletedAt'].some((f) => aValue.includes(f));
+                            const bIsStandard = ['id', 'createdAt', 'updatedAt', 'deletedAt'].some((f) => bValue.includes(f));
+                            if (aIsStandard === bIsStandard) {
+                                return a.name.localeCompare(b.name);
+                            }
+                            return aIsStandard ? -1 : 1;
+                        });
+                        return options;
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load fields for resource: ${error.message}`);
+                    }
+                },
+                async getFieldsForOrderBy() {
+                    try {
+                        const resource = this.getCurrentNodeParameter('resource');
+                        if (!resource) {
+                            return [{ name: '(No Sorting)', value: '' }];
+                        }
+                        const schema = await TwentyApi_client_1.getCachedSchema.call(this, false);
+                        const objectMeta = schema.objects.find((obj) => obj.nameSingular === resource);
+                        const metadataFields = (objectMeta === null || objectMeta === void 0 ? void 0 : objectMeta.fields) || [];
+                        const graphqlFields = await TwentyApi_client_1.getDataSchemaForObject.call(this, resource);
+                        const fieldMap = new Map();
+                        graphqlFields.forEach((f) => fieldMap.set(f.name, { ...f, source: 'graphql' }));
+                        metadataFields.forEach((f) => fieldMap.set(f.name, { ...f, source: 'metadata' }));
+                        const allFields = Array.from(fieldMap.values());
+                        const sortableTypes = ['TEXT', 'NUMBER', 'BOOLEAN', 'UUID', 'DATE_TIME', 'DATE', 'SELECT', 'PHONE', 'EMAIL', 'RAW_JSON'];
+                        const sortableFields = allFields.filter((f) => {
+                            if (f.isActive === false)
+                                return false;
+                            if (sortableTypes.includes(f.type))
+                                return true;
+                            if (f.type.includes('Connection'))
+                                return false;
+                            if (['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Date', 'UUID', 'ID'].includes(f.type))
+                                return true;
+                            return false;
+                        });
+                        const options = [
+                            { name: '(No Sorting)', value: '' },
+                        ];
+                        sortableFields.forEach((field) => {
+                            options.push({
+                                name: (0, TwentyApi_client_1.getCleanFieldLabel)(field.label, field.name),
+                                value: field.name,
+                                description: field.type,
+                            });
+                        });
+                        options.sort((a, b) => {
+                            if (a.value === '')
+                                return -1;
+                            if (b.value === '')
+                                return 1;
+                            return a.name.localeCompare(b.name);
+                        });
+                        return options;
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load sortable fields: ${error.message}`);
+                    }
+                },
+                async getOptionsForSelectField() {
+                    var _a, _b;
+                    try {
+                        const resource = this.getCurrentNodeParameter('resource');
+                        if (!resource) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No resource selected');
+                        }
+                        let fieldNameWithType;
+                        try {
+                            fieldNameWithType = this.getCurrentNodeParameter('&fieldName');
+                        }
+                        catch {
+                            return [];
+                        }
+                        if (!fieldNameWithType) {
+                            return [];
+                        }
+                        const parts = fieldNameWithType.split('|');
+                        if (parts.length !== 2) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid field format: ${fieldNameWithType}`);
+                        }
+                        const [fieldName, fieldType] = parts;
+                        if (!['select', 'multiSelect'].includes(fieldType)) {
+                            return [];
+                        }
+                        const schema = await TwentyApi_client_1.getCachedSchema.call(this, false);
+                        const objectMeta = schema.objects.find((obj) => obj.nameSingular === resource);
+                        if (objectMeta === null || objectMeta === void 0 ? void 0 : objectMeta.fields) {
+                            const metadataField = objectMeta.fields.find((f) => f.name === fieldName);
+                            if ((metadataField === null || metadataField === void 0 ? void 0 : metadataField.options) && metadataField.options.length > 0) {
+                                const sortedOptions = [...metadataField.options].sort((a, b) => a.position - b.position);
+                                return sortedOptions.map(opt => ({
+                                    name: opt.label,
+                                    value: opt.value,
+                                    description: opt.color ? `Color: ${opt.color}` : undefined,
+                                }));
+                            }
+                        }
+                        const typeName = resource.charAt(0).toUpperCase() + resource.slice(1);
+                        const graphqlSchema = await TwentyApi_client_1.queryGraphQLType.call(this, typeName);
+                        if ((_a = graphqlSchema.__type) === null || _a === void 0 ? void 0 : _a.fields) {
+                            const graphqlField = graphqlSchema.__type.fields.find((f) => f.name === fieldName);
+                            if (graphqlField) {
+                                let enumTypeName = null;
+                                if (graphqlField.type.kind === 'ENUM') {
+                                    enumTypeName = graphqlField.type.name;
+                                }
+                                else if (graphqlField.type.kind === 'LIST' && ((_b = graphqlField.type.ofType) === null || _b === void 0 ? void 0 : _b.kind) === 'ENUM') {
+                                    enumTypeName = graphqlField.type.ofType.name;
+                                }
+                                if (enumTypeName) {
+                                    const enumValues = await TwentyApi_client_1.queryEnumValues.call(this, enumTypeName);
+                                    return enumValues.map(ev => ({
+                                        name: ev.label,
+                                        value: ev.name,
+                                    }));
+                                }
+                            }
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No options found for field "${fieldName}" (type: ${fieldType}). This field may not be a SELECT or MULTI_SELECT type, or the field data is not available.`);
+                    }
+                    catch (error) {
+                        if (error instanceof n8n_workflow_1.NodeOperationError) {
+                            throw error;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error fetching options: ${error.message}`);
+                    }
+                },
+            },
+            listSearch: {
+                async getRecordsForDatabase(filter) {
+                    var _a;
+                    try {
+                        const resource = this.getCurrentNodeParameter('resource');
+                        if (!resource) {
+                            return { results: [] };
+                        }
+                        const schema = await TwentyApi_client_1.getCachedSchema.call(this, true);
+                        const objectMetadata = schema.objects.find((obj) => obj.nameSingular === resource);
+                        if (!objectMetadata) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Database "${resource}" not found in schema`);
+                        }
+                        const isPerson = resource === 'person';
+                        const nameFieldQuery = isPerson
+                            ? `name {
+                            firstName
+                            lastName
+                        }`
+                            : 'name';
+                        const fieldsToQuery = ['id', nameFieldQuery];
+                        const pluralName = objectMetadata.namePlural;
+                        const hasFilter = filter && filter.trim() !== '';
+                        let filterClause = '';
+                        if (hasFilter) {
+                            if (isPerson) {
+                                filterClause = ', filter: { or: [ { name: { firstName: { ilike: $searchPattern } } }, { name: { lastName: { ilike: $searchPattern } } } ] }';
+                            }
+                            else {
+                                filterClause = ', filter: { name: { ilike: $searchPattern } }';
+                            }
+                        }
+                        const query = `
+                        query List${objectMetadata.labelPlural.replace(/\s+/g, '')}($limit: Int!${hasFilter ? ', $searchPattern: String!' : ''}) {
+                            ${pluralName}(first: $limit${filterClause}) {
+                                edges {
+                                    node {
+                                        ${fieldsToQuery.join('\n                                        ')}
+                                    }
+                                }
+                            }
+                        }
+                    `;
+                        const variables = {
+                            limit: 100,
+                        };
+                        if (hasFilter) {
+                            variables.searchPattern = `%${filter}%`;
+                        }
+                        const response = await TwentyApi_client_1.twentyApiRequest.call(this, 'graphql', query, variables);
+                        const edges = ((_a = response[pluralName]) === null || _a === void 0 ? void 0 : _a.edges) || [];
+                        if (edges.length === 0) {
+                            return {
+                                results: [
+                                    {
+                                        name: `No ${objectMetadata.labelPlural} Found`,
+                                        value: '',
+                                    },
+                                ],
+                            };
+                        }
+                        const results = edges.map((edge) => {
+                            const record = edge.node;
+                            let displayValue;
+                            if (isPerson && record.name && typeof record.name === 'object') {
+                                const firstName = record.name.firstName || '';
+                                const lastName = record.name.lastName || '';
+                                displayValue = `${firstName} ${lastName}`.trim() || record.id;
+                            }
+                            else {
+                                displayValue = record.name || record.id;
+                            }
+                            return {
+                                name: displayValue,
+                                value: record.id,
+                                url: `https://app.twenty.com/objects/${objectMetadata.namePlural}/${record.id}`,
+                            };
+                        });
+                        return { results };
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load records from Twenty CRM. Error: ${error.message}`);
+                    }
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e;
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        const resource = this.getNodeParameter('resource', 0);
+        const schema = await TwentyApi_client_1.getCachedSchema.call(this, true);
+        const objectMetadata = schema.objects.find((obj) => obj.nameSingular === resource);
+        if (!objectMetadata) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Object "${resource}" not found in schema`);
+        }
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (operation === 'create') {
+                    const fieldsParam = this.getNodeParameter('fields', i, {});
+                    const fieldsData = (0, FieldTransformation_1.transformFieldsData)(fieldsParam.field || [], resource);
+                    const { query, variables } = await TwentyApi_client_1.buildCreateMutation.call(this, resource, fieldsData, objectMetadata);
+                    const response = await TwentyApi_client_1.twentyApiRequest.call(this, 'graphql', query, variables);
+                    const operationName = `create${resource.charAt(0).toUpperCase() + resource.slice(1)}`;
+                    const createdRecord = response[operationName];
+                    returnData.push({
+                        json: createdRecord,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'createMany') {
+                    const bulkDataParam = this.getNodeParameter('bulkData', i);
+                    const recordsData = JSON.parse(bulkDataParam);
+                    if (!Array.isArray(recordsData)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Input Data must be an array of objects');
+                    }
+                    const transformedRecords = recordsData.map(record => (0, FieldTransformation_1.transformFieldsData)(Object.entries(record).map(([key, value]) => ({
+                        fieldName: key,
+                        fieldValue: value,
+                    })), resource));
+                    const results = await (0, operations_1.executeCreateMany)(this, resource, transformedRecords, objectMetadata);
+                    results.forEach((result) => {
+                        returnData.push({
+                            json: result.success ? result.record : { error: result.error, index: result.index },
+                            pairedItem: { item: i },
+                        });
+                    });
+                }
+                else if (operation === 'get') {
+                    const recordIdParam = this.getNodeParameter('recordId', i);
+                    let recordId;
+                    if (typeof recordIdParam === 'string') {
+                        recordId = recordIdParam;
+                    }
+                    else if (recordIdParam && typeof recordIdParam === 'object' && recordIdParam.value) {
+                        if (recordIdParam.mode === 'url') {
+                            const urlMatch = recordIdParam.value.match(/https?:\/\/.*?\/objects\/[^\/]+\/([a-f0-9-]{36})/i);
+                            if (!urlMatch) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Could not extract record ID from URL: ${recordIdParam.value}`);
+                            }
+                            recordId = urlMatch[1];
+                        }
+                        else {
+                            recordId = recordIdParam.value;
+                        }
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No record ID provided');
+                    }
+                    const pluralName = objectMetadata.namePlural;
+                    const restPath = `/${pluralName}/${recordId}`;
+                    try {
+                        const response = await TwentyApi_client_1.twentyRestApiRequest.call(this, 'GET', restPath);
+                        const record = (_a = response.data) === null || _a === void 0 ? void 0 : _a[resource];
+                        if (!record) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Record with ID "${recordId}" not found`);
+                        }
+                        returnData.push({
+                            json: record,
+                            pairedItem: { item: i },
+                        });
+                    }
+                    catch (error) {
+                        if (error.message.includes('Record not found')) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Record with ID "${recordId}" not found`);
+                        }
+                        throw error;
+                    }
+                }
+                else if (operation === 'getMany') {
+                    const bulkDataParam = this.getNodeParameter('bulkData', i);
+                    const recordIds = JSON.parse(bulkDataParam);
+                    if (!Array.isArray(recordIds)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Input Data must be an array of record IDs');
+                    }
+                    const results = await (0, operations_1.executeGetMany)(this, resource, recordIds, objectMetadata);
+                    results.forEach((result) => {
+                        returnData.push({
+                            json: result.success ? result.record : { error: result.error, id: result.id, index: result.index },
+                            pairedItem: { item: i },
+                        });
+                    });
+                }
+                else if (operation === 'update') {
+                    const recordIdParam = this.getNodeParameter('recordIdUpdate', i);
+                    let recordId;
+                    if (typeof recordIdParam === 'string') {
+                        recordId = recordIdParam;
+                    }
+                    else if (recordIdParam && typeof recordIdParam === 'object' && recordIdParam.value) {
+                        if (recordIdParam.mode === 'url') {
+                            const urlMatch = recordIdParam.value.match(/https?:\/\/.*?\/objects\/[^\/]+\/([a-f0-9-]{36})/i);
+                            if (!urlMatch) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Could not extract record ID from URL: ${recordIdParam.value}`);
+                            }
+                            recordId = urlMatch[1];
+                        }
+                        else {
+                            recordId = recordIdParam.value;
+                        }
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No record ID provided');
+                    }
+                    const fieldsParam = this.getNodeParameter('fields', i, {});
+                    const fieldsData = (0, FieldTransformation_1.transformFieldsData)(fieldsParam.field || [], resource);
+                    const { query, variables } = await TwentyApi_client_1.buildUpdateMutation.call(this, resource, recordId, fieldsData, objectMetadata);
+                    const response = await TwentyApi_client_1.twentyApiRequest.call(this, 'graphql', query, variables);
+                    const operationName = `update${resource.charAt(0).toUpperCase() + resource.slice(1)}`;
+                    const updatedRecord = response[operationName];
+                    returnData.push({
+                        json: updatedRecord,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'updateMany') {
+                    const bulkDataParam = this.getNodeParameter('bulkData', i);
+                    const updatesData = JSON.parse(bulkDataParam);
+                    if (!Array.isArray(updatesData)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Input Data must be an array of objects with id and fields');
+                    }
+                    const transformedUpdates = updatesData.map(update => ({
+                        id: update.id,
+                        fieldsData: (0, FieldTransformation_1.transformFieldsData)(Object.entries(update.fields || {}).map(([key, value]) => ({
+                            fieldName: key,
+                            fieldValue: value,
+                        })), resource),
+                    }));
+                    const results = await (0, operations_1.executeUpdateMany)(this, resource, transformedUpdates, objectMetadata);
+                    results.forEach((result) => {
+                        returnData.push({
+                            json: result.success ? result.record : { error: result.error, id: result.id, index: result.index },
+                            pairedItem: { item: i },
+                        });
+                    });
+                }
+                else if (operation === 'upsert') {
+                    const upsertMode = this.getNodeParameter('upsertMode', i, 'field');
+                    const fieldsParam = this.getNodeParameter('fields', i, {});
+                    const fieldsData = (0, FieldTransformation_1.transformFieldsData)(fieldsParam.field || [], resource);
+                    const options = {};
+                    if (upsertMode === 'id') {
+                        options.recordIdParam = this.getNodeParameter('recordIdUpsert', i);
+                    }
+                    else {
+                        const matchFieldParam = this.getNodeParameter('upsertMatchField', i);
+                        const matchValue = this.getNodeParameter('upsertMatchValue', i);
+                        options.matchField = matchFieldParam.split('|')[0];
+                        options.matchValue = matchValue;
+                    }
+                    const { record, action } = await (0, operations_1.executeUpsert)(this, upsertMode, resource, fieldsData, objectMetadata, options);
+                    returnData.push({
+                        json: { ...record, __upsertAction: action },
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'upsertMany') {
+                    const bulkDataParam = this.getNodeParameter('bulkData', i);
+                    const upsertData = JSON.parse(bulkDataParam);
+                    if (!Array.isArray(upsertData)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Input Data must be an array of objects with matchValue and fields');
+                    }
+                    const matchFieldParam = this.getNodeParameter('upsertManyMatchField', i);
+                    const matchField = matchFieldParam.split('|')[0];
+                    const transformedUpserts = upsertData.map(item => ({
+                        matchValue: item.matchValue,
+                        fieldsData: (0, FieldTransformation_1.transformFieldsData)(Object.entries(item.fields || {}).map(([key, value]) => ({
+                            fieldName: key,
+                            fieldValue: value,
+                        })), resource),
+                    }));
+                    const results = await (0, operations_1.executeUpsertMany)(this, resource, 'field', transformedUpserts, objectMetadata, { matchField });
+                    results.forEach((result) => {
+                        returnData.push({
+                            json: result.success
+                                ? { ...result.record, __upsertAction: result.action }
+                                : { error: result.error, index: result.index },
+                            pairedItem: { item: i },
+                        });
+                    });
+                }
+                else if (operation === 'delete') {
+                    const recordIdParam = this.getNodeParameter('recordIdDelete', i);
+                    let recordId;
+                    if (typeof recordIdParam === 'string') {
+                        recordId = recordIdParam;
+                    }
+                    else if (recordIdParam && typeof recordIdParam === 'object' && recordIdParam.value) {
+                        if (recordIdParam.mode === 'url') {
+                            const urlMatch = recordIdParam.value.match(/https?:\/\/.*?\/objects\/[^\/]+\/([a-f0-9-]{36})/i);
+                            if (!urlMatch) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Could not extract record ID from URL: ${recordIdParam.value}`);
+                            }
+                            recordId = urlMatch[1];
+                        }
+                        else {
+                            recordId = recordIdParam.value;
+                        }
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No record ID provided');
+                    }
+                    const pluralName = objectMetadata.namePlural;
+                    const restPath = `/${pluralName}/${recordId}`;
+                    try {
+                        const response = await TwentyApi_client_1.twentyRestApiRequest.call(this, 'DELETE', restPath);
+                        let deletedRecord;
+                        if (response.data) {
+                            deletedRecord = response.data[resource] || response.data[objectMetadata.nameSingular] || response.data;
+                        }
+                        else {
+                            deletedRecord = response;
+                        }
+                        const resultId = (deletedRecord === null || deletedRecord === void 0 ? void 0 : deletedRecord.id) || recordId;
+                        returnData.push({
+                            json: { success: true, id: resultId, deletedRecord },
+                            pairedItem: { item: i },
+                        });
+                    }
+                    catch (error) {
+                        if (error.message && error.message.includes('Record not found')) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Record with ID "${recordId}" not found`);
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to delete record with ID "${recordId}": ${error.message || error}`);
+                    }
+                }
+                else if (operation === 'deleteMany') {
+                    const bulkDataParam = this.getNodeParameter('bulkData', i);
+                    const recordIds = JSON.parse(bulkDataParam);
+                    if (!Array.isArray(recordIds)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Input Data must be an array of record IDs');
+                    }
+                    const results = await (0, operations_1.executeDeleteMany)(this, resource, recordIds, objectMetadata);
+                    results.forEach((result) => {
+                        returnData.push({
+                            json: result.success
+                                ? { success: true, id: result.id }
+                                : { error: result.error, id: result.id, index: result.index },
+                            pairedItem: { item: i },
+                        });
+                    });
+                }
+                else if (operation === 'findMany') {
+                    const limit = this.getNodeParameter('limit', i);
+                    const searchQuery = this.getNodeParameter('searchQuery', i, '');
+                    const orderByField = this.getNodeParameter('orderByField', i, '');
+                    const orderByDirection = this.getNodeParameter('orderByDirection', i, 'AscNullsFirst');
+                    const pluralName = objectMetadata.namePlural;
+                    const staticParts = [];
+                    if (searchQuery) {
+                        const filter = buildSmartFilter(searchQuery, resource);
+                        staticParts.push(`filter=${encodeURIComponent(filter)}`);
+                    }
+                    if (orderByField) {
+                        staticParts.push(`order_by=${orderByField}[${orderByDirection}]`);
+                    }
+                    let collected = 0;
+                    let cursor;
+                    let hasNextPage = true;
+                    try {
+                        while (hasNextPage && (!limit || collected < limit)) {
+                            const remaining = limit ? limit - collected : TwentyApi_client_1.TWENTY_REST_MAX_PAGE_SIZE;
+                            const pageSize = Math.min(remaining, TwentyApi_client_1.TWENTY_REST_MAX_PAGE_SIZE);
+                            const queryParts = [...staticParts, `limit=${pageSize}`];
+                            if (cursor) {
+                                queryParts.push(`starting_after=${encodeURIComponent(cursor)}`);
+                            }
+                            const restPath = `/${pluralName}?${queryParts.join('&')}`;
+                            const response = await TwentyApi_client_1.twentyRestApiRequest.call(this, 'GET', restPath);
+                            const data = response.data;
+                            if (!data)
+                                break;
+                            const records = data[pluralName];
+                            if (!records)
+                                break;
+                            const recordsArray = Array.isArray(records)
+                                ? records
+                                : (_c = (_b = records.edges) === null || _b === void 0 ? void 0 : _b.map((edge) => edge.node)) !== null && _c !== void 0 ? _c : [];
+                            for (const record of recordsArray) {
+                                returnData.push({
+                                    json: record,
+                                    pairedItem: { item: i },
+                                });
+                                collected++;
+                            }
+                            const pageInfo = (_d = data.pageInfo) !== null && _d !== void 0 ? _d : records.pageInfo;
+                            hasNextPage = (pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.hasNextPage) === true;
+                            cursor = pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.endCursor;
+                            if (!cursor || recordsArray.length === 0)
+                                break;
+                        }
+                    }
+                    catch (error) {
+                        if ((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('not found')) {
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Twenty = Twenty;
+//# sourceMappingURL=Twenty.node.js.map