Elastic Security node (#2206)

*  Create Elastic Security node

* 🔨 Place Elastic nodes in Elastic dir

*  Improvements

* 🔨 Split credentials

* 🎨 Fix formatting

*  Tolerate trailing slash

* 👕 Fix lint

* 👕 Fix lint

* 🐛 Fix tags filter in case:getAll

* 🔨 Refactor sort options in case:getAll

* ✏️ Reword param descriptions

* 🔥 Remove descriptions per feedback

* 🐛 Fix case:getStatus operation

* ✏️ Reword param and error message

* ✏️ Reword param descriptions

* 🔨 Account for empty string in owner

* ✏️ Reword param description

* ✏️ Add more tooltip descriptions

*  Add cred test

* ✏️ Add param description

* ✏️ Add comment dividers

*  Improve UX for third-party service params

* 🔨 Minor tweaks per feedback

* 🔨 Make getStatus naming consistent

*  Fix operation

Co-authored-by: ricardo <ricardoespinoza105@gmail.com>
Co-authored-by: Mutasem <mutdmour@gmail.com>
Co-authored-by: Jan Oberhauser <jan.oberhauser@gmail.com>
This commit is contained in:
Iván Ovejero
2021-09-22 17:48:50 +02:00
committed by GitHub
parent 5644a88d78
commit ca9a155c69
21 changed files with 2296 additions and 8 deletions

View File

@@ -0,0 +1,625 @@
import {
IExecuteFunctions,
} from 'n8n-core';
import {
ICredentialsDecrypted,
ICredentialTestFunctions,
IDataObject,
ILoadOptionsFunctions,
INodeExecutionData,
INodePropertyOptions,
INodeType,
INodeTypeDescription,
NodeCredentialTestResult,
NodeOperationError,
} from 'n8n-workflow';
import {
elasticSecurityApiRequest,
getConnector,
getVersion,
handleListing,
throwOnEmptyUpdate,
tolerateTrailingSlash,
} from './GenericFunctions';
import {
caseCommentFields,
caseCommentOperations,
caseFields,
caseOperations,
caseTagFields,
caseTagOperations,
connectorFields,
connectorOperations,
} from './descriptions';
import {
Connector,
ConnectorCreatePayload,
ConnectorType,
ElasticSecurityApiCredentials,
} from './types';
import {
OptionsWithUri,
} from 'request';
export class ElasticSecurity implements INodeType {
description: INodeTypeDescription = {
displayName: 'Elastic Security',
name: 'elasticSecurity',
icon: 'file:elasticSecurity.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Consume the Elastic Security API',
defaults: {
name: 'Elastic Security',
color: '#f3d337',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'elasticSecurityApi',
required: true,
testedBy: 'elasticSecurityApiTest',
},
],
properties: [
{
displayName: 'Resource',
name: 'resource',
noDataExpression: true,
type: 'options',
options: [
{
name: 'Case',
value: 'case',
},
{
name: 'Case Comment',
value: 'caseComment',
},
{
name: 'Case Tag',
value: 'caseTag',
},
{
name: 'Connector',
value: 'connector',
},
],
default: 'case',
},
...caseOperations,
...caseFields,
...caseCommentOperations,
...caseCommentFields,
...caseTagOperations,
...caseTagFields,
...connectorOperations,
...connectorFields,
],
};
methods = {
loadOptions: {
async getTags(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const tags = await elasticSecurityApiRequest.call(this, 'GET', '/cases/tags') as string[];
return tags.map(tag => ({ name: tag, value: tag }));
},
async getConnectors(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const endpoint = '/cases/configure/connectors/_find';
const connectors = await elasticSecurityApiRequest.call(this, 'GET', endpoint) as Connector[];
return connectors.map(({ name, id }) => ({ name, value: id }));
},
},
credentialTest: {
async elasticSecurityApiTest(
this: ICredentialTestFunctions,
credential: ICredentialsDecrypted,
): Promise<NodeCredentialTestResult> {
const {
username,
password,
baseUrl: rawBaseUrl,
} = credential.data as ElasticSecurityApiCredentials;
const baseUrl = tolerateTrailingSlash(rawBaseUrl);
const token = Buffer.from(`${username}:${password}`).toString('base64');
const endpoint = '/cases/status';
const options: OptionsWithUri = {
headers: {
Authorization: `Basic ${token}`,
'kbn-xsrf': true,
},
method: 'GET',
body: {},
qs: {},
uri: `${baseUrl}/api${endpoint}`,
json: true,
};
try {
await this.helpers.request(options);
return {
status: 'OK',
message: 'Authentication successful',
};
} catch (error) {
return {
status: 'Error',
message: error.message,
};
}
},
},
};
async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
const items = this.getInputData();
const returnData: IDataObject[] = [];
const resource = this.getNodeParameter('resource', 0) as string;
const operation = this.getNodeParameter('operation', 0) as string;
let responseData;
for (let i = 0; i < items.length; i++) {
try {
if (resource === 'case') {
// **********************************************************************
// case
// **********************************************************************
if (operation === 'create') {
// ----------------------------------------
// case: create
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-create.html
const body = {
title: this.getNodeParameter('title', i),
connector: {},
owner: 'securitySolution',
description: '',
tags: [], // set via `caseTag: add` but must be present
settings: {
syncAlerts: this.getNodeParameter('additionalFields.syncAlerts', i, false),
},
} as IDataObject;
const connectorId = this.getNodeParameter('connectorId', i) as ConnectorType;
const {
id: fetchedId,
name: fetchedName,
type: fetchedType,
} = await getConnector.call(this, connectorId);
const selectedConnectorType = this.getNodeParameter('connectorType', i) as ConnectorType;
if (fetchedType !== selectedConnectorType) {
throw new NodeOperationError(
this.getNode(),
'Connector Type does not match the type of the connector in Connector Name',
);
}
const connector = {
id: fetchedId,
name: fetchedName,
type: fetchedType,
fields: {},
};
if (selectedConnectorType === '.jira') {
connector.fields = {
issueType: this.getNodeParameter('issueType', i),
priority: this.getNodeParameter('priority', i),
parent: null, // required but unimplemented
};
} else if (selectedConnectorType === '.servicenow') {
connector.fields = {
urgency: this.getNodeParameter('urgency', i),
severity: this.getNodeParameter('severity', i),
impact: this.getNodeParameter('impact', i),
category: this.getNodeParameter('category', i),
subcategory: null, // required but unimplemented
};
} else if (selectedConnectorType === '.resilient') {
const rawIssueTypes = this.getNodeParameter('issueTypes', i) as string;
connector.fields = {
issueTypes: rawIssueTypes.split(',').map(Number),
severityCode: this.getNodeParameter('severityCode', i) as number,
incidentTypes: null, // required but undocumented
};
}
body.connector = connector;
const {
syncAlerts, // ignored because already set
...rest
} = this.getNodeParameter('additionalFields', i) as IDataObject;
if (Object.keys(rest).length) {
Object.assign(body, rest);
}
responseData = await elasticSecurityApiRequest.call(this, 'POST', '/cases', body);
} else if (operation === 'delete') {
// ----------------------------------------
// case: delete
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-delete-case.html
const caseId = this.getNodeParameter('caseId', i);
await elasticSecurityApiRequest.call(this, 'DELETE', `/cases?ids=["${caseId}"]`);
responseData = { success: true };
} else if (operation === 'get') {
// ----------------------------------------
// case: get
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-get-case.html
const caseId = this.getNodeParameter('caseId', i);
responseData = await elasticSecurityApiRequest.call(this, 'GET', `/cases/${caseId}`);
} else if (operation === 'getAll') {
// ----------------------------------------
// case: getAll
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-find-cases.html
const qs = {} as IDataObject;
const {
tags,
status,
} = this.getNodeParameter('filters', i) as IDataObject & { tags: string[], status: string };
const sortOptions = this.getNodeParameter('sortOptions', i) as IDataObject;
qs.sortField = sortOptions.sortField ?? 'createdAt';
qs.sortOrder = sortOptions.sortOrder ?? 'asc';
if (status) {
qs.status = status;
}
if (tags?.length) {
qs.tags = tags.join(',');
}
responseData = await handleListing.call(this, 'GET', '/cases/_find', {}, qs);
} else if (operation === 'getStatus') {
// ----------------------------------------
// case: getStatus
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-get-status.html
responseData = await elasticSecurityApiRequest.call(this, 'GET', '/cases/status');
} else if (operation === 'update') {
// ----------------------------------------
// case: update
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-update.html
const caseId = this.getNodeParameter('caseId', i);
const body = {} as IDataObject;
const updateFields = this.getNodeParameter('updateFields', i) as IDataObject;
if (!Object.keys(updateFields).length) {
throwOnEmptyUpdate.call(this, resource);
}
const { syncAlerts, ...rest } = updateFields;
Object.assign(body, {
cases: [
{
id: caseId,
version: await getVersion.call(this, `/cases/${caseId}`),
...(syncAlerts && { settings: { syncAlerts } }),
...rest,
},
],
});
responseData = await elasticSecurityApiRequest.call(this, 'PATCH', '/cases', body);
}
} else if (resource === 'caseTag') {
// **********************************************************************
// caseTag
// **********************************************************************
if (operation === 'add') {
// ----------------------------------------
// caseTag: add
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-create.html
const caseId = this.getNodeParameter('caseId', i);
const {
title,
connector,
owner,
description,
settings,
tags,
} = await elasticSecurityApiRequest.call(this, 'GET', `/cases/${caseId}`);
const tagToAdd = this.getNodeParameter('tag', i);
if (tags.includes(tagToAdd)) {
throw new NodeOperationError(
this.getNode(),
`Cannot add tag "${tagToAdd}" to case ID ${caseId} because this case already has this tag.`,
);
}
const body = {};
Object.assign(body, {
cases: [
{
id: caseId,
title,
connector,
owner,
description,
settings,
version: await getVersion.call(this, `/cases/${caseId}`),
tags: [...tags, tagToAdd],
},
],
});
responseData = await elasticSecurityApiRequest.call(this, 'PATCH', '/cases', body);
} else if (operation === 'remove') {
// https://www.elastic.co/guide/en/security/current/cases-api-update.html
const caseId = this.getNodeParameter('caseId', i);
const tagToRemove = this.getNodeParameter('tag', i) as string;
const {
title,
connector,
owner,
description,
settings,
tags,
} = await elasticSecurityApiRequest.call(this, 'GET', `/cases/${caseId}`) as IDataObject & { tags: string[] };
if (!tags.includes(tagToRemove)) {
throw new NodeOperationError(this.getNode(), `Cannot remove tag "${tagToRemove}" from case ID ${caseId} because this case does not have this tag.`);
}
const body = {};
Object.assign(body, {
cases: [
{
id: caseId,
title,
connector,
owner,
description,
settings,
version: await getVersion.call(this, `/cases/${caseId}`),
tags: tags.filter((tag) => tag !== tagToRemove),
},
],
});
responseData = await elasticSecurityApiRequest.call(this, 'PATCH', '/cases', body);
}
} else if (resource === 'caseComment') {
// **********************************************************************
// caseComment
// **********************************************************************
if (operation === 'add') {
// ----------------------------------------
// caseComment: add
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-add-comment.html
const simple = this.getNodeParameter('simple', i) as boolean;
const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;
const body = {
comment: this.getNodeParameter('comment', i),
type: 'user',
owner: additionalFields.owner || 'securitySolution',
} as IDataObject;
const caseId = this.getNodeParameter('caseId', i);
const endpoint = `/cases/${caseId}/comments`;
responseData = await elasticSecurityApiRequest.call(this, 'POST', endpoint, body);
if (simple === true) {
const { comments } = responseData;
responseData = comments[comments.length - 1];
}
} else if (operation === 'get') {
// ----------------------------------------
// caseComment: get
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-get-comment.html
const caseId = this.getNodeParameter('caseId', i);
const commentId = this.getNodeParameter('commentId', i);
const endpoint = `/cases/${caseId}/comments/${commentId}`;
responseData = await elasticSecurityApiRequest.call(this, 'GET', endpoint);
} else if (operation === 'getAll') {
// ----------------------------------------
// caseComment: getAll
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-get-all-case-comments.html
const caseId = this.getNodeParameter('caseId', i);
const endpoint = `/cases/${caseId}/comments`;
responseData = await handleListing.call(this, 'GET', endpoint);
} else if (operation === 'remove') {
// ----------------------------------------
// caseComment: remove
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-delete-comment.html
const caseId = this.getNodeParameter('caseId', i);
const commentId = this.getNodeParameter('commentId', i);
const endpoint = `/cases/${caseId}/comments/${commentId}`;
await elasticSecurityApiRequest.call(this, 'DELETE', endpoint);
responseData = { success: true };
} else if (operation === 'update') {
// ----------------------------------------
// caseComment: update
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/cases-api-update-comment.html
const simple = this.getNodeParameter('simple', i) as boolean;
const caseId = this.getNodeParameter('caseId', i);
const commentId = this.getNodeParameter('commentId', i);
const body = {
comment: this.getNodeParameter('comment', i),
id: commentId,
type: 'user',
owner: 'securitySolution',
version: await getVersion.call(this, `/cases/${caseId}/comments/${commentId}`),
} as IDataObject;
const patchEndpoint = `/cases/${caseId}/comments`;
responseData = await elasticSecurityApiRequest.call(this, 'PATCH', patchEndpoint, body);
if (simple === true) {
const { comments } = responseData;
responseData = comments[comments.length - 1];
}
}
} else if (resource === 'connector') {
if (operation === 'create') {
// ----------------------------------------
// connector: create
// ----------------------------------------
// https://www.elastic.co/guide/en/security/current/register-connector.html
const connectorType = this.getNodeParameter('connectorType', i) as ConnectorType;
const body: ConnectorCreatePayload = {
connector_type_id: connectorType,
name: this.getNodeParameter('name', i) as string,
};
if (connectorType === '.jira') {
body.config = {
apiUrl: this.getNodeParameter('apiUrl', i) as string,
projectKey: this.getNodeParameter('projectKey', i) as string,
};
body.secrets = {
email: this.getNodeParameter('email', i) as string,
apiToken: this.getNodeParameter('apiToken', i) as string,
};
} else if (connectorType === '.resilient') {
body.config = {
apiUrl: this.getNodeParameter('apiUrl', i) as string,
orgId: this.getNodeParameter('orgId', i) as string,
};
body.secrets = {
apiKeyId: this.getNodeParameter('apiKeyId', i) as string,
apiKeySecret: this.getNodeParameter('apiKeySecret', i) as string,
};
} else if (connectorType === '.servicenow') {
body.config = {
apiUrl: this.getNodeParameter('apiUrl', i) as string,
};
body.secrets = {
username: this.getNodeParameter('username', i) as string,
password: this.getNodeParameter('password', i) as string,
};
}
responseData = await elasticSecurityApiRequest.call(this, 'POST', '/actions/connector', body);
}
}
Array.isArray(responseData)
? returnData.push(...responseData)
: returnData.push(responseData);
} catch (error) {
if (this.continueOnFail()) {
returnData.push({ error: error.message });
continue;
}
throw error;
}
}
return [this.helpers.returnJsonArray(returnData)];
}
}

