@quanticjs/workflow-kogito 2.1.0

package/dist/KogitoClient.d.ts

@@ -0,0 +1,19 @@
+import { HttpService } from '@nestjs/axios';
+export interface KogitoProcessInstance {
+    id: string;
+    processId: string;
+    state: number;
+    variables: Record<string, unknown>;
+}
+export declare class KogitoClient {
+    private readonly httpService;
+    private readonly logger;
+    constructor(httpService: HttpService);
+    startProcess(processId: string, variables: Record<string, unknown>): Promise<{
+        id: string;
+    }>;
+    signalProcess(processId: string, instanceId: string, signal: string, data?: unknown): Promise<void>;
+    updateVariables(processId: string, instanceId: string, variables: Record<string, unknown>): Promise<void>;
+    abortProcess(processId: string, instanceId: string): Promise<void>;
+    getProcessInstance(processId: string, instanceId: string): Promise<KogitoProcessInstance>;
+}

package/dist/KogitoClient.js

@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var KogitoClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KogitoClient = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = require("@nestjs/axios");
+const rxjs_1 = require("rxjs");
+let KogitoClient = KogitoClient_1 = class KogitoClient {
+    httpService;
+    logger = new common_1.Logger(KogitoClient_1.name);
+    constructor(httpService) {
+        this.httpService = httpService;
+    }
+    async startProcess(processId, variables) {
+        const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.post(`/${processId}`, variables));
+        this.logger.log(`Started process ${processId}, instance: ${data.id}`);
+        return data;
+    }
+    async signalProcess(processId, instanceId, signal, data) {
+        await (0, rxjs_1.firstValueFrom)(this.httpService.post(`/${processId}/${instanceId}/${signal}`, data ?? {}));
+        this.logger.log(`Signaled process ${processId}/${instanceId} with ${signal}`);
+    }
+    async updateVariables(processId, instanceId, variables) {
+        await (0, rxjs_1.firstValueFrom)(this.httpService.put(`/${processId}/${instanceId}`, variables));
+        this.logger.log(`Updated variables for ${processId}/${instanceId}`);
+    }
+    async abortProcess(processId, instanceId) {
+        await (0, rxjs_1.firstValueFrom)(this.httpService.delete(`/${processId}/${instanceId}`));
+        this.logger.log(`Aborted process ${processId}/${instanceId}`);
+    }
+    async getProcessInstance(processId, instanceId) {
+        const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`/${processId}/${instanceId}`));
+        return data;
+    }
+};
+exports.KogitoClient = KogitoClient;
+exports.KogitoClient = KogitoClient = KogitoClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [axios_1.HttpService])
+], KogitoClient);

package/dist/KogitoWorkflowEngine.d.ts

@@ -0,0 +1,13 @@
+import type { WorkflowEngine, WorkflowStartResult } from '@quanticjs/core';
+import { KogitoClient } from './KogitoClient';
+export declare class KogitoWorkflowEngine implements WorkflowEngine {
+    private readonly kogitoClient;
+    private readonly logger;
+    constructor(kogitoClient: KogitoClient);
+    startProcess(processDefinitionId: string, command: object, metadata: {
+        commandType: string;
+        correlationId?: string;
+    }): Promise<WorkflowStartResult>;
+    signalProcess(_processInstanceId: string, _signal: string, _data?: unknown): Promise<void>;
+    abortProcess(_processInstanceId: string): Promise<void>;
+}

package/dist/KogitoWorkflowEngine.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var KogitoWorkflowEngine_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KogitoWorkflowEngine = void 0;
+const common_1 = require("@nestjs/common");
+const KogitoClient_1 = require("./KogitoClient");
+let KogitoWorkflowEngine = KogitoWorkflowEngine_1 = class KogitoWorkflowEngine {
+    kogitoClient;
+    logger = new common_1.Logger(KogitoWorkflowEngine_1.name);
+    constructor(kogitoClient) {
+        this.kogitoClient = kogitoClient;
+    }
+    async startProcess(processDefinitionId, command, metadata) {
+        const variables = {
+            ...JSON.parse(JSON.stringify(command)),
+            __commandType: metadata.commandType,
+        };
+        const { id: processInstanceId } = await this.kogitoClient.startProcess(processDefinitionId, variables);
+        this.logger.log(`Workflow started: process=${processInstanceId}, definition=${processDefinitionId}`);
+        return {
+            workflowInstanceId: processInstanceId,
+            processInstanceId,
+            status: 'STARTED',
+        };
+    }
+    async signalProcess(_processInstanceId, _signal, _data) {
+        throw new Error('signalProcess is not supported — this package only starts Kogito processes');
+    }
+    async abortProcess(_processInstanceId) {
+        throw new Error('abortProcess is not supported — this package only starts Kogito processes');
+    }
+};
+exports.KogitoWorkflowEngine = KogitoWorkflowEngine;
+exports.KogitoWorkflowEngine = KogitoWorkflowEngine = KogitoWorkflowEngine_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [KogitoClient_1.KogitoClient])
+], KogitoWorkflowEngine);

package/dist/KogitoWorkflowModule.d.ts

@@ -0,0 +1,9 @@
+import { DynamicModule } from '@nestjs/common';
+export interface KogitoWorkflowModuleOptions {
+    url: string;
+    requestTimeout?: number;
+    callbackSecret?: string;
+}
+export declare class KogitoWorkflowModule {
+    static forRoot(options: KogitoWorkflowModuleOptions): DynamicModule;
+}

