@canmertinyo/rate-limit-express 1.3.0 → 1.3.3

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { RateLimiterOptions } from "./interfaces/rate-limiter-options.interface";
-export { rateLimiter, IRateLimitRecord, IRateLimiter } from "./rate.limiter";
+export * from "./interfaces";
+export { rateLimiter } from "./rate.limiter";

package/dist/index.js

@@ -1,5 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rateLimiter = void 0;
+__exportStar(require("./interfaces"), exports);
 var rate_limiter_1 = require("./rate.limiter");
 Object.defineProperty(exports, "rateLimiter", { enumerable: true, get: function () { return rate_limiter_1.rateLimiter; } });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./rate-limit-record.interface";
+export * from "./rate-limiter-options.interface";
+export * from "./rate-limiter.interface";
+export * from "./redis-config.interface";

package/dist/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rate-limit-record.interface"), exports);
+__exportStar(require("./rate-limiter-options.interface"), exports);
+__exportStar(require("./rate-limiter.interface"), exports);
+__exportStar(require("./redis-config.interface"), exports);

package/dist/interfaces/rate-limit-record.interface.d.ts

@@ -0,0 +1,5 @@
+export interface RateLimitRecord {
+    key: string;
+    count: number;
+    timestamp: number;
+}

package/dist/interfaces/rate-limiter-options.interface.d.ts

@@ -1,13 +1,13 @@
-import { IRateLimiter } from "../rate.limiter";
+import { RateLimiter } from "./rate-limiter.interface";
 /**
  * Options for the rate limiter configuration.
  *
  * @property ms - The time window in milliseconds for rate limiting.
- * @property maxRequest - The maximum number of allowed requests
+ * @property maxRequest - The maximum number of allowed requests.
+ * @property storage?(optional) - The storage property allows you to use a specific storage manager. [REDIS,MONGO, DEFAULT=INMEMORY]
  */
 export interface RateLimiterOptions {
     ms: number;
     maxRequest: number;
-    storage?: IRateLimiter;
+    storage?: RateLimiter;
 }
-export declare const defaultOptions: RateLimiterOptions;

package/dist/interfaces/rate-limiter-options.interface.js

@@ -1,9 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultOptions = void 0;
-const in_memory_storage_1 = require("../in-memory-storage");
-exports.defaultOptions = {
-    ms: 1000,
-    maxRequest: 5,
-    storage: new in_memory_storage_1.InMemoryStorage(),
-};

package/dist/interfaces/rate-limiter.interface.d.ts

@@ -0,0 +1,7 @@
+import { RateLimitRecord } from "./rate-limit-record.interface";
+export interface RateLimiter {
+    getRateLimitRecord(key: string): Promise<RateLimitRecord | undefined>;
+    createRateLimitRecord(record: RateLimitRecord): Promise<RateLimitRecord>;
+    updateRateLimitRecord(key: string, timestamp: number, count: number): Promise<RateLimitRecord>;
+    increment(key: string): Promise<RateLimitRecord>;
+}

package/dist/interfaces/rate-limiter.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/redis-config.interface.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @property port - Redis server port, default : 6379
+ * @property host - Redis server host or IP address.
+ * @property username - Redis username for authentication (optional)
+ * @property password - Redis password for authentication (optional).
+ * @property db - Redis database number, default is 0 (optional).
+ */
+export interface RedisConfig {
+    port: number;
+    host: string;
+    username?: string;
+    password?: string;
+    db?: number;
+}

package/dist/interfaces/redis-config.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * @property port - Redis server port, default : 6379
+ * @property host - Redis server host or IP address.
+ * @property username - Redis username for authentication (optional)
+ * @property password - Redis password for authentication (optional).
+ * @property db - Redis database number, default is 0 (optional).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/rate.limiter.d.ts

@@ -1,14 +1,3 @@
 import { Request, Response, NextFunction } from "express";
 import { RateLimiterOptions } from "./interfaces/rate-limiter-options.interface";
