mielk-api 1.3.9 → 1.4.0

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

@@ -4,7 +4,9 @@ export declare const HttpResponseStatus: {
     CREATED: HttpStatus;
     BAD_REQUEST: HttpStatus;
     UNAUTHORIZED: HttpStatus;
+    FORBIDDEN: HttpStatus;
     NOT_FOUND: HttpStatus;
     CONFLICT: HttpStatus;
+    TOO_MANY_REQUESTS: HttpStatus;
     SERVER_ERROR: HttpStatus;
 };

package/dist/http/httpResponseStatus/HttpResponseStatus.js

@@ -6,7 +6,9 @@ export const HttpResponseStatus = {
     CREATED: createApiStatus(true, 201, msg.created),
     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),
+    TOO_MANY_REQUESTS: createApiStatus(false, 429, msg.tooManyRequests),
     SERVER_ERROR: createApiStatus(false, 500, msg.serverError),
 };

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

@@ -2,10 +2,12 @@ export declare const Msg: {
     apiStatus: {
         ok: string;
         created: string;
-        unauthorized: string;
         badRequest: string;
+        unauthorized: string;
+        forbidden: string;
         notFound: string;
         conflict: string;
+        tooManyRequests: string;
         serverError: string;
     };
     connection: {

package/dist/internal/messaging/messageTags.js

@@ -5,10 +5,12 @@ export const Msg = {
     apiStatus: {
         ok: `${___HTTP_STATUS___}:ok`,
         created: `${___HTTP_STATUS___}:created`,
-        unauthorized: `${___HTTP_STATUS___}:unauthorized`,
         badRequest: `${___HTTP_STATUS___}:badRequest`,
+        unauthorized: `${___HTTP_STATUS___}:unauthorized`,
+        forbidden: `${___HTTP_STATUS___}:forbidden`,
         notFound: `${___HTTP_STATUS___}:notFound`,
         conflict: `${___HTTP_STATUS___}:conflict`,
+        tooManyRequests: `${___HTTP_STATUS___}:tooManyRequests`,
         serverError: `${___HTTP_STATUS___}:serverError`,
     },
     connection: {

package/dist/middlewares/cors/privateCors.js

@@ -15,4 +15,5 @@ export const privateCors = cors({
     },
     methods: ['GET', 'POST', 'PUT', 'DELETE'],
     allowedHeaders: ['Content-Type', 'Authorization'],
+    credentials: true
 });

package/dist/middlewares/cors/publicCors.js

@@ -7,4 +7,5 @@ export const publicCors = cors({
     },
     methods: ['GET'],
     allowedHeaders: ['Content-Type', 'Authorization'],
+    credentials: true
 });

package/dist/middlewares/index.d.ts

@@ -1,10 +1,8 @@
 import { CorsConfig, initCors } from './cors/cors.js';
 import { privateCors } from './cors/privateCors.js';
 import { publicCors } from './cors/publicCors.js';
-import { RateLimitConfig, setRateLimit } from './rateLimit/rateLimit.js';
 import { apiKeyAuthorization } from './requestAuth/auth.middleware.js';
 import { validateQueryParams, validateBodyJson } from './zod/validate.js';
 export { CorsConfig, initCors, privateCors, publicCors };
-export { RateLimitConfig, setRateLimit };
 export { apiKeyAuthorization };
 export { validateQueryParams, validateBodyJson };

package/dist/middlewares/index.js

@@ -1,10 +1,8 @@
 import { initCors } from './cors/cors.js';
 import { privateCors } from './cors/privateCors.js';
 import { publicCors } from './cors/publicCors.js';
-import { setRateLimit } from './rateLimit/rateLimit.js';
 import { apiKeyAuthorization } from './requestAuth/auth.middleware.js';
 import { validateQueryParams, validateBodyJson } from './zod/validate.js';
 export { initCors, privateCors, publicCors };
-export { setRateLimit };
 export { apiKeyAuthorization };
 export { validateQueryParams, validateBodyJson };

package/dist/rateLimit/checkRateLimit.d.ts

@@ -0,0 +1,2 @@
+import { RateLimitCheck, RateLimit } from './types.js';
+export declare const checkRateLimit: (rateLimit: RateLimit) => Promise<RateLimitCheck>;

package/dist/rateLimit/checkRateLimit.js

@@ -0,0 +1,26 @@
+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 checkRateLimit = (rateLimit) => __awaiter(void 0, void 0, void 0, function* () {
+    const { key, limit, windowSec } = rateLimit;
+    const client = yield getRedisClient();
+    const currentCounter = yield client.incr(key);
+    if (currentCounter === 1) {
+        yield client.expire(key, windowSec);
+    }
+    const ttl = yield client.ttl(key);
+    const allowed = currentCounter <= limit;
+    return {
+        currentCounter,
+        limit,
+        ttl,
+        allowed
+    };
+});

package/dist/rateLimit/createRateLimiter.d.ts

@@ -0,0 +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>>>;
+export declare const createRateLimiter: (config: RateLimitConfig) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;

package/dist/rateLimit/createRateLimiter.js

@@ -0,0 +1,39 @@
+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 { checkRateLimit } from './checkRateLimit.js';
+import { failure, HttpResponseStatus } from '../http/index.js';
+import { Msg } from '../internal/messaging/messageTags.js';
+import { RateLimitConfigFactory } from './rateLimitConfigFactory.js';
+export const createGlobalRateLimiter = (config) => {
+    return createRateLimiter(config || RateLimitConfigFactory.globalIp);
+};
+export const createRateLimiter = (config) => {
+    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const { message } = config;
+        const rateLimit = createRateLimitFromConfig(config, req);
+        const { limit, currentCounter, ttl, allowed } = yield checkRateLimit(rateLimit);
+        res.setHeader('X-RateLimit-Limit', limit);
+        res.setHeader('X-RateLimit-Remaining', Math.max(0, limit - currentCounter));
+        res.setHeader('X-RateLimit-Reset', ttl);
+        if (!allowed) {
+            return failure(res, HttpResponseStatus.TOO_MANY_REQUESTS, message || Msg.apiStatus.tooManyRequests);
+        }
+        return next();
+    });
+};
+const createRateLimitFromConfig = (config, req) => {
+    const { limit, windowSec, message } = config;
+    const key = generateKeyFromConfig(config, req);
+    return { key, limit, windowSec, message };
+};
+const generateKeyFromConfig = (config, req) => {
+    const { keyPrefix, keySuffixes } = config;
+    return `${keyPrefix}:${keySuffixes(req).join(':')}`;
+};

