n8n-nodes-selfhosthub
Version:
Collection of n8n nodes for self-hosted AI services, including Leonardo.ai integration for AI image and content generation capabilities.
240 lines • 8.63 kB
JavaScript
;
// nodes/CreateJ2vMovie/CreateJ2vMovie.node.ts
Object.defineProperty(exports, "__esModule", { value: true });
exports.CreateJ2vMovie = void 0;
exports.extractErrorMessage = extractErrorMessage;
exports.extractParameterErrorMessage = extractParameterErrorMessage;
exports.extractMainErrorMessage = extractMainErrorMessage;
exports.isEmptyRequest = isEmptyRequest;
exports.createBaseArray = createBaseArray;
const properties_1 = require("./presentation/properties");
const collector_1 = require("./core/collector");
const buildRequest_1 = require("./core/buildRequest");
const validator_1 = require("./core/validator");
/**
* n8n node for creating videos using the JSON2Video API
*/
class CreateJ2vMovie {
constructor() {
this.description = {
displayName: 'Self-Host Hub (JSON2Video)',
name: 'createJ2vMovie',
icon: 'file:createJ2vMovie.png',
group: ['transform'],
version: 2,
subtitle: '={{$parameter["advancedMode"] ? "Advanced Mode" : "Create Movie"}}',
description: 'Create videos with the JSON2Video API',
defaults: {
name: 'Create JSON2Video Movie',
},
inputs: [
{
displayName: '',
type: "main" /* NodeConnectionType.Main */,
},
],
outputs: [
{
displayName: '',
type: "main" /* NodeConnectionType.Main */,
},
],
credentials: [
{
name: 'json2VideoApiCredentials',
required: true,
},
],
requestDefaults: {
headers: {
Accept: 'application/json',
'Content-Type': 'application/json',
},
},
properties: (0, properties_1.getAllNodeProperties)(),
};
}
/**
* Execute the node for each input item
*/
async execute() {
const items = this.getInputData();
if (items.length === 0) {
return [[]];
}
const returnData = [];
for (let i = 0; i < items.length; i++) {
try {
// Collect and validate parameters
const collectedParameters = collector_1.collectParameters.call(this, i);
const parameterValidation = (0, collector_1.validateCollectedParameters)(collectedParameters);
// Build API request
const buildResult = (0, buildRequest_1.buildRequest)(collectedParameters);
// Validate complete request
const validationResult = (0, validator_1.validateBuildResult)(buildResult, {
level: 'complete',
strictMode: true,
includeWarnings: true,
validateElements: true,
});
if (!validationResult.isValid) {
throw new Error(validationResult.errors.join('; '));
}
// Prepare API request
const credentials = await this.getCredentials('json2VideoApiCredentials');
if (!credentials || !credentials.apiKey) {
throw new Error('JSON2Video API credentials are required');
}
const baseUrl = 'https://api.json2video.com/v2/movies';
let apiUrl = baseUrl;
const urlParams = new URLSearchParams();
// Add optional query parameters
const webhookUrl = this.getNodeParameter('webhookUrl', i, '');
if (webhookUrl) {
urlParams.append('webhook', webhookUrl);
}
const recordId = this.getNodeParameter('recordId', i, '');
if (recordId) {
urlParams.append('id', recordId);
}
if (urlParams.toString()) {
apiUrl += '?' + urlParams.toString();
}
const requestOptions = {
method: 'POST',
url: apiUrl,
headers: {
'x-api-key': credentials.apiKey,
'Content-Type': 'application/json',
},
body: buildResult.request,
json: true,
};
const response = await this.helpers.request(requestOptions);
// Process response
const responseData = processApiResponse(response.body);
// Add execution metadata to response
for (const responseItem of responseData) {
returnData.push({
json: {
...responseItem,
itemIndex: i,
timestamp: new Date().toISOString(),
},
pairedItem: { item: i },
});
}
}
catch (error) {
const errorMessage = extractMainErrorMessage(extractErrorMessage(error));
if (this.continueOnFail()) {
returnData.push({
json: {
error: errorMessage,
itemIndex: i,
timestamp: new Date().toISOString(),
},
pairedItem: { item: i },
});
}
else {
throw new Error(`Item ${i + 1} processing failed: ${errorMessage}`);
}
}
}
return [returnData];
}
}
exports.CreateJ2vMovie = CreateJ2vMovie;
// =============================================================================
// UTILITY FUNCTIONS
// =============================================================================
/**
* Extract error message from various error types
*/
function extractErrorMessage(error) {
if (error instanceof Error) {
return error.message || 'Unknown error occurred';
}
return 'Unknown error occurred';
}
/**
* Extract parameter-specific error messages
*/
function extractParameterErrorMessage(error) {
const message = extractErrorMessage(error);
const parameterErrorPrefix = 'Parameter validation failed: ';
if (message.startsWith(parameterErrorPrefix)) {
return message.substring(parameterErrorPrefix.length);
}
return message;
}
/**
* Extract main error by removing common error prefixes
*/
function extractMainErrorMessage(message) {
const errorPrefixes = [
'Request building failed: ',
'Request validation failed: ',
'Failed to collect parameters for operation \'',
'Processing failed: ',
'API error: ',
'Network error: ',
'Authentication failed: ',
'Invalid operation: ',
'Build failed: ',
'Validation failed: ',
'Parameter validation failed: ',
];
for (const prefix of errorPrefixes) {
if (message.startsWith(prefix)) {
let cleaned = message.substring(prefix.length);
// Handle operation-specific error format
if (prefix.includes('operation') && cleaned.includes('\': ')) {
cleaned = cleaned.split('\': ')[1];
}
return cleaned;
}
}
return message;
}
/**
* Check if request contains meaningful content
*/
function isEmptyRequest(request) {
if (!request || Object.keys(request).length === 0) {
return true;
}
if (request.elements && request.elements.length > 0) {
return false;
}
if (request.scenes && Array.isArray(request.scenes)) {
if (request.scenes.length === 0) {
return true;
}
const hasContent = request.scenes.some((scene) => scene && scene.elements && Array.isArray(scene.elements) && scene.elements.length > 0);
if (!hasContent) {
return true;
}
}
return false;
}
/**
* Create base return array structure
*/
function createBaseArray() {
return [[]];
}
/**
* Process API response into standardized format
*/
function processApiResponse(responseData) {
if (Array.isArray(responseData)) {
return responseData;
}
if (responseData) {
return [responseData];
}
return [{}];
}
//# sourceMappingURL=CreateJ2vMovie.node.js.map