bpmn-elements 9.0.0 → 9.1.1

package/src/tasks/SubProcess.js

@@ -205,9 +205,10 @@ SubProcessBehaviour.prototype._onExecutionCompleted = function onExecutionComple
       broker.cancel(message.fields.consumerTag);
       break;
     }
+    case 'cancel':
     case 'discard': {
       broker.cancel(message.fields.consumerTag);
-      broker.publish('execution', 'execute.discard', cloneContent(content));
+      broker.publish('execution', 'execute.' + messageType, cloneContent(content));
       break;
     }
     case 'completed': {

package/types/index.d.ts

@@ -1,5 +1,6 @@
 declare module 'bpmn-elements' {
   import { Broker } from 'smqp';
+  import { BrokerState } from 'smqp/types/Broker';
   import { Consumer } from 'smqp/types/Queue';
   import { MessageMessage } from 'smqp/types/Message';
   import { SerializableContext, SerializableElement } from 'moddle-context-serializer';
@@ -43,7 +44,7 @@ declare module 'bpmn-elements' {
     get isThrowing(): boolean;
     get activity(): Activity;
     get broker(): Broker;
-    get logger(): Logger;
+    get logger(): ILogger;
     get reference(): {
       id?: string,
       name: string,
@@ -62,14 +63,12 @@ declare module 'bpmn-elements' {
     get broker(): Broker;
     get environment(): Environment;
     get context(): Context;
-    get logger(): Logger;
+    get logger(): ILogger;
   }
 
   abstract class Element<T> extends ElementBase {
     get broker(): ElementBroker<T>;
-    getState(): any;
     stop(): void;
-    recover(state?: any): T;
     resume(): void;
     getApi(message?: ElementBrokerMessage): Api<T>;
     on(eventName: string, callback: CallableFunction, options?: any): Consumer;
@@ -110,10 +109,13 @@ declare module 'bpmn-elements' {
     settings?: EnvironmentSettings;
     variables?: Record<string, any>;
     services?: Record<string, CallableFunction>;
-    logger?: Logger;
+    Logger?: LoggerFactory;
     timers?: ITimers;
     scripts?: IScripts;
     extensions?: Record<string, Extension>;
+    /**
+     * optional override expressions handler
+     */
     expressions?: IExpressions;
   }
 
@@ -126,6 +128,30 @@ declare module 'bpmn-elements' {
 
   type filterPostponed = (elementApi: Api<ElementBase>) => boolean;
 
+  /**
+   * Activity status
+   * Can be used to decide when to save states, Timer and Wait is recommended.
+   */
+  const enum ActivityStatus {
+    /** Idle, not running anything */
+    Idle = 'idle',
+    /**
+     * At least one activity is executing,
+     * e.g. a service task making a asynchronous request
+     */
+    Executing = 'executing',
+    /**
+     * At least one activity is waiting for a timer to complete,
+     * usually only TimerEventDefinition's
+     */
+    Timer = 'timer',
+    /**
+     * At least one activity is waiting for a signal of some sort,
+     * e.g. user tasks, intermediate catch events, etc
+     */
+    Wait = 'wait',
+  }
+
   interface DefinitionExecution {
     get id(): string;
     get type(): string;
@@ -139,6 +165,7 @@ declare module 'bpmn-elements' {
     get processes(): Process[];
     get postponedCount(): number;
     get isRunning(): boolean;
+    get activityStatus(): ActivityStatus;
     execute(executeMessage: ElementBrokerMessage): void;
     getProcesses(): Process[];
     getProcessById(processId: string): Process;
@@ -209,14 +236,14 @@ declare module 'bpmn-elements' {
     extensions: Record<string, IExtension>;
     scripts: IScripts;
     timers: ITimers;
-    Logger: Logger;
+    Logger: LoggerFactory;
     get settings(): EnvironmentSettings;
     get variables(): Record<string, any>;
     get output(): Record<string, any>;
     set services(arg: any);
     get services(): any;
-    getState(): any;
-    recover(state?: any): Environment;
+    getState(): EnvironmentState;
+    recover(state?: EnvironmentState): Environment;
     clone(overrideOptions?: EnvironmentOptions): Environment;
     assignVariables(newVars: Record<string, any>): void;
     assignSettings(newSettings: Record<string, any>): void;
@@ -258,19 +285,107 @@ declare module 'bpmn-elements' {
     loadExtensions(activity: ElementBase): IExtension;
   }
 
+  interface ElementState {
+    id: string;
+    type: string;
+    name: string;
+    broker?: BrokerState;
+    [x: string]: any;
+  }
+
+  interface EnvironmentState {
+    settings: EnvironmentSettings;
+    variables: Record<string, any>;
+    output: Record<string, any>;
+  }
+
+  type completedCounters = { completed: number, discarded: number };
+
+  interface ActivityExecutionState {
+    completed: boolean;
+    [x: string]: any;
+  }
+
+  interface ActivityState extends ElementState {
+    executionId: string;
+    stopped: boolean;
+    behaviour: Record<string, any>;
+    counters: { taken: number, discarded: number };
+    execution?: ActivityExecutionState;
+  }
+
+  interface SequenceFlowState extends ElementState {
+    counters: {take: number, discard: number, looped: number};
+  }
+
+  interface MessageFlowState {
+    id: string;
+    type: string;
+    counters: {messages: number};
+  }
+
+  interface AssociationState extends ElementState {
+    counters: {take: number, discard: number };
+    sourceId: string;
+    targetId: string;
+    isAssociation: boolean;
+  }
+
+  interface ProcessExecutionState {
+    executionId: string;
+    stopped: boolean;
+    completed: boolean;
+    status: string;
+    children: ActivityState[];
+    flows?: SequenceFlowState[];
+    messageFlows?: MessageFlowState[];
+    associations?: AssociationState[];
+  }
+
+  interface ProcessState extends ElementState {
+    status: string;
+    stopped: boolean,
+    executionId?: string;
+    counters: completedCounters;
+    environment: EnvironmentState;
+    execution?: ProcessExecutionState;
+  }
+
+  interface DefinitionExecutionState {
+    executionId: string;
+    stopped: boolean;
+    completed: boolean;
+    status: string;
+    processes: ProcessState[];
+  }
+
+  interface DefinitionState extends ElementState {
+    status: string;
+    stopped: boolean,
+    executionId?: string;
+    counters: completedCounters;
+    environment: EnvironmentState;
+    execution?: DefinitionExecutionState;
+  }
+
   type runCallback = (err: Error, definitionApi: Api<Definition>) => void;
   class Definition extends Element<Definition> {
     constructor(context: Context, options?: EnvironmentOptions);
-    get counters(): { completed: number, discarded: number };
+    get counters(): completedCounters;
     get execution(): DefinitionExecution;
     get executionId(): string;
     get isRunning(): boolean;
     get status(): string;
     get stopped(): boolean;
+    get activityStatus(): ActivityStatus;
     run(): Definition;
     run(runContent: Record<string, any>): Definition;
     run(runContent: Record<string, any>, callback: runCallback): Definition;
     run(callback: runCallback): Definition;
+    getState(): DefinitionState;
+    recover(state?: DefinitionState): Definition;
+    resume(): void;
+    resume(callback: (err: Error, definitionApi: Api<Definition>) => void): void;
     shake(startId?: string): object;
     getProcesses(): Process[];
     /** get processes marked with isExecutable=true */
@@ -289,15 +404,18 @@ declare module 'bpmn-elements' {
   class Process extends Element<Process> {
     constructor(processDef: SerializableElement, context: Context);
     get isExecutable(): boolean;
-    get counters(): { completed: number, discarded: number };
+    get counters(): completedCounters;
     get extensions(): IExtension;
     get stopped(): boolean;
     get isRunning(): boolean;
     get executionId(): string;
     get execution(): ProcessExecution;
     get status(): string;
+    get activityStatus(): ActivityStatus;
     init(useAsExecutionId?: string): void;
     run(runContent?: Record<string, any>): void;
+    getState(): ProcessState;
+    recover(state?: ProcessState): Process;
     shake(startId?: string): void;
     signal(message: any): any;
     cancelActivity(message: any): any;
@@ -320,6 +438,7 @@ declare module 'bpmn-elements' {
     get status(): string;
     get postponedCount(): number;
     get isRunning(): boolean;
+    get activityStatus(): ActivityStatus;
     execute(executeMessage: ElementBrokerMessage): void;
     getPostponed(filterFn: filterPostponed): Api<ElementBase>[];
     getActivities(): Activity[];
@@ -363,7 +482,9 @@ declare module 'bpmn-elements' {
     discard(content?: any): boolean;
   }
 
-  interface Logger {
+  type LoggerFactory = (scope: string) => ILogger;
+
+  interface ILogger {
     debug(...args: any[]): void;
     error(...args: any[]): void;
     warn(...args: any[]): void;