mielk-api 1.1.0 → 1.2.0

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

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Msg } from '../../../internal/messaging/messageTags.js';
 import { Pool } from 'pg';
 import { openSshTunnel } from './tunnel.js';
+import { isProd } from '../../../express.js';
 let pool = null;
 let config = null;
 export const initDb = (dbConfig) => {
@@ -21,7 +22,7 @@ export function getPool() {
             return pool;
         if (config === null)
             throw new Error(Msg.connection.notInitialized);
-        if (!config.isProd) {
+        if (!isProd) {
             if (!config.ssh)
                 throw new Error(Msg.connection.sshOptionsNotSpecified);
             const port = yield openSshTunnel(config.ssh, config.port);

package/dist/db/pg/index.d.ts

@@ -1,6 +1,6 @@
 import { POSTGRE_ERRORS } from './static/PostgreErrorCodes.js';
 import { initDb, getPool } from './connection/pool.js';
-import type { DbConfig } from './types/DbConfig.js';
+import { DbConfig } from './types/DbConfig.js';
 export { POSTGRE_ERRORS };
 export { initDb, getPool };
-export type { DbConfig };
+export { DbConfig };

package/dist/db/pg/types/DbConfig.d.ts

@@ -1,6 +1,5 @@
 import { SshOptions } from "tunnel-ssh";
 export interface DbConfig {
-    isProd: boolean;
     host: string;
     port: number;
     user: string;

package/dist/express.d.ts

@@ -0,0 +1,4 @@
+import { DbConfig } from './db/pg/index.js';
+import { CorsConfig, RateLimitConfig } from './middlewares/index.js';
+export declare const createExpressApp: (isProd: boolean, dbConfig: DbConfig, corsConfig: CorsConfig, rateLimitConfig?: RateLimitConfig) => import("express-serve-static-core").Express;
+export declare const isProd: boolean;

package/dist/express.js

@@ -0,0 +1,16 @@
+import express from 'express';
+import { initDb } from './db/pg/index.js';
+import { initCors, setRateLimit } from './middlewares/index.js';
+const env = {
+    isProd: true
+};
+export const createExpressApp = (isProd, dbConfig, corsConfig, rateLimitConfig) => {
+    const app = express();
+    env.isProd = isProd;
+    initDb(dbConfig);
+    initCors(corsConfig);
+    setRateLimit(app, rateLimitConfig);
+    app.use(express.json());
+    return app;
+};
+export const isProd = env.isProd;

package/dist/http/apiResponse/apiResponse.d.ts

@@ -0,0 +1,6 @@
+import { Response } from 'express';
+import { HttpStatus } from '../types/HttpStatus.js';
+import { ApiErrorDetails } from '../types/ApiResponse.js';
+export declare function success<T>(res: Response, status: HttpStatus, data: T): void;
+export declare function failure(res: Response, status: HttpStatus, details: string | ApiErrorDetails): void;
+export declare function serverError(res: Response, err: Error): void;

package/dist/http/apiResponse/apiResponse.js

@@ -0,0 +1,28 @@
+import { isObject, isPrimitive } from 'mielk-fn/variables';
+import { HttpResponseStatus } from '../httpResponseStatus/HttpResponseStatus.js';
+import { isProd } from '../../express.js';
+export function success(res, status, data) {
+    const apiResponse = {
+        success: true,
+        data,
+    };
+    res.status(status.code).json(apiResponse);
+}
+export function failure(res, status, details) {
+    const message = isPrimitive(details) ? details : (details === null || details === void 0 ? void 0 : details.message) || status.defaultMessageTag;
+    const apiError = {
+        success: false,
+        message,
+        params: isObject(details) ? details.params : undefined
+    };
+    res.status(status.code).json(apiError);
+}
+export function serverError(res, err) {
+    var _a;
+    const status = HttpResponseStatus.SERVER_ERROR;
+    const apiError = {
+        success: false,
+        message: isProd ? status.defaultMessageTag : `message: ${err.message} | stack: ${(_a = err.stack) === null || _a === void 0 ? void 0 : _a.toString()}`,
+    };
+    res.status(status.code).json(apiError);
+}

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

@@ -0,0 +1,10 @@
+import { HttpStatus } from "../types/HttpStatus.js";
+export declare const HttpResponseStatus: {
+    OK: HttpStatus;
+    CREATED: HttpStatus;
+    BAD_REQUEST: HttpStatus;
+    UNAUTHORIZED: HttpStatus;
+    NOT_FOUND: HttpStatus;
+    CONFLICT: HttpStatus;
+    SERVER_ERROR: HttpStatus;
+};

package/dist/http/{ApiStatus.js → httpResponseStatus/HttpResponseStatus.js}

@@ -1,7 +1,7 @@
-import { Msg } from "../internal/messaging/messageTags.js";
+import { Msg } from "../../internal/messaging/messageTags.js";
 const createApiStatus = (success, code, defaultMessageTag) => ({ success, code, defaultMessageTag });
 const msg = Msg.apiStatus;
-export const API_STATUS = {
+export const HttpResponseStatus = {
     OK: createApiStatus(true, 200, msg.ok),
     CREATED: createApiStatus(true, 201, msg.created),
     BAD_REQUEST: createApiStatus(false, 400, msg.badRequest),

package/dist/http/index.d.ts

@@ -1,7 +1,9 @@
 import { ApiSuccess, ApiError, ApiErrorDetails } from '../http/types/ApiResponse.js';
 import type { ApiResponse } from '../http/types/ApiResponse.js';
-import type { ApiStatus } from './types/ApiStatus.js';
-import { API_STATUS } from './ApiStatus.js';
-export type { ApiStatus, ApiResponse };
-export { ApiError, ApiSuccess, ApiErrorDetails };
-export { API_STATUS };
+import { HttpStatus } from './types/HttpStatus.js';
+import { HttpResponseStatus } from './httpResponseStatus/HttpResponseStatus.js';
+import { success, failure, serverError } from './apiResponse/apiResponse.js';
+export type { ApiResponse };
+export { HttpStatus as ApiStatus, ApiError, ApiSuccess, ApiErrorDetails };
+export { HttpResponseStatus };
+export { success, failure, serverError };

package/dist/http/index.js

@@ -1,2 +1,4 @@
-import { API_STATUS } from './ApiStatus.js';
-export { API_STATUS };
+import { HttpResponseStatus } from './httpResponseStatus/HttpResponseStatus.js';
+import { success, failure, serverError } from './apiResponse/apiResponse.js';
+export { HttpResponseStatus };
+export { success, failure, serverError };

package/dist/http/types/{ApiStatus.d.ts → HttpStatus.d.ts}

@@ -1,5 +1,5 @@
-export type ApiStatus = {
+export interface HttpStatus {
     success: boolean;
     code: number;
     defaultMessageTag: string;
-};
+}

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export * as pg from './db/pg/index.js';
 export * as mssql from './db/mssql/index.js';
 export * as http from './http/index.js';
+export { dbRouter } from './routing/routes/db.route.js';
+export { healthRouter } from './routing/routes/health.route.js';
+export { createExpressApp } from './express.js';

package/dist/index.js

@@ -1,3 +1,6 @@
 export * as pg from './db/pg/index.js';
 export * as mssql from './db/mssql/index.js';
 export * as http from './http/index.js';
+export { dbRouter } from './routing/routes/db.route.js';
+export { healthRouter } from './routing/routes/health.route.js';
+export { createExpressApp } from './express.js';

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

@@ -9,6 +9,7 @@ export declare const Msg: {
         serverError: string;
     };
     connection: {
+        corsBlocked: string;
         notInitialized: string;
         sshOptionsNotSpecified: string;
         sshTunnelFailed: string;

package/dist/internal/messaging/messageTags.js

@@ -12,6 +12,7 @@ export const Msg = {
         serverError: `${___API_STATUS___}:serverError`,
     },
     connection: {
+        corsBlocked: `${___CONNECTION___}:corsBlocked`,
         notInitialized: `${___CONNECTION___}:notInitialized`,
         sshOptionsNotSpecified: `${___CONNECTION___}:sshOptionsNotSpecified`,
         sshTunnelFailed: `${___CONNECTION___}:sshTunnelFailed`, // ❌ SSH tunnel failed

package/dist/middlewares/cors/cors.d.ts

@@ -0,0 +1,7 @@
+export type CorsConfig = {
+    allowedOrigins: string | undefined;
+    apiKey: string | undefined;
+};
+export declare const initCors: (config: CorsConfig) => void;
+export declare function checkCors(origin?: string): boolean;
+export declare const apiKey: () => string | undefined;

package/dist/middlewares/cors/cors.js

@@ -0,0 +1,31 @@
+import { isProd } from "../../express.js";
+const corsConfig = {
+    allowedOrigins: '',
+    apiKey: ''
+};
+export const initCors = (config) => {
+    const { allowedOrigins, apiKey } = config;
+    corsConfig.allowedOrigins = allowedOrigins;
+    corsConfig.apiKey = apiKey;
+};
+function getAllowedOrigins() {
+    const { allowedOrigins } = corsConfig;
+    if (!allowedOrigins)
+        return [];
+    return allowedOrigins
+        .split(',')
+        .map((o) => o.trim())
+        .filter(Boolean);
+}
+export function checkCors(origin) {
+    if (!origin)
+        return false;
+    if (!isProd) {
+        return origin.startsWith('http://localhost');
+    }
+    else {
+        const allowedOrigins = getAllowedOrigins();
+        return allowedOrigins.includes(origin);
+    }
+}
+export const apiKey = () => corsConfig.apiKey;

package/dist/middlewares/cors/privateCors.d.ts

@@ -0,0 +1,6 @@
+import cors from 'cors';
+export declare const privateCors: (req: cors.CorsRequest, res: {
+    statusCode?: number | undefined;
+    setHeader(key: string, value: string): any;
+    end(): any;
+}, next: (err?: any) => any) => void;

package/dist/middlewares/cors/privateCors.js

@@ -0,0 +1,18 @@
+import cors from 'cors';
+import { checkCors } from './cors.js';
+export const privateCors = cors({
+    origin: (origin, callback) => {
+        if (!origin) {
+            // i.e. Postman or curl
+            return callback(null, true);
+        }
+        if (checkCors(origin)) {
+            return callback(null, true);
+        }
+        const message = `CORS blocked: ${origin}`;
+        console.warn(`❌ ${message}`);
+        return callback(new Error(message), false);
+    },
+    methods: ['GET', 'POST', 'PUT', 'DELETE'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+});

package/dist/middlewares/cors/publicCors.d.ts

@@ -0,0 +1,6 @@
+import cors from 'cors';
+export declare const publicCors: (req: cors.CorsRequest, res: {
+    statusCode?: number | undefined;
+    setHeader(key: string, value: string): any;
+    end(): any;
+}, next: (err?: any) => any) => void;

package/dist/middlewares/cors/publicCors.js

@@ -0,0 +1,10 @@
+import cors from 'cors';
+export const publicCors = cors({
+    origin: (origin, callback) => {
+        if (!origin)
+            return callback(null, true);
+        return callback(null, true);
+    },
+    methods: ['GET'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+});

package/dist/middlewares/index.d.ts

@@ -0,0 +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 { 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

@@ -0,0 +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 { 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/middlewares/rateLimit/rateLimit.d.ts

@@ -0,0 +1,6 @@
+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

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

package/dist/middlewares/requestAuth/auth.middleware.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare function apiKeyAuthorization(req: Request, res: Response, next: NextFunction): void;

package/dist/middlewares/requestAuth/auth.middleware.js

@@ -0,0 +1,13 @@
+import { isProd } from '../../express.js';
+import { apiKey } from '../cors/cors.js';
+export function apiKeyAuthorization(req, res, next) {
+    var _a;
+    if (!isProd) {
+        return next();
+    }
+    const key = (_a = req.headers['authorization']) === null || _a === void 0 ? void 0 : _a.split(' ')[1]; // Bearer <key>
+    if (!apiKey && (!key || key !== apiKey)) {
+        // failure(res, API_STATUS.UNAUTHORIZED, { message: Msg.connection.unauthorizedRequest} )
+    }
+    next();
+}

package/dist/middlewares/zod/validate.d.ts

@@ -0,0 +1,4 @@
+import { Request, Response, NextFunction } from 'express';
+import { ZodType } from 'zod';
+export declare const validateQueryParams: (schema: ZodType) => (req: Request, res: Response, next: NextFunction) => void;
+export declare const validateBodyJson: (schema: ZodType) => (req: Request, res: Response, next: NextFunction) => void;

package/dist/middlewares/zod/validate.js

@@ -0,0 +1,34 @@
+import { failure, HttpResponseStatus } from '../../http/index.js';
+export const validateQueryParams = (schema) => (req, res, next) => {
+    const result = schema.safeParse({
+        params: req.params,
+        query: req.query,
+        body: req.body,
+    });
+    if (!result.success) {
+        const issue = result.error.issues[0];
+        const { message } = issue;
+        failure(res, HttpResponseStatus.BAD_REQUEST, { message });
+    }
+    else {
+        const data = result.data;
+        if (data.params)
+            req.params = data.params;
+        if (data.query)
+            req.query = data.query;
+        if (data.body)
+            req.body = data.body;
+    }
+    next();
+};
+export const validateBodyJson = (schema) => (req, res, next) => {
+    const result = schema.safeParse(req.body);
+    if (!result.success) {
+        const message = result.error.issues.map(i => i.message).join('; ');
+        failure(res, HttpResponseStatus.BAD_REQUEST, { message });
+    }
+    else {
+        req.body = result.data;
+    }
+    next();
+};

package/dist/routing/controllers/db.controller.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response } from 'express';
+export declare const getDbTest: (_req: Request, res: Response) => Promise<void>;
+export declare function getDbVersion(_req: Request, res: Response): Promise<void>;

package/dist/routing/controllers/db.controller.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 * as DbService from '../services/db.service.js';
+import { HttpResponseStatus, serverError, success } from '../../http/index.js';
+export const getDbTest = (_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const dbTime = yield DbService.getDatabaseTime();
+        return success(res, HttpResponseStatus.OK, dbTime);
+    }
+    catch (err) {
+        return serverError(res, err);
+    }
+});
+export function getDbVersion(_req, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const version = yield DbService.getDatabaseVersion();
+            return success(res, HttpResponseStatus.OK, version);
+        }
+        catch (err) {
+            return serverError(res, err);
+        }
+    });
+}

package/dist/routing/controllers/health.controller.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response } from 'express';
+export declare const getHealth: (_req: Request, res: Response) => void;
+export declare const getEnv: (_req: Request, res: Response) => void;

package/dist/routing/controllers/health.controller.js

@@ -0,0 +1,11 @@
+import { HttpResponseStatus, success } from '../../http/index.js';
+import { isProd } from '../../express.js';
+export const getHealth = (_req, res) => {
+    return success(res, HttpResponseStatus.OK, new Date().toISOString());
+};
+export const getEnv = (_req, res) => {
+    const data = {
+        isProduction: isProd,
+    };
+    return success(res, HttpResponseStatus.OK, data);
+};

package/dist/routing/repositories/db.repository.d.ts

@@ -0,0 +1,2 @@
+export declare function selectDatabaseTime(): Promise<any>;
+export declare function selectDatabaseVersion(): Promise<any>;

package/dist/routing/repositories/db.repository.js

@@ -0,0 +1,24 @@
+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 { getPool } from '../../db/pg/connection/pool.js';
+export function selectDatabaseTime() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pool = yield getPool();
+        const result = yield pool.query('SELECT NOW()');
+        return result.rows[0].now;
+    });
+}
+export function selectDatabaseVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pool = yield getPool();
+        const result = yield pool.query('SELECT version()');
+        return result.rows[0].version;
+    });
+}