-export declare function rateLimiter(options: RateLimiterOptions): (req: Request, res: Response, next: NextFunction) => void;
-export interface IRateLimitRecord {
-    key: string;
-    count: number;
-    timestamp: number;
-}
-export interface IRateLimiter {
-    getRateLimitRecord(key: string): IRateLimitRecord | undefined;
-    createRateLimitRecord(record: IRateLimitRecord): IRateLimitRecord;
-    updateRateLimitRecord(key: string, timestamp: number, count: number): IRateLimitRecord;
-    increment(key: string): IRateLimitRecord;
-}
+export declare function rateLimiter(options: RateLimiterOptions): (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/rate.limiter.js

@@ -1,34 +1,43 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rateLimiter = rateLimiter;
 const utils_1 = require("./utils");
-const in_memory_storage_1 = require("./in-memory-storage");
+const in_memory_storage_1 = require("./storages/in-memory.storage");
 const inMemoryStorage = new in_memory_storage_1.InMemoryStorage();
 function rateLimiter(options) {
-    return (req, res, next) => {
+    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
         var _a;
         const ip = (0, utils_1.getIp)(req);
         const currentTime = (0, utils_1.getTimestamp)();
         const startTime = currentTime - options.ms;
         var storage = (_a = options.storage) !== null && _a !== void 0 ? _a : inMemoryStorage;
-        var record = storage.getRateLimitRecord(ip);
+        var record = yield storage.getRateLimitRecord(ip);
         if (!record) {
-            record = storage.createRateLimitRecord({
+            record = yield storage.createRateLimitRecord({
                 key: ip,
                 count: 0,
                 timestamp: currentTime,
             });
         }
         if (startTime > record.timestamp) {
-            record = storage.updateRateLimitRecord(ip, currentTime, 1);
+            record = yield storage.updateRateLimitRecord(ip, currentTime, 1);
             return next();
         }
         if (record.count < options.maxRequest) {
-            record = storage.increment(record.key);
+            record = yield storage.increment(record.key);
             return next();
         }
         res
             .status(420)
             .json({ message: "Too many requests, please try again later." });
-    };
+    });
 }

package/dist/storages/in-memory.storage.d.ts

@@ -0,0 +1,9 @@
+import { RateLimitRecord } from "../interfaces/rate-limit-record.interface";
+import { RateLimiter } from "../interfaces/rate-limiter.interface";
+export declare class InMemoryStorage implements RateLimiter {
+    private store;
+    getRateLimitRecord(key: string): Promise<RateLimitRecord | undefined>;
+    createRateLimitRecord(record: RateLimitRecord): Promise<RateLimitRecord>;
+    updateRateLimitRecord(key: string, timestamp: number, count: number): Promise<RateLimitRecord>;
+    increment(key: string): Promise<RateLimitRecord>;
+}

package/dist/storages/in-memory.storage.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorage = void 0;
+class InMemoryStorage {
+    constructor() {
+        this.store = [];
+    }
+    getRateLimitRecord(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.store.find((x) => x.key === key);
+        });
+    }
+    createRateLimitRecord(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let index = this.store.push(record);
+            return this.store[index - 1];
+        });
+    }
+    updateRateLimitRecord(key, timestamp, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let index = this.store.findIndex((x) => x.key === key);
+            this.store[index].count = count;
+            this.store[index].timestamp = timestamp;
+            return this.store[index];
+        });
+    }
+    increment(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let index = this.store.findIndex((x) => x.key === key);
+            this.store[index].count += 1;
+            return this.store[index];
+        });
+    }
+}
+exports.InMemoryStorage = InMemoryStorage;

package/dist/storages/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./in-memory.storage";
+export * from "./mongo.storage";
+export * from "./redis.storage";

package/dist/storages/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./in-memory.storage"), exports);
+__exportStar(require("./mongo.storage"), exports);
+__exportStar(require("./redis.storage"), exports);

package/dist/storages/mongo.storage.d.ts

@@ -0,0 +1,10 @@
+import { RateLimiter, RateLimitRecord } from "../interfaces";
+export declare class MongoStorage implements RateLimiter {
+    mongoDbUrl: string;
+    private model;
+    constructor(mongoDbUrl?: string);
+    getRateLimitRecord(key: string): Promise<RateLimitRecord | undefined>;
+    createRateLimitRecord(record: RateLimitRecord): Promise<RateLimitRecord>;
+    updateRateLimitRecord(key: string, timestamp: number, count: number): Promise<RateLimitRecord>;
+    increment(key: string): Promise<RateLimitRecord>;
+}

