@nest-omni/core 3.1.1-10 → 3.1.1-11

package/common/boilerplate.polyfill.d.ts

@@ -35,5 +35,16 @@ declare module 'typeorm' {
         leftJoin<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
         innerJoinAndSelect<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
         innerJoin<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        iterate(this: SelectQueryBuilder<Entity>, options?: {
+            batchSize?: number;
+        }): AsyncIterableIterator<Entity[]>;
+        eachBatch(this: SelectQueryBuilder<Entity>, callback: (item: Entity) => Promise<void> | void, options?: {
+            batchSize?: number;
+            mode?: 'single';
+        }): Promise<void>;
+        eachBatch(this: SelectQueryBuilder<Entity>, callback: (items: Entity[]) => Promise<void> | void, options?: {
+            batchSize?: number;
+            mode?: 'batch';
+        }): Promise<void>;
     }
 }

package/common/boilerplate.polyfill.js

@@ -8,6 +8,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 require("source-map-support/register");
 const lodash_1 = require("lodash");
@@ -75,3 +88,47 @@ typeorm_1.SelectQueryBuilder.prototype.withTenant = function (tenantId, tenantFi
     }
     return this;
 };
+typeorm_1.SelectQueryBuilder.prototype.iterate = function (options) {
+    return __asyncGenerator(this, arguments, function* () {
+        const batchSize = (options === null || options === void 0 ? void 0 : options.batchSize) || 100;
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const batch = yield __await(this.clone().skip(offset).take(batchSize).getMany());
+            if (batch.length > 0) {
+                yield yield __await(batch);
+                offset += batchSize;
+                hasMore = batch.length === batchSize;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+    });
+};
+typeorm_1.SelectQueryBuilder.prototype.eachBatch = function (callback, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const batchSize = (options === null || options === void 0 ? void 0 : options.batchSize) || 100;
+        const mode = (options === null || options === void 0 ? void 0 : options.mode) || 'batch';
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const batch = yield this.clone().skip(offset).take(batchSize).getMany();
+            if (batch.length > 0) {
+                if (mode === 'single') {
+                    for (const item of batch) {
+                        yield callback(item);
+                    }
+                }
+                else {
+                    yield callback(batch);
+                }
+                offset += batchSize;
+                hasMore = batch.length === batchSize;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "3.1.1-10",
+  "version": "3.1.1-11",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",
@@ -69,8 +69,6 @@
     "@dataui/crud": "^5.3.0",
     "@dataui/crud-typeorm": "^5.3.0",
     "@keyv/redis": "^5.1.3",
-    "@songkeys/nestjs-redis": "^11.0.0",
-    "@songkeys/nestjs-redis-health": "^11.0.0",
     "@nestjs/bull": "^11.0.0",
     "@nestjs/cache-manager": "^3.0.0",
     "@nestjs/common": "^11.0.0",
@@ -81,13 +79,15 @@
     "@nestjs/swagger": "^11.0.0",
     "@nestjs/terminus": "^11.0.0",
     "@nestjs/typeorm": "^11.0.0",
+    "@songkeys/nestjs-redis": "^11.0.0",
+    "@songkeys/nestjs-redis-health": "^11.0.0",
     "bcrypt": "^6.0.0",
     "bull": "^4.16.0",
     "cache-manager": "^7.0.0",
-    "keyv": "^5.5.3",
     "connect-redis": "^9.0.0",
     "express": "^5.0.0",
     "express-session": "^1.18.0",
+    "keyv": "^5.5.3",
     "mime-types": "^3.0.0",
     "mysql2": "^3.0.0",
     "nestjs-cls": "^6.0.0",

package/setup/index.d.ts

@@ -2,5 +2,5 @@ export * from './bootstrap.setup';
 export * from './mode.setup';
 export * from './worker.decorator';
 export * from './schedule.decorator';
-export * from './redis.lock.service';
-export * from './redis.lock.decorator';
+export * from './redis-lock.service';
+export * from './redis-lock.decorator';

package/setup/index.js

@@ -18,5 +18,5 @@ __exportStar(require("./bootstrap.setup"), exports);
 __exportStar(require("./mode.setup"), exports);
 __exportStar(require("./worker.decorator"), exports);
 __exportStar(require("./schedule.decorator"), exports);
-__exportStar(require("./redis.lock.service"), exports);
-__exportStar(require("./redis.lock.decorator"), exports);
+__exportStar(require("./redis-lock.service"), exports);
+__exportStar(require("./redis-lock.decorator"), exports);

package/setup/{redis.lock.decorator.d.ts → redis-lock.decorator.d.ts}

@@ -1,4 +1,4 @@
-import type { LockOptions } from './redis.lock.service';
+import type { LockOptions } from './redis-lock.service';
 export declare function UseRedisLock(lockKey: string, options?: LockOptions & {
     skipReturnValue?: any;
 }): MethodDecorator;

package/setup/redis-lock.decorator.js

@@ -0,0 +1,78 @@
+"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.UseRedisLock = UseRedisLock;
+exports.UseRedisLockOrSkip = UseRedisLockOrSkip;
+const common_1 = require("@nestjs/common");
+function UseRedisLock(lockKey, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const logger = new common_1.Logger(`RedisLock:${String(propertyKey)}`);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const { RedisLockService } = yield Promise.resolve().then(() => require('./redis-lock.service'));
+                let lockService = RedisLockService.getGlobalInstance();
+                if (!lockService) {
+                    try {
+                        lockService = RedisLockService.getOrCreateGlobalInstance();
+                        logger.debug('RedisLockService auto-initialized for decorator');
+                    }
+                    catch (error) {
+                        logger.error(`Failed to auto-initialize RedisLockService: ${error.message}. ` +
+                            `Please ensure Redis is accessible or call configureRedisLock() in your application setup.`);
+                        throw new Error(`RedisLockService initialization failed. Please check Redis connection or call configureRedisLock() in your application setup.`);
+                    }
+                }
+                const skipReturnValue = (_a = options.skipReturnValue) !== null && _a !== void 0 ? _a : null;
+                try {
+                    const lockResult = yield lockService.acquireLock(lockKey, options);
+                    if (!lockResult.acquired) {
+                        logger.log(`Lock '${lockKey}' is already held, skipping execution of ${String(propertyKey)}`);
+                        return skipReturnValue;
+                    }
+                    logger.debug(`Lock '${lockKey}' acquired, executing ${String(propertyKey)}`);
+                    try {
+                        return yield originalMethod.apply(this, args);
+                    }
+                    catch (error) {
+                        logger.error(`Error executing ${String(propertyKey)} with lock '${lockKey}':`, error);
+                        throw error;
+                    }
+                    finally {
+                        if (lockResult.autoExtendTimer) {
+                            clearInterval(lockResult.autoExtendTimer);
+                        }
+                        yield lockService.releaseLock(lockKey, lockResult.lockValue, options.keyPrefix);
+                        logger.debug(`Lock '${lockKey}' released`);
+                    }
+                }
+                catch (error) {
+                    if (error.message.includes('ECONNREFUSED') ||
+                        error.message.includes('Redis connection') ||
+                        error.message.includes('RedisLockService initialization failed')) {
+                        logger.error(`Redis connection error in ${String(propertyKey)}: ${error.message}. ` +
+                            `Skipping execution to prevent issues.`);
+                        return skipReturnValue;
+                    }
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+function UseRedisLockOrSkip(lockKey, ttl = 300000) {
+    return UseRedisLock(lockKey, {
+        ttl,
+        skipReturnValue: false,
+    });
+}

package/setup/{redis.lock.service.d.ts → redis-lock.service.d.ts}

@@ -24,6 +24,7 @@ export interface RedisOptions {
 }
 export declare class RedisLockService implements OnModuleInit, OnModuleDestroy {
     private static globalInstance;
+    private static globalConfig;
     private readonly logger;
     private redis;
     private redisOptions;
@@ -33,7 +34,9 @@ export declare class RedisLockService implements OnModuleInit, OnModuleDestroy {
     private readonly defaultOptions;
     private readonly defaultRedisOptions;
     constructor(redisOptions?: RedisOptions);
+    static initializeGlobalInstance(config?: RedisOptions): RedisLockService;
     static getGlobalInstance(): RedisLockService | null;
+    static getOrCreateGlobalInstance(): RedisLockService;
     static setGlobalInstance(instance: RedisLockService): void;
     onModuleInit(): Promise<void>;
     onModuleDestroy(): Promise<void>;

package/setup/{redis.lock.service.js → redis-lock.service.js}

@@ -49,14 +49,37 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
                 return true;
             },
         };
-        this.redisOptions = Object.assign(Object.assign({}, this.defaultRedisOptions), redisOptions);
+        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;
     }
@@ -332,6 +355,7 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
 };
 exports.RedisLockService = RedisLockService;
 RedisLockService.globalInstance = null;
+RedisLockService.globalConfig = null;
 exports.RedisLockService = RedisLockService = RedisLockService_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [Object])

package/setup/schedule.decorator.d.ts

@@ -1,21 +1,23 @@
 import type { CronOptions } from '@nestjs/schedule';
-export declare function WorkerCron(cronTime: string | Date, options?: CronOptions): MethodDecorator;
-export declare function WorkerInterval(timeout: number, options?: {
-    name?: string;
-}): MethodDecorator;
-export declare function WorkerTimeout(timeout: number, options?: {
-    name?: string;
-}): MethodDecorator;
-export declare function WorkerCronWithLock(cronTime: string | Date, lockKey: string, lockTtl?: number, cronOptions?: CronOptions): MethodDecorator;
-export declare function WorkerIntervalWithLock(timeout: number, lockKey: string, lockTtl?: number, intervalOptions?: {
-    name?: string;
-}): MethodDecorator;
-export declare function WorkerTimeoutWithLock(timeout: number, lockKey: string, lockTtl?: number, timeoutOptions?: {
-    name?: string;
-}): MethodDecorator;
-export declare function WorkerCronAdvanced(cronTime: string | Date, lockKey: string, options?: {
+export interface ScheduleWithLockOptions {
     lockTtl?: number;
-    cronOptions?: CronOptions;
+    retryCount?: number;
+    retryDelay?: number;
+    useExponentialBackoff?: boolean;
+    maxRetryDelay?: number;
     logExecution?: boolean;
-    onError?: (error: Error) => void;
-}): MethodDecorator;
+    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);

package/setup/schedule.decorator.js

@@ -15,113 +15,219 @@ 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_decorator_1 = require("./redis.lock.decorator");
-const common_1 = require("@nestjs/common");
-function WorkerCron(cronTime, options) {
-    if ((0, mode_setup_1.shouldProcessQueues)()) {
-        return (0, schedule_1.Cron)(cronTime, options);
-    }
-    return function (target, propertyKey, descriptor) {
-        return descriptor;
-    };
-}
-function WorkerInterval(timeout, options) {
-    if ((0, mode_setup_1.shouldProcessQueues)()) {
-        return (0, schedule_1.Interval)((options === null || options === void 0 ? void 0 : options.name) || `interval-${timeout}`, timeout);
-    }
-    return function (target, propertyKey, descriptor) {
-        return descriptor;
-    };
-}
-function WorkerTimeout(timeout, options) {
-    if ((0, mode_setup_1.shouldProcessQueues)()) {
-        return (0, schedule_1.Timeout)((options === null || options === void 0 ? void 0 : options.name) || `timeout-${timeout}`, timeout);
-    }
-    return function (target, propertyKey, descriptor) {
-        return descriptor;
-    };
+const redis_lock_service_1 = require("./redis-lock.service");
+function generateLockKey(className, methodName) {
+    return `${className}.${methodName}`;
 }
-function WorkerCronWithLock(cronTime, lockKey, lockTtl = 300000, cronOptions) {
-    if (!(0, mode_setup_1.shouldProcessQueues)()) {
-        return function (target, propertyKey, descriptor) {
-            return descriptor;
-        };
-    }
-    return function (target, propertyKey, descriptor) {
-        (0, schedule_1.Cron)(cronTime, cronOptions)(target, propertyKey, descriptor);
-        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, lockTtl)(target, propertyKey, descriptor);
-        return descriptor;
-    };
+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 WorkerIntervalWithLock(timeout, lockKey, lockTtl, intervalOptions) {
-    if (!(0, mode_setup_1.shouldProcessQueues)()) {
-        return function (target, propertyKey, descriptor) {
-            return descriptor;
-        };
-    }
-    const ttl = lockTtl !== null && lockTtl !== void 0 ? lockTtl : timeout;
+function createWorkerDecorator(baseDecorator, decoratorName) {
     return function (target, propertyKey, descriptor) {
-        (0, schedule_1.Interval)((intervalOptions === null || intervalOptions === void 0 ? void 0 : intervalOptions.name) || `interval-with-lock-${timeout}`, timeout)(target, propertyKey, descriptor);
-        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, ttl)(target, propertyKey, descriptor);
-        return descriptor;
-    };
-}
-function WorkerTimeoutWithLock(timeout, lockKey, lockTtl = 300000, timeoutOptions) {
-    if (!(0, mode_setup_1.shouldProcessQueues)()) {
-        return function (target, propertyKey, descriptor) {
-            return 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);
+            });
         };
-    }
-    return function (target, propertyKey, descriptor) {
-        (0, schedule_1.Timeout)((timeoutOptions === null || timeoutOptions === void 0 ? void 0 : timeoutOptions.name) || `timeout-with-lock-${timeout}`, timeout)(target, propertyKey, descriptor);
-        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, lockTtl)(target, propertyKey, descriptor);
+        baseDecorator(target, propertyKey, descriptor);
         return descriptor;
     };
 }
