@hapiboo/server 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { IRoutingItem, routingProvider } from './routing';
+import { server } from './server';
+import { validator } from './validator';
+export { IRoutingItem, routingProvider, server, validator };

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = exports.server = exports.routingProvider = void 0;
+const routing_1 = require("./routing");
+Object.defineProperty(exports, "routingProvider", { enumerable: true, get: function () { return routing_1.routingProvider; } });
+const server_1 = require("./server");
+Object.defineProperty(exports, "server", { enumerable: true, get: function () { return server_1.server; } });
+const validator_1 = require("./validator");
+Object.defineProperty(exports, "validator", { enumerable: true, get: function () { return validator_1.validator; } });

package/dist/routing.d.ts

@@ -0,0 +1,12 @@
+import { Application, Router } from 'express';
+export interface IRoutingItem {
+    mount: string | undefined;
+    children: IRoutingItem[];
+    router: Router;
+}
+export declare namespace routingProvider {
+    function printMap(routes: IRoutingItem[]): void;
+    function createRoutingItem(mount: string | undefined, router: Router): IRoutingItem;
+    function createRouter(mount: string | undefined, routes: IRoutingItem[]): IRoutingItem;
+    function processApp(expressApp: Application, routers: IRoutingItem[]): void;
+}

package/dist/routing.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routingProvider = void 0;
+const express_1 = require("express");
+function parseItem(path, item) {
+    if (item.children.length === 0) {
+        return parseRouter(`${path}${item.mount ?? ''}`, item.router);
+    }
+    else {
+        const ret = [];
+        item.children.forEach((child) => {
+            ret.push(...parseItem(`${path}${item.mount ?? ''}`, child));
+        });
+        return ret;
+    }
+}
+function parseRouter(path, item) {
+    const ret = [];
+    item.stack.forEach((layer) => {
+        if (layer.route && layer.name === 'handle') {
+            layer.route.stack.forEach((details) => {
+                if (details.name === '<anonymous>') {
+                    ret.push({ method: details.method, url: `${path}${layer.route?.path}` });
+                }
+            });
+        }
+    });
+    return ret;
+}
+var routingProvider;
+(function (routingProvider) {
+    function printMap(routes) {
+        console.info('Method     Routes:');
+        console.info('------------------');
+        routes.forEach((route) => {
+            parseItem('', route).forEach((detail) => {
+                console.info(`${detail.method.toUpperCase().padEnd(10)} ${detail.url}`);
+            });
+        });
+    }
+    routingProvider.printMap = printMap;
+    function createRoutingItem(mount, router) {
+        return { mount: mount, children: [], router: router };
+    }
+    routingProvider.createRoutingItem = createRoutingItem;
+    function createRouter(mount, routes) {
+        const router = (0, express_1.Router)({ mergeParams: true });
+        routes.forEach((item) => {
+            if (item.mount && item.mount !== '') {
+                router.use(item.mount, item.router);
+            }
+            else {
+                router.use(item.router);
+            }
+        });
+        return { mount: mount, children: routes, router: router };
+    }
+    routingProvider.createRouter = createRouter;
+    function processApp(expressApp, routers) {
+        routers.forEach((item) => {
+            if (item.mount && item.mount !== '') {
+                expressApp.use(item.mount, item.router);
+            }
+            else {
+                expressApp.use(item.router);
+            }
+        });
+    }
+    routingProvider.processApp = processApp;
+})(routingProvider || (exports.routingProvider = routingProvider = {}));

package/dist/server.d.ts

