@kaia-team/n8n-nodes-kaia/dist/nodes/Kaia/apis/documentImportsApi.js

n8n nodes for Kaia LLM integration

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.documentImportsApiProperties = void 0;
exports.handleDocumentImportsApi = handleDocumentImportsApi;
const n8n_workflow_1 = require("n8n-workflow");
const utils_1 = require("../utils");
/**
 * Document Imports API Properties
 * Properties specific to the documentImports API resource (CSV imports)
 */
exports.documentImportsApiProperties = [
    {
        displayName: 'Operation',
        name: 'operation',
        type: 'options',
        noDataExpression: true,
        displayOptions: {
            show: {
                resource: ['documentImports'],
            },
        },
        options: [
            {
                name: 'Create',
                value: 'create',
                action: 'Create a CSV',
            },
            {
                name: 'Delete',
                value: 'delete',
                action: 'Delete a CSV',
            },
            {
                name: 'Import Data',
                value: 'importData',
                action: 'Import data for a CSV',
            },
            {
                name: 'List',
                value: 'list',
                action: 'List CSVs',
            },
            {
                name: 'Read',
                value: 'read',
                action: 'Read a CSV',
            },
            {
                name: 'Read Properties',
                value: 'readProperties',
                action: 'Read properties of a CSV',
            },
        ],
        default: 'list',
    },
    {
        displayName: 'CSV ID',
        name: 'documentImportId',
        type: 'string',
        default: '',
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['read', 'readProperties', 'importData', 'delete'],
            },
        },
        required: true,
    },
    {
        displayName: 'Binary File',
        name: 'binaryData',
        type: 'boolean',
        default: true,
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['create'],
            },
        },
        description: 'Whether the file to upload is binary',
    },
    {
        displayName: 'Input Binary Field',
        name: 'binaryPropertyName',
        type: 'string',
        default: 'data',
        required: true,
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['create'],
                binaryData: [true],
            },
        },
        description: 'Name of the input binary field containing the file to upload',
    },
    {
        displayName: 'File Content',
        name: 'fileContent',
        type: 'string',
        default: '',
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['create'],
                binaryData: [false],
            },
        },
        description: 'The text content of the file to upload',
    },
    {
        displayName: 'File Name',
        name: 'fileName',
        type: 'string',
        required: true,
        default: '',
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['create'],
            },
        },
        description: 'The name of the file to upload',
    },
    {
        displayName: 'Filter Columns',
        name: 'filter_columns',
        type: 'string',
        default: '',
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['importData'],
            },
        },
        description: 'Comma-separated filter columns',
    },
    {
        displayName: 'Searchable Columns',
        name: 'searchable_columns',
        type: 'string',
        required: true,
        default: '',
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['importData'],
            },
        },
        description: 'Comma-separated searchable columns',
    },
    // Property for list operation (based on handler usage)
    {
        displayName: 'User ID',
        name: 'user_id',
        type: 'string',
        default: '',
        displayOptions: {
            show: {
                resource: ['documentImports'],
                operation: ['list'],
            },
        },
        description: 'Filter imports by user ID',
    },
];
/**
 * Document Imports API Handler
 * Handles requests to the documentImports API (CSV imports)
 */
async function handleDocumentImportsApi(executeFunctions, itemIndex, adminUrl, adminToken) {
    const operation = executeFunctions.getNodeParameter('operation', itemIndex);
    const additionalFields = executeFunctions.getNodeParameter('additionalFields', itemIndex, {});
    const headers = (0, utils_1.createHeaders)(adminToken, additionalFields);
    if (operation === 'list') {
        const qs = {};
        const userId = executeFunctions.getNodeParameter('user_id', itemIndex, '');
        if (userId)
            qs.user_id = userId;
        const response = await executeFunctions.helpers.httpRequest({
            method: 'GET',
            url: `${adminUrl}/document_imports.json`,
            headers,
            qs,
        });
        return executeFunctions.helpers.returnJsonArray(response);
    }
    else if (operation === 'read') {
        let documentImportId = executeFunctions.getNodeParameter('documentImportId', itemIndex);
        documentImportId = (0, utils_1.extractIdFromUrlOrId)(documentImportId, 'document_imports');
        const response = await executeFunctions.helpers.httpRequest({
            method: 'GET',
            url: `${adminUrl}/document_imports/${documentImportId}.json`,
            headers,
        });
        return response;
    }
    else if (operation === 'create') {
        const isBinary = executeFunctions.getNodeParameter('binaryData', itemIndex, true);
        const fileName = executeFunctions.getNodeParameter('fileName', itemIndex, '');
        const formData = new FormData();
        if (isBinary) {
            const binaryPropertyName = executeFunctions.getNodeParameter('binaryPropertyName', itemIndex, 'data');
            const binaryDataBuffer = await executeFunctions.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
            // convert binary to blob
            const blob = new Blob([binaryDataBuffer], { type: 'application/octet-stream' });
            formData.append('document_import[file]', blob, fileName);
        }
        else {
            const fileContent = executeFunctions.getNodeParameter('fileContent', itemIndex, '');
            const blob = new Blob([fileContent], { type: 'text/csv' });
            formData.append('document_import[file]', blob, fileName);
        }
        headers['Content-Type'] = 'multipart/form-data';
        const response = await executeFunctions.helpers.httpRequest({
            method: 'POST',
            url: `${adminUrl}/document_imports.json`,
            body: formData,
            headers,
        });
        return response;
    }
    else if (operation === 'importData') {
        let documentImportId = executeFunctions.getNodeParameter('documentImportId', itemIndex);
        documentImportId = (0, utils_1.extractIdFromUrlOrId)(documentImportId, 'document_imports');
        const filterColumnsStr = executeFunctions.getNodeParameter('filter_columns', itemIndex, '');
        const searchableColumnsStr = executeFunctions.getNodeParameter('searchable_columns', itemIndex, '');
        const payload = {
            filter_columns: filterColumnsStr ? filterColumnsStr.split(',').map(s => s.trim()) : [],
            searchable_columns: searchableColumnsStr
                ? searchableColumnsStr.split(',').map(s => s.trim())
                : [],
        };
        const response = await executeFunctions.helpers.httpRequest({
            method: 'POST',
            url: `${adminUrl}/document_imports/${documentImportId}/create_data_shards.json`,
            body: { document_import: { ...payload } },
            headers,
        });
        return response; // TODO: May require backend modifications to allow method over API
    }
    else if (operation === 'delete') {
        let documentImportId = executeFunctions.getNodeParameter('documentImportId', itemIndex);
        documentImportId = (0, utils_1.extractIdFromUrlOrId)(documentImportId, 'document_imports');
        const response = await executeFunctions.helpers.httpRequest({
            method: 'DELETE',
            url: `${adminUrl}/document_imports/${documentImportId}.json`,
            headers,
        });
        return { success: true, deletedId: documentImportId };
    }
    else if (operation === 'readProperties') {
        let documentImportId = executeFunctions.getNodeParameter('documentImportId', itemIndex);
        documentImportId = (0, utils_1.extractIdFromUrlOrId)(documentImportId, 'document_imports');
        const response = await executeFunctions.helpers.httpRequest({
            method: 'GET',
            url: `${adminUrl}/document_imports/${documentImportId}/render_csv.json`,
            headers,
        });
        return response;
    }
    throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Unknown CSV operation: ${operation}`);
}
//# sourceMappingURL=documentImportsApi.js.map