mielk-api 1.5.0 → 1.5.1

package/dist/middlewares/index.d.ts

@@ -3,12 +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 { createRedisLocker, setRedisLock, removeRedisLock, checkIfLockedInRedis } from './redisLocks/redisLocker.js';
-import { RedisLockerConfigFactory } from './redisLocks/redisLockerConfigFactory.js';
-import { RedisLocker, RedisLockerConfig, RedisLockerConfigParams } from './redisLocks/types.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 { createRedisLocker, setRedisLock, removeRedisLock as removeLock, checkIfLockedInRedis as isLocked };
 export { RedisLockerConfigFactory };
-export { RedisLocker, RedisLockerConfig, RedisLockerConfigParams };
+export { RedisLockerConfig, RedisLockerConfigParams };
+export { setRedisLock, removeRedisLock };
+export { createRedisLockChecker, checkIfLockedInRedis };
+export { RedisLockCheckerConfigFactory };
+export { RedisLockChecker, RedisLockCheckerConfig, RedisLockCheckerConfigParams };

package/dist/middlewares/index.js

@@ -3,10 +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 { createRedisLocker, setRedisLock, removeRedisLock, checkIfLockedInRedis } from './redisLocks/redisLocker.js';
-import { RedisLockerConfigFactory } from './redisLocks/redisLockerConfigFactory.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 };
-export { createRedisLocker, setRedisLock, removeRedisLock as removeLock, checkIfLockedInRedis as isLocked };
+// Redis locker
 export { RedisLockerConfigFactory };
