mielk-api 1.3.8 → 1.3.10

package/dist/db/mssql/connection/pool.d.ts

@@ -1,5 +1,6 @@
-import { RawData } from 'msnodesqlv8/types';
+import type { RawData, SqlClient, sqlQueryParamType } from 'msnodesqlv8/types';
 import { MsSqlDbConfig } from '../types/DbConfig.js';
+export declare const getMsSql: () => Promise<SqlClient>;
 export declare const initDb: (dbConfig: MsSqlDbConfig) => void;
 export declare const query: (queryText: string) => Promise<any[]>;
-export declare const spExecute: (sqlText: string, params: MsNodeSqlV8.sqlQueryParamType[]) => Promise<RawData | undefined>;
+export declare const spExecute: (sqlText: string, params: sqlQueryParamType[]) => Promise<RawData | undefined>;

package/dist/db/mssql/connection/pool.js

@@ -1,12 +1,32 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import sql from 'msnodesqlv8';
+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());
+    });
+};
+let sql = null;
 let connectionString = '';
+export const getMsSql = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (!sql) {
+        try {
+            sql = yield import('msnodesqlv8');
+        }
+        catch (e) {
+            throw new Error('MSSQL driver not installed');
+        }
+    }
+    return sql;
+});
 export const initDb = (dbConfig) => {
     const { host, database, user, password, driver } = dbConfig;
     connectionString = `Server=${host};Database=${database};UID=${user};PWD=${password};Driver=${driver}`;
     console.log(connectionString);
 };
-export const query = (queryText) => {
+export const query = (queryText) => __awaiter(void 0, void 0, void 0, function* () {
+    const sql = yield getMsSql();
     return new Promise((resolve, reject) => {
         sql.query(connectionString, queryText, (err, rows) => {
             if (err)
@@ -17,8 +37,9 @@ export const query = (queryText) => {
                 resolve(rows);
         });
     });
-};
-export const spExecute = (sqlText, params) => {
+});
+export const spExecute = (sqlText, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const sql = yield getMsSql();
     return new Promise((resolve, reject) => {
         sql.open(connectionString, (err, conn) => {
             if (err)
@@ -31,4 +52,4 @@ export const spExecute = (sqlText, params) => {
             });
         });
     });
-};
+});

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

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

package/dist/http/httpResponseStatus/HttpResponseStatus.js

@@ -6,6 +6,7 @@ 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),
     SERVER_ERROR: createApiStatus(false, 500, msg.serverError),

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

@@ -2,8 +2,9 @@ export declare const Msg: {
     apiStatus: {
         ok: string;
         created: string;
-        unauthorized: string;
         badRequest: string;
+        unauthorized: string;
+        forbidden: string;
         notFound: string;
         conflict: string;
         serverError: string;
@@ -11,6 +12,7 @@ export declare const Msg: {
     connection: {
         corsBlocked: string;
         notInitialized: string;
+        rateLimitExceededMessage: string;
         sshOptionsNotSpecified: string;
         sshTunnelFailed: string;
         postgreConnectionError: string;

package/dist/internal/messaging/messageTags.js

@@ -5,8 +5,9 @@ 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`,
         serverError: `${___HTTP_STATUS___}:serverError`,
@@ -14,6 +15,7 @@ export const Msg = {
     connection: {
         corsBlocked: `${___CONNECTION___}:corsBlocked`,
         notInitialized: `${___CONNECTION___}:notInitialized`,
+        rateLimitExceededMessage: `${___CONNECTION___}:rateLimitExceededMessage`,
         sshOptionsNotSpecified: `${___CONNECTION___}:sshOptionsNotSpecified`,
         sshTunnelFailed: `${___CONNECTION___}:sshTunnelFailed`, // ❌ SSH tunnel failed
         postgreConnectionError: `${___CONNECTION___}:postgreConnectionError`, // Unexpected PostgreSQL error

package/dist/middlewares/index.d.ts

@@ -1,10 +1,10 @@
 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 { RateLimitConfig, setAppRateLimit, getRateLimit } 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 { RateLimitConfig, setAppRateLimit, getRateLimit };
 export { apiKeyAuthorization };
 export { validateQueryParams, validateBodyJson };

package/dist/middlewares/index.js

@@ -1,10 +1,10 @@
 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 { setAppRateLimit, getRateLimit } 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 { setAppRateLimit, getRateLimit };
 export { apiKeyAuthorization };
 export { validateQueryParams, validateBodyJson };

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

@@ -1,6 +1,8 @@
 import { Express } from 'express';
+import { RateLimitRequestHandler } from 'express-rate-limit';
 export interface RateLimitConfig {
     windowsMs?: number;
     max?: number;
 }
-export declare const setRateLimit: (app: Express, customConfig?: RateLimitConfig) => void;
+export declare const setAppRateLimit: (app: Express, customConfig?: RateLimitConfig) => void;
+export declare const getRateLimit: (minutes: number, maxAttempts: number, message?: string) => RateLimitRequestHandler;

package/dist/middlewares/rateLimit/rateLimit.js

@@ -1,10 +1,18 @@
 import rateLimit from 'express-rate-limit';
+import { Msg } from '../../internal/messaging/messageTags.js';
 const rateLimitConfig = {
     windowMs: 60 * 1000,
     max: 100,
 };
-export const setRateLimit = (app, customConfig) => {
+export const setAppRateLimit = (app, customConfig) => {
     const config = Object.assign(Object.assign({}, rateLimitConfig), customConfig);
     const limiter = rateLimit(config);
     app.use(limiter);
 };
+export const getRateLimit = (minutes, maxAttempts, message) => {
+    return rateLimit({
+        windowMs: minutes * 60 * 1000,
+        max: maxAttempts,
+        message: message || Msg.connection.rateLimitExceededMessage
+    });
+};

package/dist/routing/express.js

@@ -1,7 +1,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, setRateLimit } from '../middlewares/index.js';
+import { initCors, setAppRateLimit } from '../middlewares/index.js';
 const env = {
     isProd: true,
     provider: undefined
@@ -19,7 +19,7 @@ export const createExpressApp = (isProd, dbConfig, corsConfig, rateLimitConfig)
             break;
     }
     initCors(corsConfig);
-    setRateLimit(app, rateLimitConfig);
+    setAppRateLimit(app, rateLimitConfig);
     app.use(express.json());
     return app;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-api",
-	"version": "1.3.8",
+	"version": "1.3.10",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Wrapper for API operations",