Merge branch 'master' into stabilize-rollup-test

Author: elasticmachine

src/plugins/expressions/common/execution/execution.test.ts

@@ -336,16 +336,18 @@ describe('Execution', () => {
     });
 
     test('execution state is "pending" while execution is in progress', async () => {
+      jest.useFakeTimers();
       const execution = createExecution('sleep 20');
       execution.start(null);
-      await new Promise(r => setTimeout(r, 5));
+      jest.advanceTimersByTime(5);
       expect(execution.state.get().state).toBe('pending');
+      jest.useRealTimers();
     });
 
     test('execution state is "result" when execution successfully completes', async () => {
       const execution = createExecution('sleep 1');
       execution.start(null);
-      await new Promise(r => setTimeout(r, 30));
+      await execution.result;
       expect(execution.state.get().state).toBe('result');
     });
 

src/plugins/expressions/common/service/expressions_services.ts

@@ -22,8 +22,41 @@ import { ExpressionRendererRegistry } from '../expression_renderers';
 import { ExpressionAstExpression } from '../ast';
 import { ExecutionContract } from '../execution/execution_contract';
 
-export type ExpressionsServiceSetup = ReturnType<ExpressionsService['setup']>;
-export type ExpressionsServiceStart = ReturnType<ExpressionsService['start']>;
+/**
+ * The public contract that `ExpressionsService` provides to other plugins
+ * in Kibana Platform in *setup* life-cycle.
+ */
+export type ExpressionsServiceSetup = Pick<
+  ExpressionsService,
+  | 'getFunction'
+  | 'getFunctions'
+  | 'getRenderer'
+  | 'getRenderers'
+  | 'getType'
+  | 'getTypes'
+  | 'registerFunction'
+  | 'registerRenderer'
+  | 'registerType'
+  | 'run'
+  | 'fork'
+>;
+
+/**
+ * The public contract that `ExpressionsService` provides to other plugins
+ * in Kibana Platform in *start* life-cycle.
+ */
+export type ExpressionsServiceStart = Pick<
+  ExpressionsService,
+  | 'getFunction'
+  | 'getFunctions'
+  | 'getRenderer'
+  | 'getRenderers'
+  | 'getType'
+  | 'getTypes'
+  | 'run'
+  | 'execute'
+  | 'fork'
+>;
 
 export interface ExpressionServiceParams {
   executor?: Executor;
@@ -97,6 +130,14 @@ export class ExpressionsService {
     ...args: Parameters<Executor['registerFunction']>
   ): ReturnType<Executor['registerFunction']> => this.executor.registerFunction(...args);
 
+  public readonly registerType = (
+    ...args: Parameters<Executor['registerType']>
+  ): ReturnType<Executor['registerType']> => this.executor.registerType(...args);
+
+  public readonly registerRenderer = (
+    ...args: Parameters<ExpressionRendererRegistry['register']>
+  ): ReturnType<ExpressionRendererRegistry['register']> => this.renderers.register(...args);
+
   /**
    * Executes expression string or a parsed expression AST and immediately
    * returns the result.
@@ -132,21 +173,51 @@ export class ExpressionsService {
   ): Promise<Output> => this.executor.run<Input, Output, ExtraContext>(ast, input, context);
 
   /**
-   * Create a new instance of `ExpressionsService`. The new instance inherits
-   * all state of the original `ExpressionsService`, including all expression
-   * types, expression functions and context. Also, all new types and functions
-   * registered in the original services AFTER the forking event will be
-   * available in the forked instance. However, all new types and functions
-   * registered in the forked instances will NOT be available to the original
-   * service.
+   * Get a registered `ExpressionFunction` by its name, which was registered
+   * using the `registerFunction` method. The returned `ExpressionFunction`
+   * instance is an internal representation of the function in Expressions
+   * service - do not mutate that object.
    */
-  public readonly fork = (): ExpressionsService => {
-    const executor = this.executor.fork();
-    const renderers = this.renderers;
-    const fork = new ExpressionsService({ executor, renderers });
+  public readonly getFunction = (name: string): ReturnType<Executor['getFunction']> =>
+    this.executor.getFunction(name);
 
-    return fork;
-  };
+  /**
+   * Returns POJO map of all registered expression functions, where keys are
+   * names of the functions and values are `ExpressionFunction` instances.
+   */
+  public readonly getFunctions = (): ReturnType<Executor['getFunctions']> =>
+    this.executor.getFunctions();
+
+  /**
+   * Get a registered `ExpressionRenderer` by its name, which was registered
+   * using the `registerRenderer` method. The returned `ExpressionRenderer`
+   * instance is an internal representation of the renderer in Expressions
+   * service - do not mutate that object.
+   */
+  public readonly getRenderer = (name: string): ReturnType<ExpressionRendererRegistry['get']> =>
+    this.renderers.get(name);
+
+  /**
+   * Returns POJO map of all registered expression renderers, where keys are
+   * names of the renderers and values are `ExpressionRenderer` instances.
+   */
+  public readonly getRenderers = (): ReturnType<ExpressionRendererRegistry['toJS']> =>
+    this.renderers.toJS();
+
+  /**
+   * Get a registered `ExpressionType` by its name, which was registered
+   * using the `registerType` method. The returned `ExpressionType`
+   * instance is an internal representation of the type in Expressions
+   * service - do not mutate that object.
+   */
+  public readonly getType = (name: string): ReturnType<Executor['getType']> =>
+    this.executor.getType(name);
+
+  /**
+   * Returns POJO map of all registered expression types, where keys are
+   * names of the types and values are `ExpressionType` instances.
+   */
+  public readonly getTypes = (): ReturnType<Executor['getTypes']> => this.executor.getTypes();
 
   /**
    * Starts expression execution and immediately returns `ExecutionContract`
@@ -168,53 +239,37 @@ export class ExpressionsService {
     return execution.contract;
   };
 
-  public setup() {
-    const { executor, renderers, registerFunction, run, fork } = this;
-
-    const getFunction = executor.getFunction.bind(executor);
-    const getFunctions = executor.getFunctions.bind(executor);
-    const getRenderer = renderers.get.bind(renderers);
-    const getRenderers = renderers.toJS.bind(renderers);
-    const getType = executor.getType.bind(executor);
-    const getTypes = executor.getTypes.bind(executor);
-    const registerRenderer = renderers.register.bind(renderers);
-    const registerType = executor.registerType.bind(executor);
-
-    return {
-      fork,
-      getFunction,
-      getFunctions,
-      getRenderer,
-      getRenderers,
-      getType,
-      getTypes,
-      registerFunction,
-      registerRenderer,
-      registerType,
-      run,
-    };
+  /**
+   * Create a new instance of `ExpressionsService`. The new instance inherits
+   * all state of the original `ExpressionsService`, including all expression
+   * types, expression functions and context. Also, all new types and functions
+   * registered in the original services AFTER the forking event will be
+   * available in the forked instance. However, all new types and functions
+   * registered in the forked instances will NOT be available to the original
+   * service.
+   */
+  public readonly fork = (): ExpressionsService => {
+    const executor = this.executor.fork();
+    const renderers = this.renderers;
+    const fork = new ExpressionsService({ executor, renderers });
+
+    return fork;
+  };
+
+  /**
+   * Returns Kibana Platform *setup* life-cycle contract. Useful to return the
+   * same contract on server-side and browser-side.
+   */
+  public setup(): ExpressionsServiceSetup {
+    return this;
   }
 
-  public start() {
-    const { execute, executor, renderers, run } = this;
-
-    const getFunction = executor.getFunction.bind(executor);
-    const getFunctions = executor.getFunctions.bind(executor);
-    const getRenderer = renderers.get.bind(renderers);
-    const getRenderers = renderers.toJS.bind(renderers);
-    const getType = executor.getType.bind(executor);
-    const getTypes = executor.getTypes.bind(executor);
-
-    return {
-      execute,
-      getFunction,
-      getFunctions,
-      getRenderer,
-      getRenderers,
-      getType,
-      getTypes,
-      run,
-    };
+  /**
+   * Returns Kibana Platform *start* life-cycle contract. Useful to return the
+   * same contract on server-side and browser-side.
+   */
+  public start(): ExpressionsServiceStart {
+    return this;
   }
 
   public stop() {}

src/plugins/expressions/public/mocks.tsx

@@ -68,6 +68,7 @@ const createStartContract = (): Start => {
     execute: jest.fn(),
     ExpressionLoader: jest.fn(),
     ExpressionRenderHandler: jest.fn(),
+    fork: jest.fn(),
     getFunction: jest.fn(),
     getFunctions: jest.fn(),
     getRenderer: jest.fn(),

src/plugins/expressions/public/plugin.ts

@@ -177,7 +177,7 @@ export class ExpressionsPublicPlugin
       },
     };
 
-    return setup;
+    return Object.freeze(setup);
   }
 
   public start(core: CoreStart, { inspector, bfetch }: ExpressionsStartDeps): ExpressionsStart {
@@ -186,17 +186,19 @@ export class ExpressionsPublicPlugin
     setNotifications(core.notifications);
 
     const { expressions } = this;
-    const expressionsStart = expressions.start();
-
-    return {
-      ...expressionsStart,
+    const start = {
+      ...expressions.start(),
       ExpressionLoader,
       ExpressionRenderHandler,
       loader,
       ReactExpressionRenderer,
       render,
     };
+
+    return Object.freeze(start);
   }
 
-  public stop() {}
+  public stop() {
+    this.expressions.stop();
+  }
 }

