n8n-nodes-test-node 1.0.13 → 1.0.15

package/README.md

@@ -1,6 +1,6 @@
 # n8n-nodes-test-node
 
-Auto-generated n8n community node for the **camofox-browser** API (spec version 1.16.0), built from its OpenAPI document.
+Auto-generated n8n community node for the **Gofile API** API (spec version 2025-05-16), built from its OpenAPI document.
 
 ## Install
 
@@ -14,10 +14,19 @@ npm install n8n-nodes-test-node
 
 ## What was generated
 
-- Node type(s) in this package: **camofoxBrowser**, **camofoxBrowserTool** (AI Agent tool).
-- 8 resource(s), 40 operation(s) (identical parameter set on both the regular node and the tool node -- they share the same credential and routing, differing only in identity and how they present themselves).
-- Credential type **camofoxBrowserApi**, with an editable **Base URL** field, plus: API Key / Bearer token field(s) per the spec's security scheme.
-- Default Base URL: `http://localhost:9377` (override it in the credential's "Base URL" field to point at a different environment)
+- Node type(s) in this package: **gofileAPI**, **gofileAPITool** (AI Agent tool), **gofileAPIFiles** (file upload/download), **gofileAPIFilesTool** (file upload/download, AI Agent tool).
+- 2 resource(s), 14 operation(s) (identical parameter set on the regular and tool nodes -- they share the same credential and routing, differing only in identity and how they present themselves).
+- 1 file upload/download operation(s), handled by the separate **Files** node -- see "File upload/download" below for why they're not part of the main node.
+- Credential type **gofileAPIApi**, with an editable **Base URL** field, plus: API Key / Bearer token field(s) per the spec's security scheme.
+- Default Base URL: `https://api.gofile.io` (override it in the credential's "Base URL" field to point at a different environment)
+
+## File upload/download
+
+Operations whose request body is a `multipart/form-data` file upload, or whose response is binary (an image, PDF, or other non-JSON file), are generated as a **separate node** ("...Files") rather than folded into the main one. This is deliberate, not a limitation of the source spec: n8n's declarative request-routing (what the main node is built with, so it needs no hand-written request logic) is confirmed broken for binary payloads -- it JSON-serializes binary data instead of sending real bytes ([n8n-io/n8n#17823](https://github.com/n8n-io/n8n/issues/17823)). The Files node is instead a small, hand-written (programmatic) node using n8n's HTTP helpers directly, which handle binary correctly.
+
+- **Uploads**: set "Input Binary Field" to the name of the binary property on the incoming item that holds the file (n8n's convention -- usually `data`, e.g. from a **Read/Write File** or **HTTP Request** node upstream).
+- **Downloads**: set "Output Binary Field" to the name the downloaded file should be written to on the output item (also usually `data`, ready for a **Read/Write File** node or another HTTP call downstream).
+- The Files node shares the exact same credential as the main node.
 
 ## Using the AI Agent tool node
 
@@ -34,6 +43,7 @@ Once installed and enabled, add an **AI Agent** node to your workflow, and this
 - OAuth2 and HTTP Basic each use n8n's own built-in credential mechanism and can't be combined with each other or with API Key/Bearer in one credential. If a spec declares more than one auth *family* as alternatives, this generator picks one deterministically -- **OAuth2 > HTTP Basic > API Key/Bearer** -- and the rest are ignored (logged during generation, and listed above if applicable). Multiple schemes *within* the API Key/Bearer family are still combined into one credential.
 - If some operations require only an unsupported scheme while others are covered by this node's credential (the classic Swagger Petstore spec is a real example -- OAuth2 implicit flow for writes, an API key for some reads), the unsupported operations are left out of the node rather than the whole build failing -- see above for which ones, if any.
 - Request bodies with nested objects, arrays, or genuine `oneOf`/`anyOf`/`allOf` type unions are exposed as a single raw "Body (JSON)" field rather than individual fields. A nullable/optional primitive field (OpenAPI 3.1's `anyOf: [{type: 'string'}, {type: 'null'}]`, as FastAPI/Pydantic generates for `Optional[str]`) is still recognized as simple and gets its own field.
+- The Files node keeps every field top-level (no "Additional Fields" grouping for optional params, unlike the main node) -- binary operations tend to have few parameters, so this keeps its hand-written `execute()` logic simpler.
 
 ## Regenerating
 

package/dist/{CamofoxBrowserApi.credentials.d.ts → GofileAPIApi.credentials.d.ts}

@@ -1,5 +1,5 @@
 import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
-export declare class CamofoxBrowserApi implements ICredentialType {
+export declare class GofileAPIApi implements ICredentialType {
     name: string;
     displayName: string;
     documentationUrl: string;

package/dist/{CamofoxBrowserApi.credentials.js → GofileAPIApi.credentials.js}

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CamofoxBrowserApi = void 0;
-class CamofoxBrowserApi {
+exports.GofileAPIApi = void 0;
+class GofileAPIApi {
     constructor() {
-        this.name = 'camofoxBrowserApi';
-        this.displayName = 'camofox-browser API';
+        this.name = 'gofileAPIApi';
+        this.displayName = 'Gofile API';
         this.documentationUrl = '';
         this.properties = [
             {
                 displayName: 'Base URL',
                 name: 'baseUrl',
                 type: 'string',
-                default: 'http://localhost:9377',
+                default: 'https://api.gofile.io',
                 required: true,
                 description: 'Base URL every request is sent to. Change this to point the node at a different environment (staging, self-hosted, etc.).',
             },
@@ -36,10 +36,10 @@ class CamofoxBrowserApi {
         this.test = {
             request: {
                 baseURL: '={{$credentials.baseUrl}}',
-                url: '/health',
+                url: '/accounts/getid',
                 method: 'GET',
             },
         };
     }
 }
-exports.CamofoxBrowserApi = CamofoxBrowserApi;
+exports.GofileAPIApi = GofileAPIApi;

package/dist/GofileAPIFilesNode.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class GofileAPIFilesNode implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/GofileAPIFilesNode.node.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GofileAPIFilesNode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const CREDENTIAL_TYPE_NAME = 'gofileAPIApi';
+class GofileAPIFilesNode {
+    constructor() {
+        this.description = {
+            displayName: 'Gofile API Files',
+            name: 'gofileAPIFiles',
+            icon: 'file:icon.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ($parameter["resource"] ? " " + $parameter["resource"] : "")}}',
+            description: 'File upload/download operations for the Gofile API API that need real binary handling (a separate, hand-written node -- see README).',
+            defaults: {
+                name: 'Gofile API Files',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: CREDENTIAL_TYPE_NAME,
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Upload A File',
+                            value: 'uploadFile',
+                            action: 'Upload a file',
+                            description: 'Uploads a file to Gofile. If folderId is omitted, Gofile creates a new public folder. Regional upload hosts may be selected by changing the server URL. The official documentation states that the API uses Bearer-token authentication.',
+                        },
+                    ],
+                    default: 'uploadFile',
+                },
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    description: 'File to upload.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadFile'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Folder Id',
+                    name: 'folderId',
+                    type: 'string',
+                    default: '',
+                    required: false,
+                    description: 'Destination folder ID. If omitted, a new public folder is created.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadFile'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials(CREDENTIAL_TYPE_NAME);
+        const baseUrl = credentials.baseUrl;
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                switch (operation) {
+                    case 'uploadFile': {
+                        const url = `${baseUrl}/uploadfile`;
+                        const inputBinaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                        const fileBinaryData = this.helpers.assertBinaryData(i, inputBinaryPropertyName);
+                        const fileBuffer = await this.helpers.getBinaryDataBuffer(i, inputBinaryPropertyName);
+                        const formData = new FormData();
+                        formData.append('file', new Blob([fileBuffer], { type: fileBinaryData.mimeType }), fileBinaryData.fileName || 'file');
+                        formData.append('folderId', String(this.getNodeParameter('folderId', i, '')));
+                        const response = (await this.helpers.httpRequestWithAuthentication.call(this, CREDENTIAL_TYPE_NAME, {
+                            method: 'POST',
+                            url,
+                            body: formData,
+                            returnFullResponse: true,
+                        }));
+                        returnData.push({
+                            json: ((_a = response.body) !== null && _a !== void 0 ? _a : {}),
+                            pairedItem: { item: i },
+                        });
+                        break;
+                    }
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, {
+                            itemIndex: i,
+                        });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.GofileAPIFilesNode = GofileAPIFilesNode;

package/dist/GofileAPIFilesToolNode.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class GofileAPIFilesToolNode implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/GofileAPIFilesToolNode.node.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GofileAPIFilesToolNode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const CREDENTIAL_TYPE_NAME = 'gofileAPIApi';
+class GofileAPIFilesToolNode {
+    constructor() {
+        this.description = {
+            displayName: 'Gofile API Files Tool',
+            name: 'gofileAPIFilesTool',
+            icon: 'file:icon.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ($parameter["resource"] ? " " + $parameter["resource"] : "")}}',
+            description: 'Use this tool to upload or download files via the Gofile API API.',
+            usableAsTool: true,
+            defaults: {
+                name: 'Gofile API Files Tool',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: CREDENTIAL_TYPE_NAME,
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Upload A File',
+                            value: 'uploadFile',
+                            action: 'Upload a file',
+                            description: 'Uploads a file to Gofile. If folderId is omitted, Gofile creates a new public folder. Regional upload hosts may be selected by changing the server URL. The official documentation states that the API uses Bearer-token authentication.',
+                        },
+                    ],
+                    default: 'uploadFile',
+                },
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    description: 'File to upload.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadFile'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Folder Id',
+                    name: 'folderId',
+                    type: 'string',
+                    default: '',
+                    required: false,
+                    description: 'Destination folder ID. If omitted, a new public folder is created.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadFile'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials(CREDENTIAL_TYPE_NAME);
+        const baseUrl = credentials.baseUrl;
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                switch (operation) {
+                    case 'uploadFile': {
+                        const url = `${baseUrl}/uploadfile`;
+                        const inputBinaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                        const fileBinaryData = this.helpers.assertBinaryData(i, inputBinaryPropertyName);
+                        const fileBuffer = await this.helpers.getBinaryDataBuffer(i, inputBinaryPropertyName);
+                        const formData = new FormData();
+                        formData.append('file', new Blob([fileBuffer], { type: fileBinaryData.mimeType }), fileBinaryData.fileName || 'file');
+                        formData.append('folderId', String(this.getNodeParameter('folderId', i, '')));
+                        const response = (await this.helpers.httpRequestWithAuthentication.call(this, CREDENTIAL_TYPE_NAME, {
+                            method: 'POST',
+                            url,
+                            body: formData,
+                            returnFullResponse: true,
+                        }));
+                        returnData.push({
+                            json: ((_a = response.body) !== null && _a !== void 0 ? _a : {}),
+                            pairedItem: { item: i },
+                        });
+                        break;
+                    }
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, {
+                            itemIndex: i,
+                        });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.GofileAPIFilesToolNode = GofileAPIFilesToolNode;

package/dist/{CamofoxBrowserNode.node.d.ts → GofileAPINode.node.d.ts}

@@ -1,4 +1,4 @@
 import type { INodeType, INodeTypeDescription } from 'n8n-workflow';
-export declare class CamofoxBrowserNode implements INodeType {
+export declare class GofileAPINode implements INodeType {
     description: INodeTypeDescription;
 }