package/dist/storages/mongo.storage.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStorage = void 0;
+const mongoose_1 = require("mongoose");
+const rate_limit_schema_1 = require("./schemas/rate-limit.schema");
+class MongoStorage {
+    //DEFAULT DB URI VERRIRSEK PATLICAZ GİBİ AMA BAKARIZ, AZ KÖTÜ🤨
+    //connect-mongo kütüphanesini kullanarak yapsak?
+    constructor(mongoDbUrl = "mongodb://127.0.0.1:27017") {
+        this.mongoDbUrl = mongoDbUrl;
+        mongoose_1.default
+            .connect(mongoDbUrl)
+            .then(() => {
+            console.log("Db connected.");
+        })
+            .catch((err) => {
+            console.log("Db failed to connect.", err);
+        });
+        this.model = rate_limit_schema_1.RateLimitModel;
+    }
+    getRateLimitRecord(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.model.findOne({ key });
+            return record ? record.toObject() : undefined;
+        });
+    }
+    createRateLimitRecord(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newRecord = yield this.model.create(record);
+            newRecord.save();
+            return newRecord.toObject();
+        });
+    }
+    updateRateLimitRecord(key, timestamp, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.model.findOneAndUpdate({ key }, {
+                timestamp,
+                count,
+            }, {
+                new: true,
+            });
+            if (!record) {
+                throw new Error("No record found.");
+            }
+            return record.toObject();
+        });
+    }
+    increment(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.model.findOneAndUpdate({ key }, { $inc: { count: 1 } }, { new: true });
+            if (!record) {
+                throw new Error("No record found to increment.");
+            }
+            return record.toObject();
+        });
+    }
+}
+exports.MongoStorage = MongoStorage;

package/dist/storages/redis.storage.d.ts

@@ -0,0 +1,9 @@
+import { RateLimiter, RateLimitRecord, RedisConfig } from "../interfaces";
+export declare class RedisStorage implements RateLimiter {
+    private redis;
+    constructor(redisConfig: RedisConfig);
+    getRateLimitRecord(key: string): Promise<RateLimitRecord | undefined>;
+    createRateLimitRecord(record: RateLimitRecord): Promise<RateLimitRecord>;
+    updateRateLimitRecord(key: string, timestamp: number, count: number): Promise<RateLimitRecord>;
+    increment(key: string): Promise<RateLimitRecord>;
+}

package/dist/storages/redis.storage.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStorage = void 0;
+const ioredis_1 = require("ioredis");
+class RedisStorage {
+    constructor(redisConfig) {
+        const { host, port, db, password, username } = redisConfig;
+        const resolvedPort = port ? port : 6379;
+        this.redis = new ioredis_1.default({
+            host,
+            port: resolvedPort,
+            db,
+            password,
+            username,
+        });
+    }
+    getRateLimitRecord(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.redis.get(key);
+            return data ? JSON.parse(data) : undefined;
+        });
+    }
+    createRateLimitRecord(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.set(record.key, JSON.stringify(record));
+            return record;
+        });
+    }
+    updateRateLimitRecord(key, timestamp, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.getRateLimitRecord(key);
+            if (!record)
+                throw new Error("Record not found");
+            const updatedRecord = Object.assign(Object.assign({}, record), { count,
+                timestamp });
+            yield this.redis.set(key, JSON.stringify(updatedRecord));
+            return updatedRecord;
+        });
+    }
+    increment(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield this.getRateLimitRecord(key);
+            if (!record)
+                throw new Error("Record not found");
+            const updatedRecord = Object.assign(Object.assign({}, record), { count: record.count + 1 });
+            yield this.redis.set(key, JSON.stringify(updatedRecord));
+            return updatedRecord;
+        });
+    }
+}
+exports.RedisStorage = RedisStorage;

