n8n-nodes-base
Version:
Base nodes of n8n
620 lines • 20.3 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.bucketFields = exports.bucketOperations = void 0;
// Projection field controls the page limit maximum
// When not returning all, return the max number for the current projection parameter
const PAGE_LIMITS = {
noAcl: 1000,
full: 200,
};
// Define a JSON parse function here to use it in two places
async function parseJSONBody(requestOptions) {
if (!requestOptions.body)
requestOptions.body = {};
const body = this.getNodeParameter('createBody');
// Parse all the JSON fields
if (body.acl) {
try {
body.acl = JSON.parse(body.acl);
}
catch (error) { }
}
if (body.billing) {
try {
body.billing = JSON.parse(body.billing);
}
catch (error) { }
}
if (body.cors) {
try {
body.cors = JSON.parse(body.cors);
}
catch (error) { }
}
if (body.customPlacementConfig) {
try {
body.customPlacementConfig = JSON.parse(body.customPlacementConfig);
}
catch (error) { }
}
if (body.dataLocations) {
try {
body.dataLocations = JSON.parse(body.dataLocations);
}
catch (error) { }
}
if (body.defaultObjectAcl) {
try {
body.defaultObjectAcl = JSON.parse(body.defaultObjectAcl);
}
catch (error) { }
}
if (body.encryption) {
try {
body.encryption = JSON.parse(body.encryption);
}
catch (error) { }
}
if (body.iamConfiguration) {
try {
body.iamConfiguration = JSON.parse(body.iamConfiguration);
}
catch (error) { }
}
if (body.labels) {
try {
body.labels = JSON.parse(body.labels);
}
catch (error) { }
}
if (body.lifecycle) {
try {
body.lifecycle = JSON.parse(body.lifecycle);
}
catch (error) { }
}
if (body.logging) {
try {
body.logging = JSON.parse(body.logging);
}
catch (error) { }
}
if (body.retentionPolicy) {
try {
body.retentionPolicy = JSON.parse(body.retentionPolicy);
}
catch (error) { }
}
if (body.versioning) {
try {
body.versioning = JSON.parse(body.versioning);
}
catch (error) { }
}
if (body.website) {
try {
body.website = JSON.parse(body.website);
}
catch (error) { }
}
requestOptions.body = Object.assign(requestOptions.body, body);
return requestOptions;
}
exports.bucketOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['bucket'],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create a new Bucket',
routing: {
request: {
method: 'POST',
url: '/b/',
qs: {},
body: {
name: '={{$parameter["bucketName"]}}',
},
returnFullResponse: true,
},
send: {
preSend: [parseJSONBody],
},
},
action: 'Create a new Bucket',
},
{
name: 'Delete',
value: 'delete',
description: 'Delete an empty Bucket',
routing: {
request: {
method: 'DELETE',
url: '={{"/b/" + $parameter["bucketName"]}}',
returnFullResponse: true,
},
},
action: 'Delete an empty Bucket',
},
{
name: 'Get',
value: 'get',
description: 'Get metadata for a specific Bucket',
routing: {
request: {
method: 'GET',
url: '={{"/b/" + $parameter["bucketName"]}}',
returnFullResponse: true,
qs: {},
},
},
action: 'Get a Bucket',
},
{
name: 'Get Many',
value: 'getAll',
description: 'Get list of Buckets',
routing: {
request: {
method: 'GET',
url: '/b/',
qs: {},
},
send: {
paginate: true,
preSend: [
async function (requestOptions) {
if (!requestOptions.qs)
requestOptions.qs = {};
const returnAll = this.getNodeParameter('returnAll');
if (!returnAll) {
const key = this.getNodeParameter('projection');
requestOptions.qs.maxResults =
key === 'noAcl' ? PAGE_LIMITS.noAcl : PAGE_LIMITS.full;
}
return requestOptions;
},
],
},
operations: {
async pagination(requestOptions) {
if (!requestOptions.options.qs)
requestOptions.options.qs = {};
let executions = [];
let responseData;
let nextPageToken = undefined;
const returnAll = this.getNodeParameter('returnAll');
const extractBucketsList = (page) => {
const buckets = page.json.items;
if (buckets) {
executions = executions.concat(buckets.map((bucket) => ({ json: bucket })));
}
};
do {
requestOptions.options.qs.pageToken = nextPageToken;
responseData = await this.makeRoutingRequest(requestOptions);
// Check for another page
const lastItem = responseData[responseData.length - 1].json;
nextPageToken = lastItem.nextPageToken;
// Extract just the list of buckets from the page data
responseData.forEach(extractBucketsList);
// If we don't return all, just return the first page
} while (returnAll && nextPageToken);
// Return all execution responses as an array
return executions;
},
},
},
action: 'Get a list of Buckets for a given project',
},
{
name: 'Update',
value: 'update',
description: 'Update the metadata of a bucket',
routing: {
request: {
method: 'PATCH',
url: '={{"/b/" + $parameter["bucketName"]}}',
qs: {
project: '={{$parameter["projectId"]}}',
},
body: {},
returnFullResponse: true,
},
send: {
preSend: [parseJSONBody],
},
},
action: 'Update the metadata of a Bucket',
},
],
default: 'getAll',
},
];
exports.bucketFields = [
{
displayName: 'Project ID',
name: 'projectId',
type: 'string',
required: true,
placeholder: 'Project ID',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['create', 'getAll'],
},
},
default: '',
routing: {
request: {
qs: {
project: '={{$value}}',
},
},
},
},
{
displayName: 'Bucket Name',
name: 'bucketName',
type: 'string',
placeholder: 'Bucket Name',
required: true,
displayOptions: {
show: {
resource: ['bucket'],
operation: ['create', 'get', 'update', 'delete'],
},
},
default: '',
},
{
displayName: 'Prefix',
name: 'prefix',
type: 'string',
placeholder: 'Filter for Bucket Names',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['getAll'],
},
},
default: '',
routing: {
request: {
qs: {
prefix: '={{$value}}',
},
},
},
},
{
displayName: 'Projection',
name: 'projection',
type: 'options',
noDataExpression: true,
options: [
{
name: 'All Properties',
value: 'full',
},
{
name: 'No ACL',
value: 'noAcl',
},
],
default: 'noAcl',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['create', 'get', 'getAll', 'update'],
},
},
routing: {
request: {
qs: {
projection: '={{$value}}',
},
},
},
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['getAll'],
},
},
default: false,
description: 'Whether to return all results or only up to a given limit',
},
{
displayName: 'Filters',
name: 'getFilters',
type: 'collection',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['delete', 'get', 'update'],
},
},
default: {},
placeholder: 'Add Filter',
options: [
{
displayName: 'Metageneration Match',
name: 'ifMetagenerationMatch',
type: 'number',
description: 'Only return data if the metageneration value of the Bucket matches the sent value',
default: 0,
routing: {
request: {
qs: {
ifMetagenerationMatch: '={{$value}}',
},
},
},
},
{
displayName: 'Metageneration Exclude',
name: 'ifMetagenerationNotMatch',
type: 'number',
description: 'Only return data if the metageneration value of the Bucket does not match the sent value',
default: 0,
routing: {
request: {
qs: {
ifMetagenerationNotMatch: '={{$value}}',
},
},
},
},
],
},
{
displayName: 'Predefined Access Control',
name: 'createAcl',
type: 'collection',
noDataExpression: true,
default: {},
placeholder: 'Add Access Control Parameters',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['create', 'update'],
},
},
options: [
{
displayName: 'Predefined ACL',
name: 'predefinedAcl',
type: 'options',
default: 'authenticatedRead',
placeholder: 'Apply a predefined set of access controls to this bucket',
options: [
{
name: 'Authenticated Read',
value: 'authenticatedRead',
},
{
name: 'Private',
value: 'private',
},
{
name: 'Project Private',
value: 'projectPrivate',
},
{
name: 'Public Read',
value: 'publicRead',
},
{
name: 'Public Read/Write',
value: 'publicReadWrite',
},
],
routing: {
request: {
qs: {
predefinedAcl: '={{$value}}',
},
},
},
},
{
displayName: 'Predefined Default Object ACL',
name: 'predefinedDefaultObjectAcl',
type: 'options',
default: 'authenticatedRead',
placeholder: 'Apply a predefined set of default object access controls to this bucket',
options: [
{
name: 'Authenticated Read',
value: 'authenticatedRead',
},
{
name: 'Bucket Owner Full Control',
value: 'bucketOwnerFullControl',
},
{
name: 'Bucket Owner Read',
value: 'bucketOwnerRead',
},
{
name: 'Private',
value: 'private',
},
{
name: 'Project Private',
value: 'projectPrivate',
},
{
name: 'Public Read',
value: 'publicRead',
},
],
routing: {
request: {
qs: {
predefinedObjectAcl: '={{$value}}',
},
},
},
},
],
},
{
displayName: 'Additional Parameters',
name: 'createBody',
type: 'collection',
noDataExpression: true,
default: {},
placeholder: 'Add Metadata Parameter',
displayOptions: {
show: {
resource: ['bucket'],
operation: ['create', 'update'],
},
},
options: [
{
displayName: 'Access Control',
name: 'acl',
type: 'json',
default: '[]',
placeholder: 'Access controls on the Bucket',
},
{
displayName: 'Billing',
name: 'billing',
type: 'json',
default: '{}',
placeholder: "The bucket's billing configuration",
},
{
displayName: 'CORS',
name: 'cors',
type: 'json',
default: '[]',
placeholder: "The bucket's Cross Origin Resource Sharing configuration",
},
{
displayName: 'Custom Placement Config',
name: 'customPlacementConfig',
type: 'json',
default: '{}',
placeholder: 'The configuration for the region(s) for the Bucket',
},
{
displayName: 'Data Locations',
name: 'dataLocations',
type: 'json',
default: '[]',
placeholder: 'The list of individual regions that comprise a dual-region Bucket',
},
{
displayName: 'Default Event Based Hold',
name: 'defaultEventBasedHold',
type: 'boolean',
default: true,
placeholder: 'Whether or not to automatically apply an event based hold to new objects',
},
{
displayName: 'Default Object ACL',
name: 'defaultObjectAcl',
type: 'json',
default: '[]',
placeholder: 'Default Access Controls for new objects when no ACL is provided',
},
{
displayName: 'Encryption',
name: 'encryption',
type: 'json',
default: '{}',
placeholder: 'Encryption configuration for a bucket',
},
{
displayName: 'IAM Configuration',
name: 'iamConfiguration',
type: 'json',
default: '{}',
placeholder: "The bucket's IAM configuration",
},
{
displayName: 'Labels',
name: 'labels',
type: 'json',
default: '{}',
placeholder: 'User provided bucket labels, in key/value pairs',
},
{
displayName: 'Lifecycle',
name: 'lifecycle',
type: 'json',
default: '{}',
placeholder: "The bucket's lifecycle configuration",
},
{
displayName: 'Location',
name: 'location',
type: 'string',
default: 'US',
placeholder: 'The location of the bucket',
},
{
displayName: 'Logging',
name: 'logging',
type: 'json',
default: '{}',
placeholder: "The bucket's logging configuration",
},
{
displayName: 'Retention Policy',
name: 'retentionPolicy',
type: 'json',
default: '{}',
placeholder: "The bucket's retention policy",
},
{
displayName: 'Recovery Point Objective',
name: 'rpo',
type: 'string',
default: 'DEFAULT',
placeholder: 'The recovery point objective for the bucket',
},
{
displayName: 'Storage Class',
name: 'storageClass',
type: 'string',
default: 'STANDARD',
placeholder: "The bucket's default storage class for objects that don't define one",
},
{
displayName: 'Versioning',
name: 'versioning',
type: 'json',
default: '{}',
placeholder: "The bucket's versioning configuration",
},
{
displayName: 'Website',
name: 'website',
type: 'json',
default: '{}',
placeholder: "The bucket's website configuration for when it is used to host a website",
},
],
},
];
//# sourceMappingURL=BucketDescription.js.map