@@ -0,0 +1,19 @@
+import { Response, Request } from 'express';
+import { ResponseError, IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+export declare namespace server {
+    function prepareJsonResponse<T>(response: Response, data: T, err?: ResponseError, non200Status?: number): void;
+    function prepareStringResponse(response: Response, data: string, err?: ResponseError): void;
+    function prepareBinaryResponse(response: Response, data: Buffer, err?: ResponseError): void;
+    function prepareMimeResponse(response: Response, data: Buffer, mime: string, err?: ResponseError, non200Status?: number): void;
+    function prepareJsonPromiseResponse<T>(response: Response, promise: IResponsePromise<T>, non200Status?: number): void;
+    function prepareStringPromiseResponse(response: Response, promise: IResponsePromise<string>, non200Status?: number): void;
+    function prepareEmptyPromiseResponse(response: Response, promise: IResponsePromiseVoid, non200Status?: number): void;
+    function prepareMimePromiseResponse(response: Response, mime: string, promise: IResponsePromise<Buffer>, non200Status?: number): void;
+    function prepareMimeBinaryPromiseResponse(response: Response, promise: IResponsePromise<{
+        mime: string;
+        binary: Buffer;
+    }>, non200Status?: number): void;
+    function prepareCustomPromiseResponse<T>(response: Response, promise: IResponsePromiseVoid, successContent: T, non200Status?: number): void;
+    function createValidatedPromise<T>(request: Request, validator: (request: Request) => boolean, delayedPromise: IResponsePromise<T>): IResponsePromise<T>;
+    function createValidatedVoidPromise(request: Request, validator: (request: Request) => boolean, delayedPromise: IResponsePromiseVoid): IResponsePromiseVoid;
+}

package/dist/server.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.server = void 0;
+const core_1 = require("@hapiboo/core");
+function prepareResponse(response, responseSender, err, non200Status) {
+    if (err) {
+        response.status(err.status);
+        if (err.code) {
+            if (err.error) {
+                response.json({ code: err.code, error: err.message, original: err.error.name, stack: err.error.stack });
+            }
+            else {
+                response.json({ code: err.code, error: err.message });
+            }
+        }
+        else {
+            if (err.error) {
+                response.json({ error: err.message, original: err.error.name, stack: err.error.stack });
+            }
+            else {
+                response.json({ error: err.message });
+            }
+        }
+    }
+    else {
+        if (responseSender) {
+            response.status(non200Status ?? 200);
+            responseSender();
+        }
+        else {
+            response.status(non200Status ?? 204);
+            response.send();
+        }
+    }
+}
+var server;
+(function (server) {
+    function prepareJsonResponse(response, data, err, non200Status) {
+        prepareResponse(response, () => {
+            response.json(data);
+        }, err, non200Status);
+    }
+    server.prepareJsonResponse = prepareJsonResponse;
+    function prepareStringResponse(response, data, err) {
+        prepareResponse(response, () => {
+            response.send(data);
+        }, err);
+    }
+    server.prepareStringResponse = prepareStringResponse;
+    function prepareBinaryResponse(response, data, err) {
+        prepareResponse(response, () => {
+            response.send(data);
+        }, err);
+    }
+    server.prepareBinaryResponse = prepareBinaryResponse;
+    function prepareMimeResponse(response, data, mime, err, non200Status) {
+        prepareResponse(response, () => {
+            if (mime != undefined && data != undefined) {
+                response.contentType(mime);
+                response.send(data);
+            }
+            else {
+                response.json({});
+            }
+        }, err, non200Status);
+    }
+    server.prepareMimeResponse = prepareMimeResponse;
+    function prepareJsonPromiseResponse(response, promise, non200Status) {
+        promise
+            .then((data) => {
+            prepareResponse(response, () => {
+                response.json(data);
+            }, undefined, non200Status);
+        })
+            .catch((error) => {
+            prepareResponse(response, undefined, error, non200Status);
+        });
+    }
+    server.prepareJsonPromiseResponse = prepareJsonPromiseResponse;
+    function prepareStringPromiseResponse(response, promise, non200Status) {
+        promise
+            .then((value) => {
+            prepareStringResponse(response, value);
+        })
+            .catch((error) => {
+            prepareResponse(response, undefined, error, non200Status);
+        });
+    }
+    server.prepareStringPromiseResponse = prepareStringPromiseResponse;
+    function prepareEmptyPromiseResponse(response, promise, non200Status) {
+        promise
+            .then(() => {
+            prepareResponse(response, undefined, undefined, non200Status);
+        })
+            .catch((error) => {
+            prepareResponse(response, undefined, error, non200Status);
+        });
+    }
+    server.prepareEmptyPromiseResponse = prepareEmptyPromiseResponse;
+    function prepareMimePromiseResponse(response, mime, promise, non200Status) {
+        promise
+            .then((data) => {
+            prepareMimeResponse(response, data, mime, undefined, non200Status);
+        })
+            .catch((error) => {
+            prepareResponse(response, undefined, error, non200Status);
+        });
+    }
+    server.prepareMimePromiseResponse = prepareMimePromiseResponse;
+    function prepareMimeBinaryPromiseResponse(response, promise, non200Status) {
+        promise
+            .then((data) => {
+            prepareMimeResponse(response, data.binary, data.mime, undefined, non200Status);
+        })
+            .catch((error) => {
+            prepareResponse(response, undefined, error, non200Status);
+        });
+    }
+    server.prepareMimeBinaryPromiseResponse = prepareMimeBinaryPromiseResponse;
+    function prepareCustomPromiseResponse(response, promise, successContent, non200Status) {
+        promise
+            .then(() => {
+            prepareResponse(response, () => { response.send(successContent); }, undefined, non200Status);
+        })
+            .catch((error) => {
+            prepareResponse(response, undefined, error, non200Status);
+        });
+    }
+    server.prepareCustomPromiseResponse = prepareCustomPromiseResponse;
+    function createValidatedPromise(request, validator, delayedPromise) {
+        if (validator(request)) {
+            return delayedPromise.start();
+        }
+        else {
+            return core_1.promise.createFailedPromise(core_1.ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+    server.createValidatedPromise = createValidatedPromise;
+    function createValidatedVoidPromise(request, validator, delayedPromise) {
+        if (validator(request)) {
+            return delayedPromise.start();
+        }
+        else {
+            return core_1.promise.createFailedVoidPromise(core_1.ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+    server.createValidatedVoidPromise = createValidatedVoidPromise;
+})(server || (exports.server = server = {}));

package/dist/validator.d.ts

@@ -0,0 +1,20 @@
+import { Request } from 'express';
+import { IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+export declare namespace validator {
+    function createValidatedPromise<T>(validator: () => boolean, delayedPromise: IResponsePromise<T>): IResponsePromise<T>;
+    function createValidatedVoidPromise(validator: () => boolean, delayedPromise: IResponsePromiseVoid): IResponsePromiseVoid;
+    function validateString(toValidate: string): boolean;
+    function validatePattern(toValidate: string, pattern: string[]): boolean;
+    function validateStringArray(toValidate: string[]): boolean;
+    function validateNotEmptyStringArray(toValidate: string[]): boolean;
+    function validateInteger(toValidate: number): boolean;
+    function validateBody(request: Request): boolean;
+    function validateHeader(request: Request, headerKey: string): {
+        isValid: boolean;
+        value: string;
+    };
+    function validateQuery(request: Request, queryKey: string): {
+        isValid: boolean;
+        value: string;
+    };
+}

package/dist/validator.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = void 0;
+const core_1 = require("@hapiboo/core");
+var validator;
+(function (validator_1) {
+    function createValidatedPromise(validator, delayedPromise) {
+        if (validator()) {
+            return delayedPromise.start();
+        }
+        else {
+            return core_1.promise.createFailedPromise(core_1.ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+    validator_1.createValidatedPromise = createValidatedPromise;
+    function createValidatedVoidPromise(validator, delayedPromise) {
+        if (validator()) {
+            return delayedPromise.start();
+        }
+        else {
+            return core_1.promise.createFailedVoidPromise(core_1.ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+    validator_1.createValidatedVoidPromise = createValidatedVoidPromise;
+    function validateString(toValidate) {
+        return toValidate != undefined && toValidate != '';
+    }
+    validator_1.validateString = validateString;
+    function validatePattern(toValidate, pattern) {
+        return validateString(toValidate) &&
+            pattern.some((val) => {
+                return val == toValidate;
+            });
+    }
+    validator_1.validatePattern = validatePattern;
+    function validateStringArray(toValidate) {
+        return toValidate != undefined;
+    }
+    validator_1.validateStringArray = validateStringArray;
+    function validateNotEmptyStringArray(toValidate) {
+        return toValidate != undefined && toValidate.length > 0 && toValidate.every((item) => { return validateString(item); });
+    }
+    validator_1.validateNotEmptyStringArray = validateNotEmptyStringArray;
+    function validateInteger(toValidate) {
+        return toValidate != undefined && (Math.floor(toValidate) == toValidate);
+    }
+    validator_1.validateInteger = validateInteger;
+    function validateBody(request) {
+        return request.body !== undefined;
+    }
+    validator_1.validateBody = validateBody;
+    function validateHeader(request, headerKey) {
+        const headerValue = request.headers[headerKey.toLowerCase()];
+        if (headerValue && typeof (headerValue) === 'string' && headerValue.trim() !== '') {
+            return { isValid: true, value: headerValue };
+        }
+        else {
+            return { isValid: false, value: '' };
+        }
+    }
+    validator_1.validateHeader = validateHeader;
+    function validateQuery(request, queryKey) {
+        const queryValue = request.query[queryKey];
+        if (queryValue && typeof (queryValue) === 'string' && queryValue.trim() !== '') {
+            return { isValid: true, value: queryValue };
+        }
+        else {
+            return { isValid: false, value: '' };
+        }
+    }
+    validator_1.validateQuery = validateQuery;
+})(validator || (exports.validator = validator = {}));

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+    ...tseslint.configs.recommended,
+    {
+        files: ["**/*.{ts,mts,cts}"],
+        rules: {
+            "@typescript-eslint/no-namespace": "off",
+            indent: ['error', 4],
+            'linebreak-style': ['error', 'unix'],
+            quotes: ['error', 'single'],
+            semi: ['error', 'always'],
+        },
+    },
+]);

package/package.dev.json

@@ -0,0 +1,31 @@
+{
+    "name": "@hapiboo/server",
+    "version": "2.0.1-dev",
+    "description": "MK13 Studio Hapiboo - API server services",
+    "author": "MK13 Studio",
+    "license": "ISC",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "s_public": "cp package.public.json package.json",
+        "s_dev": "cp package.dev.json package.json",
+        "s_clean": "rm -f pnpm-lock.yaml && rm -rf node_modules dist",
+        "s_dependency": "cd .. && cd __core && pnpm s_build",
+        "s_build": "tsc --project tsconfig.dev.json",
+        "s_lint": "eslint 'src/*.ts'",
+        "s_lint_fix": "eslint 'src/*.ts' --fix",
+        "s_prepare": "pnpm s_clean && pnpm i && pnpm s_lint && pnpm s_build"
+    },
+    "dependencies": {
+        "@hapiboo/core": "workspace:*",
+        "express": "^5.1.0"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.3",
+        "@typescript-eslint/eslint-plugin": "^8.38.0",
+        "@typescript-eslint/parser": "^8.38.0",
+        "eslint": "^9.32.0",
+        "typescript": "5.8.3",
+        "typescript-eslint": "^8.38.0"
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@hapiboo/server",
+  "version": "2.0.0",
+  "description": "MK13 Studio Hapiboo - API server services",
+  "author": "MK13 Studio",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@hapiboo/core": "^2.0.0",
+    "express": "^5.1.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^9.32.0",
+    "typescript": "5.8.3",
+    "typescript-eslint": "^8.38.0"
+  },
+  "scripts": {
+    "s_public": "cp package.public.json package.json",
+    "s_dev": "cp package.dev.json package.json",
+    "s_clean": "rm -f pnpm-lock.yaml && rm -rf node_modules dist",
+    "s_build": "tsc --project tsconfig.public.json",
+    "s_lint": "eslint 'src/*.ts'",
+    "s_check": "bash ../../scripts/publish.sh ./",
+    "s_publish": "pnpm s_clean && pnpm i -w=false && pnpm s_lint && pnpm s_build && pnpm s_check && pnpm s_dev"
+  }
+}

package/package.public.json

@@ -0,0 +1,30 @@
+{
+    "name": "@hapiboo/server",
+    "version": "2.0.0",
+    "description": "MK13 Studio Hapiboo - API server services",
+    "author": "MK13 Studio",
+    "license": "ISC",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "s_public": "cp package.public.json package.json",
+        "s_dev": "cp package.dev.json package.json",
+        "s_clean": "rm -f pnpm-lock.yaml && rm -rf node_modules dist",
+        "s_build": "tsc --project tsconfig.public.json",
+        "s_lint": "eslint 'src/*.ts'",
+        "s_check": "bash ../../scripts/publish.sh ./",
+        "s_publish": "pnpm s_clean && pnpm i -w=false && pnpm s_lint && pnpm s_build && pnpm s_check && pnpm s_dev"
+    },
+    "dependencies": {
+        "@hapiboo/core": "^2.0.0",
+        "express": "^5.1.0"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.3",
+        "@typescript-eslint/eslint-plugin": "^8.38.0",
+        "@typescript-eslint/parser": "^8.38.0",
+        "eslint": "^9.32.0",
+        "typescript": "5.8.3",
+        "typescript-eslint": "^8.38.0"
+    }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import { IRoutingItem, routingProvider } from './routing';
+import { server } from './server';
+import { validator } from './validator';
+
+export { IRoutingItem, routingProvider, server, validator };

package/src/routing.ts

@@ -0,0 +1,77 @@
+import { Application, Router, IRouter } from 'express';
+
+interface IRouteDetails{
+    method: string;
+    url: string;
+}
+
+function parseItem(path: string, item: IRoutingItem): IRouteDetails[]{
+    if (item.children.length === 0) {
+        return parseRouter(`${path}${item.mount ?? ''}`, item.router);
+    } else {
+        const ret: IRouteDetails[] = [];
+        item.children.forEach((child) => {
+            ret.push(...parseItem(`${path}${item.mount ?? ''}`, child));
+        });
+
+        return ret;
+    }
+}
+function parseRouter(path: string, item: IRouter): IRouteDetails[]{
+    const ret: IRouteDetails[] = [];
+    item.stack.forEach((layer) => {
+        if (layer.route && layer.name === 'handle') {
+            layer.route.stack.forEach((details) => {
+                if (details.name === '<anonymous>'){
+                    ret.push({ method: details.method, url: `${path}${layer.route?.path }` });
+                }
+            });
+        }
+    });
+
+    return ret;
+}
+
+export interface IRoutingItem{
+    mount: string | undefined;
+    children: IRoutingItem[];
+    router: Router;
+}
+
+export namespace routingProvider{
+    export function printMap(routes: IRoutingItem[]){
+        console.info('Method     Routes:');
+        console.info('------------------');
+
+        routes.forEach((route) => {
+            parseItem('', route).forEach((detail) => {
+                console.info(`${detail.method.toUpperCase().padEnd(10)} ${detail.url}`);
+            });
+        });
+    }
+    export function createRoutingItem(mount: string | undefined, router: Router): IRoutingItem{
+        return { mount: mount, children: [], router: router };
+    }
+    export function createRouter(mount: string | undefined, routes: IRoutingItem[]): IRoutingItem{
+        const router = Router({ mergeParams: true });
+
+        routes.forEach((item) => {
+            if (item.mount && item.mount !== ''){
+                router.use(item.mount, item.router);
+            } else {
+                router.use(item.router);
+            }
+        });
+
+        return { mount: mount, children: routes, router: router };
+    }
+    export function processApp(expressApp: Application, routers: IRoutingItem[]){
+        routers.forEach((item) => {
+            if (item.mount && item.mount !== ''){
+                expressApp.use(item.mount, item.router);
+            } else {
+                expressApp.use(item.router);
+            }
+        });
+    }
+}

package/src/server.ts

@@ -0,0 +1,129 @@
+import { Response, Request } from 'express';
+import { promise, ResponseError, IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+
+function prepareResponse(response: Response, responseSender?: () => void, err?: ResponseError, non200Status?: number) {
+    if (err) {
+        response.status(err.status);
+        if (err.code) {
+            if (err.error) {
+                response.json({ code: err.code, error: err.message, original: err.error.name, stack: err.error.stack });
+            } else {
+                response.json({ code: err.code, error: err.message});
+            }
+        } else {
+            if (err.error) {
+                response.json({ error: err.message, original: err.error.name, stack: err.error.stack });
+            } else {
+                response.json({ error: err.message});
+            }    
+        }
+    } else {
+        if (responseSender) {
+            response.status(non200Status ?? 200);
+            responseSender();
+        } else {
+            response.status(non200Status ?? 204);
+            response.send();
+        }
+    }
+}
+
+export namespace server {
+    export function prepareJsonResponse<T>(response: Response, data: T, err?: ResponseError, non200Status?: number) {
+        prepareResponse(response, () => {
+            response.json(data);
+        }, err, non200Status);
+    }
+    export function prepareStringResponse(response: Response, data: string, err?: ResponseError) {
+        prepareResponse(response, () => {
+            response.send(data);
+        }, err);
+    }
+    export function prepareBinaryResponse(response: Response, data: Buffer, err?: ResponseError) {
+        prepareResponse(response, () => {
+            response.send(data);
+        }, err);
+    }
+    export function prepareMimeResponse(response: Response, data: Buffer, mime: string, err?: ResponseError, non200Status?: number) {
+        prepareResponse(response, () => {
+            if (mime != undefined && data != undefined) {
+                response.contentType(mime);
+                response.send(data);    
+            } else {
+                response.json({});
+            }
+        }, err, non200Status);
+    }
+
+    export function prepareJsonPromiseResponse<T>(response: Response, promise: IResponsePromise<T>, non200Status?: number) {
+        promise
+            .then((data) => {
+                prepareResponse(response, () => {
+                    response.json(data);
+                }, undefined, non200Status);        
+            })
+            .catch((error) => {
+                prepareResponse(response, undefined, error, non200Status);
+            });
+    }
+    export function prepareStringPromiseResponse(response: Response, promise: IResponsePromise<string>, non200Status?: number) {
+        promise
+            .then((value) => {
+                prepareStringResponse(response, value);
+            })
+            .catch((error) => {
+                prepareResponse(response, undefined, error, non200Status);
+            });
+    }
+    export function prepareEmptyPromiseResponse(response: Response, promise: IResponsePromiseVoid, non200Status?: number) {
+        promise
+            .then(() => {
+                prepareResponse(response, undefined, undefined, non200Status);
+            })
+            .catch((error) => {
+                prepareResponse(response, undefined, error, non200Status);
+            });
+    }
+    export function prepareMimePromiseResponse(response: Response, mime: string, promise: IResponsePromise<Buffer>, non200Status?: number) {
+        promise
+            .then((data) => {
+                prepareMimeResponse(response, data, mime, undefined, non200Status);
+            })
+            .catch((error) => {
+                prepareResponse(response, undefined, error, non200Status);
+            });
+    }
+    export function prepareMimeBinaryPromiseResponse(response: Response, promise: IResponsePromise<{mime: string, binary: Buffer}>, non200Status?: number) {
+        promise
+            .then((data) => {
+                prepareMimeResponse(response, data.binary, data.mime, undefined, non200Status);
+            })
+            .catch((error) => {
+                prepareResponse(response, undefined, error, non200Status);
+            });
+    }
+    export function prepareCustomPromiseResponse<T>(response: Response, promise: IResponsePromiseVoid, successContent: T, non200Status?: number) {
+        promise
+            .then(() => {
+                prepareResponse(response, () => { response.send(successContent); }, undefined, non200Status);
+            })
+            .catch((error) => {
+                prepareResponse(response, undefined, error, non200Status);
+            });
+    }
+
+    export function createValidatedPromise<T>(request: Request, validator: (request: Request) => boolean, delayedPromise: IResponsePromise<T>): IResponsePromise<T> {
+        if (validator(request)) {
+            return delayedPromise.start();
+        } else {
+            return promise.createFailedPromise(ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+    export function createValidatedVoidPromise(request: Request, validator: (request: Request) => boolean, delayedPromise: IResponsePromiseVoid): IResponsePromiseVoid {
+        if (validator(request)) {
+            return delayedPromise.start();
+        } else {
+            return promise.createFailedVoidPromise(ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+}

package/src/validator.ts

@@ -0,0 +1,63 @@
+import { Request } from 'express';
+import { promise, ResponseError, IResponsePromise, IResponsePromiseVoid } from '@hapiboo/core';
+
+export namespace validator {
+
+    export function createValidatedPromise<T>(validator: () => boolean, delayedPromise: IResponsePromise<T>): IResponsePromise<T> {
+        if (validator()) {
+            return delayedPromise.start();
+        } else {
+            return promise.createFailedPromise(ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+    export function createValidatedVoidPromise(validator: () => boolean, delayedPromise: IResponsePromiseVoid): IResponsePromiseVoid {
+        if (validator()) {
+            return delayedPromise.start();
+        } else {
+            return promise.createFailedVoidPromise(ResponseError.getMessageResponse(400, 'malformed request'));
+        }
+    }
+
+    export function validateString(toValidate: string): boolean {
+        return toValidate != undefined && toValidate != '';
+    }
+    export function validatePattern(toValidate: string, pattern: string[]): boolean {
+        return validateString(toValidate) &&
+            pattern.some((val) => {
+                return val == toValidate;
+            });
+    }
+    export function validateStringArray(toValidate: string[]): boolean {
+        return toValidate != undefined;
+    }
+    export function validateNotEmptyStringArray(toValidate: string[]): boolean {
+        return toValidate != undefined && toValidate.length > 0 && toValidate.every((item) => { return validateString(item); });
+    }
+    export function validateInteger(toValidate: number): boolean {
+        return toValidate != undefined && (Math.floor(toValidate) == toValidate);
+    }
+
+    export function validateBody(request: Request): boolean{
+        return request.body !== undefined;
+    }
+
+    export function validateHeader(request: Request, headerKey: string): { isValid: boolean, value: string }{
+        const headerValue = request.headers[headerKey.toLowerCase()];
+
+        if (headerValue && typeof(headerValue) === 'string' && headerValue.trim() !== '') {
+            return { isValid: true, value: headerValue };
+        } else {
+            return { isValid: false, value: '' };
+        }
+    }
+
+    export function validateQuery(request: Request, queryKey: string): { isValid: boolean, value: string }{
+        const queryValue = request.query[queryKey];
+
+        if (queryValue && typeof(queryValue) === 'string' && queryValue.trim() !== '') {
+            return { isValid: true, value: queryValue };
+        } else {
+            return { isValid: false, value: '' };
+        }
+    }
+}

package/tsconfig.base.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": ["ES2020"],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "declaration": true,
+        },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
+} 

package/tsconfig.dev.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "sourceMap": true,
+        "declarationMap": true
+    } 
+}

package/tsconfig.public.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "sourceMap": false,
+        "declarationMap": false
+    }
+}