package/dist/storages/schemas/rate-limit.schema.d.ts

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+import { RateLimitRecord } from "../../interfaces";
+export declare const RATE_LIMIT_SCHEMA_CONST = "RateLimit";
+export declare const RateLimitSchema: mongoose.Schema<RateLimitRecord, mongoose.Model<RateLimitRecord, any, any, any, mongoose.Document<unknown, any, RateLimitRecord> & RateLimitRecord & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, RateLimitRecord, mongoose.Document<unknown, {}, mongoose.FlatRecord<RateLimitRecord>> & mongoose.FlatRecord<RateLimitRecord> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const RateLimitModel: mongoose.Model<RateLimitRecord, {}, {}, {}, mongoose.Document<unknown, {}, RateLimitRecord> & RateLimitRecord & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>;

package/dist/storages/schemas/rate-limit.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitModel = exports.RateLimitSchema = exports.RATE_LIMIT_SCHEMA_CONST = void 0;
+const mongoose_1 = require("mongoose");
+exports.RATE_LIMIT_SCHEMA_CONST = "RateLimit";
+exports.RateLimitSchema = new mongoose_1.Schema({
+    key: { type: String, required: true, unique: true },
+    count: { type: Number, required: true },
+    timestamp: { type: Number, required: true },
+});
+exports.RateLimitModel = mongoose_1.default.model(exports.RATE_LIMIT_SCHEMA_CONST, exports.RateLimitSchema);

package/package.json

@@ -1,23 +1,25 @@
-{
-  "name": "@canmertinyo/rate-limit-express",
-  "description": "A simple rate-limiting middleware for Express.js",
-  "version": "1.3.0",
-  "main": "dist/index.js",
-  "license": "MIT",
-  "types": "dist/index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/c4nzin/rate-limiter-express"
-  },
-  "scripts": {
-    "build": "tsc"
-  },
-  "keywords": [
-    "ratelimiter-express"
-  ],
-  "author": "c4nzin",
-  "devDependencies": {
-    "@types/express": "^5.0.0",
-    "typescript": "^5.7.2"
-  }
-}
+{
+  "name": "@canmertinyo/rate-limit-express",
+  "description": "A simple rate-limiting middleware for Express.js",
+  "version": "1.3.3",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/c4nzin/rate-limiter-express"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "ratelimiter-express"
+  ],
+  "author": "c4nzin",
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "typescript": "^5.7.2",
+    "ioredis": "^5.4.1",
+    "mongoose": "^8.8.3"
+  }
+}

package/src/index.ts

@@ -1,2 +1,2 @@
-export { RateLimiterOptions } from "./interfaces/rate-limiter-options.interface";
-export { rateLimiter, IRateLimitRecord, IRateLimiter } from "./rate.limiter";
+export * from "./interfaces";
+export { rateLimiter } from "./rate.limiter";

package/src/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from "./rate-limit-record.interface";
+export * from "./rate-limiter-options.interface";
+export * from "./rate-limiter.interface";
+export * from "./redis-config.interface";

package/src/interfaces/rate-limit-record.interface.ts

@@ -0,0 +1,5 @@
+export interface RateLimitRecord {
+  key: string;
+  count: number;
+  timestamp: number;
+}

package/src/interfaces/rate-limiter-options.interface.ts

@@ -1,20 +1,14 @@
-import { InMemoryStorage } from "../in-memory-storage";
-import { IRateLimiter } from "../rate.limiter";
+import { RateLimiter } from "./rate-limiter.interface";
 
 /**
  * Options for the rate limiter configuration.
  *
  * @property ms - The time window in milliseconds for rate limiting.
- * @property maxRequest - The maximum number of allowed requests
+ * @property maxRequest - The maximum number of allowed requests.
+ * @property storage?(optional) - The storage property allows you to use a specific storage manager. [REDIS,MONGO, DEFAULT=INMEMORY]
  */
 export interface RateLimiterOptions {
   ms: number;
   maxRequest: number;
-  storage?: IRateLimiter;
+  storage?: RateLimiter;
 }
-
-export const defaultOptions: RateLimiterOptions = {
-  ms: 1000,
-  maxRequest: 5,
-  storage: new InMemoryStorage(),
-};

package/src/interfaces/rate-limiter.interface.ts

