n8n-nodes-base 2.44.2 → 2.45.0

package/dist/nodes/MondayCom/V2/actions/item/item.execute.js

@@ -0,0 +1,1042 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOVE_UNMAPPABLE_COLUMN_TYPES = exports.MAX_BULK_ARCHIVE_DELETE_ITEMS = exports.MAX_CLEAR_COLUMNS = exports.MAX_CLEAR_ITEMS = void 0;
+exports.withArchiveOrDeleteOutcome = withArchiveOrDeleteOutcome;
+exports.resolveArchiveOrDeleteAction = resolveArchiveOrDeleteAction;
+exports.createItem = createItem;
+exports.createSubitem = createSubitem;
+exports.updateItem = updateItem;
+exports.buildClearColumnValuesMutation = buildClearColumnValuesMutation;
+exports.clearColumnValues = clearColumnValues;
+exports.bulkImportItems = bulkImportItems;
+exports.getBulkImportJobStatus = getBulkImportJobStatus;
+exports.buildBulkArchiveOrDeleteMutation = buildBulkArchiveOrDeleteMutation;
+exports.archiveOrDeleteManyItems = archiveOrDeleteManyItems;
+exports.completeMoveColumnsMapping = completeMoveColumnsMapping;
+exports.moveItem = moveItem;
+exports.safeJsonParse = safeJsonParse;
+exports.flattenItemColumns = flattenItemColumns;
+exports.buildGetItemQuery = buildGetItemQuery;
+exports.getItem = getItem;
+exports.searchAcrossAccount = searchAcrossAccount;
+exports.formatColumnValueOutput = formatColumnValueOutput;
+exports.getColumnValue = getColumnValue;
+exports.getManyItems = getManyItems;
+const sleep_1 = require("@n8n/utils/sleep");
+const n8n_workflow_1 = require("n8n-workflow");
+const accountSearch_1 = require("../../helpers/accountSearch");
+const bulkImport_1 = require("../../helpers/bulkImport");
+const columnMapper_1 = require("../../helpers/columnMapper");
+const boardLocator_1 = require("../../helpers/boardLocator");
+const columnValueMappers_1 = require("../../helpers/columnValueMappers");
+const fileTransfer_1 = require("../../helpers/fileTransfer");
+const filterOptions_1 = require("../../helpers/filterOptions");
+const itemFilters_1 = require("../../helpers/itemFilters");
+const multiLevel_1 = require("../../helpers/multiLevel");
+const pagination_1 = require("../../helpers/pagination");
+const userLocator_1 = require("../../helpers/userLocator");
+const constants_1 = require("../../transport/constants");
+/**
+ * Shapes the output row of an archive/delete mutation. monday echoes the
+ * entity's state from BEFORE the change (`state: "active"`,
+ * `archived: false`), so the state fields are set from the action taken —
+ * a downstream IF on them must see the new state, like Odoo V2's
+ * `{ id, deleted: true }`.
+ */
+function withArchiveOrDeleteOutcome(payload, action, entity) {
+    if (entity === 'group') {
+        return action === 'archive'
+            ? { ...payload, archived: true, action }
+            : { ...payload, deleted: true, action };
+    }
+    return { ...payload, state: action === 'archive' ? 'archived' : 'deleted', action };
+}
+function resolveArchiveOrDeleteAction(itemIndex) {
+    const action = this.getNodeParameter('archiveOrDeleteAction', itemIndex, 'archive');
+    return action === 'delete' ? 'delete' : 'archive';
+}
+/**
+ * Resolves the column_values object shared by Item: Create and Item: Update —
+ * either the typed column mapper (friendly per-type inputs) or a raw
+ * API-format JSON object. Returns undefined when nothing was set.
+ */
+async function resolveColumnValues(itemIndex, boardId) {
+    const mode = this.getNodeParameter('columnValuesMode', itemIndex);
+    if (mode === 'json') {
+        const raw = this.getNodeParameter('columnValuesJson', itemIndex, '{}');
+        if (typeof raw === 'object' && raw !== null) {
+            return raw;
+        }
+        if (typeof raw === 'string' && raw.trim() !== '' && raw.trim() !== '{}') {
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Column Values (JSON) must be a valid JSON object keyed by column ID', { itemIndex });
+            }
+        }
+        return undefined;
+    }
+    const mapped = (0, columnMapper_1.extractMappedValues)(this.getNodeParameter('columns', itemIndex, {}));
+    if (Object.keys(mapped).length === 0)
+        return undefined;
+    const columnTypes = await (0, columnMapper_1.fetchColumnTypes)(this, boardId, itemIndex);
+    return (0, columnValueMappers_1.buildColumnValues)(mapped, columnTypes, { timezone: this.getTimezone() });
+}
+/** Item: Create — create_item with column values from the shared builder. */
+async function createItem(client, itemIndex) {
+    // Unified Create: Subitem mode routes to create_subitem.
+    const createAs = this.getNodeParameter('createAs', itemIndex, 'item');
+    if (createAs === 'subitem') {
+        return await createSubitem.call(this, client, itemIndex);
+    }
+    const boardId = this.getNodeParameter('boardId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const name = this.getNodeParameter('name', itemIndex);
+    const createOptions = this.getNodeParameter('createOptions', itemIndex, {});
+    const groupId = createOptions.groupId || '';
+    const columnValues = await resolveColumnValues.call(this, itemIndex, boardId);
+    const data = await client.execute(`mutation ($boardId: ID!, $groupId: String, $itemName: String!, $columnValues: JSON, $createLabels: Boolean) {
+			create_item(
+				board_id: $boardId,
+				group_id: $groupId,
+				item_name: $itemName,
+				column_values: $columnValues,
+				create_labels_if_missing: $createLabels
+			) {
+				id
+				name
+				url
+				state
+				board { id name }
+				group { id title }
+				column_values(${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG}) { id type text value ${multiLevel_1.BATTERY_VALUE_FRAGMENT} ${multiLevel_1.LINKED_VALUE_FRAGMENTS} }
+			}
+		}`, itemIndex, {
+        boardId,
+        groupId: groupId || null,
+        itemName: name,
+        // The API's JSON scalar arrives as a string.
+        columnValues: columnValues ? JSON.stringify(columnValues) : null,
+        createLabels: createOptions.createLabelsIfMissing === true,
+    });
+    return (data.create_item ?? {});
+}
+/**
+ * Item: Create in Subitem mode — create_subitem under a parent item,
+ * through the same column builder as
+ * Create. Mapper values are typed against the SUBITEM board, resolved via
+ * the parent board's subtasks column — on multi-level boards that resolves
+ * to the parent board itself (one shared schema at every depth), and the
+ * parent may be a subitem (nesting up to 5 levels).
+ */
+async function createSubitem(client, itemIndex) {
+    const parentBoardId = this.getNodeParameter('boardId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const parentItemId = this.getNodeParameter('itemId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const name = this.getNodeParameter('name', itemIndex);
+    const createOptions = this.getNodeParameter('createOptions', itemIndex, {});
+    // Column types must come from the subitem board, not the parent's.
+    // Only needed in mapper mode; raw JSON passes through untyped.
+    const mode = this.getNodeParameter('columnValuesMode', itemIndex);
+    let valuesBoardId = parentBoardId;
+    if (mode === 'mapper') {
+        const mapped = (0, columnMapper_1.extractMappedValues)(this.getNodeParameter('columns', itemIndex, {}));
+        if (Object.keys(mapped).length > 0) {
+            const subitemBoardId = await (0, columnMapper_1.resolveSubitemBoardId)(this, parentBoardId, itemIndex);
+            if (!subitemBoardId) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This board has no subitems board yet — create the first subitem without column values, or use Raw JSON', { itemIndex });
+            }
+            valuesBoardId = subitemBoardId;
+        }
+    }
+    const columnValues = await resolveColumnValues.call(this, itemIndex, valuesBoardId);
+    const data = await client.execute(`mutation ($parentItemId: ID!, $itemName: String!, $columnValues: JSON, $createLabels: Boolean) {
+			create_subitem(
+				parent_item_id: $parentItemId,
+				item_name: $itemName,
+				column_values: $columnValues,
+				create_labels_if_missing: $createLabels
+			) {
+				id
+				name
+				url
+				state
+				board { id name }
+				group { id title }
+				parent_item { id name }
+				column_values(${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG}) { id type text value ${multiLevel_1.BATTERY_VALUE_FRAGMENT} ${multiLevel_1.LINKED_VALUE_FRAGMENTS} }
+			}
+		}`, itemIndex, {
+        parentItemId,
+        itemName: name,
+        columnValues: columnValues ? JSON.stringify(columnValues) : null,
+        createLabels: createOptions.createLabelsIfMissing === true,
+    });
+    return (data.create_subitem ?? {});
+}
+/**
+ * Item: Update — change_multiple_column_values via the same column builder
+ * as Create; the mapper additionally exposes the name column for renames.
+ */
+async function updateItem(client, itemIndex) {
+    const boardId = this.getNodeParameter('boardId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const itemId = this.getNodeParameter('itemId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const createOptions = this.getNodeParameter('createOptions', itemIndex, {});
+    const columnValues = await resolveColumnValues.call(this, itemIndex, boardId);
+    if (!columnValues || Object.keys(columnValues).length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Set at least one column value to update', {
+            itemIndex,
+        });
+    }
+    const data = await client.execute(`mutation ($boardId: ID!, $itemId: ID!, $columnValues: JSON!, $createLabels: Boolean) {
+			change_multiple_column_values(
+				board_id: $boardId,
+				item_id: $itemId,
+				column_values: $columnValues,
+				create_labels_if_missing: $createLabels
+			) {
+				id
+				name
+				url
+				state
+				board { id name }
+				group { id title }
+				column_values(${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG}) { id type text value ${multiLevel_1.BATTERY_VALUE_FRAGMENT} ${multiLevel_1.LINKED_VALUE_FRAGMENTS} }
+			}
+		}`, itemIndex, {
+        boardId,
+        itemId,
+        columnValues: JSON.stringify(columnValues),
+        createLabels: createOptions.createLabelsIfMissing === true,
+    });
+    return (data.change_multiple_column_values ?? {});
+}
+/** Product cap for Item: Clear Column Values — items and columns per execution. */
+exports.MAX_CLEAR_ITEMS = 10;
+exports.MAX_CLEAR_COLUMNS = 10;
+/**
+ * Builds the single aliased request that clears the given columns on every
+ * item: one change_multiple_column_values per item, all in one mutation.
+ * Setting a column to null resets it to its empty/default value (verified
+ * live for text, numbers, date, link, status, checkbox and file columns).
+ * Exported for unit tests.
+ */
+function buildClearColumnValuesMutation(itemIds, columnIds) {
+    const columnValues = JSON.stringify(Object.fromEntries(columnIds.map((columnId) => [columnId, null])));
+    const variables = { boardId: undefined, columnValues };
+    const varDefs = ['$boardId: ID!', '$columnValues: JSON!'];
+    const aliases = [];
+    itemIds.forEach((itemId, index) => {
+        varDefs.push(`$item${index}: ID!`);
+        variables[`item${index}`] = itemId;
+        aliases.push(`item${index}: change_multiple_column_values(board_id: $boardId, item_id: $item${index}, column_values: $columnValues) { id name }`);
+    });
+    return {
+        query: `mutation (${varDefs.join(', ')}) {\n\t${aliases.join('\n\t')}\n}`,
+        variables,
+    };
+}
+/**
+ * Item: Clear Column Values — resets up to 10 columns on up to 10 items back
+ * to their empty/default values in ONE aliased API request. Not atomic: if a
+ * later item in the batch fails, earlier aliases may already have executed.
+ */
+async function clearColumnValues(client, itemIndex) {
+    const boardId = this.getNodeParameter('boardId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const itemIds = (0, filterOptions_1.normalizeIdList)(this.getNodeParameter('clearItemIds', itemIndex));
+    const columnIds = (0, filterOptions_1.normalizeIdList)(this.getNodeParameter('clearColumnIds', itemIndex));
+    if (itemIds.length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Provide at least one item ID to clear', {
+            itemIndex,
+        });
+    }
+    if (itemIds.length > exports.MAX_CLEAR_ITEMS) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Too many items: ${itemIds.length} provided, but Clear Column Values handles at most ${exports.MAX_CLEAR_ITEMS} per execution. Split the list across multiple runs.`, { itemIndex });
+    }
+    if (columnIds.length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Select at least one column to clear', {
+            itemIndex,
+        });
+    }
+    if (columnIds.length > exports.MAX_CLEAR_COLUMNS) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Too many columns: ${columnIds.length} selected, but Clear Column Values handles at most ${exports.MAX_CLEAR_COLUMNS} per execution`, { itemIndex });
+    }
+    const { query, variables } = buildClearColumnValuesMutation(itemIds, columnIds);
+    variables.boardId = boardId;
+    const { data, errors } = await client.executeBulk(query, itemIndex, variables);
+    const failures = [];
+    const rows = itemIds.map((itemId, index) => {
+        const payload = data[`item${index}`];
+        if (payload) {
+            return {
+                itemId: payload.id ?? itemId,
+                name: payload.name ?? null,
+                success: true,
+                clearedColumnIds: columnIds,
+            };
+        }
+        const failure = errors.find((error) => error.path?.[0] === `item${index}`);
+        const message = failure?.message ?? 'Unknown error';
+        failures.push({ itemId, message });
+        return {
+            itemId,
+            success: false,
+            error: message,
+            errorCode: failure?.extensions?.code ?? failure?.error_code ?? null,
+        };
+    });
+    if (failures.length > 0 && !this.continueOnFail()) {
+        const detail = failures.map((failure) => `${failure.itemId} (${failure.message})`).join(', ');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${failures.length} of ${itemIds.length} items failed to clear: ${detail}. The other items in the batch were still cleared.`, { itemIndex });
+    }
+    return rows;
+}
+/** Selection set for fetch_job_status — shared by the wait loop and the status op. */
+const ITEMS_JOB_STATUS_QUERY = `query ($jobId: ID!) {
+	fetch_job_status(job_id: $jobId) {
+		... on ItemsJobStatus {
+			status
+			counts { submitted invalid skipped created updated failed }
+			progress_percentage
+			failure_reason
+			failure_message
+			fully_imported
+			report_created
+			report_url
+		}
+	}
+}`;
+/** One fetch_job_status poll. */
+async function fetchBulkImportJobStatus(client, itemIndex, jobId) {
+    const data = await client.execute(ITEMS_JOB_STATUS_QUERY, itemIndex, { jobId });
+    return (data.fetch_job_status ?? {});
+}
+/**
+ * Downloads and parses monday's per-row import report. The report URL is a
+ * pre-signed S3 GET that expires after 10 minutes — always fetched
+ * immediately, never emitted downstream. Rows in mapped mode pair back to
+ * the input item they came from (serialNo is the 1-based data-row number).
+ */
+async function fetchBulkImportReportRows(jobId, reportUrl, pairToInputRows, fallbackItemIndex, inputItemCount) {
+    (0, fileTransfer_1.assertPresignedStorageUrl)(this.getNode(), reportUrl, 'report', fallbackItemIndex);
+    const reportText = (await this.helpers.httpRequest({
+        url: reportUrl,
+        ...fileTransfer_1.PRESIGNED_URL_REQUEST_OPTIONS,
+    }));
+    return (0, bulkImport_1.parseReportRows)(String(reportText)).map((row) => {
+        const serialNo = typeof row.serialNo === 'number' ? row.serialNo : undefined;
+        const pairedIndex = pairToInputRows && serialNo !== undefined && serialNo >= 1 && serialNo <= inputItemCount
+            ? serialNo - 1
+            : fallbackItemIndex;
+        return {
+            json: { jobId, ...row },
+            pairedItem: { item: pairedIndex },
+        };
+    });
+}
+/**
+ * Item: Bulk Import — one asynchronous CSV import job per execution:
+ * start ingest_items/backfill_items, PUT the CSV to the pre-signed URL
+ * (valid 10 minutes, so the upload happens immediately), then optionally
+ * poll fetch_job_status every 10s until a terminal state.
+ */
+async function bulkImportItems(client, inputItemCount) {
+    const boardId = this.getNodeParameter('boardId', 0, undefined, {
+        extractValue: true,
+    });
+    const groupIdParam = this.getNodeParameter('bulkImportGroupId', 0, '');
+    const importType = this.getNodeParameter('bulkImportType', 0);
+    const source = this.getNodeParameter('bulkImportSource', 0);
+    const wait = this.getNodeParameter('bulkImportWait', 0);
+    const options = this.getNodeParameter('bulkImportOptions', 0, {});
+    const isBackfill = importType === 'backfill';
+    const rowCap = isBackfill ? bulkImport_1.MAX_BACKFILL_ROWS : bulkImport_1.MAX_INGEST_ROWS;
+    // Assemble the CSV before starting the job — the upload URL only lives
+    // 10 minutes, so everything slow happens first. A file source is
+    // streamed from binary storage rather than buffered.
+    let csvBody;
+    let csvLength;
+    let mappedMode = false;
+    if (source === 'file') {
+        const binaryPropertyName = this.getNodeParameter('bulkImportBinaryPropertyName', 0);
+        const upload = await (0, fileTransfer_1.resolveBinaryUpload)(this, 0, binaryPropertyName);
+        csvBody = upload.body;
+        csvLength = upload.contentLength;
+    }
+    else {
+        mappedMode = true;
+        if (inputItemCount > rowCap) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Too many rows: ${inputItemCount} input items, but ${isBackfill ? 'backfill' : 'ingest'} accepts at most ${rowCap} rows per job. Split the input into smaller batches.`, { itemIndex: 0 });
+        }
+        const mappedRows = [];
+        for (let i = 0; i < inputItemCount; i++) {
+            mappedRows.push((0, columnMapper_1.extractMappedValues)(this.getNodeParameter('bulkImportColumns', i, {})));
+        }
+        const columns = await (0, columnMapper_1.fetchColumns)(this, boardId, 0);
+        const columnTypes = Object.fromEntries(columns.map((column) => [column.id, column.type]));
+        try {
+            const built = (0, bulkImport_1.buildBulkImportCsv)(mappedRows, columnTypes, columns.map((column) => column.id));
+            csvBody = Buffer.from(built.csv, 'utf-8');
+            csvLength = csvBody.length;
+        }
+        catch (error) {
+            if (error instanceof bulkImport_1.BulkImportInputError) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, { itemIndex: 0 });
+            }
+            // Anything else came from the GraphQL client — already a mapped NodeApiError.
+            throw error;
+        }
+    }
+    // group_id is required by the API; empty picker = the board's top group.
+    let groupId = groupIdParam;
+    if (!groupId) {
+        const groupIds = await (0, multiLevel_1.fetchBoardGroupIds)(client, 0, boardId);
+        if (groupIds.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Board ${boardId} has no groups`, {
+                itemIndex: 0,
+            });
+        }
+        groupId = groupIds[0];
+    }
+    // on_match only exists on ingest_items (backfill always creates).
+    const onMatchBehaviour = isBackfill
+        ? 'none'
+        : this.getNodeParameter('bulkImportOnMatch', 0, 'none');
+    let onMatch = null;
+    if (onMatchBehaviour !== 'none') {
+        const matchColumnId = this.getNodeParameter('bulkImportMatchColumnId', 0);
+        onMatch = { behaviour: onMatchBehaviour, match_column_id: matchColumnId };
+    }
+    const startMutation = isBackfill
+        ? `mutation ($boardId: ID!, $groupId: ID!) {
+				backfill_items(board_id: $boardId, group_id: $groupId) { job_id upload_url }
+			}`
+        : `mutation ($boardId: ID!, $groupId: ID!, $onMatch: OnMatchInput) {
+				ingest_items(board_id: $boardId, group_id: $groupId, on_match: $onMatch) { job_id upload_url }
+			}`;
+    const startVariables = { boardId, groupId };
+    if (!isBackfill)
+        startVariables.onMatch = onMatch;
+    const startData = await client.execute(startMutation, 0, startVariables);
+    const jobInit = (startData[isBackfill ? 'backfill_items' : 'ingest_items'] ?? {});
+    if (!jobInit.job_id || !jobInit.upload_url) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'monday.com did not return a job ID and upload URL for the import job', { itemIndex: 0 });
+    }
+    const jobId = jobInit.job_id;
+    (0, fileTransfer_1.assertPresignedStorageUrl)(this.getNode(), jobInit.upload_url, 'upload', 0);
+    // Pre-signed S3 PUT: no auth header, and no extra headers beyond the
+    // standard ones — an unsigned x-amz-checksum-crc32 header makes S3
+    // reject the upload (403). Content-Length is required for a stream body.
+    await this.helpers.httpRequest({
+        method: 'PUT',
+        url: jobInit.upload_url,
+        body: csvBody,
+        headers: { 'Content-Type': 'text/csv', 'Content-Length': String(csvLength) },
+        ...fileTransfer_1.PRESIGNED_URL_REQUEST_OPTIONS,
+    });
+    if (!wait) {
+        return [
+            {
+                json: { jobId, status: 'UPLOAD_PENDING', boardId, groupId, importType },
+                pairedItem: { item: 0 },
+            },
+        ];
+    }
+    const maxWaitTimeMs = (options.maxWaitTime ?? 1800) * 1000;
+    const startedAt = Date.now();
+    let status = await fetchBulkImportJobStatus(client, 0, jobId);
+    while (!bulkImport_1.BULK_IMPORT_TERMINAL_STATES.has(status.status ?? '')) {
+        if (Date.now() - startedAt >= maxWaitTimeMs) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Import job ${jobId} did not finish within ${maxWaitTimeMs / 1000}s (last status: ${status.status ?? 'unknown'}). The job keeps running on monday's side — check it with the Get Bulk Import Status operation.`, { itemIndex: 0 });
+        }
+        await (0, sleep_1.sleep)(bulkImport_1.BULK_IMPORT_POLL_INTERVAL_MS);
+        status = await fetchBulkImportJobStatus(client, 0, jobId);
+    }
+    if (status.status === 'FAILED' || status.status === 'REJECTED') {
+        const reason = [status.failure_reason, status.failure_message].filter(Boolean).join(' — ');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Import job ${jobId} ${status.status === 'REJECTED' ? 'was rejected' : 'failed'}${reason ? `: ${reason}` : ''}`, { itemIndex: 0 });
+    }
+    const results = [
+        { json: (0, bulkImport_1.summarizeJobStatus)(jobId, status), pairedItem: { item: 0 } },
+    ];
+    if (options.includeRowResults === true && status.report_created && status.report_url) {
+        results.push(...(await fetchBulkImportReportRows.call(this, jobId, status.report_url, mappedMode, 0, inputItemCount)));
+    }
+    return results;
+}
+/**
+ * Item: Get Bulk Import Status — one fetch_job_status poll for a job ID
+ * from a previous Bulk Import run (the no-wait path).
+ */
+async function getBulkImportJobStatus(client, itemIndex) {
+    const jobId = this.getNodeParameter('bulkImportJobId', itemIndex).trim();
+    if (!jobId) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Job ID is required', { itemIndex });
+    }
+    const options = this.getNodeParameter('bulkImportStatusOptions', itemIndex, {});
+    const status = await fetchBulkImportJobStatus(client, itemIndex, jobId);
+    if (status.status === undefined) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No import job found for job ID ${jobId}`, {
+            itemIndex,
+        });
+    }
+    const results = [
+        { json: (0, bulkImport_1.summarizeJobStatus)(jobId, status), pairedItem: { item: itemIndex } },
+    ];
+    if (options.includeRowResults === true && status.report_created && status.report_url) {
+        results.push(...(await fetchBulkImportReportRows.call(this, jobId, status.report_url, false, itemIndex, 0)));
+    }
+    return results;
+}
+/** Product cap for bulk Item: Archive or Delete — item IDs per execution. */
+exports.MAX_BULK_ARCHIVE_DELETE_ITEMS = 50;
+/**
+ * Builds the single aliased request that archives or deletes every item in
+ * the list: one archive_item/delete_item per ID, all in one mutation. The
+ * batch is NOT atomic — a failing alias returns null (with a per-alias error
+ * carrying its path) while the other aliases still execute (verified live).
+ * Exported for unit tests.
+ */
+function buildBulkArchiveOrDeleteMutation(action, itemIds) {
+    const mutationField = action === 'archive' ? 'archive_item' : 'delete_item';
+    const variables = {};
+    const varDefs = [];
+    const aliases = [];
+    itemIds.forEach((itemId, index) => {
+        varDefs.push(`$item${index}: ID!`);
+        variables[`item${index}`] = itemId;
+        aliases.push(`item${index}: ${mutationField}(item_id: $item${index}) { id name state }`);
+    });
+    return {
+        query: `mutation (${varDefs.join(', ')}) {\n\t${aliases.join('\n\t')}\n}`,
+        variables,
+    };
+}
+/**
+ * Item: Archive or Delete in Multiple Items mode — up to 50 item IDs in ONE
+ * aliased API request. Per-ID failures are mapped back to their item via the
+ * error path; with continueOnFail they become error rows, otherwise the run
+ * fails with a summary that names the failed IDs (the rest were still
+ * processed — the batch is not atomic).
+ */
+async function archiveOrDeleteManyItems(client, itemIndex, action) {
+    const itemIds = [...new Set((0, filterOptions_1.normalizeIdList)(this.getNodeParameter('bulkItemIds', itemIndex)))];
+    if (itemIds.length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Provide at least one item ID to ${action}`, {
+            itemIndex,
+        });
+    }
+    if (itemIds.length > exports.MAX_BULK_ARCHIVE_DELETE_ITEMS) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Too many items: ${itemIds.length} provided, but Archive or Delete handles at most ${exports.MAX_BULK_ARCHIVE_DELETE_ITEMS} unique item IDs per execution. Split the list across multiple runs.`, { itemIndex });
+    }
+    const { query, variables } = buildBulkArchiveOrDeleteMutation(action, itemIds);
+    const { data, errors } = await client.executeBulk(query, itemIndex, variables);
+    const failures = [];
+    const rows = itemIds.map((itemId, index) => {
+        const payload = data[`item${index}`];
+        if (payload) {
+            return withArchiveOrDeleteOutcome(payload, action, 'item');
+        }
+        const failure = errors.find((error) => error.path?.[0] === `item${index}`);
+        const message = failure?.message ?? 'Unknown error';
+        failures.push({ itemId, message });
+        return {
+            itemId,
+            action,
+            error: message,
+            errorCode: failure?.extensions?.code ?? failure?.error_code ?? null,
+        };
+    });
+    if (failures.length > 0 && !this.continueOnFail()) {
+        const detail = failures.map((failure) => `${failure.itemId} (${failure.message})`).join(', ');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${failures.length} of ${itemIds.length} items failed to ${action}: ${detail}. The other items in the batch were still processed.`, { itemIndex });
+    }
+    return rows;
+}
+/**
+ * Column types move_item_to_board's columns_mapping cannot include — the
+ * API rejects the whole mapping with an opaque "Columns mapping is not in
+ * the expected format" error (name and subtasks verified live 2026-07-19;
+ * formula per the API docs). These columns are handled by the move itself.
+ */
+exports.MOVE_UNMAPPABLE_COLUMN_TYPES = new Set(['formula', 'name', 'subtasks']);
+/**
+ * Builds the complete columns_mapping that move_item_to_board requires. The
+ * API rejects partial mappings outright, so the configured pairs are
+ * validated against both boards' columns and every remaining mappable
+ * source column is filled in with target: null — which is what monday's own
+ * move dialog submits for unmapped columns (their values are dropped).
+ * Exported for unit tests.
+ */
+function completeMoveColumnsMapping(picked, sourceColumns, targetColumns) {
+    const sourceById = new Map(sourceColumns.map((column) => [column.id, column]));
+    const targetIds = new Set(targetColumns.map((column) => column.id));
+    const mapping = [];
+    const mappedSourceIds = new Set();
+    for (const pair of picked) {
+        const sourceColumn = sourceById.get(pair.source);
+        if (!sourceColumn) {
+            throw new n8n_workflow_1.UserError(`Column "${pair.source}" does not exist on the item's board`);
+        }
+        if (exports.MOVE_UNMAPPABLE_COLUMN_TYPES.has(sourceColumn.type)) {
+            throw new n8n_workflow_1.UserError(`The "${pair.source}" column (type ${sourceColumn.type}) cannot be mapped — the move handles it automatically`);
+        }
+        if (mappedSourceIds.has(pair.source)) {
+            throw new n8n_workflow_1.UserError(`Column "${pair.source}" is mapped more than once`);
+        }
+        const target = pair.target ?? null;
+        if (target !== null && target !== '' && !targetIds.has(target)) {
+            throw new n8n_workflow_1.UserError(`Column "${target}" does not exist on the target board`);
+        }
+        mappedSourceIds.add(pair.source);
+        mapping.push({ source: pair.source, target: target === '' ? null : target });
+    }
+    for (const column of sourceColumns) {
+        if (!mappedSourceIds.has(column.id) && !exports.MOVE_UNMAPPABLE_COLUMN_TYPES.has(column.type)) {
+            mapping.push({ source: column.id, target: null });
+        }
+    }
+    return mapping;
+}
+/**
+ * Item: Move — move_item_to_group within the board, or move_item_to_board
+ * with an optional columns_mapping for cross-board moves. The mapping comes
+ * from the guided mapper rows when any are configured, otherwise from the
+ * raw-JSON escape hatch in Options; either way it is completed to the
+ * full-board mapping the API demands. Exported for unit tests.
+ */
+async function moveItem(client, itemIndex) {
+    const itemId = this.getNodeParameter('itemId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const destination = this.getNodeParameter('moveDestination', itemIndex);
+    if (destination === 'group') {
+        const targetGroupId = this.getNodeParameter('targetGroupId', itemIndex);
+        const data = await client.execute(`mutation ($itemId: ID!, $groupId: String!) {
+				move_item_to_group(item_id: $itemId, group_id: $groupId) {
+					id
+					name
+					url
+					board { id name }
+					group { id title }
+				}
+			}`, itemIndex, { itemId, groupId: targetGroupId });
+        return (data.move_item_to_group ?? {});
+    }
+    const targetBoardId = this.getNodeParameter('targetBoardId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const targetGroupId = this.getNodeParameter('targetBoardGroupId', itemIndex);
+    const moveOptions = this.getNodeParameter('moveOptions', itemIndex, {});
+    const mappingUi = this.getNodeParameter('columnsMappingUi', itemIndex, {});
+    let pickedMapping;
+    const uiRows = mappingUi.mappings ?? [];
+    if (uiRows.length > 0) {
+        pickedMapping = uiRows.map((row, rowIndex) => {
+            const source = typeof row.source === 'string' ? row.source.trim() : '';
+            const target = typeof row.target === 'string' ? row.target.trim() : '';
+            if (!source || !target) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Columns Mapping row ${rowIndex + 1} needs both a source and a target column`, { itemIndex });
+            }
+            return { source, target };
+        });
+    }
+    else {
+        const rawMapping = moveOptions.columnsMapping;
+        if (rawMapping !== undefined && rawMapping !== null && rawMapping !== '') {
+            const parsed = typeof rawMapping === 'string' ? safeJsonParse(rawMapping) : rawMapping;
+            if (!Array.isArray(parsed)) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Columns Mapping must be a JSON array of {"source", "target"} pairs', { itemIndex });
+            }
+            if (parsed.length > 0) {
+                pickedMapping = parsed;
+            }
+        }
+    }
+    // The API rejects partial mappings ("Columns mapping is not in the
+    // expected format"), so complete the configured pairs against both
+    // boards' real columns before sending.
+    let columnsMapping;
+    if (pickedMapping) {
+        const sourceBoardId = this.getNodeParameter('boardId', itemIndex, undefined, {
+            extractValue: true,
+        });
+        const boardData = await client.execute('query ($ids: [ID!]) { boards(ids: $ids) { id columns { id type } } }', itemIndex, { ids: [sourceBoardId, targetBoardId] });
+        const boards = (boardData.boards ?? []);
+        const sourceColumns = boards.find((board) => board.id === String(sourceBoardId))?.columns ?? [];
+        const targetColumns = boards.find((board) => board.id === String(targetBoardId))?.columns ?? [];
+        try {
+            columnsMapping = completeMoveColumnsMapping(pickedMapping, sourceColumns, targetColumns);
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, { itemIndex });
+        }
+    }
+    const data = await client.execute(`mutation ($boardId: ID!, $groupId: ID!, $itemId: ID!, $columnsMapping: [ColumnMappingInput!]) {
+			move_item_to_board(
+				board_id: $boardId,
+				group_id: $groupId,
+				item_id: $itemId,
+				columns_mapping: $columnsMapping
+			) {
+				id
+				name
+				url
+				board { id name }
+				group { id title }
+			}
+		}`, itemIndex, {
+        boardId: targetBoardId,
+        groupId: targetGroupId,
+        itemId,
+        columnsMapping: columnsMapping ?? null,
+    });
+    return (data.move_item_to_board ?? {});
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Flattens column values into { [column title]: text }. Status rollups
+ * (BatteryValue, multi-level boards) have no text — their label counts are
+ * rendered as "Done: 2, Stuck: 1" via the column's status labels.
+ * Linked-item columns (dependency / board_relation / mirror) also have no
+ * text — they fall back to display_value, the comma-separated linked item
+ * names ("" = no links, flattened to null). Exported for unit tests.
+ */
+function flattenItemColumns(columnValues) {
+    const columns = {};
+    for (const columnValue of columnValues) {
+        const title = columnValue.column?.title ?? columnValue.id;
+        if (columnValue.battery_value) {
+            columns[title] = (0, multiLevel_1.formatBatteryText)(columnValue.battery_value, columnValue.column?.settings_str);
+            continue;
+        }
+        columns[title] = columnValue.text ?? (columnValue.display_value || null);
+    }
+    return columns;
+}
+/**
+ * Builds the Item: Get query. Column values are scoped to the Select
+ * Columns option when set (empty = all columns — the ids argument is only
+ * sent when columns were picked, which cuts complexity cost and payload on
+ * big boards). Include All Item Info adds the metadata fields the base
+ * selection deliberately excludes. Exported for unit tests.
+ */
+function buildGetItemQuery(itemId, options) {
+    const columnIds = (0, filterOptions_1.normalizeIdList)(options.columnIds);
+    const scoped = columnIds.length > 0;
+    const extraFields = [
+        options.includeAllItemInfo === true
+            ? 'creator { id name email } email relative_link subscribers { id name }'
+            : '',
+        options.includeSubitems === true
+            ? 'subitems { id name state url parent_item { id name } }'
+            : '',
+        options.includeUpdates === true ? 'updates { id body created_at creator { id name } }' : '',
+    ].join('\n');
+    const columnArgs = scoped
+        ? `ids: $columnIds, ${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG}`
+        : multiLevel_1.COLUMN_VALUES_CALCULATED_ARG;
+    return {
+        query: `query ($ids: [ID!]${scoped ? ', $columnIds: [String!]' : ''}) {
+			items(ids: $ids) {
+				id
+				name
+				state
+				url
+				created_at
+				updated_at
+				board { id name }
+				group { id title }
+				parent_item { id name }
+				column_values(${columnArgs}) {
+					id type text value column { title settings_str }
+					${multiLevel_1.BATTERY_VALUE_FRAGMENT}
+					${multiLevel_1.LINKED_VALUE_FRAGMENTS}
+				}
+				${extraFields}
+			}
+		}`,
+        variables: scoped ? { ids: [itemId], columnIds } : { ids: [itemId] },
+    };
+}
+/**
+ * Item: Get — items(ids:) with optional subitems/updates/full metadata, and
+ * a Simplify Column Values Response mode that flattens column values into
+ * { [column title]: text }. Works at any depth of a multi-level board
+ * (subitems are items on the same board); rollup column values are included
+ * via the CALCULATED capability.
+ */
+async function getItem(client, itemIndex) {
+    const itemId = this.getNodeParameter('itemId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const simplify = this.getNodeParameter('simplify', itemIndex, true);
+    const options = this.getNodeParameter('getItemOptions', itemIndex, {});
+    const { query, variables } = buildGetItemQuery(itemId, options);
+    const data = await client.execute(query, itemIndex, variables);
+    const item = (data.items ?? [])[0];
+    if (!item) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Item ${itemId} not found`, { itemIndex });
+    }
+    if (!simplify)
+        return item;
+    const columns = flattenItemColumns((item.column_values ?? []));
+    const rest = { ...item };
+    delete rest.column_values;
+    return { ...rest, columns };
+}
+/**
+ * Search: one request against the entity's field on the cross-entity
+ * `search` root query. Which entity type is searched follows from the
+ * operation (SEARCH_OPERATION_ENTITY). Scale-safe by design: server-side
+ * relevance search, hard-capped at 20 results, no pagination (see
+ * accountSearch.ts for the verified API contract).
+ */
+async function searchAcrossAccount(client, itemIndex, operation) {
+    const entity = accountSearch_1.SEARCH_OPERATION_ENTITY[operation];
+    const searchText = this.getNodeParameter('searchQuery', itemIndex).trim();
+    const includeLiveData = this.getNodeParameter('includeLiveData', itemIndex, false) === true;
+    const options = this.getNodeParameter('searchOptions', itemIndex, {});
+    if (!searchText) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Query is required', {
+            itemIndex,
+            description: 'Provide the text to search for.',
+        });
+    }
+    const filters = {
+        boardIds: (0, filterOptions_1.normalizeIdList)(options.boardIds),
+        workspaceIds: (0, filterOptions_1.normalizeIdList)(options.workspaceIds),
+        creatorIds: (0, userLocator_1.extractUserRowIds)(options.creatorIds),
+        createdAfter: (0, filterOptions_1.toIso8601)(options.createdAfter),
+        createdBefore: (0, filterOptions_1.toIso8601)(options.createdBefore),
+        updatedAfter: (0, filterOptions_1.toIso8601)(options.updatedAfter),
+        updatedBefore: (0, filterOptions_1.toIso8601)(options.updatedBefore),
+    };
+    const plan = (0, accountSearch_1.buildAccountSearchPlan)(searchText, [entity], includeLiveData, options.searchLimit ?? 10, options.strategy, filters);
+    const data = await client.execute(plan.query, itemIndex, plan.variables);
+    return (0, accountSearch_1.flattenSearchResults)(data.search, [entity], includeLiveData);
+}
+/**
+ * Shapes the Get Column Value output: parsed text plus the raw API value.
+ * `value` arrives as a JSON-encoded string — decode it so workflows can
+ * address fields directly (e.g. {{$json.value.index}}); `valueRaw` keeps
+ * the original string for round-tripping into raw-JSON updates. Status
+ * rollups (BatteryValue, multi-level boards) have no text/value — they get
+ * label-count text plus batteryValue/isLeaf fields instead. Linked-item
+ * columns (dependency / board_relation / mirror) also have no text/value —
+ * text falls back to display_value (the linked items' names), and the raw
+ * link data lands in displayValue/linkedItemIds/linkedItems (+
+ * dependencyLinks for dependency columns).
+ */
+function formatColumnValueOutput(item, columnValue, columnId) {
+    let value = null;
+    if (columnValue?.value != null) {
+        value = safeJsonParse(columnValue.value);
+        if (value === undefined)
+            value = columnValue.value;
+    }
+    const output = {
+        itemId: item.id ?? null,
+        itemName: item.name ?? null,
+        columnId,
+        columnTitle: columnValue?.column?.title ?? null,
+        columnType: columnValue?.type ?? null,
+        text: columnValue?.text ?? null,
+        value: value,
+        valueRaw: columnValue?.value ?? null,
+    };
+    if (columnValue?.battery_value) {
+        output.text = (0, multiLevel_1.formatBatteryText)(columnValue.battery_value, columnValue.column?.settings_str);
+        output.batteryValue = columnValue.battery_value;
+        // is_leaf: false = calculated from children; true = static leaf value.
+        output.isLeaf = columnValue.is_leaf ?? null;
+    }
+    if (columnValue?.display_value !== undefined) {
+        output.text = columnValue.text ?? (columnValue.display_value || null);
+        output.displayValue = columnValue.display_value ?? '';
+        if (columnValue.linked_item_ids) {
+            output.linkedItemIds = columnValue.linked_item_ids;
+        }
+        if (columnValue.linked_items) {
+            output.linkedItems = columnValue.linked_items;
+        }
+        if (columnValue.dependency_links) {
+            output.dependencyLinks = columnValue.dependency_links;
+        }
+    }
+    return output;
+}
+/**
+ * Item: Get Column Value — items(ids:) { column_values(ids:) }, one column.
+ * A column with no value set still yields a record (text/value null), so
+ * downstream nodes can branch on emptiness without erroring.
+ */
+async function getColumnValue(client, itemIndex) {
+    const itemId = this.getNodeParameter('itemId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const columnId = this.getNodeParameter('columnId', itemIndex);
+    const data = await client.execute(`query ($ids: [ID!], $columnIds: [String!]) {
+			items(ids: $ids) {
+				id
+				name
+				column_values(ids: $columnIds, ${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG}) {
+					id type text value column { title settings_str }
+					${multiLevel_1.BATTERY_VALUE_FRAGMENT}
+					${multiLevel_1.LINKED_VALUE_DETAIL_FRAGMENTS}
+				}
+			}
+		}`, itemIndex, { ids: [itemId], columnIds: [columnId] });
+    const item = (data.items ?? [])[0];
+    if (!item) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Item ${itemId} not found`, { itemIndex });
+    }
+    const columnValue = (item.column_values ?? []).find((row) => row.id === columnId);
+    if (!columnValue) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Column ${columnId} not found on the item's board`, { itemIndex });
+    }
+    return formatColumnValueOutput(item, columnValue, columnId);
+}
+/**
+ * Item: Get Many — cursor pagination via items_page / next_items_page.
+ * Group and column-value filtering plus sorting all go through query_params,
+ * which keeps a single cursor across the whole query. Emits one item per
+ * record, plus an optional trailing { nextCursor } item for resuming.
+ *
+ * Include Subitems (multi-level boards) adds hierarchy_scope_config:
+ * "allItems" — subject to two verified API bugs handled here: order_by is
+ * silently ignored under that scope (blocked with an error), and an
+ * unfiltered all-items query returns an empty page (worked around with a
+ * tautological all-groups rule).
+ */
+async function getManyItems(client, itemIndex) {
+    const boardId = this.getNodeParameter('boardId', itemIndex, undefined, {
+        extractValue: true,
+    });
+    const options = this.getNodeParameter('options', itemIndex, {});
+    // No "Return All" — a bounded limit only, under Options with a default
+    // (node-wide convention). The helper still walks the cursor internally
+    // (100/request) until the limit is reached.
+    const limit = options.limit ?? constants_1.DEFAULT_LIMIT;
+    const groupIds = (0, filterOptions_1.normalizeIdList)(options.groupIds);
+    const columnIds = (0, filterOptions_1.normalizeIdList)(options.columnIds);
+    const startingCursor = (options.startingCursor ?? '');
+    const includeCursor = options.includeCursor === true;
+    const includeSubitems = options.includeSubitems === true;
+    if (includeSubitems && options.sortBy && !startingCursor) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Sort By Column cannot be combined with Include Subitems — the API silently ignores sorting when subitems are included. Remove one of the two options.', { itemIndex });
+    }
+    const filterRows = this.getNodeParameter('itemFilters', itemIndex, {}).rules ??
+        [];
+    const rules = [];
+    if (groupIds.length > 0) {
+        rules.push({ column_id: 'group', compare_value: groupIds, operator: 'any_of' });
+    }
+    if (filterRows.length > 0) {
+        // Column settings are needed to resolve status/dropdown label text
+        // into the label indexes the API filters by.
+        const columns = await (0, columnMapper_1.fetchColumns)(this, boardId, itemIndex);
+        // Rollup status columns (BatteryValue) return silently wrong filter
+        // results — the picker hides them, this guards expression-set IDs.
+        const rollupStatusColumns = (0, itemFilters_1.findRollupStatusRuleColumns)(filterRows, columns);
+        if (rollupStatusColumns.length > 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot filter on ${rollupStatusColumns.join(', ')}: status columns that roll up child values (multi-level boards) return unreliable filter results in the monday API. Filter on a different column, or filter the output in n8n instead.`, { itemIndex });
+        }
+        // Stale dropdown selections (n8n keeps the operator when the column
+        // changes) and expression-mode column IDs can pair a column with an
+        // operator its type rejects — fail with the supported list up front.
+        const unsupportedOperatorRules = (0, itemFilters_1.findUnsupportedOperatorRules)(filterRows, columns);
+        if (unsupportedOperatorRules.length > 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), (0, itemFilters_1.formatUnsupportedOperatorMessage)(unsupportedOperatorRules), { itemIndex });
+        }
+        rules.push(...(0, itemFilters_1.buildFilterRules)(filterRows, columns));
+    }
+    if (includeSubitems && rules.length === 0 && !startingCursor) {
+        // Verified API bug: the all-items scope returns an empty page when no
+        // rules are set at all. A rule matching every group is a no-op filter.
+        rules.push((0, multiLevel_1.buildAllGroupsRule)(await (0, multiLevel_1.fetchBoardGroupIds)(client, itemIndex, boardId)));
+    }
+    const orderBy = options.sortBy
+        ? [{ column_id: options.sortBy, direction: options.sortDirection ?? 'asc' }]
+        : undefined;
+    let queryParams = null;
+    if (rules.length > 0 || orderBy) {
+        queryParams = {};
+        if (rules.length > 0) {
+            queryParams.rules = rules;
+            queryParams.operator = options.filtersMatch ?? 'and';
+        }
+        if (orderBy) {
+            queryParams.order_by = orderBy;
+        }
+    }
+    // Column IDs come from the picker or an expression; serialize them as a
+    // JSON string array, which is valid GraphQL list syntax for [String!].
+    // Empty selection = all columns. The item name is a top-level field, so
+    // it is always present regardless of this selection. CALCULATED is
+    // always requested — without it, rollup columns (multi-level boards)
+    // are silently missing from column_values.
+    const columnArgs = columnIds.length > 0
+        ? `(ids: ${JSON.stringify(columnIds)}, ${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG})`
+        : `(${multiLevel_1.COLUMN_VALUES_CALCULATED_ARG})`;
+    const itemFields = `
+		id
+		name
+		state
+		url
+		created_at
+		updated_at
+		group { id title }
+		${includeSubitems ? 'parent_item { id name }' : ''}
+		column_values${columnArgs} { id type text value ${multiLevel_1.BATTERY_VALUE_FRAGMENT} ${multiLevel_1.LINKED_VALUE_FRAGMENTS} }
+	`;
+    // The hierarchy scope only exists on the first query; follow-up
+    // next_items_page calls inherit it through the cursor.
+    const scopeArg = includeSubitems ? ', hierarchy_scope_config: "allItems"' : '';
+    const { rows, nextCursor } = await (0, pagination_1.fetchAllByCursor)({
+        client,
+        itemIndex,
+        firstQuery: `query ($boardId: [ID!], $limit: Int!, $queryParams: ItemsQuery) {
+			boards(ids: $boardId) {
+				items_page(limit: $limit, query_params: $queryParams${scopeArg}) {
+					cursor
+					items { ${itemFields} }
+				}
+			}
+		}`,
+        firstVariables: {
+            boardId: [boardId],
+            queryParams,
+        },
+        extractFirstPage: (data) => {
+            const board = data.boards?.[0];
+            if (!board)
+                throw (0, boardLocator_1.boardNotFoundError)(this.getNode(), boardId, itemIndex);
+            const page = board.items_page;
+            return page ? { cursor: page.cursor, items: page.items } : undefined;
+        },
+        itemFields,
+        limit,
+        startCursor: startingCursor || undefined,
+    });
+    return includeCursor ? [...rows, { nextCursor }] : rows;
+}
+//# sourceMappingURL=item.execute.js.map