-function WorkerCronAdvanced(cronTime, lockKey, options = {}) {
-    if (!(0, mode_setup_1.shouldProcessQueues)()) {
-        return function (target, propertyKey, descriptor) {
-            return descriptor;
-        };
-    }
-    const { lockTtl = 300000, cronOptions, logExecution = true, onError, } = options;
+function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, options = {}) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
-        const logger = new common_1.Logger(`Scheduler:${String(propertyKey)}`);
+        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 {
-                    if (logExecution) {
-                        logger.log(`Starting scheduled task: ${String(propertyKey)}`);
+                    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}"`);
+                        }
                     }
-                    const result = yield originalMethod.apply(this, args);
-                    if (logExecution) {
+                    try {
+                        const result = yield executeWithRetry(() => originalMethod.apply(this, args), {
+                            retryCount,
+                            retryDelay,
+                            useExponentialBackoff,
+                            maxRetryDelay,
+                            logger,
+                            taskName: `${className}.${methodName}`,
+                        });
                         const duration = Date.now() - startTime;
-                        logger.log(`Completed scheduled task: ${String(propertyKey)} (${duration}ms)`);
+                        if (logExecution) {
+                            logger.log(`Task completed successfully in ${duration}ms`);
+                        }
+                        if (onSuccess) {
+                            yield onSuccess(duration);
+                        }
+                        return result;
+                    }
+                    finally {
+                        if (lockResult.autoExtendTimer) {
+                            clearInterval(lockResult.autoExtendTimer);
+                        }
+                        yield lockService.releaseLock(resolvedLockKey, lockResult.lockValue, lockKeyPrefix);
+                        if (logExecution) {
+                            logger.debug(`Lock "${fullLockKey}" released`);
+                        }
                     }
-                    return result;
                 }
                 catch (error) {
                     const duration = Date.now() - startTime;
-                    logger.error(`Error in scheduled task: ${String(propertyKey)} (${duration}ms)`, error.stack);
+                    if (logExecution) {
+                        logger.error(`Task failed after ${duration}ms: ${error.message}`, error.stack);
+                    }
                     if (onError) {
-                        try {
-                            onError(error);
-                        }
-                        catch (handlerError) {
-                            logger.error('Error handler threw an error:', handlerError);
-                        }
+                        yield onError(error);
                     }
                     throw error;
                 }
             });
         };
