xpref 1.0.0

package/router.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = registerRoutes;
+const express_1 = require("express");
+const getMethodHandlers = (handlerOptions, options = {}) => {
+    if (Array.isArray(handlerOptions))
+        return handlerOptions;
+    if (typeof handlerOptions === 'function')
+        return [handlerOptions];
+    const { action, params } = handlerOptions;
+    if (!(params || false))
+        return Array.isArray(action) ? action : [action];
+    const { validator } = options;
+    const validatorMiddleware = validator({ params });
+    const methodHandlers = Array.isArray(action) ? action : [action];
+    return [validatorMiddleware, ...methodHandlers];
+};
+/**
+ * Registers the verb handlers to routes
+ * @property {any} handlers
+ * @property {any} router
+ */
+const registerHandler = ({ handlers, router }, options = {}) => {
+    const methods = Object.keys(handlers);
+    const path = '/';
+    methods.forEach((method) => {
+        const methodHandlers = handlers[method];
+        const callbacks = getMethodHandlers(methodHandlers, options);
+        router[method](path, ...callbacks);
+    });
+};
+/**
+ * Creates router for path information
+ * @param {PathDetail} pathDetail - The path default defined after uri
+ * @return router
+ */
+const createRouter = (pathHandler, options) => {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    const [_name, middlewares, handlers, children = {}] = pathHandler;
+    if (middlewares.length > 0)
+        router.use(...middlewares);
+    registerHandler({ handlers, router }, options);
+    const childPaths = Object.keys(children);
+    if (childPaths.length === 0)
+        return router;
+    childPaths.forEach((childPath) => {
+        const childRouter = createRouter(children[childPath], options);
+        router.use(childPath, childRouter);
+    });
+    return router;
+};
+/**
+ * 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
+ */
+function registerRoutes(app, routes, options) {
+    const paths = Object.keys(routes);
+    paths.forEach((path) => {
+        const pathDetail = routes[path];
+        const router = createRouter(pathDetail, options);
+        app.use(path, router);
+    });
+}

package/setting/index.d.ts

@@ -0,0 +1 @@
+export default function getSetting(): Date;

package/setting/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getSetting;
+function getSetting() {
+    return new Date();
+}

package/static.d.ts

@@ -0,0 +1,2 @@
+import { type Application } from 'express';
+export default function registerStatic(app: Application, staticRoutes?: any): void;

package/static.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = registerStatic;
+const path_1 = require("path");
+const express_1 = require("express");
+function registerStatic(app, staticRoutes = {}) {
+    const keys = Object.keys(staticRoutes);
+    keys.forEach((path) => {
+        const location = (0, path_1.resolve)(staticRoutes[path]);
+        app.use(path, (0, express_1.static)(location));
+    });
+}

package/types.d.ts

@@ -0,0 +1,52 @@
+import type { Application } from 'express';
+import type { IncomingMessage } from 'http';
+export type { IncomingMessage } from 'http';
+export type { Request, Response, NextFunction, Application } from 'express';
+export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
+type MethodHandlerAction = CallableFunction | CallableFunction[];
+type Params = {
+    query?: any;
+    path?: any;
+    body?: any;
+};
+export type MethodOptions = MethodHandlerAction | {
+    action: MethodHandlerAction;
+    params?: Params;
+    description?: string | [string, string];
+};
+export type MethodHandler = {
+    get?: MethodOptions;
+    post?: MethodOptions;
+    put?: MethodOptions;
+    delete?: MethodOptions;
+    patch?: MethodOptions;
+};
+export type PathMiddleware = Array<any>;
+export type PathDetail = [string, PathMiddleware, MethodHandler] | [string, PathMiddleware, MethodHandler, Record<string, PathDetail>];
+export type Route = Record<any, PathDetail>;
+type OnInit = (_app: Application) => void;
+export type API = {
+    appName: string;
+    appEnv: string;
+    port?: number;
+    routes: Route;
+    logger?: any;
+    staticRoutes?: Record<string, string>;
+    interceptor?: any;
+    onInit?: OnInit;
+    schemas?: Record<string, any>;
+    manuallyStart?: any;
+};
+export type RequestForwarder = {
+    host: string;
+    proxyPrefix?: string;
+    withPrefix?: boolean;
+    headers?: Record<string, string | boolean | number>;
+    onUrlConstructed?: (url: string) => string;
+    passToNext?: boolean;
+};
+export type ProxyResult = {
+    statusCode: number;
+    headers: IncomingMessage['headers'];
+    body: Buffer;
+};

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Response } from 'express';
+export declare const responseError: (res: Response, message: any, statusCode?: number) => Response<any, Record<string, any>>;
+type DecodedSchema = [string, boolean, string[]];
+export declare const decodeSchemaName: (schemaName: string, accuRequired?: string[]) => DecodedSchema;
+export {};