@@ -0,0 +1,12 @@
+import { RateLimitRecord } from "./rate-limit-record.interface";
+
+export interface RateLimiter {
+  getRateLimitRecord(key: string): Promise<RateLimitRecord | undefined>;
+  createRateLimitRecord(record: RateLimitRecord): Promise<RateLimitRecord>;
+  updateRateLimitRecord(
+    key: string,
+    timestamp: number,
+    count: number
+  ): Promise<RateLimitRecord>;
+  increment(key: string): Promise<RateLimitRecord>;
+}

package/src/interfaces/redis-config.interface.ts

@@ -0,0 +1,19 @@
+/**
+ * @property port - Redis server port, default : 6379
+ * @property host - Redis server host or IP address.
+ * @property username - Redis username for authentication (optional)
+ * @property password - Redis password for authentication (optional).
+ * @property db - Redis database number, default is 0 (optional).
+ */
+
+export interface RedisConfig {
+  port: number;
+
+  host: string;
+
+  username?: string;
+
+  password?: string;
+
+  db?: number;
+}

package/src/rate.limiter.ts

@@ -1,21 +1,21 @@
 import { Request, Response, NextFunction } from "express";
 import { getIp, getTimestamp } from "./utils";
 import { RateLimiterOptions } from "./interfaces/rate-limiter-options.interface";
