@kabyeon/nexusjs 0.6.5

package/dist/queue/index.js

@@ -0,0 +1,961 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = 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 __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+// src/queue/backends/memory.ts
+class MemoryWorkerHandle {
+  #running = true;
+  #handler;
+  #context;
+  constructor(name, handler) {
+    this.#handler = handler;
+    this.#context = { jobId: "", name };
+  }
+  get name() {
+    return this.#context.name;
+  }
+  async close() {
+    this.#running = false;
+  }
+  async pause() {
+    this.#running = false;
+  }
+  async resume() {
+    this.#running = true;
+  }
+  isRunning() {
+    return this.#running;
+  }
+}
+
+class MemoryQueueBackend {
+  name = "memory";
+  #queue = [];
+  #handlers = new Map;
+  #workerOptions = new Map;
+  #listeners = new Set;
+  #tickHandle = null;
+  #inFlight = 0;
+  constructor() {
+    this.#tickHandle = setInterval(() => this.#tick(), 100);
+    if (typeof this.#tickHandle.unref === "function") {
+      this.#tickHandle.unref();
+    }
+  }
+  async add(name, data, options = {}) {
+    const jobId = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const delayMs = (options.delaySeconds ?? 0) * 1000;
+    this.#queue.push({
+      jobId,
+      name,
+      data,
+      options,
+      resolveAt: Date.now() + delayMs
+    });
+    this.#emit({ kind: "job:added", jobId, name });
+    return { jobId, name };
+  }
+  async addBatch(jobs) {
+    return Promise.all(jobs.map((j) => this.add(j.name, j.data, j.options)));
+  }
+  async process(name, handler, options = {}) {
+    this.#handlers.set(name, handler);
+    this.#workerOptions.set(name, options);
+    const handle = new MemoryWorkerHandle(name, handler);
+    this.#emit({
+      kind: "worker:started",
+      name,
+      concurrency: options.concurrency ?? 1
+    });
+    return handle;
+  }
+  async drain() {
+    while (this.#inFlight > 0 || this.#queue.length > 0) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  async stop() {
+    for (const name of this.#handlers.keys()) {
+      this.#emit({ kind: "worker:stopped", name });
+    }
+    if (this.#tickHandle)
+      clearInterval(this.#tickHandle);
+    this.#tickHandle = null;
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  async#tick() {
+    if (this.#queue.length === 0)
+      return;
+    const now = Date.now();
+    const due = this.#queue.filter((j) => j.resolveAt <= now);
+    for (const job of due) {
+      this.#queue = this.#queue.filter((j) => j !== job);
+      const handler = this.#handlers.get(job.name);
+      if (!handler)
+        continue;
+      const options = this.#workerOptions.get(job.name) ?? {};
+      const concurrency = options.concurrency ?? 1;
+      if (this.#inFlight >= concurrency) {
+        this.#queue.unshift(job);
+        continue;
+      }
+      this.#runJob(job, handler, options);
+    }
+  }
+  async#runJob(job, handler, options) {
+    this.#inFlight++;
+    const ctx = {
+      jobId: job.jobId,
+      attempts: 1,
+      job: { name: job.name, data: job.data },
+      prefix: `[queue:${job.name}]`
+    };
+    this.#emit({
+      kind: "job:active",
+      jobId: job.jobId,
+      name: job.name,
+      attempts: 1
+    });
+    try {
+      const result = await handler(job.data, ctx);
+      if (result && typeof result === "object" && "status" in result) {
+        const r = result;
+        if (r.status === "failed") {
+          this.#emit({
+            kind: "job:failed",
+            jobId: job.jobId,
+            name: job.name,
+            error: r.error ?? new Error("unknown"),
+            willRetry: false
+          });
+        } else {
+          this.#emit({
+            kind: "job:completed",
+            jobId: job.jobId,
+            name: job.name,
+            returnvalue: r.returnvalue
+          });
+        }
+      } else {
+        this.#emit({
+          kind: "job:completed",
+          jobId: job.jobId,
+          name: job.name,
+          returnvalue: result
+        });
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const willRetry = (job.options.attempts ?? 1) > 1;
+      this.#emit({
+        kind: "job:failed",
+        jobId: job.jobId,
+        name: job.name,
+        error,
+        willRetry
+      });
+      if (willRetry) {
+        const delayMs = (job.options.backoff?.delayMs ?? 1000) * (job.options.backoff?.type === "exponential" ? 2 ** ctx.attempts : 1);
+        this.#queue.push({
+          ...job,
+          resolveAt: Date.now() + delayMs
+        });
+      }
+    } finally {
+      this.#inFlight--;
+    }
+  }
+  #emit(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+// src/queue/backends/bullmq.ts
+import {
+  Queue,
+  Worker
+} from "bullmq";
+import IORedis from "ioredis";
+
+class BullMQWorkerHandle {
+  #worker;
+  #name;
+  constructor(name, worker) {
+    this.#name = name;
+    this.#worker = worker;
+  }
+  get name() {
+    return this.#name;
+  }
+  async close() {
+    await this.#worker.close();
+  }
+  async pause() {
+    await this.#worker.pause();
+  }
+  async resume() {
+    await this.#worker.resume();
+  }
+  isRunning() {
+    return !this.#worker.closing;
+  }
+}
+
+class BullMQBackend {
+  name = "bullmq";
+  #queue;
+  #connection;
+  #prefix;
+  #defaultJobOptions;
+  #workers = new Map;
+  #listeners = new Set;
+  #closed = false;
+  constructor(options) {
+    this.#connection = typeof options.connection === "string" ? new IORedis(options.connection, {
+      maxRetriesPerRequest: null
+    }) : options.connection;
+    this.#prefix = options.prefix ?? "nexusjs";
+    this.#defaultJobOptions = options.defaultJobOptions ?? {};
+    this.#queue = new Queue("nexus-queue", {
+      connection: this.#connection,
+      prefix: this.#prefix,
+      defaultJobOptions: this.#toBullJobOptions(this.#defaultJobOptions)
+    });
+  }
+  async add(name, data, options = {}) {
+    const merged = { ...this.#defaultJobOptions, ...options };
+    const job = await this.#queue.add(name, data, this.#toBullJobOptions(merged));
+    this.#emit({ kind: "job:added", jobId: String(job.id ?? ""), name });
+    return { jobId: String(job.id ?? ""), name, handle: job };
+  }
+  async addBatch(jobs) {
+    const bullJobs = jobs.map((j) => ({
+      name: j.name,
+      data: j.data,
+      opts: this.#toBullJobOptions({
+        ...this.#defaultJobOptions,
+        ...j.options
+      })
+    }));
+    const added = await this.#queue.addBulk(bullJobs);
+    for (const job of added) {
+      this.#emit({
+        kind: "job:added",
+        jobId: String(job.id ?? ""),
+        name: job.name
+      });
+    }
+    return added.map((job) => ({
+      jobId: String(job.id ?? ""),
+      name: job.name,
+      handle: job
+    }));
+  }
+  async process(name, handler, options = {}) {
+    const worker = new Worker("nexus-queue", async (job) => {
+      const ctx = {
+        jobId: String(job.id ?? ""),
+        attempts: job.attemptsMade + 1,
+        job: { name: job.name, data: job.data },
+        prefix: `[queue:${job.name}]`
+      };
+      this.#emit({
+        kind: "job:active",
+        jobId: ctx.jobId,
+        name: job.name,
+        attempts: ctx.attempts
+      });
+      try {
+        const result = await handler(job.data, ctx);
+        if (result && typeof result === "object" && "status" in result) {
+          const r = result;
+          if (r.status === "completed") {
+            this.#emit({
+              kind: "job:completed",
+              jobId: ctx.jobId,
+              name: job.name,
+              returnvalue: r.returnvalue
+            });
+            return r.returnvalue;
+          }
+          if (r.status === "retry") {
+            const r2 = result;
+            throw new RetryError(r2.reason ?? "retry requested", r2.delaySeconds);
+          }
+        }
+        this.#emit({
+          kind: "job:completed",
+          jobId: ctx.jobId,
+          name: job.name,
+          returnvalue: result
+        });
+        return result;
+      } catch (err) {
+        if (err instanceof RetryError) {
+          await job.moveToDelayed(Date.now() + (err.delaySeconds ?? 0) * 1000, job.token);
+          return;
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        const willRetry = (job.opts.attempts ?? 1) > job.attemptsMade;
+        this.#emit({
+          kind: "job:failed",
+          jobId: ctx.jobId,
+          name: job.name,
+          error,
+          willRetry
+        });
+        throw err;
+      }
+    }, {
+      connection: this.#connection,
+      prefix: this.#prefix,
+      concurrency: options.concurrency ?? 1,
+      lockDuration: options.lockDurationMs ?? 30000,
+      limiter: options.limiter ? { max: options.limiter.max, duration: options.limiter.durationMs } : undefined
+    });
+    this.#workers.set(name, worker);
+    this.#emit({
+      kind: "worker:started",
+      name,
+      concurrency: options.concurrency ?? 1
+    });
+    return new BullMQWorkerHandle(name, worker);
+  }
+  async drain() {
+    const workers = [...this.#workers.values()];
+    await Promise.all(workers.map((w) => w.waitUntilReady()));
+    while (workers.some((w) => w._job !== undefined)) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  async stop() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const [name, worker] of this.#workers) {
+      await worker.close();
+      this.#emit({ kind: "worker:stopped", name });
+    }
+    await this.#queue.close();
+    try {
+      const conn = this.#connection;
+      if (typeof conn?.quit === "function")
+        await conn.quit();
+    } catch {}
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  #toBullJobOptions(opts) {
+    const out = {};
+    if (opts.delaySeconds !== undefined)
+      out.delay = opts.delaySeconds * 1000;
+    if (opts.attempts !== undefined)
+      out.attempts = opts.attempts;
+    if (opts.backoff)
+      out.backoff = { type: opts.backoff.type, delay: opts.backoff.delayMs };
+    if (opts.priority !== undefined)
+      out.priority = opts.priority;
+    if (opts.jobId !== undefined)
+      out.jobId = opts.jobId;
+    if (opts.removeOnComplete !== undefined)
+      out.removeOnComplete = opts.removeOnComplete;
+    if (opts.removeOnFail !== undefined)
+      out.removeOnFail = opts.removeOnFail;
+    return out;
+  }
+  #emit(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+
+class RetryError extends Error {
+  delaySeconds;
+  __retry = true;
+  constructor(message, delaySeconds) {
+    super(message);
+    this.delaySeconds = delaySeconds;
+    this.name = "RetryError";
+  }
+}
+// src/queue/backends/cloudflare.ts
+class CloudflareWorkerHandle {
+  #name;
+  #running = true;
+  constructor(name) {
+    this.#name = name;
+  }
+  get name() {
+    return this.#name;
+  }
+  async close() {
+    this.#running = false;
+  }
+  async pause() {
+    this.#running = false;
+  }
+  async resume() {
+    this.#running = true;
+  }
+  isRunning() {
+    return this.#running;
+  }
+}
+
+class CloudflareQueueBackend {
+  name = "cloudflare";
+  #queue = null;
+  #resolveBinding;
+  #handlers = new Map;
+  #workerOptions = new Map;
+  #listeners = new Set;
+  #queueName;
+  constructor(options) {
+    this.#resolveBinding = options.resolveBinding;
+    this.#queueName = options.name ?? "queue";
+  }
+  bind(env) {
+    this.#queue = this.#resolveBinding(env);
+  }
+  async add(name, data, options = {}) {
+    if (!this.#queue)
+      throw new Error("[queue/cloudflare] bind() must be called before add()");
+    const id = `cf-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    await this.#queue.send({ name, data, jobId: id, options }, { delaySeconds: options.delaySeconds });
+    this.#emit({ kind: "job:added", jobId: id, name });
+    return { jobId: id, name };
+  }
+  async addBatch(jobs) {
+    if (!this.#queue)
+      throw new Error("[queue/cloudflare] bind() must be called before addBatch()");
+    const ids = jobs.map(() => `cf-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`);
+    await this.#queue.sendBatch(jobs.map((j, i) => ({
+      body: { name: j.name, data: j.data, jobId: ids[i], options: j.options },
+      delaySeconds: j.options?.delaySeconds
+    })));
+    for (let i = 0;i < jobs.length; i++) {
+      const j = jobs[i];
+      this.#emit({ kind: "job:added", jobId: ids[i], name: j.name });
+    }
+    return jobs.map((j, i) => ({ jobId: ids[i], name: j.name }));
+  }
+  async process(name, handler, options = {}) {
+    this.#handlers.set(name, handler);
+    this.#workerOptions.set(name, options);
+    this.#emit({
+      kind: "worker:started",
+      name,
+      concurrency: options.concurrency ?? 1
+    });
+    return new CloudflareWorkerHandle(name);
+  }
+  consumerHandler() {
+    return async (batch) => {
+      for (const message of batch.messages) {
+        const body = message.body ?? {};
+        const jobName = body.name ?? "";
+        const handler = this.#handlers.get(jobName);
+        if (!handler) {
+          message.retry();
+          continue;
+        }
+        const ctx = {
+          jobId: body.jobId ?? message.id,
+          attempts: message.attempts,
+          job: { name: jobName, data: body.data },
+          prefix: `[queue:${jobName}]`
+        };
+        this.#emit({
+          kind: "job:active",
+          jobId: ctx.jobId,
+          name: jobName,
+          attempts: ctx.attempts
+        });
+        try {
+          const result = await handler(body.data, ctx);
+          if (result && typeof result === "object" && "status" in result) {
+            const r = result;
+            if (r.status === "failed") {
+              this.#emit({
+                kind: "job:failed",
+                jobId: ctx.jobId,
+                name: jobName,
+                error: r.error ?? new Error("failed"),
+                willRetry: true
+              });
+              message.retry();
+              continue;
+            }
+            if (r.status === "retry") {
+              const r2 = result;
+              message.retry({ delaySeconds: r2.delaySeconds });
+              continue;
+            }
+            this.#emit({
+              kind: "job:completed",
+              jobId: ctx.jobId,
+              name: jobName,
+              returnvalue: r.returnvalue
+            });
+          } else {
+            this.#emit({
+              kind: "job:completed",
+              jobId: ctx.jobId,
+              name: jobName,
+              returnvalue: result
+            });
+          }
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          const willRetry = (body.options?.attempts ?? 1) > message.attempts;
+          this.#emit({
+            kind: "job:failed",
+            jobId: ctx.jobId,
+            name: jobName,
+            error,
+            willRetry
+          });
+          if (willRetry)
+            message.retry();
+          else
+            message.ack();
+        }
+      }
+    };
+  }
+  async drain() {}
+  async stop() {
+    for (const name of this.#handlers.keys()) {
+      this.#emit({ kind: "worker:stopped", name });
+    }
+    this.#handlers.clear();
+    this.#workerOptions.clear();
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  #emit(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+  get queueName() {
+    return this.#queueName;
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/queue/queue.service.ts
+class QueueService {
+  config;
+  static TOKEN = Symbol.for("nexus:QueueService");
+  backend;
+  #workers = new Map;
+  #listeners = new Set;
+  #started = false;
+  constructor(config) {
+    this.config = config;
+    this.backend = this.#createBackend(config);
+  }
+  async add(name, data, options = {}) {
+    const merged = { ...this.config.defaults, ...options };
+    return this.backend.add(name, data, merged);
+  }
+  async addBatch(jobs) {
+    return this.backend.addBatch(jobs);
+  }
+  async process(name, handler) {
+    const handle = await this.backend.process(name, handler);
+    this.#workers.set(name, handle);
+    return handle;
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  async start() {
+    if (this.#started)
+      return;
+    this.#started = true;
+    this.backend.on((event) => this.#broadcast(event));
+  }
+  async stop() {
+    if (!this.#started)
+      return;
+    this.#started = false;
+    await this.backend.drain();
+    for (const handle of this.#workers.values()) {
+      await handle.close();
+    }
+    await this.backend.stop();
+    this.#workers.clear();
+  }
+  getCloudflareBackend() {
+    return this.backend instanceof CloudflareQueueBackend ? this.backend : null;
+  }
+  #createBackend(config) {
+    switch (config.backend) {
+      case "memory":
+        return new MemoryQueueBackend;
+      case "bullmq": {
+        if (!config.bullmq) {
+          throw new Error("[queue] backend=bullmq requires `bullmq.connection` in config.");
+        }
+        return new BullMQBackend({
+          connection: config.bullmq.connection,
+          prefix: config.bullmq.prefix,
+          defaultJobOptions: config.bullmq.defaultJobOptions
+        });
+      }
+      case "cloudflare": {
+        if (!config.cloudflare) {
+          throw new Error("[queue] backend=cloudflare requires `cloudflare.resolveBinding` in config.");
+        }
+        return new CloudflareQueueBackend({
+          resolveBinding: config.cloudflare.resolveBinding,
+          name: config.cloudflare.name
+        });
+      }
+    }
+  }
+  #broadcast(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+QueueService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("QUEUE_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof QueueConfig === "undefined" ? Object : QueueConfig
+  ])
+], QueueService);
+// src/queue/queue.module.ts
+import"reflect-metadata";
+class QueueModule {
+  static forRoot(config) {
+    class ConfiguredQueueModule {
+    }
+    ConfiguredQueueModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          QueueService,
+          { provide: QueueService.TOKEN, useExisting: QueueService },
+          { provide: "QUEUE_CONFIG", useValue: config }
+        ],
+        exports: [QueueService, QueueService.TOKEN]
+      })
+    ], ConfiguredQueueModule);
+    Object.defineProperty(ConfiguredQueueModule, "name", {
+      value: "ConfiguredQueueModule"
+    });
+    return ConfiguredQueueModule;
+  }
+}
+QueueModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      QueueService,
+      { provide: QueueService.TOKEN, useExisting: QueueService }
+    ],
+    exports: [QueueService, QueueService.TOKEN]
+  })
+], QueueModule);
+// src/queue/decorators/on-queue-ready.ts
+import"reflect-metadata";
+function OnQueueReady() {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("@OnQueueReady can only decorate methods.");
+    }
+    const ctor = target.constructor;
+    const hooks = Reflect.getMetadata("nexus:queue:ready-hooks", ctor) ?? [];
+    hooks.push(propertyKey);
+    Reflect.defineMetadata("nexus:queue:ready-hooks", hooks, ctor);
+  };
+}
+function getQueueReadyHooks(target) {
+  const ctor = target.constructor ?? target;
+  return Reflect.getMetadata("nexus:queue:ready-hooks", ctor) ?? [];
+}
+async function invokeQueueReadyHooks(instance) {
+  const hooks = getQueueReadyHooks(instance);
+  for (const key of hooks) {
+    const fn = instance[key];
+    if (typeof fn === "function") {
+      await fn.call(instance);
+    }
+  }
+}
+export {
+  invokeQueueReadyHooks,
+  getQueueReadyHooks,
+  QueueService,
+  QueueModule,
+  OnQueueReady,
+  MemoryQueueBackend,
+  CloudflareQueueBackend,
+  BullMQBackend
+};
+
+//# debugId=A7D10A8ACACCA70164756E2164756E21
+//# sourceMappingURL=index.js.map