xpref 1.0.0

package/idempotency/storage.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteItem = exports.store = exports.getItem = exports.create = exports.exists = exports.getAll = exports.status = void 0;
+const storage = {};
+exports.status = {
+    IN_PROGERSS: 'in-progress',
+    DONE: 'done',
+};
+const getAll = () => storage;
+exports.getAll = getAll;
+const exists = (key) => !!(storage[key] || false);
+exports.exists = exists;
+/**
+ * Creates the storage with minimal information (the predetermined default value)
+ * @param {string} key - The key to be added into storage.
+ */
+const create = (key) => {
+    if ((0, exports.exists)(key))
+        throw new Error('Idempotency key exists.');
+    storage[key] = {
+        createdAt: new Date(),
+        status: exports.status.IN_PROGERSS,
+    };
+};
+exports.create = create;
+/**
+ * Gets the stored item by key
+ * @param {string} key - Storage key
+ * @return object;
+ */
+const getItem = (key) => storage[key] || {};
+exports.getItem = getItem;
+/**
+ * Stores the response object to be used when passing the stored
+ * result back to the client. This make sure the previouse response
+ * (stored response) is sent back.
+ * @param {string} key - The key of the storage
+ * @param {Response} response - The response information
+ */
+const store = (key, response) => {
+    const item = (0, exports.getItem)(key);
+    storage[key] = {
+        ...item,
+        response,
+        status: exports.status.DONE,
+    };
+};
+exports.store = store;
+const deleteItem = (key) => {
+    if ((0, exports.exists)(key)) {
+        delete storage[key];
+    }
+};
+exports.deleteItem = deleteItem;

package/index.d.ts

@@ -0,0 +1,7 @@
+import type { API } from './types';
+import { getReqId } from './request-log';
+export default function api(pProps: API, tried?: number): any;
+export { urlencoded, type Request, type Response, type NextFunction, type Application, } from 'express';
+export declare const getRequestId: typeof getReqId;
+export * from './types';
+export { default as i18n } from './i18n';