-import { InMemoryStorage } from "./in-memory-storage";
+import { InMemoryStorage } from "./storages/in-memory.storage";
 
 const inMemoryStorage = new InMemoryStorage();
 
 export function rateLimiter(options: RateLimiterOptions) {
-  return (req: Request, res: Response, next: NextFunction) => {
+  return async (req: Request, res: Response, next: NextFunction) => {
     const ip = getIp(req);
     const currentTime = getTimestamp();
     const startTime = currentTime - options.ms;
     var storage = options.storage ?? inMemoryStorage;
 
-    var record = storage.getRateLimitRecord(ip);
+    var record = await storage.getRateLimitRecord(ip);
 
     if (!record) {
-      record = storage.createRateLimitRecord({
+      record = await storage.createRateLimitRecord({
         key: ip,
         count: 0,
         timestamp: currentTime,
@@ -23,12 +23,12 @@ export function rateLimiter(options: RateLimiterOptions) {
     }
 
     if (startTime > record.timestamp) {
-      record = storage.updateRateLimitRecord(ip, currentTime, 1);
+      record = await storage.updateRateLimitRecord(ip, currentTime, 1);
       return next();
     }
 
     if (record.count < options.maxRequest) {
-      record = storage.increment(record.key);
+      record = await storage.increment(record.key);
       return next();
     }
 
@@ -37,20 +37,3 @@ export function rateLimiter(options: RateLimiterOptions) {
       .json({ message: "Too many requests, please try again later." });
   };
 }
-
-export interface IRateLimitRecord {
-  key: string;
-  count: number;
-  timestamp: number;
-}
-
-export interface IRateLimiter {
-  getRateLimitRecord(key: string): IRateLimitRecord | undefined;
-  createRateLimitRecord(record: IRateLimitRecord): IRateLimitRecord;
-  updateRateLimitRecord(
-    key: string,
-    timestamp: number,
-    count: number
-  ): IRateLimitRecord;
-  increment(key: string): IRateLimitRecord;
-}

package/src/storages/in-memory.storage.ts

@@ -0,0 +1,37 @@
+import { RateLimitRecord } from "../interfaces/rate-limit-record.interface";
+import { RateLimiter } from "../interfaces/rate-limiter.interface";
+
+export class InMemoryStorage implements RateLimiter {
+  private store: RateLimitRecord[] = [];
+
+  public async getRateLimitRecord(
+    key: string
+  ): Promise<RateLimitRecord | undefined> {
+    return this.store.find((x) => x.key === key);
+  }
+
+  public async createRateLimitRecord(
+    record: RateLimitRecord
+  ): Promise<RateLimitRecord> {
+    let index = this.store.push(record);
+    return this.store[index - 1];
+  }
+
+  public async updateRateLimitRecord(
+    key: string,
+    timestamp: number,
+    count: number
+  ): Promise<RateLimitRecord> {
+    let index = this.store.findIndex((x) => x.key === key);
+    this.store[index].count = count;
+    this.store[index].timestamp = timestamp;
+
+    return this.store[index];
+  }
+
+  public async increment(key: string): Promise<RateLimitRecord> {
+    let index = this.store.findIndex((x) => x.key === key);
+    this.store[index].count += 1;
+    return this.store[index];
+  }
+}

package/src/storages/index.ts

@@ -0,0 +1,3 @@
+export * from "./in-memory.storage";
+export * from "./mongo.storage";
+export * from "./redis.storage";

package/src/storages/mongo.storage.ts

@@ -0,0 +1,76 @@
+import { RateLimiter, RateLimitRecord } from "../interfaces";
+import mongoose from "mongoose";
+import { RateLimitModel } from "./schemas/rate-limit.schema";
+
+export class MongoStorage implements RateLimiter {
+  private model: mongoose.Model<RateLimitRecord>;
+
+  //DEFAULT DB URI VERRIRSEK PATLICAZ GİBİ AMA BAKARIZ, AZ KÖTÜ🤨
+  //connect-mongo kütüphanesini kullanarak yapsak?
+  constructor(public mongoDbUrl: string = "mongodb://127.0.0.1:27017") {
+    mongoose
+      .connect(mongoDbUrl)
+      .then(() => {
+        console.log("Db connected.");
+      })
+      .catch((err) => {
+        console.log("Db failed to connect.", err);
+      });
+
+    this.model = RateLimitModel;
+  }
+
+  public async getRateLimitRecord(
+    key: string
+  ): Promise<RateLimitRecord | undefined> {
+    const record = await this.model.findOne({ key });
+
+    return record ? record.toObject() : undefined;
+  }
+
+  public async createRateLimitRecord(
+    record: RateLimitRecord
+  ): Promise<RateLimitRecord> {
+    const newRecord = await this.model.create(record);
+    newRecord.save();
+
+    return newRecord.toObject() as RateLimitRecord;
+  }
+
+  public async updateRateLimitRecord(
+    key: string,
+    timestamp: number,
+    count: number
+  ): Promise<RateLimitRecord> {
+    const record = await this.model.findOneAndUpdate(
+      { key },
+      {
+        timestamp,
+        count,
+      },
+      {
+        new: true,
+      }
+    )!;
+
+    if (!record) {
+      throw new Error("No record found.");
+    }
+
+    return record.toObject() as RateLimitRecord;
+  }
+
+  public async increment(key: string): Promise<RateLimitRecord> {
+    const record = await this.model.findOneAndUpdate(
+      { key },
+      { $inc: { count: 1 } },
+      { new: true }
+    );
+
+    if (!record) {
+      throw new Error("No record found to increment.");
+    }
+
+    return record.toObject();
+  }
+}

package/src/storages/redis.storage.ts

@@ -0,0 +1,63 @@
+import Redis from "ioredis";
+import { RateLimiter, RateLimitRecord, RedisConfig } from "../interfaces";
+
+export class RedisStorage implements RateLimiter {
+  private redis: Redis;
+
+  constructor(redisConfig: RedisConfig) {
+    const { host, port, db, password, username } = redisConfig;
+
+    const resolvedPort = port ? port : 6379;
+
+    this.redis = new Redis({
+      host,
+      port: resolvedPort,
+      db,
+      password,
+      username,
+    });
+  }
+
+  public async getRateLimitRecord(
+    key: string
+  ): Promise<RateLimitRecord | undefined> {
+    const data = await this.redis.get(key);
+    return data ? (JSON.parse(data) as RateLimitRecord) : undefined;
+  }
+
+  public async createRateLimitRecord(
+    record: RateLimitRecord
+  ): Promise<RateLimitRecord> {
+    await this.redis.set(record.key, JSON.stringify(record));
+    return record;
+  }
+
+  public async updateRateLimitRecord(
+    key: string,
+    timestamp: number,
+    count: number
+  ): Promise<RateLimitRecord> {
+    const record = await this.getRateLimitRecord(key);
+    if (!record) throw new Error("Record not found");
+
+    const updatedRecord: RateLimitRecord = {
+      ...record,
+      count,
+      timestamp,
+    };
+    await this.redis.set(key, JSON.stringify(updatedRecord));
+    return updatedRecord;
+  }
+
+  public async increment(key: string): Promise<RateLimitRecord> {
+    const record = await this.getRateLimitRecord(key);
+    if (!record) throw new Error("Record not found");
+
+    const updatedRecord: RateLimitRecord = {
+      ...record,
+      count: record.count + 1,
+    };
+    await this.redis.set(key, JSON.stringify(updatedRecord));
+    return updatedRecord;
+  }
+}

package/src/storages/schemas/rate-limit.schema.ts

@@ -0,0 +1,15 @@
+import mongoose, { Schema } from "mongoose";
+import { RateLimitRecord } from "../../interfaces";
+
+export const RATE_LIMIT_SCHEMA_CONST = "RateLimit";
+
+export const RateLimitSchema = new Schema<RateLimitRecord>({
+  key: { type: String, required: true, unique: true },
+  count: { type: Number, required: true },
+  timestamp: { type: Number, required: true },
+});
+
+export const RateLimitModel = mongoose.model<RateLimitRecord>(
+  RATE_LIMIT_SCHEMA_CONST,
+  RateLimitSchema
+);

package/dist/in-memory-storage.d.ts

@@ -1,8 +0,0 @@
-import { IRateLimiter, IRateLimitRecord } from "./rate.limiter";
-export declare class InMemoryStorage implements IRateLimiter {
-    private store;
-    getRateLimitRecord(key: string): IRateLimitRecord | undefined;
-    createRateLimitRecord(record: IRateLimitRecord): IRateLimitRecord;
-    updateRateLimitRecord(key: string, timestamp: number, count: number): IRateLimitRecord;
-    increment(key: string): IRateLimitRecord;
-}

package/dist/in-memory-storage.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryStorage = void 0;
-class InMemoryStorage {
-    constructor() {
-        this.store = [];
-    }
-    getRateLimitRecord(key) {
-        return this.store.find((x) => x.key === key);
-    }
-    createRateLimitRecord(record) {
-        var index = this.store.push(record);
-        return this.store[index - 1];
-    }
-    updateRateLimitRecord(key, timestamp, count) {
-        var index = this.store.findIndex((x) => x.key === key);
-        this.store[index].count = count;
-        this.store[index].timestamp = timestamp;
-        return this.store[index];
-    }
-    increment(key) {
-        var index = this.store.findIndex((x) => x.key === key);
-        this.store[index].count += 1;
-        return this.store[index];
-    }
-}
-exports.InMemoryStorage = InMemoryStorage;

package/dist/types/store.type.d.ts

@@ -1,6 +0,0 @@
-export type Store = {
-    [key: string]: {
-        count: number;
-        timestamp: number;
-    };
-};

package/src/in-memory-storage.ts

@@ -1,32 +0,0 @@
-import { IRateLimiter, IRateLimitRecord } from "./rate.limiter";
-
-export class InMemoryStorage implements IRateLimiter {
-  private store: IRateLimitRecord[] = [];
-
-  getRateLimitRecord(key: string): IRateLimitRecord | undefined {
-    return this.store.find((x) => x.key === key);
-  }
-
-  createRateLimitRecord(record: IRateLimitRecord): IRateLimitRecord {
-    var index = this.store.push(record);
-    return this.store[index - 1];
-  }
-
-  updateRateLimitRecord(
-    key: string,
-    timestamp: number,
-    count: number
-  ): IRateLimitRecord {
-    var index = this.store.findIndex((x) => x.key === key);
-    this.store[index].count = count;
-    this.store[index].timestamp = timestamp;
-
-    return this.store[index];
-  }
-
-  increment(key: string): IRateLimitRecord {
-    var index = this.store.findIndex((x) => x.key === key);
-    this.store[index].count += 1;
-    return this.store[index];
-  }
-}

package/src/types/store.type.ts

@@ -1,3 +0,0 @@
-export type Store = {
-  [key: string]: { count: number; timestamp: number };
-};