+export { setRedisLock, removeRedisLock };
+// Redis lock checker
+export { createRedisLockChecker, checkIfLockedInRedis };
+export { RedisLockCheckerConfigFactory };

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

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { getRedisClient } from 'mielk-fn/redis';
-import { setRedisLock } from '../middlewares/redisLocks/redisLocker.js';
+import { setRedisLock } from '../redis/redisLocker.js';
 export const checkRateLimit = (rateLimit) => __awaiter(void 0, void 0, void 0, function* () {
     const { key, limit, windowSec, redisLock } = rateLimit;
     const client = yield getRedisClient();
@@ -20,10 +20,8 @@ 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/{rateLimit → middlewares/rateLimit}/createRateLimiter.js

@@ -8,10 +8,10 @@ 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 '../middlewares/redisLocks/redisLocker.js';
+import { generateRedisLockKey } from '../redis/redisLockChecker.js';
+import { Msg } from '../../internal/messaging/messageTags.js';
 export const createGlobalRateLimiter = (config) => {
     return createRateLimiter(RateLimitConfigFactory.globalIp(config));
 };
@@ -36,8 +36,9 @@ const createRateLimitFromConfig = (config, req) => {
     const key = generateKeyFromConfig(config, req);
     const rateLimit = { key, limit, windowSec, message };
     if (redisLockerConfig) {
-        const { ttlSeconds } = redisLockerConfig;
-        const key = generateRedisLockKey(redisLockerConfig, req);
+        const { keyPrefix, ttlSeconds } = redisLockerConfig;
+        const { keySuffixes } = config;
+        const key = generateRedisLockKey(keyPrefix, keySuffixes, req);
         const redisLock = { key, ttlSeconds };
         rateLimit.redisLock = redisLock;
     }

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

@@ -1,7 +1,7 @@
 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';
 import { type RateLimiter, RateLimitConfig, RateLimit, RateLimitCheck } from './types.js';
 export { checkRateLimit, createRateLimiter, RateLimitConfigFactory, RedisKeyFactory };
 export { RateLimitConfig, RateLimit, RateLimitCheck };

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/{rateLimit → middlewares/rateLimit}/rateLimitConfigFactory.js

@@ -1,6 +1,5 @@
-import { RedisKeyFactory } from "./redisKeysFactory.js";
-import { Msg } from "../internal/messaging/messageTags.js";
-import { RedisLockerConfigFactory } from "../middlewares/index.js";
+import { RedisKeyFactory } from "../redis/redisKeysFactory.js";
+import { Msg } from "../../internal/messaging/messageTags.js";
 const defaultRateLimitConfig = {
     keyPrefix: RedisKeyFactory.prefixes.login,
     keySuffixes: RedisKeyFactory.suffixes.ip,
@@ -21,7 +20,7 @@ const loginIpMail = (params) => {
     return createRateLimitConfig(Object.assign({ keySuffixes: RedisKeyFactory.suffixes.ipMail }, (params || {})));
 };
 const loginMail = (params) => {
-    return createRateLimitConfig(Object.assign({ keySuffixes: RedisKeyFactory.suffixes.mail, redisLockerConfig: RedisLockerConfigFactory.mail() }, (params || {})));
+    return createRateLimitConfig(Object.assign({ keySuffixes: RedisKeyFactory.suffixes.mail, redisLockerConfig: { keyPrefix: RedisKeyFactory.prefixes.lockEmail, ttlSeconds: 15 * 60 } }, (params || {})));
 };
 export const RateLimitConfigFactory = {
     globalIp,

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

@@ -1,5 +1,5 @@
-import { NextFunction, Request, Response } from "express";
-import { RedisLockerConfig } from "../middlewares/index.js";
+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;

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/{redisLocks/redisLocker.js → redis/redisLockChecker.js}

@@ -10,10 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { getRedisClient } from "mielk-fn/redis";
 import { failure, HttpResponseStatus } from "../../http/index.js";
 import { Msg } from "../../internal/messaging/messageTags.js";
-export const createRedisLocker = (config) => {
+export const createRedisLockChecker = (config) => {
     return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-        const { message } = config;
-        const key = generateRedisLockKey(config, req);
+        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);
@@ -21,24 +21,9 @@ export const createRedisLocker = (config) => {
         return next();
     });
 };
-export const generateRedisLockKey = (config, req) => {
-    const { keyPrefix, keySuffixes } = config;
+export const generateRedisLockKey = (keyPrefix, keySuffixes, req) => {
     return `${keyPrefix}:${keySuffixes(req).join(':')}`;
 };
-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
-        }
-    });
-    console.log('RL key:', key, ttlSeconds);
-});
-export const removeRedisLock = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    const redisClient = yield getRedisClient();
-    yield redisClient.del(key);
-});
 export const checkIfLockedInRedis = (key) => __awaiter(void 0, void 0, void 0, function* () {
     const redisClient = yield getRedisClient();
     const value = yield redisClient.get(key);

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/{redisLocks → redis}/redisLockerConfigFactory.js

@@ -1,10 +1,7 @@
-import { RedisKeyFactory } from "../../rateLimit/redisKeysFactory.js";
-import { Msg } from "../../internal/messaging/messageTags.js";
+import { RedisKeyFactory } from "./redisKeysFactory.js";
 const defaultRedisLockerConfig = {
     keyPrefix: RedisKeyFactory.prefixes.lockEmail,
-    keySuffixes: RedisKeyFactory.suffixes.mail,
-    ttlSeconds: 3 * 60,
-    message: Msg.apiStatus.locked,
+    ttlSeconds: 30 * 60,
 };
 const createRedisLockerConfig = (params) => {
     return Object.assign(Object.assign({}, defaultRedisLockerConfig), params);

package/dist/middlewares/{redisLocks → redis}/types.d.ts

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

package/dist/routing/express.d.ts

@@ -2,7 +2,7 @@ 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 '../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?: RateLimitConfigParams) => Promise<import("express-serve-static-core").Express>;
 export declare const isProd: () => boolean;

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-api",
-	"version": "1.5.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/middlewares/redisLocks/redisLocker.d.ts

@@ -1,7 +0,0 @@
-import { RedisLocker, RedisLockerConfig } from "./types.js";
-import { Request } from "express";
-export declare const createRedisLocker: (config: RedisLockerConfig) => RedisLocker;
-export declare const generateRedisLockKey: (config: RedisLockerConfig, req: Request) => string;
-export declare const setRedisLock: (key: string, ttlSeconds: number) => Promise<void>;
-export declare const removeRedisLock: (key: string) => Promise<void>;
-export declare const checkIfLockedInRedis: (key: string) => Promise<boolean>;