mielk-api 1.4.0 → 1.5.1

package/dist/http/httpResponseStatus/HttpResponseStatus.d.ts

@@ -2,11 +2,14 @@ import { HttpStatus } from "../types/HttpStatus.js";
 export declare const HttpResponseStatus: {
     OK: HttpStatus;
     CREATED: HttpStatus;
+    ACCEPTED: HttpStatus;
+    NO_CONTENT: HttpStatus;
     BAD_REQUEST: HttpStatus;
     UNAUTHORIZED: HttpStatus;
     FORBIDDEN: HttpStatus;
     NOT_FOUND: HttpStatus;
     CONFLICT: HttpStatus;
+    LOCKED: HttpStatus;
     TOO_MANY_REQUESTS: HttpStatus;
     SERVER_ERROR: HttpStatus;
 };

package/dist/http/httpResponseStatus/HttpResponseStatus.js

@@ -4,11 +4,14 @@ const msg = Msg.apiStatus;
 export const HttpResponseStatus = {
     OK: createApiStatus(true, 200, msg.ok),
     CREATED: createApiStatus(true, 201, msg.created),
+    ACCEPTED: createApiStatus(true, 202, msg.created),
+    NO_CONTENT: createApiStatus(true, 204, msg.noContent),
     BAD_REQUEST: createApiStatus(false, 400, msg.badRequest),
     UNAUTHORIZED: createApiStatus(false, 401, msg.unauthorized),
     FORBIDDEN: createApiStatus(false, 403, msg.forbidden),
     NOT_FOUND: createApiStatus(false, 404, msg.notFound),
     CONFLICT: createApiStatus(false, 409, msg.conflict),
+    LOCKED: createApiStatus(false, 423, msg.locked),
     TOO_MANY_REQUESTS: createApiStatus(false, 429, msg.tooManyRequests),
     SERVER_ERROR: createApiStatus(false, 500, msg.serverError),
 };

package/dist/internal/messaging/messageTags.d.ts