package/dist/routing/routes/db.route.d.ts

@@ -0,0 +1,4 @@
+import { Router } from 'express';
+declare const dbRouter: Router;
+export { dbRouter };
+export default dbRouter;

package/dist/routing/routes/db.route.js

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { getDbTest, getDbVersion } from '../controllers/db.controller.js';
+const dbRouter = Router();
+dbRouter.get('/test/', getDbTest);
+dbRouter.get('/version/', getDbVersion);
+export { dbRouter };
+export default dbRouter;

package/dist/routing/routes/health.route.d.ts

@@ -0,0 +1,4 @@
+import { Router } from 'express';
+declare const healthRouter: Router;
+export { healthRouter };
+export default healthRouter;

package/dist/routing/routes/health.route.js

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { getHealth, getEnv } from '../controllers/health.controller.js';
+const healthRouter = Router();
+healthRouter.get('/', getHealth);
+healthRouter.get('/environment', getEnv);
+export { healthRouter };
+export default healthRouter;

package/dist/routing/services/db.service.d.ts

@@ -0,0 +1,2 @@
+export declare function getDatabaseTime(): Promise<Date>;
+export declare function getDatabaseVersion(): Promise<string>;

package/dist/routing/services/db.service.js

@@ -0,0 +1,20 @@
+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 * as dbRepository from '../repositories/db.repository.js';
+export function getDatabaseTime() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return dbRepository.selectDatabaseTime();
+    });
+}
+export function getDatabaseVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return dbRepository.selectDatabaseVersion();
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mielk-api",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Wrapper for API operations",
@@ -27,10 +27,15 @@
 			"types": "./dist/http/index.d.ts",
 			"import": "./dist/http/index.js",
 			"default": "./dist/http/index.js"
