@dendaio/n8n-nodes-collection
Version:
🚀 Comprehensive n8n node collection for financial analysis and automation. Features 55+ technical indicators (RSI, MACD, Bollinger Bands), 32+ candlestick patterns (Doji, Hammer, Engulfing), automated trading strategies, RSS feed processing, and OAuth2 v
423 lines • 19.2 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.VolatilityIndicators = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const indicatorts = __importStar(require("indicatorts"));
const technicalindicators = __importStar(require("technicalindicators"));
class VolatilityIndicators {
constructor() {
this.description = {
displayName: 'Volatility Indicators',
name: 'volatilityIndicators',
icon: 'file:icon.svg',
group: ['transform'],
version: 1,
description: 'Calculate volatility indicators using the indicatorts library',
defaults: {
name: 'Volatility Indicators',
},
inputs: ["main"],
outputs: ["main"],
properties: [
{
displayName: 'Indicators',
name: 'indicators',
type: 'multiOptions',
options: [
{
name: 'Acceleration Bands (AB)',
value: 'accelerationBands',
description: 'Volatility indicator that shows price channels',
},
{
name: 'Average True Range (ATR)',
value: 'averageTrueRange',
description: 'Measures market volatility by decomposing the entire range',
},
{
name: 'Bollinger Bands (BB)',
value: 'bollingerBands',
description: 'Volatility indicator with upper and lower bands',
},
{
name: 'Bollinger Bands Width (BBW)',
value: 'bollingerBandsWidth',
description: 'Measures the width of Bollinger Bands',
},
{
name: 'Chandelier Exit (CE)',
value: 'chandelierExit',
description: 'Volatility-based trailing stop indicator',
},
{
name: 'Donchian Channel (DC)',
value: 'donchianChannel',
description: 'Volatility indicator showing the highest high and lowest low',
},
{
name: 'Keltner Channel (KC)',
value: 'keltnerChannel',
description: 'Volatility-based envelope indicator',
},
{
name: 'Moving Standard Deviation (MSTD)',
value: 'movingStandardDeviation',
description: 'Measures the dispersion of prices from their moving average',
},
{
name: 'Projection Oscillator (PO)',
value: 'projectionOscillator',
description: 'Momentum oscillator that measures the position of price within its range',
},
{
name: 'Standard Deviation (SD)',
value: 'standardDeviation',
description: 'Measures the dispersion of values from their mean',
},
{
name: 'True Range (TR)',
value: 'trueRange',
description: 'Measures market volatility',
},
{
name: 'Ulcer Index (UI)',
value: 'ulcerIndex',
description: 'Measures downside risk and volatility',
},
],
default: ['averageTrueRange'],
noDataExpression: true,
},
{
displayName: 'OHLCV Data',
name: 'ohlcvData',
type: 'string',
default: '={{ $json.ohlcv }}',
description: 'JSON string containing OHLCV data array',
},
{
displayName: 'Acceleration Bands Period',
name: 'abPeriod',
type: 'number',
default: 20,
description: 'Period for Acceleration Bands calculation',
displayOptions: {
show: {
indicators: ['accelerationBands'],
},
},
},
{
displayName: 'Acceleration Bands Multiplier',
name: 'abMultiplier',
type: 'number',
default: 4,
description: 'Multiplier for Acceleration Bands calculation',
displayOptions: {
show: {
indicators: ['accelerationBands'],
},
},
},
{
displayName: 'ATR Period',
name: 'atrPeriod',
type: 'number',
default: 14,
description: 'Period for ATR calculation',
displayOptions: {
show: {
indicators: ['averageTrueRange'],
},
},
},
{
displayName: 'Bollinger Bands Period',
name: 'bbPeriod',
type: 'number',
default: 20,
description: 'Period for Bollinger Bands calculation',
displayOptions: {
show: {
indicators: ['bollingerBands', 'bollingerBandsWidth'],
},
},
},
{
displayName: 'Chandelier Exit Period',
name: 'cePeriod',
type: 'number',
default: 22,
description: 'Period for Chandelier Exit calculation',
displayOptions: {
show: {
indicators: ['chandelierExit'],
},
},
},
{
displayName: 'Donchian Channel Period',
name: 'dcPeriod',
type: 'number',
default: 20,
description: 'Period for Donchian Channel calculation',
displayOptions: {
show: {
indicators: ['donchianChannel'],
},
},
},
{
displayName: 'Keltner Channel Period',
name: 'kcPeriod',
type: 'number',
default: 20,
description: 'Period for Keltner Channel calculation',
displayOptions: {
show: {
indicators: ['keltnerChannel'],
},
},
},
{
displayName: 'Moving Standard Deviation Period',
name: 'mstdPeriod',
type: 'number',
default: 20,
description: 'Period for Moving Standard Deviation calculation',
displayOptions: {
show: {
indicators: ['movingStandardDeviation'],
},
},
},
{
displayName: 'Projection Oscillator Period',
name: 'poPeriod',
type: 'number',
default: 14,
description: 'Period for Projection Oscillator calculation',
displayOptions: {
show: {
indicators: ['projectionOscillator'],
},
},
},
{
displayName: 'Projection Oscillator Smooth',
name: 'poSmooth',
type: 'number',
default: 3,
description: 'Smooth period for Projection Oscillator calculation',
displayOptions: {
show: {
indicators: ['projectionOscillator'],
},
},
},
{
displayName: 'Standard Deviation Period',
name: 'sdPeriod',
type: 'number',
default: 20,
description: 'Period for Standard Deviation calculation',
displayOptions: {
show: {
indicators: ['standardDeviation'],
},
},
},
{
displayName: 'Ulcer Index Period',
name: 'uiPeriod',
type: 'number',
default: 14,
description: 'Period for Ulcer Index calculation',
displayOptions: {
show: {
indicators: ['ulcerIndex'],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
options: [
{
displayName: 'Return Type',
name: 'returnType',
type: 'options',
options: [
{
name: 'Values Only',
value: 'values',
description: 'Return only the calculated values',
},
{
name: 'With Metadata',
value: 'metadata',
description: 'Return values with additional metadata',
},
],
default: 'values',
},
],
},
],
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
for (let i = 0; i < items.length; i++) {
try {
const indicators = this.getNodeParameter('indicators', i);
const ohlcvDataString = this.getNodeParameter('ohlcvData', i);
const options = this.getNodeParameter('options', i, {});
let ohlcvData;
try {
ohlcvData = JSON.parse(ohlcvDataString);
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to parse OHLCV data: ${error instanceof Error ? error.message : 'Unknown error'}`);
}
if (!Array.isArray(ohlcvData) || ohlcvData.length === 0) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'OHLCV data must be a non-empty array');
}
const highs = ohlcvData.map((candle) => candle[1]);
const lows = ohlcvData.map((candle) => candle[2]);
const closes = ohlcvData.map((candle) => candle[3]);
const indicatorPromises = indicators.map(async (indicator) => {
const mappedParameters = {};
let result;
switch (indicator) {
case 'accelerationBands':
mappedParameters.period = this.getNodeParameter('abPeriod', i, 20);
mappedParameters.multiplier = this.getNodeParameter('abMultiplier', i, 4);
result = indicatorts.accelerationBands(highs, lows, closes, mappedParameters);
break;
case 'averageTrueRange':
mappedParameters.period = this.getNodeParameter('atrPeriod', i, 14);
result = indicatorts.averageTrueRange(highs, lows, closes, mappedParameters);
break;
case 'bollingerBands':
mappedParameters.period = this.getNodeParameter('bbPeriod', i, 20);
result = indicatorts.bollingerBands(closes, mappedParameters);
break;
case 'bollingerBandsWidth':
mappedParameters.period = this.getNodeParameter('bbPeriod', i, 20);
const bbResult = indicatorts.bollingerBands(closes, mappedParameters);
result = indicatorts.bollingerBandsWidth(bbResult, mappedParameters);
break;
case 'chandelierExit':
mappedParameters.period = this.getNodeParameter('cePeriod', i, 22);
result = indicatorts.chandelierExit(highs, lows, closes, mappedParameters);
break;
case 'donchianChannel':
mappedParameters.period = this.getNodeParameter('dcPeriod', i, 20);
result = indicatorts.donchianChannel(closes, mappedParameters);
break;
case 'keltnerChannel':
mappedParameters.period = this.getNodeParameter('kcPeriod', i, 20);
result = indicatorts.keltnerChannel(highs, lows, closes, mappedParameters);
break;
case 'movingStandardDeviation':
mappedParameters.period = this.getNodeParameter('mstdPeriod', i, 20);
result = indicatorts.movingStandardDeviation(closes, mappedParameters);
break;
case 'projectionOscillator':
mappedParameters.period = this.getNodeParameter('poPeriod', i, 14);
mappedParameters.smooth = this.getNodeParameter('poSmooth', i, 3);
result = indicatorts.projectionOscillator(highs, lows, closes, mappedParameters);
break;
case 'standardDeviation':
mappedParameters.period = this.getNodeParameter('sdPeriod', i, 20);
result = technicalindicators.sd({
values: closes,
period: mappedParameters.period,
});
break;
case 'trueRange':
result = indicatorts.trueRange(highs, lows, closes);
break;
case 'ulcerIndex':
mappedParameters.period = this.getNodeParameter('uiPeriod', i, 14);
result = indicatorts.ulcerIndex(closes, mappedParameters);
break;
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported indicator: ${indicator}`);
}
return {
indicator,
parameters: mappedParameters,
result,
};
});
const indicatorResults = await Promise.all(indicatorPromises);
const outputData = {
indicators: indicatorResults,
};
if (options.returnType === 'metadata') {
outputData.metadata = {
inputLength: ohlcvData.length,
indicatorsCount: indicators.length,
calculationTimestamp: new Date().toISOString(),
};
}
returnData.push({
json: outputData,
});
}
catch (error) {
if (this.continueOnFail()) {
returnData.push({
json: {
error: error instanceof Error ? error.message : 'Unknown error occurred',
},
});
continue;
}
throw error;
}
}
return [returnData];
}
}
exports.VolatilityIndicators = VolatilityIndicators;
//# sourceMappingURL=VolatilityIndicators.node.js.map