View File

@@ -0,0 +1,163 @@
import {
IExecuteFunctions,
} from 'n8n-core';
import {
IDataObject,
ILoadOptionsFunctions,
NodeApiError,
NodeOperationError,
} from 'n8n-workflow';
import {
OptionsWithUri,
} from 'request';
import {
Connector,
ElasticSecurityApiCredentials,
} from './types';
export async function elasticSecurityApiRequest(
this: IExecuteFunctions | ILoadOptionsFunctions,
method: string,
endpoint: string,
body: IDataObject = {},
qs: IDataObject = {},
) {
const {
username,
password,
baseUrl: rawBaseUrl,
} = await this.getCredentials('elasticSecurityApi') as ElasticSecurityApiCredentials;
const baseUrl = tolerateTrailingSlash(rawBaseUrl);
const token = Buffer.from(`${username}:${password}`).toString('base64');
const options: OptionsWithUri = {
headers: {
Authorization: `Basic ${token}`,
'kbn-xsrf': true,
},
method,
body,
qs,
uri: `${baseUrl}/api${endpoint}`,
json: true,
};
if (!Object.keys(body).length) {
delete options.body;
}
if (!Object.keys(qs).length) {
delete options.qs;
}
try {
return await this.helpers.request!(options);
} catch (error) {
if (error?.error?.error === 'Not Acceptable' && error?.error?.message) {
error.error.error = `${error.error.error}: ${error.error.message}`;
}
throw new NodeApiError(this.getNode(), error);
}
}
export async function elasticSecurityApiRequestAllItems(
this: IExecuteFunctions,
method: string,
endpoint: string,
body: IDataObject = {},
qs: IDataObject = {},
) {
let page = 1;
const returnData: IDataObject[] = [];
let responseData: any; // tslint:disable-line
const resource = this.getNodeParameter('resource', 0) as 'case' | 'caseComment';
do {
responseData = await elasticSecurityApiRequest.call(this, method, endpoint, body, qs);
page++;
const items = resource === 'case'
? responseData.cases
: responseData;
returnData.push(...items);
} while (returnData.length < responseData.total);
return returnData;
}
export async function handleListing(
this: IExecuteFunctions,
method: string,
endpoint: string,
body: IDataObject = {},
qs: IDataObject = {},
) {
const returnAll = this.getNodeParameter('returnAll', 0) as boolean;
if (returnAll) {
return await elasticSecurityApiRequestAllItems.call(this, method, endpoint, body, qs);
}
const responseData = await elasticSecurityApiRequestAllItems.call(this, method, endpoint, body, qs);
const limit = this.getNodeParameter('limit', 0) as number;
return responseData.slice(0, limit);
}
/**
* Retrieve a connector name and type from a connector ID.
*
* https://www.elastic.co/guide/en/kibana/master/get-connector-api.html
*/
export async function getConnector(
this: IExecuteFunctions,
connectorId: string,
) {
const endpoint = `/actions/connector/${connectorId}`;
const {
id,
name,
connector_type_id: type,
} = await elasticSecurityApiRequest.call(this, 'GET', endpoint) as Connector;
return { id, name, type };
}
export function throwOnEmptyUpdate(
this: IExecuteFunctions,
resource: string,
) {
throw new NodeOperationError(
this.getNode(),
`Please enter at least one field to update for the ${resource}`,
);
}
export async function getVersion(
this: IExecuteFunctions,
endpoint: string,
) {
const { version } = await elasticSecurityApiRequest.call(this, 'GET', endpoint) as {
version?: string;
};
if (!version) {
throw new NodeOperationError(this.getNode(), 'Cannot retrieve version for resource');
}
return version;
}
export function tolerateTrailingSlash(baseUrl: string) {
return baseUrl.endsWith('/')
? baseUrl.substr(0, baseUrl.length - 1)
: baseUrl;
}

