nestjs-temporal-core/dist/decorators/activity.decorator.js

Complete NestJS integration for Temporal.io with auto-discovery, declarative scheduling, enhanced monitoring, and enterprise-ready features

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ActivityMethod = exports.Activity = void 0;
const constants_1 = require("../constants");
const logger_1 = require("../utils/logger");
const logger = (0, logger_1.createLogger)('ActivityDecorators');
const Activity = (options) => {
    return (target) => {
        const targetClass = target;
        const activityName = options?.name || targetClass.name;
        logger.debug(`@Activity decorator applied to class: ${targetClass.name}`);
        logger.debug(`Activity name: ${activityName}`);
        logger.debug(`Activity options: ${JSON.stringify(options)}`);
        const metadata = {
            name: activityName,
            className: targetClass.name,
            ...options,
        };
        logger.debug(`Storing activity metadata for ${targetClass.name}: ${JSON.stringify(metadata)}`);
        try {
            Reflect.defineMetadata(constants_1.TEMPORAL_ACTIVITY, metadata, targetClass);
            logger.debug(`Stored activity metadata on class constructor: ${targetClass.name}`);
            Reflect.defineMetadata(constants_1.TEMPORAL_ACTIVITY, metadata, targetClass.prototype);
            logger.debug(`Stored activity metadata on class prototype: ${targetClass.name}`);
            logger.debug(`@Activity decorator successfully applied to ${targetClass.name}`);
        }
        catch (error) {
            logger.error(`Failed to apply @Activity decorator to ${targetClass.name}:`, error);
            throw error;
        }
        return target;
    };
};
exports.Activity = Activity;
const ActivityMethod = (nameOrOptions) => {
    return (target, propertyKey, descriptor) => {
        const className = target.constructor.name;
        const methodName = propertyKey.toString();
        logger.debug(`@ActivityMethod decorator applied to method: ${className}.${methodName}`);
        logger.debug(`ActivityMethod nameOrOptions: ${JSON.stringify(nameOrOptions)}`);
        let activityName;
        let methodOptions = {};
        if (typeof nameOrOptions === 'string') {
            activityName = nameOrOptions;
            methodOptions = { name: activityName };
            logger.debug(`Using provided string name: ${activityName}`);
        }
        else if (nameOrOptions &&
            typeof nameOrOptions.name === 'string' &&
            nameOrOptions.name.trim().length > 0) {
            activityName = nameOrOptions.name;
            methodOptions = { ...nameOrOptions };
            logger.debug(`Using name from options object: ${activityName}`);
        }
        else if (nameOrOptions && nameOrOptions.name === '') {
            activityName = '';
            methodOptions = { ...nameOrOptions };
            logger.debug(`Explicit empty name provided`);
        }
        else if (nameOrOptions && !nameOrOptions.name) {
            activityName = methodName;
            methodOptions = { name: activityName, ...nameOrOptions };
            logger.debug(`Using method name as activity name: ${activityName}`);
        }
        else {
            activityName = methodName;
            methodOptions = { name: activityName };
            logger.debug(`Auto-generated activity name from method name: ${activityName}`);
        }
        if (!activityName || activityName.trim().length === 0) {
            const error = 'Activity name cannot be empty';
            logger.error(`@ActivityMethod validation failed for ${className}.${methodName}: ${error}`);
            throw new Error(error);
        }
        logger.verbose(`Activity name resolved to: "${activityName}" for method ${className}.${methodName}`);
        const metadata = {
            name: activityName,
            methodName,
            className,
            ...methodOptions,
        };
        logger.debug(`Final activity metadata for ${className}.${methodName}: ${JSON.stringify(metadata)}`);
        try {
            if (descriptor?.value && typeof descriptor.value === 'function') {
                logger.debug(`Storing @ActivityMethod metadata on method function: ${className}.${methodName}`);
                Reflect.defineMetadata(constants_1.TEMPORAL_ACTIVITY_METHOD, metadata, descriptor.value);
                logger.debug(`Stored activity method metadata on method function: ${className}.${methodName}`);
                const activityMethods = Reflect.getMetadata(constants_1.TEMPORAL_ACTIVITY_METHOD, target.constructor.prototype) ||
                    {};
                activityMethods[methodName] = metadata;
                Reflect.defineMetadata(constants_1.TEMPORAL_ACTIVITY_METHOD, activityMethods, target.constructor.prototype);
                logger.debug(`Stored activity method metadata on class prototype: ${className}`);
                logger.debug(`Total activity methods on ${className}: ${Object.keys(activityMethods).length}`);
                logger.debug(`@ActivityMethod decorator successfully applied to ${className}.${methodName}`);
                return descriptor;
            }
            else {
                logger.debug(`Handling property-style decorator for ${className}.${methodName}`);
                Reflect.defineMetadata(constants_1.TEMPORAL_ACTIVITY_METHOD, metadata, target, propertyKey);
                logger.debug(`Stored activity method metadata on property: ${className}.${methodName}`);
            }
        }
        catch (error) {
            logger.error(`Failed to apply @ActivityMethod decorator to ${className}.${methodName}:`, error);
            throw error;
        }
    };
};
exports.ActivityMethod = ActivityMethod;
//# sourceMappingURL=activity.decorator.js.map