@@ -2,11 +2,14 @@ export declare const Msg: {
     apiStatus: {
         ok: string;
         created: string;
+        accepted: string;
+        noContent: string;
         badRequest: string;
         unauthorized: string;
         forbidden: string;
         notFound: string;
         conflict: string;
+        locked: string;
         tooManyRequests: string;
         serverError: string;
     };

package/dist/internal/messaging/messageTags.js

@@ -5,11 +5,14 @@ export const Msg = {
     apiStatus: {
         ok: `${___HTTP_STATUS___}:ok`,
         created: `${___HTTP_STATUS___}:created`,
+        accepted: `${___HTTP_STATUS___}:accepted`,
+        noContent: `${___HTTP_STATUS___}:noContent`,
         badRequest: `${___HTTP_STATUS___}:badRequest`,
         unauthorized: `${___HTTP_STATUS___}:unauthorized`,
         forbidden: `${___HTTP_STATUS___}:forbidden`,
         notFound: `${___HTTP_STATUS___}:notFound`,
         conflict: `${___HTTP_STATUS___}:conflict`,
+        locked: `${___HTTP_STATUS___}:locked`, // Account is temporarily locked. Try again later or reset your password. OR Your account has been temporarily locked due to multiple failed login attempts. Please reset your password to regain access.
         tooManyRequests: `${___HTTP_STATUS___}:tooManyRequests`,
         serverError: `${___HTTP_STATUS___}:serverError`,
     },

package/dist/middlewares/index.d.ts

@@ -3,6 +3,18 @@ import { privateCors } from './cors/privateCors.js';
 import { publicCors } from './cors/publicCors.js';
 import { apiKeyAuthorization } from './requestAuth/auth.middleware.js';
 import { validateQueryParams, validateBodyJson } from './zod/validate.js';
+import { RedisLockerConfigFactory } from './redis/redisLockerConfigFactory.js';
+import { RedisLockerConfig, RedisLockerConfigParams } from './redis/types.js';
+import { setRedisLock, removeRedisLock } from './redis/redisLocker.js';
+import { RedisLockCheckerConfigFactory } from './redis/redisLockCheckerConfigFactory.js';
+import { RedisLockChecker, RedisLockCheckerConfig, RedisLockCheckerConfigParams } from './redis/types.js';
+import { createRedisLockChecker, checkIfLockedInRedis } from './redis/redisLockChecker.js';
 export { CorsConfig, initCors, privateCors, publicCors };
 export { apiKeyAuthorization };
 export { validateQueryParams, validateBodyJson };
+export { RedisLockerConfigFactory };
+export { RedisLockerConfig, RedisLockerConfigParams };
+export { setRedisLock, removeRedisLock };
+export { createRedisLockChecker, checkIfLockedInRedis };
+export { RedisLockCheckerConfigFactory };
+export { RedisLockChecker, RedisLockCheckerConfig, RedisLockCheckerConfigParams };

package/dist/middlewares/index.js

@@ -3,6 +3,18 @@ import { privateCors } from './cors/privateCors.js';
 import { publicCors } from './cors/publicCors.js';
 import { apiKeyAuthorization } from './requestAuth/auth.middleware.js';
 import { validateQueryParams, validateBodyJson } from './zod/validate.js';
+// Redis locker
+import { RedisLockerConfigFactory } from './redis/redisLockerConfigFactory.js';
+import { setRedisLock, removeRedisLock } from './redis/redisLocker.js';
+// Redis lock checker
+import { RedisLockCheckerConfigFactory } from './redis/redisLockCheckerConfigFactory.js';
+import { createRedisLockChecker, checkIfLockedInRedis } from './redis/redisLockChecker.js';
 export { initCors, privateCors, publicCors };
 export { apiKeyAuthorization };
 export { validateQueryParams, validateBodyJson };
+// Redis locker
+export { RedisLockerConfigFactory };
+export { setRedisLock, removeRedisLock };
+// Redis lock checker
+export { createRedisLockChecker, checkIfLockedInRedis };
+export { RedisLockCheckerConfigFactory };

package/dist/{rateLimit → middlewares/rateLimit}/checkRateLimit.js

@@ -8,8 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { getRedisClient } from 'mielk-fn/redis';
+import { setRedisLock } from '../redis/redisLocker.js';
 export const checkRateLimit = (rateLimit) => __awaiter(void 0, void 0, void 0, function* () {
-    const { key, limit, windowSec } = rateLimit;
+    const { key, limit, windowSec, redisLock } = rateLimit;
     const client = yield getRedisClient();
     const currentCounter = yield client.incr(key);
     if (currentCounter === 1) {
@@ -17,6 +18,10 @@ export const checkRateLimit = (rateLimit) => __awaiter(void 0, void 0, void 0, f
     }
     const ttl = yield client.ttl(key);
     const allowed = currentCounter <= limit;
+    if (!allowed && redisLock) {
+        const { key, ttlSeconds } = redisLock;
+        setRedisLock(key, ttlSeconds);
+    }
     return {
         currentCounter,
         limit,

package/dist/{rateLimit → middlewares/rateLimit}/createRateLimiter.d.ts

@@ -1,4 +1,4 @@
 import { Request, Response, NextFunction } from 'express';
-import { RateLimitConfig } from './types.js';
-export declare const createGlobalRateLimiter: (config?: RateLimitConfig) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;
+import { RateLimitConfig, RateLimitConfigParams } from './types.js';
+export declare const createGlobalRateLimiter: (config?: RateLimitConfigParams) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;
 export declare const createRateLimiter: (config: RateLimitConfig) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;

package/dist/{rateLimit → middlewares/rateLimit}/createRateLimiter.js

@@ -8,11 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { checkRateLimit } from './checkRateLimit.js';
-import { failure, HttpResponseStatus } from '../http/index.js';
-import { Msg } from '../internal/messaging/messageTags.js';
+import { failure, HttpResponseStatus } from '../../http/index.js';
 import { RateLimitConfigFactory } from './rateLimitConfigFactory.js';
+import { generateRedisLockKey } from '../redis/redisLockChecker.js';
+import { Msg } from '../../internal/messaging/messageTags.js';
 export const createGlobalRateLimiter = (config) => {
-    return createRateLimiter(config || RateLimitConfigFactory.globalIp);
+    return createRateLimiter(RateLimitConfigFactory.globalIp(config));
 };
 export const createRateLimiter = (config) => {
     return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
@@ -22,6 +23,8 @@ export const createRateLimiter = (config) => {
         res.setHeader('X-RateLimit-Limit', limit);
         res.setHeader('X-RateLimit-Remaining', Math.max(0, limit - currentCounter));
         res.setHeader('X-RateLimit-Reset', ttl);
+        console.log('IP:', req.ip);
+        console.log('Forwarded:', req.headers['x-forwarded-for']);
         if (!allowed) {
             return failure(res, HttpResponseStatus.TOO_MANY_REQUESTS, message || Msg.apiStatus.tooManyRequests);
         }
@@ -29,9 +32,17 @@ export const createRateLimiter = (config) => {
     });
 };
 const createRateLimitFromConfig = (config, req) => {
-    const { limit, windowSec, message } = config;
+    const { limit, windowSec, message, redisLockerConfig } = config;
     const key = generateKeyFromConfig(config, req);
-    return { key, limit, windowSec, message };
+    const rateLimit = { key, limit, windowSec, message };
+    if (redisLockerConfig) {
+        const { keyPrefix, ttlSeconds } = redisLockerConfig;
+        const { keySuffixes } = config;
+        const key = generateRedisLockKey(keyPrefix, keySuffixes, req);
+        const redisLock = { key, ttlSeconds };
+        rateLimit.redisLock = redisLock;
+    }
+    return rateLimit;
 };
 const generateKeyFromConfig = (config, req) => {
     const { keyPrefix, keySuffixes } = config;

package/dist/{rateLimit → middlewares/rateLimit}/index.d.ts

@@ -1,7 +1,8 @@
 import { checkRateLimit } from './checkRateLimit.js';
 import { createRateLimiter } from './createRateLimiter.js';
 import { RateLimitConfigFactory } from './rateLimitConfigFactory.js';
-import { RedisKeyFactory } from './redisKeysFactory.js';
-import { RateLimitConfig, RateLimit, RateLimitCheck } from './types.js';
+import { RedisKeyFactory } from '../redis/redisKeysFactory.js';
+import { type RateLimiter, RateLimitConfig, RateLimit, RateLimitCheck } from './types.js';
 export { checkRateLimit, createRateLimiter, RateLimitConfigFactory, RedisKeyFactory };
 export { RateLimitConfig, RateLimit, RateLimitCheck };
+export type { RateLimiter };

package/dist/{rateLimit → middlewares/rateLimit}/index.js

@@ -1,5 +1,5 @@
 import { checkRateLimit } from './checkRateLimit.js';
 import { createRateLimiter } from './createRateLimiter.js';
 import { RateLimitConfigFactory } from './rateLimitConfigFactory.js';
-import { RedisKeyFactory } from './redisKeysFactory.js';
+import { RedisKeyFactory } from '../redis/redisKeysFactory.js';
 export { checkRateLimit, createRateLimiter, RateLimitConfigFactory, RedisKeyFactory };

package/dist/middlewares/rateLimit/rateLimitConfigFactory.d.ts

@@ -0,0 +1,7 @@
+import { RateLimitConfig, RateLimitConfigParams } from "./types.js";
+export declare const RateLimitConfigFactory: {
+    globalIp: (params?: RateLimitConfigParams) => RateLimitConfig;
+    loginIp: (params?: RateLimitConfigParams) => RateLimitConfig;
+    loginIpMail: (params?: RateLimitConfigParams) => RateLimitConfig;
+    loginMail: (params?: RateLimitConfigParams) => RateLimitConfig;
+};

package/dist/middlewares/rateLimit/rateLimitConfigFactory.js

@@ -0,0 +1,30 @@
+import { RedisKeyFactory } from "../redis/redisKeysFactory.js";
+import { Msg } from "../../internal/messaging/messageTags.js";
+const defaultRateLimitConfig = {
+    keyPrefix: RedisKeyFactory.prefixes.login,
+    keySuffixes: RedisKeyFactory.suffixes.ip,
+    windowSec: 15 * 60,
+    limit: 5,
+    message: Msg.apiStatus.tooManyRequests,
+};
+const createRateLimitConfig = (params) => {
+    return Object.assign(Object.assign({}, defaultRateLimitConfig), params);
+};
+const globalIp = (params) => {
+    return createRateLimitConfig(Object.assign({ keyPrefix: RedisKeyFactory.prefixes.global, windowSec: 60, limit: 2 }, (params || {})));
+};
+const loginIp = (params) => {
+    return createRateLimitConfig(Object.assign({}, (params || {})));
+};
+const loginIpMail = (params) => {
+    return createRateLimitConfig(Object.assign({ keySuffixes: RedisKeyFactory.suffixes.ipMail }, (params || {})));
+};
+const loginMail = (params) => {
+    return createRateLimitConfig(Object.assign({ keySuffixes: RedisKeyFactory.suffixes.mail, redisLockerConfig: { keyPrefix: RedisKeyFactory.prefixes.lockEmail, ttlSeconds: 15 * 60 } }, (params || {})));
+};
+export const RateLimitConfigFactory = {
+    globalIp,
+    loginIp,
+    loginIpMail,
+    loginMail
+};

package/dist/middlewares/rateLimit/types.d.ts

@@ -0,0 +1,35 @@
+import { NextFunction, Request, Response } from 'express';
+import { RedisLockerConfig } from '../redis/types.js';
+export type RateLimiter = (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;
+export type RateLimitConfigParams = {
+    keyPrefix?: string;
+    keySuffixes?: (req: Request) => string[];
+    windowSec?: number;
+    limit?: number;
+    message?: string;
+    redisLockerConfig?: RedisLockerConfig | null;
+};
+export interface RateLimitConfig {
+    keyPrefix: string;
+    keySuffixes: (req: Request) => string[];
+    limit: number;
+    windowSec: number;
+    message?: string;
+    redisLockerConfig?: RedisLockerConfig | null;
+}
+export interface RateLimit {
+    key: string;
+    limit: number;
+    windowSec: number;
+    message?: string;
+    redisLock?: {
+        key: string;
+        ttlSeconds: number;
+    };
+}
+export interface RateLimitCheck {
+    currentCounter: number;
+    limit: number;
+    ttl: number;
+    allowed: boolean;
+}

package/dist/{rateLimit → middlewares/redis}/redisKeysFactory.d.ts

@@ -3,6 +3,7 @@ export declare const RedisKeyFactory: {
     prefixes: {
         readonly global: "global";
         readonly login: "login";
+        readonly lockEmail: "lock:email";
         readonly refresh: "refresh";
     };
     suffixes: {

package/dist/{rateLimit → middlewares/redis}/redisKeysFactory.js

@@ -1,7 +1,8 @@
 const prefixes = {
     global: 'global',
     login: 'login',
-    refresh: 'refresh'
+    lockEmail: 'lock:email',
+    refresh: 'refresh',
 };
 const getIpSuffixCallback = (req) => {
     const ip = req.ip || 'undefined';
@@ -9,12 +10,12 @@ const getIpSuffixCallback = (req) => {
 };
 const getEmailSuffixCallback = (req) => {
     var _a;
-    const email = ((_a = req.body) === null || _a === void 0 ? void 0 : _a.email) || 'unknown';
+    const email = (((_a = req.body) === null || _a === void 0 ? void 0 : _a.email) || 'unknown').toLowerCase();
     return [email];
 };
 const getIpEmailSuffixCallback = (req) => {
     var _a;
-    const email = ((_a = req.body) === null || _a === void 0 ? void 0 : _a.email) || 'unknown';
+    const email = (((_a = req.body) === null || _a === void 0 ? void 0 : _a.email) || 'unknown').toLowerCase();
     const ip = req.ip || 'unknown';
     return [ip, email];
 };

package/dist/middlewares/redis/redisLockChecker.d.ts

@@ -0,0 +1,5 @@
+import { RedisLockChecker, RedisLockCheckerConfig } from "./types.js";
+import { Request } from "express";
+export declare const createRedisLockChecker: (config: RedisLockCheckerConfig) => RedisLockChecker;
+export declare const generateRedisLockKey: (keyPrefix: string, keySuffixes: (req: Request) => string[], req: Request) => string;
+export declare const checkIfLockedInRedis: (key: string) => Promise<boolean>;

package/dist/middlewares/redis/redisLockChecker.js

@@ -0,0 +1,31 @@
+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());
+    });
+};
+import { getRedisClient } from "mielk-fn/redis";
+import { failure, HttpResponseStatus } from "../../http/index.js";
+import { Msg } from "../../internal/messaging/messageTags.js";
+export const createRedisLockChecker = (config) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const { message, keyPrefix, keySuffixes } = config;
+        const key = generateRedisLockKey(keyPrefix, keySuffixes, req);
+        const isLocked = yield checkIfLockedInRedis(key);
+        if (isLocked) {
+            return failure(res, HttpResponseStatus.LOCKED, message || Msg.apiStatus.locked);
+        }
+        return next();
+    });
+};
+export const generateRedisLockKey = (keyPrefix, keySuffixes, req) => {
+    return `${keyPrefix}:${keySuffixes(req).join(':')}`;
+};
+export const checkIfLockedInRedis = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const redisClient = yield getRedisClient();
+    const value = yield redisClient.get(key);
+    return value !== null;
+});

package/dist/middlewares/redis/redisLockCheckerConfigFactory.d.ts

@@ -0,0 +1,4 @@
+import { RedisLockCheckerConfig, RedisLockCheckerConfigParams } from "./types.js";
+export declare const RedisLockCheckerConfigFactory: {
+    mail: (params?: RedisLockCheckerConfigParams) => RedisLockCheckerConfig;
+};

package/dist/middlewares/redis/redisLockCheckerConfigFactory.js

@@ -0,0 +1,16 @@
+import { RedisKeyFactory } from "./redisKeysFactory.js";
+import { Msg } from "../../internal/messaging/messageTags.js";
+const defaultRedisLockCheckerConfig = {
+    keyPrefix: RedisKeyFactory.prefixes.lockEmail,
+    keySuffixes: RedisKeyFactory.suffixes.mail,
+    message: Msg.apiStatus.locked,
+};
+const createRedisLockCheckerConfig = (params) => {
+    return Object.assign(Object.assign({}, defaultRedisLockCheckerConfig), params);
+};
+const mail = (params) => {
+    return createRedisLockCheckerConfig(Object.assign({}, (params || {})));
+};
+export const RedisLockCheckerConfigFactory = {
+    mail,
+};

package/dist/middlewares/redis/redisLocker.d.ts

@@ -0,0 +1,2 @@
+export declare const setRedisLock: (key: string, ttlSeconds: number) => Promise<void>;
+export declare const removeRedisLock: (key: string) => Promise<void>;

package/dist/middlewares/redis/redisLocker.js

@@ -0,0 +1,23 @@
+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());
+    });
+};
+import { getRedisClient } from "mielk-fn/redis";
+export const setRedisLock = (key, ttlSeconds) => __awaiter(void 0, void 0, void 0, function* () {
+    const redisClient = yield getRedisClient();
+    yield redisClient.set(key, JSON.stringify({ locked: true }), {
+        expiration: {
+            type: 'EX',
+            value: ttlSeconds
+        }
+    });
+});
+export const removeRedisLock = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const redisClient = yield getRedisClient();
+    yield redisClient.del(key);
+});

