nestjs-temporal-core/dist/utils/validation.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.ServiceInitializationUtils = void 0;
exports.validateWorkflowId = validateWorkflowId;
exports.validateSignalName = validateSignalName;
exports.validateQueryName = validateQueryName;
exports.validateWorkflowType = validateWorkflowType;
exports.validateActivityName = validateActivityName;
exports.isValidCronExpression = isValidCronExpression;
exports.isValidIntervalExpression = isValidIntervalExpression;
require("reflect-metadata");
const logger_1 = require("./logger");
const logger = (0, logger_1.createLogger)('ValidationUtils');
function validateWorkflowId(workflowId) {
    if (!workflowId || workflowId.trim().length === 0) {
        logger.debug(`Workflow ID validation failed: "${workflowId}"`);
        throw new Error('Workflow ID is required and cannot be empty');
    }
    logger.debug(`Workflow ID validation passed: "${workflowId}"`);
}
function validateSignalName(signalName) {
    if (!signalName || signalName.trim().length === 0) {
        logger.debug(`Signal name validation failed: "${signalName}"`);
        throw new Error('Signal name is required and cannot be empty');
    }
    if (signalName.includes(' ') || signalName.includes('\n') || signalName.includes('\t')) {
        logger.debug(`Signal name validation failed: "${signalName}" (contains whitespace)`);
        throw new Error(`Invalid signal name: "${signalName}". Signal names cannot contain whitespace.`);
    }
    logger.debug(`Signal name validation passed: "${signalName}"`);
}
function validateQueryName(queryName) {
    if (!queryName || queryName.trim().length === 0) {
        logger.debug(`Query name validation failed: "${queryName}"`);
        throw new Error('Query name is required and cannot be empty');
    }
    if (queryName.includes(' ') || queryName.includes('\n') || queryName.includes('\t')) {
        logger.debug(`Query name validation failed: "${queryName}" (contains whitespace)`);
        throw new Error(`Invalid query name: "${queryName}". Query names cannot contain whitespace.`);
    }
    logger.debug(`Query name validation passed: "${queryName}"`);
}
function validateWorkflowType(workflowType) {
    if (!workflowType || workflowType.trim().length === 0) {
        logger.debug(`Workflow type validation failed: "${workflowType}"`);
        throw new Error('Workflow type is required and cannot be empty');
    }
    logger.debug(`Workflow type validation passed: "${workflowType}"`);
}
function validateActivityName(activityName) {
    if (!activityName || activityName.trim().length === 0) {
        logger.debug(`Activity name validation failed: "${activityName}"`);
        throw new Error('Activity name is required and cannot be empty');
    }
    logger.debug(`Activity name validation passed: "${activityName}"`);
}
class ServiceInitializationUtils {
    static async safeInitialize(serviceName, logger, initFunction, allowFailure = true) {
        try {
            logger.debug(`Initializing ${serviceName}...`);
            const result = await initFunction();
            logger.info(`${serviceName} initialized successfully`);
            return result;
        }
        catch (error) {
            if (allowFailure) {
                logger.warn(`${serviceName} initialization failed - continuing in degraded mode: ${error.message}`);
                return null;
            }
            else {
                logger.error(`${serviceName} initialization failed: ${error.message}`);
                throw error;
            }
        }
    }
}
exports.ServiceInitializationUtils = ServiceInitializationUtils;
function isValidCronExpression(expression) {
    if (!expression || typeof expression !== 'string') {
        return false;
    }
    const parts = expression
        .trim()
        .split(/\s+/)
        .filter((part) => part.length > 0);
    if (parts.length < 5 || parts.length > 6) {
        return false;
    }
    if (/^\s\d/.test(expression) && !/^\s\s+/.test(expression)) {
        return false;
    }
    const validCronRegex = /^[\d\*\-,\/\?LW]+$/;
    for (let i = 0; i < parts.length; i++) {
        const part = parts[i];
        if (/[@&#]/.test(part)) {
            return false;
        }
        if (part !== '*' && !validCronRegex.test(part)) {
            return false;
        }
        if (parts.length === 6 && i === 0) {
            if (part !== '*' && /^\d+$/.test(part) && parseInt(part, 10) > 59) {
                return false;
            }
        }
    }
    return true;
}
function isValidIntervalExpression(expression) {
    if (!expression || typeof expression !== 'string') {
        return false;
    }
    const intervalRegex = /^\d+(ms|[smhd])$/;
    return intervalRegex.test(expression.trim());
}
//# sourceMappingURL=validation.js.map