Dynamic uiActions & license support

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

@@ -41,6 +41,11 @@ export interface Action<Context extends {} = {}, T = ActionType>
    */
   readonly type: T;
 
+  /**
+   * Extension point for extra information on Action
+   */
+  readonly enhancements?: unknown;
+
   /**
    * Optional EUI icon type that can be displayed along with the title.
    */
@@ -85,10 +90,29 @@ export interface ActionDefinition<Context extends object = object>
    */
   readonly type?: ActionType;
 
+  /**
+   * Extension point for extra information on Action
+   */
+  readonly enhancements?: unknown;
+
   /**
    * Executes the action.
    */
   execute(context: Context): Promise<void>;
 }
 
 export type ActionContext<A> = A extends ActionDefinition<infer Context> ? Context : never;
+
+/**
+ * Extension point allows to hook into {@link Action} methods
+ */
+export interface ActionHook {
+  /**
+   * onIsCompatible hook allows to extend action.isCompatible with additional compatibility checks
+   * It doesn't override original isCompatible checks, so it isn't possible to _force_ compatibility with this hook.
+   *
+   * @param action
+   * @param context
+   */
+  onIsCompatible?: (action: Action, context: unknown) => boolean;
+}

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

@@ -27,7 +27,16 @@ const defaultActionDef: ActionDefinition = {
 
 describe('ActionInternal', () => {
   test('can instantiate from action definition', () => {
-    const action = new ActionInternal(defaultActionDef);
+    const action = new ActionInternal(defaultActionDef, () => []);
     expect(action.id).toBe('test-action');
   });
+
+  test('can hook into action methods', async () => {
+    const action = new ActionInternal(defaultActionDef, () => [
+      {
+        onIsCompatible: () => false,
+      },
+    ]);
+    expect(await action.isCompatible({})).toBe(false);
+  });
 });

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

@@ -19,17 +19,21 @@
 
 // @ts-ignore
 import React from 'react';
-import { Action, ActionContext as Context, ActionDefinition } from './action';
+import { Action, ActionContext as Context, ActionDefinition, ActionHook } from './action';
 import { Presentable } from '../util/presentable';
 import { uiToReactComponent } from '../../../kibana_react/public';
 import { ActionType } from '../types';
 
+/**
+ * @internal
+ */
 export class ActionInternal<A extends ActionDefinition = ActionDefinition>
   implements Action<Context<A>>, Presentable<Context<A>> {
-  constructor(public readonly definition: A) {}
+  constructor(public readonly definition: A, private readonly getActionHooks: () => ActionHook[]) {}
 
   public readonly id: string = this.definition.id;
   public readonly type: ActionType = this.definition.type || '';
+  public readonly enhancements: unknown = this.definition.enhancements;
   public readonly order: number = this.definition.order || 0;
   public readonly MenuItem? = this.definition.MenuItem;
   public readonly ReactMenuItem? = this.MenuItem ? uiToReactComponent(this.MenuItem) : undefined;
@@ -54,6 +58,10 @@ export class ActionInternal<A extends ActionDefinition = ActionDefinition>
   }
 
   public async isCompatible(context: Context<A>): Promise<boolean> {
+    for (const { onIsCompatible } of this.getActionHooks()) {
+      if (onIsCompatible && !onIsCompatible(this, context)) return false;
+    }
+
     if (!this.definition.isCompatible) return true;
     return await this.definition.isCompatible(context);
   }

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(),
+    registerActionHook: jest.fn(),
   };
   return setupContract;
 };

src/plugins/ui_actions/public/plugin.ts

@@ -29,9 +29,10 @@ export type UiActionsSetup = Pick<
   | 'registerAction'
   | 'registerTrigger'
   | 'unregisterAction'
+  | 'registerActionHook'
 >;
 
-export type UiActionsStart = PublicMethodsOf<UiActionsService>;
+export type UiActionsStart = Omit<PublicMethodsOf<UiActionsService>, 'registerActionHook'>;
 
 export class UiActionsPlugin implements Plugin<UiActionsSetup, UiActionsStart> {
   private readonly service = new UiActionsService();

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, ActionRegistry } from '../types';
 import { Trigger } from '../triggers';
 
 // Casting to ActionType or TriggerId is a hack - in a real situation use
@@ -491,4 +491,56 @@ describe('UiActionsService', () => {
       );
     });
   });
+
+  describe('action hooks', () => {
+    describe('onIsCompatible', () => {
+      test('can make action incompatible', async () => {
+        const service = new UiActionsService();
+        service.registerActionHook({
+          onIsCompatible: () => false,
+        });
+        service.registerActionHook({
+          onIsCompatible: () => true,
+        });
+        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);
+
+        const isCompatible = await action.isCompatible({});
+        expect(isCompatible).toBe(false);
+      });
+
+      test("can't force compatibility of incompatible action", async () => {
+        const service = new UiActionsService();
+        service.registerActionHook({
+          onIsCompatible: () => true,
+        });
+        service.registerActionHook({
+          onIsCompatible: () => true,
+        });
+        const actionDef: Action = {
+          id: 'action1',
+          order: 1,
+          type: 'type1' as ActionType,
+          execute: async () => {},
+          getDisplayName: () => 'test',
+          getIconType: () => '',
+          isCompatible: async () => false,
+        };
+        service.registerAction(actionDef);
+        const action = service.getAction(actionDef.id);
+
+        const isCompatible = await action.isCompatible({});
+        expect(isCompatible).toBe(false);
+      });
+    });
+  });
 });

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