+		},
+		"./middlewares": {
+			"types": "./dist/middlewares/index.d.ts",
+			"import": "./dist/middlewares/index.js",
+			"default": "./dist/middlewares/index.js"
 		}
 	},
 	"scripts": {
-		"test": "jest --detectOpenHandles",
+		"test": "jest --watchAll=false --detectOpenHandles",
 		"build": "tsc",
 		"prepublishOnly": "npm test && npm run build",
 		"dev": "tsc -w",
@@ -47,6 +52,8 @@
 		"@babel/core": "^7.25.8",
 		"@babel/node": "^7.25.7",
 		"@babel/preset-env": "^7.25.8",
+		"@types/cors": "^2.8.19",
+		"@types/express": "^5.0.6",
 		"@types/jest": "^30.0.0",
 		"@types/node": "^22.7.5",
 		"@types/pg": "^8.18.0",
@@ -62,7 +69,13 @@
 	"files": [
 		"dist"
 	],
+	"peerDependencies": {
+		"express": "^5",
+		"express-rate-limit": "^8",
+		"zod": "^4"
+	},
 	"dependencies": {
+		"cors": "^2.8.6",
 		"mielk-fn": "^1.1.1",
 		"pg": "^8.20.0",
 		"tunnel-ssh": "^5.2.0"

package/dist/back/index.js

@@ -1,7 +0,0 @@
-// import type { ApiStatus } from '../http/types/ApiStatus.js';
-// import { PG_ERRORS } from '../db/PostgreErrorCodes.js';
-// import { API_STATUS } from '../http/ApiStatus.js';
-export {};
-// export type { ApiStatus }
-// export { PG_ERRORS }
-// export { API_STATUS }

package/dist/http/ApiStatus.d.ts

@@ -1,10 +0,0 @@
-import { ApiStatus } from "./types/ApiStatus.js";
-export declare const API_STATUS: {
-    OK: ApiStatus;
-    CREATED: ApiStatus;
-    BAD_REQUEST: ApiStatus;
-    UNAUTHORIZED: ApiStatus;
-    NOT_FOUND: ApiStatus;
-    CONFLICT: ApiStatus;
-    SERVER_ERROR: ApiStatus;
-};

package/dist/http/types/ApiStatus.js

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