@m16khb/nestjs-sidequest 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1037 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var core = require('@nestjs/core');
+var sidequest = require('sidequest');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/constants.ts
+var SIDEQUEST_MODULE_OPTIONS = Symbol("SIDEQUEST_MODULE_OPTIONS");
+var SIDEQUEST_ENGINE = Symbol("SIDEQUEST_ENGINE");
+var PROCESSOR_METADATA_KEY = Symbol("sidequest:processor");
+var ON_JOB_METADATA_KEY = Symbol("sidequest:on-job");
+var RETRY_OPTIONS_METADATA_KEY = Symbol("sidequest:retry");
+var ON_JOB_COMPLETE_METADATA_KEY = Symbol("sidequest:on-job-complete");
+var ON_JOB_FAILED_METADATA_KEY = Symbol("sidequest:on-job-failed");
+var QUEUE_TOKEN_PREFIX = "SIDEQUEST_QUEUE_";
+function getQueueToken(queueName) {
+  return `${QUEUE_TOKEN_PREFIX}${queueName}`;
+}
+__name(getQueueToken, "getQueueToken");
+var DEFAULT_QUEUE_NAME = "default";
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_CONCURRENCY = 10;
+function _ts_decorate(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;
+}
+__name(_ts_decorate, "_ts_decorate");
+exports.SidequestAdapter = class _SidequestAdapter {
+  static {
+    __name(this, "SidequestAdapter");
+  }
+  logger = new common.Logger(_SidequestAdapter.name);
+  isStarted = false;
+  registeredJobs = /* @__PURE__ */ new Map();
+  /**
+  * Sidequest 엔진 시작
+  */
+  async start(options) {
+    if (this.isStarted) {
+      this.logger.warn("Sidequest engine is already started");
+      return;
+    }
+    this.logger.log("Starting Sidequest engine...");
+    try {
+      const config = {
+        backend: {
+          driver: options.backend.driver,
+          config: options.backend.config
+        }
+      };
+      if (options.queues) {
+        config.queues = options.queues.map((q) => ({
+          name: q.name,
+          concurrency: q.concurrency,
+          priority: q.priority,
+          state: q.state
+        }));
+      }
+      if (options.maxConcurrentJobs !== void 0) {
+        config.maxConcurrentJobs = options.maxConcurrentJobs;
+      }
+      if (options.minThreads !== void 0) {
+        config.minThreads = options.minThreads;
+      }
+      if (options.maxThreads !== void 0) {
+        config.maxThreads = options.maxThreads;
+      }
+      if (options.jobPollingInterval !== void 0) {
+        config.jobPollingInterval = options.jobPollingInterval;
+      }
+      if (options.releaseStaleJobsIntervalMin !== void 0) {
+        config.releaseStaleJobsIntervalMin = options.releaseStaleJobsIntervalMin;
+      }
+      if (options.cleanupFinishedJobsIntervalMin !== void 0) {
+        config.cleanupFinishedJobsIntervalMin = options.cleanupFinishedJobsIntervalMin;
+      }
+      if (options.logger) {
+        config.logger = {
+          level: options.logger.level ?? "info",
+          json: options.logger.json ?? false
+        };
+      }
+      if (options.dashboard) {
+        config.dashboard = options.dashboard;
+      }
+      await sidequest.Sidequest.start(config);
+      this.isStarted = true;
+      this.logger.log("Sidequest engine started");
+    } catch (error) {
+      this.logger.error("Failed to start Sidequest engine", error);
+      throw error;
+    }
+  }
+  /**
+  * Sidequest 엔진 종료
+  */
+  async shutdown() {
+    if (!this.isStarted) {
+      return;
+    }
+    this.logger.log("Stopping Sidequest engine...");
+    try {
+      await sidequest.Sidequest.stop();
+      this.isStarted = false;
+      this.logger.log("Sidequest engine stopped");
+    } catch (error) {
+      this.logger.error("Failed to stop Sidequest engine", error);
+      throw error;
+    }
+  }
+  /**
+  * Job 클래스 등록
+  */
+  registerJob(jobName, JobClass) {
+    this.registeredJobs.set(jobName, JobClass);
+    this.logger.debug(`Job '${jobName}' registered`);
+  }
+  /**
+  * Job 추가
+  */
+  async addJob(queueName, jobName, args, options) {
+    const JobClass = this.registeredJobs.get(jobName);
+    if (!JobClass) {
+      throw new Error(`Job class '${jobName}' not found. Make sure it's registered.`);
+    }
+    let builder = sidequest.Sidequest.build(JobClass).queue(queueName);
+    if (options?.maxAttempts !== void 0) {
+      builder = builder.maxAttempts(options.maxAttempts);
+    }
+    if (options?.timeout !== void 0) {
+      builder = builder.timeout(options.timeout);
+    }
+    if (options?.priority !== void 0) ;
+    if (options?.scheduledAt !== void 0) {
+      builder = builder.availableAt(options.scheduledAt);
+    }
+    if (options?.retryDelay !== void 0) {
+      builder = builder.retryDelay(options.retryDelay);
+    }
+    if (options?.backoffStrategy !== void 0) {
+      builder = builder.backoffStrategy(options.backoffStrategy);
+    }
+    if (options?.uniqueKey !== void 0) {
+      builder = builder.unique(true);
+    }
+    const jobData = await builder.enqueue(...args);
+    const jobId = String(jobData?.id ?? `job_${Date.now()}`);
+    this.logger.debug(`Job '${jobName}' (ID: ${jobId}) added to Queue '${queueName}'`);
+    return jobId;
+  }
+  /**
+  * Bulk Job 추가
+  */
+  async addBulkJobs(queueName, jobs) {
+    const jobIds = [];
+    for (const { jobName, args, options } of jobs) {
+      const jobId = await this.addJob(queueName, jobName, args, options);
+      jobIds.push(jobId);
+    }
+    return jobIds;
+  }
+  /**
+  * Job 조회
+  */
+  async getJob(jobId) {
+    try {
+      const numericId = typeof jobId === "string" ? parseInt(jobId, 10) : jobId;
+      if (isNaN(numericId)) {
+        return void 0;
+      }
+      const job = await sidequest.Sidequest.job.get(numericId);
+      if (!job) {
+        return void 0;
+      }
+      const jobData = job;
+      return {
+        id: String(job.id),
+        name: jobData.name,
+        queue: job.queue,
+        state: job.state,
+        attempt: job.attempt,
+        maxAttempts: job.max_attempts,
+        insertedAt: job.inserted_at,
+        attemptedAt: job.attempted_at ?? void 0,
+        completedAt: job.completed_at ?? void 0,
+        result: job.result,
+        errors: job.errors
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+  * 엔진 시작 여부
+  */
+  get started() {
+    return this.isStarted;
+  }
+  /**
+  * 등록된 Job 클래스 반환
+  */
+  getRegisteredJob(jobName) {
+    return this.registeredJobs.get(jobName);
+  }
+  /**
+  * 모든 등록된 Job 클래스 반환
+  */
+  getAllRegisteredJobs() {
+    return this.registeredJobs;
+  }
+};
+exports.SidequestAdapter = _ts_decorate([
+  common.Injectable()
+], exports.SidequestAdapter);
+function _ts_decorate2(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;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+exports.SidequestEngineService = class _SidequestEngineService {
+  static {
+    __name(this, "SidequestEngineService");
+  }
+  options;
+  adapter;
+  logger = new common.Logger(_SidequestEngineService.name);
+  constructor(options, adapter) {
+    this.options = options;
+    this.adapter = adapter;
+  }
+  /**
+  * 모듈 초기화 시 엔진 시작
+  */
+  async onModuleInit() {
+    this.logger.log("Initializing Sidequest engine...");
+    await this.adapter.start(this.options);
+    this.logger.log("Sidequest engine initialized");
+  }
+  /**
+  * 모듈 종료 시 엔진 종료
+  */
+  async onModuleDestroy() {
+    const gracefulShutdown = this.options.gracefulShutdown ?? {
+      enabled: true,
+      timeout: 3e4
+    };
+    if (gracefulShutdown.enabled) {
+      this.logger.log(`Sidequest engine graceful shutdown (timeout: ${gracefulShutdown.timeout}ms)`);
+    }
+    await this.adapter.shutdown();
+    this.logger.log("Sidequest engine stopped");
+  }
+  /**
+  * 엔진 시작 여부
+  */
+  get isStarted() {
+    return this.adapter.started;
+  }
+  /**
+  * Adapter 인스턴스 반환
+  */
+  getAdapter() {
+    return this.adapter;
+  }
+};
+exports.SidequestEngineService = _ts_decorate2([
+  common.Injectable(),
+  _ts_param(0, common.Inject(SIDEQUEST_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof SidequestModuleOptions === "undefined" ? Object : SidequestModuleOptions,
+    typeof exports.SidequestAdapter === "undefined" ? Object : exports.SidequestAdapter
+  ])
+], exports.SidequestEngineService);
+function _ts_decorate3(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;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+exports.QueueRegistryService = class _QueueRegistryService {
+  static {
+    __name(this, "QueueRegistryService");
+  }
+  options;
+  adapter;
+  logger = new common.Logger(_QueueRegistryService.name);
+  queueServices = /* @__PURE__ */ new Map();
+  constructor(options, adapter) {
+    this.options = options;
+    this.adapter = adapter;
+    this.initializeQueues();
+  }
+  /**
+  * 설정된 큐 초기화
+  */
+  initializeQueues() {
+    const queues = this.options.queues ?? [];
+    for (const queueConfig of queues) {
+      this.registerQueue(queueConfig);
+    }
+    if (!this.queueServices.has("default")) {
+      this.registerQueue({
+        name: "default"
+      });
+    }
+  }
+  /**
+  * 큐 등록
+  */
+  registerQueue(config) {
+    const queueService = this.createQueueService(config.name);
+    this.queueServices.set(config.name, queueService);
+    this.logger.log(`Queue '${config.name}' registered`);
+  }
+  /**
+  * 큐 서비스 조회
+  */
+  getQueue(name) {
+    return this.queueServices.get(name);
+  }
+  /**
+  * 큐 서비스 조회 (없으면 에러)
+  */
+  getQueueOrThrow(name) {
+    const queue = this.getQueue(name);
+    if (!queue) {
+      throw new Error(`Queue '${name}' not found. Make sure it is registered in SidequestModule.forRoot().`);
+    }
+    return queue;
+  }
+  /**
+  * 모든 큐 조회
+  */
+  getAllQueues() {
+    return this.queueServices;
+  }
+  /**
+  * 큐 서비스 인스턴스 생성
+  */
+  createQueueService(queueName) {
+    const adapter = this.adapter;
+    return {
+      name: queueName,
+      async add(JobClass, ...args) {
+        const jobName = JobClass.name;
+        return adapter.addJob(queueName, jobName, args);
+      },
+      async addWithOptions(JobClass, options, ...args) {
+        const jobName = JobClass.name;
+        return adapter.addJob(queueName, jobName, args, options);
+      },
+      async addScheduled(JobClass, scheduledAt, ...args) {
+        const jobName = JobClass.name;
+        return adapter.addJob(queueName, jobName, args, {
+          scheduledAt
+        });
+      },
+      async addBulk(jobs) {
+        const bulkJobs = jobs.map((job) => {
+          const result = {
+            jobName: job.JobClass.name,
+            args: job.args
+          };
+          if (job.options !== void 0) {
+            result.options = job.options;
+          }
+          return result;
+        });
+        return adapter.addBulkJobs(queueName, bulkJobs);
+      }
+    };
+  }
+};
+exports.QueueRegistryService = _ts_decorate3([
+  common.Injectable(),
+  _ts_param2(0, common.Inject(SIDEQUEST_MODULE_OPTIONS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof SidequestModuleOptions === "undefined" ? Object : SidequestModuleOptions,
+    typeof exports.SidequestAdapter === "undefined" ? Object : exports.SidequestAdapter
+  ])
+], exports.QueueRegistryService);
+function _ts_decorate4(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;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+exports.ClsIntegrationService = class _ClsIntegrationService {
+  static {
+    __name(this, "ClsIntegrationService");
+  }
+  logger = new common.Logger(_ClsIntegrationService.name);
+  enabled;
+  clsService = null;
+  constructor(options, clsService) {
+    this.enabled = options.enableCls ?? false;
+    this.clsService = clsService ?? null;
+    if (this.enabled && !this.clsService) {
+      this.logger.warn("CLS integration is enabled but nestjs-cls is not installed. Install nestjs-cls to enable context propagation.");
+    }
+  }
+  /**
+  * CLS context 내에서 콜백 실행
+  */
+  async runInContext(metadata, callback) {
+    if (!this.enabled || !this.clsService) {
+      return callback();
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.clsService.run(() => {
+          for (const [key, value] of Object.entries(metadata)) {
+            this.clsService.set(key, value);
+          }
+          callback().then(resolve).catch(reject);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+  * 현재 traceId 조회
+  */
+  getTraceId() {
+    if (!this.enabled || !this.clsService) {
+      return void 0;
+    }
+    return this.clsService.get("traceId");
+  }
+  /**
+  * traceId 설정
+  */
+  setTraceId(traceId) {
+    if (!this.enabled || !this.clsService) {
+      return;
+    }
+    this.clsService.set("traceId", traceId);
+  }
+  /**
+  * CLS에서 값 조회
+  */
+  get(key) {
+    if (!this.enabled || !this.clsService) {
+      return void 0;
+    }
+    return this.clsService.get(key);
+  }
+  /**
+  * CLS에 값 설정
+  */
+  set(key, value) {
+    if (!this.enabled || !this.clsService) {
+      return;
+    }
+    this.clsService.set(key, value);
+  }
+  /**
+  * CLS 통합 활성화 여부
+  */
+  isEnabled() {
+    return this.enabled && this.clsService !== null;
+  }
+};
+exports.ClsIntegrationService = _ts_decorate4([
+  common.Injectable(),
+  _ts_param3(0, common.Inject(SIDEQUEST_MODULE_OPTIONS)),
+  _ts_param3(1, common.Optional()),
+  _ts_param3(1, common.Inject("ClsService")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof SidequestModuleOptions === "undefined" ? Object : SidequestModuleOptions,
+    typeof ClsService === "undefined" ? Object : ClsService
+  ])
+], exports.ClsIntegrationService);
+
+// src/services/processor-registry.service.ts
+function _ts_decorate5(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;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+exports.ProcessorRegistryService = class _ProcessorRegistryService {
+  static {
+    __name(this, "ProcessorRegistryService");
+  }
+  clsService;
+  logger = new common.Logger(_ProcessorRegistryService.name);
+  processors = /* @__PURE__ */ new Map();
+  constructor(clsService) {
+    this.clsService = clsService;
+  }
+  /**
+  * 프로세서 등록
+  */
+  register(processor) {
+    this.processors.set(processor.queueName, processor);
+    this.logger.log(`Processor '${processor.metatype.name}' (Queue: ${processor.queueName}) registered`);
+  }
+  /**
+  * 프로세서 조회
+  */
+  getProcessor(queueName) {
+    return this.processors.get(queueName);
+  }
+  /**
+  * 모든 프로세서 조회
+  */
+  getAllProcessors() {
+    return this.processors;
+  }
+  /**
+  * Job 핸들러 조회
+  */
+  getJobHandler(queueName, jobName) {
+    const processor = this.processors.get(queueName);
+    if (!processor) {
+      return void 0;
+    }
+    return processor.handlers.get(jobName);
+  }
+  /**
+  * Job 완료 핸들러 조회
+  */
+  getCompleteHandler(queueName, jobName) {
+    const processor = this.processors.get(queueName);
+    if (!processor) {
+      return void 0;
+    }
+    return processor.completeHandlers.get(jobName) ?? processor.completeHandlers.get("*");
+  }
+  /**
+  * Job 실패 핸들러 조회
+  */
+  getFailedHandler(queueName, jobName) {
+    const processor = this.processors.get(queueName);
+    if (!processor) {
+      return void 0;
+    }
+    return processor.failedHandlers.get(jobName) ?? processor.failedHandlers.get("*");
+  }
+  /**
+  * Job 디스패치 (실행)
+  *
+  * @param queueName - 큐 이름
+  * @param jobName - Job 이름
+  * @param args - Job 인자
+  * @param metadata - Job 메타데이터 (traceId 등)
+  */
+  async dispatch(queueName, jobName, args, metadata) {
+    const processor = this.processors.get(queueName);
+    if (!processor) {
+      throw new Error(`Processor not found for Queue '${queueName}'`);
+    }
+    const handler = processor.handlers.get(jobName);
+    if (!handler) {
+      throw new Error(`Handler not found for Job '${jobName}' (Queue: ${queueName})`);
+    }
+    const instance = processor.instance;
+    const method = instance[handler.methodName];
+    if (typeof method !== "function") {
+      throw new Error(`Handler method '${handler.methodName}' not found`);
+    }
+    const executeJob = /* @__PURE__ */ __name(async () => {
+      try {
+        const result = await method.apply(processor.instance, args);
+        const completeHandlerName = this.getCompleteHandler(queueName, jobName);
+        if (completeHandlerName) {
+          const completeHandler = instance[completeHandlerName];
+          if (typeof completeHandler === "function") {
+            await completeHandler.apply(processor.instance, [
+              {
+                jobName,
+                args,
+                result
+              }
+            ]);
+          }
+        }
+        return result;
+      } catch (error) {
+        const failedHandlerName = this.getFailedHandler(queueName, jobName);
+        if (failedHandlerName) {
+          const failedHandler = instance[failedHandlerName];
+          if (typeof failedHandler === "function") {
+            await failedHandler.apply(processor.instance, [
+              {
+                jobName,
+                args,
+                error
+              }
+            ]);
+          }
+        }
+        throw error;
+      }
+    }, "executeJob");
+    if (this.clsService?.isEnabled() && metadata) {
+      return this.clsService.runInContext(metadata, executeJob);
+    }
+    return executeJob();
+  }
+};
+exports.ProcessorRegistryService = _ts_decorate5([
+  common.Injectable(),
+  _ts_param4(0, common.Optional()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof exports.ClsIntegrationService === "undefined" ? Object : exports.ClsIntegrationService
+  ])
+], exports.ProcessorRegistryService);
+function _ts_decorate6(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;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var ProcessorExplorer = class _ProcessorExplorer {
+  static {
+    __name(this, "ProcessorExplorer");
+  }
+  discoveryService;
+  metadataScanner;
+  reflector;
+  processorRegistry;
+  logger = new common.Logger(_ProcessorExplorer.name);
+  constructor(discoveryService, metadataScanner, reflector, processorRegistry) {
+    this.discoveryService = discoveryService;
+    this.metadataScanner = metadataScanner;
+    this.reflector = reflector;
+    this.processorRegistry = processorRegistry;
+  }
+  /**
+  * 모듈 초기화 시 프로세서 스캔
+  */
+  async onModuleInit() {
+    this.logger.log("Scanning for processors...");
+    await this.explore();
+    this.logger.log("Processor scan completed");
+  }
+  /**
+  * 모든 프로바이더를 스캔하여 @Processor 클래스 찾기
+  */
+  async explore() {
+    const providers = this.discoveryService.getProviders();
+    for (const wrapper of providers) {
+      await this.processWrapper(wrapper);
+    }
+  }
+  /**
+  * 프로바이더 래퍼 처리
+  */
+  async processWrapper(wrapper) {
+    const { instance, metatype } = wrapper;
+    if (!instance || !metatype) {
+      return;
+    }
+    const processorMetadata = this.reflector.get(PROCESSOR_METADATA_KEY, metatype);
+    if (!processorMetadata) {
+      return;
+    }
+    const handlers = this.scanHandlers(instance, metatype);
+    const completeHandlers = this.scanCompleteHandlers(instance, metatype);
+    const failedHandlers = this.scanFailedHandlers(instance, metatype);
+    const registeredProcessor = {
+      queueName: processorMetadata.queueName,
+      instance,
+      metatype,
+      handlers,
+      completeHandlers,
+      failedHandlers
+    };
+    this.processorRegistry.register(registeredProcessor);
+    this.logger.log(`Processor '${metatype.name}' registered (Queue: ${processorMetadata.queueName}, Handlers: ${handlers.size})`);
+  }
+  /**
+  * @OnJob 메서드 스캔
+  */
+  scanHandlers(instance, _metatype) {
+    const handlers = /* @__PURE__ */ new Map();
+    const prototype = Object.getPrototypeOf(instance);
+    const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+    for (const methodName of methodNames) {
+      const methodRef = prototype[methodName];
+      const onJobMetadata = this.reflector.get(ON_JOB_METADATA_KEY, methodRef);
+      if (!onJobMetadata) {
+        continue;
+      }
+      const retryOptions = this.reflector.get(RETRY_OPTIONS_METADATA_KEY, methodRef);
+      const handler = {
+        methodName,
+        jobName: onJobMetadata.jobName,
+        options: onJobMetadata.options,
+        retryOptions
+      };
+      handlers.set(onJobMetadata.jobName, handler);
+      this.logger.debug(`  - Job '${onJobMetadata.jobName}' -> ${methodName}()`);
+    }
+    return handlers;
+  }
+  /**
+  * @OnJobComplete 메서드 스캔
+  */
+  scanCompleteHandlers(instance, _metatype) {
+    const handlers = /* @__PURE__ */ new Map();
+    const prototype = Object.getPrototypeOf(instance);
+    const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+    for (const methodName of methodNames) {
+      const methodRef = prototype[methodName];
+      const jobName = this.reflector.get(ON_JOB_COMPLETE_METADATA_KEY, methodRef);
+      if (jobName !== void 0) {
+        const key = jobName || "*";
+        handlers.set(key, methodName);
+        this.logger.debug(`  - OnJobComplete '${key}' -> ${methodName}()`);
+      }
+    }
+    return handlers;
+  }
+  /**
+  * @OnJobFailed 메서드 스캔
+  */
+  scanFailedHandlers(instance, _metatype) {
+    const handlers = /* @__PURE__ */ new Map();
+    const prototype = Object.getPrototypeOf(instance);
+    const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+    for (const methodName of methodNames) {
+      const methodRef = prototype[methodName];
+      const jobName = this.reflector.get(ON_JOB_FAILED_METADATA_KEY, methodRef);
+      if (jobName !== void 0) {
+        const key = jobName || "*";
+        handlers.set(key, methodName);
+        this.logger.debug(`  - OnJobFailed '${key}' -> ${methodName}()`);
+      }
+    }
+    return handlers;
+  }
+};
+ProcessorExplorer = _ts_decorate6([
+  common.Injectable(),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof core.DiscoveryService === "undefined" ? Object : core.DiscoveryService,
+    typeof core.MetadataScanner === "undefined" ? Object : core.MetadataScanner,
+    typeof core.Reflector === "undefined" ? Object : core.Reflector,
+    typeof exports.ProcessorRegistryService === "undefined" ? Object : exports.ProcessorRegistryService
+  ])
+], ProcessorExplorer);
+
+// src/modules/sidequest.module.ts
+function _ts_decorate7(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;
+}
+__name(_ts_decorate7, "_ts_decorate");
+exports.SidequestModule = class _SidequestModule {
+  static {
+    __name(this, "SidequestModule");
+  }
+  /**
+  * 동기 설정으로 모듈 등록
+  */
+  static forRoot(options) {
+    const isGlobal = options.isGlobal ?? true;
+    const queueProviders = this.createQueueProviders(options);
+    return {
+      module: _SidequestModule,
+      global: isGlobal,
+      imports: [
+        core.DiscoveryModule
+      ],
+      providers: [
+        {
+          provide: SIDEQUEST_MODULE_OPTIONS,
+          useValue: options
+        },
+        exports.SidequestAdapter,
+        exports.SidequestEngineService,
+        exports.QueueRegistryService,
+        exports.ProcessorRegistryService,
+        exports.ClsIntegrationService,
+        ProcessorExplorer,
+        ...queueProviders
+      ],
+      exports: [
+        SIDEQUEST_MODULE_OPTIONS,
+        exports.SidequestAdapter,
+        exports.SidequestEngineService,
+        exports.QueueRegistryService,
+        exports.ProcessorRegistryService,
+        exports.ClsIntegrationService,
+        ...queueProviders.map((p) => p.provide)
+      ]
+    };
+  }
+  /**
+  * 비동기 설정으로 모듈 등록
+  */
+  static forRootAsync(asyncOptions) {
+    const isGlobal = asyncOptions.isGlobal ?? true;
+    return {
+      module: _SidequestModule,
+      global: isGlobal,
+      imports: [
+        core.DiscoveryModule,
+        ...asyncOptions.imports || []
+      ],
+      providers: [
+        ...this.createAsyncProviders(asyncOptions),
+        exports.SidequestAdapter,
+        exports.SidequestEngineService,
+        exports.QueueRegistryService,
+        exports.ProcessorRegistryService,
+        exports.ClsIntegrationService,
+        ProcessorExplorer,
+        // 동적 큐 프로바이더 - options에서 queues를 읽어 생성
+        {
+          provide: "SIDEQUEST_QUEUE_PROVIDERS_INIT",
+          useFactory: /* @__PURE__ */ __name(() => {
+            return true;
+          }, "useFactory"),
+          inject: [
+            exports.QueueRegistryService
+          ]
+        }
+      ],
+      exports: [
+        SIDEQUEST_MODULE_OPTIONS,
+        exports.SidequestAdapter,
+        exports.SidequestEngineService,
+        exports.QueueRegistryService,
+        exports.ProcessorRegistryService,
+        exports.ClsIntegrationService
+      ]
+    };
+  }
+  /**
+  * 큐별 DI 프로바이더 생성
+  */
+  static createQueueProviders(options) {
+    const queues = options.queues ?? [
+      {
+        name: "default"
+      }
+    ];
+    return queues.map((queue) => ({
+      provide: getQueueToken(queue.name),
+      useFactory: /* @__PURE__ */ __name((registry) => registry.getQueueOrThrow(queue.name), "useFactory"),
+      inject: [
+        exports.QueueRegistryService
+      ]
+    }));
+  }
+  /**
+  * 비동기 프로바이더 생성
+  */
+  static createAsyncProviders(asyncOptions) {
+    if (asyncOptions.useFactory) {
+      return [
+        {
+          provide: SIDEQUEST_MODULE_OPTIONS,
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject || []
+        }
+      ];
+    }
+    if (asyncOptions.useClass) {
+      return [
+        {
+          provide: asyncOptions.useClass,
+          useClass: asyncOptions.useClass
+        },
+        {
+          provide: SIDEQUEST_MODULE_OPTIONS,
+          useFactory: /* @__PURE__ */ __name(async (optionsFactory) => optionsFactory.createSidequestOptions(), "useFactory"),
+          inject: [
+            asyncOptions.useClass
+          ]
+        }
+      ];
+    }
+    if (asyncOptions.useExisting) {
+      return [
+        {
+          provide: SIDEQUEST_MODULE_OPTIONS,
+          useFactory: /* @__PURE__ */ __name(async (optionsFactory) => optionsFactory.createSidequestOptions(), "useFactory"),
+          inject: [
+            asyncOptions.useExisting
+          ]
+        }
+      ];
+    }
+    return [
+      {
+        provide: SIDEQUEST_MODULE_OPTIONS,
+        useValue: {}
+      }
+    ];
+  }
+};
+exports.SidequestModule = _ts_decorate7([
+  common.Global(),
+  common.Module({})
+], exports.SidequestModule);
+function Processor(queueName, options) {
+  return (target) => {
+    const metadata = {
+      queueName,
+      options
+    };
+    common.SetMetadata(PROCESSOR_METADATA_KEY, metadata)(target);
+    common.Injectable()(target);
+  };
+}
+__name(Processor, "Processor");
+function OnJob(jobName, options) {
+  return (target, propertyKey, descriptor) => {
+    const metadata = {
+      jobName,
+      options
+    };
+    common.SetMetadata(ON_JOB_METADATA_KEY, metadata)(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(OnJob, "OnJob");
+function Retry(options) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(RETRY_OPTIONS_METADATA_KEY, options)(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(Retry, "Retry");
+function InjectQueue(queueName) {
+  return common.Inject(getQueueToken(queueName));
+}
+__name(InjectQueue, "InjectQueue");
+function OnJobComplete(jobName) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(ON_JOB_COMPLETE_METADATA_KEY, jobName ?? "")(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(OnJobComplete, "OnJobComplete");
+function OnJobFailed(jobName) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(ON_JOB_FAILED_METADATA_KEY, jobName ?? "")(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+__name(OnJobFailed, "OnJobFailed");
+
+Object.defineProperty(exports, "Job", {
+  enumerable: true,
+  get: function () { return sidequest.Job; }
+});
+exports.DEFAULT_CONCURRENCY = DEFAULT_CONCURRENCY;
+exports.DEFAULT_MAX_ATTEMPTS = DEFAULT_MAX_ATTEMPTS;
+exports.DEFAULT_QUEUE_NAME = DEFAULT_QUEUE_NAME;
+exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.InjectQueue = InjectQueue;
+exports.ON_JOB_COMPLETE_METADATA_KEY = ON_JOB_COMPLETE_METADATA_KEY;
+exports.ON_JOB_FAILED_METADATA_KEY = ON_JOB_FAILED_METADATA_KEY;
+exports.ON_JOB_METADATA_KEY = ON_JOB_METADATA_KEY;
+exports.OnJob = OnJob;
+exports.OnJobComplete = OnJobComplete;
+exports.OnJobFailed = OnJobFailed;
+exports.PROCESSOR_METADATA_KEY = PROCESSOR_METADATA_KEY;
+exports.Processor = Processor;
+exports.QUEUE_TOKEN_PREFIX = QUEUE_TOKEN_PREFIX;
+exports.RETRY_OPTIONS_METADATA_KEY = RETRY_OPTIONS_METADATA_KEY;
+exports.Retry = Retry;
+exports.SIDEQUEST_ENGINE = SIDEQUEST_ENGINE;
+exports.SIDEQUEST_MODULE_OPTIONS = SIDEQUEST_MODULE_OPTIONS;
+exports.getQueueToken = getQueueToken;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map