@5minds/processcube_engine_sdk 7.2.0-alpha.3 → 7.2.0-alpha.5

package/dist/DataModels/ApplicationInfo.d.ts

@@ -56,5 +56,8 @@ export type ApplicationInfo = {
         name: string;
         version: string;
     }>;
+    extensionInfo?: {
+        [extensionName: string]: any;
+    };
     extraInfo: any;
 };

package/dist/DataModels/EngineMetadata.d.ts

@@ -0,0 +1,13 @@
+export type EngineMetadata = {
+    engineId: string;
+    hostname: string;
+    lastSeen: number;
+    alive?: boolean;
+    leader?: boolean;
+    current?: boolean;
+    allProcesses?: number;
+    runningProcesses?: number;
+    finishedProcesses?: number;
+    erroredProcesses?: number;
+    terminatedProcesses?: number;
+};

package/dist/DataModels/ProcessInstance/ProcessInstance.d.ts

@@ -161,6 +161,7 @@ export declare type ProcessInstance = {
     metadata?: ProcessInstanceMetadata;
     correlation?: Correlation;
     triggeredByFlowNodeInstance?: FlowNodeInstance;
+    engineId?: string;
 };
 /**
  * @swagger

package/dist/DataModels/index.d.ts

@@ -16,6 +16,7 @@ export * from './Constants';
 export * from './Correlation';
 export * from './Cronjob/index';
 export * from './DataObjectInstance';
+export * from './EngineMetadata';
 export * from './ExternalTask/index';
 export * from './FlowNodeInstance/index';
 export * from './Iam/index';

package/dist/Engine.d.ts

@@ -1,8 +1,9 @@
 import * as express from 'express';
 import { UserTaskInstance } from './DataModels';
 import { Identity } from './DataModels/Iam/index';
+import { ExternalEventBus } from './EngineEventBus';
 import { EngineEventType, MiddlewareCallback } from './EngineEvents/index';
-import { IApplicationInfoExtensionAdapter, ICorrelationExtensionAdapter, ICronjobExtensionAdapter, IDataObjectInstanceExtensionAdapter, IEventExtensionAdapter, IExternalTaskExtensionAdapter, IFlowNodeInstanceExtensionAdapter, IIamExtensionAdapter, IManualTaskExtensionAdapter, INotificationExtensionAdapter, IProcessDefinitionExtensionAdapter, IProcessInstanceExtensionAdapter, IProcessModelExtensionAdapter, IUntypedTaskExtensionAdapter, IUserTaskExtensionAdapter } from './ExtensionAdapter';
+import { IApplicationInfoExtensionAdapter, IClusterExtensionAdapter, ICorrelationExtensionAdapter, ICronjobExtensionAdapter, IDataObjectInstanceExtensionAdapter, IEventExtensionAdapter, IExternalTaskExtensionAdapter, IFlowNodeInstanceExtensionAdapter, IIamExtensionAdapter, IManualTaskExtensionAdapter, IMessageEventExtensionAdapter, INotificationExtensionAdapter, IProcessDefinitionExtensionAdapter, IProcessInstanceExtensionAdapter, IProcessModelExtensionAdapter, ISignalEventExtensionAdapter, IUntypedTaskExtensionAdapter, IUserTaskExtensionAdapter } from './ExtensionAdapter';
 import { EventViewModel, FlowNodeViewModel } from './ProcessModel/index';
 /**
  * Describes the onLoad function, which can be exported by an extension.
@@ -12,8 +13,16 @@ import { EventViewModel, FlowNodeViewModel } from './ProcessModel/index';
  * export const onLoad: onLoadFunction = (engine: Engine) => {}
  */
 export type OnLoad = (engine: Engine) => void | Promise<void>;
