n8n-nodes-test-node 1.0.9 → 1.0.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
# n8n-nodes-test-node
|
|
2
2
|
|
|
3
|
-
Auto-generated n8n community node for the **
|
|
3
|
+
Auto-generated n8n community node for the **Gofile API** API (spec version 2025-05-16), built from its OpenAPI document.
|
|
4
4
|
|
|
5
5
|
## Install
|
|
6
6
|
|
|
@@ -14,9 +14,9 @@ npm install n8n-nodes-test-node
|
|
|
14
14
|
|
|
15
15
|
## What was generated
|
|
16
16
|
|
|
17
|
-
-
|
|
18
|
-
- Credential type **
|
|
19
|
-
- Default Base URL: `https://api.
|
|
17
|
+
- 3 resource(s), 15 operation(s).
|
|
18
|
+
- Credential type **gofileAPIApi**, with an editable **Base URL** field, plus: API Key / Bearer token field(s) per the spec's security scheme.
|
|
19
|
+
- Default Base URL: `https://api.gofile.io` (override it in the credential's "Base URL" field to point at a different environment)
|
|
20
20
|
|
|
21
21
|
## Limitations
|
|
22
22
|
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
|
|
2
|
+
export declare class GofileAPIApi implements ICredentialType {
|
|
3
|
+
name: string;
|
|
4
|
+
displayName: string;
|
|
5
|
+
documentationUrl: string;
|
|
6
|
+
properties: INodeProperties[];
|
|
7
|
+
authenticate: IAuthenticateGeneric;
|
|
8
|
+
test: ICredentialTestRequest;
|
|
9
|
+
}
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.GofileAPIApi = void 0;
|
|
4
|
+
class GofileAPIApi {
|
|
5
|
+
constructor() {
|
|
6
|
+
this.name = 'gofileAPIApi';
|
|
7
|
+
this.displayName = 'Gofile API';
|
|
8
|
+
this.documentationUrl = '';
|
|
9
|
+
this.properties = [
|
|
10
|
+
{
|
|
11
|
+
displayName: 'Base URL',
|
|
12
|
+
name: 'baseUrl',
|
|
13
|
+
type: 'string',
|
|
14
|
+
default: 'https://api.gofile.io',
|
|
15
|
+
required: true,
|
|
16
|
+
description: 'Base URL every request is sent to. Change this to point the node at a different environment (staging, self-hosted, etc.).',
|
|
17
|
+
},
|
|
18
|
+
{
|
|
19
|
+
displayName: 'Bearer Token',
|
|
20
|
+
name: 'bearerAuthToken',
|
|
21
|
+
type: 'string',
|
|
22
|
+
typeOptions: { password: true },
|
|
23
|
+
default: '',
|
|
24
|
+
required: true,
|
|
25
|
+
description: 'Sent as "Authorization: Bearer <token>" on every request.',
|
|
26
|
+
},
|
|
27
|
+
];
|
|
28
|
+
this.authenticate = {
|
|
29
|
+
type: 'generic',
|
|
30
|
+
properties: {
|
|
31
|
+
headers: {
|
|
32
|
+
Authorization: '=Bearer {{$credentials.bearerAuthToken}}',
|
|
33
|
+
},
|
|
34
|
+
},
|
|
35
|
+
};
|
|
36
|
+
this.test = {
|
|
37
|
+
request: {
|
|
38
|
+
baseURL: '={{$credentials.baseUrl}}',
|
|
39
|
+
url: '/accounts/getid',
|
|
40
|
+
method: 'GET',
|
|
41
|
+
},
|
|
42
|
+
};
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
exports.GofileAPIApi = GofileAPIApi;
|
|
@@ -0,0 +1,864 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.GofileAPINode = void 0;
|
|
4
|
+
class GofileAPINode {
|
|
5
|
+
constructor() {
|
|
6
|
+
this.description = {
|
|
7
|
+
displayName: 'Gofile API',
|
|
8
|
+
name: 'gofileAPI',
|
|
9
|
+
icon: 'file:icon.svg',
|
|
10
|
+
group: ['transform'],
|
|
11
|
+
version: 1,
|
|
12
|
+
subtitle: '={{$parameter["operation"] + ($parameter["resource"] ? " " + $parameter["resource"] : "")}}',
|
|
13
|
+
description: 'OpenAPI 3 specification for the Gofile REST API, based on the official Gofile API documentation last updated May 16, 2025. Gofile is a beta API and may change. Authentication uses an API token as a Bearer token in the Authorization header. Most endpoints require a premium account; basic operations such as uploading, creating folders, renaming content, and removing content are available to free accounts.',
|
|
14
|
+
defaults: {
|
|
15
|
+
name: 'Gofile API',
|
|
16
|
+
},
|
|
17
|
+
inputs: ['main'],
|
|
18
|
+
outputs: ['main'],
|
|
19
|
+
credentials: [
|
|
20
|
+
{
|
|
21
|
+
name: 'gofileAPIApi',
|
|
22
|
+
required: true,
|
|
23
|
+
},
|
|
24
|
+
],
|
|
25
|
+
requestDefaults: {
|
|
26
|
+
baseURL: '={{$credentials.baseUrl}}',
|
|
27
|
+
headers: {
|
|
28
|
+
Accept: 'application/json',
|
|
29
|
+
},
|
|
30
|
+
},
|
|
31
|
+
properties: [
|
|
32
|
+
{
|
|
33
|
+
displayName: 'Resource',
|
|
34
|
+
name: 'resource',
|
|
35
|
+
type: 'options',
|
|
36
|
+
noDataExpression: true,
|
|
37
|
+
options: [
|
|
38
|
+
{ name: 'Contents', value: 'contents' },
|
|
39
|
+
{ name: 'Accounts', value: 'accounts' },
|
|
40
|
+
{ name: 'Uploads', value: 'uploads' },
|
|
41
|
+
],
|
|
42
|
+
default: 'contents',
|
|
43
|
+
},
|
|
44
|
+
{
|
|
45
|
+
displayName: 'Operation',
|
|
46
|
+
name: 'operation',
|
|
47
|
+
type: 'options',
|
|
48
|
+
noDataExpression: true,
|
|
49
|
+
options: [
|
|
50
|
+
{
|
|
51
|
+
name: 'Create A Folder',
|
|
52
|
+
value: 'createFolder',
|
|
53
|
+
action: 'Create a folder',
|
|
54
|
+
description: 'Creates a new folder inside the specified parent folder.',
|
|
55
|
+
routing: {
|
|
56
|
+
request: {
|
|
57
|
+
method: 'POST',
|
|
58
|
+
url: '=/contents/createFolder',
|
|
59
|
+
},
|
|
60
|
+
},
|
|
61
|
+
},
|
|
62
|
+
{
|
|
63
|
+
name: 'Update Content Attribute',
|
|
64
|
+
value: 'updateContent',
|
|
65
|
+
action: 'Update content attribute',
|
|
66
|
+
description: 'Modifies one attribute of a file or folder. Available attributes depend on content type.',
|
|
67
|
+
routing: {
|
|
68
|
+
request: {
|
|
69
|
+
method: 'PUT',
|
|
70
|
+
url: '=/contents/{{$parameter["contentId"]}}/update',
|
|
71
|
+
},
|
|
72
|
+
},
|
|
73
|
+
},
|
|
74
|
+
{
|
|
75
|
+
name: 'Delete Content',
|
|
76
|
+
value: 'deleteContents',
|
|
77
|
+
action: 'Delete content',
|
|
78
|
+
description: 'Permanently deletes one or more files and folders belonging to the authenticated account. Deleting a folder also deletes its contents.',
|
|
79
|
+
routing: {
|
|
80
|
+
request: {
|
|
81
|
+
method: 'DELETE',
|
|
82
|
+
url: '=/contents',
|
|
83
|
+
},
|
|
84
|
+
},
|
|
85
|
+
},
|
|
86
|
+
{
|
|
87
|
+
name: 'Get Content Details',
|
|
88
|
+
value: 'getContent',
|
|
89
|
+
action: 'Get content details',
|
|
90
|
+
description: 'Retrieves detailed information about a folder and its contents.',
|
|
91
|
+
routing: {
|
|
92
|
+
request: {
|
|
93
|
+
method: 'GET',
|
|
94
|
+
url: '=/contents/{{$parameter["contentId"]}}',
|
|
95
|
+
},
|
|
96
|
+
},
|
|
97
|
+
},
|
|
98
|
+
{
|
|
99
|
+
name: 'Search Contents',
|
|
100
|
+
value: 'searchContents',
|
|
101
|
+
action: 'Search contents',
|
|
102
|
+
description: 'Recursively searches a folder for content names or tags. Matching is case-insensitive and supports partial matches.',
|
|
103
|
+
routing: {
|
|
104
|
+
request: {
|
|
105
|
+
method: 'GET',
|
|
106
|
+
url: '=/contents/search',
|
|
107
|
+
},
|
|
108
|
+
},
|
|
109
|
+
},
|
|
110
|
+
{
|
|
111
|
+
name: 'Create A Direct Link',
|
|
112
|
+
value: 'createDirectLink',
|
|
113
|
+
action: 'Create a direct link',
|
|
114
|
+
description: 'Creates a direct access link. For folders, Gofile generates a ZIP archive.',
|
|
115
|
+
routing: {
|
|
116
|
+
request: {
|
|
117
|
+
method: 'POST',
|
|
118
|
+
url: '=/contents/{{$parameter["contentId"]}}/directlinks',
|
|
119
|
+
},
|
|
120
|
+
},
|
|
121
|
+
},
|
|
122
|
+
{
|
|
123
|
+
name: 'Update A Direct Link',
|
|
124
|
+
value: 'updateDirectLink',
|
|
125
|
+
action: 'Update a direct link',
|
|
126
|
+
description: 'Updates an existing direct link. If a restriction is omitted, Gofile removes that restriction.',
|
|
127
|
+
routing: {
|
|
128
|
+
request: {
|
|
129
|
+
method: 'PUT',
|
|
130
|
+
url: '=/contents/{{$parameter["contentId"]}}/directlinks/{{$parameter["directLinkId"]}}',
|
|
131
|
+
},
|
|
132
|
+
},
|
|
133
|
+
},
|
|
134
|
+
{
|
|
135
|
+
name: 'Delete A Direct Link',
|
|
136
|
+
value: 'deleteDirectLink',
|
|
137
|
+
action: 'Delete a direct link',
|
|
138
|
+
description: 'Permanently removes a direct link without deleting the underlying content.',
|
|
139
|
+
routing: {
|
|
140
|
+
request: {
|
|
141
|
+
method: 'DELETE',
|
|
142
|
+
url: '=/contents/{{$parameter["contentId"]}}/directlinks/{{$parameter["directLinkId"]}}',
|
|
143
|
+
},
|
|
144
|
+
},
|
|
145
|
+
},
|
|
146
|
+
{
|
|
147
|
+
name: 'Copy Content',
|
|
148
|
+
value: 'copyContents',
|
|
149
|
+
action: 'Copy content',
|
|
150
|
+
description: 'Copies one or more files/folders into a destination folder.',
|
|
151
|
+
routing: {
|
|
152
|
+
request: {
|
|
153
|
+
method: 'POST',
|
|
154
|
+
url: '=/contents/copy',
|
|
155
|
+
},
|
|
156
|
+
},
|
|
157
|
+
},
|
|
158
|
+
{
|
|
159
|
+
name: 'Move Content',
|
|
160
|
+
value: 'moveContents',
|
|
161
|
+
action: 'Move content',
|
|
162
|
+
description: 'Moves one or more files/folders into a destination folder while preserving their attributes and permissions.',
|
|
163
|
+
routing: {
|
|
164
|
+
request: {
|
|
165
|
+
method: 'PUT',
|
|
166
|
+
url: '=/contents/move',
|
|
167
|
+
},
|
|
168
|
+
},
|
|
169
|
+
},
|
|
170
|
+
{
|
|
171
|
+
name: 'Import Content',
|
|
172
|
+
value: 'importContents',
|
|
173
|
+
action: 'Import content',
|
|
174
|
+
description: "Imports shared content into the authenticated account's root folder.",
|
|
175
|
+
routing: {
|
|
176
|
+
request: {
|
|
177
|
+
method: 'POST',
|
|
178
|
+
url: '=/contents/import',
|
|
179
|
+
},
|
|
180
|
+
},
|
|
181
|
+
},
|
|
182
|
+
],
|
|
183
|
+
displayOptions: {
|
|
184
|
+
show: {
|
|
185
|
+
resource: ['contents'],
|
|
186
|
+
},
|
|
187
|
+
},
|
|
188
|
+
default: 'createFolder',
|
|
189
|
+
},
|
|
190
|
+
{
|
|
191
|
+
displayName: 'Operation',
|
|
192
|
+
name: 'operation',
|
|
193
|
+
type: 'options',
|
|
194
|
+
noDataExpression: true,
|
|
195
|
+
options: [
|
|
196
|
+
{
|
|
197
|
+
name: 'Get Account ID',
|
|
198
|
+
value: 'getAccountId',
|
|
199
|
+
action: 'Get account ID',
|
|
200
|
+
description: 'Returns the account associated with the current API token.',
|
|
201
|
+
routing: {
|
|
202
|
+
request: {
|
|
203
|
+
method: 'GET',
|
|
204
|
+
url: '=/accounts/getid',
|
|
205
|
+
},
|
|
206
|
+
},
|
|
207
|
+
},
|
|
208
|
+
{
|
|
209
|
+
name: 'Get Account Details',
|
|
210
|
+
value: 'getAccount',
|
|
211
|
+
action: 'Get account details',
|
|
212
|
+
description: 'Returns detailed information about an account. The account ID must belong to the authenticated token.',
|
|
213
|
+
routing: {
|
|
214
|
+
request: {
|
|
215
|
+
method: 'GET',
|
|
216
|
+
url: '=/accounts/{{$parameter["accountId"]}}',
|
|
217
|
+
},
|
|
218
|
+
},
|
|
219
|
+
},
|
|
220
|
+
{
|
|
221
|
+
name: 'Reset API Token',
|
|
222
|
+
value: 'resetAccountToken',
|
|
223
|
+
action: 'Reset API token',
|
|
224
|
+
description: 'Invalidates the current authentication token. A login link containing the new token is sent to the account email.',
|
|
225
|
+
routing: {
|
|
226
|
+
request: {
|
|
227
|
+
method: 'POST',
|
|
228
|
+
url: '=/accounts/{{$parameter["accountId"]}}/resettoken',
|
|
229
|
+
},
|
|
230
|
+
},
|
|
231
|
+
},
|
|
232
|
+
],
|
|
233
|
+
displayOptions: {
|
|
234
|
+
show: {
|
|
235
|
+
resource: ['accounts'],
|
|
236
|
+
},
|
|
237
|
+
},
|
|
238
|
+
default: 'getAccountId',
|
|
239
|
+
},
|
|
240
|
+
{
|
|
241
|
+
displayName: 'Operation',
|
|
242
|
+
name: 'operation',
|
|
243
|
+
type: 'options',
|
|
244
|
+
noDataExpression: true,
|
|
245
|
+
options: [
|
|
246
|
+
{
|
|
247
|
+
name: 'Upload A File',
|
|
248
|
+
value: 'uploadFile',
|
|
249
|
+
action: 'Upload a file',
|
|
250
|
+
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.',
|
|
251
|
+
routing: {
|
|
252
|
+
request: {
|
|
253
|
+
method: 'POST',
|
|
254
|
+
url: '=/uploadfile',
|
|
255
|
+
},
|
|
256
|
+
},
|
|
257
|
+
},
|
|
258
|
+
],
|
|
259
|
+
displayOptions: {
|
|
260
|
+
show: {
|
|
261
|
+
resource: ['uploads'],
|
|
262
|
+
},
|
|
263
|
+
},
|
|
264
|
+
default: 'uploadFile',
|
|
265
|
+
},
|
|
266
|
+
{
|
|
267
|
+
displayName: 'Parent Folder Id',
|
|
268
|
+
name: 'parentFolderId',
|
|
269
|
+
type: 'string',
|
|
270
|
+
default: '',
|
|
271
|
+
required: true,
|
|
272
|
+
description: '',
|
|
273
|
+
displayOptions: {
|
|
274
|
+
show: {
|
|
275
|
+
resource: ['contents'],
|
|
276
|
+
operation: ['createFolder'],
|
|
277
|
+
},
|
|
278
|
+
},
|
|
279
|
+
routing: {
|
|
280
|
+
send: {
|
|
281
|
+
type: 'body',
|
|
282
|
+
property: 'parentFolderId',
|
|
283
|
+
},
|
|
284
|
+
},
|
|
285
|
+
},
|
|
286
|
+
{
|
|
287
|
+
displayName: 'Additional Fields',
|
|
288
|
+
name: 'additionalFields',
|
|
289
|
+
type: 'collection',
|
|
290
|
+
placeholder: 'Add Field',
|
|
291
|
+
default: {},
|
|
292
|
+
displayOptions: {
|
|
293
|
+
show: {
|
|
294
|
+
resource: ['contents'],
|
|
295
|
+
operation: ['createFolder'],
|
|
296
|
+
},
|
|
297
|
+
},
|
|
298
|
+
options: [
|
|
299
|
+
{
|
|
300
|
+
displayName: 'Folder Name',
|
|
301
|
+
name: 'folderName',
|
|
302
|
+
type: 'string',
|
|
303
|
+
default: '',
|
|
304
|
+
description: '',
|
|
305
|
+
routing: {
|
|
306
|
+
send: {
|
|
307
|
+
type: 'body',
|
|
308
|
+
property: 'folderName',
|
|
309
|
+
},
|
|
310
|
+
},
|
|
311
|
+
},
|
|
312
|
+
{
|
|
313
|
+
displayName: 'Public',
|
|
314
|
+
name: 'public',
|
|
315
|
+
type: 'boolean',
|
|
316
|
+
default: false,
|
|
317
|
+
description: '',
|
|
318
|
+
routing: {
|
|
319
|
+
send: {
|
|
320
|
+
type: 'body',
|
|
321
|
+
property: 'public',
|
|
322
|
+
},
|
|
323
|
+
},
|
|
324
|
+
},
|
|
325
|
+
],
|
|
326
|
+
},
|
|
327
|
+
{
|
|
328
|
+
displayName: 'Content Id',
|
|
329
|
+
name: 'contentId',
|
|
330
|
+
type: 'string',
|
|
331
|
+
default: '',
|
|
332
|
+
required: true,
|
|
333
|
+
description: 'Gofile content/folder identifier.',
|
|
334
|
+
displayOptions: {
|
|
335
|
+
show: {
|
|
336
|
+
resource: ['contents'],
|
|
337
|
+
operation: ['updateContent'],
|
|
338
|
+
},
|
|
339
|
+
},
|
|
340
|
+
},
|
|
341
|
+
{
|
|
342
|
+
displayName: 'Body (JSON)',
|
|
343
|
+
name: 'bodyJson',
|
|
344
|
+
type: 'json',
|
|
345
|
+
default: '{}',
|
|
346
|
+
required: true,
|
|
347
|
+
description: "Raw JSON request body. The spec's body schema is too complex to expose as individual fields, so provide the full JSON payload here.",
|
|
348
|
+
displayOptions: {
|
|
349
|
+
show: {
|
|
350
|
+
resource: ['contents'],
|
|
351
|
+
operation: ['updateContent'],
|
|
352
|
+
},
|
|
353
|
+
},
|
|
354
|
+
routing: {
|
|
355
|
+
request: {
|
|
356
|
+
body: '={{JSON.parse($value)}}',
|
|
357
|
+
},
|
|
358
|
+
},
|
|
359
|
+
},
|
|
360
|
+
{
|
|
361
|
+
displayName: 'Contents Id',
|
|
362
|
+
name: 'contentsId',
|
|
363
|
+
type: 'string',
|
|
364
|
+
default: '',
|
|
365
|
+
required: true,
|
|
366
|
+
description: 'Comma-separated content IDs.',
|
|
367
|
+
displayOptions: {
|
|
368
|
+
show: {
|
|
369
|
+
resource: ['contents'],
|
|
370
|
+
operation: ['deleteContents'],
|
|
371
|
+
},
|
|
372
|
+
},
|
|
373
|
+
routing: {
|
|
374
|
+
send: {
|
|
375
|
+
type: 'body',
|
|
376
|
+
property: 'contentsId',
|
|
377
|
+
},
|
|
378
|
+
},
|
|
379
|
+
},
|
|
380
|
+
{
|
|
381
|
+
displayName: 'Content Id',
|
|
382
|
+
name: 'contentId',
|
|
383
|
+
type: 'string',
|
|
384
|
+
default: '',
|
|
385
|
+
required: true,
|
|
386
|
+
description: 'Gofile content/folder identifier.',
|
|
387
|
+
displayOptions: {
|
|
388
|
+
show: {
|
|
389
|
+
resource: ['contents'],
|
|
390
|
+
operation: ['getContent'],
|
|
391
|
+
},
|
|
392
|
+
},
|
|
393
|
+
},
|
|
394
|
+
{
|
|
395
|
+
displayName: 'Additional Fields',
|
|
396
|
+
name: 'additionalFields',
|
|
397
|
+
type: 'collection',
|
|
398
|
+
placeholder: 'Add Field',
|
|
399
|
+
default: {},
|
|
400
|
+
displayOptions: {
|
|
401
|
+
show: {
|
|
402
|
+
resource: ['contents'],
|
|
403
|
+
operation: ['getContent'],
|
|
404
|
+
},
|
|
405
|
+
},
|
|
406
|
+
options: [
|
|
407
|
+
{
|
|
408
|
+
displayName: 'Password',
|
|
409
|
+
name: 'password',
|
|
410
|
+
type: 'string',
|
|
411
|
+
default: '',
|
|
412
|
+
description: 'SHA-256 hash of the password for password-protected content.',
|
|
413
|
+
routing: {
|
|
414
|
+
send: {
|
|
415
|
+
type: 'query',
|
|
416
|
+
property: 'password',
|
|
417
|
+
},
|
|
418
|
+
},
|
|
419
|
+
},
|
|
420
|
+
{
|
|
421
|
+
displayName: 'Page',
|
|
422
|
+
name: 'page',
|
|
423
|
+
type: 'number',
|
|
424
|
+
default: 0,
|
|
425
|
+
description: 'Page number, starting at 1.',
|
|
426
|
+
routing: {
|
|
427
|
+
send: {
|
|
428
|
+
type: 'query',
|
|
429
|
+
property: 'page',
|
|
430
|
+
},
|
|
431
|
+
},
|
|
432
|
+
},
|
|
433
|
+
{
|
|
434
|
+
displayName: 'Page Size',
|
|
435
|
+
name: 'pageSize',
|
|
436
|
+
type: 'number',
|
|
437
|
+
default: 0,
|
|
438
|
+
description: 'Number of items per page.',
|
|
439
|
+
routing: {
|
|
440
|
+
send: {
|
|
441
|
+
type: 'query',
|
|
442
|
+
property: 'pageSize',
|
|
443
|
+
},
|
|
444
|
+
},
|
|
445
|
+
},
|
|
446
|
+
{
|
|
447
|
+
displayName: 'Sort Field',
|
|
448
|
+
name: 'sortField',
|
|
449
|
+
type: 'string',
|
|
450
|
+
default: '',
|
|
451
|
+
description: 'Field used to sort children.',
|
|
452
|
+
routing: {
|
|
453
|
+
send: {
|
|
454
|
+
type: 'query',
|
|
455
|
+
property: 'sortField',
|
|
456
|
+
},
|
|
457
|
+
},
|
|
458
|
+
},
|
|
459
|
+
{
|
|
460
|
+
displayName: 'Sort Direction',
|
|
461
|
+
name: 'sortDirection',
|
|
462
|
+
type: 'number',
|
|
463
|
+
default: 0,
|
|
464
|
+
description: 'Sort direction. Gofile documents this as an integer; the exact semantic values are left unconstrained.',
|
|
465
|
+
routing: {
|
|
466
|
+
send: {
|
|
467
|
+
type: 'query',
|
|
468
|
+
property: 'sortDirection',
|
|
469
|
+
},
|
|
470
|
+
},
|
|
471
|
+
},
|
|
472
|
+
],
|
|
473
|
+
},
|
|
474
|
+
{
|
|
475
|
+
displayName: 'Content Id',
|
|
476
|
+
name: 'contentId',
|
|
477
|
+
type: 'string',
|
|
478
|
+
default: '',
|
|
479
|
+
required: true,
|
|
480
|
+
description: 'Folder ID to search within.',
|
|
481
|
+
displayOptions: {
|
|
482
|
+
show: {
|
|
483
|
+
resource: ['contents'],
|
|
484
|
+
operation: ['searchContents'],
|
|
485
|
+
},
|
|
486
|
+
},
|
|
487
|
+
routing: {
|
|
488
|
+
send: {
|
|
489
|
+
type: 'query',
|
|
490
|
+
property: 'contentId',
|
|
491
|
+
},
|
|
492
|
+
},
|
|
493
|
+
},
|
|
494
|
+
{
|
|
495
|
+
displayName: 'Searched String',
|
|
496
|
+
name: 'searchedString',
|
|
497
|
+
type: 'string',
|
|
498
|
+
default: '',
|
|
499
|
+
required: true,
|
|
500
|
+
description: 'String to match against names or tags.',
|
|
501
|
+
displayOptions: {
|
|
502
|
+
show: {
|
|
503
|
+
resource: ['contents'],
|
|
504
|
+
operation: ['searchContents'],
|
|
505
|
+
},
|
|
506
|
+
},
|
|
507
|
+
routing: {
|
|
508
|
+
send: {
|
|
509
|
+
type: 'query',
|
|
510
|
+
property: 'searchedString',
|
|
511
|
+
},
|
|
512
|
+
},
|
|
513
|
+
},
|
|
514
|
+
{
|
|
515
|
+
displayName: 'Additional Fields',
|
|
516
|
+
name: 'additionalFields',
|
|
517
|
+
type: 'collection',
|
|
518
|
+
placeholder: 'Add Field',
|
|
519
|
+
default: {},
|
|
520
|
+
displayOptions: {
|
|
521
|
+
show: {
|
|
522
|
+
resource: ['contents'],
|
|
523
|
+
operation: ['searchContents'],
|
|
524
|
+
},
|
|
525
|
+
},
|
|
526
|
+
options: [
|
|
527
|
+
{
|
|
528
|
+
displayName: 'Password',
|
|
529
|
+
name: 'password',
|
|
530
|
+
type: 'string',
|
|
531
|
+
default: '',
|
|
532
|
+
description: 'SHA-256 hash of the password for password-protected content.',
|
|
533
|
+
routing: {
|
|
534
|
+
send: {
|
|
535
|
+
type: 'query',
|
|
536
|
+
property: 'password',
|
|
537
|
+
},
|
|
538
|
+
},
|
|
539
|
+
},
|
|
540
|
+
{
|
|
541
|
+
displayName: 'Create Time From',
|
|
542
|
+
name: 'createTimeFrom',
|
|
543
|
+
type: 'number',
|
|
544
|
+
default: 0,
|
|
545
|
+
description: 'Inclusive lower creation-time Unix timestamp.',
|
|
546
|
+
routing: {
|
|
547
|
+
send: {
|
|
548
|
+
type: 'query',
|
|
549
|
+
property: 'createTimeFrom',
|
|
550
|
+
},
|
|
551
|
+
},
|
|
552
|
+
},
|
|
553
|
+
{
|
|
554
|
+
displayName: 'Create Time To',
|
|
555
|
+
name: 'createTimeTo',
|
|
556
|
+
type: 'number',
|
|
557
|
+
default: 0,
|
|
558
|
+
description: 'Inclusive upper creation-time Unix timestamp.',
|
|
559
|
+
routing: {
|
|
560
|
+
send: {
|
|
561
|
+
type: 'query',
|
|
562
|
+
property: 'createTimeTo',
|
|
563
|
+
},
|
|
564
|
+
},
|
|
565
|
+
},
|
|
566
|
+
],
|
|
567
|
+
},
|
|
568
|
+
{
|
|
569
|
+
displayName: 'Content Id',
|
|
570
|
+
name: 'contentId',
|
|
571
|
+
type: 'string',
|
|
572
|
+
default: '',
|
|
573
|
+
required: true,
|
|
574
|
+
description: 'Gofile content/folder identifier.',
|
|
575
|
+
displayOptions: {
|
|
576
|
+
show: {
|
|
577
|
+
resource: ['contents'],
|
|
578
|
+
operation: ['createDirectLink'],
|
|
579
|
+
},
|
|
580
|
+
},
|
|
581
|
+
},
|
|
582
|
+
{
|
|
583
|
+
displayName: 'Body (JSON)',
|
|
584
|
+
name: 'bodyJson',
|
|
585
|
+
type: 'json',
|
|
586
|
+
default: '{}',
|
|
587
|
+
required: false,
|
|
588
|
+
description: "Raw JSON request body. The spec's body schema is too complex to expose as individual fields, so provide the full JSON payload here.",
|
|
589
|
+
displayOptions: {
|
|
590
|
+
show: {
|
|
591
|
+
resource: ['contents'],
|
|
592
|
+
operation: ['createDirectLink'],
|
|
593
|
+
},
|
|
594
|
+
},
|
|
595
|
+
routing: {
|
|
596
|
+
request: {
|
|
597
|
+
body: '={{JSON.parse($value)}}',
|
|
598
|
+
},
|
|
599
|
+
},
|
|
600
|
+
},
|
|
601
|
+
{
|
|
602
|
+
displayName: 'Content Id',
|
|
603
|
+
name: 'contentId',
|
|
604
|
+
type: 'string',
|
|
605
|
+
default: '',
|
|
606
|
+
required: true,
|
|
607
|
+
description: 'Gofile content/folder identifier.',
|
|
608
|
+
displayOptions: {
|
|
609
|
+
show: {
|
|
610
|
+
resource: ['contents'],
|
|
611
|
+
operation: ['updateDirectLink'],
|
|
612
|
+
},
|
|
613
|
+
},
|
|
614
|
+
},
|
|
615
|
+
{
|
|
616
|
+
displayName: 'Direct Link Id',
|
|
617
|
+
name: 'directLinkId',
|
|
618
|
+
type: 'string',
|
|
619
|
+
default: '',
|
|
620
|
+
required: true,
|
|
621
|
+
description: 'Direct link identifier.',
|
|
622
|
+
displayOptions: {
|
|
623
|
+
show: {
|
|
624
|
+
resource: ['contents'],
|
|
625
|
+
operation: ['updateDirectLink'],
|
|
626
|
+
},
|
|
627
|
+
},
|
|
628
|
+
},
|
|
629
|
+
{
|
|
630
|
+
displayName: 'Body (JSON)',
|
|
631
|
+
name: 'bodyJson',
|
|
632
|
+
type: 'json',
|
|
633
|
+
default: '{}',
|
|
634
|
+
required: true,
|
|
635
|
+
description: "Raw JSON request body. The spec's body schema is too complex to expose as individual fields, so provide the full JSON payload here.",
|
|
636
|
+
displayOptions: {
|
|
637
|
+
show: {
|
|
638
|
+
resource: ['contents'],
|
|
639
|
+
operation: ['updateDirectLink'],
|
|
640
|
+
},
|
|
641
|
+
},
|
|
642
|
+
routing: {
|
|
643
|
+
request: {
|
|
644
|
+
body: '={{JSON.parse($value)}}',
|
|
645
|
+
},
|
|
646
|
+
},
|
|
647
|
+
},
|
|
648
|
+
{
|
|
649
|
+
displayName: 'Content Id',
|
|
650
|
+
name: 'contentId',
|
|
651
|
+
type: 'string',
|
|
652
|
+
default: '',
|
|
653
|
+
required: true,
|
|
654
|
+
description: 'Gofile content/folder identifier.',
|
|
655
|
+
displayOptions: {
|
|
656
|
+
show: {
|
|
657
|
+
resource: ['contents'],
|
|
658
|
+
operation: ['deleteDirectLink'],
|
|
659
|
+
},
|
|
660
|
+
},
|
|
661
|
+
},
|
|
662
|
+
{
|
|
663
|
+
displayName: 'Direct Link Id',
|
|
664
|
+
name: 'directLinkId',
|
|
665
|
+
type: 'string',
|
|
666
|
+
default: '',
|
|
667
|
+
required: true,
|
|
668
|
+
description: 'Direct link identifier.',
|
|
669
|
+
displayOptions: {
|
|
670
|
+
show: {
|
|
671
|
+
resource: ['contents'],
|
|
672
|
+
operation: ['deleteDirectLink'],
|
|
673
|
+
},
|
|
674
|
+
},
|
|
675
|
+
},
|
|
676
|
+
{
|
|
677
|
+
displayName: 'Contents Id',
|
|
678
|
+
name: 'contentsId',
|
|
679
|
+
type: 'string',
|
|
680
|
+
default: '',
|
|
681
|
+
required: true,
|
|
682
|
+
description: 'Comma-separated content IDs.',
|
|
683
|
+
displayOptions: {
|
|
684
|
+
show: {
|
|
685
|
+
resource: ['contents'],
|
|
686
|
+
operation: ['copyContents'],
|
|
687
|
+
},
|
|
688
|
+
},
|
|
689
|
+
routing: {
|
|
690
|
+
send: {
|
|
691
|
+
type: 'body',
|
|
692
|
+
property: 'contentsId',
|
|
693
|
+
},
|
|
694
|
+
},
|
|
695
|
+
},
|
|
696
|
+
{
|
|
697
|
+
displayName: 'Folder Id',
|
|
698
|
+
name: 'folderId',
|
|
699
|
+
type: 'string',
|
|
700
|
+
default: '',
|
|
701
|
+
required: true,
|
|
702
|
+
description: 'Destination folder ID.',
|
|
703
|
+
displayOptions: {
|
|
704
|
+
show: {
|
|
705
|
+
resource: ['contents'],
|
|
706
|
+
operation: ['copyContents'],
|
|
707
|
+
},
|
|
708
|
+
},
|
|
709
|
+
routing: {
|
|
710
|
+
send: {
|
|
711
|
+
type: 'body',
|
|
712
|
+
property: 'folderId',
|
|
713
|
+
},
|
|
714
|
+
},
|
|
715
|
+
},
|
|
716
|
+
{
|
|
717
|
+
displayName: 'Additional Fields',
|
|
718
|
+
name: 'additionalFields',
|
|
719
|
+
type: 'collection',
|
|
720
|
+
placeholder: 'Add Field',
|
|
721
|
+
default: {},
|
|
722
|
+
displayOptions: {
|
|
723
|
+
show: {
|
|
724
|
+
resource: ['contents'],
|
|
725
|
+
operation: ['copyContents'],
|
|
726
|
+
},
|
|
727
|
+
},
|
|
728
|
+
options: [
|
|
729
|
+
{
|
|
730
|
+
displayName: 'Password',
|
|
731
|
+
name: 'password',
|
|
732
|
+
type: 'string',
|
|
733
|
+
default: '',
|
|
734
|
+
description: 'SHA-256 password hash when copying password-protected content.',
|
|
735
|
+
routing: {
|
|
736
|
+
send: {
|
|
737
|
+
type: 'body',
|
|
738
|
+
property: 'password',
|
|
739
|
+
},
|
|
740
|
+
},
|
|
741
|
+
},
|
|
742
|
+
],
|
|
743
|
+
},
|
|
744
|
+
{
|
|
745
|
+
displayName: 'Contents Id',
|
|
746
|
+
name: 'contentsId',
|
|
747
|
+
type: 'string',
|
|
748
|
+
default: '',
|
|
749
|
+
required: true,
|
|
750
|
+
description: 'Comma-separated content IDs.',
|
|
751
|
+
displayOptions: {
|
|
752
|
+
show: {
|
|
753
|
+
resource: ['contents'],
|
|
754
|
+
operation: ['moveContents'],
|
|
755
|
+
},
|
|
756
|
+
},
|
|
757
|
+
routing: {
|
|
758
|
+
send: {
|
|
759
|
+
type: 'body',
|
|
760
|
+
property: 'contentsId',
|
|
761
|
+
},
|
|
762
|
+
},
|
|
763
|
+
},
|
|
764
|
+
{
|
|
765
|
+
displayName: 'Folder Id',
|
|
766
|
+
name: 'folderId',
|
|
767
|
+
type: 'string',
|
|
768
|
+
default: '',
|
|
769
|
+
required: true,
|
|
770
|
+
description: 'Destination folder ID.',
|
|
771
|
+
displayOptions: {
|
|
772
|
+
show: {
|
|
773
|
+
resource: ['contents'],
|
|
774
|
+
operation: ['moveContents'],
|
|
775
|
+
},
|
|
776
|
+
},
|
|
777
|
+
routing: {
|
|
778
|
+
send: {
|
|
779
|
+
type: 'body',
|
|
780
|
+
property: 'folderId',
|
|
781
|
+
},
|
|
782
|
+
},
|
|
783
|
+
},
|
|
784
|
+
{
|
|
785
|
+
displayName: 'Contents Id',
|
|
786
|
+
name: 'contentsId',
|
|
787
|
+
type: 'string',
|
|
788
|
+
default: '',
|
|
789
|
+
required: true,
|
|
790
|
+
description: 'Comma-separated content IDs to import.',
|
|
791
|
+
displayOptions: {
|
|
792
|
+
show: {
|
|
793
|
+
resource: ['contents'],
|
|
794
|
+
operation: ['importContents'],
|
|
795
|
+
},
|
|
796
|
+
},
|
|
797
|
+
routing: {
|
|
798
|
+
send: {
|
|
799
|
+
type: 'body',
|
|
800
|
+
property: 'contentsId',
|
|
801
|
+
},
|
|
802
|
+
},
|
|
803
|
+
},
|
|
804
|
+
{
|
|
805
|
+
displayName: 'Additional Fields',
|
|
806
|
+
name: 'additionalFields',
|
|
807
|
+
type: 'collection',
|
|
808
|
+
placeholder: 'Add Field',
|
|
809
|
+
default: {},
|
|
810
|
+
displayOptions: {
|
|
811
|
+
show: {
|
|
812
|
+
resource: ['contents'],
|
|
813
|
+
operation: ['importContents'],
|
|
814
|
+
},
|
|
815
|
+
},
|
|
816
|
+
options: [
|
|
817
|
+
{
|
|
818
|
+
displayName: 'Password',
|
|
819
|
+
name: 'password',
|
|
820
|
+
type: 'string',
|
|
821
|
+
default: '',
|
|
822
|
+
description: 'SHA-256 password hash when importing password-protected content.',
|
|
823
|
+
routing: {
|
|
824
|
+
send: {
|
|
825
|
+
type: 'body',
|
|
826
|
+
property: 'password',
|
|
827
|
+
},
|
|
828
|
+
},
|
|
829
|
+
},
|
|
830
|
+
],
|
|
831
|
+
},
|
|
832
|
+
{
|
|
833
|
+
displayName: 'Account Id',
|
|
834
|
+
name: 'accountId',
|
|
835
|
+
type: 'string',
|
|
836
|
+
default: '',
|
|
837
|
+
required: true,
|
|
838
|
+
description: 'Gofile account identifier.',
|
|
839
|
+
displayOptions: {
|
|
840
|
+
show: {
|
|
841
|
+
resource: ['accounts'],
|
|
842
|
+
operation: ['getAccount'],
|
|
843
|
+
},
|
|
844
|
+
},
|
|
845
|
+
},
|
|
846
|
+
{
|
|
847
|
+
displayName: 'Account Id',
|
|
848
|
+
name: 'accountId',
|
|
849
|
+
type: 'string',
|
|
850
|
+
default: '',
|
|
851
|
+
required: true,
|
|
852
|
+
description: 'Gofile account identifier.',
|
|
853
|
+
displayOptions: {
|
|
854
|
+
show: {
|
|
855
|
+
resource: ['accounts'],
|
|
856
|
+
operation: ['resetAccountToken'],
|
|
857
|
+
},
|
|
858
|
+
},
|
|
859
|
+
},
|
|
860
|
+
],
|
|
861
|
+
};
|
|
862
|
+
}
|
|
863
|
+
}
|
|
864
|
+
exports.GofileAPINode = GofileAPINode;
|
|
@@ -468,6 +468,18 @@ class RemoteChromiumCDPAutomationAPINode {
|
|
|
468
468
|
},
|
|
469
469
|
},
|
|
470
470
|
},
|
|
471
|
+
{
|
|
472
|
+
name: 'Get A Captured Response Body (scripts, JSON, HTML, Images, ...)',
|
|
473
|
+
value: 'networkResponseBodyTabsTargetIdNetworkLogRequestIdBodyGet',
|
|
474
|
+
action: 'Get a captured response body (scripts, JSON, HTML, images, ...)',
|
|
475
|
+
description: 'Fetch the body of a request that already appears in the network log.\n\nThis only works while Chromium still has the body buffered in memory —\ngoverned by CDP_NETWORK_MAX_RESOURCE_BUFFER / CDP_NETWORK_MAX_TOTAL_BUFFER\nand cleared on navigation — so fetch it soon after the request finishes,\nnot as a permanent record. A 404 here most often means the body was\nevicted, not that anything went wrong.',
|
|
476
|
+
routing: {
|
|
477
|
+
request: {
|
|
478
|
+
method: 'GET',
|
|
479
|
+
url: '=/tabs/{{$parameter["targetId"]}}/network/log/{{$parameter["requestId"]}}/body',
|
|
480
|
+
},
|
|
481
|
+
},
|
|
482
|
+
},
|
|
471
483
|
{
|
|
472
484
|
name: 'Block Requests Matching URL Patterns (wildcards Allowed)',
|
|
473
485
|
value: 'networkBlockTabsTargetIdNetworkBlockPost',
|
|
@@ -2386,6 +2398,62 @@ class RemoteChromiumCDPAutomationAPINode {
|
|
|
2386
2398
|
},
|
|
2387
2399
|
},
|
|
2388
2400
|
},
|
|
2401
|
+
{
|
|
2402
|
+
displayName: 'Target Id',
|
|
2403
|
+
name: 'targetId',
|
|
2404
|
+
type: 'string',
|
|
2405
|
+
default: '',
|
|
2406
|
+
required: true,
|
|
2407
|
+
description: '',
|
|
2408
|
+
displayOptions: {
|
|
2409
|
+
show: {
|
|
2410
|
+
resource: ['tabs'],
|
|
2411
|
+
operation: ['networkResponseBodyTabsTargetIdNetworkLogRequestIdBodyGet'],
|
|
2412
|
+
},
|
|
2413
|
+
},
|
|
2414
|
+
},
|
|
2415
|
+
{
|
|
2416
|
+
displayName: 'Request Id',
|
|
2417
|
+
name: 'requestId',
|
|
2418
|
+
type: 'string',
|
|
2419
|
+
default: '',
|
|
2420
|
+
required: true,
|
|
2421
|
+
description: '',
|
|
2422
|
+
displayOptions: {
|
|
2423
|
+
show: {
|
|
2424
|
+
resource: ['tabs'],
|
|
2425
|
+
operation: ['networkResponseBodyTabsTargetIdNetworkLogRequestIdBodyGet'],
|
|
2426
|
+
},
|
|
2427
|
+
},
|
|
2428
|
+
},
|
|
2429
|
+
{
|
|
2430
|
+
displayName: 'Additional Fields',
|
|
2431
|
+
name: 'additionalFields',
|
|
2432
|
+
type: 'collection',
|
|
2433
|
+
placeholder: 'Add Field',
|
|
2434
|
+
default: {},
|
|
2435
|
+
displayOptions: {
|
|
2436
|
+
show: {
|
|
2437
|
+
resource: ['tabs'],
|
|
2438
|
+
operation: ['networkResponseBodyTabsTargetIdNetworkLogRequestIdBodyGet'],
|
|
2439
|
+
},
|
|
2440
|
+
},
|
|
2441
|
+
options: [
|
|
2442
|
+
{
|
|
2443
|
+
displayName: 'Raw',
|
|
2444
|
+
name: 'raw',
|
|
2445
|
+
type: 'boolean',
|
|
2446
|
+
default: false,
|
|
2447
|
+
description: '',
|
|
2448
|
+
routing: {
|
|
2449
|
+
send: {
|
|
2450
|
+
type: 'query',
|
|
2451
|
+
property: 'raw',
|
|
2452
|
+
},
|
|
2453
|
+
},
|
|
2454
|
+
},
|
|
2455
|
+
],
|
|
2456
|
+
},
|
|
2389
2457
|
{
|
|
2390
2458
|
displayName: 'Target Id',
|
|
2391
2459
|
name: 'targetId',
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "n8n-nodes-test-node",
|
|
3
|
-
"version": "1.0.
|
|
4
|
-
"description": "
|
|
3
|
+
"version": "1.0.11",
|
|
4
|
+
"description": "OpenAPI 3 specification for the Gofile REST API, based on the official Gofile API documentation last updated May 16, 2025. Gofile is a beta API and may change. Authentication uses an API token as a Bearer token in the Authorization header. Most endpoints require a premium account; basic operations such as uploading, creating folders, renaming content, and removing content are available to free accounts.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"n8n-community-node-package"
|
|
7
7
|
],
|
|
@@ -16,10 +16,10 @@
|
|
|
16
16
|
"n8n": {
|
|
17
17
|
"n8nNodesApiVersion": 1,
|
|
18
18
|
"credentials": [
|
|
19
|
-
"dist/
|
|
19
|
+
"dist/GofileAPIApi.credentials.js"
|
|
20
20
|
],
|
|
21
21
|
"nodes": [
|
|
22
|
-
"dist/
|
|
22
|
+
"dist/GofileAPINode.node.js"
|
|
23
23
|
]
|
|
24
24
|
},
|
|
25
25
|
"devDependencies": {
|