View File

@@ -0,0 +1,345 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const caseCommentOperations: INodeProperties[] = [
{
displayName: 'Operation',
name: 'operation',
noDataExpression: true,
type: 'options',
displayOptions: {
show: {
resource: [
'caseComment',
],
},
},
options: [
{
name: 'Add',
value: 'add',
description: 'Add a comment to a case',
},
{
name: 'Get',
value: 'get',
description: 'Get a case comment',
},
{
name: 'Get All',
value: 'getAll',
description: 'Retrieve all case comments',
},
{
name: 'Remove',
value: 'remove',
description: 'Remove a comment from a case',
},
{
name: 'Update',
value: 'update',
description: 'Update a comment in a case',
},
],
default: 'add',
},
];
export const caseCommentFields: INodeProperties[] = [
// ----------------------------------------
// caseComment: add
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
description: 'ID of the case containing the comment to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'add',
],
},
},
},
{
displayName: 'Comment',
name: 'comment',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'add',
],
},
},
},
{
displayName: 'Simplify Response',
name: 'simple',
type: 'boolean',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'add',
],
},
},
default: true,
description: 'Whether to return a simplified version of the response instead of the raw data',
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'add',
],
},
},
options: [
{
displayName: 'Owner',
name: 'owner',
type: 'string',
description: 'Valid application owner registered within the Cases Role Based Access Control system',
default: '',
},
],
},
// ----------------------------------------
// caseComment: get
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
description: 'ID of the case containing the comment to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'get',
],
},
},
},
{
displayName: 'Comment ID',
name: 'commentId',
description: 'ID of the case comment to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'get',
],
},
},
},
// ----------------------------------------
// caseComment: getAll
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 50,
description: 'Max number of results to return',
typeOptions: {
minValue: 1,
},
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
// ----------------------------------------
// caseComment: remove
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
description: 'ID of the case containing the comment to remove',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'remove',
],
},
},
},
{
displayName: 'Comment ID',
name: 'commentId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'remove',
],
},
},
},
// ----------------------------------------
// caseComment: update
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
description: 'ID of the case containing the comment to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Comment ID',
name: 'commentId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Comment',
name: 'comment',
description: 'Text to replace current comment message',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Simplify Response',
name: 'simple',
type: 'boolean',
displayOptions: {
show: {
resource: [
'caseComment',
],
operation: [
'update',
],
},
},
default: true,
description: 'Whether to return a simplified version of the response instead of the raw data',
},
];

View File

