mielk-api 1.5.5 → 1.5.7

package/dist/middlewares/rateLimit/checkRateLimit.js

@@ -20,8 +20,10 @@ export const checkRateLimit = (rateLimit) => __awaiter(void 0, void 0, void 0, f
     const allowed = currentCounter <= limit;
     if (!allowed && redisLock) {
         const { key, ttlSeconds } = redisLock;
+        console.log(`Setting Redis lock for ${key} | ${ttlSeconds} seconds`);
         setRedisLock(key, ttlSeconds);
     }
+    console.log('RL key:', key, 'current:', currentCounter, 'ttl:', ttl);
     return {
         currentCounter,
         limit,

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

@@ -1,4 +1,8 @@
 import { Request, Response, NextFunction } from 'express';
-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>>>;
+import { RateLimitConfig } from './types.js';
+import { RateLimitType } from './rateLimitConfigFactory.js';
+export declare const createGlobalRateLimiter: (config?: Partial<RateLimitConfig>) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;
+export declare const createRateLimiter: (params: {
+    type?: RateLimitType;
+    customConfig?: Partial<RateLimitConfig>;
+}) => (req: Request, res: Response, next: NextFunction) => Promise<void | Response<Record<string, any>, Record<string, any>>>;

package/dist/middlewares/rateLimit/createRateLimiter.js

@@ -9,14 +9,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { checkRateLimit } from './checkRateLimit.js';
 import { failure, HttpResponseStatus } from '../../http/index.js';
-import { RateLimitConfigFactory } from './rateLimitConfigFactory.js';
-import { generateRedisLockKey } from '../redis/redisLockChecker.js';
+import { createRateLimitConfig } from './rateLimitConfigFactory.js';
+import { generateRedisKeyFromRequest } from '../redis/redisKeysFactory.js';
 import { Msg } from '../../internal/messaging/messageTags.js';
-import { generateRedisKey } from '../redis/redisKeysFactory.js';
 export const createGlobalRateLimiter = (config) => {
-    return createRateLimiter(RateLimitConfigFactory.globalIp(config));
+    return createRateLimiter({ type: 'globalIp', customConfig: config });
 };
-export const createRateLimiter = (config) => {
+export const createRateLimiter = (params) => {
+    const config = createRateLimitConfig(params);
     return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
         const { message } = config;
         const rateLimit = createRateLimitFromConfig(config, req);
@@ -34,12 +34,11 @@ export const createRateLimiter = (config) => {
 };
 const createRateLimitFromConfig = (config, req) => {
     const { keyPrefix, keySuffixes, limit, windowSec, message, redisLockerConfig } = config;
-    const key = generateRedisKey(keyPrefix, keySuffixes, req);
+    const key = generateRedisKeyFromRequest(keyPrefix, keySuffixes, req);
     const rateLimit = { key, limit, windowSec, message };
     if (redisLockerConfig) {
         const { keyPrefix, ttlSeconds } = redisLockerConfig;
-        const { keySuffixes } = config;
-        const key = generateRedisLockKey(keyPrefix, keySuffixes, req);
+        const key = generateRedisKeyFromRequest(keyPrefix, keySuffixes, req);
         const redisLock = { key, ttlSeconds };
         rateLimit.redisLock = redisLock;
     }

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

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

package/dist/middlewares/rateLimit/index.js

@@ -1,4 +1,3 @@
 import { checkRateLimit } from './checkRateLimit.js';
 import { createRateLimiter } from './createRateLimiter.js';
-import { RateLimitConfigFactory } from './rateLimitConfigFactory.js';
-export { checkRateLimit, createRateLimiter, RateLimitConfigFactory };
+export { checkRateLimit, createRateLimiter };

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

@@ -1,7 +1,25 @@
-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;
+import { RateLimitConfig } from "./types.js";
+declare const configs: {
+    readonly globalIp: {
+        readonly keyPrefix: "auth.global" | "auth.login" | "auth.lock:email" | "auth.refresh";
+        readonly windowSec: 60;
+        readonly limit: 2;
+    };
+    readonly loginIp: {};
+    readonly loginIpMail: {
+        readonly keySuffixes: ((req: import("express").Request) => string[]) | ((req: import("express").Request) => string[]) | ((req: import("express").Request) => string[]);
+    };
+    readonly loginMail: {
+        readonly keySuffixes: ((req: import("express").Request) => string[]) | ((req: import("express").Request) => string[]) | ((req: import("express").Request) => string[]);
+        readonly redisLockerConfig: {
+            readonly keyPrefix: "auth.global" | "auth.login" | "auth.lock:email" | "auth.refresh";
+            readonly ttlSeconds: number;
+        };
+    };
 };
+export type RateLimitType = keyof typeof configs;
+export declare const createRateLimitConfig: (params: {
+    type?: RateLimitType;
+    customConfig?: Partial<RateLimitConfig>;
+}) => RateLimitConfig;
+export {};

package/dist/middlewares/rateLimit/rateLimitConfigFactory.js

@@ -1,30 +1,31 @@
-import { RedisKeyFactory } from "../redis/redisKeysFactory.js";
+import { getRedisPrefix, getRedisSuffixCallback } from "../redis/redisKeysFactory.js";
 import { Msg } from "../../internal/messaging/messageTags.js";
-const defaultRateLimitConfig = {
-    keyPrefix: RedisKeyFactory.prefixes.authLogin,
-    keySuffixes: RedisKeyFactory.suffixes.ip,
+const defaultConfig = {
+    keyPrefix: getRedisPrefix("authLogin"),
+    keySuffixes: getRedisSuffixCallback("ip"),
     windowSec: 15 * 60,
     limit: 5,
     message: Msg.apiStatus.tooManyRequests,
 };
-const createRateLimitConfig = (params) => {
-    return Object.assign(Object.assign({}, defaultRateLimitConfig), params);
+const configs = {
+    globalIp: {
+        keyPrefix: getRedisPrefix("authGlobal"),
+        windowSec: 60,
+        limit: 2
+    },
+    loginIp: {},
+    loginIpMail: {
+        keySuffixes: getRedisSuffixCallback("ipMail"),
+    },
+    loginMail: {
+        keySuffixes: getRedisSuffixCallback("mail"),
+        redisLockerConfig: {
+            keyPrefix: getRedisPrefix("authLockEmail"), ttlSeconds: 15 * 60
+        }
+    }
 };
-const globalIp = (params) => {
-    return createRateLimitConfig(Object.assign({ keyPrefix: RedisKeyFactory.prefixes.authGlobal, 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.authLockEmail, ttlSeconds: 15 * 60 } }, (params || {})));
-};
-export const RateLimitConfigFactory = {
-    globalIp,
-    loginIp,
-    loginIpMail,
-    loginMail
+export const createRateLimitConfig = (params) => {
+    const { type, customConfig } = params;
+    const typeConfig = type ? configs[type] : undefined;
+    return Object.assign(Object.assign(Object.assign({}, defaultConfig), typeConfig), customConfig);
 };

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

@@ -1,17 +1,9 @@
 import { NextFunction, Request, Response } from 'express';
-import { RedisLockerConfig } from '../redis/types.js';
+import { RedisLockerConfig, RequestParamsFetcher } 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[];
+    keySuffixes: RequestParamsFetcher;
     limit: number;
     windowSec: number;
     message?: string;

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

@@ -1,14 +1,8 @@
-import { RedisLockerConfigFactory } from './redisLockerConfigFactory.js';
-import { RedisLockerConfig, RedisLockerConfigParams } from './types.js';
+import { RedisLockChecker, RequestParamsFetcher } from './types.js';
 import { setRedisLock, removeRedisLock } from './redisLocker.js';
-import { RedisLockCheckerConfigFactory } from './redisLockCheckerConfigFactory.js';
-import { RedisLockChecker, RedisLockCheckerConfig, RedisLockCheckerConfigParams } from './types.js';
-import { createRedisLockChecker, checkIfLockedInRedis } from './redisLockChecker.js';
-import { generateRedisKey, RedisKeyFactory } from './redisKeysFactory.js';
-export { RedisLockerConfigFactory };
-export { RedisLockerConfig, RedisLockerConfigParams };
+import { createRedisLockChecker } from './redisLockChecker.js';
+import { getRedisPrefix, generateRedisKeyFromValue, generateRedisKeyFromRequest } from './redisKeysFactory.js';
+export { RedisLockChecker, RequestParamsFetcher };
 export { setRedisLock, removeRedisLock };
-export { createRedisLockChecker, checkIfLockedInRedis };
-export { RedisLockCheckerConfigFactory };
-export { RedisLockChecker, RedisLockCheckerConfig, RedisLockCheckerConfigParams };
-export { generateRedisKey, RedisKeyFactory };
+export { createRedisLockChecker };
+export { getRedisPrefix, generateRedisKeyFromRequest, generateRedisKeyFromValue };

package/dist/middlewares/redis/index.js

@@ -1,16 +1,12 @@
 // Redis locker
-import { RedisLockerConfigFactory } from './redisLockerConfigFactory.js';
 import { setRedisLock, removeRedisLock } from './redisLocker.js';
 // Redis lock checker
-import { RedisLockCheckerConfigFactory } from './redisLockCheckerConfigFactory.js';
-import { createRedisLockChecker, checkIfLockedInRedis } from './redisLockChecker.js';
+import { createRedisLockChecker } from './redisLockChecker.js';
 // Redis keys
-import { generateRedisKey, RedisKeyFactory } from './redisKeysFactory.js';
+import { getRedisPrefix, generateRedisKeyFromValue, generateRedisKeyFromRequest } from './redisKeysFactory.js';
 // Redis locker
-export { RedisLockerConfigFactory };
 export { setRedisLock, removeRedisLock };
 // Redis lock checker
-export { createRedisLockChecker, checkIfLockedInRedis };
-export { RedisLockCheckerConfigFactory };
+export { createRedisLockChecker };
 // Redis keys
-export { generateRedisKey, RedisKeyFactory };
+export { getRedisPrefix, generateRedisKeyFromRequest, generateRedisKeyFromValue };

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

@@ -1,15 +1,20 @@
 import { Request } from 'express';
-export declare const RedisKeyFactory: {
-    prefixes: {
-        readonly authGlobal: "auth.global";
-        readonly authLogin: "auth.login";
-        readonly authLockEmail: "auth.lock:email";
-        readonly authRefresh: "auth.refresh";
-    };
-    suffixes: {
-        readonly ip: (req: Request) => string[];
-        readonly ipMail: (req: Request) => string[];
-        readonly mail: (req: Request) => string[];
-    };
+import { RequestParamsFetcher } from './types.js';
+declare const prefixes: {
+    readonly authGlobal: "auth.global";
+    readonly authLogin: "auth.login";
+    readonly authLockEmail: "auth.lock:email";
+    readonly authRefresh: "auth.refresh";
 };
-export declare const generateRedisKey: (prefix: string, suffixCallback: (req: Request) => string[], req: Request) => string;
+type RedisKeyPrefix = keyof typeof prefixes;
+declare const suffixCallbacks: {
+    readonly ip: (req: Request) => string[];
+    readonly ipMail: (req: Request) => string[];
+    readonly mail: (req: Request) => string[];
+};
+type RedisKeySuffixCallback = keyof typeof suffixCallbacks;
+export declare const generateRedisKeyFromValue: (prefix: RedisKeyPrefix | string, value: string[]) => string;
+export declare const generateRedisKeyFromRequest: (prefix: RedisKeyPrefix | string, suffixCallback: RedisKeySuffixCallback | RequestParamsFetcher, req: Request) => string;
+export declare const getRedisPrefix: (key: RedisKeyPrefix) => "auth.global" | "auth.login" | "auth.lock:email" | "auth.refresh";
+export declare const getRedisSuffixCallback: (key: RedisKeySuffixCallback) => ((req: Request) => string[]) | ((req: Request) => string[]) | ((req: Request) => string[]);
+export {};

package/dist/middlewares/redis/redisKeysFactory.js

@@ -1,9 +1,13 @@
+// ### PREFIXES
 const prefixes = {
     authGlobal: 'auth.global',
     authLogin: 'auth.login',
     authLockEmail: 'auth.lock:email',
     authRefresh: 'auth.refresh',
 };
+const isKnownPrefix = (value) => value in prefixes;
+// ### SUFFIXES
+const isRequestParamFetcher = (value) => typeof value === 'function';
 const getIpSuffixCallback = (req) => {
     const ip = req.ip || 'undefined';
     return [ip];
@@ -24,10 +28,18 @@ const suffixCallbacks = {
     'ipMail': getIpEmailSuffixCallback,
     'mail': getEmailSuffixCallback,
 };
-export const RedisKeyFactory = {
-    prefixes: prefixes,
-    suffixes: suffixCallbacks
+// ### CALCULATING KEYS
+const generateRedisKey = (prefix, suffixes) => {
+    const prefixValue = isKnownPrefix(prefix) ? prefixes[prefix] : prefix;
+    return `${prefixValue}:${suffixes.join(':')}`;
 };
-export const generateRedisKey = (prefix, suffixCallback, req) => {
-    return `${prefix}:${suffixCallback(req).join(':')}`;
+export const generateRedisKeyFromValue = (prefix, value) => {
+    return generateRedisKey(prefix, value);
 };
+export const generateRedisKeyFromRequest = (prefix, suffixCallback, req) => {
+    const callback = isRequestParamFetcher(suffixCallback) ? suffixCallback : suffixCallbacks[suffixCallback];
+    const suffixes = callback(req);
+    return generateRedisKey(prefix, suffixes);
+};
+export const getRedisPrefix = (key) => prefixes[key];
+export const getRedisSuffixCallback = (key) => suffixCallbacks[key];

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

@@ -1,5 +1,6 @@
 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>;
+import { RedisLockCheckerType } from "./redisLockCheckerConfigFactory.js";
+export declare const createRedisLockChecker: (params: {
+    type?: RedisLockCheckerType;
+    customConfig?: Partial<RedisLockCheckerConfig>;
+}) => RedisLockChecker;

package/dist/middlewares/redis/redisLockChecker.js

@@ -9,8 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { getRedisClient } from "mielk-fn/redis";
 import { failure, HttpResponseStatus } from "../../http/index.js";
+import { createRedisLockCheckerConfig } from "./redisLockCheckerConfigFactory.js";
+import { generateRedisKeyFromRequest } from "./redisKeysFactory.js";
 import { Msg } from "../../internal/messaging/messageTags.js";
-export const createRedisLockChecker = (config) => {
+export const createRedisLockChecker = (params) => {
+    const config = createRedisLockCheckerConfig(params);
     return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
         const { message, keyPrefix, keySuffixes } = config;
         const key = generateRedisLockKey(keyPrefix, keySuffixes, req);
@@ -21,10 +24,10 @@ export const createRedisLockChecker = (config) => {
         return next();
     });
 };
-export const generateRedisLockKey = (keyPrefix, keySuffixes, req) => {
-    return `${keyPrefix}:${keySuffixes(req).join(':')}`;
+const generateRedisLockKey = (keyPrefix, suffixCallback, req) => {
+    return generateRedisKeyFromRequest(keyPrefix, suffixCallback, req);
 };
-export const checkIfLockedInRedis = (key) => __awaiter(void 0, void 0, void 0, function* () {
+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

@@ -1,4 +1,10 @@
-import { RedisLockCheckerConfig, RedisLockCheckerConfigParams } from "./types.js";
-export declare const RedisLockCheckerConfigFactory: {
-    mail: (params?: RedisLockCheckerConfigParams) => RedisLockCheckerConfig;
+import { RedisLockCheckerConfig } from './types.js';
+declare const configs: {
+    readonly mail: {};
 };
+export type RedisLockCheckerType = keyof typeof configs;
+export declare const createRedisLockCheckerConfig: (params: {
+    type?: RedisLockCheckerType;
+    customConfig?: Partial<RedisLockCheckerConfig>;
+}) => RedisLockCheckerConfig;
+export {};

package/dist/middlewares/redis/redisLockCheckerConfigFactory.js

@@ -1,16 +1,15 @@
-import { RedisKeyFactory } from "./redisKeysFactory.js";
 import { Msg } from "../../internal/messaging/messageTags.js";
-const defaultRedisLockCheckerConfig = {
-    keyPrefix: RedisKeyFactory.prefixes.authLockEmail,
-    keySuffixes: RedisKeyFactory.suffixes.mail,
+import { getRedisPrefix, getRedisSuffixCallback } from "./redisKeysFactory.js";
+const defaultConfig = {
+    keyPrefix: getRedisPrefix("authLockEmail"),
+    keySuffixes: getRedisSuffixCallback("mail"),
     message: Msg.apiStatus.locked,
 };
-const createRedisLockCheckerConfig = (params) => {
-    return Object.assign(Object.assign({}, defaultRedisLockCheckerConfig), params);
+const configs = {
+    mail: {}
 };
-const mail = (params) => {
-    return createRedisLockCheckerConfig(Object.assign({}, (params || {})));
-};
-export const RedisLockCheckerConfigFactory = {
-    mail,
+export const createRedisLockCheckerConfig = (params) => {
+    const { type, customConfig } = params;
+    const typeConfig = type ? configs[type] : undefined;
+    return Object.assign(Object.assign(Object.assign({}, defaultConfig), typeConfig), customConfig);
 };

package/dist/middlewares/redis/redisLocker.js

@@ -7,17 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { getRedisClient } from 'mielk-fn/redis';
+import { addRedisKey, removeRedisKey } 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
-        }
-    });
+    yield addRedisKey(key, { locked: true }, ttlSeconds);
 });
 export const removeRedisLock = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    const redisClient = yield getRedisClient();
-    yield redisClient.del(key);
+    yield removeRedisKey(key);
 });

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

@@ -1,4 +1,10 @@
-import { RedisLockerConfig, RedisLockerConfigParams } from "./types.js";
-export declare const RedisLockerConfigFactory: {
-    mail: (params?: RedisLockerConfigParams) => RedisLockerConfig;
+import { RedisLockerConfig } from "./types.js";
+declare const configs: {
+    readonly mail: {};
 };
+export type RedisLockerType = keyof typeof configs;
+export declare const createRedisLockCheckerConfig: (params: {
+    type?: RedisLockerType;
+    customConfig?: Partial<RedisLockerConfig>;
+}) => RedisLockerConfig;
+export {};

package/dist/middlewares/redis/redisLockerConfigFactory.js

@@ -1,14 +1,13 @@
-import { RedisKeyFactory } from "./redisKeysFactory.js";
-const defaultRedisLockerConfig = {
-    keyPrefix: RedisKeyFactory.prefixes.authLockEmail,
+import { getRedisPrefix } from "./redisKeysFactory.js";
+const defaultConfig = {
+    keyPrefix: getRedisPrefix("authLockEmail"),
     ttlSeconds: 30 * 60,
 };
-const createRedisLockerConfig = (params) => {
-    return Object.assign(Object.assign({}, defaultRedisLockerConfig), params);
+const configs = {
+    mail: {}
 };
-const mail = (params) => {
-    return createRedisLockerConfig(Object.assign({}, (params || {})));
-};
-export const RedisLockerConfigFactory = {
-    mail,
+export const createRedisLockCheckerConfig = (params) => {
+    const { type, customConfig } = params;
+    const typeConfig = type ? configs[type] : undefined;
+    return Object.assign(Object.assign(Object.assign({}, defaultConfig), typeConfig), customConfig);
 };

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

@@ -1,19 +1,11 @@
 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 type RequestParamsFetcher = (req: Request) => string[];
 export interface RedisLockCheckerConfig {
     keyPrefix: string;
-    keySuffixes: (req: Request) => string[];
+    keySuffixes: RequestParamsFetcher;
     message: string;
 }
-export interface RedisLockerConfigParams {
-    keyPrefix?: string;
-    ttlSeconds?: number;
-}
 export interface RedisLockerConfig {
     keyPrefix: string;
     ttlSeconds: number;

package/dist/routing/express.d.ts

@@ -2,9 +2,9 @@ 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 { RateLimitConfigParams } from '../middlewares/rateLimit/types.js';
+import { RateLimitConfig } from '../middlewares/rateLimit/types.js';
 import { RedisConfig } from 'mielk-fn/redis';
 export type DbConfig = PostgreDbConfig | MsSqlDbConfig;
-export declare const createExpressApp: (isProd: boolean, dbConfig: DbConfig, corsConfig: CorsConfig, redisConfig: RedisConfig, rateLimitConfig?: RateLimitConfigParams) => Promise<import("express-serve-static-core").Express>;
+export declare const createExpressApp: (isProd: boolean, dbConfig: DbConfig, corsConfig: CorsConfig, redisConfig: RedisConfig, rateLimitConfig?: Partial<RateLimitConfig>) => Promise<import("express-serve-static-core").Express>;
 export declare const isProd: () => boolean;
 export declare const getDbProvider: () => DbProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-api",
-	"version": "1.5.5",
+	"version": "1.5.7",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Wrapper for API operations",
@@ -89,7 +89,7 @@
 	"dependencies": {
 		"cors": "^2.8.6",
 		"express-rate-limit": "^8.3.1",
-		"mielk-fn": "^1.2.2",
+		"mielk-fn": "^1.2.4",
 		"pg": "^8.20.0",
 		"tunnel-ssh": "^5.2.0"
 	}