@nest-omni/core 3.1.1-9 → 3.1.2-0

package/setup/bootstrap.setup.js

@@ -0,0 +1,184 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapSetup = bootstrapSetup;
+const Sentry = require("@sentry/nestjs");
+const profiling_node_1 = require("@sentry/profiling-node");
+const dotenv = require("dotenv");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const process = require("process");
+const mode_setup_1 = require("./mode.setup");
+function findValidRootPath() {
+    const getAppRootPath = () => {
+        if (require.main && require.main.filename) {
+            return (0, path_1.dirname)(require.main.filename);
+        }
+        if (process.argv[1]) {
+            return (0, path_1.dirname)(process.argv[1]);
+        }
+        return process.cwd();
+    };
+    const possibleRootPaths = [getAppRootPath(), process.cwd(), __dirname];
+    const envFile = `${process.env.NODE_ENV || ''}.env`;
+    const isTest = process.env.NODE_ENV === 'test';
+    let envFilePath = '';
+    for (const rootPath of possibleRootPaths) {
+        const configPath = (0, path_1.join)(rootPath, 'config');
+        const baseEnvFilePath = (0, path_1.join)(configPath, 'base.env');
+        if (isTest) {
+            envFilePath = (0, path_1.join)(configPath, 'test.env');
+            if ((0, fs_1.existsSync)(envFilePath)) {
+                return { rootPath, baseEnvFilePath, envFilePath };
+            }
+            else {
+                envFilePath = (0, path_1.join)(configPath, 'dev.env');
+                if ((0, fs_1.existsSync)(envFilePath)) {
+                    return { rootPath, baseEnvFilePath, envFilePath };
+                }
+            }
+        }
+        else {
+            envFilePath = (0, path_1.join)(configPath, envFile);
+            if ((0, fs_1.existsSync)(envFilePath)) {
+                return { rootPath, baseEnvFilePath, envFilePath };
+            }
+        }
+    }
+    throw new Error(`No valid .env file: ${envFilePath}`);
+}
+const { envFilePath, rootPath, baseEnvFilePath } = findValidRootPath();
+dotenv.config({ path: [envFilePath, baseEnvFilePath] });
+process.env.ROOT_PATH = rootPath;
+process.env.ENV_FILE_PATH = envFilePath;
+process.env.BASE_ENV_FILE_PATH = baseEnvFilePath;
+const requiredEnvVars = ['SENTRY_DSN', 'API_VERSION', 'NODE_ENV'];
+requiredEnvVars.forEach((envVar) => {
+    if (!process.env[envVar]) {
+        throw new Error(`Missing required environment variable: ${envVar}`);
+    }
+});
+Sentry.init({
+    dsn: process.env.SENTRY_DSN || '',
+    release: process.env.API_VERSION || '',
+    environment: process.env.NODE_ENV || 'unkown',
+    debug: false,
+    sampleRate: 1.0,
+    tracesSampleRate: 0.01,
+    profileSessionSampleRate: 0.01,
+    profileLifecycle: 'trace',
+    sendDefaultPii: true,
+    integrations: [profiling_node_1.nodeProfilingIntegration],
+});
+const crud_1 = require("@dataui/crud");
+crud_1.CrudConfigService.load({
+    auth: {
+        property: 'user',
+    },
+    params: {
+        id: {
+            field: 'id',
+            type: 'string',
+            primary: true,
+        },
+    },
+    query: {
+        limit: 10,
+        alwaysPaginate: true,
+    },
+    routes: {
+        updateOneBase: {
+            allowParamsOverride: false,
+        },
+        deleteOneBase: {
+            returnDeleted: false,
+        },
+        createOneBase: {
+            returnShallow: false,
+        },
+    },
+});
+const core_1 = require("@nestjs/core");
+const nestjs_pino_1 = require("nestjs-pino");
+const session = require("express-session");
+const bodyParse = require("body-parser");
+const compression = require("compression");
+const __1 = require("../");
+const common_1 = require("@nestjs/common");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const nestjs_cls_1 = require("nestjs-cls");
+const class_validator_1 = require("class-validator");
+const setup_1 = require("@sentry/nestjs/setup");
+const vault_1 = require("../vault");
+const dto_1 = require("../common/dto");
+function bootstrapSetup(AppModule, SetupSwagger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield vault_1.VaultConfigLoader.loadVaultConfig();
+        const shouldStartHttp = (0, mode_setup_1.shouldStartHttpServer)();
+        const app = yield core_1.NestFactory.create(AppModule, {
+            bufferLogs: true,
+            autoFlushLogs: true,
+        });
+        const appModuleRef = app.select(AppModule);
+        (0, class_validator_1.useContainer)(appModuleRef, { fallbackOnErrors: true });
+        dto_1.DtoContainer.useContainer(appModuleRef);
+        const configService = app.select(__1.ServiceRegistryModule).get(__1.ApiConfigService);
+        const logger = app.get(nestjs_pino_1.Logger);
+        app.useLogger(logger);
+        app.flushLogs();
+        logger.log(`Application Mode: ${(0, mode_setup_1.getModeDescription)()}`);
+        logger.log(`Environment: ${process.env.NODE_ENV || 'unknown'}`);
+        app.enableShutdownHooks();
+        app.enableVersioning();
+        app.enable('trust proxy');
+        app.use(bodyParse.json({ limit: '50mb' }), new nestjs_cls_1.ClsMiddleware({
+            saveReq: true,
+        }).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
+        const reflector = app.get(core_1.Reflector);
+        app.useGlobalFilters(new setup_1.SentryGlobalFilter(), new __1.HttpExceptionFilter(), new __1.QueryFailedFilter(reflector));
+        app.useGlobalInterceptors(new __1.LanguageInterceptor(), new __1.TranslationInterceptor(), new nestjs_pino_1.LoggerErrorInterceptor());
+        app.useGlobalPipes(new nestjs_i18n_1.I18nValidationPipe({
+            whitelist: true,
+            errorHttpStatusCode: common_1.HttpStatus.UNPROCESSABLE_ENTITY,
+            transform: true,
+            stopAtFirstError: true,
+            validationError: { target: false, value: false },
+        }));
+        if (shouldStartHttp) {
+            if (configService.documentationEnabled && SetupSwagger) {
+                SetupSwagger(app, configService.documentationPath);
+                logger.log(`Swagger docs available at ${configService.documentationPath}`);
+            }
+            if (configService.viewsEnabled) {
+                app.setBaseViewsDir((0, path_1.join)(__1.ApiConfigService.rootPath, 'views'));
+                app.setViewEngine('ejs');
+                logger.log('View engine initialized');
+            }
+            if (configService.sessionEnabled) {
+                app.use(session(configService.sessionConfig));
+                logger.log('Session middleware enabled');
+            }
+            if (configService.corsEnabled) {
+                app.enableCors(configService.corsConfig);
+                logger.log('CORS configuration applied');
+            }
+            const port = configService.appConfig.port;
+            yield app.listen(port);
+            logger.log(`HTTP Server running on ${yield app.getUrl()}`);
+        }
+        else {
+            logger.log('Running in Worker-only mode - HTTP server not started');
+            logger.log('Application is ready to process background tasks');
+            yield app.init();
+        }
+        return app;
+    });
+}