package/index.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18n = exports.getRequestId = exports.urlencoded = void 0;
+exports.default = api;
+/* eslint-disable no-console */
+const express_1 = __importStar(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const helmet_1 = __importDefault(require("helmet"));
+const router_1 = __importDefault(require("./router"));
+const static_1 = __importDefault(require("./static"));
+const request_log_1 = __importStar(require("./request-log"));
+const request_id_1 = __importDefault(require("./request-id"));
+const method_validator_1 = __importDefault(require("./validator/method-validator"));
+const getProps = (pProps) => ({
+    port: 3000,
+    ...pProps,
+});
+const showAppInfo = (props) => {
+    const { name, env, port } = props;
+    const msg = [
+        '------------ API Started ----------',
+        ` Name: ${name}`,
+        ` Env: ${env}`,
+        ` Port: ${port}`,
+        '------------------------------------',
+    ].join('\n');
+    console.log(msg);
+};
+/*
+const startApp = (
+  app: Application,
+  port: any,
+  routes: any,
+): Promise<any> => new Promise((resolve) => {
+
+  app.listen(port, () => {
+    resolve({ port });
+  }).on('error', (error: any) => {
+    const { code } = error;
+    if (code === 'EADDRINUSE') startApp(app, parseInt(port, 10) + 1, routes);
+  });
+});
+*/
+function api(pProps, tried = 0) {
+    const { appName, appEnv, routes, port, manuallyStart, schemas = {}, staticRoutes = {}, onInit = false, interceptor = false, logger = false, } = getProps(pProps);
+    const app = (0, express_1.default)();
+    if (onInit)
+        onInit(app);
+    app.use((0, cors_1.default)());
+    app.use((0, helmet_1.default)());
+    app.use((0, express_1.json)({ limit: '8mb' }));
+    app.use((0, express_1.urlencoded)({ extended: true }));
+    app.set('trust proxy', true);
+    if (interceptor)
+        interceptor(app);
+    app.use((0, request_id_1.default)());
+    app.use((0, request_log_1.default)(logger, { appName, appEnv }));
+    (0, static_1.default)(app, staticRoutes);
+    const validator = (0, method_validator_1.default)(schemas);
+    (0, router_1.default)(app, routes, { validator });
+    const startManually = manuallyStart || false;
+    if (startManually) {
+        return Promise.resolve(startManually({
+            app,
+            port,
+        }));
+    }
+    const thePort = Number(port) + tried;
+    return new Promise((resolve) => {
+        console.log(`[INFO] Starting application on port ${thePort}`);
+        app.listen(thePort, () => {
+            showAppInfo({ name: appName, env: appEnv, port });
+            resolve({ port: thePort, app });
+        }).on('error', (error) => {
+            const { code } = error;
+            console.log(`[Info] Port ${thePort} already in used...`);
+            if (code === 'EADDRINUSE')
+                resolve(api(pProps, tried + 1));
+        });
+    });
+}
+var express_2 = require("express");
+Object.defineProperty(exports, "urlencoded", { enumerable: true, get: function () { return express_2.urlencoded; } });
+exports.getRequestId = request_log_1.getReqId;
+__exportStar(require("./types"), exports);
+var i18n_1 = require("./i18n");
+Object.defineProperty(exports, "i18n", { enumerable: true, get: function () { return __importDefault(i18n_1).default; } });

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xpref",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc --build -f ./tsconfig.json",
+    "start:dev": "tsc --build -f ./tsconfig.json -w",
+    "test": "jest --detectOpenHandles --forceExit",
+    "test:dev": "npm run test -- --watchAll",
+    "jsdoc": "tsc && jsdoc build/**/* -d jsdoc",
+    "eslint": "eslint src --ext .ts"
+  },
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-errors": "^3.0.0",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "helmet": "^8.1.0",
+    "morgan": "^1.10.0",
+    "swagger-ui-express": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/ajv": "^0.0.5",
+    "@types/cors": "^2.8.12",
+    "@types/express": "^5.0.1",
+    "@types/morgan": "^1.9.3",
+    "@types/swagger-ui-express": "^4.1.3"
+  }
+}

package/request-forwarder/common.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Request forwarder is to forwards the traffic to any defined
+ * host/server. As the request is forwarded to specific host
+ * server, so noly hostname or server ip address is defined
+ * with it's prototol (http or https).
+ */
+import http from 'http';
+import https from 'https';
+export declare const getRequestHandler: (host: string) => typeof http | typeof https;
+export declare const onError: (error: any) => void;
+export declare const getUrl: (req: any, props: any) => any;

package/request-forwarder/common.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Request forwarder is to forwards the traffic to any defined
+ * host/server. As the request is forwarded to specific host
+ * server, so noly hostname or server ip address is defined
+ * with it's prototol (http or https).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrl = exports.onError = exports.getRequestHandler = void 0;
+/* eslint-disable no-console */
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const getRequestHandler = (host) => {
+    const protocol = new URL(host).protocol;
+    return protocol === 'https:' ? https_1.default : http_1.default;
+};
+exports.getRequestHandler = getRequestHandler;
+const onError = (error) => {
+    const { message = 'Unknown error' } = error;
+    console.error(`[ERROR] Request Forwarder - ${message}`);
+};
+exports.onError = onError;
+const getUrl = (req, props) => {
+    const { baseUrl, url } = req;
+    const cleanUrl = url === '/' ? '' : url;
+    const { proxyPrefix = '', withPrefix = false, host, onUrlConstructed, } = props;
+    const prefix = withPrefix ? baseUrl : '';
+    const proxyUrl = `${host}${proxyPrefix}${prefix}${cleanUrl}`;
+    return onUrlConstructed
+        ? onUrlConstructed(proxyUrl)
+        : proxyUrl;
+};
+exports.getUrl = getUrl;

package/request-forwarder/forwarder.d.ts