@@ -0,0 +1,659 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const caseOperations: INodeProperties[] = [
{
displayName: 'Operation',
name: 'operation',
noDataExpression: true,
type: 'options',
displayOptions: {
show: {
resource: [
'case',
],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create a case',
},
{
name: 'Delete',
value: 'delete',
description: 'Delete a case',
},
{
name: 'Get',
value: 'get',
description: 'Get a case',
},
{
name: 'Get All',
value: 'getAll',
description: 'Retrieve all cases',
},
{
name: 'Get Status',
value: 'getStatus',
description: 'Retrieve a summary of all case activity',
},
{
name: 'Update',
value: 'update',
description: 'Update a case',
},
],
default: 'create',
},
];
export const caseFields: INodeProperties[] = [
// ----------------------------------------
// case: create
// ----------------------------------------
{
displayName: 'Title',
name: 'title',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Connector Name',
name: 'connectorId',
description: 'Connectors allow you to send Elastic Security cases into other systems (only ServiceNow, Jira, or IBM Resilient)',
type: 'options',
required: true,
default: '',
typeOptions: {
loadOptionsMethod: 'getConnectors',
},
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Connector Type',
name: 'connectorType',
type: 'options',
required: true,
default: '.jira',
options: [
{
name: 'IBM Resilient',
value: '.resilient',
},
{
name: 'Jira',
value: '.jira',
},
{
name: 'ServiceNow ITSM',
value: '.servicenow',
},
],
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Issue Type',
name: 'issueType',
description: 'Type of the Jira issue to create for this case',
type: 'string',
placeholder: 'Task',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.jira',
],
},
},
},
{
displayName: 'Priority',
name: 'priority',
description: 'Priority of the Jira issue to create for this case',
type: 'string',
placeholder: 'High',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.jira',
],
},
},
},
{
displayName: 'Urgency',
name: 'urgency',
description: 'Urgency of the ServiceNow ITSM issue to create for this case',
type: 'options',
required: true,
default: 1,
options: [
{
name: 'Low',
value: 1,
},
{
name: 'Medium',
value: 2,
},
{
name: 'High',
value: 3,
},
],
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.servicenow',
],
},
},
},
{
displayName: 'Severity',
name: 'severity',
description: 'Severity of the ServiceNow ITSM issue to create for this case',
type: 'options',
required: true,
default: 1,
options: [
{
name: 'Low',
value: 1,
},
{
name: 'Medium',
value: 2,
},
{
name: 'High',
value: 3,
},
],
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.servicenow',
],
},
},
},
{
displayName: 'Impact',
name: 'impact',
description: 'Impact of the ServiceNow ITSM issue to create for this case',
type: 'options',
required: true,
default: 1,
options: [
{
name: 'Low',
value: 1,
},
{
name: 'Medium',
value: 2,
},
{
name: 'High',
value: 3,
},
],
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.servicenow',
],
},
},
},
{
displayName: 'Category',
name: 'category',
type: 'string',
description: 'Category of the ServiceNow ITSM issue to create for this case',
required: true,
default: '',
placeholder: 'Helpdesk',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.servicenow',
],
},
},
},
{
displayName: 'Issue Types',
name: 'issueTypes',
description: 'Comma-separated list of numerical types of the IBM Resilient issue to create for this case',
type: 'string',
placeholder: '123,456',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.resilient',
],
},
},
},
{
displayName: 'Severity Code',
name: 'severityCode',
description: 'Severity code of the IBM Resilient issue to create for this case',
type: 'number',
typeOptions: {
minValue: 0,
},
required: true,
default: 1,
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
connectorType: [
'.resilient',
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'create',
],
},
},
options: [
{
displayName: 'Description',
name: 'description',
type: 'string',
default: '',
},
{
displayName: 'Owner',
name: 'owner',
type: 'string',
description: 'Valid application owner registered within the Cases Role Based Access Control system',
default: '',
},
{
displayName: 'Sync Alerts',
name: 'syncAlerts',
description: 'Whether to synchronize with alerts',
type: 'boolean',
default: false,
},
],
},
// ----------------------------------------
// case: delete
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'delete',
],
},
},
},
// ----------------------------------------
// case: get
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'get',
],
},
},
},
// ----------------------------------------
// case: getAll
// ----------------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 50,
description: 'Max number of results to return',
typeOptions: {
minValue: 1,
},
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
{
displayName: 'Filters',
name: 'filters',
type: 'collection',
default: {},
placeholder: 'Add Filter',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'getAll',
],
},
},
options: [
{
displayName: 'Status',
name: 'status',
type: 'options',
options: [
{
name: 'Open',
value: 'open',
},
{
name: 'In Progress',
value: 'in-progress',
},
{
name: 'Closed',
value: 'closed',
},
],
default: 'open',
},
{
displayName: 'Tags',
name: 'tags',
type: 'multiOptions',
default: [],
typeOptions: {
loadOptionsMethod: 'getTags',
},
},
],
},
{
displayName: 'Sort',
name: 'sortOptions',
type: 'fixedCollection',
placeholder: 'Add Sort Options',
default: {},
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'getAll',
],
},
},
options: [
{
displayName: 'Sort Options',
name: 'sortOptionsProperties',
values: [
{
displayName: 'Sort Key',
name: 'sortField',
type: 'options',
options: [
{
name: 'Created At',
value: 'createdAt',
},
{
name: 'Updated At',
value: 'updatedAt',
},
],
default: 'createdAt',
},
{
displayName: 'Sort Order',
name: 'sortOrder',
type: 'options',
options: [
{
name: 'Ascending',
value: 'asc',
},
{
name: 'Descending',
value: 'desc',
},
],
default: 'asc',
},
],
},
],
},
// ----------------------------------------
// case: update
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Update Fields',
name: 'updateFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: [
'case',
],
operation: [
'update',
],
},
},
options: [
{
displayName: 'Description',
name: 'description',
type: 'string',
default: '',
},
{
displayName: 'Status',
name: 'status',
type: 'options',
default: 'open',
options: [
{
name: 'Closed',
value: 'closed',
},
{
name: 'Open',
value: 'open',
},
{
name: 'In Progress',
value: 'in-progress',
},
],
},
{
displayName: 'Sync Alerts',
name: 'syncAlerts',
description: 'Whether to synchronize with alerts',
type: 'boolean',
default: false,
},
{
displayName: 'Title',
name: 'title',
type: 'string',
default: '',
},
{
displayName: 'Version',
name: 'version',
type: 'string',
default: '',
},
],
},
];

View File

@@ -0,0 +1,117 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const caseTagOperations: INodeProperties[] = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: [
'caseTag',
],
},
},
options: [
{
name: 'Add',
value: 'add',
description: 'Add a tag to a case',
},
{
name: 'Remove',
value: 'remove',
description: 'Remove a tag from a case',
},
],
default: 'add',
},
];
export const caseTagFields: INodeProperties[] = [
// ----------------------------------------
// caseTag: add
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseTag',
],
operation: [
'add',
],
},
},
},
{
displayName: 'Tag',
name: 'tag',
type: 'options',
description: 'Tag to attach to the case. Choose from the list or enter a new one with an expression.',
required: true,
default: '',
typeOptions: {
loadOptionsMethod: 'getTags',
},
displayOptions: {
show: {
resource: [
'caseTag',
],
operation: [
'add',
],
},
},
},
// ----------------------------------------
// caseTag: remove
// ----------------------------------------
{
displayName: 'Case ID',
name: 'caseId',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'caseTag',
],
operation: [
'remove',
],
},
},
},
{
displayName: 'Tag',
name: 'tag',
type: 'options',
required: true,
default: '',
typeOptions: {
loadOptionsMethod: 'getTags',
},
displayOptions: {
show: {
resource: [
'caseTag',
],
operation: [
'remove',
],
},
},
},
];

View File

@@ -0,0 +1,268 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const connectorOperations: INodeProperties[] = [
{
displayName: 'Operation',
name: 'operation',
noDataExpression: true,
type: 'options',
displayOptions: {
show: {
resource: [
'connector',
],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create a connector',
},
],
default: 'create',
},
];
export const connectorFields: INodeProperties[] = [
// ----------------------------------------
// connector: create
// ----------------------------------------
{
displayName: 'Connector Name',
name: 'name',
description: 'Connectors allow you to send Elastic Security cases into other systems (only ServiceNow, Jira, or IBM Resilient)',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Connector Type',
name: 'connectorType',
type: 'options',
required: true,
default: '.jira',
options: [
{
name: 'IBM Resilient',
value: '.resilient',
},
{
name: 'Jira',
value: '.jira',
},
{
name: 'ServiceNow ITSM',
value: '.servicenow',
},
],
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
},
},
},
{
displayName: 'API URL',
name: 'apiUrl',
type: 'string',
description: 'URL of the third-party instance',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Email',
name: 'email',
description: 'Jira-registered email',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.jira',
],
},
},
},
{
displayName: 'API Token',
name: 'apiToken',
description: 'Jira API token',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.jira',
],
},
},
},
{
displayName: 'Project Key',
name: 'projectKey',
description: 'Jira Project Key',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.jira',
],
},
},
},
{
displayName: 'Username',
name: 'username',
description: 'ServiceNow ITSM username',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.servicenow',
],
},
},
},
{
displayName: 'Password',
name: 'password',
description: 'ServiceNow ITSM password',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.servicenow',
],
},
},
},
{
displayName: 'API Key ID',
name: 'apiKeyId',
description: 'IBM Resilient API key ID',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.resilient',
],
},
},
},
{
displayName: 'API Key Secret',
name: 'apiKeySecret',
description: 'IBM Resilient API key secret',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.resilient',
],
},
},
},
{
displayName: 'Organization ID',
name: 'orgId',
description: 'IBM Resilient organization ID',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'connector',
],
operation: [
'create',
],
connectorType: [
'.resilient',
],
},
},
},
];

