@villedemontreal/workit-core/lib/src/processHandler/simpleCamundaProcessHandler.js

This package provides default and no-op implementations of the WorkIt types for client packages.

"use strict";
/*
 * Copyright (c) 2025 Ville de Montreal. All rights reserved.
 * Licensed under the MIT license.
 * See LICENSE file in the project root for full license information.
 */
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 __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SCProcessHandler = void 0;
const api_1 = require("@opentelemetry/api");
const events_1 = require("events");
const inversify_1 = require("inversify");
require("reflect-metadata");
const core_1 = require("@opentelemetry/core");
const identifiers_1 = require("../config/constants/identifiers");
const container_1 = require("../config/container");
const interceptors_1 = require("../interceptors");
// eslint-disable-next-line import/order
const debug = require("debug");
const log = debug('workit:processHandler');
let SCProcessHandler = class SCProcessHandler extends events_1.EventEmitter {
    constructor(successStrategy, failureStrategy, tracer, config) {
        super();
        /**
         * Camunda Process Handler
         * T = message.body type
         * K = message.properties.customHeaders type
         */
        this.handle = async (message, service) => {
            log('handling message');
            return this._otHandle(message, service);
        };
        this._otHandle = (message, service) => {
            log('handling message with tracing');
            const { properties } = message;
            const identifier = properties.activityId;
            const spanOptions = {
                kind: api_1.SpanKind.SERVER,
                attributes: {
                    'wf.activityId': identifier,
                    'wf.processInstanceId': properties.processInstanceId,
                    'wf.workflowInstanceKey': properties.workflowInstanceKey,
                    'wf.retries': properties.retries || 0,
                    'wf.topicName': properties.topicName,
                    'worker.id': properties.workerId,
                },
            };
            const ctx = this._propagation.extractFromMessage(message) || api_1.context.active();
            const span = this._tracer.startSpan(identifier, spanOptions, ctx);
            const rpcMetadata = {
                type: core_1.RPCType.HTTP,
                span,
            };
            const requestContext = (0, core_1.setRPCMetadata)(api_1.trace.setSpan(ctx, span), rpcMetadata);
            return api_1.context.with(requestContext, () => {
                api_1.context.bind(api_1.context.active(), this);
                if (properties.businessKey) {
                    span.setAttribute('wf.businessKey', properties.businessKey);
                }
                return this._handler(message, service, () => span.end());
            });
        };
        this._handler = async (message, service, callback) => {
            let msg = message;
            const { properties } = message;
            try {
                this.emit('message', msg);
                const workflowCriteria = {
                    bpmnProcessId: properties.bpmnProcessId,
                    version: properties.workflowDefinitionVersion,
                };
                const task = container_1.IoC.getTask(properties.activityId, workflowCriteria);
                msg = await interceptors_1.Interceptors.execute(this._config.interceptors, message);
                msg = await task.execute(msg);
                await this._success.handle(msg, service);
                this.emit('message-handled', null, msg);
            }
            catch (e) {
                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                log(typeof e === 'object' ? e.message : e);
                await this._failure.handle(e, message, service);
                this.emit('message-handled', e, message);
            }
            finally {
                if (callback) {
                    callback();
                }
            }
        };
        this._tracer = tracer;
        this._config = config || {};
        this._propagation = this._config.propagation || container_1.IoC.get(identifiers_1.SERVICE_IDENTIFIER.tracer_propagator);
        this._success = successStrategy;
        this._failure = failureStrategy;
    }
};
SCProcessHandler = __decorate([
    (0, inversify_1.injectable)(),
    __param(0, (0, inversify_1.inject)(identifiers_1.SERVICE_IDENTIFIER.success_strategy)),
    __param(1, (0, inversify_1.inject)(identifiers_1.SERVICE_IDENTIFIER.failure_strategy)),
    __param(2, (0, inversify_1.inject)(identifiers_1.SERVICE_IDENTIFIER.tracer)),
    __param(3, (0, inversify_1.inject)(identifiers_1.SERVICE_IDENTIFIER.process_handler_config)),
    __param(3, (0, inversify_1.optional)()),
    __metadata("design:paramtypes", [Object, Object, Object, Object])
], SCProcessHandler);
exports.SCProcessHandler = SCProcessHandler;
container_1.kernel.bind(identifiers_1.SERVICE_IDENTIFIER.process_handler).to(SCProcessHandler);
//# sourceMappingURL=simpleCamundaProcessHandler.js.map