@@ -0,0 +1,2 @@
+import type { RequestForwarder, Response, Request, NextFunction } from '../types';
+export default function requestFowarder(props: RequestForwarder): (req: Request, res: Response, next: NextFunction) => import("node:http").ClientRequest;

package/request-forwarder/forwarder.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requestFowarder;
+const node_querystring_1 = __importDefault(require("node:querystring"));
+const common_1 = require("./common");
+const pass_to_next_1 = require("./pass-to-next");
+const getBodyData = (req) => {
+    const { method, body = {} } = req;
+    if (method.toUpperCase() === 'GET')
+        return JSON.stringify(body);
+    const reqBody = req.is('json')
+        ? JSON.stringify(body)
+        : node_querystring_1.default.stringify(body);
+    return reqBody;
+};
+const writeRequest = (client, req, bodyData) => {
+    const { method } = req;
+    if (method.toUpperCase() === 'GET')
+        return false;
+    client.write(bodyData);
+    return true;
+};
+const getHeaders = (req, props) => {
+    const { headers: propHeaders } = props;
+    const { headers = {} } = req;
+    const { 'content-length': _cl, ...cleanedHeaders } = headers;
+    const nextHeaders = {
+        'forwarded-from': req.headers['host'],
+        'forwarded-fequest-id': req.headers['Request-Id'] || req.headers['request-id'] || '',
+        ...cleanedHeaders,
+        ...propHeaders,
+    };
+    return nextHeaders;
+};
+const getRequestOptions = (req, props, bodyData) => {
+    const headers = getHeaders(req, props);
+    const { method } = req;
+    const touchedHeaders = method.toUpperCase() === 'GET'
+        ? headers
+        : { ...headers, 'Content-Length': Buffer.byteLength(bodyData) };
+    return {
+        method: req.method,
+        headers: touchedHeaders,
+    };
+};
+function requestFowarder(props) {
+    const { passToNext = false } = props;
+    return function (req, res, next) {
+        const url = (0, common_1.getUrl)(req, props);
+        const handler = (0, common_1.getRequestHandler)(url);
+        const bodyData = getBodyData(req);
+        const requestOptions = getRequestOptions(req, props, bodyData);
+        const proxy = handler.request(url, requestOptions, (proxyResponse) => {
+            if (passToNext) {
+                return (0, pass_to_next_1.collectProxyResult)(proxyResponse)
+                    .then((result) => {
+                    (0, pass_to_next_1.applyProxyResultToRequest)(req, res, result);
+                    next();
+                })
+                    .catch((error) => next(error));
+            }
+            res.writeHead(proxyResponse.statusCode, {
+                ...proxyResponse.headers,
+                'is-proxy': true,
+            });
+            return proxyResponse.pipe(res);
+        });
+        proxy.on('error', (error) => {
+            if (passToNext) {
+                next(error);
+                return;
+            }
+            (0, common_1.onError)(error);
+        });
+        writeRequest(proxy, req, bodyData);
+        return req.pipe(proxy);
+    };
+}

package/request-forwarder/index.d.ts

@@ -0,0 +1,2 @@
+export { default as forwarder } from './forwarder';
+export { default as proxy } from './proxy';

package/request-forwarder/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxy = exports.forwarder = void 0;
+var forwarder_1 = require("./forwarder");
+Object.defineProperty(exports, "forwarder", { enumerable: true, get: function () { return __importDefault(forwarder_1).default; } });
+var proxy_1 = require("./proxy");
+Object.defineProperty(exports, "proxy", { enumerable: true, get: function () { return __importDefault(proxy_1).default; } });

package/request-forwarder/pass-to-next.d.ts

@@ -0,0 +1,4 @@
+import type { ProxyResult, Request, Response } from '../types';
+import type { IncomingMessage } from 'http';
+export declare const applyProxyResultToRequest: (req: Request, res: Response, result: ProxyResult) => void;
+export declare const collectProxyResult: (proxyResponse: IncomingMessage) => Promise<ProxyResult>;