package/dist/rateLimit/index.d.ts

@@ -0,0 +1,7 @@
+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';
+export { checkRateLimit, createRateLimiter, RateLimitConfigFactory, RedisKeyFactory };
+export { RateLimitConfig, RateLimit, RateLimitCheck };

package/dist/rateLimit/index.js

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

package/dist/rateLimit/rateLimitConfigFactory.d.ts

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

package/dist/rateLimit/rateLimitConfigFactory.js

@@ -0,0 +1,30 @@
+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/redisKeysFactory.d.ts

@@ -0,0 +1,13 @@
+import { Request } from 'express';
+export declare const RedisKeyFactory: {
+    prefixes: {
+        readonly global: "global";
+        readonly login: "login";
+        readonly refresh: "refresh";
+    };
+    suffixes: {
+        readonly ip: (req: Request) => string[];
+        readonly ipMail: (req: Request) => string[];
+        readonly mail: (req: Request) => string[];
+    };
+};

package/dist/rateLimit/redisKeysFactory.js

@@ -0,0 +1,29 @@
+const prefixes = {
+    global: 'global',
+    login: 'login',
+    refresh: 'refresh'
+};
+const getIpSuffixCallback = (req) => {
+    const ip = req.ip || 'undefined';
+    return [ip];
+};
+const getEmailSuffixCallback = (req) => {
+    var _a;
+    const email = ((_a = req.body) === null || _a === void 0 ? void 0 : _a.email) || 'unknown';
+    return [email];
+};
+const getIpEmailSuffixCallback = (req) => {
+    var _a;
+    const email = ((_a = req.body) === null || _a === void 0 ? void 0 : _a.email) || 'unknown';
+    const ip = req.ip || 'unknown';
+    return [ip, email];
+};
+const suffixCallbacks = {
+    'ip': getIpSuffixCallback,
+    'ipMail': getIpEmailSuffixCallback,
+    'mail': getEmailSuffixCallback,
+};
+export const RedisKeyFactory = {
+    prefixes: prefixes,
+    suffixes: suffixCallbacks
+};

