feat: 🎸 add first version of dynamic action manager

Author: streamich

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

@@ -19,14 +19,15 @@
 
 import { uiToReactComponent } from '../../../kibana_react/public';
 import { Presentable } from '../util/presentable';
-import { ActionDefinition } from './action_definition';
+import { ActionDefinition } from './action';
 import {
   AnyActionFactoryDefinition,
   AFDConfig as Config,
   AFDFactoryContext as FactoryContext,
   AFDActionContext as ActionContext,
 } from './action_factory_definition';
 import { Configurable } from '../util';
+import { SerializedAction } from './types';
 
 export class ActionFactory<D extends AnyActionFactoryDefinition>
   implements Presentable<FactoryContext<D>>, Configurable<Config<D>> {
@@ -62,8 +63,10 @@ export class ActionFactory<D extends AnyActionFactoryDefinition>
     return this.definition.getHref(context);
   }
 
-  public create(config: Config<D>): ActionDefinition<ActionContext<D>> {
-    return this.definition.create(config);
+  public create(
+    serializedAction: Omit<SerializedAction<Config<D>>, 'factoryId'>
+  ): ActionDefinition<ActionContext<D>> {
+    return this.definition.create(serializedAction);
   }
 }
 

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

@@ -17,8 +17,9 @@
  * under the License.
  */
 
-import { ActionDefinition } from './action_definition';
+import { ActionDefinition } from './action';
 import { Presentable, Configurable } from '../util';
+import { SerializedAction } from './types';
 
 /**
  * This is a convenience interface for registering new action factories.
@@ -39,7 +40,9 @@ export interface ActionFactoryDefinition<
    * This method should return a definition of a new action, normally used to
    * register it in `ui_actions` registry.
    */
-  create(config: Config): ActionDefinition<any>; // TODO: FIX THIS....
+  create(
+    serializedAction: Omit<SerializedAction<Config>, 'factoryId'>
+  ): ActionDefinition<ActionContext>;
 }
 
 export type AnyActionFactoryDefinition = ActionFactoryDefinition<any, any, any>;

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

@@ -21,6 +21,7 @@ import { Action, ActionContext as Context, AnyActionDefinition } from './action'
 import { Presentable } from '../util/presentable';
 import { uiToReactComponent } from '../../../kibana_react/public';
 import { ActionType } from '../types';
+import { SerializedAction } from './types';
 
 export class ActionInternal<A extends AnyActionDefinition>
   implements Action<Context<A>>, Presentable<Context<A>> {
@@ -45,7 +46,7 @@ export class ActionInternal<A extends AnyActionDefinition>
   }
 
   public getDisplayName(context: Context<A>): string {
-    if (!this.definition.getDisplayName) return '';
+    if (!this.definition.getDisplayName) return `Action: ${this.id}`;
     return this.definition.getDisplayName(context);
   }
 
@@ -64,8 +65,7 @@ export class ActionInternal<A extends AnyActionDefinition>
       throw new Error('Action does not have a config.');
     }
 