package/dist/middlewares/redis/redisLockerConfigFactory.d.ts

@@ -0,0 +1,4 @@
+import { RedisLockerConfig, RedisLockerConfigParams } from "./types.js";
+export declare const RedisLockerConfigFactory: {
+    mail: (params?: RedisLockerConfigParams) => RedisLockerConfig;
+};

package/dist/middlewares/redis/redisLockerConfigFactory.js

@@ -0,0 +1,14 @@
+import { RedisKeyFactory } from "./redisKeysFactory.js";
+const defaultRedisLockerConfig = {
+    keyPrefix: RedisKeyFactory.prefixes.lockEmail,
+    ttlSeconds: 30 * 60,
+};
+const createRedisLockerConfig = (params) => {
+    return Object.assign(Object.assign({}, defaultRedisLockerConfig), params);
+};
+const mail = (params) => {
+    return createRedisLockerConfig(Object.assign({}, (params || {})));
+};
+export const RedisLockerConfigFactory = {
+    mail,
+};

package/dist/middlewares/redis/types.d.ts

@@ -0,0 +1,20 @@
+import { NextFunction, Request, Response } from "express";
+export type RedisLockChecker = (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;
+export interface RedisLockCheckerConfigParams {
+    keyPrefix?: string;
+    keySuffixes?: (req: Request) => string[];
+    message?: string;
+}
+export interface RedisLockCheckerConfig {
+    keyPrefix: string;
+    keySuffixes: (req: Request) => string[];
+    message: string;
+}
+export interface RedisLockerConfigParams {
+    keyPrefix?: string;
+    ttlSeconds?: number;
+}
+export interface RedisLockerConfig {
+    keyPrefix: string;
+    ttlSeconds: number;
+}

package/dist/middlewares/redis/types.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/express.d.ts

@@ -2,8 +2,8 @@ import { PostgreDbConfig } from '../db/pg/index.js';
 import { MsSqlDbConfig } from '../db/mssql/index.js';
 import { CorsConfig } from '../middlewares/index.js';
 import { DbProvider } from './DbProvider.js';
-import { RateLimitConfig } from '../rateLimit/types.js';
+import { RateLimitConfigParams } from '../middlewares/rateLimit/types.js';
 export type DbConfig = PostgreDbConfig | MsSqlDbConfig;
-export declare const createExpressApp: (isProd: boolean, dbConfig: DbConfig, corsConfig: CorsConfig, rateLimitConfig?: RateLimitConfig) => Promise<import("express-serve-static-core").Express>;
+export declare const createExpressApp: (isProd: boolean, dbConfig: DbConfig, corsConfig: CorsConfig, rateLimitConfig?: RateLimitConfigParams) => Promise<import("express-serve-static-core").Express>;
 export declare const isProd: () => boolean;
 export declare const getDbProvider: () => DbProvider;

package/dist/routing/express.js

@@ -11,7 +11,7 @@ import express from 'express';
 import { initDb as postgreInitDb } from '../db/pg/index.js';
 import { initDb as msSqlInitDb } from '../db/mssql/index.js';
 import { initCors } from '../middlewares/index.js';
-import { createGlobalRateLimiter } from '../rateLimit/createRateLimiter.js';
+import { createGlobalRateLimiter } from '../middlewares/rateLimit/createRateLimiter.js';
 const env = {
     isProd: true,
     provider: undefined
@@ -31,6 +31,8 @@ export const createExpressApp = (isProd, dbConfig, corsConfig, rateLimitConfig)
     initCors(corsConfig);
     app.use(createGlobalRateLimiter(rateLimitConfig));
     app.use(express.json());
+    if (isProd)
+        app.set('trust proxy', 1);
     return app;
 });
 export const isProd = () => env.isProd;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-api",
