@kaia-team/n8n-nodes-kaia
Version:
n8n nodes for Kaia LLM integration
482 lines • 17.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.databaseImportsApiProperties = void 0;
exports.handleDatabaseImportsApi = handleDatabaseImportsApi;
const n8n_workflow_1 = require("n8n-workflow");
const utils_1 = require("../utils");
/**
* Database Imports API Properties
* Properties specific to the databaseImports API resource
*/
exports.databaseImportsApiProperties = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['databaseImports'],
},
},
options: [
{
name: 'Analyze',
value: 'analyze',
action: 'Analyze a database import',
},
{
name: 'Connection Diagnostics',
value: 'connectionDiagnostics',
action: 'Get connection diagnostics',
},
{
name: 'Create Table',
value: 'createTable',
action: 'Create table for database import',
},
{
name: 'Create',
value: 'create',
action: 'Create a database import',
},
{
name: 'Delete',
value: 'delete',
action: 'Delete a database import',
},
{
name: 'Get Default Values',
value: 'getDefaults',
action: 'Get default values for new database import',
},
{
name: 'Inspect Table',
value: 'inspectTable',
action: 'Inspect a specific table',
},
{
name: 'List',
value: 'list',
action: 'List database imports',
},
{
name: 'Read',
value: 'read',
action: 'Read a database import',
},
{
name: 'Read Configuration',
value: 'readConfiguration',
action: 'Read configuration of a database import',
},
{
name: 'Repair Connection',
value: 'repairConnection',
action: 'Repair connection status',
},
{
name: 'Update',
value: 'update',
action: 'Update a database import',
},
],
default: 'list',
},
{
displayName: 'Database Import ID',
name: 'databaseImportId',
type: 'string',
default: '',
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['read', 'readConfiguration', 'analyze', 'update', 'delete', 'createTable'],
},
},
required: true,
description: 'The ID of the database import',
},
{
displayName: 'Binary File',
name: 'binaryData',
type: 'boolean',
default: true,
displayOptions: {
show: {
resource: ['databaseImports'],
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: ['databaseImports'],
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: ['databaseImports'],
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: ['databaseImports'],
operation: ['create'],
},
},
description: 'The name of the file to upload',
},
{
displayName: 'Table Name',
name: 'tableName',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['create'],
},
},
description: 'The name for the table to be created',
},
{
displayName: 'Submit Action',
name: 'submitAction',
type: 'options',
options: [
{
name: 'Quick Setup',
value: 'quick_setup',
},
{
name: 'Manual Setup',
value: 'manual_setup',
},
],
default: 'quick_setup',
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['create'],
},
},
description: 'The submit action for the database import',
},
{
displayName: 'Table Name to Inspect',
name: 'tableNameToInspect',
type: 'string',
default: '',
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['inspectTable'],
},
},
description: 'The name of the table to inspect',
},
{
displayName: 'Auto ID',
name: 'autoId',
type: 'boolean',
default: true,
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['update'],
},
},
description: 'Whether to auto-generate IDs',
},
{
displayName: 'ID Field',
name: 'idField',
type: 'string',
default: 'id',
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['update'],
},
},
description: 'The name of the field to use as the ID',
},
{
displayName: 'Field Mappings',
name: 'fieldMappings',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
placeholder: 'Add Field Mapping',
default: {},
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['update'],
},
},
options: [
{
name: 'mappings',
displayName: 'Field Mappings',
values: [
{
displayName: 'Field Name',
name: 'fieldName',
type: 'string',
default: '',
description: 'The name of the field',
},
{
displayName: 'Field Type',
name: 'fieldType',
type: 'options',
options: [
{ name: 'String', value: 'string' },
{ name: 'Text', value: 'text' },
{ name: 'Varchar', value: 'varchar' },
{ name: 'Integer', value: 'integer' },
{ name: 'Bigint', value: 'bigint' },
{ name: 'Number', value: 'number' },
{ name: 'Numeric', value: 'numeric' },
{ name: 'Float', value: 'float' },
{ name: 'Decimal', value: 'decimal' },
{ name: 'Date', value: 'date' },
{ name: 'DateTime', value: 'datetime' },
],
default: 'string',
description: 'The type of the field',
},
],
},
],
},
{
displayName: 'Drop Table',
name: 'dropTable',
type: 'boolean',
default: false,
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['delete'],
},
},
description: 'Whether to drop the table',
},
{
displayName: 'Delete Function',
name: 'deleteFunction',
type: 'boolean',
default: false,
displayOptions: {
show: {
resource: ['databaseImports'],
operation: ['delete'],
},
},
},
];
/**
* Database Imports API Handler
* Handles requests to the databaseImports API
*/
async function handleDatabaseImportsApi(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 response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports.json`,
headers,
});
return executeFunctions.helpers.returnJsonArray(response);
}
else if (operation === 'read') {
let databaseImportId = executeFunctions.getNodeParameter('databaseImportId', itemIndex);
databaseImportId = (0, utils_1.extractIdFromUrlOrId)(databaseImportId, 'database_imports');
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/${databaseImportId}.json`,
headers,
});
return response;
}
else if (operation === 'analyze') {
let databaseImportId = executeFunctions.getNodeParameter('databaseImportId', itemIndex);
databaseImportId = (0, utils_1.extractIdFromUrlOrId)(databaseImportId, 'database_imports');
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/${databaseImportId}/analyze.json`,
headers,
});
return response;
}
else if (operation === 'readConfiguration') {
let databaseImportId = executeFunctions.getNodeParameter('databaseImportId', itemIndex);
databaseImportId = (0, utils_1.extractIdFromUrlOrId)(databaseImportId, 'database_imports');
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/${databaseImportId}/configure.json`,
headers,
});
return response;
}
else if (operation === 'inspectTable') {
const tableName = executeFunctions.getNodeParameter('tableNameToInspect', itemIndex);
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/inspect_table.json`,
headers,
qs: { table_name: tableName },
});
return response;
}
else if (operation === 'repairConnection') {
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/repair_connection.json`,
headers,
});
return response;
}
else if (operation === 'connectionDiagnostics') {
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/connection_diagnostics.json`,
headers,
});
return response;
}
else if (operation === 'getDefaults') {
const response = await executeFunctions.helpers.httpRequest({
method: 'GET',
url: `${adminUrl}/database_imports/new.json`,
headers,
});
return response;
}
else if (operation === 'create') {
const isBinary = executeFunctions.getNodeParameter('binaryData', itemIndex, true);
const fileName = executeFunctions.getNodeParameter('fileName', itemIndex, '');
const tableName = executeFunctions.getNodeParameter('tableName', itemIndex, '');
const submitAction = executeFunctions.getNodeParameter('submitAction', itemIndex, 'quick_setup');
const formData = new FormData();
if (isBinary) {
const binaryPropertyName = executeFunctions.getNodeParameter('binaryPropertyName', itemIndex, 'data');
const binaryDataBuffer = await executeFunctions.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
const blob = new Blob([binaryDataBuffer], { type: 'application/octet-stream' });
formData.append('database_import[file]', blob, fileName);
}
else {
const fileContent = executeFunctions.getNodeParameter('fileContent', itemIndex, '');
const blob = new Blob([fileContent], { type: 'text/csv' });
formData.append('database_import[file]', blob, fileName);
}
formData.append('database_import[table_name]', tableName);
formData.append('submit_action', submitAction);
// Remove Content-Type header to let FormData set it with boundary
delete headers['Content-Type'];
const response = await executeFunctions.helpers.httpRequest({
method: 'POST',
url: `${adminUrl}/database_imports.json`,
body: formData,
headers,
});
return response;
}
else if (operation === 'update') {
let databaseImportId = executeFunctions.getNodeParameter('databaseImportId', itemIndex);
databaseImportId = (0, utils_1.extractIdFromUrlOrId)(databaseImportId, 'database_imports');
const autoId = executeFunctions.getNodeParameter('autoId', itemIndex, true);
const fieldMappings = executeFunctions.getNodeParameter('fieldMappings', itemIndex, {});
const idField = executeFunctions.getNodeParameter('idField', itemIndex, 'id');
const payload = {
database_import: {
auto_id: autoId,
id_field: idField,
field_mappings: {},
},
};
// Process field mappings
if (fieldMappings.mappings) {
const mappings = fieldMappings.mappings;
for (const mapping of mappings) {
const fieldName = mapping.fieldName;
const fieldType = mapping.fieldType;
if (fieldName && fieldType) {
payload.database_import.field_mappings[fieldName] = fieldType;
}
}
}
const response = await executeFunctions.helpers.httpRequest({
method: 'PATCH',
url: `${adminUrl}/database_imports/${databaseImportId}.json`,
body: payload,
headers,
});
return response;
}
else if (operation === 'createTable') {
let databaseImportId = executeFunctions.getNodeParameter('databaseImportId', itemIndex);
databaseImportId = (0, utils_1.extractIdFromUrlOrId)(databaseImportId, 'database_imports');
const response = await executeFunctions.helpers.httpRequest({
method: 'POST',
url: `${adminUrl}/database_imports/${databaseImportId}/create_table.json`,
headers,
});
return response;
}
else if (operation === 'delete') {
let body = {};
let databaseImportId = executeFunctions.getNodeParameter('databaseImportId', itemIndex);
databaseImportId = (0, utils_1.extractIdFromUrlOrId)(databaseImportId, 'database_imports');
const dropTable = executeFunctions.getNodeParameter('dropTable', itemIndex, false);
if (dropTable) {
body.drop_table = 'true';
}
const deleteFunction = executeFunctions.getNodeParameter('deleteFunction', itemIndex, false);
if (deleteFunction) {
body.delete_function = 'true';
}
const response = await executeFunctions.helpers.httpRequest({
method: 'DELETE',
url: `${adminUrl}/database_imports/${databaseImportId}.json`,
headers,
body,
});
return { success: true, deletedId: databaseImportId };
}
throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Unknown database import operation: ${operation}`);
}
//# sourceMappingURL=databaseImportsApi.js.map