package/request-forwarder/pass-to-next.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectProxyResult = exports.applyProxyResultToRequest = void 0;
+const normalizeProxyHeaders = (headers) => (Object.entries(headers).reduce((acc, [key, value]) => {
+    if (value === undefined)
+        return acc;
+    const headerKey = key.toLowerCase();
+    const nextValue = Array.isArray(value)
+        ? value.map((item) => String(item))
+        : String(value);
+    return { ...acc, [headerKey]: nextValue };
+}, {}));
+const parseProxyBody = (body, headers) => {
+    const contentType = String(headers['content-type'] || '');
+    const isJson = contentType.includes('application/json');
+    if (!isJson)
+        return body;
+    try {
+        return JSON.parse(body.toString('utf8'));
+    }
+    catch {
+        return body.toString('utf8');
+    }
+};
+const applyProxyResultToRequest = (req, res, result) => {
+    const upstreamHeaders = normalizeProxyHeaders(result.headers);
+    req.body = parseProxyBody(result.body, result.headers);
+    req.headers = { ...req.headers, ...upstreamHeaders };
+    res.statusCode = result.statusCode;
+    Object.entries(upstreamHeaders).forEach(([key, value]) => {
+        res.setHeader(key, value);
+    });
+};
+exports.applyProxyResultToRequest = applyProxyResultToRequest;
+const collectProxyResult = (proxyResponse) => {
+    const chunks = [];
+    proxyResponse.on('data', (chunk) => chunks.push(chunk));
+    return new Promise((resolve, reject) => {
+        proxyResponse.on('error', (error) => reject(error));
+        proxyResponse.on('aborted', () => reject(new Error('Upstream response aborted.')));
+        proxyResponse.on('end', () => resolve({
+            statusCode: proxyResponse.statusCode || 500,
+            headers: proxyResponse.headers,
+            body: Buffer.concat(chunks),
+        }));
+    });
+};
+exports.collectProxyResult = collectProxyResult;

package/request-forwarder/proxy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Request forwarder is to forwards the traffic to any defined
+ * host/server. As the request is forwarded to specific host
+ * server, so noly hostname or server ip address is defined
+ * with it's prototol (http or https).
+ */
+import type { Request, Response, RequestForwarder } from '../types';
+export default function requestFowarder(props: RequestForwarder): (req: Request, res: Response) => import("node:http").ClientRequest;

package/request-forwarder/proxy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requestFowarder;
+const common_1 = require("./common");
+const getHeaders = (req, headers = {}) => {
+    const nextHeaders = {
+        'forwarded-from': req.headers['host'],
+        'forwarded-fequest-id': req.headers['Request-Id'] || req.headers['request-id'] || '',
+        ...headers,
+    };
+    return nextHeaders;
+};
+const getRequestOptions = (req, extraHeaders) => {
+    const headers = { ...extraHeaders, ...req.headers };
+    return { method: req.method, headers };
+};
+function requestFowarder(props) {
+    const { headers = {} } = props;
+    return function (req, res) {
+        const url = (0, common_1.getUrl)(req, props);
+        const extraHeaders = getHeaders(req, headers);
+        const handler = (0, common_1.getRequestHandler)(url);
+        const requestOptions = getRequestOptions(req, extraHeaders);
+        const proxy = handler.request(url, requestOptions, (proxyResponse) => {
+            res.writeHead(proxyResponse.statusCode, {
+                ...proxyResponse.headers,
+                'is-proxy': true,
+            });
+            proxyResponse.pipe(res);
+        });
+        proxy.on('error', common_1.onError);
+        return req.pipe(proxy);
+    };
+}

package/request-id.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The middleware is to inject the Request Id (UUID format)
+ * to identify the each request based on that ID.
+ * The process is to inject the ``Request-Id`` into the headers
+ * Request object, and Response object.
+ */
+export default function requestIdMiddleware(): (req: any, res: any, next: any) => void;

