[CCR] Add Delete auto follow pattern api endpoint

.eslintrc.js

@@ -341,6 +341,7 @@ module.exports = {
         'jsx-a11y/click-events-have-key-events': 'off',
         'jsx-a11y/anchor-has-content': 'off',
         'jsx-a11y/tabindex-no-positive': 'off',
+        'jsx-a11y/label-has-associated-control': 'off',
         'jsx-a11y/aria-role': 'off',
       },
     },

.i18nrc.json

@@ -29,12 +29,15 @@
     "xpack.rollupJobs": "x-pack/plugins/rollup",
     "xpack.searchProfiler": "x-pack/plugins/searchprofiler",
     "xpack.security": "x-pack/plugins/security",
+    "xpack.spaces": "x-pack/plugins/spaces",
     "xpack.watcher": "x-pack/plugins/watcher"
   },
   "exclude": [
     "src/ui/ui_render/bootstrap/app_bootstrap.js",
     "src/ui/ui_render/ui_render_mixin.js",
+    "x-pack/plugins/infra/public/graphql/types.ts",
     "x-pack/plugins/infra/public/utils/loading_state/loading_result.ts",
+    "x-pack/plugins/infra/server/graphql/types.ts",
     "x-pack/plugins/infra/server/lib/domains/log_entries_domain/log_entries_domain.ts"
   ]
 }

package.json

@@ -144,6 +144,7 @@
     "getos": "^3.1.0",
     "glob": "^7.1.2",
     "glob-all": "^3.1.0",
+    "globby": "^8.0.1",
     "good-squeeze": "2.1.0",
     "h2o2": "^8.1.2",
     "handlebars": "4.0.5",
@@ -205,7 +206,7 @@
     "regression": "2.0.0",
     "request": "^2.88.0",
     "reselect": "^3.0.1",
-    "resize-observer-polyfill": "1.2.1",
+    "resize-observer-polyfill": "^1.5.0",
     "rimraf": "2.4.3",
     "rison-node": "1.0.0",
     "rxjs": "^6.2.1",
@@ -216,7 +217,7 @@
     "style-loader": "0.23.1",
     "tar": "2.2.0",
     "tinygradient": "0.3.0",
-    "tinymath": "1.1.0",
+    "tinymath": "1.1.1",
     "topojson-client": "3.0.0",
     "trunc-html": "1.0.2",
     "trunc-text": "1.0.2",
@@ -337,7 +338,6 @@
     "fetch-mock": "^5.13.1",
     "geckodriver": "1.12.2",
     "getopts": "2.0.0",
-    "globby": "^8.0.1",
     "grunt": "1.0.1",
     "grunt-cli": "^1.2.0",
     "grunt-contrib-watch": "^1.1.0",

packages/elastic-datemath/src/index.d.ts

