Adds a builtin action for triggering webhooks

x-pack/legacy/plugins/actions/server/builtin_action_types/email.ts

@@ -10,19 +10,17 @@ import nodemailerServices from 'nodemailer/lib/well-known/services.json';
 
 import { sendEmail, JSON_TRANSPORT_SERVICE } from './lib/send_email';
 import { nullableType } from './lib/nullable';
+import { portSchema } from './lib/schemas';
 import { ActionType, ActionTypeExecutorOptions, ActionTypeExecutorResult } from '../types';
 
-const PORT_MAX = 256 * 256 - 1;
-
 // config definition
-
 export type ActionTypeConfigType = TypeOf<typeof ConfigSchema>;
 
 const ConfigSchema = schema.object(
   {
     service: nullableType(schema.string()),
     host: nullableType(schema.string()),
-    port: nullableType(schema.number({ min: 1, max: PORT_MAX })),
+    port: nullableType(portSchema()),
     secure: nullableType(schema.boolean()),
     from: schema.string(),
   },

x-pack/legacy/plugins/actions/server/builtin_action_types/index.ts

@@ -8,12 +8,14 @@ import { ActionTypeRegistry } from '../action_type_registry';
 
 import { actionType as serverLogActionType } from './server_log';
 import { actionType as slackActionType } from './slack';
+import { actionType as webhookActionType } from './webhook';
 import { actionType as emailActionType } from './email';
 import { actionType as indexActionType } from './es_index';
 
 export function registerBuiltInActionTypes(actionTypeRegistry: ActionTypeRegistry) {
   actionTypeRegistry.register(serverLogActionType);
   actionTypeRegistry.register(slackActionType);
+  actionTypeRegistry.register(webhookActionType);
   actionTypeRegistry.register(emailActionType);
   actionTypeRegistry.register(indexActionType);
 }

x-pack/legacy/plugins/actions/server/builtin_action_types/lib/result_type.ts

@@ -0,0 +1,53 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+// There appears to be an unexported implementation of Either in here: src/core/server/saved_objects/service/lib/repository.ts
+// Which is basically the Haskel equivalent of Rust/ML/Scala's Result
+// I'll reach out to other's in Kibana to see if we can merge these into one type
+
+// eslint-disable-next-line @typescript-eslint/prefer-interface
+export type Ok<T> = {
+  tag: 'ok';
+  value: T;
+};
+// eslint-disable-next-line @typescript-eslint/prefer-interface
+export type Err<E> = {
+  tag: 'err';
+  error: E;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+
+function asOk<T>(value: T): Ok<T> {
+  return {
+    tag: 'ok',
+    value,
+  };
+}
+
+function asErr<T>(error: T): Err<T> {
+  return {
+    tag: 'err',
+    error,
+  };
+}
+
+function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
+  return result.tag === 'ok';
+}
+
+function isErr<T, E>(result: Result<T, E>): result is Err<E> {
+  return !isOk(result);
+}
+
+async function promiseResult<T, E>(future: Promise<T>): Promise<Result<T, E>> {
+  try {
+    return asOk(await future);
+  } catch (e) {
+    return asErr(e);
+  }
+}
+
+export { isOk, asOk, isErr, asErr, promiseResult };

x-pack/legacy/plugins/actions/server/builtin_action_types/lib/schemas.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { schema } from '@kbn/config-schema';
+
+const PORT_MAX = 256 * 256 - 1;
+export const portSchema = () => schema.number({ min: 1, max: PORT_MAX });

x-pack/legacy/plugins/actions/server/builtin_action_types/webhook.test.ts

@@ -0,0 +1,209 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { actionType } from './webhook';
+import { validateConfig, validateSecrets, validateParams } from '../lib';
+
+describe('actionType', () => {
+  test('exposes the action as `webhook` on its Id and Name', () => {
+    expect(actionType.id).toEqual('.webhook');
+    expect(actionType.name).toEqual('webhook');
+  });
+});
+
+describe('secrets validation', () => {
+  test('succeeds when secrets is valid', () => {
+    const secrets: Record<string, any> = {
+      user: 'bob',
+      password: 'supersecret',
+    };
+    expect(validateSecrets(actionType, secrets)).toEqual(secrets);
+  });
+
+  test('fails when secret password is omitted', () => {
+    expect(() => {
+      validateSecrets(actionType, { user: 'bob' });
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"error validating action type secrets: [password]: expected value of type [string] but got [undefined]"`
+    );
+  });
+
+  test('fails when secret user is omitted', () => {
+    expect(() => {
+      validateSecrets(actionType, {});
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"error validating action type secrets: [user]: expected value of type [string] but got [undefined]"`
+    );
+  });
+});
+
+describe('config validation', () => {
+  const defaultValues: Record<string, any> = {
+    headers: null,
+    method: 'post',
+  };
+
+  const defaultCompositeUrlValues: Record<string, any> = {
+    scheme: 'http',
+    path: null,
+  };
+
+  test('config validation passes when only required fields are provided', () => {
+    const config: Record<string, any> = {
+      url: {
+        host: 'mylisteningserver',
+        port: 9200,
+      },
+    };
+    expect(validateConfig(actionType, config)).toEqual({
+      ...defaultValues,
+      url: {
+        ...defaultCompositeUrlValues,
+        ...config.url,
+      },
+    });
+  });
+
+  test('config validation passes when valid schemes are provided', () => {
+    const httpConfig: Record<string, any> = {
+      url: {
+        host: 'mylisteningserver',
+        port: 9200,
+        scheme: 'http',
+      },
+    };
+    expect(validateConfig(actionType, httpConfig)).toEqual({
+      ...defaultValues,
+      ...httpConfig,
+      url: {
+        ...defaultCompositeUrlValues,
+        ...httpConfig.url,
+      },
+    });
+
+    const httpsConfig: Record<string, any> = {
+      url: {
+        host: 'mylisteningserver',
+        port: 9200,
+        scheme: 'https',
+      },
+    };
+    expect(validateConfig(actionType, httpsConfig)).toEqual({
+      ...defaultValues,
+      url: {
+        ...defaultCompositeUrlValues,
+        ...httpsConfig.url,
+      },
+    });
+  });
+
+  test('should validate and throw error when scheme on config is invalid', () => {
+    const config: Record<string, any> = {
+      url: {
+        host: 'mylisteningserver',
+        port: 9200,
+        scheme: 'ftp',
+      },
+    };
+    expect(() => {
+      validateConfig(actionType, config);
+    }).toThrowErrorMatchingInlineSnapshot(`
+"error validating action type config: [url]: types that failed validation:
+- [url.0]: expected value of type [string] but got [Object]
+- [url.1.scheme]: types that failed validation:"
+`);
+  });
+
+  test('config validation passes when valid methods are provided', () => {
+    ['post', 'put'].forEach(method => {
+      const config: Record<string, any> = {
+        url: {
+          host: 'mylisteningserver',
+          port: 9200,
+        },
+        method,
+      };
+      expect(validateConfig(actionType, config)).toEqual({
+        ...defaultValues,
+        ...config,
+        url: {
+          ...defaultCompositeUrlValues,
+          ...config.url,
+        },
+      });
+    });
+  });
+
+  test('should validate and throw error when method on config is invalid', () => {
+    const config: Record<string, any> = {
+      url: {
+        host: 'mylisteningserver',
+        port: 9200,
+      },
+      method: 'https',
+    };
+    expect(() => {
+      validateConfig(actionType, config);
+    }).toThrowErrorMatchingInlineSnapshot(`
+"error validating action type config: [method]: types that failed validation:
+- [method.0]: expected value to equal [post] but got [https]
+- [method.1]: expected value to equal [put] but got [https]"
+`);
+  });
+
+  test('config validation passes when a url is specified', () => {
+    const config: Record<string, any> = {
+      url: 'http://mylisteningserver:9200/endpoint',
+    };
+    expect(validateConfig(actionType, config)).toEqual({
+      ...defaultValues,
+      ...config,
+    });
+  });
+
+  test('config validation passes when valid headers are provided', () => {
+    const config: Record<string, any> = {
+      url: 'http://mylisteningserver:9200/endpoint',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    };
+    expect(validateConfig(actionType, config)).toEqual({
+      ...defaultValues,
+      ...config,
+    });
+  });
+
+  test('should validate and throw error when headers on config is invalid', () => {
+    const config: Record<string, any> = {
+      url: 'http://mylisteningserver:9200/endpoint',
+      headers: 'application/json',
+    };
+    expect(() => {
+      validateConfig(actionType, config);
+    }).toThrowErrorMatchingInlineSnapshot(`
+"error validating action type config: [headers]: types that failed validation:
+- [headers.0]: expected value of type [object] but got [string]
+- [headers.1]: expected value to equal [null] but got [application/json]"
+`);
+  });
+});
+
+describe('params validation', () => {
+  test('param validation passes when no fields are provided as none are required', () => {
+    const params: Record<string, any> = {};
+    expect(validateParams(actionType, params)).toEqual({});
+  });
+
+  test('params validation passes when a valid body is provided', () => {
+    const params: Record<string, any> = {
+      body: 'count: {{ctx.payload.hits.total}}',
+    };
+    expect(validateParams(actionType, params)).toEqual({
+      ...params,
+    });
+  });
+});