@dangao/bun-server 0.4.0 → 1.0.1

package/dist/index.js

@@ -969,21 +969,23 @@ class MiddlewarePipeline {
     if (length === 0) {
       return await finalHandler();
     }
+    let currentIndex = 0;
     const called = new Array(length).fill(false);
-    const chain = new Array(length + 1);
-    chain[length] = finalHandler;
-    for (let i = length - 1;i >= 0; i--) {
-      const middleware = this.middlewares[i];
-      const downstream = chain[i + 1];
-      chain[i] = async () => {
-        if (called[i]) {
+    const createNext = (index) => {
+      if (index >= length) {
+        return finalHandler;
+      }
+      return async () => {
+        if (called[index]) {
           throw new Error("next() called multiple times");
         }
-        called[i] = true;
-        return await middleware(context, downstream);
+        called[index] = true;
+        currentIndex = index + 1;
+        const middleware = this.middlewares[index];
+        return await middleware(context, createNext(index + 1));
       };
-    }
-    return await chain[0]();
+    };
+    return await createNext(0)();
   }
 }
 
@@ -1053,6 +1055,7 @@ class Router {
   routes = [];
   staticRoutes = new Map;
   dynamicRoutes = [];
+  matchCache = new Map;
   normalizePath(path) {
     if (path.length > 1 && path.endsWith("/")) {
       return path.slice(0, -1);
@@ -1069,6 +1072,7 @@ class Router {
     } else {
       this.dynamicRoutes.push(route);
     }
+    this.matchCache.clear();
   }
   get(path, handler, middlewares = []) {
     this.register("GET", path, handler, middlewares);
@@ -1086,14 +1090,29 @@ class Router {
     this.register("PATCH", path, handler, middlewares);
   }
   findRoute(method, path) {
-    const staticRoute = this.staticRoutes.get(`${method}:${path}`);
+    const result = this.findRouteWithMatch(method, path);
+    return result?.route;
+  }
+  findRouteWithMatch(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const cacheKey = `${method}:${normalizedPath}`;
+    const cached = this.matchCache.get(cacheKey);
+    if (cached && cached.match.matched) {
+      return cached;
+    }
+    const staticRoute = this.staticRoutes.get(cacheKey);
     if (staticRoute) {
-      return staticRoute;
+      const match = { matched: true, params: {} };
+      const result = { route: staticRoute, match };
+      this.matchCache.set(cacheKey, result);
+      return result;
     }
     for (const route of this.dynamicRoutes) {
-      const match = route.match(method, path);
+      const match = route.match(method, normalizedPath);
       if (match.matched) {
-        return route;
+        const result = { route, match };
+        this.matchCache.set(cacheKey, result);
+        return result;
       }
     }
     return;
@@ -1101,11 +1120,11 @@ class Router {
   async preHandle(context) {
     const method = context.method;
     const path = this.normalizePath(context.path);
-    const route = this.findRoute(method, path);
-    if (!route) {
+    const result = this.findRouteWithMatch(method, path);
+    if (!result) {
       return;
     }
-    const match = route.match(method, path);
+    const { route, match } = result;
     if (match.matched) {
       context.params = match.params;
     }
@@ -1117,13 +1136,22 @@ class Router {
     }
   }
   async handle(context) {
-    await this.preHandle(context);
     const method = context.method;
     const path = this.normalizePath(context.path);
-    const route = this.findRoute(method, path);
-    if (!route) {
+    const result = this.findRouteWithMatch(method, path);
+    if (!result) {
       return;
     }
+    const { route, match } = result;
+    if (match.matched) {
+      context.params = match.params;
+    }
+    if (route.controllerClass && route.methodName) {
+      context.routeHandler = {
+        controller: route.controllerClass,
+        method: route.methodName
+      };
+    }
     return await route.execute(context);
   }
   getRoutes() {
@@ -1133,6 +1161,7 @@ class Router {
     this.routes.length = 0;
     this.dynamicRoutes.length = 0;
     this.staticRoutes.clear();
+    this.matchCache.clear();
   }
 }
 
@@ -1521,14 +1550,162 @@ function getParamMetadata(target, propertyKey) {
   return Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
 }
 
+// src/session/types.ts
+class MemorySessionStore {
+  store = new Map;
+  cleanupInterval;
+  constructor(options) {
+    if (options?.cleanupInterval !== undefined) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanup();
+      }, options.cleanupInterval);
+    }
+  }
+  async get(sessionId) {
+    const session = this.store.get(sessionId);
+    if (!session) {
+      return;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.store.delete(sessionId);
+      return;
+    }
+    return session;
+  }
+  async set(session, maxAge) {
+    const now = Date.now();
+    session.expiresAt = now + maxAge;
+    session.lastAccessedAt = now;
+    this.store.set(session.id, session);
+    return true;
+  }
+  async delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  async has(sessionId) {
+    const session = this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.store.delete(sessionId);
+      return false;
+    }
+    return true;
+  }
+  async touch(sessionId) {
+    const session = this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.store.delete(sessionId);
+      return false;
+    }
+    session.lastAccessedAt = Date.now();
+    return true;
+  }
+  async clear() {
+    this.store.clear();
+    return true;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [sessionId, session] of this.store.entries()) {
+      if (now > session.expiresAt) {
+        this.store.delete(sessionId);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = undefined;
+    }
+    this.store.clear();
+  }
+}
+
+class RedisSessionStore {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "session:";
+  }
+  getKey(sessionId) {
+    return `${this.keyPrefix}${sessionId}`;
+  }
+  async get(sessionId) {
+    try {
+      const value = await this.client.get(this.getKey(sessionId));
+      if (value === null) {
+        return;
+      }
+      return JSON.parse(value);
+    } catch {
+      return;
+    }
+  }
+  async set(session, maxAge) {
+    try {
+      const serialized = JSON.stringify(session);
+      await this.client.set(this.getKey(session.id), serialized, {
+        PX: maxAge
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(sessionId) {
+    try {
+      await this.client.del(this.getKey(sessionId));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async has(sessionId) {
+    try {
+      const result = await this.client.exists(this.getKey(sessionId));
+      return result === 1;
+    } catch {
+      return false;
+    }
+  }
+  async touch(sessionId) {
+    try {
+      const session = await this.get(sessionId);
+      if (!session) {
+        return false;
+      }
+      session.lastAccessedAt = Date.now();
+      const remainingTime = session.expiresAt - Date.now();
+      if (remainingTime > 0) {
+        await this.client.expire(this.getKey(sessionId), Math.floor(remainingTime / 1000));
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async clear() {
+    return false;
+  }
+}
+var SESSION_SERVICE_TOKEN = Symbol("@dangao/bun-server:session:service");
+var SESSION_OPTIONS_TOKEN = Symbol("@dangao/bun-server:session:options");
+
 // src/controller/param-binder.ts
 class ParamBinder {
-  static async bind(target, propertyKey, context) {
+  static async bind(target, propertyKey, context, container) {
     const metadata = getParamMetadata(target, propertyKey);
     const params = [];
     metadata.sort((a, b) => a.index - b.index);
     for (const meta of metadata) {
-      const value = await this.getValue(meta, context);
+      const value = await this.getValue(meta, context, container);
       params[meta.index] = value;
     }
     const maxIndex = metadata.length > 0 ? Math.max(...metadata.map((m) => m.index)) : -1;
@@ -1539,7 +1716,7 @@ class ParamBinder {
     }
     return params;
   }
-  static async getValue(meta, context) {
+  static async getValue(meta, context, container) {
     switch (meta.type) {
       case "body" /* BODY */:
         return await this.getBodyValue(meta.key, context);
@@ -1558,6 +1735,24 @@ class ParamBinder {
           throw new Error("@Header() decorator requires a key parameter");
         }
         return this.getHeaderValue(meta.key, context);
+      case "session" /* SESSION */:
+        if (!container) {
+          throw new Error("@Session() decorator requires a Container instance");
+        }
+        const session = context.session;
+        if (session) {
+          return session;
+        }
+        try {
+          const sessionService = container.resolve(SESSION_SERVICE_TOKEN);
+          if (sessionService) {
+            const newSession = await sessionService.create();
+            context.session = newSession;
+            context.sessionId = newSession.id;
+            return newSession;
+          }
+        } catch {}
+        return;
       default:
         return;
     }
@@ -2116,7 +2311,7 @@ class ControllerRegistry {
           const controllerContainer = this.controllerContainers.get(controllerClass) ?? this.container;
           const controllerInstance = controllerContainer.resolve(controllerClass);
           const prototype2 = controllerClass.prototype;
-          const params = await ParamBinder.bind(prototype2, propertyKey, context);
+          const params = await ParamBinder.bind(prototype2, propertyKey, context, controllerContainer);
           const validationMetadata = getValidationMetadata(prototype2, propertyKey);
           if (validationMetadata.length > 0) {
             validateParameters(params, validationMetadata);
@@ -5181,6 +5376,885 @@ class StressTester {
     };
   }
 }
+// src/cache/types.ts
+class MemoryCacheStore {
+  store = new Map;
+  cleanupInterval;
+  constructor(options) {
+    if (options?.cleanupInterval !== undefined) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanup();
+      }, options.cleanupInterval);
+    }
+  }
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = ttl && ttl > 0 ? Date.now() + ttl : undefined;
+    this.store.set(key, { value, expiresAt });
+    return true;
+  }
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  async has(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async clear() {
+    this.store.clear();
+    return true;
+  }
+  async getMany(keys) {
+    const result = new Map;
+    const now = Date.now();
+    for (const key of keys) {
+      const entry = this.store.get(key);
+      if (entry) {
+        if (entry.expiresAt && now > entry.expiresAt) {
+          this.store.delete(key);
+          continue;
+        }
+        result.set(key, entry.value);
+      }
+    }
+    return result;
+  }
+  async setMany(entries, ttl) {
+    const expiresAt = ttl && ttl > 0 ? Date.now() + ttl : undefined;
+    for (const { key, value } of entries) {
+      this.store.set(key, { value, expiresAt });
+    }
+    return true;
+  }
+  async deleteMany(keys) {
+    const deleted = [];
+    for (const key of keys) {
+      if (this.store.delete(key)) {
+        deleted.push(key);
+      }
+    }
+    return deleted;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt && now > entry.expiresAt) {
+        this.store.delete(key);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = undefined;
+    }
+    this.store.clear();
+  }
+}
+
+class RedisCacheStore {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "cache:";
+  }
+  getKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  async get(key) {
+    const value = await this.client.get(this.getKey(key));
+    if (value === null) {
+      return;
+    }
+    try {
+      return JSON.parse(value);
+    } catch {
+      return;
+    }
+  }
+  async set(key, value, ttl) {
+    try {
+      const serialized = JSON.stringify(value);
+      if (ttl && ttl > 0) {
+        await this.client.set(this.getKey(key), serialized, { PX: ttl });
+      } else {
+        await this.client.set(this.getKey(key), serialized);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(key) {
+    try {
+      await this.client.del(this.getKey(key));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async has(key) {
+    try {
+      const result = await this.client.exists(this.getKey(key));
+      return result === 1;
+    } catch {
+      return false;
+    }
+  }
+  async clear() {
+    try {
+      await this.client.flushdb();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getMany(keys) {
+    const result = new Map;
+    if (keys.length === 0) {
+      return result;
+    }
+    try {
+      const prefixedKeys = keys.map((k) => this.getKey(k));
+      const values = await this.client.mget(prefixedKeys);
+      for (let i = 0;i < keys.length; i++) {
+        const value = values[i];
+        if (value !== null) {
+          try {
+            result.set(keys[i], JSON.parse(value));
+          } catch {}
+        }
+      }
+    } catch {}
+    return result;
+  }
+  async setMany(entries, ttl) {
+    if (entries.length === 0) {
+      return true;
+    }
+    try {
+      const redisEntries = entries.map(({ key, value }) => ({
+        key: this.getKey(key),
+        value: JSON.stringify(value)
+      }));
+      await this.client.mset(redisEntries);
+      if (ttl && ttl > 0) {
+        for (const entry of redisEntries) {
+          await this.client.set(entry.key, entry.value, { PX: ttl });
+        }
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0) {
+      return [];
+    }
+    try {
+      const prefixedKeys = keys.map((k) => this.getKey(k));
+      const deleted = [];
+      for (const key of prefixedKeys) {
+        try {
+          await this.client.del(key);
+          deleted.push(key.replace(this.keyPrefix, ""));
+        } catch {}
+      }
+      return deleted;
+    } catch {
+      return [];
+    }
+  }
+}
+var CACHE_SERVICE_TOKEN = Symbol("@dangao/bun-server:cache:service");
+var CACHE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:cache:options");
+
+// src/cache/service.ts
+class CacheService {
+  store;
+  defaultTtl;
+  keyPrefix;
+  constructor(options) {
+    this.store = options.store;
+    this.defaultTtl = options.defaultTtl ?? 3600000;
+    this.keyPrefix = options.keyPrefix ?? "";
+  }
+  async get(key) {
+    return this.store.get(this.getKey(key));
+  }
+  async set(key, value, ttl) {
+    const finalTtl = ttl !== undefined ? ttl : this.defaultTtl;
+    return this.store.set(this.getKey(key), value, finalTtl);
+  }
+  async delete(key) {
+    return this.store.delete(this.getKey(key));
+  }
+  async has(key) {
+    return this.store.has(this.getKey(key));
+  }
+  async clear() {
+    return this.store.clear();
+  }
+  async getMany(keys) {
+    const prefixedKeys = keys.map((k) => this.getKey(k));
+    const result = await this.store.getMany(prefixedKeys);
+    const map = new Map;
+    for (const [key, value] of result.entries()) {
+      map.set(key.replace(this.keyPrefix, ""), value);
+    }
+    return map;
+  }
+  async setMany(entries, ttl) {
+    const finalTtl = ttl !== undefined ? ttl : this.defaultTtl;
+    const prefixedEntries = entries.map(({ key, value }) => ({
+      key: this.getKey(key),
+      value
+    }));
+    return this.store.setMany(prefixedEntries, finalTtl);
+  }
+  async deleteMany(keys) {
+    const prefixedKeys = keys.map((k) => this.getKey(k));
+    const deleted = await this.store.deleteMany(prefixedKeys);
+    return deleted.map((k) => k.replace(this.keyPrefix, ""));
+  }
+  async getOrSet(key, factory, ttl) {
+    const cached = await this.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const value = await factory();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  getKey(key) {
+    return this.keyPrefix ? `${this.keyPrefix}${key}` : key;
+  }
+}
+CacheService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(CACHE_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof CacheModuleOptions === "undefined" ? Object : CacheModuleOptions
+  ])
+], CacheService);
+
+// src/cache/cache-module.ts
+class CacheModule {
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const store = options.store ?? new MemoryCacheStore({
+      cleanupInterval: 60000
+    });
+    const service = new CacheService({
+      store,
+      defaultTtl: options.defaultTtl,
+      keyPrefix: options.keyPrefix
+    });
+    providers2.push({
+      provide: CACHE_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: CACHE_OPTIONS_TOKEN,
+      useValue: options
+    }, CacheService);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, CacheModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        CACHE_SERVICE_TOKEN,
+        CACHE_OPTIONS_TOKEN,
+        CacheService
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, CacheModule);
+    return CacheModule;
+  }
+}
+CacheModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], CacheModule);
+// src/cache/decorators.ts
+import"reflect-metadata";
+var CACHEABLE_METADATA_KEY = Symbol("@dangao/bun-server:cache:cacheable");
+var CACHE_EVICT_METADATA_KEY = Symbol("@dangao/bun-server:cache:cache-evict");
+var CACHE_PUT_METADATA_KEY = Symbol("@dangao/bun-server:cache:cache-put");
+function Cacheable(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      ttl: options.ttl,
+      condition: options.condition
+    };
+    Reflect.defineMetadata(CACHEABLE_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+function CacheEvict(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      beforeInvocation: options.beforeInvocation ?? false,
+      allEntries: options.allEntries ?? false
+    };
+    Reflect.defineMetadata(CACHE_EVICT_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+function CachePut(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      ttl: options.ttl,
+      condition: options.condition
+    };
+    Reflect.defineMetadata(CACHE_PUT_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+// src/queue/types.ts
+class MemoryQueueStore {
+  queues = new Map;
+  jobCounter = 0;
+  async add(queueName, job) {
+    const queue = this.getQueue(queueName);
+    const jobId = job.options?.jobId ?? `job_${++this.jobCounter}_${Date.now()}`;
+    const now = Date.now();
+    const fullJob = {
+      id: jobId,
+      name: job.name,
+      data: job.data,
+      options: job.options,
+      status: job.options?.delay ? "delayed" : "waiting",
+      createdAt: now,
+      updatedAt: now
+    };
+    queue.set(jobId, fullJob);
+    return jobId;
+  }
+  async get(queueName, jobId) {
+    const queue = this.getQueue(queueName);
+    return queue.get(jobId);
+  }
+  async getNext(queueName) {
+    const queue = this.getQueue(queueName);
+    const now = Date.now();
+    let nextJob;
+    let highestPriority = -Infinity;
+    for (const job of queue.values()) {
+      if (job.status === "delayed" && job.options?.delay) {
+        const delayEndTime = job.createdAt + job.options.delay;
+        if (now >= delayEndTime) {
+          if ((job.options.priority ?? 0) > highestPriority || !nextJob) {
+            nextJob = job;
+            highestPriority = job.options?.priority ?? 0;
+          }
+        }
+      } else if (job.status === "waiting") {
+        if ((job.options?.priority ?? 0) > highestPriority || !nextJob) {
+          nextJob = job;
+          highestPriority = job.options?.priority ?? 0;
+        }
+      }
+    }
+    return nextJob;
+  }
+  async updateStatus(queueName, jobId, status) {
+    const queue = this.getQueue(queueName);
+    const job = queue.get(jobId);
+    if (!job) {
+      return false;
+    }
+    job.status = status;
+    job.updatedAt = Date.now();
+    return true;
+  }
+  async delete(queueName, jobId) {
+    const queue = this.getQueue(queueName);
+    return queue.delete(jobId);
+  }
+  async clear(queueName) {
+    const queue = this.getQueue(queueName);
+    queue.clear();
+    return true;
+  }
+  async count(queueName) {
+    const queue = this.getQueue(queueName);
+    return queue.size;
+  }
+  getQueue(queueName) {
+    if (!this.queues.has(queueName)) {
+      this.queues.set(queueName, new Map);
+    }
+    return this.queues.get(queueName);
+  }
+}
+var QUEUE_SERVICE_TOKEN = Symbol("@dangao/bun-server:queue:service");
+var QUEUE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:queue:options");
+
+// src/queue/service.ts
+class QueueService {
+  store;
+  defaultQueue;
+  enableWorker;
+  concurrency;
+  workers = new Map;
+  cronJobs = new Map;
+  cronTimers = new Map;
+  constructor(options) {
+    this.store = options.store;
+    this.defaultQueue = options.defaultQueue ?? "default";
+    this.enableWorker = options.enableWorker ?? true;
+    this.concurrency = options.concurrency ?? 1;
+    if (this.enableWorker) {
+      this.startWorker(this.defaultQueue);
+    }
+  }
+  async add(jobName, data, options, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    const jobId = await this.store.add(queue, {
+      name: jobName,
+      data,
+      options
+    });
+    if (this.enableWorker && !this.workers.has(queue)) {
+      this.startWorker(queue);
+    }
+    return jobId;
+  }
+  async get(jobId, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.get(queue, jobId);
+  }
+  async delete(jobId, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.delete(queue, jobId);
+  }
+  async clear(queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.clear(queue);
+  }
+  async count(queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.count(queue);
+  }
+  async registerHandler(jobName, handler, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    const key = `${queue}:${jobName}`;
+    this.handlers = this.handlers ?? new Map;
+    this.handlers.set(key, handler);
+  }
+  async registerCron(jobName, handler, options, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    const key = `${queue}:${jobName}`;
+    this.cronJobs.set(key, { handler, options });
+    if (options.runOnInit) {
+      await this.add(jobName, {}, undefined, queue);
+    }
+    const interval = this.parseCronInterval(options.pattern);
+    if (interval > 0) {
+      const timer = setInterval(async () => {
+        await this.add(jobName, {}, undefined, queue);
+      }, interval);
+      this.cronTimers.set(key, timer);
+    }
+  }
+  startWorker(queueName) {
+    if (this.workers.has(queueName)) {
+      return;
+    }
+    const workerSet = new Set;
+    this.workers.set(queueName, workerSet);
+    for (let i = 0;i < this.concurrency; i++) {
+      const worker = this.processQueue(queueName);
+      workerSet.add(worker);
+    }
+  }
+  async processQueue(queueName) {
+    while (true) {
+      try {
+        const job = await this.store.getNext(queueName);
+        if (!job) {
+          await new Promise((resolve2) => setTimeout(resolve2, 1000));
+          continue;
+        }
+        await this.store.updateStatus(queueName, job.id, "active");
+        try {
+          const handler = this.getHandler(job.name, queueName);
+          if (handler) {
+            await handler(job);
+            await this.store.updateStatus(queueName, job.id, "completed");
+          } else {
+            await this.store.updateStatus(queueName, job.id, "failed");
+          }
+        } catch (error) {
+          await this.store.updateStatus(queueName, job.id, "failed");
+          console.error(`Job ${job.id} failed:`, error);
+        }
+      } catch (error) {
+        console.error(`Error processing queue ${queueName}:`, error);
+        await new Promise((resolve2) => setTimeout(resolve2, 1000));
+      }
+    }
+  }
+  getHandler(jobName, queueName) {
+    const key = `${queueName}:${jobName}`;
+    return this.handlers?.get(key);
+  }
+  parseCronInterval(pattern) {
+    const parts = pattern.trim().split(/\s+/);
+    if (parts.length !== 5) {
+      return -1;
+    }
+    const [minute, hour, day, month, weekday] = parts;
+    if (minute === "*" && hour === "*" && day === "*" && month === "*" && weekday === "*") {
+      return 60000;
+    }
+    if (/^\d+$/.test(minute) && hour === "*" && day === "*" && month === "*" && weekday === "*") {
+      return parseInt(minute, 10) * 60000;
+    }
+    return -1;
+  }
+  destroy() {
+    for (const timer of this.cronTimers.values()) {
+      clearInterval(timer);
+    }
+    this.cronTimers.clear();
+    this.cronJobs.clear();
+    this.workers.clear();
+  }
+}
+QueueService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(QUEUE_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof QueueModuleOptions === "undefined" ? Object : QueueModuleOptions
+  ])
+], QueueService);
+
+// src/queue/queue-module.ts
+class QueueModule {
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const store = options.store ?? new MemoryQueueStore;
+    const service = new QueueService({
+      store,
+      defaultQueue: options.defaultQueue,
+      enableWorker: options.enableWorker,
+      concurrency: options.concurrency
+    });
+    providers2.push({
+      provide: QUEUE_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: QUEUE_OPTIONS_TOKEN,
+      useValue: options
+    }, QueueService);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        QUEUE_SERVICE_TOKEN,
+        QUEUE_OPTIONS_TOKEN,
+        QueueService
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, QueueModule);
+    return QueueModule;
+  }
+}
+QueueModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], QueueModule);
+// src/queue/decorators.ts
+import"reflect-metadata";
+var QUEUE_METADATA_KEY = Symbol("@dangao/bun-server:queue:queue");
+var CRON_METADATA_KEY = Symbol("@dangao/bun-server:queue:cron");
+function Queue(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      name: options.name
+    };
+    Reflect.defineMetadata(QUEUE_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+function Cron(options) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      pattern: options.pattern,
+      timezone: options.timezone,
+      runOnInit: options.runOnInit ?? false,
+      queueName: options.queueName
+    };
+    Reflect.defineMetadata(CRON_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+// src/session/service.ts
+import { randomBytes } from "crypto";
+class SessionService {
+  store;
+  name;
+  maxAge;
+  rolling;
+  cookieOptions;
+  constructor(options) {
+    this.store = options.store;
+    this.name = options.name ?? "sessionId";
+    this.maxAge = options.maxAge ?? 86400000;
+    this.rolling = options.rolling ?? true;
+    this.cookieOptions = {
+      secure: options.cookie?.secure ?? false,
+      httpOnly: options.cookie?.httpOnly ?? true,
+      path: options.cookie?.path ?? "/",
+      domain: options.cookie?.domain,
+      sameSite: options.cookie?.sameSite ?? "lax"
+    };
+  }
+  generateSessionId() {
+    return randomBytes(32).toString("hex");
+  }
+  async create(initialData = {}) {
+    const now = Date.now();
+    const session = {
+      id: this.generateSessionId(),
+      data: initialData,
+      createdAt: now,
+      lastAccessedAt: now,
+      expiresAt: now + this.maxAge
+    };
+    await this.store.set(session, this.maxAge);
+    return session;
+  }
+  async get(sessionId) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return;
+    }
+    if (this.rolling) {
+      await this.touch(sessionId);
+    }
+    return session;
+  }
+  async set(sessionId, data) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    session.data = { ...session.data, ...data };
+    session.lastAccessedAt = Date.now();
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+    return this.store.set(session, this.maxAge);
+  }
+  async getValue(sessionId, key) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return;
+    }
+    return session.data[key];
+  }
+  async setValue(sessionId, key, value) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    session.data[key] = value;
+    session.lastAccessedAt = Date.now();
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+    return this.store.set(session, this.maxAge);
+  }
+  async deleteValue(sessionId, key) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    delete session.data[key];
+    session.lastAccessedAt = Date.now();
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+    return this.store.set(session, this.maxAge);
+  }
+  async delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  async touch(sessionId) {
+    return this.store.touch(sessionId);
+  }
+  getCookieName() {
+    return this.name;
+  }
+  getCookieOptions() {
+    return this.cookieOptions;
+  }
+  getMaxAge() {
+    return this.maxAge;
+  }
+}
+SessionService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(SESSION_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof SessionModuleOptions === "undefined" ? Object : SessionModuleOptions
+  ])
+], SessionService);
+
+// src/session/session-module.ts
+class SessionModule {
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const store = options.store ?? new MemorySessionStore({
+      cleanupInterval: 60000
+    });
+    const service = new SessionService({
+      store,
+      name: options.name,
+      maxAge: options.maxAge,
+      rolling: options.rolling,
+      cookie: options.cookie
+    });
+    providers2.push({
+      provide: SESSION_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: SESSION_OPTIONS_TOKEN,
+      useValue: options
+    }, SessionService);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, SessionModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        SESSION_SERVICE_TOKEN,
+        SESSION_OPTIONS_TOKEN,
+        SessionService
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, SessionModule);
+    return SessionModule;
+  }
+}
+SessionModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], SessionModule);
+// src/session/middleware.ts
+function createSessionMiddleware(container) {
+  return async (context2, next) => {
+    let sessionService;
+    try {
+      sessionService = container.resolve(SESSION_SERVICE_TOKEN);
+    } catch {
+      return await next();
+    }
+    if (!sessionService) {
+      return await next();
+    }
+    const cookieName = sessionService.getCookieName();
+    const cookieHeader = context2.request.headers.get("cookie");
+    let sessionId;
+    if (cookieHeader) {
+      const cookies = cookieHeader.split(";").map((c) => c.trim());
+      for (const cookie of cookies) {
+        if (cookie.startsWith(`${cookieName}=`)) {
+          sessionId = cookie.substring(cookieName.length + 1).trim();
+          break;
+        }
+      }
+    }
+    if (sessionId) {
+      const session = await sessionService.get(sessionId);
+      if (session) {
+        context2.session = session;
+        context2.sessionId = sessionId;
+      } else {
+        sessionId = undefined;
+      }
+    }
+    if (!sessionId) {
+      const newSession = await sessionService.create();
+      context2.session = newSession;
+      context2.sessionId = newSession.id;
+      sessionId = newSession.id;
+    }
+    const response = await next();
+    const currentSessionId = context2.sessionId;
+    if (currentSessionId) {
+      const cookieOptions = sessionService.getCookieOptions();
+      const maxAge = sessionService.getMaxAge();
+      const cookieValue = buildCookie(cookieName, currentSessionId, {
+        ...cookieOptions,
+        maxAge
+      });
+      const newHeaders = new Headers(response.headers);
+      newHeaders.set("Set-Cookie", cookieValue);
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders
+      });
+    }
+    return response;
+  };
+}
+function buildCookie(name, value, options) {
+  let cookie = `${name}=${value}`;
+  if (options.path) {
+    cookie += `; Path=${options.path}`;
+  }
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+  if (options.maxAge) {
+    cookie += `; Max-Age=${Math.floor(options.maxAge / 1000)}`;
+  }
+  if (options.secure) {
+    cookie += "; Secure";
+  }
+  if (options.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite}`;
+  }
+  return cookie;
+}
+// src/session/decorators.ts
+import"reflect-metadata";
+function Session() {
+  return createParamDecorator("session" /* SESSION */);
+}
 export {
   requiresAuth,
   getTransactionMetadata,
@@ -5192,6 +6266,7 @@ export {
   createTokenKeyGenerator,
   createSwaggerUIMiddleware,
   createStaticFileMiddleware,
+  createSessionMiddleware,
   createSecurityFilter,
   createRequestLoggingMiddleware,
   createRateLimitMiddleware,
@@ -5216,8 +6291,13 @@ export {
   SwaggerGenerator,
   SwaggerExtension,
   StressTester,
+  SessionService,
+  SessionModule,
+  Session,
   SecurityModule,
   SecurityContextHolder,
+  SESSION_SERVICE_TOKEN,
+  SESSION_OPTIONS_TOKEN,
   Router,
   RouteRegistry,
   Route,
@@ -5225,8 +6305,15 @@ export {
   ResponseBuilder,
   RequestWrapper,
   Repository,
+  RedisSessionStore,
+  RedisCacheStore,
   RateLimit,
+  QueueService,
+  QueueModule,
+  Queue,
   Query,
+  QUEUE_SERVICE_TOKEN,
+  QUEUE_OPTIONS_TOKEN,
   Propagation,
   PrometheusFormatter,
   PrimaryKey,
@@ -5252,6 +6339,9 @@ export {
   MiddlewarePipeline,
   MetricsModule,
   MetricsCollector,
+  MemorySessionStore,
+  MemoryQueueStore,
+  MemoryCacheStore,
   METRICS_SERVICE_TOKEN,
   METRICS_OPTIONS_TOKEN,
   LoggerModule,
@@ -5288,6 +6378,7 @@ export {
   DELETE,
   DATABASE_SERVICE_TOKEN,
   DATABASE_OPTIONS_TOKEN,
+  Cron,
   ControllerRegistry,
   Controller,
   Context,
@@ -5296,7 +6387,14 @@ export {
   ConfigService,
   ConfigModule,
   Column,
+  Cacheable,
+  CacheService,
+  CachePut,
+  CacheModule,
+  CacheEvict,
   CONFIG_SERVICE_TOKEN,
+  CACHE_SERVICE_TOKEN,
+  CACHE_OPTIONS_TOKEN,
   BunServer,
   BodyParser,
   Body,