-    const serialized: SerializedAction = {
-      id: this.id,
+    const serialized: SerializedAction<unknown> = {
       factoryId: this.type,
       name: this.name,
       config: this.config,
@@ -74,17 +74,10 @@ export class ActionInternal<A extends AnyActionDefinition>
     return serialized;
   }
 
-  public deserialize({ name, config }: SerializedAction) {
+  public deserialize({ name, config }: SerializedAction<unknown>) {
     this.name = name;
-    this.config = config;
+    this.config = config as object;
   }
 }
 
 export type AnyActionInternal = ActionInternal<any>;
-
-export interface SerializedAction<Config extends object = object> {
-  readonly id: string;
-  readonly factoryId: string;
-  readonly name: string;
-  readonly config: Config;
-}

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

@@ -17,11 +17,14 @@
  * under the License.
  */
 
-import { ActionByType } from './action';
-import { ActionType } from '../types';
-import { ActionDefinition } from './action_definition';
+import { Ensure } from '@kbn/utility-types';
+import { Action } from './action';
+import { TriggerContextMapping } from '../types';
+import { ActionDefinition } from './action';
 
-export function createAction<T extends ActionType>(action: ActionDefinition<T>): ActionByType<T> {
+export function createAction<T extends keyof TriggerContextMapping>(
+  action: ActionDefinition<Ensure<TriggerContextMapping[T], object>>
+): Action<TriggerContextMapping[T], T> {
   return {
     getIconType: () => undefined,
     order: 0,
@@ -30,5 +33,5 @@ export function createAction<T extends ActionType>(action: ActionDefinition<T>):
     getDisplayName: () => '',
     getHref: () => undefined,
     ...action,
-  } as ActionByType<T>;
+  } as Action<TriggerContextMapping[T], T>;
 }

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

@@ -17,14 +17,77 @@
  * under the License.
  */
 
-import { ActionStorage } from './dynamic_action_storage';
+import { v4 as uuidv4 } from 'uuid';
+import { ActionStorage, SerializedEvent } from './dynamic_action_storage';
 import { UiActionsService } from '../service';
+import { SerializedAction } from './types';
+import { ActionDefinition } from './action';
 
 export interface DynamicActionManagerParams {
   storage: ActionStorage;
-  uiActions: UiActionsService;
+  uiActions: Pick<UiActionsService, 'registerAction' | 'attachAction' | 'getActionFactory'>;
+  isCompatible: <C = unknown>(context: C) => Promise<boolean>;
 }
 
 export class DynamicActionManager {
+  static idPrefixCounter = 0;
+
+  private readonly idPrefix = 'DYN_ACTION_' + DynamicActionManager.idPrefixCounter++;
+
   constructor(protected readonly params: DynamicActionManagerParams) {}
+
+  protected generateActionId(eventId: string): string {
+    return this.idPrefix + eventId;
+  }
+
+  public async start() {
+    const events = await this.params.storage.list();
+
+    for (const event of events) {
+      this.reviveAction(event);
+    }
+  }
+
+  public async stop() {
+    /*
+    const { storage, uiActions } = this.params;
+    const events = await storage.list();
+
+    for (const event of events) {
+      uiActions.detachAction(event.triggerId, event.action.id);
+      uiActions.unregisterAction(event.action.id);
+    }
+    */
+  }
+
+  public async createEvent(action: SerializedAction<unknown>, triggerId = 'VALUE_CLICK_TRIGGER') {
+    const event: SerializedEvent = {
+      eventId: uuidv4(),
+      triggerId,
+      action,
+    };
+
+    await this.params.storage.create(event);
+    this.reviveAction(event);
+  }
+
+  protected reviveAction(event: SerializedEvent) {
+    const { eventId, triggerId, action } = event;
+    const { uiActions, isCompatible } = this.params;
+    const { name } = action;
+
+    const actionId = this.generateActionId(eventId);
+    const factory = uiActions.getActionFactory(event.action.factoryId);
+    const actionDefinition: ActionDefinition<any> = {
+      ...factory.create(action as SerializedAction<object>),
+      id: actionId,
+      isCompatible,
+      getDisplayName: () => name,
+      getIconType: context => factory.getIconType(context),
+    };
+
+    uiActions.attachAction(triggerId as any, actionDefinition as any);
+  }
+
+  protected killAction(actionId: string) {}
 }

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

@@ -17,15 +17,15 @@
  * under the License.
  */
 
-import { SerializedAction } from './action_internal';
+import { SerializedAction } from './types';
 
 /**
  * Serialized representation of event-action pair, used to persist in storage.
  */
 export interface SerializedEvent {
   eventId: string;
   triggerId: string;
-  action: SerializedAction;
+  action: SerializedAction<unknown>;
 }
 
 /**

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

@@ -24,3 +24,5 @@ export * from './action_factory';
 export * from './create_action';
 export * from './incompatible_action_error';
 export * from './dynamic_action_storage';
+export * from './dynamic_action_manager';
+export * from './types';

src/plugins/ui_actions/public/actions/action_definition.ts renamed to src/plugins/ui_actions/public/actions/types.ts

@@ -17,19 +17,8 @@
  * under the License.
  */
 
-import { ActionType, ActionContextMapping } from '../types';
-import { Presentable } from '../util/presentable';
-
-export interface ActionDefinition<T extends ActionType>
-  extends Partial<Presentable<ActionContextMapping[T]>> {
-  /**
-   * ID of the action factory for this action. Action factories are registered
-   * int X-Pack `ui_actions` plugin.
-   */
-  readonly type?: T;
-
-  /**
-   * Executes the action.
-   */
-  execute(context: ActionContextMapping[T]): Promise<void>;
+export interface SerializedAction<Config> {
+  readonly factoryId: string;
+  readonly name: string;
+  readonly config: Config;
 }

src/plugins/ui_actions/public/index.ts

@@ -44,4 +44,4 @@ export {
 } from './util';
 export { Trigger, TriggerContext } from './triggers';
 export { TriggerContextMapping, TriggerId, ActionContextMapping, ActionType } from './types';
-export { ActionByType } from './actions';
+export { ActionByType, DynamicActionManager as UiActionsDynamicActionManager } from './actions';

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

@@ -102,6 +102,8 @@ describe('UiActionsService', () => {
         type: 'test' as ActionType,
       });
     });
+
+    test.todo('return action instance');
   });
 
   describe('.getTriggerActions()', () => {
@@ -481,5 +483,7 @@ describe('UiActionsService', () => {
     test.todo('.getActionFactories() returns empty array if no action factories registered');
     test.todo('can register an action factory');
     test.todo('can retrieve all action factories');
+    test.todo('can retrieve action factory by ID');
+    test.todo('throws when retrieving action factory that does not exist');
   });
 });