package/setup/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bootstrap.setup';
+export * from './mode.setup';
+export * from './worker.decorator';
+export * from './schedule.decorator';

package/setup/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bootstrap.setup"), exports);
+__exportStar(require("./mode.setup"), exports);
+__exportStar(require("./worker.decorator"), exports);
+__exportStar(require("./schedule.decorator"), exports);

package/setup/mode.setup.d.ts

@@ -0,0 +1,12 @@
+export declare enum ApplicationMode {
+    HTTP = "http",
+    WORKER = "worker",
+    HYBRID = "hybrid"
+}
+export declare function getApplicationMode(): ApplicationMode;
+export declare function shouldProcessQueues(): boolean;
+export declare function shouldStartHttpServer(): boolean;
+export declare function isHttpMode(): boolean;
+export declare function isWorkerMode(): boolean;
+export declare function isHybridMode(): boolean;
+export declare function getModeDescription(): string;

package/setup/mode.setup.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationMode = void 0;
+exports.getApplicationMode = getApplicationMode;
+exports.shouldProcessQueues = shouldProcessQueues;
+exports.shouldStartHttpServer = shouldStartHttpServer;
+exports.isHttpMode = isHttpMode;
+exports.isWorkerMode = isWorkerMode;
+exports.isHybridMode = isHybridMode;
+exports.getModeDescription = getModeDescription;
+var ApplicationMode;
+(function (ApplicationMode) {
+    ApplicationMode["HTTP"] = "http";
+    ApplicationMode["WORKER"] = "worker";
+    ApplicationMode["HYBRID"] = "hybrid";
+})(ApplicationMode || (exports.ApplicationMode = ApplicationMode = {}));
+function getApplicationMode() {
+    const mode = (process.env.APP_MODE || process.env.MODE || 'hybrid')
+        .toLowerCase()
+        .trim();
+    switch (mode) {
+        case 'http':
+            return ApplicationMode.HTTP;
+        case 'worker':
+            return ApplicationMode.WORKER;
+        case 'hybrid':
+        default:
+            return ApplicationMode.HYBRID;
+    }
+}
+function shouldProcessQueues() {
+    const mode = getApplicationMode();
+    return mode === ApplicationMode.WORKER || mode === ApplicationMode.HYBRID;
+}
+function shouldStartHttpServer() {
+    const mode = getApplicationMode();
+    return mode === ApplicationMode.HTTP || mode === ApplicationMode.HYBRID;
+}
+function isHttpMode() {
+    return getApplicationMode() === ApplicationMode.HTTP;
+}
+function isWorkerMode() {
+    return getApplicationMode() === ApplicationMode.WORKER;
+}
+function isHybridMode() {
+    return getApplicationMode() === ApplicationMode.HYBRID;
+}
+function getModeDescription() {
+    const mode = getApplicationMode();
+    switch (mode) {
+        case ApplicationMode.HTTP:
+            return 'HTTP-only mode (no background workers)';
+        case ApplicationMode.WORKER:
+            return 'Worker-only mode (no HTTP server)';
+        case ApplicationMode.HYBRID:
+            return 'Hybrid mode (HTTP server + background workers)';
+        default:
+            return 'Unknown mode';
+    }
+}

