@nest-omni/core 2.0.1-9 → 3.1.1-11

package/setup/redis-lock.service.js

@@ -0,0 +1,362 @@
+"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 __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());
+    });
+};
+var RedisLockService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLockService = void 0;
+const common_1 = require("@nestjs/common");
+const ioredis_1 = require("ioredis");
+let RedisLockService = RedisLockService_1 = class RedisLockService {
+    constructor(redisOptions) {
+        this.logger = new common_1.Logger(RedisLockService_1.name);
+        this.redis = null;
+        this.isConnected = false;
+        this.isConnecting = false;
+        this.connectionPromise = null;
+        this.defaultOptions = {
+            ttl: 300000,
+            retryCount: 0,
+            retryDelay: 100,
+            keyPrefix: 'lock',
+            throwOnFailure: false,
+            autoExtend: 0,
+        };
+        this.defaultRedisOptions = {
+            host: process.env.REDIS_HOST || 'localhost',
+            port: parseInt(process.env.REDIS_PORT || '6379', 10),
+            password: process.env.REDIS_PASSWORD,
+            db: parseInt(process.env.REDIS_DB || '0', 10),
+            retryDelay: 2000,
+            maxRetries: 10,
+            reconnectOnError: (err) => {
+                this.logger.warn('Redis reconnection error:', err.message);
+                return true;
+            },
+        };
+        this.redisOptions = redisOptions ||
+            RedisLockService_1.globalConfig || Object.assign({}, this.defaultRedisOptions);
+        if (!RedisLockService_1.globalInstance) {
+            RedisLockService_1.globalInstance = this;
+        }
+    }
+    static initializeGlobalInstance(config) {
+        if (!RedisLockService_1.globalInstance) {
+            new RedisLockService_1(config || RedisLockService_1.globalConfig);
+        }
+        return RedisLockService_1.globalInstance;
+    }
+    static getGlobalInstance() {
+        return RedisLockService_1.globalInstance;
+    }
+    static getOrCreateGlobalInstance() {
+        if (!RedisLockService_1.globalInstance) {
+            if (!RedisLockService_1.globalConfig) {
+                RedisLockService_1.globalConfig = {
+                    host: process.env.REDIS_HOST || 'localhost',
+                    port: parseInt(process.env.REDIS_PORT || '6379', 10),
+                    password: process.env.REDIS_PASSWORD,
+                    db: parseInt(process.env.REDIS_DB || '0', 10),
+                    retryDelay: 2000,
+                    maxRetries: 10,
+                };
+            }
+            return RedisLockService_1.initializeGlobalInstance();
+        }
+        return RedisLockService_1.globalInstance;
+    }
+    static setGlobalInstance(instance) {
+        RedisLockService_1.globalInstance = instance;
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('RedisLockService initialized, will connect on first use');
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.redis) {
+                yield this.redis.quit();
+                this.isConnected = false;
+                this.logger.log('Redis connection closed');
+            }
+        });
+    }
+    acquireLock(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, options = {}) {
+            const redis = yield this.getRedis();
+            const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
+            const lockKey = this.buildLockKey(key, opts.keyPrefix);
+            const lockValue = this.generateLockValue();
+            let attempts = 0;
+            const maxAttempts = opts.retryCount + 1;
+            while (attempts < maxAttempts) {
+                try {
+                    const result = yield redis.set(lockKey, lockValue, 'PX', opts.ttl, 'NX');
+                    if (result === 'OK') {
+                        this.logger.debug(`Lock acquired: ${lockKey} (value: ${lockValue}, ttl: ${opts.ttl}ms)`);
+                        let autoExtendTimer;
+                        if (opts.autoExtend && opts.autoExtend > 0) {
+                            autoExtendTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                                try {
+                                    yield this.extendLock(key, lockValue, opts.ttl, opts.keyPrefix);
+                                }
+                                catch (error) {
+                                    this.logger.error(`Failed to auto-extend lock ${lockKey}:`, error);
+                                }
+                            }), opts.autoExtend);
+                        }
+                        return { acquired: true, lockValue, autoExtendTimer };
+                    }
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        this.logger.debug(`Lock acquisition failed for ${lockKey}, retrying... (${attempts}/${opts.retryCount})`);
+                        yield this.sleep(opts.retryDelay);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
+                    this.logger.error(errorMessage, error.stack);
+                    if (opts.throwOnFailure) {
+                        throw new Error(errorMessage);
+                    }
+                    return { acquired: false, error: errorMessage };
+                }
+            }
+            const failureMessage = `Failed to acquire lock for ${lockKey} after ${attempts} attempts`;
+            this.logger.warn(failureMessage);
+            if (opts.throwOnFailure) {
+                throw new Error(failureMessage);
+            }
+            return { acquired: false, error: failureMessage };
+        });
+    }
+    releaseLock(key_1, lockValue_1) {
+        return __awaiter(this, arguments, void 0, function* (key, lockValue, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `;
+                const result = yield redis.eval(script, 1, lockKey, lockValue);
+                if (result === 1) {
+                    this.logger.debug(`Lock released: ${lockKey}`);
+                    return true;
+                }
+                else {
+                    this.logger.warn(`Lock release failed: ${lockKey} (lock value mismatch or already expired)`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error releasing lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    extendLock(key_1, lockValue_1, ttl_1) {
+        return __awaiter(this, arguments, void 0, function* (key, lockValue, ttl, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("pexpire", KEYS[1], ARGV[2])
+        else
+          return 0
+        end
+      `;
+                const result = yield redis.eval(script, 1, lockKey, lockValue, ttl);
+                if (result === 1) {
+                    this.logger.debug(`Lock extended: ${lockKey} (new ttl: ${ttl}ms)`);
+                    return true;
+                }
+                else {
+                    this.logger.warn(`Lock extension failed: ${lockKey} (lock value mismatch or doesn't exist)`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error extending lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    isLocked(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const exists = yield redis.exists(lockKey);
+                return exists === 1;
+            }
+            catch (error) {
+                this.logger.error(`Error checking lock existence for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    withLock(key_1, fn_1) {
+        return __awaiter(this, arguments, void 0, function* (key, fn, options = {}) {
+            const lockResult = yield this.acquireLock(key, options);
+            if (!lockResult.acquired) {
+                this.logger.warn(`Could not acquire lock for ${key}, skipping execution`);
+                return null;
+            }
+            try {
+                return yield fn();
+            }
+            catch (error) {
+                this.logger.error(`Error executing function with lock ${key}:`, error);
+                throw error;
+            }
+            finally {
+                if (lockResult.autoExtendTimer) {
+                    clearInterval(lockResult.autoExtendTimer);
+                }
+                yield this.releaseLock(key, lockResult.lockValue, options.keyPrefix);
+            }
+        });
+    }
+    getLockInfo(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const [value, ttl] = yield Promise.all([
+                    redis.get(lockKey),
+                    redis.pttl(lockKey),
+                ]);
+                return {
+                    value,
+                    ttl: ttl >= 0 ? ttl : null,
+                };
+            }
+            catch (error) {
+                this.logger.error(`Error getting lock info for ${lockKey}: ${error.message}`, error.stack);
+                return { value: null, ttl: null };
+            }
+        });
+    }
+    forceRelease(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const result = yield redis.del(lockKey);
+                if (result === 1) {
+                    this.logger.debug(`Lock forcefully released: ${lockKey}`);
+                    return true;
+                }
+                else {
+                    this.logger.debug(`No lock found to forcefully release: ${lockKey}`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error force releasing lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    getRedisOptions() {
+        return Object.assign({}, this.redisOptions);
+    }
+    getRedis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.redis && this.isConnected) {
+                return this.redis;
+            }
+            if (this.isConnecting && this.connectionPromise) {
+                return this.connectionPromise;
+            }
+            this.isConnecting = true;
+            this.connectionPromise = this.createRedisConnection()
+                .then((redis) => {
+                this.isConnecting = false;
+                this.isConnected = true;
+                return redis;
+            })
+                .catch((error) => {
+                this.isConnecting = false;
+                this.connectionPromise = null;
+                throw error;
+            });
+            return this.connectionPromise;
+        });
+    }
+    createRedisConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const redis = new ioredis_1.default({
+                    host: this.redisOptions.host,
+                    port: this.redisOptions.port,
+                    password: this.redisOptions.password,
+                    db: this.redisOptions.db,
+                    retryStrategy: (times) => {
+                        this.logger.warn(`Redis connection retry attempt ${times}`);
+                        if (times > (this.redisOptions.maxRetries || 10)) {
+                            this.logger.error('Max retries reached, giving up on Redis connection');
+                            this.isConnected = false;
+                            return undefined;
+                        }
+                        const delay = Math.min(times * (this.redisOptions.retryDelay || 2000), 30000);
+                        this.logger.log(`Retrying Redis connection in ${delay}ms`);
+                        return delay;
+                    },
+                    reconnectOnError: this.redisOptions.reconnectOnError,
+                });
+                const onConnect = () => {
+                    this.logger.log(`Connected to Redis at ${this.redisOptions.host}:${this.redisOptions.port}`);
+                    this.isConnected = true;
+                    resolve(redis);
+                };
+                const onError = (err) => {
+                    this.logger.error('Redis connection error:', err.message);
+                    if (!this.isConnected) {
+                        reject(err);
+                    }
+                };
+                redis.once('connect', onConnect);
+                redis.once('error', onError);
+                this.redis = redis;
+            });
+        });
+    }
+    generateLockValue() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}-${process.pid}`;
+    }
+    buildLockKey(key, prefix = 'lock') {
+        return `${prefix}:${key}`;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+};
+exports.RedisLockService = RedisLockService;
+RedisLockService.globalInstance = null;
+RedisLockService.globalConfig = null;
+exports.RedisLockService = RedisLockService = RedisLockService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], RedisLockService);

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.examples.d.ts

@@ -0,0 +1,18 @@
+export declare class SchedulerExamples {
+    dailyBasicTask(): Promise<void>;
+    sixHourlyTaskWithLock(): Promise<void>;
+    twoHourlyTaskWithOptions(): Promise<void>;
+    hourlySmartTask(): Promise<void>;
+    nightlySmartTask(): Promise<void>;
+    weeklyReportTask(): Promise<void>;
+    monthlyReportTask(): Promise<void>;
+    checkStatusWithLock(): Promise<void>;
+    checkStatusWithOptions(): Promise<void>;
+    checkStatusSmart(): Promise<void>;
+    syncDataSmart(): Promise<void>;
+    initializeWithLock(): Promise<void>;
+    warmUpWithOptions(): Promise<void>;
+    weekdayTask(): Promise<void>;
+    processDataWithRetry(): Promise<void>;
+    private performDataProcessing;
+}

package/setup/schedule.decorator.examples.js

@@ -0,0 +1,255 @@
+"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 __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.SchedulerExamples = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_decorator_1 = require("./schedule.decorator");
+let SchedulerExamples = class SchedulerExamples {
+    dailyBasicTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('执行基本定时任务');
+        });
+    }
+    sixHourlyTaskWithLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('执行带锁的定时任务');
+        });
+    }
+    twoHourlyTaskWithOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('执行带选项的定时任务');
+        });
+    }
+    hourlySmartTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('执行智能定时任务');
+        });
+    }
+    nightlySmartTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('执行夜间智能定时任务');
+        });
+    }
+    weeklyReportTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('生成周报');
+        });
+    }
+    monthlyReportTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('生成月报');
+        });
+    }
+    checkStatusWithLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('检查系统状态');
+        });
+    }
+    checkStatusWithOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('检查系统状态（带选项）');
+        });
+    }
+    checkStatusSmart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('智能检查系统状态');
+        });
+    }
+    syncDataSmart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('智能同步数据');
+        });
+    }
+    initializeWithLock() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('初始化系统');
+        });
+    }
+    warmUpWithOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('系统预热');
+        });
+    }
+    weekdayTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('执行工作日任务');
+        });
+    }
+    processDataWithRetry() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('开始处理数据');
+            try {
+                yield this.performDataProcessing();
+            }
+            catch (error) {
+                console.error('数据处理失败:', error);
+                throw error;
+            }
+        });
+    }
+    performDataProcessing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('数据处理完成');
+        });
+    }
+};
+exports.SchedulerExamples = SchedulerExamples;
+__decorate([
+    (0, schedule_decorator_1.WorkerCron)('0 0 * * *'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "dailyBasicTask", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronWithLock)('0 */6 * * *', 'six-hourly-task', 3600000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "sixHourlyTaskWithLock", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronWithLock)('0 */2 * * *', {
+        lockTtl: 5400000,
+        logExecution: true,
+        onError: (error) => console.error('任务执行失败:', error),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "twoHourlyTaskWithOptions", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronSmart)('0 * * * *'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "hourlySmartTask", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronSmart)('30 2 * * *', {
+        lockTtl: 3600000,
+        logExecution: true,
+        onError: (error) => console.error('夜间任务失败:', error),
+        onSuccess: (duration) => console.log(`夜间任务完成，耗时: ${duration}ms`),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "nightlySmartTask", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronAdvanced)('0 0 * * 0', 'weekly-report', {
+        lockTtl: 7200000,
+        logExecution: true,
+        onError: (error) => console.error('周报生成失败:', error),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "weeklyReportTask", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronAdvanced)('0 0 1 * *', {
+        lockTtl: 14400000,
+        logExecution: true,
+        onError: (error) => console.error('月报生成失败:', error),
+        onSuccess: (duration) => console.log(`月报生成完成，耗时: ${duration}ms`),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "monthlyReportTask", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerIntervalWithLock)(60000, 'status-check'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "checkStatusWithLock", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerIntervalWithLock)(300000, {
+        lockTtl: 240000,
+        logExecution: true,
+        onError: (error) => console.error('状态检查失败:', error),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "checkStatusWithOptions", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerIntervalSmart)(120000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "checkStatusSmart", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerIntervalSmart)(600000, {
+        lockTtl: 480000,
+        logExecution: true,
+        onError: (error) => console.error('数据同步失败:', error),
+        onSuccess: (duration) => console.log(`数据同步完成，耗时: ${duration}ms`),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "syncDataSmart", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerTimeoutWithLock)(5000, 'init-task', 10000),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "initializeWithLock", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerTimeoutWithLock)(10000, {
+        lockTtl: 30000,
+        logExecution: true,
+        onError: (error) => console.error('预热任务失败:', error),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "warmUpWithOptions", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronSmart)('0 9 * * 1-5', {
+        lockTtl: 3600000,
+        logExecution: true,
+        onError: (error) => console.error('工作日任务失败:', error),
+        onSuccess: (duration) => {
+            console.log(`工作日任务完成，耗时: ${duration}ms`);
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "weekdayTask", null);
+__decorate([
+    (0, schedule_decorator_1.WorkerCronSmart)('0 */30 * * * *', {
+        lockTtl: 1500000,
+        logExecution: true,
+        onError: (error) => __awaiter(void 0, void 0, void 0, function* () {
+            console.error('数据处理任务失败:', error);
+        }),
+        onSuccess: (duration) => {
+            if (duration > 60000) {
+                console.warn(`数据处理任务耗时较长: ${duration}ms`);
+            }
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SchedulerExamples.prototype, "processDataWithRetry", null);
+exports.SchedulerExamples = SchedulerExamples = __decorate([
+    (0, common_1.Injectable)()
+], SchedulerExamples);