Dynamic uiActions & license support

src/plugins/ui_actions/public/actions/action_internal.ts

@@ -24,6 +24,13 @@ import { Presentable } from '../util/presentable';
 import { uiToReactComponent } from '../../../kibana_react/public';
 import { ActionType } from '../types';
 
+/**
+ * @remarks
+ * This is exported from a plugin only to be used in `x-pack/actions_enhanced`
+ * This is not part of public api and could be changed without notice
+ *
+ * @internal
+ */
 export class ActionInternal<A extends ActionDefinition = ActionDefinition>
   implements Action<Context<A>>, Presentable<Context<A>> {
   constructor(public readonly definition: A) {}

src/plugins/ui_actions/public/index.ts

@@ -45,4 +45,4 @@ export {
   applyFilterTrigger,
 } from './triggers';
 export { TriggerContextMapping, TriggerId, ActionContextMapping, ActionType } from './types';
-export { ActionByType } from './actions';
+export { ActionByType, ActionInternal } from './actions';

src/plugins/ui_actions/public/mocks.ts

@@ -34,6 +34,7 @@ const createSetupContract = (): Setup => {
     registerAction: jest.fn(),
     registerTrigger: jest.fn(),
     unregisterAction: jest.fn(),
+    setCustomActionCreator: jest.fn(),
   };
   return setupContract;
 };

src/plugins/ui_actions/public/plugin.ts

@@ -29,9 +29,13 @@ export type UiActionsSetup = Pick<
   | 'registerAction'
   | 'registerTrigger'
   | 'unregisterAction'
+  | 'setCustomActionCreator'
 >;
 
-export type UiActionsStart = PublicMethodsOf<UiActionsService>;
+export type UiActionsStart = Omit<
+  PublicMethodsOf<UiActionsService>,
+  'ensureActionsExist' | 'setCustomActionCreator'
+>;
 
 export class UiActionsPlugin implements Plugin<UiActionsSetup, UiActionsStart> {
   private readonly service = new UiActionsService();
@@ -46,6 +50,7 @@ export class UiActionsPlugin implements Plugin<UiActionsSetup, UiActionsStart> {
   }
 
   public start(core: CoreStart): UiActionsStart {
+    this.service.ensureActionsExist();
     return this.service;
   }
 

src/plugins/ui_actions/public/service/ui_actions_service.test.ts

@@ -20,7 +20,7 @@
 import { UiActionsService } from './ui_actions_service';
 import { Action, ActionInternal, createAction } from '../actions';
 import { createHelloWorldAction } from '../tests/test_samples';
-import { ActionRegistry, TriggerRegistry, TriggerId, ActionType } from '../types';
+import { TriggerRegistry, TriggerId, ActionType, ActionDefinitionRegistry } from '../types';
 import { Trigger } from '../triggers';
 
 // Casting to ActionType or TriggerId is a hack - in a real situation use
@@ -103,9 +103,9 @@ describe('UiActionsService', () => {
       });
     });
 
