@kabyeon/nexusjs 0.6.5

package/dist/limiter/index.js

@@ -0,0 +1,640 @@
+// @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/limiter/types.ts
+import"reflect-metadata";
+var LIMITER_RULE_KEY = Symbol.for("nexus:RateLimitRule");
+function RateLimit(rule) {
+  return (target, propertyKey, descriptor) => {
+    if (descriptor === undefined) {
+      const existing2 = Reflect.getMetadata(LIMITER_RULE_KEY, target) ?? [];
+      existing2.push({ ...rule, path: "**" });
+      Reflect.defineMetadata(LIMITER_RULE_KEY, existing2, target);
+      return target;
+    }
+    const existing = Reflect.getMetadata(LIMITER_RULE_KEY, target.constructor) ?? [];
+    existing.push({ ...rule, path: propertyKey === undefined ? "**" : `**` });
+    Reflect.defineMetadata(LIMITER_RULE_KEY, existing, target.constructor);
+  };
+}
+function getLimiterRules(target) {
+  return Reflect.getMetadata(LIMITER_RULE_KEY, target) ?? [];
+}
+function durationToMs(d) {
+  if (typeof d === "number")
+    return d;
+  const m = /^(\d+)([smhd])$/.exec(d);
+  if (!m)
+    throw new Error(`Invalid duration: ${d}`);
+  const n = Number(m[1]);
+  const unit = m[2];
+  const mult = {
+    s: 1000,
+    m: 60000,
+    h: 3600000,
+    d: 86400000
+  };
+  return n * mult[unit];
+}
+// src/limiter/backends/memory.ts
+class MemoryRateLimitStorage {
+  kind = "memory";
+  fixed = new Map;
+  sliding = new Map;
+  token = new Map;
+  async consume(key, points, limit, durationMs, strategy = "sliding-window") {
+    const now = Date.now();
+    switch (strategy) {
+      case "fixed-window":
+        return this.consumeFixed(key, points, limit, durationMs, now);
+      case "sliding-window":
+        return this.consumeSliding(key, points, limit, durationMs, now);
+      case "token-bucket":
+        return this.consumeToken(key, points, limit, durationMs, now);
+      default: {
+        const _ = strategy;
+        throw new Error(`Unknown strategy: ${_}`);
+      }
+    }
+  }
+  async reset(key) {
+    this.fixed.delete(key);
+    this.sliding.delete(key);
+    this.token.delete(key);
+  }
+  consumeFixed(key, points, limit, durationMs, now) {
+    let b = this.fixed.get(key);
+    if (!b || b.resetAt <= now) {
+      b = { resetAt: now + durationMs, count: 0 };
+      this.fixed.set(key, b);
+    }
+    b.count += points;
+    const allowed = b.count <= limit;
+    return {
+      allowed,
+      remaining: Math.max(0, limit - b.count),
+      limit,
+      resetAt: b.resetAt,
+      retryAfter: allowed ? 0 : Math.ceil((b.resetAt - now) / 1000)
+    };
+  }
+  consumeSliding(key, points, limit, durationMs, now) {
+    let s = this.sliding.get(key);
+    if (!s) {
+      s = { log: [] };
+      this.sliding.set(key, s);
+    }
+    const cutoff = now - durationMs;
+    s.log = s.log.filter((t) => t > cutoff);
+    const inWindow = s.log.length + points;
+    const allowed = inWindow <= limit;
+    if (allowed) {
+      for (let i = 0;i < points; i++)
+        s.log.push(now);
+    }
+    const oldest = s.log[0] ?? now;
+    return {
+      allowed,
+      remaining: Math.max(0, limit - s.log.length),
+      limit,
+      resetAt: now + durationMs,
+      retryAfter: allowed ? 0 : Math.ceil((oldest + durationMs - now) / 1000)
+    };
+  }
+  consumeToken(key, points, limit, durationMs, now) {
+    let b = this.token.get(key);
+    const refillPerMs = limit / durationMs;
+    if (!b) {
+      b = { tokens: limit, updatedAt: now };
+      this.token.set(key, b);
+    } else {
+      const elapsed = now - b.updatedAt;
+      b.tokens = Math.min(limit, b.tokens + elapsed * refillPerMs);
+      b.updatedAt = now;
+    }
+    const allowed = b.tokens >= points;
+    if (allowed)
+      b.tokens -= points;
+    return {
+      allowed,
+      remaining: Math.floor(b.tokens),
+      limit,
+      resetAt: now + durationMs,
+      retryAfter: allowed ? 0 : Math.ceil((points - b.tokens) / refillPerMs / 1000)
+    };
+  }
+}
+// src/limiter/backends/drizzle.ts
+class DrizzleRateLimitStorage {
+  kind = "drizzle";
+  #db;
+  #table;
+  constructor(db, options = {}) {
+    this.#db = db;
+    this.#table = options.tableName ?? "nexus_rate_limits";
+  }
+  async consume(key, points, limit, durationMs, strategy = "sliding-window") {
+    const now = Date.now();
+    const resetAt = now + durationMs;
+    const rows = await this.#db.rawQuery(`SELECT * FROM ${this.#table} WHERE key = ? LIMIT 1`, [key]);
+    const existing = rows[0];
+    if (!existing) {
+      const initialLog = strategy === "sliding-window" ? JSON.stringify(Array(points).fill(now)) : null;
+      await this.#db.rawQuery(`INSERT INTO ${this.#table} (key, strategy, max_points, points, reset_at, log)
+				 VALUES (?, ?, ?, ?, ?, ?)`, [
+        key,
+        strategy,
+        limit,
+        strategy === "sliding-window" ? 0 : 1,
+        new Date(resetAt).toISOString(),
+        initialLog
+      ]);
+      return {
+        allowed: true,
+        remaining: limit - 1,
+        limit,
+        resetAt,
+        retryAfter: 0
+      };
+    }
+    const result = await this.#applyStrategy(existing, points, limit, durationMs, now);
+    return result;
+  }
+  async reset(key) {
+    await this.#db.rawQuery(`DELETE FROM ${this.#table} WHERE key = ?`, [key]);
+  }
+  async#applyStrategy(row, points, limit, durationMs, now) {
+    const strategy = row.strategy;
+    const resetAt = Number(new Date(row.reset_at).getTime());
+    if (strategy === "fixed-window") {
+      if (resetAt <= now) {
+        await this.#db.rawQuery(`UPDATE ${this.#table} SET points = 1, reset_at = ? WHERE key = ?`, [new Date(now + durationMs).toISOString(), row.key]);
+        return {
+          allowed: true,
+          remaining: limit - 1,
+          limit,
+          resetAt: now + durationMs,
+          retryAfter: 0
+        };
+      }
+      const newPoints = (row.points ?? 0) + 1;
+      const allowed = newPoints <= limit;
+      await this.#db.rawQuery(`UPDATE ${this.#table} SET points = ? WHERE key = ?`, [newPoints, row.key]);
+      return {
+        allowed,
+        remaining: Math.max(0, limit - newPoints),
+        limit,
+        resetAt,
+        retryAfter: allowed ? 0 : Math.ceil((resetAt - now) / 1000)
+      };
+    }
+    if (strategy === "sliding-window") {
+      const log = row.log ? JSON.parse(row.log) : [];
+      const cutoff = now - durationMs;
+      const fresh = log.filter((t) => t > cutoff);
+      fresh.push(now);
+      const used = fresh.length;
+      const allowed = used <= limit;
+      await this.#db.rawQuery(`UPDATE ${this.#table} SET log = ?, points = ? WHERE key = ?`, [JSON.stringify(fresh), used, row.key]);
+      const oldest = fresh[0] ?? now;
+      return {
+        allowed,
+        remaining: Math.max(0, limit - used),
+        limit,
+        resetAt: now + durationMs,
+        retryAfter: allowed ? 0 : Math.ceil((oldest + durationMs - now) / 1000)
+      };
+    }
+    if (strategy === "token-bucket") {
+      const elapsed = Math.max(0, now - resetAt);
+      const refillPerMs = limit / durationMs;
+      let tokens = Math.min(limit, (row.points ?? 0) + elapsed * refillPerMs);
+      const allowed = tokens >= 1;
+      if (allowed)
+        tokens -= 1;
+      await this.#db.rawQuery(`UPDATE ${this.#table} SET points = ?, reset_at = ? WHERE key = ?`, [tokens, new Date(now).toISOString(), row.key]);
+      return {
+        allowed,
+        remaining: Math.floor(tokens),
+        limit,
+        resetAt: now + durationMs,
+        retryAfter: allowed ? 0 : Math.ceil((1 - tokens) / refillPerMs / 1000)
+      };
+    }
+    throw new Error(`Unknown strategy: ${strategy}`);
+  }
+}
+// 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/limiter/limiter.service.ts
+class LimiterService {
+  static TOKEN = Symbol.for("nexus:LimiterService");
+  storage;
+  rules;
+  defaultKey;
+  defaultReject;
+  constructor(config = {}) {
+    this.storage = config.storage ?? new MemoryRateLimitStorage;
+    this.rules = config.rules ?? [];
+    this.defaultKey = config.defaultKey ?? ((c) => {
+      const fwd = c?.req?.header?.("x-forwarded-for");
+      if (fwd)
+        return fwd.split(",")[0]?.trim() ?? "unknown";
+      return c?.req?.raw?.["conn"]?.remoteAddr?.hostname ?? "unknown";
+    });
+    this.defaultReject = config.defaultReject ?? ((_c, result) => new Response(JSON.stringify({
+      error: "Too Many Requests",
+      limit: result.limit,
+      remaining: 0,
+      retryAfter: result.retryAfter
+    }), {
+      status: 429,
+      headers: {
+        "Content-Type": "application/json",
+        "Retry-After": String(result.retryAfter),
+        "X-RateLimit-Limit": String(result.limit),
+        "X-RateLimit-Remaining": "0",
+        "X-RateLimit-Reset": String(Math.ceil(result.resetAt / 1000))
+      }
+    }));
+  }
+  async check(key, rule) {
+    const durationMs = durationToMs(rule.duration);
+    return this.storage.consume(key, 1, rule.points, durationMs, rule.strategy ?? "sliding-window");
+  }
+  async reset(key) {
+    await this.storage.reset(key);
+  }
+}
+LimiterService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("LIMITER_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LimiterConfig === "undefined" ? Object : LimiterConfig
+  ])
+], LimiterService);
+// src/limiter/limiter.middleware.ts
+class LimiterMiddleware {
+  limiter;
+  static TOKEN = Symbol.for("nexus:LimiterMiddleware");
+  constructor(limiter) {
+    this.limiter = limiter;
+  }
+  middleware() {
+    return async (c, next) => {
+      const method = c.req.method.toUpperCase();
+      for (const rule of this.limiter.rules) {
+        if (!this.matches(rule, method, c.req.path))
+          continue;
+        if (rule.skip && await rule.skip(c))
+          continue;
+        const keyFn = rule.key ?? this.limiter.defaultKey;
+        const key = await keyFn(c) ?? "unknown";
+        const result = await this.limiter.check(key, rule);
+        c.header?.("X-RateLimit-Limit", String(result.limit));
+        c.header?.("X-RateLimit-Remaining", String(result.remaining));
+        c.header?.("X-RateLimit-Reset", String(Math.ceil(result.resetAt / 1000)));
+        if (!result.allowed) {
+          const reject = rule.reject ?? this.limiter.defaultReject;
+          return reject(c, result);
+        }
+      }
+      return next();
+    };
+  }
+  matches(rule, method, path) {
+    if (rule.methods && rule.methods.length > 0) {
+      if (!rule.methods.map((m) => m.toUpperCase()).includes(method))
+        return false;
+    }
+    if (rule.path === "**")
+      return true;
+    return matchGlob(rule.path, path);
+  }
+}
+LimiterMiddleware = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(LimiterService.TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LimiterService === "undefined" ? Object : LimiterService
+  ])
+], LimiterMiddleware);
+function matchGlob(pattern, path) {
+  const regex = new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DOUBLESTAR::").replace(/\*/g, "[^/]+").replace(/::DOUBLESTAR::/g, ".*") + "/?$");
+  return regex.test(path);
+}
+// src/limiter/limiter.module.ts
+import"reflect-metadata";
+class LimiterModule {
+  static forRoot(config = {}) {
+    const cfg = {
+      storage: new MemoryRateLimitStorage,
+      ...config
+    };
+
+    class ConfiguredLimiterModule {
+    }
+    ConfiguredLimiterModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          LimiterService,
+          { provide: LimiterService.TOKEN, useExisting: LimiterService },
+          LimiterMiddleware,
+          { provide: LimiterMiddleware.TOKEN, useExisting: LimiterMiddleware },
+          { provide: "LIMITER_CONFIG", useValue: cfg }
+        ],
+        exports: [
+          LimiterService,
+          LimiterService.TOKEN,
+          LimiterMiddleware,
+          LimiterMiddleware.TOKEN
+        ]
+      })
+    ], ConfiguredLimiterModule);
+    Object.defineProperty(ConfiguredLimiterModule, "name", {
+      value: "ConfiguredLimiterModule"
+    });
+    return ConfiguredLimiterModule;
+  }
+}
+LimiterModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      LimiterService,
+      { provide: LimiterService.TOKEN, useExisting: LimiterService },
+      LimiterMiddleware,
+      { provide: LimiterMiddleware.TOKEN, useExisting: LimiterMiddleware }
+    ],
+    exports: [
+      LimiterService,
+      LimiterService.TOKEN,
+      LimiterMiddleware,
+      LimiterMiddleware.TOKEN
+    ]
+  })
+], LimiterModule);
+export {
+  getLimiterRules,
+  durationToMs,
+  RateLimit,
+  MemoryRateLimitStorage,
+  LimiterService,
+  LimiterModule,
+  LimiterMiddleware,
+  LIMITER_RULE_KEY
+};
+
+//# debugId=275C9EEE8EE4A8EB64756E2164756E21
+//# sourceMappingURL=index.js.map