package/request-id.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * The middleware is to inject the Request Id (UUID format)
+ * to identify the each request based on that ID.
+ * The process is to inject the ``Request-Id`` into the headers
+ * Request object, and Response object.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = requestIdMiddleware;
+const crypto_1 = require("crypto");
+function requestIdMiddleware() {
+    return (req, res, next) => {
+        const uuid = (0, crypto_1.randomUUID)();
+        const { headers } = req;
+        req.headers = { ...headers, 'Request-Id': uuid };
+        res.setHeader('request-id', uuid);
+        next();
+    };
+}

package/request-log.d.ts

@@ -0,0 +1,3 @@
+import { type Request } from './index';
+export declare const getReqId: (req: Request) => string | string[];
+export default function loggerMiddleware(logger: any, props: any): (req: any, res: any, callback: (err?: Error) => void) => void;

package/request-log.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReqId = void 0;
+exports.default = loggerMiddleware;
+const morgan_1 = __importDefault(require("morgan"));
+const debug_1 = __importDefault(require("./debug"));
+const getReqId = (req) => {
+    const { headers } = req;
+    return headers['Request-Id'] || headers['request-id'] || 'N/A';
+};
+exports.getReqId = getReqId;
+const getLanguage = (req) => {
+    const { headers } = req;
+    const language = headers['language'] || req.acceptsLanguages();
+    if (Array.isArray(language)) {
+        const [userLang] = language;
+        return userLang;
+    }
+    try {
+        const langData = JSON.parse(language);
+        const { language: lang } = langData;
+        return lang;
+    }
+    catch {
+        return language;
+    }
+};
+const getLogInfo = (req, res) => {
+    const reqId = (0, exports.getReqId)(req);
+    const { headers, method } = req;
+    const logInfo = {
+        requestId: reqId,
+        userAgent: headers['user-agent'],
+        deviceId: headers['device-id'],
+        country: headers['cf-ipcountry'] || headers['ipcountry'] || headers['country'] || 'N/A',
+        language: getLanguage(req),
+        origin: headers['origin'],
+        referer: headers['referer'],
+        ip: req.ip,
+        url: req.originalUrl,
+        statusCode: res.statusCode,
+        method,
+    };
+    if (method === 'GET')
+        return logInfo;
+    const strBody = JSON.stringify(req.body || {});
+    const encodedBody = Buffer.from(strBody).toString('base64');
+    return {
+        ...logInfo,
+        body: encodedBody,
+    };
+};
+const writeToLogger = (req, res, logger) => {
+    if (!(logger || false))
+        return false;
+    try {
+        const logInfo = getLogInfo(req, res);
+        logger().log(logInfo, { severity: 'request-log' });
+        return true;
+    }
+    catch (error) {
+        (0, debug_1.default)(error);
+        return false;
+    }
+};
+function loggerMiddleware(logger, props) {
+    const { appName, appEnv } = props;
+    return (0, morgan_1.default)((tokens, req, res) => {
+        const reqId = (0, exports.getReqId)(req);
+        const timer = setTimeout(() => {
+            writeToLogger(req, res, logger);
+            clearTimeout(timer);
+        }, 10);
+        return [
+            `${appName}[${appEnv}] -`,
+            `[${reqId}]`,
+            tokens.method(req, res),
+            tokens.status(req, res),
+            tokens.url(req, res),
+            tokens.res(req, res, 'content-length'), '-',
+            tokens['response-time'](req, res), 'ms',
+            tokens['user-agent'](req, res),
+        ].join(' ');
+    });
+}

package/router.d.ts

@@ -0,0 +1,13 @@
+import { Application } from 'express';
+import { Route } from './types';
+type RouteOptions = {
+    validator: CallableFunction;
+};
+/**
+ * Registers routes configuration, the way to register routes
+ * is based on route base, not url base
+ * @param {Application} app - Express Application
+ * @param {Route} routes - Routes configuration
+ */
+export default function registerRoutes(app: Application, routes: Route, options: RouteOptions): void;
+export {};