package/dist/KogitoWorkflowModule.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var KogitoWorkflowModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KogitoWorkflowModule = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = require("@nestjs/axios");
+const core_1 = require("@quanticjs/core");
+const KogitoClient_1 = require("./KogitoClient");
+const KogitoWorkflowEngine_1 = require("./KogitoWorkflowEngine");
+const WorkflowCallbackService_1 = require("./WorkflowCallbackService");
+let KogitoWorkflowModule = KogitoWorkflowModule_1 = class KogitoWorkflowModule {
+    static forRoot(options) {
+        return {
+            module: KogitoWorkflowModule_1,
+            imports: [
+                axios_1.HttpModule.register({
+                    baseURL: options.url,
+                    timeout: options.requestTimeout ?? 10000,
+                }),
+            ],
+            providers: [
+                KogitoClient_1.KogitoClient,
+                {
+                    provide: core_1.WORKFLOW_ENGINE,
+                    useClass: KogitoWorkflowEngine_1.KogitoWorkflowEngine,
+                },
+                WorkflowCallbackService_1.WorkflowCallbackService,
+            ],
+            exports: [core_1.WORKFLOW_ENGINE, KogitoClient_1.KogitoClient, WorkflowCallbackService_1.WorkflowCallbackService],
+        };
+    }
+};
+exports.KogitoWorkflowModule = KogitoWorkflowModule;
+exports.KogitoWorkflowModule = KogitoWorkflowModule = KogitoWorkflowModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], KogitoWorkflowModule);

package/dist/WorkflowCallbackService.d.ts

@@ -0,0 +1,12 @@
+import { CommandBus } from '@nestjs/cqrs';
+export interface KogitoCallbackPayload {
+    processInstanceId: string;
+    processId: string;
+    variables: Record<string, unknown>;
+}
+export declare class WorkflowCallbackService {
+    private readonly commandBus;
+    private readonly logger;
+    constructor(commandBus: CommandBus);
+    handle<T>(CommandClass: new (...args: any[]) => object, payload: KogitoCallbackPayload): Promise<T>;
+}

package/dist/WorkflowCallbackService.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var WorkflowCallbackService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowCallbackService = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+let WorkflowCallbackService = WorkflowCallbackService_1 = class WorkflowCallbackService {
+    commandBus;
+    logger = new common_1.Logger(WorkflowCallbackService_1.name);
+    constructor(commandBus) {
+        this.commandBus = commandBus;
+    }
+    async handle(CommandClass, payload) {
+        const { __commandType, ...variables } = payload.variables;
+        const command = Object.assign(new CommandClass(), variables);
+        this.logger.log(`Workflow callback: process=${payload.processId}, instance=${payload.processInstanceId}, dispatching=${CommandClass.name}`);
+        return this.commandBus.execute(command);
+    }
+};
+exports.WorkflowCallbackService = WorkflowCallbackService;
+exports.WorkflowCallbackService = WorkflowCallbackService = WorkflowCallbackService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [cqrs_1.CommandBus])
+], WorkflowCallbackService);

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { KogitoWorkflowModule } from './KogitoWorkflowModule';
+export type { KogitoWorkflowModuleOptions } from './KogitoWorkflowModule';
+export { KogitoClient } from './KogitoClient';
+export type { KogitoProcessInstance } from './KogitoClient';
+export { KogitoWorkflowEngine } from './KogitoWorkflowEngine';
+export { WorkflowCallbackService } from './WorkflowCallbackService';
+export type { KogitoCallbackPayload } from './WorkflowCallbackService';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowCallbackService = exports.KogitoWorkflowEngine = exports.KogitoClient = exports.KogitoWorkflowModule = void 0;
+var KogitoWorkflowModule_1 = require("./KogitoWorkflowModule");
+Object.defineProperty(exports, "KogitoWorkflowModule", { enumerable: true, get: function () { return KogitoWorkflowModule_1.KogitoWorkflowModule; } });
+var KogitoClient_1 = require("./KogitoClient");
+Object.defineProperty(exports, "KogitoClient", { enumerable: true, get: function () { return KogitoClient_1.KogitoClient; } });
+var KogitoWorkflowEngine_1 = require("./KogitoWorkflowEngine");
+Object.defineProperty(exports, "KogitoWorkflowEngine", { enumerable: true, get: function () { return KogitoWorkflowEngine_1.KogitoWorkflowEngine; } });
+var WorkflowCallbackService_1 = require("./WorkflowCallbackService");
+Object.defineProperty(exports, "WorkflowCallbackService", { enumerable: true, get: function () { return WorkflowCallbackService_1.WorkflowCallbackService; } });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@quanticjs/workflow-kogito",
+  "version": "2.1.0",
+  "description": "Kogito workflow engine adapter for @quanticjs/workflow",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --config jest.config.js",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "nestjs",
+    "cqrs",
+    "kogito",
+    "workflow",
+    "bpmn"
+  ],
+  "author": "turkelk",
+  "license": "MIT",
+  "dependencies": {
+    "@nestjs/axios": "^4.0.0",
+    "@quanticjs/core": "^2.1.0",
+    "axios": "^1.6.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "reflect-metadata": "^0.1.13 || ^0.2.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/quanticjs/quanticjs-backend.git",
+    "directory": "packages/workflow-kogito"
+  }
+}