@kabyeon/nexusjs 0.6.5

package/dist/cache/index.js

@@ -0,0 +1,814 @@
+// @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/cache/types.ts
+init_constants();
+import"reflect-metadata";
+var CACHEABLE_META = "nexus:cache:cacheable";
+var CACHE_INVALIDATE_META = "nexus:cache:invalidate";
+function Cacheable(prefix, keyFn, ttlSeconds = 60) {
+  return (target, propertyKey, descriptor) => {
+    const existing = Reflect.getMetadata(CACHEABLE_META, target.constructor) ?? [];
+    existing.push({
+      prefix,
+      keyFn,
+      ttl: ttlSeconds,
+      propertyKey,
+      original: descriptor.value
+    });
+    Reflect.defineMetadata(CACHEABLE_META, existing, target.constructor);
+  };
+}
+function CacheInvalidate(prefix, keyFn) {
+  return (target, propertyKey, descriptor) => {
+    const existing = Reflect.getMetadata(CACHE_INVALIDATE_META, target.constructor) ?? [];
+    existing.push({ prefix, keyFn, propertyKey, original: descriptor.value });
+    Reflect.defineMetadata(CACHE_INVALIDATE_META, existing, target.constructor);
+  };
+}
+function getCacheableSpecs(target) {
+  return Reflect.getMetadata(CACHEABLE_META, target) ?? [];
+}
+function getCacheInvalidateSpecs(target) {
+  return Reflect.getMetadata(CACHE_INVALIDATE_META, target) ?? [];
+}
+// src/cache/stores/memory.ts
+class MemoryStore {
+  kind = "memory";
+  data = new Map;
+  tagIndex = new Map;
+  max;
+  sweepTimer = null;
+  constructor(opts = {}) {
+    this.max = opts.max ?? 1e4;
+    const sweepMs = opts.sweepIntervalMs ?? 30000;
+    if (sweepMs > 0) {
+      this.sweepTimer = setInterval(() => this.sweepExpired(), sweepMs);
+      if (typeof this.sweepTimer === "object" && this.sweepTimer !== null) {
+        this.sweepTimer.unref?.();
+      }
+    }
+  }
+  async get(key) {
+    const e = this.data.get(key);
+    if (!e)
+      return;
+    if (e.expiresAt > 0 && e.expiresAt <= Date.now()) {
+      this.data.delete(key);
+      return;
+    }
+    this.data.delete(key);
+    this.data.set(key, e);
+    return e.value;
+  }
+  async set(key, value, opts = {}) {
+    const ttl = opts.ttl ?? 0;
+    const entry = {
+      value,
+      expiresAt: ttl > 0 ? Date.now() + ttl * 1000 : 0,
+      tags: opts.tags
+    };
+    if (!this.data.has(key) && this.data.size >= this.max) {
+      const oldest = this.data.keys().next().value;
+      if (oldest !== undefined) {
+        this.data.delete(oldest);
+        for (const keys of this.tagIndex.values())
+          keys.delete(oldest);
+      }
+    }
+    this.data.set(key, entry);
+    if (opts.tags) {
+      for (const [, keys] of this.tagIndex.entries())
+        keys.delete(key);
+      for (const tag of opts.tags) {
+        let set = this.tagIndex.get(tag);
+        if (!set) {
+          set = new Set;
+          this.tagIndex.set(tag, set);
+        }
+        set.add(key);
+      }
+    }
+  }
+  async delete(key) {
+    const deleted = this.data.delete(key);
+    for (const keys of this.tagIndex.values())
+      keys.delete(key);
+    return deleted;
+  }
+  async clear(pattern) {
+    if (!pattern) {
+      const n2 = this.data.size;
+      this.data.clear();
+      this.tagIndex.clear();
+      return n2;
+    }
+    const rx = globToRegExp(pattern);
+    let n = 0;
+    for (const k of [...this.data.keys()]) {
+      if (rx.test(k)) {
+        this.data.delete(k);
+        for (const keys of this.tagIndex.values())
+          keys.delete(k);
+        n++;
+      }
+    }
+    return n;
+  }
+  async wrap(key, fn, ttl) {
+    const v = await this.get(key);
+    if (v !== undefined)
+      return v;
+    const result = await fn();
+    await this.set(key, result, { ttl });
+    return result;
+  }
+  async invalidateByTag(tag) {
+    const keys = this.tagIndex.get(tag);
+    if (!keys)
+      return 0;
+    let n = 0;
+    for (const k of keys) {
+      if (this.data.delete(k))
+        n++;
+    }
+    this.tagIndex.delete(tag);
+    return n;
+  }
+  async close() {
+    if (this.sweepTimer)
+      clearInterval(this.sweepTimer);
+    this.sweepTimer = null;
+    this.data.clear();
+    this.tagIndex.clear();
+  }
+  sweepExpired() {
+    const now = Date.now();
+    for (const [k, e] of this.data.entries()) {
+      if (e.expiresAt > 0 && e.expiresAt <= now)
+        this.data.delete(k);
+    }
+    for (const [tag, keys] of this.tagIndex.entries()) {
+      for (const k of keys) {
+        if (!this.data.has(k))
+          keys.delete(k);
+      }
+      if (keys.size === 0)
+        this.tagIndex.delete(tag);
+    }
+  }
+}
+function globToRegExp(pattern) {
+  return new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DBL::").replace(/\*/g, "[^:]+").replace(/::DBL::/g, ".*") + "$");
+}
+// src/cache/stores/drizzle.ts
+class DrizzleCacheStore {
+  kind = "drizzle";
+  db;
+  t;
+  tagsT;
+  c;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.t = options.tableName ?? "nexus_cache";
+    this.tagsT = options.tagsTableName ?? "nexus_cache_tags";
+    this.c = {
+      key: options.columns?.key ?? "key",
+      value: options.columns?.value ?? "value",
+      expiresAt: options.columns?.expiresAt ?? "expires_at",
+      createdAt: options.columns?.createdAt ?? "created_at",
+      updatedAt: options.columns?.updatedAt ?? "updated_at",
+      tag: options.columns?.tag ?? "tag"
+    };
+  }
+  async get(key) {
+    const rows = await this.db.rawQuery(`SELECT * FROM ${this.t} WHERE ${this.c.key} = ? LIMIT 1`, [key]);
+    const row = rows[0];
+    if (!row)
+      return;
+    const expiresAt = row[this.c.expiresAt];
+    if (expiresAt && new Date(expiresAt).getTime() <= Date.now()) {
+      await this.delete(key);
+      return;
+    }
+    const raw = row[this.c.value];
+    if (raw === null || raw === undefined)
+      return;
+    try {
+      return JSON.parse(String(raw));
+    } catch {
+      return;
+    }
+  }
+  async set(key, value, opts = {}) {
+    const now = new Date().toISOString();
+    const expiresAt = opts.ttl && opts.ttl > 0 ? new Date(Date.now() + opts.ttl * 1000).toISOString() : null;
+    const serialized = JSON.stringify(value);
+    await this.db.rawQuery(`INSERT INTO ${this.t} (${this.c.key}, ${this.c.value}, ${this.c.expiresAt}, ${this.c.createdAt}, ${this.c.updatedAt})
+			 VALUES (?, ?, ?, ?, ?)
+			 ON CONFLICT (${this.c.key}) DO UPDATE SET
+			   ${this.c.value} = excluded.${this.c.value},
+			   ${this.c.expiresAt} = excluded.${this.c.expiresAt},
+			   ${this.c.updatedAt} = excluded.${this.c.updatedAt}`, [key, serialized, expiresAt, now, now]);
+    if (opts.tags && opts.tags.length > 0) {
+      await this.db.rawQuery(`DELETE FROM ${this.tagsT} WHERE ${this.c.key} = ?`, [key]);
+      for (const tag of opts.tags) {
+        await this.db.rawQuery(`INSERT OR IGNORE INTO ${this.tagsT} (${this.c.tag}, ${this.c.key}) VALUES (?, ?)`, [tag, key]);
+      }
+    }
+  }
+  async delete(key) {
+    const probe = await this.db.rawQuery(`SELECT ${this.c.key} FROM ${this.t} WHERE ${this.c.key} = ? LIMIT 1`, [key]);
+    if (probe.length === 0)
+      return false;
+    await this.db.rawQuery(`DELETE FROM ${this.t} WHERE ${this.c.key} = ?`, [key]);
+    await this.db.rawQuery(`DELETE FROM ${this.tagsT} WHERE ${this.c.key} = ?`, [key]);
+    return true;
+  }
+  async clear(pattern) {
+    if (!pattern) {
+      await this.db.rawQuery(`DELETE FROM ${this.tagsT}`);
+      const before2 = await this.db.rawQuery(`SELECT COUNT(*) as n FROM ${this.t}`);
+      await this.db.rawQuery(`DELETE FROM ${this.t}`);
+      const n = Number(before2[0]?.n ?? 0);
+      return n;
+    }
+    const likePattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "%").replace(/\*/g, "%");
+    const before = await this.db.rawQuery(`SELECT COUNT(*) as n FROM ${this.t} WHERE ${this.c.key} LIKE ? ESCAPE '\\'`, [likePattern]);
+    await this.db.rawQuery(`DELETE FROM ${this.t} WHERE ${this.c.key} LIKE ? ESCAPE '\\'`, [likePattern]);
+    return Number(before[0]?.n ?? 0);
+  }
+  async wrap(key, fn, ttl) {
+    const hit = await this.get(key);
+    if (hit !== undefined)
+      return hit;
+    const v = await fn();
+    await this.set(key, v, { ttl });
+    return v;
+  }
+  async invalidateByTag(tag) {
+    const tagRows = await this.db.rawQuery(`SELECT ${this.c.key} FROM ${this.tagsT} WHERE ${this.c.tag} = ?`, [tag]);
+    const keys = tagRows.map((r) => r[this.c.key]);
+    if (keys.length === 0)
+      return 0;
+    const chunkSize = 100;
+    let removed = 0;
+    for (let i = 0;i < keys.length; i += chunkSize) {
+      const chunk = keys.slice(i, i + chunkSize);
+      const placeholders = chunk.map(() => "?").join(", ");
+      const r1 = await this.db.rawQuery(`DELETE FROM ${this.t} WHERE ${this.c.key} IN (${placeholders})`, chunk);
+      const r2 = await this.db.rawQuery(`DELETE FROM ${this.tagsT} WHERE ${this.c.key} IN (${placeholders})`, chunk);
+      removed += Math.max(r1.length, r2.length, chunk.length);
+    }
+    return removed;
+  }
+  async gc() {
+    const now = new Date().toISOString();
+    const before = await this.db.rawQuery(`SELECT COUNT(*) as n FROM ${this.t} WHERE ${this.c.expiresAt} IS NOT NULL AND ${this.c.expiresAt} <= ?`, [now]);
+    await this.db.rawQuery(`DELETE FROM ${this.t} WHERE ${this.c.expiresAt} IS NOT NULL AND ${this.c.expiresAt} <= ?`, [now]);
+    await this.db.rawQuery(`DELETE FROM ${this.tagsT} WHERE ${this.c.key} NOT IN (SELECT ${this.c.key} FROM ${this.t})`);
+    return Number(before[0]?.n ?? 0);
+  }
+  async close() {}
+}
+// src/cache/stores/redis.ts
+var DEFAULT_KEY_PREFIX = "cache:";
+
+class RedisCacheStore {
+  kind = "redis";
+  #client;
+  #keyPrefix;
+  #tagKeyPrefix;
+  constructor(client, options = {}) {
+    this.#client = client;
+    this.#keyPrefix = options.keyPrefix ?? DEFAULT_KEY_PREFIX;
+    this.#tagKeyPrefix = `${this.#keyPrefix}tag:`;
+  }
+  #key(key) {
+    return `${this.#keyPrefix}${key}`;
+  }
+  #tagKey(tag) {
+    return `${this.#tagKeyPrefix}${crc32(tag)}`;
+  }
+  async get(key) {
+    const raw = await this.#client.get(this.#key(key));
+    if (raw === null)
+      return;
+    try {
+      const entry = JSON.parse(raw);
+      if (entry.expiresAt && entry.expiresAt <= Date.now()) {
+        await this.#client.del(this.#key(key));
+        return;
+      }
+      return entry.value;
+    } catch {
+      return;
+    }
+  }
+  async set(key, value, opts) {
+    const ttl = opts?.ttl ?? 0;
+    const tags = opts?.tags ?? [];
+    const entry = {
+      value,
+      expiresAt: ttl > 0 ? Date.now() + ttl * 1000 : 0,
+      ...tags.length > 0 ? { tags } : {}
+    };
+    const fullKey = this.#key(key);
+    const ex = ttl > 0 ? ttl : undefined;
+    await this.#client.set(fullKey, JSON.stringify(entry), ex ? { ex } : undefined);
+    for (const tag of tags) {
+      await this.#addToTagIndex(tag, key);
+    }
+  }
+  async delete(key) {
+    const fullKey = this.#key(key);
+    const existed = await this.#client.get(fullKey) !== null;
+    await this.#client.del(fullKey);
+    return existed;
+  }
+  async has(key) {
+    return this.#client.exists(this.#key(key));
+  }
+  async clear() {
+    let n = 0;
+    let cursor = "0";
+    do {
+      const res = await this.#client.scan({
+        match: `${this.#keyPrefix}*`,
+        cursor,
+        count: 100
+      });
+      for (const k of res.keys) {
+        await this.#client.del(this.#keyPrefix + k);
+        n++;
+      }
+      cursor = res.cursor;
+    } while (cursor !== "0" && cursor !== 0);
+    return n;
+  }
+  async gc() {
+    let removed = 0;
+    let cursor = "0";
+    do {
+      const res = await this.#client.scan({
+        match: `${this.#tagKeyPrefix}*`,
+        cursor,
+        count: 100
+      });
+      for (const k of res.keys) {
+        const raw = await this.#client.get(this.#keyPrefix + k);
+        const ids = raw ? safeParseStringArray(raw) : [];
+        const live = [];
+        for (const id of ids) {
+          if (await this.#client.exists(this.#key(id)))
+            live.push(id);
+        }
+        if (live.length === 0) {
+          await this.#client.del(this.#keyPrefix + k);
+          removed++;
+        } else if (live.length !== ids.length) {
+          await this.#client.set(this.#keyPrefix + k, JSON.stringify(live));
+        }
+      }
+      cursor = res.cursor;
+    } while (cursor !== "0" && cursor !== 0);
+    return removed;
+  }
+  async invalidateByTag(tag) {
+    const tagK = this.#tagKey(tag);
+    const raw = await this.#client.get(tagK);
+    if (!raw)
+      return 0;
+    const keys = safeParseStringArray(raw);
+    let n = 0;
+    for (const k of keys) {
+      await this.#client.del(this.#key(k));
+      n++;
+    }
+    await this.#client.del(tagK);
+    return n;
+  }
+  async invalidateByTags(tags) {
+    let n = 0;
+    for (const t of tags)
+      n += await this.invalidateByTag(t);
+    return n;
+  }
+  async wrap(key, fn, ttl) {
+    const hit = await this.get(key);
+    if (hit !== undefined)
+      return hit;
+    const value = await fn();
+    await this.set(key, value, ttl !== undefined ? { ttl } : undefined);
+    return value;
+  }
+  async close() {
+    await this.#client.close();
+  }
+  async#addToTagIndex(tag, key) {
+    const k = this.#tagKey(tag);
+    const raw = await this.#client.get(k);
+    const ids = raw ? safeParseStringArray(raw) : [];
+    if (!ids.includes(key))
+      ids.push(key);
+    await this.#client.set(k, JSON.stringify(ids));
+  }
+}
+function safeParseStringArray(raw) {
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function crc32(s) {
+  let c = 4294967295;
+  for (let i = 0;i < s.length; i++) {
+    c ^= s.charCodeAt(i);
+    for (let k = 0;k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+  }
+  return (c ^ 4294967295).toString(16);
+}
+// 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/cache/cache.service.ts
+class CacheService {
+  static TOKEN = Symbol.for("nexus:CacheService");
+  store;
+  defaultTtl;
+  prefix;
+  constructor(config = {}) {
+    this.store = config.store ?? new MemoryStore;
+    this.defaultTtl = config.defaultTtl ?? 60;
+    this.prefix = config.prefix ?? "nexusjs";
+  }
+  key(k) {
+    return `${this.prefix}:${k}`;
+  }
+  async get(k) {
+    return this.store.get(this.key(k));
+  }
+  async set(k, value, optsOrTtl = this.defaultTtl) {
+    const opts = typeof optsOrTtl === "number" ? { ttl: optsOrTtl } : { ttl: optsOrTtl.ttl ?? this.defaultTtl, tags: optsOrTtl.tags };
+    await this.store.set(this.key(k), value, opts);
+  }
+  async delete(k) {
+    return this.store.delete(this.key(k));
+  }
+  async clear(pattern) {
+    return this.store.clear(pattern ? `${this.prefix}:${pattern}` : undefined);
+  }
+  async wrap(k, fn, ttl) {
+    return this.store.wrap(this.key(k), fn, ttl ?? this.defaultTtl);
+  }
+  async invalidateByTag(tag) {
+    if (typeof this.store.invalidateByTag === "function") {
+      return await this.store.invalidateByTag(this.prefixedTag(tag));
+    }
+    return 0;
+  }
+  async gc() {
+    if (typeof this.store.gc === "function") {
+      return await this.store.gc();
+    }
+    return 0;
+  }
+  prefixedTag(tag) {
+    return `${this.prefix}:${tag}`;
+  }
+  applyDecorators(target) {
+    const ctor = target.constructor;
+    const cacheables = getCacheableSpecs(ctor);
+    for (const spec of cacheables) {
+      const original = spec.original;
+      target[spec.propertyKey] = async (...args) => {
+        const subKey = spec.keyFn(...args);
+        return this.wrap(`${spec.prefix}:${subKey}`, () => original.apply(target, args));
+      };
+    }
+    const invalidates = getCacheInvalidateSpecs(ctor);
+    for (const spec of invalidates) {
+      const original = spec.original;
+      target[spec.propertyKey] = async (...args) => {
+        const result = await original.apply(target, args);
+        const subKey = spec.keyFn(...args);
+        await this.clear(`${spec.prefix}:${subKey}*`);
+        return result;
+      };
+    }
+  }
+}
+CacheService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("CACHE_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof CacheConfig === "undefined" ? Object : CacheConfig
+  ])
+], CacheService);
+// src/cache/cache.module.ts
+import"reflect-metadata";
+class CacheModule {
+  static forRoot(config = {}) {
+    const cfg = {
+      store: new MemoryStore,
+      ...config
+    };
+
+    class ConfiguredCacheModule {
+    }
+    ConfiguredCacheModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          CacheService,
+          { provide: CacheService.TOKEN, useExisting: CacheService },
+          { provide: "CACHE_CONFIG", useValue: cfg }
+        ],
+        exports: [CacheService, CacheService.TOKEN]
+      })
+    ], ConfiguredCacheModule);
+    Object.defineProperty(ConfiguredCacheModule, "name", {
+      value: "ConfiguredCacheModule"
+    });
+    return ConfiguredCacheModule;
+  }
+}
+CacheModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      CacheService,
+      { provide: CacheService.TOKEN, useExisting: CacheService }
+    ],
+    exports: [CacheService, CacheService.TOKEN]
+  })
+], CacheModule);
+export {
+  getCacheableSpecs,
+  getCacheInvalidateSpecs,
+  MemoryStore,
+  METADATA_KEY,
+  DrizzleCacheStore,
+  Cacheable,
+  CacheService,
+  CacheModule,
+  CacheInvalidate,
+  CACHE_INVALIDATE_META,
+  CACHEABLE_META
+};
+
+//# debugId=BEF376EA3BCD922764756E2164756E21
+//# sourceMappingURL=index.js.map