src/plugins/expressions/server/index.ts

@@ -22,6 +22,88 @@ import { ExpressionsServerPlugin } from './plugin';
 
 export { ExpressionsServerSetup, ExpressionsServerStart } from './plugin';
 
+// Kibana Platform.
+export { ExpressionsServerPlugin as Plugin };
+export * from './plugin';
 export function plugin(initializerContext: PluginInitializerContext) {
   return new ExpressionsServerPlugin(initializerContext);
 }
+
+// Static exports.
+export {
+  AnyExpressionFunctionDefinition,
+  AnyExpressionTypeDefinition,
+  ArgumentType,
+  Datatable,
+  DatatableColumn,
+  DatatableColumnType,
+  DatatableRow,
+  Execution,
+  ExecutionContainer,
+  ExecutionContext,
+  ExecutionParams,
+  ExecutionState,
+  Executor,
+  ExecutorContainer,
+  ExecutorState,
+  ExpressionAstArgument,
+  ExpressionAstExpression,
+  ExpressionAstFunction,
+  ExpressionAstNode,
+  ExpressionFunction,
+  ExpressionFunctionDefinition,
+  ExpressionFunctionKibana,
+  ExpressionFunctionParameter,
+  ExpressionImage,
+  ExpressionRenderDefinition,
+  ExpressionRenderer,
+  ExpressionRendererRegistry,
+  ExpressionType,
+  ExpressionTypeDefinition,
+  ExpressionTypeStyle,
+  ExpressionValue,
+  ExpressionValueBoxed,
+  ExpressionValueConverter,
+  ExpressionValueError,
+  ExpressionValueNum,
+  ExpressionValueRender,
+  ExpressionValueSearchContext,
+  ExpressionValueUnboxed,
+  Filter,
+  Font,
+  FontLabel,
+  FontStyle,
+  FontValue,
+  FontWeight,
+  format,
+  formatExpression,
+  FunctionsRegistry,
+  IInterpreterRenderHandlers,
+  InterpreterErrorType,
+  IRegistry,
+  KIBANA_CONTEXT_NAME,
+  KibanaContext,
+  KibanaDatatable,
+  KibanaDatatableColumn,
+  KibanaDatatableRow,
+  KnownTypeToString,
+  Overflow,
+  parse,
+  parseExpression,
+  PointSeries,
+  PointSeriesColumn,
+  PointSeriesColumnName,
+  PointSeriesColumns,
+  PointSeriesRow,
+  Range,
+  SerializedDatatable,
+  SerializedFieldFormat,
+  Style,
+  TextAlignment,
+  TextDecoration,
+  TypesRegistry,
+  TypeString,
+  TypeToString,
+  UnmappedTypeStrings,
+  ExpressionValueRender as Render,
+} from '../common';

src/plugins/expressions/server/mocks.ts

@@ -30,6 +30,17 @@ export type Start = jest.Mocked<ExpressionsServerStart>;
 
 const createSetupContract = (): Setup => {
   const setupContract: Setup = {
+    fork: jest.fn(),
+    getFunction: jest.fn(),
+    getFunctions: jest.fn(),
+    getRenderer: jest.fn(),
+    getRenderers: jest.fn(),
+    getType: jest.fn(),
+    getTypes: jest.fn(),
+    registerFunction: jest.fn(),
+    registerRenderer: jest.fn(),
+    registerType: jest.fn(),
+    run: jest.fn(),
     __LEGACY: {
       register: jest.fn(),
       registries: jest.fn(),
@@ -39,7 +50,17 @@ const createSetupContract = (): Setup => {
 };
 
 const createStartContract = (): Start => {
-  const startContract: Start = {};
+  const startContract: Start = {
+    execute: jest.fn(),
+    fork: jest.fn(),
+    getFunction: jest.fn(),
+    getFunctions: jest.fn(),
+    getRenderer: jest.fn(),
+    getRenderers: jest.fn(),
+    getType: jest.fn(),
+    getTypes: jest.fn(),
+    run: jest.fn(),
+  };
 
   return startContract;
 };