package/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSchemaName = exports.responseError = void 0;
+const responseError = (res, message, statusCode = 400) => {
+    const objMsg = typeof message === 'string' ? { message } : message;
+    const errorResult = {
+        error: true,
+        status: statusCode,
+        ...objMsg,
+    };
+    return res
+        .status(statusCode)
+        .send(errorResult);
+};
+exports.responseError = responseError;
+const decodeSchemaName = (schemaName, accuRequired = []) => {
+    const [field, isRequired = false] = schemaName.split('*');
+    if (isRequired === false)
+        return [field, false, accuRequired];
+    return [field, true, [...accuRequired, field]];
+};
+exports.decodeSchemaName = decodeSchemaName;

package/validator/method-validator.d.ts

@@ -0,0 +1,6 @@
+import type { Request, Response, NextFunction, MethodOptions } from '../types';
+type SchemaOptions = {
+    domainName?: string;
+};
+export default function initMethodValidation(pSchemas: any, options?: SchemaOptions): (methodOptions: MethodOptions) => (req: Request, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
+export {};

package/validator/method-validator.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = initMethodValidation;
+const ajv_1 = __importDefault(require("ajv"));
+const ajvErrors = require('ajv-errors');
+const schema_1 = require("./schema");
+const validate_1 = require("./validate");
+const ajvOptions = {
+    allErrors: true,
+    $data: true,
+    strict: true,
+    coerceTypes: true,
+    schemas: [],
+};
+const ajv = new ajv_1.default(ajvOptions);
+ajvErrors(ajv);
+function initMethodValidation(pSchemas, options = {}) {
+    const { domainName = 'common' } = options;
+    const schemas = (0, schema_1.getObjectSchema)({
+        type: 'object',
+        properties: pSchemas,
+        required: [],
+    }, domainName);
+    ajv.addSchema(schemas);
+    return (methodOptions) => {
+        const sources = Object.keys(methodOptions);
+        return (req, res, next) => {
+            if (sources.length === 0)
+                return next();
+            const errors = (0, validate_1.validate)(ajv, {
+                methodOptions,
+                request: req,
+            });
+            if (errors.length === 0)
+                return next();
+            return res.status(400).json({
+                error: true,
+                errors: (0, validate_1.getErrors)(errors),
+            });
+        };
+    };
+}

package/validator/route-schema.d.ts

@@ -0,0 +1,2 @@
+import type { MethodOptions } from '../types';
+export default function getRouteSchema(methodOptions: Omit<MethodOptions, 'action'>): any;

package/validator/route-schema.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getRouteSchema;
+const utils_1 = require("../utils");
+const schema_1 = require("./schema");
+const getSchemaFromString = (accu, refName) => {
+    const [accuProps, accuRequired] = accu;
+    const [schemaName, _re, required] = (0, utils_1.decodeSchemaName)(refName, accuRequired);
+    return [
+        { ...accuProps, [schemaName]: (0, schema_1.getRefSchema)(schemaName, 'common.js') },
+        required,
+    ];
+};
+const getSchemasOfArrayProps = (properties, required = []) => {
+    const result = properties.reduce((accu, prop) => {
+        const isString = typeof prop === 'string';
+        if (isString)
+            return getSchemaFromString(accu, prop);
+        const [accuProps, accuRequired] = accu;
+        const [name, props] = prop;
+        const [schemaName, _req, nextRequired] = (0, utils_1.decodeSchemaName)(name, accuRequired);
+        return [
+            { ...accuProps, [schemaName]: getObjectSchema(props) },
+            nextRequired,
+        ];
+    }, [{}, required]);
+    return result;
+};
+const getSchemasOfObjectProps = (properties, required = []) => {
+    const names = Object.keys(properties);
+    const result = names.reduce((accu) => accu, [{}, required]);
+    return result;
+};
+const injectId = (props, id = '') => {
+    if (id === '')
+        return props;
+    return { ...props, $id: id };
+};
+function getObjectSchema(schemaProps, id = '') {
+    const { type = 'string' } = schemaProps;
+    if (type !== 'object') {
+        const res = (0, schema_1.senitizeSchema)(schemaProps);
+        return res;
+    }
+    ;
+    const { properties = [], required = [] } = schemaProps;
+    const isArray = Array.isArray(properties);
+    const [nextProps, nextRequired] = (isArray)
+        ? getSchemasOfArrayProps(properties, required)
+        : getSchemasOfObjectProps(properties, required);
+    const result = { properties: nextProps, required: nextRequired, type: 'object' };
+    return injectId(result, id);
+}
+;
+function getRouteSchema(methodOptions) {
+    const { params = {} } = methodOptions;
+    return ['query', 'params', 'body'].reduce((accu, dataSlot) => {
+        const properties = params[dataSlot] || [];
+        const isArray = Array.isArray(properties);
+        const isEmpty = isArray && properties.length == 0;
+        if (isEmpty)
+            return accu;
+        const schemaProps = isArray
+            ? { properties, type: 'object' }
+            : { type: 'object', ...properties };
+        const now = new Date().getTime();
+        const schema = getObjectSchema(schemaProps, `${schema_1.domain}/${dataSlot}-${now}.js`);
+        return { ...accu, [dataSlot]: schema };
+    }, {});
+}
+;

package/validator/schema.d.ts

@@ -0,0 +1,15 @@
+type ObjectSchema = {
+    type?: string;
+    properties: string[];
+    required?: string[];
+    $id?: string;
+};
+export declare const senitizeSchema: (schemaProps: Record<string, any>) => {
+    type: string;
+};
+export declare const domain = "https://schemas.api.com";
+export declare const getRefSchema: (name: string, ref: string) => {
+    $ref: string;
+};
+export declare function getObjectSchema(schema: ObjectSchema, id?: string | false, ref?: string): ObjectSchema;
+export {};

package/validator/schema.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefSchema = exports.domain = exports.senitizeSchema = void 0;
+exports.getObjectSchema = getObjectSchema;
+const senitizeSchema = (schemaProps) => {
+    const { example: _ex, ...senitizedSchema } = schemaProps;
+    return { type: 'string', ...senitizedSchema };
+};
+exports.senitizeSchema = senitizeSchema;
+exports.domain = 'https://schemas.api.com';
+const getRef = (refName, ref = '') => `${ref}#/properties/${refName}`;
+const getRefSchema = (name, ref) => ({
+    $ref: getRef(name, ref),
+});
+exports.getRefSchema = getRefSchema;
+const getArrayProperties = (properties, ref = '') => {
+    if (properties.length === 0)
+        return properties;
+    const touchedProperties = properties.reduce((accu, prop) => {
+        const isString = typeof prop === 'string';
+        if (isString)
+            return { ...accu, [prop]: (0, exports.getRefSchema)(prop, ref) };
+        const [schemaName, schemaProps] = prop;
+        const type = schemaProps.type || 'string';
+        if (type !== 'object')
+            return {
+                ...accu,
+                [schemaName]: (0, exports.senitizeSchema)(schemaProps),
+            };
+        return {
+            ...accu,
+            [schemaName]: getObjectSchema(schemaProps),
+        };
+    }, {});
+    return touchedProperties;
+};
+const getObjectProperties = (properties) => {
+    const schemaNames = Object.keys(properties);
+    const nextProperties = schemaNames.reduce((accu, schemaName) => {
+        const schemaProps = properties[schemaName];
+        const type = schemaProps.type || 'string';
+        if (type !== 'object')
+            return { ...accu, [schemaName]: (0, exports.senitizeSchema)(schemaProps) };
+        return { ...accu, [schemaName]: getObjectSchema(schemaProps, false) };
+    }, {});
+    return nextProperties;
+};
+function getObjectSchema(schema, id = false, ref = '') {
+    const { properties, required = [] } = schema;
+    const isArray = Array.isArray(properties);
+    const nextProperties = isArray
+        ? getArrayProperties(properties, ref)
+        : getObjectProperties(properties);
+    const result = {
+        type: 'object',
+        properties: nextProperties,
+        required,
+    };
+    if (!id)
+        return result;
+    const refId = `${exports.domain}/${id}.js`;
+    return { ...result, $id: refId };
+}

package/validator/validate.d.ts

@@ -0,0 +1,8 @@
+import type { Request, MethodOptions } from '../types';
+type ValidationProps = {
+    request: Request;
+    methodOptions: MethodOptions;
+};
+export declare const getErrors: (errors: any) => any;
+export declare const validate: (ajv: any, pProps: ValidationProps) => any;
+export {};

package/validator/validate.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.getErrors = void 0;
+const route_schema_1 = __importDefault(require("./route-schema"));
+const anyOfRequiredField = [];
+const caseToWords = (field) => field
+    .replace(/([a-z])([A-Z])/g, '$1 $2') // split camelCase => camel Case
+    .replace(/[_-]/g, ' ')
+    .replace(/\s+/g, ' ') // replace multi space with single one
+    .replace(/\b[a-z]/g, (char) => char.toUpperCase()) // capitalize text => Text
+    .trim(); // remove start/end space
+const getRequestData = (req) => {
+    const { query, params, body } = req;
+    return { query, params, body };
+};
+const splitField = (field, delimiter = '/') => {
+    const fields = field.split(delimiter);
+    return fields[fields.length - 1];
+};
+const customMsg = (params, keyword, message) => {
+    const { missingProperty = '' } = params;
+    let newMsg = message;
+    switch (keyword) {
+        case 'required':
+            anyOfRequiredField.push(missingProperty);
+            const words = caseToWords(missingProperty);
+            newMsg = `${words} field is required.`;
+            break;
+        case 'anyOf':
+            newMsg = `Must has anyOf the field ${anyOfRequiredField}`;
+            anyOfRequiredField.splice(0, anyOfRequiredField.length);
+            break;
+        case 'maximum':
+            newMsg = message.replace('<=', 'less than or equal to');
+            break;
+        case 'minimum':
+            newMsg = message.replace('>=', 'greater than or equal to');
+            break;
+        case 'minLength':
+            newMsg = message.replace('NOT have fewer than', 'be at least');
+            break;
+        case 'enum':
+            newMsg = `${message} ${JSON.stringify(params.allowedValues)}`;
+            break;
+        default: break;
+    }
+    return newMsg;
+};
+const getErrorMsg = (error) => {
+    const { instancePath = '', params = {}, keyword = '', message, } = error;
+    const newMessage = customMsg(params, keyword, message);
+    if (instancePath === '')
+        return newMessage;
+    const errorField = splitField(instancePath, '/');
+    return `${caseToWords(errorField)} ${newMessage}`;
+};
+const getErrorField = (error) => {
+    const { params, keyword } = error;
+    switch (keyword) {
+        case 'required':
+            return splitField(params.missingProperty, '.');
+        case 'anyOf':
+            return 'anyOf';
+        default:
+            return splitField(error.instancePath, '/');
+    }
+};
+const getErrors = (errors) => (errors.reduce((acc, error) => {
+    const field = getErrorField(error);
+    const message = getErrorMsg(error);
+    return { ...acc, [field]: message };
+}, {}));
+exports.getErrors = getErrors;
+const validate = (ajv, pProps) => {
+    const { methodOptions, request } = pProps;
+    const requestData = getRequestData(request);
+    const schemaData = (0, route_schema_1.default)(methodOptions);
+    const dataSlots = Object.keys(schemaData);
+    const validatedRequest = dataSlots.reduce((accu, dataSlot) => {
+        const schema = schemaData[dataSlot];
+        const data = requestData[dataSlot];
+        const ajvValidate = ajv.compile({ type: 'object', ...schema });
+        const valid = ajvValidate(data);
+        ajv.removeSchema(schema.$id);
+        if (valid)
+            return accu;
+        return [...accu, ...ajvValidate.errors];
+    }, []);
+    return validatedRequest;
+};
+exports.validate = validate;

package/validator/validator.test.js

@@ -0,0 +1,6 @@
+"use strict";
+describe('Validator Test', () => {
+    it('Converts cany case to word', () => {
+        expect(1).toBe(1);
+    });
+});