n8n/packages/nodes-base/nodes/ApiTemplateIo/ApiTemplateIo.node.ts
Iván Ovejero 1d27a9e87e
Improve node error handling (#1309)
* Add path mapping and response error interfaces

* Add error handling and throwing functionality

* Refactor error handling into a single function

* Re-implement error handling in Hacker News node

* Fix linting details

* Re-implement error handling in Spotify node

* Re-implement error handling in G Suite Admin node

* 🚧 create basic setup NodeError

* 🚧 add httpCodes

* 🚧 add path priolist

* 🚧 handle statusCode in error, adjust interfaces

* 🚧 fixing type issues w/Ivan

* 🚧 add error exploration

* 👔 fix linter issues

* 🔧 improve object check

* 🚧 remove path passing from NodeApiError

* 🚧 add multi error + refactor findProperty method

* 👔 allow any

* 🔧 handle multi error message callback

*  change return type of callback

*  add customCallback to MultiError

* 🚧 refactor to use INode

* 🔨 handle arrays, continue search after first null property found

* 🚫 refactor method access

* 🚧 setup NodeErrorView

*  change timestamp to Date.now

* 📚 Add documentation for methods and constants

* 🚧 change message setting

* 🚚 move NodeErrors to workflow

*  add new ErrorView for Nodes

* 🎨 improve error notification

* 🎨 refactor interfaces

*  add WorkflowOperationError, refactor error throwing

* 👕 fix linter issues

* 🎨 rename param

* 🐛 fix handling normal errors

*  add usage of NodeApiError

* 🎨 fix throw new error instead of constructor

* 🎨 remove unnecessary code/comments

* 🎨 adjusted spacing + updated status messages

* 🎨 fix tab indentation

*  Replace current errors with custom errors (#1576)

*  Introduce NodeApiError in catch blocks

*  Introduce NodeOperationError in nodes

*  Add missing errors and remove incompatible

*  Fix NodeOperationError in incompatible nodes

* 🔧 Adjust error handling in missed nodes

PayPal, FileMaker, Reddit, Taiga and Facebook Graph API nodes

* 🔨 Adjust Strava Trigger node error handling

* 🔨 Adjust AWS nodes error handling

* 🔨 Remove duplicate instantiation of NodeApiError

* 🐛 fix strava trigger node error handling

* Add XML parsing to NodeApiError constructor (#1633)

* 🐛 Remove type annotation from catch variable

*  Add XML parsing to NodeApiError

*  Simplify error handling in Rekognition node

*  Pass in XML flag in generic functions

* 🔥 Remove try/catch wrappers at call sites

* 🔨 Refactor setting description from XML

* 🔨 Refactor let to const in resource loaders

*  Find property in parsed XML

*  Change let to const

* 🔥 Remove unneeded try/catch block

* 👕 Fix linting issues

* 🐛 Fix errors from merge conflict resolution

*  Add custom errors to latest contributions

* 👕 Fix linting issues

*  Refactor MongoDB helpers for custom errors

* 🐛 Correct custom error type

*  Apply feedback to A nodes

*  Apply feedback to missed A node

*  Apply feedback to B-D nodes

*  Apply feedback to E-F nodes

*  Apply feedback to G nodes

*  Apply feedback to H-L nodes

*  Apply feedback to M nodes

*  Apply feedback to P nodes

*  Apply feedback to R nodes

*  Apply feedback to S nodes

*  Apply feedback to T nodes

*  Apply feedback to V-Z nodes

*  Add HTTP code to iterable node error

* 🔨 Standardize e as error

* 🔨 Standardize err as error

*  Fix error handling for non-standard nodes

Co-authored-by: Ben Hesseldieck <b.hesseldieck@gmail.com>

Co-authored-by: Ben Hesseldieck <b.hesseldieck@gmail.com>
Co-authored-by: Ben Hesseldieck <1849459+BHesseldieck@users.noreply.github.com>
2021-04-16 18:33:36 +02:00

562 lines
13 KiB
TypeScript

import {
IExecuteFunctions,
} from 'n8n-core';
import {
IDataObject,
ILoadOptionsFunctions,
INodeExecutionData,
INodePropertyOptions,
INodeType,
INodeTypeDescription,
NodeOperationError,
} from 'n8n-workflow';
import {
apiTemplateIoApiRequest,
downloadImage,
loadResource,
validateJSON,
} from './GenericFunctions';
export class ApiTemplateIo implements INodeType {
description: INodeTypeDescription = {
displayName: 'APITemplate.io',
name: 'apiTemplateIo',
icon: 'file:apiTemplateIo.svg',
group: ['transform'],
version: 1,
description: 'Consume the APITemplate.io API',
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
defaults: {
name: 'APITemplate.io',
color: '#c0c0c0',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'apiTemplateIoApi',
required: true,
},
],
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
options: [
{
name: 'Account',
value: 'account',
},
{
name: 'Image',
value: 'image',
},
{
name: 'PDF',
value: 'pdf',
},
],
default: 'image',
description: 'Resource to consume',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'create',
required: true,
description: 'Operation to perform',
options: [
{
name: 'Create',
value: 'create',
},
],
displayOptions: {
show: {
resource: [
'image',
'pdf',
],
},
},
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
required: true,
description: 'Operation to perform',
options: [
{
name: 'Get',
value: 'get',
},
],
displayOptions: {
show: {
resource: [
'account',
],
},
},
},
{
displayName: 'Template ID',
name: 'imageTemplateId',
type: 'options',
required: true,
default: '',
description: 'ID of the image template to use.',
typeOptions: {
loadOptionsMethod: 'getImageTemplates',
},
displayOptions: {
show: {
resource: [
'image',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Template ID',
name: 'pdfTemplateId',
type: 'options',
required: true,
default: '',
description: 'ID of the PDF template to use.',
typeOptions: {
loadOptionsMethod: 'getPdfTemplates',
},
displayOptions: {
show: {
resource: [
'pdf',
],
operation: [
'create',
],
},
},
},
{
displayName: 'JSON Parameters',
name: 'jsonParameters',
type: 'boolean',
default: false,
displayOptions: {
show: {
resource: [
'pdf',
'image',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Download',
name: 'download',
type: 'boolean',
default: false,
displayOptions: {
show: {
resource: [
'pdf',
'image',
],
operation: [
'create',
],
},
},
description: 'Name of the binary property to which to<br />write the data of the read file.',
},
{
displayName: 'Binary Property',
name: 'binaryProperty',
type: 'string',
required: true,
default: 'data',
description: 'Name of the binary property to which to write to.',
displayOptions: {
show: {
resource: [
'pdf',
'image',
],
operation: [
'create',
],
download: [
true,
],
},
},
},
{
displayName: 'Overrides (JSON)',
name: 'overridesJson',
type: 'json',
default: '',
displayOptions: {
show: {
resource: [
'image',
],
operation: [
'create',
],
jsonParameters: [
true,
],
},
},
placeholder: `[ {"name": "text_1", "text": "hello world", "textBackgroundColor": "rgba(246, 243, 243, 0)" } ]`,
},
{
displayName: 'Properties (JSON)',
name: 'propertiesJson',
type: 'json',
default: '',
displayOptions: {
show: {
resource: [
'pdf',
],
operation: [
'create',
],
jsonParameters: [
true,
],
},
},
placeholder: `{ "name": "text_1" }`,
},
{
displayName: 'Overrides',
name: 'overridesUi',
placeholder: 'Add Override',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
displayOptions: {
show: {
resource: [
'image',
],
operation: [
'create',
],
jsonParameters: [
false,
],
},
},
default: {},
options: [
{
name: 'overrideValues',
displayName: 'Override',
values: [
{
displayName: 'Properties',
name: 'propertiesUi',
placeholder: 'Add Property',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
default: {},
options: [
{
name: 'propertyValues',
displayName: 'Property',
values: [
{
displayName: 'Key',
name: 'key',
type: 'string',
default: '',
description: 'Name of the property',
},
{
displayName: 'Value',
name: 'value',
type: 'string',
default: '',
description: 'Value to the property.',
},
],
},
],
},
],
},
],
},
{
displayName: 'Properties',
name: 'propertiesUi',
placeholder: 'Add Property',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
default: {},
displayOptions: {
show: {
resource: [
'pdf',
],
operation: [
'create',
],
jsonParameters: [
false,
],
},
},
options: [
{
name: 'propertyValues',
displayName: 'Property',
values: [
{
displayName: 'Key',
name: 'key',
type: 'string',
default: '',
description: 'Name of the property',
},
{
displayName: 'Value',
name: 'value',
type: 'string',
default: '',
description: 'Value to the property.',
},
],
},
],
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
operation: [
'create',
],
resource: [
'pdf',
'image',
],
'download': [
true,
],
},
},
default: {},
options: [
{
displayName: 'File Name',
name: 'fileName',
type: 'string',
default: '',
description: 'The name of the downloaded image/pdf. It has to include the extension. For example: report.pdf',
},
],
},
],
};
methods = {
loadOptions: {
async getImageTemplates(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
return await loadResource.call(this, 'image');
},
async getPdfTemplates(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
return await loadResource.call(this, 'pdf');
},
},
};
async execute(this: IExecuteFunctions) {
const items = this.getInputData();
const returnData: IDataObject[] = [];
const length = items.length;
let responseData;
const resource = this.getNodeParameter('resource', 0) as string;
const operation = this.getNodeParameter('operation', 0) as string;
if (resource === 'account') {
// *********************************************************************
// account
// *********************************************************************
if (operation === 'get') {
// ----------------------------------
// account: get
// ----------------------------------
for (let i = 0; i < length; i++) {
responseData = await apiTemplateIoApiRequest.call(this, 'GET', '/account-information');
returnData.push(responseData);
}
}
} else if (resource === 'image') {
// *********************************************************************
// image
// *********************************************************************
if (operation === 'create') {
// ----------------------------------
// image: create
// ----------------------------------
const download = this.getNodeParameter('download', 0) as boolean;
// https://docs.apitemplate.io/reference/api-reference.html#create-an-image-jpeg-and-png
for (let i = 0; i < length; i++) {
const jsonParameters = this.getNodeParameter('jsonParameters', i) as boolean;
const options = this.getNodeParameter('options', i) as IDataObject;
const qs = {
template_id: this.getNodeParameter('imageTemplateId', i),
};
const body = { overrides: [] } as IDataObject;
if (jsonParameters === false) {
const overrides = (this.getNodeParameter('overridesUi', i) as IDataObject || {}).overrideValues as IDataObject[] || [];
if (overrides.length !== 0) {
const data: IDataObject[] = [];
for (const override of overrides) {
const properties = (override.propertiesUi as IDataObject || {}).propertyValues as IDataObject[] || [];
data.push(properties.reduce((obj, value) => Object.assign(obj, { [`${value.key}`]: value.value }), {}));
}
body.overrides = data;
}
} else {
const overrideJson = this.getNodeParameter('overridesJson', i) as string;
if (overrideJson !== '') {
const data = validateJSON(overrideJson);
if (data === undefined) {
throw new NodeOperationError(this.getNode(), 'A valid JSON must be provided.');
}
body.overrides = data;
}
}
responseData = await apiTemplateIoApiRequest.call(this, 'POST', '/create', qs, body);
if (download === true) {
const binaryProperty = this.getNodeParameter('binaryProperty', i) as string;
const data = await downloadImage.call(this, responseData.download_url);
const fileName = responseData.download_url.split('/').pop();
const binaryData = await this.helpers.prepareBinaryData(data, options.fileName || fileName);
responseData = {
json: responseData,
binary: {
[binaryProperty]: binaryData,
},
};
}
returnData.push(responseData);
}
if (download === true) {
return this.prepareOutputData(returnData as unknown as INodeExecutionData[]);
}
}
} else if (resource === 'pdf') {
// *********************************************************************
// pdf
// *********************************************************************
if (operation === 'create') {
// ----------------------------------
// pdf: create
// ----------------------------------
// https://docs.apitemplate.io/reference/api-reference.html#create-a-pdf
const download = this.getNodeParameter('download', 0) as boolean;
for (let i = 0; i < length; i++) {
const jsonParameters = this.getNodeParameter('jsonParameters', i) as boolean;
const options = this.getNodeParameter('options', i) as IDataObject;
const qs = {
template_id: this.getNodeParameter('pdfTemplateId', i),
};
let data;
if (jsonParameters === false) {
const properties = (this.getNodeParameter('propertiesUi', i) as IDataObject || {}).propertyValues as IDataObject[] || [];
if (properties.length === 0) {
throw new NodeOperationError(this.getNode(), 'The parameter properties cannot be empty');
}
data = properties.reduce((obj, value) => Object.assign(obj, { [`${value.key}`]: value.value }), {});
} else {
const propertiesJson = this.getNodeParameter('propertiesJson', i) as string;
data = validateJSON(propertiesJson);
if (data === undefined) {
throw new NodeOperationError(this.getNode(), 'A valid JSON must be provided.');
}
}
responseData = await apiTemplateIoApiRequest.call(this, 'POST', '/create', qs, data);
if (download === true) {
const binaryProperty = this.getNodeParameter('binaryProperty', i) as string;
const data = await downloadImage.call(this, responseData.download_url);
const fileName = responseData.download_url.split('/').pop();
const binaryData = await this.helpers.prepareBinaryData(data, options.fileName || fileName);
responseData = {
json: responseData,
binary: {
[binaryProperty]: binaryData,
},
};
}
returnData.push(responseData);
}
if (download === true) {
return this.prepareOutputData(returnData as unknown as INodeExecutionData[]);
}
}
}
return [this.helpers.returnJsonArray(returnData)];
}
}