View File

@@ -0,0 +1,4 @@
export * from './CaseDescription';
export * from './CaseCommentDescription';
export * from './CaseTagDescription';
export * from './ConnectorDescription';

View File

@@ -0,0 +1,11 @@
<svg width="64px" height="64px" viewBox="2 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<!-- Generator: Sketch 63.1 (92452) - https://sketch.com -->
<title>security-logo-color-32px</title>
<desc>Created with Sketch.</desc>
<g id="security-logo-color-32px" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
<rect id="bounding-box" x="0" y="0" width="32" height="32"/>
<path d="M9,7.00818271 L9,5.68434189e-14 L29,5.68434189e-14 L29,16.744186 C29,20.6574083 22.621662,23.2210512 19.9845875,24 L19.9845875,7.00818271 L9,7.00818271 Z" id="Shape" fill="#FA744E"/>
<path d="M3,20.0727575 L3,10 L17,10 L17,32 C7.66666667,27.9800464 3,24.0042989 3,20.0727575 Z" id="Path" fill="#1DBAB0"/>
<path d="M9,10 L17,10 L17,24 C14.0165399,22.8590583 9,20.2435363 9,16.956562 L9,10 Z" id="Path" fill="#343741"/>
</g>
</svg>

After

Width:  |  Height:  |  Size: 929 B

View File

@@ -0,0 +1,56 @@
export type ElasticSecurityApiCredentials = {
username: string;
password: string;
baseUrl: string;
};
export type ConnectorType = '.jira' | '.servicenow' | '.resilient';
export type Connector = {
id: string;
name: string;
connector_type_id: ConnectorType
};
export type ConnectorCreatePayload =
| ServiceNowConnectorCreatePayload
| JiraConnectorCreatePayload
| IbmResilientConnectorCreatePayload;
type ServiceNowConnectorCreatePayload = {
connector_type_id: '.servicenow',
name: string,
secrets?: {
username: string;
password: string;
},
config?: {
apiUrl: string;
},
};
type JiraConnectorCreatePayload = {
connector_type_id: '.jira',
name: string,
secrets?: {
email: string;
apiToken: string;
},
config?: {
apiUrl: string;
projectKey: string;
},
};
type IbmResilientConnectorCreatePayload = {
connector_type_id: '.resilient',
name: string,
secrets?: {
apiKeyId: string;
apiKeySecret: string;
},
config?: {
apiUrl: string;
orgId: string;
},
};

View File

@@ -0,0 +1,21 @@
{
"node": "n8n-nodes-base.elasticsearch",
"nodeVersion": "1.0",
"codexVersion": "1.0",
"categories": [
"Development",
"Data & Storage"
],
"resources": {
"credentialDocumentation": [
{
"url": "https://docs.n8n.io/credentials/elasticsearch"
}
],
"primaryDocumentation": [
{
"url": "https://docs.n8n.io/nodes/n8n-nodes-base.elasticsearch/"
}
]
}
}

View File

@@ -0,0 +1,364 @@
import {
IExecuteFunctions,
} from 'n8n-core';
import {
IDataObject,
INodeExecutionData,
INodeType,
INodeTypeDescription,
} from 'n8n-workflow';
import {
elasticsearchApiRequest,
} from './GenericFunctions';
import {
documentFields,
documentOperations,
indexFields,
indexOperations,
} from './descriptions';
import {
DocumentGetAllOptions,
FieldsUiValues,
} from './types';
import {
omit,
} from 'lodash';
export class Elasticsearch implements INodeType {
description: INodeTypeDescription = {
displayName: 'Elasticsearch',
name: 'elasticsearch',
icon: 'file:elasticsearch.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Consume the Elasticsearch API',
defaults: {
name: 'Elasticsearch',
color: '#f3d337',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'elasticsearchApi',
required: true,
},
],
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
options: [
{
name: 'Document',
value: 'document',
},
{
name: 'Index',
value: 'index',
},
],
default: 'document',
description: 'Resource to consume',
},
...documentOperations,
...documentFields,
...indexOperations,
...indexFields,
],
};
async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
const items = this.getInputData();
const returnData: IDataObject[] = [];
const resource = this.getNodeParameter('resource', 0) as 'document' | 'index';
const operation = this.getNodeParameter('operation', 0) as string;
let responseData;
for (let i = 0; i < items.length; i++) {
if (resource === 'document') {
// **********************************************************************
// document
// **********************************************************************
// https://www.elastic.co/guide/en/elasticsearch/reference/current/docs.html
if (operation === 'delete') {
// ----------------------------------------
// document: delete
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete.html
const indexId = this.getNodeParameter('indexId', i);
const documentId = this.getNodeParameter('documentId', i);
const endpoint = `/${indexId}/_doc/${documentId}`;
responseData = await elasticsearchApiRequest.call(this, 'DELETE', endpoint);
} else if (operation === 'get') {
// ----------------------------------------
// document: get
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-get.html
const indexId = this.getNodeParameter('indexId', i);
const documentId = this.getNodeParameter('documentId', i);
const qs = {} as IDataObject;
const options = this.getNodeParameter('options', i) as IDataObject;
if (Object.keys(options).length) {
Object.assign(qs, options);
qs._source = true;
}
const endpoint = `/${indexId}/_doc/${documentId}`;
responseData = await elasticsearchApiRequest.call(this, 'GET', endpoint, {}, qs);
const simple = this.getNodeParameter('simple', i) as IDataObject;
if (simple) {
responseData = {
_id: responseData._id,
...responseData._source,
};
}
} else if (operation === 'getAll') {
// ----------------------------------------
// document: getAll
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html
const indexId = this.getNodeParameter('indexId', i);
const body = {} as IDataObject;
const qs = {} as IDataObject;
const options = this.getNodeParameter('options', i) as DocumentGetAllOptions;
if (Object.keys(options).length) {
const { query, ...rest } = options;
if (query) Object.assign(body, JSON.parse(query));
Object.assign(qs, rest);
qs._source = true;
}
const returnAll = this.getNodeParameter('returnAll', 0);
if (!returnAll) {
qs.size = this.getNodeParameter('limit', 0);
}
responseData = await elasticsearchApiRequest.call(this, 'GET', `/${indexId}/_search`, body, qs);
responseData = responseData.hits.hits;
const simple = this.getNodeParameter('simple', 0) as IDataObject;
if (simple) {
responseData = responseData.map((item: IDataObject) => {
return {
_id: item._id,
...(item._source as {}),
};
});
}
} else if (operation === 'create') {
// ----------------------------------------
// document: create
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-index_.html
const body: IDataObject = {};
const dataToSend = this.getNodeParameter('dataToSend', 0) as 'defineBelow' | 'autoMapInputData';
if (dataToSend === 'defineBelow') {
const fields = this.getNodeParameter('fieldsUi.fieldValues', i, []) as FieldsUiValues;
fields.forEach(({ fieldId, fieldValue }) => body[fieldId] = fieldValue);
} else {
const inputData = items[i].json;
const rawInputsToIgnore = this.getNodeParameter('inputsToIgnore', i) as string;
const inputsToIgnore = rawInputsToIgnore.split(',').map(c => c.trim());
for (const key of Object.keys(inputData)) {
if (inputsToIgnore.includes(key)) continue;
body[key] = inputData[key];
}
}
const qs = {} as IDataObject;
const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;
if (Object.keys(additionalFields).length) {
Object.assign(qs, omit(additionalFields, ['documentId']));
}
const indexId = this.getNodeParameter('indexId', i);
const { documentId } = additionalFields;
if (documentId) {
const endpoint = `/${indexId}/_doc/${documentId}`;
responseData = await elasticsearchApiRequest.call(this, 'PUT', endpoint, body);
} else {
const endpoint = `/${indexId}/_doc`;
responseData = await elasticsearchApiRequest.call(this, 'POST', endpoint, body);
}
} else if (operation === 'update') {
// ----------------------------------------
// document: update
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-update.html
const body = { doc: {} } as { doc: { [key: string]: string } };
const dataToSend = this.getNodeParameter('dataToSend', 0) as 'defineBelow' | 'autoMapInputData';
if (dataToSend === 'defineBelow') {
const fields = this.getNodeParameter('fieldsUi.fieldValues', i, []) as FieldsUiValues;
fields.forEach(({ fieldId, fieldValue }) => body.doc[fieldId] = fieldValue);
} else {
const inputData = items[i].json;
const rawInputsToIgnore = this.getNodeParameter('inputsToIgnore', i) as string;
const inputsToIgnore = rawInputsToIgnore.split(',').map(c => c.trim());
for (const key of Object.keys(inputData)) {
if (inputsToIgnore.includes(key)) continue;
body.doc[key] = inputData[key] as string;
}
}
const indexId = this.getNodeParameter('indexId', i);
const documentId = this.getNodeParameter('documentId', i);
const endpoint = `/${indexId}/_update/${documentId}`;
responseData = await elasticsearchApiRequest.call(this, 'POST', endpoint, body);
}
} else if (resource === 'index') {
// **********************************************************************
// index
// **********************************************************************
// https://www.elastic.co/guide/en/elasticsearch/reference/current/indices.html
if (operation === 'create') {
// ----------------------------------------
// index: create
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-create-index.html
const indexId = this.getNodeParameter('indexId', i);
const body = {} as IDataObject;
const qs = {} as IDataObject;
const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;
if (Object.keys(additionalFields).length) {
const { aliases, mappings, settings, ...rest } = additionalFields;
Object.assign(body, aliases, mappings, settings);
Object.assign(qs, rest);
}
responseData = await elasticsearchApiRequest.call(this, 'PUT', `/${indexId}`);
responseData = { id: indexId, ...responseData };
delete responseData.index;
} else if (operation === 'delete') {
// ----------------------------------------
// index: delete
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-delete-index.html
const indexId = this.getNodeParameter('indexId', i);
responseData = await elasticsearchApiRequest.call(this, 'DELETE', `/${indexId}`);
responseData = { success: true };
} else if (operation === 'get') {
// ----------------------------------------
// index: get
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-get-index.html
const indexId = this.getNodeParameter('indexId', i) as string;
const qs = {} as IDataObject;
const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;
if (Object.keys(additionalFields).length) {
Object.assign(qs, additionalFields);
}
responseData = await elasticsearchApiRequest.call(this, 'GET', `/${indexId}`, {}, qs);
responseData = { id: indexId, ...responseData[indexId] };
} else if (operation === 'getAll') {
// ----------------------------------------
// index: getAll
// ----------------------------------------
// https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html
responseData = await elasticsearchApiRequest.call(this, 'GET', '/_aliases');
responseData = Object.keys(responseData).map(i => ({ indexId: i }));
const returnAll = this.getNodeParameter('returnAll', i);
if (!returnAll) {
const limit = this.getNodeParameter('limit', i) as number;
responseData = responseData.slice(0, limit);
}
}
}
Array.isArray(responseData)
? returnData.push(...responseData)
: returnData.push(responseData);
}
return [this.helpers.returnJsonArray(returnData)];
}
}

