Expression executor service

packages/kbn-interpreter/src/common/index.d.ts

@@ -18,3 +18,5 @@
  */
 
 export { Registry } from './lib/registry';
+
+export { fromExpression, Ast } from './lib/ast';

packages/kbn-interpreter/src/common/lib/ast.d.ts

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+export type Ast = unknown;
+
+export declare function fromExpression(expression: string): Ast;

src/legacy/core_plugins/data/public/expression_executor/expression_executor_service.test.tsx

@@ -0,0 +1,180 @@
+/*
+ * 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 { fromExpression, Ast } from '@kbn/interpreter/common';
+
+import {
+  ExpressionExecutorService,
+  RenderFunctionsRegistry,
+  RenderFunction,
+  Interpreter,
+  ExpressionExecutorSetupPlugins,
+  Result,
+  ExpressionExecutorSetup,
+} from './expression_executor_service';
+import { mount } from 'enzyme';
+import React from 'react';
+
+const waitForInterpreterRun = async () => {
+  // Wait for two ticks with empty callback queues
+  // This makes sure the runFn promise and actual interpretAst
+  // promise have been resolved and processed
+  await new Promise(resolve => setTimeout(resolve));
+  await new Promise(resolve => setTimeout(resolve));
+};
+
+describe('expression_executor_service', () => {
+  let interpreterMock: jest.Mocked<Interpreter>;
+  let renderFunctionMock: jest.Mocked<RenderFunction>;
+  let setupPluginsMock: ExpressionExecutorSetupPlugins;
+  const expressionResult: Result = { type: 'render', as: 'abc', value: {} };
+
+  let api: ExpressionExecutorSetup;
+  let testExpression: string;
+  let testAst: Ast;
+
+  beforeEach(() => {
+    interpreterMock = { interpretAst: jest.fn(_ => Promise.resolve(expressionResult)) };
+    renderFunctionMock = ({
+      render: jest.fn(),
+    } as unknown) as jest.Mocked<RenderFunction>;
+    setupPluginsMock = {
+      interpreter: {
+        getInterpreter: () => Promise.resolve({ interpreter: interpreterMock }),
+        renderersRegistry: ({
+          get: () => renderFunctionMock,
+        } as unknown) as RenderFunctionsRegistry,
+      },
+    };
+    api = new ExpressionExecutorService().setup(null, setupPluginsMock);
+    testExpression = 'test | expression';
+    testAst = fromExpression(testExpression);
+  });
+
+  it('should return run function', () => {
+    expect(typeof api.run).toBe('function');
+  });
+
+  it('should call the interpreter with parsed expression', async () => {
+    await api.run(testExpression, document.createElement('div'));
+    expect(interpreterMock.interpretAst).toHaveBeenCalledWith(
+      testAst,
+      expect.anything(),
+      expect.anything()
+    );
+  });
+
+  it('should call the interpreter with passed in ast', async () => {
+    await api.run(testAst, document.createElement('div'));
+    expect(interpreterMock.interpretAst).toHaveBeenCalledWith(
+      testAst,
+      expect.anything(),
+      expect.anything()
+    );
+  });
+
+  it('should call the render function with the result and element', async () => {
+    const element = document.createElement('div');
+
+    await api.run(testAst, element);
+    expect(renderFunctionMock.render).toHaveBeenCalledWith(
+      element,
+      expressionResult.value,
+      expect.anything()
+    );
+    expect(interpreterMock.interpretAst).toHaveBeenCalledWith(
+      testAst,
+      expect.anything(),
+      expect.anything()
+    );
+  });
+
+  it('should call interpreter and render function when called through react component', async () => {
+    const ExpressionRenderer = api.ExpressionRenderer;
+
+    mount(<ExpressionRenderer expression={testExpression} />);
+
+    await waitForInterpreterRun();
+
+    expect(renderFunctionMock.render).toHaveBeenCalledWith(
+      expect.any(Element),
+      expressionResult.value,
+      expect.anything()
+    );
+    expect(interpreterMock.interpretAst).toHaveBeenCalledWith(
+      testAst,
+      expect.anything(),
+      expect.anything()
+    );
+  });
+
+  it('should call interpreter and render function again if expression changes', async () => {
+    const ExpressionRenderer = api.ExpressionRenderer;
+
+    const instance = mount(<ExpressionRenderer expression={testExpression} />);
+
+    await waitForInterpreterRun();
+
+    expect(renderFunctionMock.render).toHaveBeenCalledWith(
+      expect.any(Element),
+      expressionResult.value,
+      expect.anything()
+    );
+    expect(interpreterMock.interpretAst).toHaveBeenCalledWith(
+      testAst,
+      expect.anything(),
+      expect.anything()
+    );
+
+    instance.setProps({ expression: 'supertest | expression ' });
+
+    await waitForInterpreterRun();
+
+    expect(renderFunctionMock.render).toHaveBeenCalledTimes(2);
+    expect(interpreterMock.interpretAst).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not call interpreter and render function again if expression does not change', async () => {
+    const ast = fromExpression(testExpression);
+
+    const ExpressionRenderer = api.ExpressionRenderer;
+
+    const instance = mount(<ExpressionRenderer expression={testExpression} />);
+
+    await waitForInterpreterRun();
+
+    expect(renderFunctionMock.render).toHaveBeenCalledWith(
+      expect.any(Element),
+      expressionResult.value,
+      expect.anything()
+    );
+    expect(interpreterMock.interpretAst).toHaveBeenCalledWith(
+      ast,
+      expect.anything(),
+      expect.anything()
+    );
+
+    instance.update();
+
+    await waitForInterpreterRun();
+
+    expect(renderFunctionMock.render).toHaveBeenCalledTimes(1);
+    expect(interpreterMock.interpretAst).toHaveBeenCalledTimes(1);
+  });
+});

src/legacy/core_plugins/data/public/expression_executor/expression_executor_service.tsx

@@ -0,0 +1,177 @@
+/*
+ * 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 { CoreSetup } from 'kibana/public';
+import { useRef, useEffect } from 'react';
+import React from 'react';
+
+import { fromExpression, Ast } from '@kbn/interpreter/common';
+
+// this type import and the types below them should be switched to the types of
+// the interpreter plugin itself once they are ready
+import { RunPipelineHandlers } from 'ui/visualize/loader/pipeline_helpers/run_pipeline';
+import { Registry } from '@kbn/interpreter/common';
+import { RequestAdapter, DataAdapter } from 'ui/inspector/adapters';
+
+type Context = object;
+type Handlers = RunPipelineHandlers;
+export interface Result {
+  type: string;
+  as?: string;
+  value?: unknown;
+}
+
+interface RenderHandlers {
+  done: () => void;
+  onDestroy: (fn: () => void) => void;
+}
+
+export interface RenderFunction {
+  name: string;
+  displayName: string;
+  help: string;
+  validate: () => void;
+  reuseDomNode: boolean;
+  render: (domNode: Element, data: unknown, handlers: RenderHandlers) => void;
+}
+
+export type RenderFunctionsRegistry = Registry<unknown, RenderFunction>;
+
+export interface Interpreter {
+  interpretAst(ast: Ast, context: Context, handlers: Handlers): Promise<Result>;
+}
+
+export interface ExpressionExecutorSetupPlugins {
+  interpreter: {
+    renderersRegistry: RenderFunctionsRegistry;
+    getInterpreter: () => Promise<{ interpreter: Interpreter }>;
+  };
+}
+
+async function runFn(
+  expressionOrAst: string | Ast,
+  element: Element,
+  renderersRegistry: RenderFunctionsRegistry,
+  interpreter: Interpreter
+) {
+  const ast =
+    typeof expressionOrAst === 'string' ? fromExpression(expressionOrAst) : expressionOrAst;
+  const response = await interpreter.interpretAst(
+    ast,
+    { type: 'null' },
+    {
+      getInitialContext: () => ({}),
+      inspectorAdapters: {
+        // TODO connect real adapters
+        requests: new RequestAdapter(),
+        data: new DataAdapter(),
+      },
+    }
+  );
+
+  if (response.type === 'render' && response.as) {
+    renderersRegistry.get(response.as).render(element, response.value, {
+      onDestroy: fn => {
+        // TODO implement
+      },
+      done: () => {
+        // TODO implement
+      },
+    });
+  } else {
+    // eslint-disable-next-line no-console
+    console.log('Unexpected result of expression', response);
+  }
+
+  return response;
+}
+
+/**
+ * Expression Executor Service
+ * @internal
+ */
+export class ExpressionExecutorService {
+  private interpreterInstance: Interpreter | null = null;
+
+  // TODO core won't ever be null once this is switched to the new platform
+  public setup(_core: CoreSetup | null, plugins: ExpressionExecutorSetupPlugins) {
+    /**
+     * **experimential** This API is experimential and might be removed in the future
+     * without notice
+     *
+     * Executes the given expression string or ast and renders the result into the
+     * given DOM element.
+     *
+     *
+     * @param expressionOrAst
+     * @param element
+     */
+    const run = async (expressionOrAst: string | Ast, element: Element) => {
+      if (!this.interpreterInstance) {
+        this.interpreterInstance = (await plugins.interpreter.getInterpreter()).interpreter;
+      }
+      return await runFn(
+        expressionOrAst,
+        element,
+        plugins.interpreter.renderersRegistry,
+        this.interpreterInstance
+      );
+    };
+    return {
+      run,
+      /**
+       * **experimential** This API is experimential and might be removed in the future
+       * without notice
+       *
+       * Component which executes and renders the given expression in a div element.
+       * The expression is re-executed on updating the props.
+       *
+       * This is a React bridge of the `run` method
+       * @param props
+       */
+      ExpressionRenderer({ expression }: { expression: string }) {
+        const mountpoint: React.MutableRefObject<null | HTMLDivElement> = useRef(null);
+
+        useEffect(
+          () => {
+            if (mountpoint.current) {
+              run(expression, mountpoint.current);
+            }
+          },
+          [expression, mountpoint.current]
+        );
+
+        return (
+          <div
+            ref={el => {
+              mountpoint.current = el;
+            }}
+          />
+        );
+      },
+    };
+  }
+
+  public stop() {
+    // nothing to do here yet
+  }
+}
+
+/** @public */
+export type ExpressionExecutorSetup = ReturnType<ExpressionExecutorService['setup']>;