n8n-nodes-helixdb
Version:
n8n community node to integrate with HelixDB - the time-series database for modern applications
382 lines • 15.8 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HelixDb = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const helix_ts_1 = __importDefault(require("helix-ts"));
class HelixDb {
constructor() {
this.description = {
displayName: 'HelixDB',
name: 'helixDb',
icon: 'file:helixdb.svg',
group: ['database'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Interact with HelixDB - the time-series database for modern applications. Requires HelixDB server running with deployed HelixQL queries.',
defaults: {
name: 'HelixDB',
},
inputs: ["main"],
outputs: ["main"],
credentials: [
{
name: 'helixDbApi',
required: true,
},
],
usableAsTool: true,
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Record',
value: 'record',
description: 'Work with records in HelixDB',
},
{
name: 'Vector',
value: 'vector',
description: 'Work with vectors in HelixDB',
},
{
name: 'Raw Query',
value: 'rawQuery',
description: 'Execute raw HelixQL queries',
},
],
default: 'record',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['record'],
},
},
options: [
{
name: 'Insert',
value: 'insert',
description: 'Insert a new record',
action: 'Insert a record',
},
{
name: 'Get',
value: 'get',
description: 'Get a record by ID',
action: 'Get a record',
},
{
name: 'Update',
value: 'update',
description: 'Update an existing record',
action: 'Update a record',
},
{
name: 'Delete',
value: 'delete',
description: 'Delete a record',
action: 'Delete a record',
},
],
default: 'insert',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['vector'],
},
},
options: [
{
name: 'Insert Vector',
value: 'insertVector',
description: 'Insert a new vector',
action: 'Insert a vector',
},
{
name: 'Search Vectors',
value: 'searchVectors',
description: 'Search for similar vectors',
action: 'Search vectors',
},
{
name: 'Delete Vector',
value: 'deleteVector',
description: 'Delete a vector',
action: 'Delete a vector',
},
],
default: 'insertVector',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['rawQuery'],
},
},
options: [
{
name: 'Run HelixQL',
value: 'runHelixQL',
description: 'Execute a raw HelixQL query',
action: 'Run helix ql query',
},
],
default: 'runHelixQL',
description: 'Execute raw HelixQL queries',
},
{
displayName: 'Table Name',
name: 'tableName',
type: 'string',
default: '',
placeholder: 'users',
description: 'Name of the table to operate on',
displayOptions: {
show: {
resource: ['record'],
},
},
},
{
displayName: 'Record ID',
name: 'recordId',
type: 'string',
default: '',
description: 'ID of the record',
displayOptions: {
show: {
resource: ['record'],
operation: ['get', 'update', 'delete'],
},
},
},
{
displayName: 'Record Data',
name: 'recordData',
type: 'json',
default: '{}',
description: 'Record data as JSON object',
displayOptions: {
show: {
resource: ['record'],
operation: ['insert', 'update'],
},
},
},
{
displayName: 'Collection Name',
name: 'collectionName',
type: 'string',
default: '',
placeholder: 'embeddings',
description: 'Name of the vector collection',
displayOptions: {
show: {
resource: ['vector'],
},
},
},
{
displayName: 'Vector ID',
name: 'vectorId',
type: 'string',
default: '',
description: 'ID of the vector',
displayOptions: {
show: {
resource: ['vector'],
operation: ['deleteVector'],
},
},
},
{
displayName: 'Vector Data',
name: 'vectorData',
type: 'json',
default: '[]',
description: 'Vector data as JSON array of numbers',
displayOptions: {
show: {
resource: ['vector'],
operation: ['insertVector', 'searchVectors'],
},
},
},
{
displayName: 'Vector Metadata',
name: 'vectorMetadata',
type: 'json',
default: '{}',
description: 'Optional metadata for the vector',
displayOptions: {
show: {
resource: ['vector'],
operation: ['insertVector'],
},
},
},
{
displayName: 'Search Limit',
name: 'searchLimit',
type: 'number',
default: 10,
description: 'Maximum number of results to return',
displayOptions: {
show: {
resource: ['vector'],
operation: ['searchVectors'],
},
},
},
{
displayName: 'HelixQL Query',
name: 'helixqlQuery',
type: 'string',
typeOptions: {
rows: 5,
},
default: '',
placeholder: 'getUserByName',
description: 'The name of the HelixQL query to execute (must be already deployed to HelixDB)',
displayOptions: {
show: {
resource: ['rawQuery'],
},
},
},
{
displayName: 'Query Parameters',
name: 'queryParameters',
type: 'json',
default: '{}',
description: 'Parameters for the HelixQL query as JSON object',
displayOptions: {
show: {
resource: ['rawQuery'],
},
},
},
],
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
const credentials = await this.getCredentials('helixDbApi');
const port = credentials.port;
const client = port === 6969 ? new helix_ts_1.default() : new helix_ts_1.default(port);
for (let i = 0; i < items.length; i++) {
try {
const resource = this.getNodeParameter('resource', i);
const operation = this.getNodeParameter('operation', i);
let result;
switch (`${resource}:${operation}`) {
case 'record:insert': {
const tableName = this.getNodeParameter('tableName', i);
const recordData = this.getNodeParameter('recordData', i);
result = await client.query(`add${tableName}`, recordData);
break;
}
case 'record:get': {
const tableName = this.getNodeParameter('tableName', i);
const recordId = this.getNodeParameter('recordId', i);
result = await client.query(`get${tableName}`, { id: recordId });
break;
}
case 'record:update': {
const tableName = this.getNodeParameter('tableName', i);
const recordId = this.getNodeParameter('recordId', i);
const recordData = this.getNodeParameter('recordData', i);
result = await client.query(`update${tableName}`, {
id: recordId,
...recordData
});
break;
}
case 'record:delete': {
const tableName = this.getNodeParameter('tableName', i);
const recordId = this.getNodeParameter('recordId', i);
result = await client.query(`delete${tableName}`, { id: recordId });
break;
}
case 'vector:insertVector': {
const collectionName = this.getNodeParameter('collectionName', i);
const vectorData = this.getNodeParameter('vectorData', i);
const vectorMetadata = this.getNodeParameter('vectorMetadata', i);
result = await client.query(`addVector${collectionName}`, {
vector: vectorData,
metadata: vectorMetadata,
});
break;
}
case 'vector:searchVectors': {
const collectionName = this.getNodeParameter('collectionName', i);
const vectorData = this.getNodeParameter('vectorData', i);
const searchLimit = this.getNodeParameter('searchLimit', i);
result = await client.query(`searchVector${collectionName}`, {
query: vectorData,
limit: searchLimit,
});
break;
}
case 'vector:deleteVector': {
const collectionName = this.getNodeParameter('collectionName', i);
const vectorId = this.getNodeParameter('vectorId', i);
result = await client.query(`deleteVector${collectionName}`, { id: vectorId });
break;
}
case 'rawQuery:runHelixQL': {
const helixqlQuery = this.getNodeParameter('helixqlQuery', i);
const queryParameters = this.getNodeParameter('queryParameters', i);
result = await client.query(helixqlQuery, queryParameters);
break;
}
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported operation: ${resource}:${operation}`, { itemIndex: i });
}
returnData.push({
json: result,
pairedItem: i,
});
}
catch (error) {
if (this.continueOnFail()) {
returnData.push({
json: { error: error.message },
pairedItem: i,
});
}
else {
if (error.context) {
error.context.itemIndex = i;
throw error;
}
throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
}
}
}
return [returnData];
}
}
exports.HelixDb = HelixDb;
//# sourceMappingURL=HelixDb.node.js.map