@5minds/processcube_engine_sdk 5.0.0-feature-180a4f-lpqpy1m8 → 5.0.0-feature-2b4d7d-lpqpyld8

package/dist/Engine.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Identity } from './DataModels/Iam/index';
 import { EngineEventType, MiddlewareCallback } from './EngineEvents/index';
+import { EngineEventBus } from './EngineEventBus';
 import { IApplicationInfoExtensionAdapter, ICorrelationExtensionAdapter, ICronjobExtensionAdapter, IDataObjectInstanceExtensionAdapter, IUntypedTaskExtensionAdapter, IEventExtensionAdapter, IExternalTaskExtensionAdapter, IFlowNodeInstanceExtensionAdapter, IIamExtensionAdapter, IManualTaskExtensionAdapter, INotificationExtensionAdapter, IProcessDefinitionExtensionAdapter, IProcessInstanceExtensionAdapter, IProcessModelExtensionAdapter, IUserTaskExtensionAdapter } from './ExtensionAdapter';
 import { EventViewModel, FlowNodeViewModel } from './ProcessModel/index';
 import * as express from 'express';
@@ -204,6 +205,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 EngineEventBus}.
+     */
+    registerCustomEventBus(eventBus: EngineEventBus): void;
     /**
      * Registers the given callback as an Event Middleware.
      * This middleware gets called whenever a Log Event occurs at the Engine.

package/dist/EngineEventBus.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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;
+};
+/**
+ * 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;
+};

package/dist/EngineEventBusSettings.d.ts

@@ -0,0 +1,78 @@
+export declare const EngineEventBusSettings: {
+    messageParams: {
+        externalTaskId: string;
+        flowNodeInstanceId: string;
+        messageReference: string;
+        processInstanceId: string;
+        triggerValueReference: string;
+        processModelId: string;
+        signalReference: string;
+    };
+    messagePaths: {
+        activityReached: string;
+        activityFinished: string;
+        boundaryEventTriggered: string;
+        boundaryEventFinished: string;
+        correlationMetadataChanged: string;
+        cronjobCreated: string;
+        cronjobExecuted: string;
+        cronjobEnabledChanged: string;
+        cronjobStopped: string;
+        cronjobUpdated: string;
+        cronjobRemoved: string;
+        untypedTaskReached: string;
+        untypedTaskFinished: string;
+        endEventFinished: string;
+        externalTaskCreated: string;
+        externalTaskExpired: string;
+        externalTaskFinished: string;
+        externalTaskLocked: string;
+        externalTaskUnlocked: string;
+        intermediateThrowEventTriggered: string;
+        intermediateCatchEventReached: string;
+        intermediateCatchEventFinished: string;
+        manualTaskReached: string;
+        manualTaskFinished: string;
+        processDeployed: string;
+        processUndeployed: string;
+        processInstancesDeleted: string;
+        processInstanceMetadataChanged: string;
+        processExecutableChanged: string;
+        startEventFinished: string;
+        userTaskReached: string;
+        userTaskFinished: string;
+        userTaskReserved: string;
+        userTaskReservationCanceled: string;
+        messageOnProcessInstanceTriggered: string;
+        messageEventTriggeredOnPath: string;
+        messageTriggered: string;
+        signalOnProcessInstanceTriggered: string;
+        signalEventTriggeredOnPath: string;
+        signalTriggered: string;
+        tokenPayloadChange: string;
+        tokenPayloadChangeFinished: string;
+        activityError: string;
+        processStarting: string;
+        processStarted: string;
+        processResumed: string;
+        processOwnerChanged: string;
+        processEnded: string;
+        processError: string;
+        processTerminated: string;
+        gatewayFinished: string;
+        finishUntypedTask: string;
+        untypedTaskWithInstanceIdFinished: string;
+        finishUserTask: string;
+        userTaskWithInstanceIdFinished: string;
+        finishManualTask: string;
+        manualTaskWithInstanceIdFinished: string;
+        endEventReached: string;
+        processInstanceWithIdStarted: string;
+        processInstanceWithIdEnded: string;
+        processInstanceWithIdErrored: string;
+        terminateProcessInstanceWithId: string;
+        processInstanceWithIdTerminated: string;
+        changeProcessInstanceOwner: string;
+        processInstanceOwnerChanged: string;
+    };
+};

package/dist/EngineEvents/index.d.ts

@@ -3,9 +3,9 @@ export * from './EventCallbackTypes';
 export * from './EngineEvent';
 export * from './EngineEventMiddlewares';
 export * from './EventPayloads/index';
-export * from './Subscription';
 /**
  * Only for backwards compatibility.
+ * We'd get a ton of breaking changes without them, when using the SDK with the client or proxy.
  */
 import * as eventPayloads from './EventPayloads/index';
 import * as callbackTypes from './EventCallbackTypes';