-	"version": "1.4.0",
+	"version": "1.5.1",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Wrapper for API operations",
@@ -34,9 +34,9 @@
 			"default": "./dist/middlewares/index.js"
 		},
 		"./rate-limit": {
-			"types": "./dist/rateLimit/index.d.ts",
-			"import": "./dist/rateLimit/index.js",
-			"default": "./dist/rateLimit/index.js"
+			"types": "./dist/middlewares/rateLimit/index.d.ts",
+			"import": "./dist/middlewares/rateLimit/index.js",
+			"default": "./dist/middlewares/rateLimit/index.js"
 		}
 	},
 	"scripts": {

package/dist/rateLimit/rateLimitConfigFactory.d.ts

@@ -1,7 +0,0 @@
-import { RateLimitConfig } from "./types.js";
-export declare const RateLimitConfigFactory: {
-    globalIp: RateLimitConfig;
-    loginIp: RateLimitConfig;
-    loginIpMail: RateLimitConfig;
-    loginMail: RateLimitConfig;
-};

package/dist/rateLimit/rateLimitConfigFactory.js

@@ -1,30 +0,0 @@
-import { RedisKeyFactory } from "./redisKeysFactory.js";
-import { Msg } from "../internal/messaging/messageTags.js";
-const defaultRateLimitConfig = {
-    keyPrefix: RedisKeyFactory.prefixes.login,
-    keySuffixes: RedisKeyFactory.suffixes.ip,
-    windowSec: 15 * 60,
-    limit: 5,
-    message: Msg.apiStatus.tooManyRequests,
-};
-const createRateLimitConfig = (params) => {
-    return Object.assign(Object.assign({}, defaultRateLimitConfig), params);
-};
-const globalIp = createRateLimitConfig({
-    keyPrefix: RedisKeyFactory.prefixes.global,
-    windowSec: 60,
-    limit: 100,
-});
-const loginIp = defaultRateLimitConfig;
-const loginIpMail = createRateLimitConfig({
-    keySuffixes: RedisKeyFactory.suffixes.ipMail,
-});
-const loginMail = createRateLimitConfig({
-    keySuffixes: RedisKeyFactory.suffixes.mail,
-});
-export const RateLimitConfigFactory = {
-    globalIp,
-    loginIp,
-    loginIpMail,
-    loginMail
-};

package/dist/rateLimit/types.d.ts

@@ -1,20 +0,0 @@
-import { Request } from "express";
-export interface RateLimitConfig {
-    keyPrefix: string;
-    keySuffixes: (req: Request) => string[];
-    limit: number;
-    windowSec: number;
-    message?: string;
-}
-export interface RateLimit {
-    key: string;
-    limit: number;
-    windowSec: number;
-    message?: string;
-}
-export interface RateLimitCheck {
-    currentCounter: number;
-    limit: number;
-    ttl: number;
-    allowed: boolean;
-}