View File

@@ -0,0 +1,58 @@
import {
OptionsWithUri,
} from 'request';
import {
IExecuteFunctions,
} from 'n8n-core';
import {
IDataObject,
NodeApiError,
} from 'n8n-workflow';
import {
ElasticsearchApiCredentials,
} from './types';
export async function elasticsearchApiRequest(
this: IExecuteFunctions,
method: 'GET' | 'PUT' | 'POST' | 'DELETE',
endpoint: string,
body: IDataObject = {},
qs: IDataObject = {},
) {
const {
username,
password,
baseUrl,
} = await this.getCredentials('elasticsearchApi') as ElasticsearchApiCredentials;
const token = Buffer.from(`${username}:${password}`).toString('base64');
const options: OptionsWithUri = {
headers: {
Authorization: `Basic ${token}`,
'Content-Type': 'application/json',
},
method,
body,
qs,
uri: `${baseUrl}${endpoint}`,
json: true,
};
if (!Object.keys(body).length) {
delete options.body;
}
if (!Object.keys(qs).length) {
delete options.qs;
}
try {
return await this.helpers.request(options);
} catch (error) {
throw new NodeApiError(this.getNode(), error);
}
}

View File

@@ -0,0 +1,788 @@
import {
INodeProperties,
} from 'n8n-workflow';
import * as placeholders from './placeholders';
export const documentOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
displayOptions: {
show: {
resource: [
'document',
],
},
},
options: [
{
name: 'Create',
value: 'create',
description: 'Create a document',
},
{
name: 'Delete',
value: 'delete',
description: 'Delete a document',
},
{
name: 'Get',
value: 'get',
description: 'Get a document',
},
{
name: 'Get All',
value: 'getAll',
description: 'Get all documents',
},
{
name: 'Update',
value: 'update',
description: 'Update a document',
},
],
default: 'get',
description: 'Operation to perform',
},
] as INodeProperties[];
export const documentFields = [
// ----------------------------------------
// document: delete
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index containing the document to delete',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'delete',
],
},
},
},
{
displayName: 'Document ID',
name: 'documentId',
description: 'ID of the document to delete',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'delete',
],
},
},
},
// ----------------------------------------
// document: get
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index containing the document to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'get',
],
},
},
},
{
displayName: 'Document ID',
name: 'documentId',
description: 'ID of the document to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'get',
],
},
},
},
{
displayName: 'Simple',
name: 'simple',
type: 'boolean',
default: true,
description: 'Whether to return a simplified version of the response instead of the raw data',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'get',
],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'get',
],
},
},
options: [
{
displayName: 'Source Excludes',
name: '_source_excludes',
description: 'Comma-separated list of source fields to exclude from the response',
type: 'string',
default: '',
},
{
displayName: 'Source Includes',
name: '_source_includes',
description: 'Comma-separated list of source fields to include in the response',
type: 'string',
default: '',
},
{
displayName: 'Stored Fields',
name: 'stored_fields',
description: 'If true, retrieve the document fields stored in the index rather than the document <code>_source</code>. Defaults to false',
type: 'boolean',
default: false,
},
],
},
// ----------------------------------------
// document: getAll
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index containing the documents to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 50,
description: 'How many results to return',
typeOptions: {
minValue: 1,
},
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
{
displayName: 'Simple',
name: 'simple',
type: 'boolean',
default: true,
description: 'Whether to return a simplified version of the response instead of the raw data',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'getAll',
],
},
},
options: [
{
displayName: 'Allow No Indices',
name: 'allow_no_indices',
description: 'If false, return an error if any of the following targets only missing/closed indices: wildcard expression, index alias, or <code>_all</code> value. Defaults to true',
type: 'boolean',
default: true,
},
{
displayName: 'Allow Partial Search Results',
name: 'allow_partial_search_results',
description: 'If true, return partial results if there are shard request timeouts or shard failures.<br>If false, returns an error with no partial results. Defaults to true',
type: 'boolean',
default: true,
},
{
displayName: 'Batched Reduce Size',
name: 'batched_reduce_size',
description: 'Number of shard results that should be reduced at once on the coordinating node. Defaults to 512',
type: 'number',
typeOptions: {
minValue: 2,
},
default: 512,
},
{
displayName: 'CCS Minimize Roundtrips',
name: 'ccs_minimize_roundtrips',
description: 'If true, network round-trips between the coordinating node and the remote clusters are minimized when executing cross-cluster search (CCS) requests. Defaults to true',
type: 'boolean',
default: true,
},
{
displayName: 'Doc Value Fields',
name: 'docvalue_fields',
description: 'Comma-separated list of fields to return as the docvalue representation of a field for each hit',
type: 'string',
default: '',
},
{
displayName: 'Expand Wildcards',
name: 'expand_wildcards',
description: 'Type of index that wildcard expressions can match. Defaults to <code>open</code>',
type: 'options',
options: [
{
name: 'All',
value: 'all',
},
{
name: 'Closed',
value: 'closed',
},
{
name: 'Hidden',
value: 'hidden',
},
{
name: 'None',
value: 'none',
},
{
name: 'Open',
value: 'open',
},
],
default: 'open',
},
{
displayName: 'Explain',
name: 'explain',
description: 'If true, return detailed information about score computation as part of a hit. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Ignore Throttled',
name: 'ignore_throttled',
description: 'If true, concrete, expanded or aliased indices are ignored when frozen. Defaults to true',
type: 'boolean',
default: true,
},
{
displayName: 'Ignore Unavailable',
name: 'ignore_unavailable',
description: 'If true, missing or closed indices are not included in the response. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Max Concurrent Shard Requests',
name: 'max_concurrent_shard_requests',
description: 'Define the number of shard requests per node this search executes concurrently. Defaults to 5',
type: 'number',
default: 5,
},
{
displayName: 'Pre-Filter Shard Size',
name: 'pre_filter_shard_size',
description: 'Define a threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting.<br>Only used if the number of shards the search request expands to exceeds the threshold',
type: 'number',
typeOptions: {
minValue: 1,
},
default: 1,
},
{
displayName: 'Query',
name: 'query',
description: 'Query in the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html">Elasticsearch Query DSL</a>',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
placeholder: placeholders.query,
},
{
displayName: 'Request Cache',
name: 'request_cache',
description: 'If true, the caching of search results is enabled for requests where size is 0. See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/shard-request-cache.html">Elasticsearch shard request cache settings</a>',
type: 'boolean',
default: false,
},
{
displayName: 'Routing',
name: 'routing',
description: 'Target this primary shard',
type: 'string',
default: '',
},
{
displayName: 'Search Type',
name: 'search_type',
description: 'How distributed term frequencies are calculated for relevance scoring. Defaults to Query then Fetch',
type: 'options',
options: [
{
name: 'DFS Query Then Fetch',
value: 'dfs_query_then_fetch',
},
{
name: 'Query Then Fetch',
value: 'query_then_fetch',
},
],
default: 'query_then_fetch',
},
{
displayName: 'Sequence Number and Primary Term',
name: 'seq_no_primary_term',
description: 'If true, return the sequence number and primary term of the last modification of each hit. See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/optimistic-concurrency-control.html">Optimistic concurrency control</a>',
type: 'boolean',
default: false,
},
{
displayName: 'Sort',
name: 'sort',
description: 'Comma-separated list of <code>field:direction</code> pairs',
type: 'string',
default: '',
},
{
displayName: 'Stats',
name: 'stats',
description: 'Tag of the request for logging and statistical purposes',
type: 'string',
default: '',
},
{
displayName: 'Stored Fields',
name: 'stored_fields',
description: 'If true, retrieve the document fields stored in the index rather than the document <code>_source</code>. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Terminate After',
name: 'terminate_after',
description: 'Max number of documents to collect for each shard',
type: 'number',
default: 0,
},
{
displayName: 'Timeout',
name: 'timeout',
description: 'Period to wait for active shards. Defaults to <code>1m</code> (one minute). See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#time-units">Elasticsearch time units reference</a>',
type: 'string',
default: '1m',
},
{
displayName: 'Track Scores',
name: 'track_scores',
description: 'If true, calculate and return document scores, even if the scores are not used for sorting. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Track Total Hits',
name: 'track_total_hits',
description: 'Number of hits matching the query to count accurately. Defaults to 10000',
type: 'number',
default: 10000,
},
{
displayName: 'Version',
name: 'version',
description: 'If true, return document version as part of a hit. Defaults to false',
type: 'boolean',
default: false,
},
],
},
// ----------------------------------------
// document: create
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index to add the document to',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Data to Send',
name: 'dataToSend',
type: 'options',
options: [
{
name: 'Define Below for Each Column',
value: 'defineBelow',
description: 'Set the value for each destination column',
},
{
name: 'Auto-map Input Data to Columns',
value: 'autoMapInputData',
description: 'Use when node input properties match destination column names',
},
],
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'create',
],
},
},
default: 'defineBelow',
description: 'Whether to insert the input data this node receives in the new row',
},
{
displayName: 'Inputs to Ignore',
name: 'inputsToIgnore',
type: 'string',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'create',
],
dataToSend: [
'autoMapInputData',
],
},
},
default: '',
required: false,
description: 'List of input properties to avoid sending, separated by commas. Leave empty to send all properties',
placeholder: 'Enter properties...',
},
{
displayName: 'Fields to Send',
name: 'fieldsUi',
placeholder: 'Add Field',
type: 'fixedCollection',
typeOptions: {
multipleValueButtonText: 'Add Field to Send',
multipleValues: true,
},
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'create',
],
dataToSend: [
'defineBelow',
],
},
},
default: {},
options: [
{
displayName: 'Field',
name: 'fieldValues',
values: [
{
displayName: 'Field Name',
name: 'fieldId',
type: 'string',
default: '',
},
{
displayName: 'Field Value',
name: 'fieldValue',
type: 'string',
default: '',
},
],
},
],
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'create',
],
},
},
options: [
{
displayName: 'Document ID',
name: 'documentId',
description: 'ID of the document to create and add to the index',
type: 'string',
default: '',
},
{
displayName: 'Routing',
name: 'routing',
description: 'Target this primary shard',
type: 'string',
default: '',
},
{
displayName: 'Timeout',
name: 'timeout',
description: 'Period to wait for active shards. Defaults to <code>1m</code> (one minute). See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#time-units">Elasticsearch time units reference</a>',
type: 'string',
default: '1m',
},
],
},
// ----------------------------------------
// document: update
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the document to update',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Document ID',
name: 'documentId',
description: 'ID of the document to update',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Data to Send',
name: 'dataToSend',
type: 'options',
options: [
{
name: 'Define Below for Each Column',
value: 'defineBelow',
description: 'Set the value for each destination column',
},
{
name: 'Auto-map Input Data to Columns',
value: 'autoMapInputData',
description: 'Use when node input properties match destination column names',
},
],
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'update',
],
},
},
default: 'defineBelow',
description: 'Whether to insert the input data this node receives in the new row',
},
{
displayName: 'Inputs to Ignore',
name: 'inputsToIgnore',
type: 'string',
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'update',
],
dataToSend: [
'autoMapInputData',
],
},
},
default: '',
required: false,
description: 'List of input properties to avoid sending, separated by commas. Leave empty to send all properties',
placeholder: 'Enter properties...',
},
{
displayName: 'Fields to Send',
name: 'fieldsUi',
placeholder: 'Add Field',
type: 'fixedCollection',
typeOptions: {
multipleValueButtonText: 'Add Field to Send',
multipleValues: true,
},
displayOptions: {
show: {
resource: [
'document',
],
operation: [
'update',
],
dataToSend: [
'defineBelow',
],
},
},
default: {},
options: [
{
displayName: 'Field',
name: 'fieldValues',
values: [
{
displayName: 'Field Name',
name: 'fieldId',
type: 'string',
default: '',
},
{
displayName: 'Field Value',
name: 'fieldValue',
type: 'string',
default: '',
},
],
},
],
},
] as INodeProperties[];