-    test('return action instance', () => {
+    test('returns an action instance getter', () => {
       const service = new UiActionsService();
-      const action = service.registerAction({
+      const getAction = service.registerAction({
         id: 'test',
         execute: async () => {},
         getDisplayName: () => 'test',
@@ -114,6 +114,8 @@ describe('UiActionsService', () => {
         type: 'test' as ActionType,
       });
 
+      const action = getAction();
+
       expect(action).toBeInstanceOf(ActionInternal);
       expect(action.id).toBe('test');
     });
@@ -172,8 +174,8 @@ describe('UiActionsService', () => {
 
   describe('.getTriggerCompatibleActions()', () => {
     test('can register and get actions', async () => {
-      const actions: ActionRegistry = new Map();
-      const service = new UiActionsService({ actions });
+      const actions: ActionDefinitionRegistry = new Map();
+      const service = new UiActionsService({ actionDefinitions: actions });
       const helloWorldAction = createHelloWorldAction({} as any);
       const length = actions.size;
 
@@ -382,8 +384,8 @@ describe('UiActionsService', () => {
     });
 
     test('can register action', () => {
-      const actions: ActionRegistry = new Map();
-      const service = new UiActionsService({ actions });
+      const actions: ActionDefinitionRegistry = new Map();
+      const service = new UiActionsService({ actionDefinitions: actions });
 
       service.registerAction({
         id: ACTION_HELLO_WORLD,
@@ -491,4 +493,26 @@ describe('UiActionsService', () => {
       );
     });
   });
+
+  describe('custom action creator', () => {
+    test('can provide custom action creator', () => {
+      const service = new UiActionsService();
+      class CustomActionInternal extends ActionInternal {
+        readonly custom = true;
+      }
+      service.setCustomActionCreator((def) => new CustomActionInternal(def));
+      const actionDef: Action = {
+        id: 'action1',
+        order: 1,
+        type: 'type1' as ActionType,
+        execute: async () => {},
+        getDisplayName: () => 'test',
+        getIconType: () => '',
+        isCompatible: async () => true,
+      };
+      service.registerAction(actionDef);
+      const action = service.getAction(actionDef.id);
+      expect('custom' in action).toBe(true);
+    });
+  });
 });

src/plugins/ui_actions/public/service/ui_actions_service.ts

@@ -23,6 +23,7 @@ import {
   TriggerToActionsRegistry,
   TriggerId,
   TriggerContextMapping,
+  ActionDefinitionRegistry,
 } from '../types';
 import { ActionInternal, Action, ActionDefinition, ActionContext } from '../actions';
 import { Trigger, TriggerContext } from '../triggers/trigger';
@@ -32,6 +33,7 @@ import { TriggerContract } from '../triggers/trigger_contract';
 export interface UiActionsServiceParams {
   readonly triggers?: TriggerRegistry;
   readonly actions?: ActionRegistry;
+  readonly actionDefinitions?: ActionDefinitionRegistry;
 
   /**
    * A 1-to-N mapping from `Trigger` to zero or more `Action`.
@@ -43,15 +45,18 @@ export class UiActionsService {
   protected readonly triggers: TriggerRegistry;
   protected readonly actions: ActionRegistry;
   protected readonly triggerToActions: TriggerToActionsRegistry;
+  protected readonly actionDefinitions: ActionDefinitionRegistry;
 
   constructor({
     triggers = new Map(),
     actions = new Map(),
     triggerToActions = new Map(),
+    actionDefinitions = new Map(),
   }: UiActionsServiceParams = {}) {
     this.triggers = triggers;
     this.actions = actions;
     this.triggerToActions = triggerToActions;
+    this.actionDefinitions = actionDefinitions;
   }
 
   public readonly registerTrigger = (trigger: Trigger) => {
@@ -77,24 +82,25 @@ export class UiActionsService {
 
   public readonly registerAction = <A extends ActionDefinition>(
     definition: A
-  ): Action<ActionContext<A>> => {
-    if (this.actions.has(definition.id)) {
+  ): (() => Action<ActionContext<A>>) => {
+    if (this.actionDefinitions.has(definition.id)) {
       throw new Error(`Action [action.id = ${definition.id}] already registered.`);
     }
 
-    const action = new ActionInternal(definition);
+    this.actionDefinitions.set(definition.id, definition);
 
-    this.actions.set(action.id, action);
-
-    return action;
+    return () => {
+      return this.getAction(definition.id);
+    };
   };
 
   public readonly unregisterAction = (actionId: string): void => {
-    if (!this.actions.has(actionId)) {
+    if (!this.actions.has(actionId) && !this.actionDefinitions.has(actionId)) {
       throw new Error(`Action [action.id = ${actionId}] is not registered.`);
     }
 
     this.actions.delete(actionId);
+    this.actionDefinitions.delete(actionId);
   };
 
   public readonly attachAction = <T extends TriggerId>(triggerId: T, actionId: string): void => {
@@ -142,13 +148,14 @@ export class UiActionsService {
     // by this type of trigger, typescript will complain. yay!
     action: Action<TriggerContextMapping[T]>
   ): void => {
-    if (!this.actions.has(action.id)) this.registerAction(action);
+    if (!this.actionDefinitions.has(action.id)) this.registerAction(action);
     this.attachAction(triggerId, action.id);
   };
 
   public readonly getAction = <T extends ActionDefinition>(
     id: string
   ): Action<ActionContext<T>> => {
+    this.ensureActionExists(id);
     if (!this.actions.has(id)) {
       throw new Error(`Action [action.id = ${id}] not registered.`);
     }
@@ -164,9 +171,7 @@ export class UiActionsService {
 
     const actionIds = this.triggerToActions.get(triggerId);
 
-    const actions = actionIds!
-      .map((actionId) => this.actions.get(actionId) as ActionInternal)
-      .filter(Boolean);
+    const actions = actionIds!.map((actionId) => this.getAction(actionId));
 
     return actions as Array<Action<TriggerContext<T>>>;
   };
@@ -204,6 +209,7 @@ export class UiActionsService {
     this.actions.clear();
     this.triggers.clear();
     this.triggerToActions.clear();
+    this.actionDefinitions.clear();
   };
 
   /**
@@ -215,12 +221,49 @@ export class UiActionsService {
     const triggers: TriggerRegistry = new Map();
     const actions: ActionRegistry = new Map();
     const triggerToActions: TriggerToActionsRegistry = new Map();
+    const actionDefinitions: ActionDefinitionRegistry = new Map();
 
     for (const [key, value] of this.triggers.entries()) triggers.set(key, value);
     for (const [key, value] of this.actions.entries()) actions.set(key, value);
     for (const [key, value] of this.triggerToActions.entries())
       triggerToActions.set(key, [...value]);
+    for (const [key, value] of this.actionDefinitions.entries()) actionDefinitions.set(key, value);
+    return new UiActionsService({ triggers, actions, triggerToActions, actionDefinitions });
+  };
+
+  /**
+   * Create action from action definition
+   * @param def
+   */
+  private createAction = (def: ActionDefinition) =>
+    this.customActionCreator ? this.customActionCreator(def) : new ActionInternal(def);
+
+  /**
+   * Allows to override default action creator
+   */
+  private customActionCreator?: (def: ActionDefinition) => ActionInternal;
 
-    return new UiActionsService({ triggers, actions, triggerToActions });
+  /**
+   * Allows to overrides default action creator
+   * @param actionCreator
+   */
+  public setCustomActionCreator = (actionCreator: (def: ActionDefinition) => ActionInternal) => {
+    if (this.customActionCreator) {
+      throw new Error('Custom action creator is already set, and can only be set once');
+    }
+    this.customActionCreator = actionCreator;
   };
+
+  // These two functions are only to support legacy plugins registering factories after the start lifecycle.
+  public ensureActionsExist() {
+    this.actionDefinitions.forEach((def) => this.ensureActionExists(def.id));
+  }
+
+  private ensureActionExists(actionId: string) {
+    if (!this.actions.has(actionId)) {
+      const def = this.actionDefinitions.get(actionId);
+      if (!def) return;
+      this.actions.set(actionId, this.createAction(def));
+    }
+  }
 }

src/plugins/ui_actions/public/types.ts

@@ -23,9 +23,11 @@ import { Filter } from '../../data/public';
 import { SELECT_RANGE_TRIGGER, VALUE_CLICK_TRIGGER, APPLY_FILTER_TRIGGER } from './triggers';
 import { IEmbeddable } from '../../embeddable/public';
 import { RangeSelectTriggerContext, ValueClickTriggerContext } from '../../embeddable/public';
+import { ActionDefinition } from './actions';
 
 export type TriggerRegistry = Map<TriggerId, TriggerInternal<any>>;
 export type ActionRegistry = Map<string, ActionInternal>;
+export type ActionDefinitionRegistry = Map<string, ActionDefinition>;
 export type TriggerToActionsRegistry = Map<TriggerId, string[]>;
 
 const DEFAULT_TRIGGER = '';

x-pack/examples/ui_actions_enhanced_examples/public/dashboard_to_url_drilldown/index.tsx

@@ -39,6 +39,8 @@ export class DashboardToUrlDrilldown implements Drilldown<Config, ActionContext>
 
   public readonly order = 8;
 
+  readonly minimalLicense = 'gold'; // example of minimal license support
+
   public readonly getDisplayName = () => 'Go to URL (example)';
 
   public readonly euiIcon = 'link';

x-pack/plugins/licensing/public/mocks.ts

@@ -4,7 +4,7 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 import { BehaviorSubject } from 'rxjs';
-import { LicensingPluginSetup } from './types';
+import { LicensingPluginSetup, LicensingPluginStart } from './types';
 import { licenseMock } from '../common/licensing.mock';
 
 const createSetupMock = () => {
@@ -18,7 +18,19 @@ const createSetupMock = () => {
   return mock;
 };
 
+const createStartMock = (): LicensingPluginStart => {
+  const license = licenseMock.createLicense();
+  const mock: jest.Mocked<LicensingPluginStart> = {
+    license$: new BehaviorSubject(license),
+    refresh: jest.fn(),
+  };
+  mock.refresh.mockResolvedValue(license);
+
+  return mock;
+};
+
 export const licensingMock = {
   createSetup: createSetupMock,
+  createStart: createStartMock,
   ...licenseMock,
 };

x-pack/plugins/ui_actions_enhanced/kibana.json

@@ -4,7 +4,8 @@
   "configPath": ["xpack", "ui_actions_enhanced"],
   "requiredPlugins": [
     "embeddable",
-    "uiActions"
+    "uiActions",
+    "licensing"
   ],
   "server": false,
   "ui": true

x-pack/plugins/ui_actions_enhanced/public/actions/action_enhanced.test.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 { ActionEnhancedDefinition } from './action_enhanced';
+import { ActionEnhancedInternal } from './action_enhanced_internal';
+import { licenseMock } from '../../../licensing/common/licensing.mock';
+
+describe('ActionEnhanced', () => {
+  const def: ActionEnhancedDefinition = {
+    id: 'test',
+    async execute() {},
+  };
+
+  describe('License checks inside isCompatible', () => {
+    test('no license requirements', async () => {
+      const action = new ActionEnhancedInternal(def, () => licenseMock.createLicense());
+      expect(await action.isCompatible({})).toBe(true);
+    });
+
+    test('not enough license level', async () => {
+      const action = new ActionEnhancedInternal({ ...def, minimalLicense: 'gold' }, () =>
+        licenseMock.createLicense()
+      );
+      expect(await action.isCompatible({})).toBe(false);
+    });
+
+    test('enough license level', async () => {
+      const action = new ActionEnhancedInternal({ ...def, minimalLicense: 'gold' }, () =>
+        licenseMock.createLicense({ license: { type: 'gold' } })
+      );
+      expect(await action.isCompatible({})).toBe(true);
+    });
+  });
+});