package/setup/schedule.decorator.d.ts

@@ -0,0 +1,23 @@
+import type { CronOptions } from '@nestjs/schedule';
+export interface ScheduleWithLockOptions {
+    lockTtl?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    useExponentialBackoff?: boolean;
+    maxRetryDelay?: number;
+    logExecution?: boolean;
+    lockKeyPrefix?: string;
+    autoExtendLock?: number;
+    onSuccess?: (duration: number) => void | Promise<void>;
+    onError?: (error: Error) => void | Promise<void>;
+    skipIfLocked?: boolean;
+}
+export declare function WorkerCron(cronTime: string | Date, options?: CronOptions): MethodDecorator;
+export declare function WorkerInterval(timeout: number, name?: string): MethodDecorator;
+export declare function WorkerTimeout(timeout: number, name?: string): MethodDecorator;
+export declare function WorkerCronWithLock(cronTime: string | Date, lockKeyOrOptions: string | ScheduleWithLockOptions, lockTtl?: number, cronOptions?: CronOptions): MethodDecorator;
+export declare function WorkerIntervalWithLock(timeout: number, lockKeyOrOptions: string | ScheduleWithLockOptions, lockTtl?: number): MethodDecorator;
+export declare function WorkerTimeoutWithLock(timeout: number, lockKeyOrOptions: string | ScheduleWithLockOptions, lockTtl?: number): MethodDecorator;
+export declare function WorkerCronSmart(cronTime: string | Date, options?: ScheduleWithLockOptions, cronOptions?: CronOptions): MethodDecorator;
+export declare function WorkerIntervalSmart(timeout: number, options?: ScheduleWithLockOptions): MethodDecorator;
+export declare function WorkerCronAdvanced(cronTime: string | Date, lockKeyOrOptions: string | ScheduleWithLockOptions, options?: ScheduleWithLockOptions, cronOptions?: CronOptions): MethodDecorator;