View File

@@ -0,0 +1,322 @@
import {
INodeProperties,
} from 'n8n-workflow';
import * as placeholders from './placeholders';
export const indexOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
displayOptions: {
show: {
resource: [
'index',
],
},
},
options: [
{
name: 'Create',
value: 'create',
},
{
name: 'Delete',
value: 'delete',
},
{
name: 'Get',
value: 'get',
},
{
name: 'Get All',
value: 'getAll',
},
],
default: 'create',
description: 'Operation to perform',
},
] as INodeProperties[];
export const indexFields = [
// ----------------------------------------
// index: create
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index to create',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'create',
],
},
},
options: [
{
displayName: 'Aliases',
name: 'aliases',
description: 'Index aliases which include the index, as an <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html">alias object</a>',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
placeholder: placeholders.aliases,
},
{
displayName: 'Include Type Name',
name: 'include_type_name',
description: 'If true, a mapping type is expected in the body of mappings. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Mappings',
name: 'mappings',
description: 'Mapping for fields in the index, as <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping.html">mapping object</a>',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
placeholder: placeholders.mappings,
},
{
displayName: 'Master Timeout',
name: 'master_timeout',
description: 'Period to wait for a connection to the master node. If no response is received before the timeout expires,<br>the request fails and returns an error. Defaults to <code>1m</code>. See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#time-units">Elasticsearch time units reference</a>',
type: 'string',
default: '1m',
},
{
displayName: 'Settings',
name: 'settings',
description: 'Configuration options for the index, as an <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules.html#index-modules-settings">index settings object</a>',
type: 'json',
typeOptions: {
alwaysOpenEditWindow: true,
},
default: '',
placeholder: placeholders.indexSettings,
},
{
displayName: 'Timeout',
name: 'timeout',
description: 'Period to wait for a response. If no response is received before the timeout expires, the request<br>fails and returns an error. Defaults to <code>30s</code>. See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#time-units">Elasticsearch time units reference</a>',
type: 'string',
default: '30s',
},
{
displayName: 'Wait for Active Shards',
name: 'wait_for_active_shards',
description: 'The number of shard copies that must be active before proceeding with the operation. Set to <code>all</code><br>or any positive integer up to the total number of shards in the index. Default: 1, the primary shard',
type: 'string',
default: '1',
},
],
},
// ----------------------------------------
// index: delete
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index to delete',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'delete',
],
},
},
},
// ----------------------------------------
// index: get
// ----------------------------------------
{
displayName: 'Index ID',
name: 'indexId',
description: 'ID of the index to retrieve',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'get',
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'get',
],
},
},
options: [
{
displayName: 'Allow No Indices',
name: 'allow_no_indices',
description: 'If false, return an error if any of the following targets only missing/closed indices: wildcard expression, index alias, or <code>_all</code> value. Defaults to true',
type: 'boolean',
default: true,
},
{
displayName: 'Expand Wildcards',
name: 'expand_wildcards',
description: 'Type of index that wildcard expressions can match. Defaults to <code>open</code>',
type: 'options',
options: [
{
name: 'All',
value: 'all',
},
{
name: 'Closed',
value: 'closed',
},
{
name: 'Hidden',
value: 'hidden',
},
{
name: 'None',
value: 'none',
},
{
name: 'Open',
value: 'open',
},
],
default: 'all',
},
{
displayName: 'Flat Settings',
name: 'flat_settings',
description: 'If true, return settings in flat format. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Ignore Unavailable',
name: 'ignore_unavailable',
description: 'If false, requests that target a missing index return an error. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Include Defaults',
name: 'include_defaults',
description: 'If true, return all default settings in the response. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Local',
name: 'local',
description: 'If true, retrieve information from the local node only. Defaults to false',
type: 'boolean',
default: false,
},
{
displayName: 'Master Timeout',
name: 'master_timeout',
description: 'Period to wait for a connection to the master node. If no response is received before the timeout expires,<br>the request fails and returns an error. Defaults to <code>1m</code>. See the <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#time-units">Elasticsearch time units reference</a>',
type: 'string',
default: '1m',
},
],
},
// ----------------------------------------
// index: getAll
// ----------------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Whether to return all results or only up to a given limit',
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 50,
description: 'How many results to return',
typeOptions: {
minValue: 1,
},
displayOptions: {
show: {
resource: [
'index',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
] as INodeProperties[];

View File

@@ -0,0 +1,2 @@
export * from './DocumentDescription';
export * from './IndexDescription';

View File

@@ -0,0 +1,43 @@
export const indexSettings = `{
"settings": {
"index": {
"number_of_shards": 3,
"number_of_replicas": 2
}
}
}`;
export const mappings = `{
"mappings": {
"properties": {
"field1": { "type": "text" }
}
}
}`;
export const aliases = `{
"aliases": {
"alias_1": {},
"alias_2": {
"filter": {
"term": { "user.id": "kimchy" }
},
"routing": "shard-1"
}
}
}`;
export const query = `{
"query": {
"term": {
"user.id": "john"
}
}
}`;
export const document = `{
"timestamp": "2099-05-06T16:21:15.000Z",
"event": {
"original": "192.0.2.42 - - [06/May/2099:16:21:15 +0000] \"GET /images/bg.jpg HTTP/1.0\" 200 24736"
}
}`;

View File

@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<svg width="64px" height="64px" viewBox="6 5 54 54" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<!-- Generator: Sketch 63.1 (92452) - https://sketch.com -->
<title>elastic-search-logo-color-64px</title>
<desc>Created with Sketch.</desc>
<g id="elastic-search-logo-color-64px" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
<rect id="bounding-box" x="0" y="0" width="64" height="64"></rect>
<g id="group" transform="translate(8.000000, 4.999500)">
<path d="M47.7246,9.708 L47.7276,9.702 C42.7746,3.774 35.3286,0 26.9996,0 C16.4006,0 7.2326,6.112 2.8136,15 L38.0056,15 C40.5306,15 42.9886,14.13 44.9206,12.504 C45.9246,11.659 46.8636,10.739 47.7246,9.708" id="Fill-1" fill="#FEC514"></path>
<path d="M0,27.0005 C0,29.4225 0.324,31.7675 0.922,34.0005 L34,34.0005 C37.866,34.0005 41,30.8665 41,27.0005 C41,23.1345 37.866,20.0005 34,20.0005 L0.922,20.0005 C0.324,22.2335 0,24.5785 0,27.0005" id="Fill-4" fill="#343741"></path>
<path d="M47.7246,44.293 L47.7276,44.299 C42.7746,50.227 35.3286,54.001 26.9996,54.001 C16.4006,54.001 7.2326,47.889 2.8136,39.001 L38.0056,39.001 C40.5306,39.001 42.9886,39.871 44.9206,41.497 C45.9246,42.342 46.8636,43.262 47.7246,44.293" id="Fill-6" fill="#00BFB3"></path>
</g>
</g>
</svg>

After

Width:  |  Height:  |  Size: 1.4 KiB

View File

@@ -0,0 +1,40 @@
export type ElasticsearchApiCredentials = {
username: string;
password: string;
baseUrl: string;
};
export type DocumentGetAllOptions = Partial<{
allow_no_indices: boolean;
allow_partial_search_results: boolean;
batched_reduce_size: number;
ccs_minimize_roundtrips: boolean;
docvalue_fields: string;
expand_wildcards: 'All' | 'Closed' | 'Hidden' | 'None' | 'Open';
explain: boolean;
ignore_throttled: boolean;
ignore_unavailable: boolean;
max_concurrent_shard_requests: number;
pre_filter_shard_size: number;
query: string;
request_cache: boolean;
routing: string;
search_type: 'query_then_fetch' | 'dfs_query_then_fetch';
seq_no_primary_term: boolean;
sort: string;
_source: boolean;
_source_excludes: string;
_source_includes: string;
stats: string;
stored_fields: boolean;
terminate_after: boolean;
timeout: number;
track_scores: boolean;
track_total_hits: string;
version: boolean;
}>;
export type FieldsUiValues = Array<{
fieldId: string;
fieldValue: string;
}>;