-        (0, schedule_1.Cron)(cronTime, cronOptions)(target, propertyKey, descriptor);
-        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, lockTtl)(target, propertyKey, descriptor);
+        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 = 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/redis.lock.decorator.js

@@ -1,60 +0,0 @@
-"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.UseRedisLock = UseRedisLock;
-exports.UseRedisLockOrSkip = UseRedisLockOrSkip;
-const common_1 = require("@nestjs/common");
-function UseRedisLock(lockKey, options = {}) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const logger = new common_1.Logger(`RedisLock:${String(propertyKey)}`);
-        descriptor.value = function (...args) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const { RedisLockService } = yield Promise.resolve().then(() => require('./redis.lock.service'));
-                const lockService = RedisLockService.getGlobalInstance();
-                if (!lockService) {
-                    logger.error(`RedisLockService global instance not found. ` +
-                        `Please ensure RedisLockService is registered in your application module.`);
-                    throw new Error(`RedisLockService not initialized. Please register it in your module.`);
-                }
-                const skipReturnValue = (_a = options.skipReturnValue) !== null && _a !== void 0 ? _a : null;
-                const lockResult = yield lockService.acquireLock(lockKey, options);
-                if (!lockResult.acquired) {
-                    logger.log(`Lock '${lockKey}' is already held, skipping execution of ${String(propertyKey)}`);
-                    return skipReturnValue;
-                }
-                logger.debug(`Lock '${lockKey}' acquired, executing ${String(propertyKey)}`);
-                try {
-                    return yield originalMethod.apply(this, args);
-                }
-                catch (error) {
-                    logger.error(`Error executing ${String(propertyKey)} with lock '${lockKey}':`, error);
-                    throw error;
-                }
-                finally {
-                    if (lockResult.autoExtendTimer) {
-                        clearInterval(lockResult.autoExtendTimer);
-                    }
-                    yield lockService.releaseLock(lockKey, lockResult.lockValue, options.keyPrefix);
-                    logger.debug(`Lock '${lockKey}' released`);
-                }
-            });
-        };
-        return descriptor;
-    };
-}
-function UseRedisLockOrSkip(lockKey, ttl = 300000) {
-    return UseRedisLock(lockKey, {
-        ttl,
-        skipReturnValue: false,
-    });
-}