mielk-api 1.0.9 → 1.2.0

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

@@ -0,0 +1,4 @@
+import { Pool } from 'pg';
+import { DbConfig } from '../types/DbConfig.js';
+export declare const initDb: (dbConfig: DbConfig) => void;
+export declare function getPool(): Promise<Pool>;

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

@@ -0,0 +1,37 @@
+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 { 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) => {
+    config = Object.assign({ max: 10, min: 0, idleTimeoutMillis: 30000, connectionTimeoutMillis: 10000 }, dbConfig);
+};
+export function getPool() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (pool)
+            return pool;
+        if (config === null)
+            throw new Error(Msg.connection.notInitialized);
+        if (!isProd) {
+            if (!config.ssh)
+                throw new Error(Msg.connection.sshOptionsNotSpecified);
+            const port = yield openSshTunnel(config.ssh, config.port);
+            config.port = port;
+        }
+        pool = new Pool(config);
+        pool.on('error', (err) => {
+            console.error(Msg.connection.postgreConnectionError, err);
+        });
+        return pool;
+    });
+}

package/dist/db/pg/connection/tunnel.d.ts

@@ -0,0 +1,2 @@
+import { SshOptions } from 'tunnel-ssh';
+export declare function openSshTunnel(sshOptions: SshOptions, dstPort: number): Promise<number>;

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

@@ -0,0 +1,30 @@
+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 { createTunnel } from 'tunnel-ssh';
+import { Msg } from '../../../internal/messaging/messageTags.js';
+const tunnelOptions = {
+    autoClose: true,
+    reconnectOnError: true,
+};
+const serverOptions = {};
+export function openSshTunnel(sshOptions, dstPort) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const forwardOptions = { dstPort };
+            const [server] = yield createTunnel(tunnelOptions, serverOptions, sshOptions, forwardOptions);
+            const port = server.address().port;
+            return port;
+        }
+        catch (err) {
+            console.error(Msg.connection.sshTunnelFailed, err);
+            throw err;
+        }
+    });
+}

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

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

package/dist/db/pg/index.js

@@ -0,0 +1,4 @@
+import { POSTGRE_ERRORS } from './static/PostgreErrorCodes.js';
+import { initDb, getPool } from './connection/pool.js';
+export { POSTGRE_ERRORS };
+export { initDb, getPool };

package/dist/{back/enums → db/pg/static}/PostgreErrorCodes.d.ts