package/setup/schedule.decorator.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerCron = WorkerCron;
+exports.WorkerInterval = WorkerInterval;
+exports.WorkerTimeout = WorkerTimeout;
+exports.WorkerCronWithLock = WorkerCronWithLock;
+exports.WorkerIntervalWithLock = WorkerIntervalWithLock;
+exports.WorkerTimeoutWithLock = WorkerTimeoutWithLock;
+exports.WorkerCronSmart = WorkerCronSmart;
+exports.WorkerIntervalSmart = WorkerIntervalSmart;
+exports.WorkerCronAdvanced = WorkerCronAdvanced;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const mode_setup_1 = require("./mode.setup");
+const redis_lock_service_1 = require("../redis-lock/redis-lock.service");
+function generateLockKey(className, methodName) {
+    return `${className}.${methodName}`;
+}
+function executeWithRetry(fn, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logger, taskName, } = options;
+        let lastError;
+        let attempt = 0;
+        while (attempt <= retryCount) {
+            try {
+                return yield fn();
+            }
+            catch (error) {
+                lastError = error;
+                attempt++;
+                if (attempt <= retryCount) {
+                    let delay = retryDelay;
+                    if (useExponentialBackoff) {
+                        delay = Math.min(retryDelay * Math.pow(2, attempt - 1), maxRetryDelay);
+                    }
+                    logger.warn(`Task "${taskName}" failed (attempt ${attempt}/${retryCount + 1}), ` +
+                        `retrying in ${delay}ms... Error: ${error.message}`);
+                    yield new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError;
+    });
+}
+function createWorkerDecorator(baseDecorator, decoratorName) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    return;
+                }
+                return originalMethod.apply(this, args);
+            });
+        };
+        baseDecorator(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        const logger = new common_1.Logger(`${className}.${methodName}`);
+        const resolvedLockKey = typeof lockKey === 'function' ? lockKey() : lockKey;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    return;
+                }
+                const lockService = redis_lock_service_1.RedisLockService.getOrCreateGlobalInstance();
+                const { lockTtl = 3600000, retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                const fullLockKey = `${lockKeyPrefix}:${resolvedLockKey}`;
+                const startTime = Date.now();
+                if (logExecution) {
+                    logger.log(`Task starting...`);
+                }
+                try {
+                    const lockResult = yield lockService.acquireLock(resolvedLockKey, {
+                        ttl: lockTtl,
+                        keyPrefix: lockKeyPrefix,
+                        autoExtend: autoExtendLock,
+                    });
+                    if (!lockResult.acquired) {
+                        if (skipIfLocked) {
+                            logger.debug(`Lock "${fullLockKey}" is held by another instance, skipping execution`);
+                            return null;
+                        }
+                        else {
+                            throw new Error(`Failed to acquire lock "${fullLockKey}"`);
+                        }
+                    }
+                    try {
+                        const result = yield executeWithRetry(() => originalMethod.apply(this, args), {
+                            retryCount,
+                            retryDelay,
+                            useExponentialBackoff,
+                            maxRetryDelay,
+                            logger,
+                            taskName: `${className}.${methodName}`,
+                        });
+                        const duration = Date.now() - startTime;
+                        if (logExecution) {
+                            logger.log(`Task completed successfully in ${duration}ms`);
+                        }
+                        if (onSuccess) {
+                            yield onSuccess.call(this, duration);
+                        }
+                        return result;
+                    }
+                    finally {
+                        if (lockResult.autoExtendTimer) {
+                            clearInterval(lockResult.autoExtendTimer);
+                        }
+                        yield lockService.releaseLock(resolvedLockKey, lockResult.lockValue, lockKeyPrefix);
+                        if (logExecution) {
+                            logger.debug(`Lock "${fullLockKey}" released`);
+                        }
+                    }
+                }
+                catch (error) {
+                    const duration = Date.now() - startTime;
+                    if (logExecution) {
+                        logger.error(`Task failed after ${duration}ms: ${error.message}`, error.stack);
+                    }
+                    if (onError) {
+                        yield onError.call(this, error);
+                    }
+                    throw error;
+                }
+            });
+        };
+        baseDecorator(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function WorkerCron(cronTime, options) {
+    return createWorkerDecorator((0, schedule_1.Cron)(cronTime, options), 'WorkerCron');
+}
+function WorkerInterval(timeout, name) {
+    if (name) {
+        return createWorkerDecorator((0, schedule_1.Interval)(name, timeout), 'WorkerInterval');
+    }
+    return createWorkerDecorator((0, schedule_1.Interval)(timeout), 'WorkerInterval');
+}
+function WorkerTimeout(timeout, name) {
+    if (name) {
+        return createWorkerDecorator((0, schedule_1.Timeout)(name, timeout), 'WorkerTimeout');
+    }
+    return createWorkerDecorator((0, schedule_1.Timeout)(timeout), 'WorkerTimeout');
+}
+function WorkerCronWithLock(cronTime, lockKeyOrOptions, lockTtl, cronOptions) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let options;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            options = { lockTtl: lockTtl || 3600000 };
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            options = lockKeyOrOptions;
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronWithLock', lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function WorkerIntervalWithLock(timeout, lockKeyOrOptions, lockTtl) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let options;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            options = { lockTtl: lockTtl || Math.floor(timeout * 0.8) };
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            options = Object.assign({ lockTtl: Math.floor(timeout * 0.8) }, lockKeyOrOptions);
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalWithLock', lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function WorkerTimeoutWithLock(timeout, lockKeyOrOptions, lockTtl) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let options;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            options = { lockTtl: lockTtl || 300000 };
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            options = Object.assign({ lockTtl: 300000 }, lockKeyOrOptions);
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Timeout)(timeout), 'WorkerTimeoutWithLock', lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function WorkerCronSmart(cronTime, options = {}, cronOptions) {
+    return function (target, propertyKey, descriptor) {
+        const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+        return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronSmart', lockKey, Object.assign({ lockTtl: 3600000, logExecution: true }, options))(target, propertyKey, descriptor);
+    };
+}
+function WorkerIntervalSmart(timeout, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalSmart', lockKey, Object.assign({ lockTtl: Math.floor(timeout * 0.8), logExecution: true }, options))(target, propertyKey, descriptor);
+    };
+}
+function WorkerCronAdvanced(cronTime, lockKeyOrOptions, options, cronOptions) {
+    return function (target, propertyKey, descriptor) {
+        let lockKey;
+        let finalOptions;
+        if (typeof lockKeyOrOptions === 'string') {
+            lockKey = lockKeyOrOptions;
+            finalOptions = Object.assign({ lockTtl: 3600000, logExecution: true }, options);
+        }
+        else {
+            lockKey = generateLockKey(target.constructor.name, String(propertyKey));
+            finalOptions = Object.assign({ lockTtl: 3600000, logExecution: true }, lockKeyOrOptions);
+        }
+        return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronAdvanced', lockKey, finalOptions)(target, propertyKey, descriptor);
+    };
+}

package/setup/worker.decorator.d.ts

@@ -0,0 +1,14 @@
+export declare function WorkerProcessor(queueName?: string): ClassDecorator;
+export declare function WorkerProcess(name?: string): MethodDecorator;
+export declare function WorkerOnQueueActive(): MethodDecorator;
+export declare function WorkerOnQueueCompleted(): MethodDecorator;
+export declare function WorkerOnQueueProgress(): MethodDecorator;
+export declare function WorkerOnQueueFailed(): MethodDecorator;
+export declare function WorkerOnQueueError(): MethodDecorator;
+export declare function WorkerOnQueueWaiting(): MethodDecorator;
+export declare function WorkerOnQueueStalled(): MethodDecorator;
+export declare function WorkerOnQueueRemoved(): MethodDecorator;
+export declare function WorkerOnQueueCleaned(): MethodDecorator;
+export declare function WorkerOnQueueDrained(): MethodDecorator;
+export declare function WorkerOnQueuePaused(): MethodDecorator;
+export declare function WorkerOnQueueResumed(): MethodDecorator;