+export type GetStatusInfo = () => Object | Promise<Object>;
 export type EngineExtension = {
     onLoad: OnLoad;
+    getStatusInfo?: GetStatusInfo;
+};
+export type Extension = {
+    exports: EngineExtension;
+    name: string;
+    version: string;
+    path: string;
 };
 export type CustomServiceTaskHandlerContext = {
     token: {
@@ -67,6 +76,7 @@ export type CustomHttpRouteRequest = {
     stale: boolean;
     subdomains: Array<string>;
     xhr: boolean;
+    nonce?: string;
 };
 export declare enum HttpResponseActionType {
     Send = "send",
@@ -213,6 +223,14 @@ export type Engine = {
      * @param callback The callback to call after the Engine has finished starting up.
      */
     onReady(callback: () => void | Promise<void>): void;
+    /**
+     * Registers a custom Event Bus, which will replace the Engine's own internal Event Bus.
+     *
+     * **NOTE:** Can only be used BEFORE the {@link Engine.onReady} Event was fired!
+     *
+     * @param eventBus A custom {@link ExternalEventBus}.
+     */
+    registerCustomEventBus(eventBus: ExternalEventBus): void;
     /**
      * Registers the given callback as an Event Middleware.
      * This middleware gets called whenever a Log Event occurs at the Engine.
@@ -357,6 +375,7 @@ export type Engine = {
     registerHttpRoute(path: string, method: 'get' | 'post' | 'put' | 'delete', routeHandler: CustomHttpRouteHandler, options?: CustomHttpRouteOptions): void;
     executeRuntimeExpression<TExpectedResult>(expression: string, params: RuntimeExpressionParameters): Promise<TExpectedResult>;
     applicationInfo: IApplicationInfoExtensionAdapter;
+    cluster: IClusterExtensionAdapter;
     correlations: ICorrelationExtensionAdapter;
     cronjobs: ICronjobExtensionAdapter;
     dataObjectInstances: IDataObjectInstanceExtensionAdapter;
@@ -366,9 +385,11 @@ export type Engine = {
     flowNodeInstances: IFlowNodeInstanceExtensionAdapter;
     iam: IIamExtensionAdapter;
     manualTasks: IManualTaskExtensionAdapter;
+    messageEvents: IMessageEventExtensionAdapter;
     notification: INotificationExtensionAdapter;
     processDefinitions: IProcessDefinitionExtensionAdapter;
     processInstances: IProcessInstanceExtensionAdapter;
     processModels: IProcessModelExtensionAdapter;
+    signalEvents: ISignalEventExtensionAdapter;
     userTasks: IUserTaskExtensionAdapter;
 };

package/dist/EngineConfiguration.d.ts

@@ -30,6 +30,7 @@ export declare type ExtensionsConfig = {
     exclude?: string[];
 };
 export declare type RuntimeExpressionConfig = {
+    disableTimeout?: boolean;
     timeoutInMiliseconds?: number;
     workerPoolSize?: number;
 };
@@ -92,6 +93,7 @@ export declare type HttpServerConfig = {
 };
 export declare type IAMConfiguration = {
     baseUrl: string;
+    internalUrl?: string;
     allowAnonymousRootAccess?: boolean;
     rootAccessToken?: string;
 };

package/dist/EngineEventBus.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Defines the signature for the Callback that an EventSubscription should have.
+ *
+ * @param eventPayload Optional: The payload received with the event.
+ * @param eventName    Optional: The name of the received event.
+ */
+export type EventReceivedCallback = (eventPayload?: any, eventName?: string) => void | Promise<void>;
+/**
+ * Contains information about a subscription on the EngineEventBus.
+ * External services can use this information to manage their own subscriptions.
+ */
+export type Subscription = {
+    /**
+     * The Id under which the EngineEventBus has stored the Subscription.
+     */
+    readonly id: string;
+    /**
+     * The name of the event for which the Subscription was created.
+     */
+    readonly eventName: string;
+    /**
+     * If set to true, the Subscription will be destroyed after first receiving
+     * the event.
+     */
+    readonly onlyReceiveOnce: boolean;
+};
+export type ExternalSubscription = {
+    remove: () => Promise<void>;
+};
+/**
+ * The Event Bus is used by the Engine to manage communications between the individual engine services, as well as all Flow Node Instances and Process Instances.
+ *
+ * By default, the Engine uses its own EventAggregator.
+ *
+ * You can replace it with your own, if you want to connect the engine to an external messagebus.
+ */
+export type EngineEventBus = {
+    /**
+     * Creates a new {@link Subscription} on the EventBus for the event with the given name.
+     * The {@link Subscription} will remain active, until manually disposed through the {@link EngineEventBus.unsubscribe} method.
+     *
+     * @param eventName The name of the Event to subscribe to.
+     * @param callback  The callback to execute, when the event is received.
+     * @returns         A {@link Subscription} object.
+     */
+    subscribe: (eventName: string, callback: EventReceivedCallback) => Subscription;
+    /**
+     * Creates a new {@link Subscription} on the EventBus for the event with the given name.
+     * The {@link Subscription} is automatically disposed, after the event was received once.
+     *
+     * @param eventName The name of the Event to subscribe to.
+     * @param callback  The callback to execute, when the event is received.
+     * @returns         A {@link Subscription} object.
+     */
+    subscribeOnce: (eventName: string, callback: EventReceivedCallback) => Subscription;
+    /**
+     * Publishes a given event on the EventBus.
+     * Usually, this function returns as soon as the Event was published.
+     * However, it is possible to wait for all Subscribers to acknowledge receiving the Event, by providing an "onAcknowledgement" Callback function.
+     *
+     * @param eventName         The name of the Event to publish.
+     * @param payload           The payload to send with the Event.
+     * @param onAcknowledgement Optional: The callback to call, after all Subscribers have acknowledged receiving the Event.
+     * @param eventId           Optional: The Event ID to use.
+     */
+    publish: (eventName: string, payload?: Record<string, any>, onAcknowledgement?: () => void, eventId?: string) => void;
+    /**
+     * Allows a Subscriber to acknowledge the receit of an Event with the given ID.
+     *
+     * @param eventId The ID of the Event to acknowledge.
+     */
+    acknowledgeEvent: (eventId: string) => void;
+    /**
+     * Disposes the given Event Subscription.
+     *
+     * @param subscription The Subscription to dispose.
+     */
+    unsubscribe: (subscription: Subscription) => void;
+};
+export type ExternalEventBus = {
+    subscribeToWorkQueue: (queueName: string, callback: Function) => Promise<ExternalSubscription>;
+    subscribeToTopicWithRoutingKey: (topic: string, routingKey: string, callback: Function, oneTimeSubscription?: boolean) => Promise<ExternalSubscription>;
+    subscribeToBroadcast: (topic: string, callback: Function, oneTimeSubscription?: boolean) => Promise<ExternalSubscription>;
+    publishToWorkQueue: (queueName: string, payload: Record<string, any>) => Promise<void>;
+    publishToTopicWithRoutingKey: (topic: string, routingKey: string, payload: Record<string, any>) => Promise<void>;
+    publishToBroadcast: (topic: string, payload: Record<string, any>) => Promise<void>;
+};

package/dist/EngineEventBusSettings.d.ts

@@ -0,0 +1,141 @@
+export declare const EngineEventBusSettings: {
+    messagePaths: {
+        activityReached: string;
+        activityFinished: string;
+        activityCanceled: string;
+        boundaryEventTriggered: string;
+        boundaryEventFinished: string;
+        boundaryEventWaiting: string;
+        changeCorrelationMetadata: {
+            topic: string;
+            routingKey: (correlationId: string) => string;
+        };
+        clusterSetupFinished: string;
+        correlationMetadataChanged: string;
+        cronjobCreated: string;
+        cronjobExecuted: string;
+        cronjobEnabledChanged: string;
+        cronjobStopped: string;
+        cronjobUpdated: string;
+        cronjobRemoved: string;
+        untypedTaskReached: string;
+        untypedTaskFinished: string;
+        endEventFinished: string;
+        engineDied: string;
+        externalTaskCreated: string;
+        externalTaskExpired: string;
+        externalTaskFinished: string;
+        externalTaskLocked: string;
+        externalTaskUnlocked: string;
+        finishExternalTask: string;
+        flowNodeEventRetrySending: string;
+        intermediateThrowEventTriggered: string;
+        intermediateCatchEventReached: string;
+        intermediateCatchEventFinished: string;
+        livenessProbe: string;
+        manualTaskReached: string;
+        processDeployed: string;
+        processUndeployed: string;
+        processInstancesDeleted: string;
+        processInstanceMetadataChanged: string;
+        processExecutableChanged: string;
+        startEventFinished: string;
+        terminateProcessInstance: string;
+        userTaskReached: string;
+        userTaskReserved: string;
+        userTaskReservationCanceled: string;
+        messageEventTriggeredOnPath: {
+            topic: string;
+            routingKey: (triggerValue: string, reference: string, processInstanceId: string) => string;
+        };
+        signalEventTriggeredOnPath: {
+            topic: string;
+            routingKey: (triggerValue: string, reference: string, processInstanceId: string) => string;
+        };
+        messageTriggered: string;
+        signalTriggered: string;
+        triggerTimerEvent: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        tokenPayloadChange: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        tokenPayloadChangeFinished: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        activityError: string;
+        processStarting: string;
+        processResumed: string;
+        processOwnerChanged: string;
+        gatewayFinished: string;
+        gatewayReached: string;
+        finishUntypedTask: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        finishUserTask: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        userTaskFinished: {
+            topic: string;
+            routingKey: (flownodeInstanceId: string) => string;
+        };
+        finishManualTask: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        manualTaskFinished: {
+            topic: string;
+            routingKey: (flowNodeInstanceId: string) => string;
+        };
+        endEventReached: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        processStarted: {
+            topic: string;
+            routingKey: (processModelId: string) => string;
+        };
+        processEnded: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        processErrored: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        processTerminated: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        killProcessInstance: {
+            topic: string;
+            routingKey: (processInstanceId?: string, engineId?: string) => string;
+        };
+        processKilled: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        terminateEndEventReached: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        changeProcessInstanceOwner: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        processInstanceOwnerChanged: {
+            topic: string;
+            routingKey: (processInstanceId: string) => string;
+        };
+        lockExternalTask: string;
+        unlockExternalTask: string;
+    };
+    externalMessagePaths: {
+        processStartRequest: string;
+    };
+};

package/dist/EngineEvents/EventPayloads/KillProcessInstanceMessage.d.ts

@@ -0,0 +1,11 @@
+import { Identity } from '../../DataModels';
+/**
+ * Encapsulates a message for when a Process Instance gets killed by a user.
+ */
+export type KillProcessInstanceMessage = {
+    /**
+     * Contain the killers identity.
+     */
+    killedBy: Identity;
+    processInstanceId: string;
+};

package/dist/EngineEvents/EventPayloads/TerminateProcessInstance.d.ts

@@ -3,6 +3,7 @@ import { Identity } from '../../DataModels/Iam/index';
  * Encapsulates a message for when a Process Instance gets terminated.
  */
 export type TerminateProcessInstanceMessage = {
+    processInstanceId: string;
     /**
      * If the Process Instance is terminated by a user, this will contain the users identity.
      */

package/dist/EngineEvents/EventPayloads/index.d.ts

@@ -5,6 +5,7 @@ export * from './ErrorEndEventReached';
 export * from './ExternalTaskMessages';
 export * from './FinishManualTask';
 export * from './FinishUserTask';
+export * from './KillProcessInstanceMessage';
 export * from './MessageEventReached';
 export * from './MetadataChangedMessage';
 export * from './ProcessDeploymentMessage';

package/dist/EngineEvents/index.d.ts

@@ -8,7 +8,6 @@ export * from './EventCallbackTypes';
 export * from './EngineEvent';
 export * from './EngineEventMiddlewares';
 export * from './EventPayloads/index';
-export * from './Subscription';
 export declare namespace Messages {
     export import EventMessage = eventPayloads.EventMessage;
     export import BpmnEvents = eventPayloads;