@@ -23,8 +23,9 @@ import {
   TriggerToActionsRegistry,
   TriggerId,
   TriggerContextMapping,
+  ActionHooksRegistry,
 } from '../types';
-import { ActionInternal, Action, ActionDefinition, ActionContext } from '../actions';
+import { ActionInternal, Action, ActionDefinition, ActionContext, ActionHook } from '../actions';
 import { Trigger, TriggerContext } from '../triggers/trigger';
 import { TriggerInternal } from '../triggers/trigger_internal';
 import { TriggerContract } from '../triggers/trigger_contract';
@@ -37,21 +38,26 @@ export interface UiActionsServiceParams {
    * A 1-to-N mapping from `Trigger` to zero or more `Action`.
    */
   readonly triggerToActions?: TriggerToActionsRegistry;
+
+  readonly actionHooks?: ActionHooksRegistry;
 }
 
 export class UiActionsService {
   protected readonly triggers: TriggerRegistry;
   protected readonly actions: ActionRegistry;
   protected readonly triggerToActions: TriggerToActionsRegistry;
+  protected readonly actionHooksRegistry: ActionHooksRegistry;
 
   constructor({
     triggers = new Map(),
     actions = new Map(),
     triggerToActions = new Map(),
+    actionHooks = [],
   }: UiActionsServiceParams = {}) {
     this.triggers = triggers;
     this.actions = actions;
     this.triggerToActions = triggerToActions;
+    this.actionHooksRegistry = actionHooks;
   }
 
   public readonly registerTrigger = (trigger: Trigger) => {
@@ -82,7 +88,7 @@ export class UiActionsService {
       throw new Error(`Action [action.id = ${definition.id}] already registered.`);
     }
 
-    const action = new ActionInternal(definition);
+    const action = new ActionInternal(definition, () => this.actionHooksRegistry);
 
     this.actions.set(action.id, action);
 
@@ -146,6 +152,10 @@ export class UiActionsService {
     this.attachAction(triggerId, action.id);
   };
 
+  public readonly registerActionHook = (hook: ActionHook) => {
+    this.actionHooksRegistry.push(hook);
+  };
+
   public readonly getAction = <T extends ActionDefinition>(
     id: string
   ): Action<ActionContext<T>> => {
@@ -220,7 +230,6 @@ export class UiActionsService {
     for (const [key, value] of this.actions.entries()) actions.set(key, value);
     for (const [key, value] of this.triggerToActions.entries())
       triggerToActions.set(key, [...value]);
-
     return new UiActionsService({ triggers, actions, triggerToActions });
   };
 }

src/plugins/ui_actions/public/types.ts

@@ -23,10 +23,12 @@ 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 { ActionHook } from './actions';
 
 export type TriggerRegistry = Map<TriggerId, TriggerInternal<any>>;
 export type ActionRegistry = Map<string, ActionInternal>;
 export type TriggerToActionsRegistry = Map<TriggerId, string[]>;
+export type ActionHooksRegistry = ActionHook[];
 
 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 = () => {
+  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.ts

@@ -0,0 +1,44 @@
+/*
+ * 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 {
+  Action,
+  ActionType,
+  UiActionsActionDefinition as ActionDefinition,
+} from '../../../../../src/plugins/ui_actions/public';
+import { LicenseType } from '../../../licensing/public';
+
+export interface ActionEnhanced<Context extends {} = {}, T = ActionType>
+  extends Action<Context, T> {
+  readonly enhancements: {
+    /**
+     * Minimal license
+     * if missing, then no license limitations
+     */
+    minimalLicense?: LicenseType;
+  };
+}
+
+export interface ActionEnhancedDefinition<Context extends object = object>
+  extends ActionDefinition<Context> {
+  readonly enhancements: {
+    /**
+     * Minimal license
+     * if missing, then no license limitations
+     */
+    minimalLicense?: LicenseType;
+  };
+}
+
+export type ActionEnhancedContext<A> = A extends ActionEnhancedDefinition<infer Context>
+  ? Context
+  : never;
+
+export function isEnhancedAction<Context extends {} = {}, T = ActionType>(
+  action: Action<Context, T>
+): action is ActionEnhanced<Context, T> {
+  return !!action.enhancements;
+}

x-pack/plugins/ui_actions_enhanced/public/actions/index.ts

@@ -0,0 +1,12 @@
+/*
+ * 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.
+ */
+
+export {
+  ActionEnhanced,
+  ActionEnhancedDefinition,
+  ActionEnhancedContext,
+  isEnhancedAction,
+} from './action_enhanced';