@geekmidas/rate-limit 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,139 @@
+import { Cache } from "@geekmidas/cache";
+import { Logger } from "@geekmidas/logger";
+import { Service, ServiceRecord } from "@geekmidas/services";
+
+//#region src/index.d.ts
+
+/**
+ * Error thrown when rate limit is exceeded
+ */
+declare class TooManyRequestsError extends Error {
+  readonly statusCode = 429;
+  readonly retryAfter?: number;
+  constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Rate limit configuration for an endpoint
+ */
+interface RateLimitConfig<T = RateLimitData> {
+  /**
+   * Maximum number of requests allowed in the window
+   */
+  limit: number;
+  /**
+   * Time window in milliseconds
+   */
+  windowMs: number;
+  /**
+   * Cache instance to store rate limit data
+   */
+  cache: Cache<T>;
+  /**
+   * Key generator function to identify clients
+   * Defaults to using IP address
+   */
+  keyGenerator?: RateLimitKeyGenerator;
+  /**
+   * Skip rate limiting for certain requests
+   */
+  skip?: RateLimitSkipFn;
+  /**
+   * Optional message to return when rate limit is exceeded
+   */
+  message?: string;
+  /**
+   * Optional custom handler when rate limit is exceeded
+   */
+  handler?: RateLimitExceededHandler;
+  /**
+   * Whether to include rate limit headers in response
+   * @default true
+   */
+  standardHeaders?: boolean;
+  /**
+   * Whether to include legacy rate limit headers
+   * @default false
+   */
+  legacyHeaders?: boolean;
+}
+/**
+ * Context for rate limiting decisions
+ */
+interface RateLimitContext<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> {
+  header: (key: string) => string | undefined;
+  services: ServiceRecord<TServices>;
+  logger: TLogger;
+  session: TSession;
+  path: string;
+  method: string;
+}
+/**
+ * Function to generate a unique key for rate limiting
+ */
+type RateLimitKeyGenerator<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> = (ctx: RateLimitContext<TServices, TLogger, TSession>) => string | Promise<string>;
+/**
+ * Function to determine if rate limiting should be skipped
+ */
+type RateLimitSkipFn<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> = (ctx: RateLimitContext<TServices, TLogger, TSession>) => boolean | Promise<boolean>;
+/**
+ * Handler for when rate limit is exceeded
+ */
+type RateLimitExceededHandler<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> = (ctx: RateLimitContext<TServices, TLogger, TSession>, info: RateLimitInfo) => void | Promise<void>;
+/**
+ * Information about current rate limit status
+ */
+interface RateLimitInfo {
+  /**
+   * Current request count in the window
+   */
+  count: number;
+  /**
+   * Maximum allowed requests
+   */
+  limit: number;
+  /**
+   * Remaining requests allowed
+   */
+  remaining: number;
+  /**
+   * Time when the window resets (Unix timestamp)
+   */
+  resetTime: number;
+  /**
+   * Time until reset in milliseconds
+   */
+  retryAfter: number;
+}
+/**
+ * Headers to be set on responses
+ */
+interface RateLimitHeaders {
+  'X-RateLimit-Limit'?: string;
+  'X-RateLimit-Remaining'?: string;
+  'X-RateLimit-Reset'?: string;
+  'Retry-After'?: string;
+  'X-RateLimit-Retry-After'?: string;
+  'X-RateLimit-Reset-After'?: string;
+}
+/**
+ * Data stored in cache for rate limiting
+ */
+interface RateLimitData {
+  count: number;
+  resetTime: number;
+}
+/**
+ * Default key generator using IP address
+ */
+declare const defaultKeyGenerator: RateLimitKeyGenerator;
+/**
+ * Check rate limit and throw error if exceeded
+ */
+declare function checkRateLimit<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown>(config: RateLimitConfig<RateLimitData>, ctx: RateLimitContext<TServices, TLogger, TSession>): Promise<RateLimitInfo>;
+/**
+ * Generate rate limit headers
+ */
+declare function getRateLimitHeaders(info: RateLimitInfo, config: RateLimitConfig): RateLimitHeaders;
+//#endregion
+export { RateLimitConfig, RateLimitContext, RateLimitData, RateLimitExceededHandler, RateLimitHeaders, RateLimitInfo, RateLimitKeyGenerator, RateLimitSkipFn, TooManyRequestsError, checkRateLimit, defaultKeyGenerator, getRateLimitHeaders };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,139 @@
+import { Cache } from "@geekmidas/cache";
+import { Logger } from "@geekmidas/logger";
+import { Service, ServiceRecord } from "@geekmidas/services";
+
+//#region src/index.d.ts
+
+/**
+ * Error thrown when rate limit is exceeded
+ */
+declare class TooManyRequestsError extends Error {
+  readonly statusCode = 429;
+  readonly retryAfter?: number;
+  constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Rate limit configuration for an endpoint
+ */
+interface RateLimitConfig<T = RateLimitData> {
+  /**
+   * Maximum number of requests allowed in the window
+   */
+  limit: number;
+  /**
+   * Time window in milliseconds
+   */
+  windowMs: number;
+  /**
+   * Cache instance to store rate limit data
+   */
+  cache: Cache<T>;
+  /**
+   * Key generator function to identify clients
+   * Defaults to using IP address
+   */
+  keyGenerator?: RateLimitKeyGenerator;
+  /**
+   * Skip rate limiting for certain requests
+   */
+  skip?: RateLimitSkipFn;
+  /**
+   * Optional message to return when rate limit is exceeded
+   */
+  message?: string;
+  /**
+   * Optional custom handler when rate limit is exceeded
+   */
+  handler?: RateLimitExceededHandler;
+  /**
+   * Whether to include rate limit headers in response
+   * @default true
+   */
+  standardHeaders?: boolean;
+  /**
+   * Whether to include legacy rate limit headers
+   * @default false
+   */
+  legacyHeaders?: boolean;
+}
+/**
+ * Context for rate limiting decisions
+ */
+interface RateLimitContext<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> {
+  header: (key: string) => string | undefined;
+  services: ServiceRecord<TServices>;
+  logger: TLogger;
+  session: TSession;
+  path: string;
+  method: string;
+}
+/**
+ * Function to generate a unique key for rate limiting
+ */
+type RateLimitKeyGenerator<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> = (ctx: RateLimitContext<TServices, TLogger, TSession>) => string | Promise<string>;
+/**
+ * Function to determine if rate limiting should be skipped
+ */
+type RateLimitSkipFn<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> = (ctx: RateLimitContext<TServices, TLogger, TSession>) => boolean | Promise<boolean>;
+/**
+ * Handler for when rate limit is exceeded
+ */
+type RateLimitExceededHandler<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown> = (ctx: RateLimitContext<TServices, TLogger, TSession>, info: RateLimitInfo) => void | Promise<void>;
+/**
+ * Information about current rate limit status
+ */
+interface RateLimitInfo {
+  /**
+   * Current request count in the window
+   */
+  count: number;
+  /**
+   * Maximum allowed requests
+   */
+  limit: number;
+  /**
+   * Remaining requests allowed
+   */
+  remaining: number;
+  /**
+   * Time when the window resets (Unix timestamp)
+   */
+  resetTime: number;
+  /**
+   * Time until reset in milliseconds
+   */
+  retryAfter: number;
+}
+/**
+ * Headers to be set on responses
+ */
+interface RateLimitHeaders {
+  'X-RateLimit-Limit'?: string;
+  'X-RateLimit-Remaining'?: string;
+  'X-RateLimit-Reset'?: string;
+  'Retry-After'?: string;
+  'X-RateLimit-Retry-After'?: string;
+  'X-RateLimit-Reset-After'?: string;
+}
+/**
+ * Data stored in cache for rate limiting
+ */
+interface RateLimitData {
+  count: number;
+  resetTime: number;
+}
+/**
+ * Default key generator using IP address
+ */
+declare const defaultKeyGenerator: RateLimitKeyGenerator;
+/**
+ * Check rate limit and throw error if exceeded
+ */
+declare function checkRateLimit<TServices extends Service[] = [], TLogger extends Logger = Logger, TSession = unknown>(config: RateLimitConfig<RateLimitData>, ctx: RateLimitContext<TServices, TLogger, TSession>): Promise<RateLimitInfo>;
+/**
+ * Generate rate limit headers
+ */
+declare function getRateLimitHeaders(info: RateLimitInfo, config: RateLimitConfig): RateLimitHeaders;
+//#endregion
+export { RateLimitConfig, RateLimitContext, RateLimitData, RateLimitExceededHandler, RateLimitHeaders, RateLimitInfo, RateLimitKeyGenerator, RateLimitSkipFn, TooManyRequestsError, checkRateLimit, defaultKeyGenerator, getRateLimitHeaders };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,84 @@
+//#region src/index.ts
+/**
+* Error thrown when rate limit is exceeded
+*/
+var TooManyRequestsError = class extends Error {
+	statusCode = 429;
+	retryAfter;
+	constructor(message, retryAfter) {
+		super(message || "Too many requests, please try again later.");
+		this.name = "TooManyRequestsError";
+		this.retryAfter = retryAfter;
+	}
+};
+/**
+* Default key generator using IP address
+*/
+const defaultKeyGenerator = (ctx) => {
+	const ip = ctx.header("x-forwarded-for")?.split(",")[0]?.trim() || ctx.header("x-real-ip") || ctx.header("x-client-ip") || ctx.header("cf-connecting-ip") || "unknown";
+	return `rate-limit:${ctx.method}:${ctx.path}:${ip}`;
+};
+/**
+* Check rate limit and throw error if exceeded
+*/
+async function checkRateLimit(config, ctx) {
+	if (config.skip && await config.skip(ctx)) return {
+		count: 0,
+		limit: config.limit,
+		remaining: config.limit,
+		resetTime: Date.now() + config.windowMs,
+		retryAfter: config.windowMs
+	};
+	const keyGenerator = config.keyGenerator || defaultKeyGenerator;
+	const key = await keyGenerator(ctx);
+	const now = Date.now();
+	let data = await config.cache.get(key);
+	if (!data || data.resetTime <= now) {
+		const resetTime = now + config.windowMs;
+		data = {
+			count: 1,
+			resetTime
+		};
+		const ttlSeconds = Math.ceil(config.windowMs / 1e3);
+		await config.cache.set(key, data, ttlSeconds);
+	} else {
+		data.count++;
+		const remainingMs = data.resetTime - now;
+		const ttlSeconds = Math.ceil(remainingMs / 1e3);
+		await config.cache.set(key, data, ttlSeconds);
+	}
+	const info = {
+		count: data.count,
+		limit: config.limit,
+		remaining: Math.max(0, config.limit - data.count),
+		resetTime: data.resetTime,
+		retryAfter: data.resetTime - now
+	};
+	if (data.count > config.limit) {
+		if (config.handler) await config.handler(ctx, info);
+		const retryAfterSeconds = Math.ceil(info.retryAfter / 1e3);
+		throw new TooManyRequestsError(config.message || "Too many requests, please try again later.", retryAfterSeconds);
+	}
+	return info;
+}
+/**
+* Generate rate limit headers
+*/
+function getRateLimitHeaders(info, config) {
+	const headers = {};
+	if (config.standardHeaders !== false) {
+		headers["X-RateLimit-Limit"] = info.limit.toString();
+		headers["X-RateLimit-Remaining"] = info.remaining.toString();
+		headers["X-RateLimit-Reset"] = new Date(info.resetTime).toISOString();
+	}
+	if (config.legacyHeaders) {
+		headers["X-RateLimit-Retry-After"] = info.retryAfter.toString();
+		headers["X-RateLimit-Reset-After"] = Math.ceil(info.retryAfter / 1e3).toString();
+	}
+	if (info.remaining === 0) headers["Retry-After"] = Math.ceil(info.retryAfter / 1e3).toString();
+	return headers;
+}
+
+//#endregion
+export { TooManyRequestsError, checkRateLimit, defaultKeyGenerator, getRateLimitHeaders };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["message?: string","retryAfter?: number","defaultKeyGenerator: RateLimitKeyGenerator","config: RateLimitConfig<RateLimitData>","ctx: RateLimitContext<TServices, TLogger, TSession>","info: RateLimitInfo","config: RateLimitConfig","headers: RateLimitHeaders"],"sources":["../src/index.ts"],"sourcesContent":["import type { Cache } from '@geekmidas/cache';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service, ServiceRecord } from '@geekmidas/services';\n\n/**\n * Error thrown when rate limit is exceeded\n */\nexport class TooManyRequestsError extends Error {\n  public readonly statusCode = 429;\n  public readonly retryAfter?: number;\n\n  constructor(message?: string, retryAfter?: number) {\n    super(message || 'Too many requests, please try again later.');\n    this.name = 'TooManyRequestsError';\n    this.retryAfter = retryAfter;\n  }\n}\n\n/**\n * Rate limit configuration for an endpoint\n */\nexport interface RateLimitConfig<T = RateLimitData> {\n  /**\n   * Maximum number of requests allowed in the window\n   */\n  limit: number;\n\n  /**\n   * Time window in milliseconds\n   */\n  windowMs: number;\n\n  /**\n   * Cache instance to store rate limit data\n   */\n  cache: Cache<T>;\n\n  /**\n   * Key generator function to identify clients\n   * Defaults to using IP address\n   */\n  keyGenerator?: RateLimitKeyGenerator;\n\n  /**\n   * Skip rate limiting for certain requests\n   */\n  skip?: RateLimitSkipFn;\n\n  /**\n   * Optional message to return when rate limit is exceeded\n   */\n  message?: string;\n\n  /**\n   * Optional custom handler when rate limit is exceeded\n   */\n  handler?: RateLimitExceededHandler;\n\n  /**\n   * Whether to include rate limit headers in response\n   * @default true\n   */\n  standardHeaders?: boolean;\n\n  /**\n   * Whether to include legacy rate limit headers\n   * @default false\n   */\n  legacyHeaders?: boolean;\n}\n\n/**\n * Context for rate limiting decisions\n */\nexport interface RateLimitContext<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> {\n  header: (key: string) => string | undefined;\n  services: ServiceRecord<TServices>;\n  logger: TLogger;\n  session: TSession;\n  path: string;\n  method: string;\n}\n\n/**\n * Function to generate a unique key for rate limiting\n */\nexport type RateLimitKeyGenerator<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> = (\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n) => string | Promise<string>;\n\n/**\n * Function to determine if rate limiting should be skipped\n */\nexport type RateLimitSkipFn<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> = (\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n) => boolean | Promise<boolean>;\n\n/**\n * Handler for when rate limit is exceeded\n */\nexport type RateLimitExceededHandler<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> = (\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n  info: RateLimitInfo,\n) => void | Promise<void>;\n\n/**\n * Information about current rate limit status\n */\nexport interface RateLimitInfo {\n  /**\n   * Current request count in the window\n   */\n  count: number;\n\n  /**\n   * Maximum allowed requests\n   */\n  limit: number;\n\n  /**\n   * Remaining requests allowed\n   */\n  remaining: number;\n\n  /**\n   * Time when the window resets (Unix timestamp)\n   */\n  resetTime: number;\n\n  /**\n   * Time until reset in milliseconds\n   */\n  retryAfter: number;\n}\n\n/**\n * Headers to be set on responses\n */\nexport interface RateLimitHeaders {\n  'X-RateLimit-Limit'?: string;\n  'X-RateLimit-Remaining'?: string;\n  'X-RateLimit-Reset'?: string;\n  'Retry-After'?: string;\n  'X-RateLimit-Retry-After'?: string;\n  'X-RateLimit-Reset-After'?: string;\n}\n\n/**\n * Data stored in cache for rate limiting\n */\nexport interface RateLimitData {\n  count: number;\n  resetTime: number;\n}\n\n/**\n * Default key generator using IP address\n */\nexport const defaultKeyGenerator: RateLimitKeyGenerator = (ctx) => {\n  // Try various headers for IP address\n  const ip =\n    ctx.header('x-forwarded-for')?.split(',')[0]?.trim() ||\n    ctx.header('x-real-ip') ||\n    ctx.header('x-client-ip') ||\n    ctx.header('cf-connecting-ip') ||\n    'unknown';\n\n  return `rate-limit:${ctx.method}:${ctx.path}:${ip}`;\n};\n\n/**\n * Check rate limit and throw error if exceeded\n */\nexport async function checkRateLimit<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n>(\n  config: RateLimitConfig<RateLimitData>,\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n): Promise<RateLimitInfo> {\n  // Check if we should skip rate limiting\n  if (config.skip && (await config.skip(ctx))) {\n    return {\n      count: 0,\n      limit: config.limit,\n      remaining: config.limit,\n      resetTime: Date.now() + config.windowMs,\n      retryAfter: config.windowMs,\n    };\n  }\n\n  // Generate key for this request\n  const keyGenerator = config.keyGenerator || defaultKeyGenerator;\n  const key = await keyGenerator(ctx);\n\n  // Get current data from cache\n  const now = Date.now();\n  let data = await config.cache.get(key);\n\n  // If no data or window expired, create new entry\n  if (!data || data.resetTime <= now) {\n    const resetTime = now + config.windowMs;\n    data = { count: 1, resetTime };\n\n    // Store with TTL matching the window\n    const ttlSeconds = Math.ceil(config.windowMs / 1000);\n    await config.cache.set(key, data, ttlSeconds);\n  } else {\n    // Increment count\n    data.count++;\n\n    // Calculate remaining TTL\n    const remainingMs = data.resetTime - now;\n    const ttlSeconds = Math.ceil(remainingMs / 1000);\n    await config.cache.set(key, data, ttlSeconds);\n  }\n\n  // Calculate rate limit info\n  const info: RateLimitInfo = {\n    count: data.count,\n    limit: config.limit,\n    remaining: Math.max(0, config.limit - data.count),\n    resetTime: data.resetTime,\n    retryAfter: data.resetTime - now,\n  };\n\n  // Check if limit exceeded\n  if (data.count > config.limit) {\n    // Call custom handler if provided\n    if (config.handler) {\n      await config.handler(ctx, info);\n    }\n\n    // Throw rate limit error\n    const retryAfterSeconds = Math.ceil(info.retryAfter / 1000);\n    throw new TooManyRequestsError(\n      config.message || 'Too many requests, please try again later.',\n      retryAfterSeconds,\n    );\n  }\n\n  return info;\n}\n\n/**\n * Generate rate limit headers\n */\nexport function getRateLimitHeaders(\n  info: RateLimitInfo,\n  config: RateLimitConfig,\n): RateLimitHeaders {\n  const headers: RateLimitHeaders = {};\n\n  if (config.standardHeaders !== false) {\n    headers['X-RateLimit-Limit'] = info.limit.toString();\n    headers['X-RateLimit-Remaining'] = info.remaining.toString();\n    headers['X-RateLimit-Reset'] = new Date(info.resetTime).toISOString();\n  }\n\n  if (config.legacyHeaders) {\n    headers['X-RateLimit-Retry-After'] = info.retryAfter.toString();\n    headers['X-RateLimit-Reset-After'] = Math.ceil(\n      info.retryAfter / 1000,\n    ).toString();\n  }\n\n  // Always set Retry-After when limit is exceeded\n  if (info.remaining === 0) {\n    headers['Retry-After'] = Math.ceil(info.retryAfter / 1000).toString();\n  }\n\n  return headers;\n}\n"],"mappings":";;;;AAOA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,AAAgB,aAAa;CAC7B,AAAgB;CAEhB,YAAYA,SAAkBC,YAAqB;AACjD,QAAM,WAAW,6CAA6C;AAC9D,OAAK,OAAO;AACZ,OAAK,aAAa;CACnB;AACF;;;;AA8JD,MAAaC,sBAA6C,CAAC,QAAQ;CAEjE,MAAM,KACJ,IAAI,OAAO,kBAAkB,EAAE,MAAM,IAAI,CAAC,IAAI,MAAM,IACpD,IAAI,OAAO,YAAY,IACvB,IAAI,OAAO,cAAc,IACzB,IAAI,OAAO,mBAAmB,IAC9B;AAEF,SAAQ,aAAa,IAAI,OAAO,GAAG,IAAI,KAAK,GAAG,GAAG;AACnD;;;;AAKD,eAAsB,eAKpBC,QACAC,KACwB;AAExB,KAAI,OAAO,QAAS,MAAM,OAAO,KAAK,IAAI,CACxC,QAAO;EACL,OAAO;EACP,OAAO,OAAO;EACd,WAAW,OAAO;EAClB,WAAW,KAAK,KAAK,GAAG,OAAO;EAC/B,YAAY,OAAO;CACpB;CAIH,MAAM,eAAe,OAAO,gBAAgB;CAC5C,MAAM,MAAM,MAAM,aAAa,IAAI;CAGnC,MAAM,MAAM,KAAK,KAAK;CACtB,IAAI,OAAO,MAAM,OAAO,MAAM,IAAI,IAAI;AAGtC,MAAK,QAAQ,KAAK,aAAa,KAAK;EAClC,MAAM,YAAY,MAAM,OAAO;AAC/B,SAAO;GAAE,OAAO;GAAG;EAAW;EAG9B,MAAM,aAAa,KAAK,KAAK,OAAO,WAAW,IAAK;AACpD,QAAM,OAAO,MAAM,IAAI,KAAK,MAAM,WAAW;CAC9C,OAAM;AAEL,OAAK;EAGL,MAAM,cAAc,KAAK,YAAY;EACrC,MAAM,aAAa,KAAK,KAAK,cAAc,IAAK;AAChD,QAAM,OAAO,MAAM,IAAI,KAAK,MAAM,WAAW;CAC9C;CAGD,MAAMC,OAAsB;EAC1B,OAAO,KAAK;EACZ,OAAO,OAAO;EACd,WAAW,KAAK,IAAI,GAAG,OAAO,QAAQ,KAAK,MAAM;EACjD,WAAW,KAAK;EAChB,YAAY,KAAK,YAAY;CAC9B;AAGD,KAAI,KAAK,QAAQ,OAAO,OAAO;AAE7B,MAAI,OAAO,QACT,OAAM,OAAO,QAAQ,KAAK,KAAK;EAIjC,MAAM,oBAAoB,KAAK,KAAK,KAAK,aAAa,IAAK;AAC3D,QAAM,IAAI,qBACR,OAAO,WAAW,8CAClB;CAEH;AAED,QAAO;AACR;;;;AAKD,SAAgB,oBACdA,MACAC,QACkB;CAClB,MAAMC,UAA4B,CAAE;AAEpC,KAAI,OAAO,oBAAoB,OAAO;AACpC,UAAQ,uBAAuB,KAAK,MAAM,UAAU;AACpD,UAAQ,2BAA2B,KAAK,UAAU,UAAU;AAC5D,UAAQ,uBAAuB,IAAI,KAAK,KAAK,WAAW,aAAa;CACtE;AAED,KAAI,OAAO,eAAe;AACxB,UAAQ,6BAA6B,KAAK,WAAW,UAAU;AAC/D,UAAQ,6BAA6B,KAAK,KACxC,KAAK,aAAa,IACnB,CAAC,UAAU;CACb;AAGD,KAAI,KAAK,cAAc,EACrB,SAAQ,iBAAiB,KAAK,KAAK,KAAK,aAAa,IAAK,CAAC,UAAU;AAGvE,QAAO;AACR"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@geekmidas/rate-limit",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geekmidas/toolbox.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@geekmidas/logger": "0.0.1",
+    "@geekmidas/services": "0.0.1",
+    "@geekmidas/cache": "0.0.7"
+  },
+  "peerDependencies": {},
+  "scripts": {
+    "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"
+  }
+}