@@ -32,11 +32,16 @@ declare const datemath: {
   unitsAsc: Unit[];
   unitsDesc: Unit[];
 
+  /**
+   * Parses a string into a moment object. The string can be something like "now - 15m".
+   * @param options.forceNow If this optional parameter is supplied, "now" will be treated as this
+   * date, rather than the real "now".
+   */
   parse(
     input: string,
     options?: {
       roundUp?: boolean;
-      forceNow?: boolean;
+      forceNow?: Date;
       momentInstance?: typeof moment;
     }
   ): moment.Moment | undefined;

packages/eslint-config-kibana/.eslintrc.js

@@ -150,6 +150,7 @@ module.exports = {
     'jsx-a11y/role-supports-aria-props': 'error',
     'jsx-a11y/scope': 'error',
     'jsx-a11y/tabindex-no-positive': 'error',
+    'jsx-a11y/label-has-associated-control': 'error',  
     'react/jsx-equals-spacing': ['error', 'never'],
     'react/jsx-indent': ['error', 2],
     'react/no-will-update-set-state': 'error',

packages/kbn-config-schema/src/index.ts

@@ -40,6 +40,8 @@ import {
   NumberType,
   ObjectType,
   Props,
+  RecordOfOptions,
+  RecordOfType,
   StringOptions,
   StringType,
   Type,
@@ -105,6 +107,14 @@ function mapOf<K, V>(
   return new MapOfType(keyType, valueType, options);
 }
 
+function recordOf<K extends string, V>(
+  keyType: Type<K>,
+  valueType: Type<V>,
+  options?: RecordOfOptions<K, V>
+): Type<Record<K, V>> {
+  return new RecordOfType(keyType, valueType, options);
+}
+
 function oneOf<A, B, C, D, E, F, G, H, I, J>(
   types: [Type<A>, Type<B>, Type<C>, Type<D>, Type<E>, Type<F>, Type<G>, Type<H>, Type<I>, Type<J>],
   options?: TypeOptions<A | B | C | D | E | F | G | H | I | J>
@@ -175,6 +185,7 @@ export const schema = {
   number,
   object,
   oneOf,
+  recordOf,
   siblingRef,
   string,
 };

packages/kbn-config-schema/src/internals/index.ts

@@ -274,6 +274,54 @@ export const internals = Joi.extend([
       },
     ],
   },
+  {
+    name: 'record',
+    pre(value: any, state: State, options: ValidationOptions) {
+      if (!isPlainObject(value)) {
+        return this.createError('record.base', { value }, state, options);
+      }
+
+      return value as any;
+    },
+    rules: [
+      anyCustomRule,
+      {
+        name: 'entries',
+        params: { key: Joi.object().schema(), value: Joi.object().schema() },
+        validate(params, value, state, options) {
+          const result = {} as Record<string, any>;
+          for (const [entryKey, entryValue] of Object.entries(value)) {
+            const { value: validatedEntryKey, error: keyError } = Joi.validate(
+              entryKey,
+              params.key
+            );
+
+            if (keyError) {
+              return this.createError('record.key', { entryKey, reason: keyError }, state, options);
+            }
+
+            const { value: validatedEntryValue, error: valueError } = Joi.validate(
+              entryValue,
+              params.value
+            );
+
+            if (valueError) {
+              return this.createError(
+                'record.value',
+                { entryKey, reason: valueError },
+                state,
+                options
+              );
+            }
+
+            result[validatedEntryKey] = validatedEntryValue;
+          }
+
+          return result as any;
+        },
+      },
+    ],
+  },
   {
     name: 'array',
 

packages/kbn-config-schema/src/types/__snapshots__/map_of_type.test.ts.snap

@@ -1,10 +1,10 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`fails when not receiving expected key type 1`] = `"[name]: expected value of type [number] but got [string]"`;
+exports[`fails when not receiving expected key type 1`] = `"[key(\\"name\\")]: expected value of type [number] but got [string]"`;
 
 exports[`fails when not receiving expected value type 1`] = `"[name]: expected value of type [string] but got [number]"`;
 
-exports[`includes namespace in failure when wrong key type 1`] = `"[foo-namespace.name]: expected value of type [number] but got [string]"`;
+exports[`includes namespace in failure when wrong key type 1`] = `"[foo-namespace.key(\\"name\\")]: expected value of type [number] but got [string]"`;
 
 exports[`includes namespace in failure when wrong top-level type 1`] = `"[foo-namespace]: expected value of type [Map] or [object] but got [Array]"`;
 

packages/kbn-config-schema/src/types/index.ts

@@ -29,5 +29,6 @@ export { MaybeType } from './maybe_type';
 export { MapOfOptions, MapOfType } from './map_type';
 export { NumberOptions, NumberType } from './number_type';
 export { ObjectType, Props, TypeOf } from './object_type';
+export { RecordOfOptions, RecordOfType } from './record_type';
 export { StringOptions, StringType } from './string_type';
 export { UnionType } from './union_type';

packages/kbn-config-schema/src/types/literal_type.ts

@@ -22,16 +22,14 @@ import { Type } from './type';
 
 export class LiteralType<T> extends Type<T> {
   constructor(value: T) {
-    super(internals.any(), {
-      // Before v13.3.0 Joi.any().value() didn't provide raw value if validation
-      // fails, so to display this value in error message we should provide
-      // custom validation function. Once we upgrade Joi, we'll be able to use
-      // `value()` with custom `any.allowOnly` error handler instead.
-      validate(valueToValidate) {
-        if (valueToValidate !== value) {
-          return `expected value to equal [${value}] but got [${valueToValidate}]`;
-        }
-      },
-    });
+    super(internals.any().valid(value));
+  }
+
+  protected handleError(type: string, { value, valids: [expectedValue] }: Record<string, any>) {
+    switch (type) {
+      case 'any.required':
+      case 'any.allowOnly':
+        return `expected value to equal [${expectedValue}] but got [${value}]`;
+    }
   }
 }

packages/kbn-config-schema/src/types/map_type.ts

@@ -18,7 +18,7 @@
  */
 
 import typeDetect from 'type-detect';
-import { SchemaTypeError } from '../errors';
+import { SchemaTypeError, SchemaTypesError } from '../errors';
 import { internals } from '../internals';
 import { Type, TypeOptions } from './type';
 
@@ -51,9 +51,16 @@ export class MapOfType<K, V> extends Type<Map<K, V>> {
       case 'map.key':
       case 'map.value':
         const childPathWithIndex = reason.path.slice();
-        childPathWithIndex.splice(path.length, 0, entryKey.toString());
+        childPathWithIndex.splice(
+          path.length,
+          0,
+          // If `key` validation failed, let's stress that to make error more obvious.
+          type === 'map.key' ? `key("${entryKey}")` : entryKey.toString()
+        );
 
-        return new SchemaTypeError(reason.message, childPathWithIndex);
+        return reason instanceof SchemaTypesError
+          ? new SchemaTypesError(reason, childPathWithIndex, reason.errors)
+          : new SchemaTypeError(reason, childPathWithIndex);
     }
   }
 }

packages/kbn-config-schema/src/types/record_of_type.test.ts

@@ -0,0 +1,122 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { schema } from '..';
+
+test('handles object as input', () => {
+  const type = schema.recordOf(schema.string(), schema.string());
+  const value = {
+    name: 'foo',
+  };
+  expect(type.validate(value)).toEqual({ name: 'foo' });
+});
+
+test('fails when not receiving expected value type', () => {
+  const type = schema.recordOf(schema.string(), schema.string());
+  const value = {
+    name: 123,
+  };
+
+  expect(() => type.validate(value)).toThrowErrorMatchingInlineSnapshot(
+    `"[name]: expected value of type [string] but got [number]"`
+  );
+});
+
+test('fails when not receiving expected key type', () => {
+  const type = schema.recordOf(
+    schema.oneOf([schema.literal('nickName'), schema.literal('lastName')]),
+    schema.string()
+  );
+
+  const value = {
+    name: 'foo',
+  };
+
+  expect(() => type.validate(value)).toThrowErrorMatchingInlineSnapshot(`
+"[key(\\"name\\")]: types that failed validation:
+- [0]: expected value to equal [nickName] but got [name]
+- [1]: expected value to equal [lastName] but got [name]"
+`);
+});
+
+test('includes namespace in failure when wrong top-level type', () => {
+  const type = schema.recordOf(schema.string(), schema.string());
+  expect(() => type.validate([], {}, 'foo-namespace')).toThrowErrorMatchingInlineSnapshot(
+    `"[foo-namespace]: expected value of type [object] but got [Array]"`
+  );
+});
+
+test('includes namespace in failure when wrong value type', () => {
+  const type = schema.recordOf(schema.string(), schema.string());
+  const value = {
+    name: 123,
+  };
+
+  expect(() => type.validate(value, {}, 'foo-namespace')).toThrowErrorMatchingInlineSnapshot(
+    `"[foo-namespace.name]: expected value of type [string] but got [number]"`
+  );
+});
+
+test('includes namespace in failure when wrong key type', () => {
+  const type = schema.recordOf(schema.string({ minLength: 10 }), schema.string());
+  const value = {
+    name: 'foo',
+  };
+
+  expect(() => type.validate(value, {}, 'foo-namespace')).toThrowErrorMatchingInlineSnapshot(
+    `"[foo-namespace.key(\\"name\\")]: value is [name] but it must have a minimum length of [10]."`
+  );
+});
+
+test('returns default value if undefined', () => {
+  const obj = { foo: 'bar' };
+
+  const type = schema.recordOf(schema.string(), schema.string(), {
+    defaultValue: obj,
+  });
+
+  expect(type.validate(undefined)).toEqual(obj);
+});
+
+test('recordOf within recordOf', () => {
+  const type = schema.recordOf(schema.string(), schema.recordOf(schema.string(), schema.number()));
+  const value = {
+    foo: {
+      bar: 123,
+    },
+  };
+
+  expect(type.validate(value)).toEqual({ foo: { bar: 123 } });
+});
+
+test('object within recordOf', () => {
+  const type = schema.recordOf(
+    schema.string(),
+    schema.object({
+      bar: schema.number(),
+    })
+  );
+  const value = {
+    foo: {
+      bar: 123,
+    },
+  };
+
+  expect(type.validate(value)).toEqual({ foo: { bar: 123 } });
+});