@@ -1,4 +1,4 @@
-export declare const PG_ERRORS: {
+export declare const POSTGRE_ERRORS: {
     UNIQUE_VIOLATION: string;
     FOREIGN_KEY_VIOLATION: string;
 };

package/dist/{back/enums → db/pg/static}/PostgreErrorCodes.js

@@ -1,4 +1,4 @@
-export const PG_ERRORS = {
+export const POSTGRE_ERRORS = {
     UNIQUE_VIOLATION: '23505',
     FOREIGN_KEY_VIOLATION: '23503',
 };

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

@@ -0,0 +1,13 @@
+import { SshOptions } from "tunnel-ssh";
+export interface DbConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    ssh?: SshOptions;
+    max?: number;
+    min?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+}

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/{back/enums/ApiStatus.js → http/httpResponseStatus/HttpResponseStatus.js}

@@ -1,7 +1,7 @@
 import { Msg } from "../../internal/messaging/messageTags.js";
 const createApiStatus = (success, code, defaultMessageTag) => ({ success, code, defaultMessageTag });
-const msg = Msg.ApiStatus;
-export const API_STATUS = {
+const msg = Msg.apiStatus;
+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

@@ -0,0 +1,9 @@
+import { ApiSuccess, ApiError, ApiErrorDetails } from '../http/types/ApiResponse.js';
+import type { ApiResponse } from '../http/types/ApiResponse.js';
+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

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

package/dist/{front/types.d.ts → http/types/ApiResponse.d.ts}

@@ -7,8 +7,8 @@ export interface ApiError {
     message: string;
     params?: Record<string, string | number | Date | unknown | boolean>;
 }
-export type ApiResponse<T> = ApiSuccess<T> | ApiError;
-export type ApiErrorDetails = {
+export interface ApiErrorDetails {
     message: string;
     params?: Record<string, string | number | Date | unknown | boolean>;
-};
+}
+export type ApiResponse<T> = ApiSuccess<T> | ApiError;

package/dist/http/types/ApiResponse.js

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

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

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

package/dist/http/types/HttpStatus.js

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

package/dist/index.d.ts

@@ -1,2 +1,6 @@
-export * as back from './back/index.js';
-export * as front from './front/index.js';
+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,2 +1,6 @@
-export * as back from './back/index.js';
-export * as front from './front/index.js';
+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

@@ -1,5 +1,5 @@
 export declare const Msg: {
-    ApiStatus: {
+    apiStatus: {
         ok: string;
         created: string;
         unauthorized: string;
@@ -8,4 +8,12 @@ export declare const Msg: {
         conflict: string;
         serverError: string;
     };
+    connection: {
+        corsBlocked: string;
+        notInitialized: string;
+        sshOptionsNotSpecified: string;
+        sshTunnelFailed: string;
+        postgreConnectionError: string;
+        unauthorizedRequest: string;
+    };
 };

package/dist/internal/messaging/messageTags.js

@@ -1,13 +1,22 @@
 const PARENT_FOLDER = 'api/';
-const API_STATUS_FOLDER = `${PARENT_FOLDER}/ApiStatus`;
+const ___API_STATUS___ = `${PARENT_FOLDER}/ApiStatus`;
+const ___CONNECTION___ = `${PARENT_FOLDER}/Connection`;
 export const Msg = {
-    ApiStatus: {
-        ok: `${API_STATUS_FOLDER}:ok`,
-        created: `${API_STATUS_FOLDER}:created`,
-        unauthorized: `${API_STATUS_FOLDER}:unauthorized`,
-        badRequest: `${API_STATUS_FOLDER}:badRequest`,
-        notFound: `${API_STATUS_FOLDER}:notFound`,
-        conflict: `${API_STATUS_FOLDER}:conflict`,
-        serverError: `${API_STATUS_FOLDER}:serverError`,
+    apiStatus: {
+        ok: `${___API_STATUS___}:ok`,
+        created: `${___API_STATUS___}:created`,
+        unauthorized: `${___API_STATUS___}:unauthorized`,
+        badRequest: `${___API_STATUS___}:badRequest`,
+        notFound: `${___API_STATUS___}:notFound`,
+        conflict: `${___API_STATUS___}:conflict`,
+        serverError: `${___API_STATUS___}:serverError`,
+    },
+    connection: {
+        corsBlocked: `${___CONNECTION___}:corsBlocked`,
+        notInitialized: `${___CONNECTION___}:notInitialized`,
+        sshOptionsNotSpecified: `${___CONNECTION___}:sshOptionsNotSpecified`,
+        sshTunnelFailed: `${___CONNECTION___}:sshTunnelFailed`, // ❌ SSH tunnel failed
+        postgreConnectionError: `${___CONNECTION___}:postgreConnectionError`, // Unexpected PostgreSQL error
+        unauthorizedRequest: `${___CONNECTION___}:unauthorizedRequest`
     }
 };

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.0.9",
+	"version": "1.2.0",
 	"keywords": [],
 	"author": "mielk",
 	"description": "Wrapper for API operations",
@@ -13,19 +13,29 @@
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
-		"./back": {
-			"types": "./dist/back/index.d.ts",
-			"import": "./dist/back/index.js",
-			"default": "./dist/back/index.js"
+		"./db-mssql": {
+			"types": "./dist/db/mssql/index.d.ts",
+			"import": "./dist/db/mssql/index.js",
+			"default": "./dist/db/mssql/index.js"
 		},
-		"./front": {
-			"types": "./dist/front/index.d.ts",
-			"import": "./dist/front/index.js",
-			"default": "./dist/front/index.js"
+		"./db-pg": {
+			"types": "./dist/db/pg/index.d.ts",
+			"import": "./dist/db/pg/index.js",
+			"default": "./dist/db/pg/index.js"
+		},
+		"./http": {
+			"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",
@@ -42,8 +52,12 @@
 		"@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",
+		"@types/tunnel-ssh": "^5.0.4",
 		"babel-jest": "^29.7.0",
 		"jest": "^30.3.0",
 		"jest-html-reporters": "^3.1.7",
@@ -55,7 +69,15 @@
 	"files": [
 		"dist"
 	],
+	"peerDependencies": {
+		"express": "^5",
+		"express-rate-limit": "^8",
+		"zod": "^4"
+	},
 	"dependencies": {
-		"mielk-fn": "^1.1.1"
+		"cors": "^2.8.6",
+		"mielk-fn": "^1.1.1",
+		"pg": "^8.20.0",
+		"tunnel-ssh": "^5.2.0"
 	}
 }

package/dist/back/enums/ApiStatus.d.ts

@@ -1,10 +0,0 @@
-import { ApiStatus } from "../types/types.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/back/index.d.ts

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

package/dist/back/index.js

@@ -1,4 +0,0 @@
-import { PG_ERRORS } from './enums/PostgreErrorCodes.js';
-import { API_STATUS } from './enums/ApiStatus.js';
-export { PG_ERRORS };
-export { API_STATUS };

package/dist/front/index.d.ts

@@ -1,4 +0,0 @@
-import { ApiSuccess, ApiError } from './types.js';
-import type { ApiResponse, ApiErrorDetails } from './types.js';
-export { ApiError, ApiSuccess };
-export type { ApiResponse, ApiErrorDetails };