package/dist/rateLimit/types.d.ts

@@ -0,0 +1,20 @@
+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;
+}

package/dist/rateLimit/types.js

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

package/dist/routing/express.d.ts

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

package/dist/routing/express.js

@@ -1,12 +1,22 @@
+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 express from 'express';
 import { initDb as postgreInitDb } from '../db/pg/index.js';
 import { initDb as msSqlInitDb } from '../db/mssql/index.js';
-import { initCors, setRateLimit } from '../middlewares/index.js';
+import { initCors } from '../middlewares/index.js';
+import { createGlobalRateLimiter } from '../rateLimit/createRateLimiter.js';
 const env = {
     isProd: true,
     provider: undefined
 };
-export const createExpressApp = (isProd, dbConfig, corsConfig, rateLimitConfig) => {
+export const createExpressApp = (isProd, dbConfig, corsConfig, rateLimitConfig) => __awaiter(void 0, void 0, void 0, function* () {
     const app = express();
     env.isProd = isProd;
     env.provider = dbConfig.provider;
@@ -19,9 +29,9 @@ export const createExpressApp = (isProd, dbConfig, corsConfig, rateLimitConfig)
             break;
     }
     initCors(corsConfig);
-    setRateLimit(app, rateLimitConfig);
+    app.use(createGlobalRateLimiter(rateLimitConfig));
     app.use(express.json());
     return app;
-};
+});
 export const isProd = () => env.isProd;
 export const getDbProvider = () => env.provider;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-api",
-	"version": "1.3.9",
+	"version": "1.4.0",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Wrapper for API operations",
@@ -32,6 +32,11 @@
 			"types": "./dist/middlewares/index.d.ts",
 			"import": "./dist/middlewares/index.js",
 			"default": "./dist/middlewares/index.js"
+		},
+		"./rate-limit": {
+			"types": "./dist/rateLimit/index.d.ts",
+			"import": "./dist/rateLimit/index.js",
+			"default": "./dist/rateLimit/index.js"
 		}
 	},
 	"scripts": {
@@ -71,7 +76,6 @@
 	],
 	"peerDependencies": {
 		"express": "^5",
-		"express-rate-limit": "^8",
 		"zod": "^4"
 	},
 	"optionalDependencies": {
@@ -79,7 +83,8 @@
 	},
 	"dependencies": {
 		"cors": "^2.8.6",
-		"mielk-fn": "^1.1.1",
+		"express-rate-limit": "^8.3.1",
+		"mielk-fn": "^1.2.0",
 		"pg": "^8.20.0",
 		"tunnel-ssh": "^5.2.0"
 	}

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

@@ -1,6 +0,0 @@
-import { Express } from 'express';
-export interface RateLimitConfig {
-    windowsMs?: number;
-    max?: number;
-}
-export declare const setRateLimit: (app: Express, customConfig?: RateLimitConfig) => void;

package/dist/middlewares/rateLimit/rateLimit.js

@@ -1,10 +0,0 @@
-import rateLimit from 'express-rate-limit';
-const rateLimitConfig = {
-    windowMs: 60 * 1000,
-    max: 100,
-};
-export const setRateLimit = (app, customConfig) => {
-    const config = Object.assign(Object.assign({}, rateLimitConfig), customConfig);
-    const limiter = rateLimit(config);
-    app.use(limiter);
-};