configurapi 2.0.0 → 2.0.1

package/dist/configurapi.d.ts

@@ -0,0 +1,21 @@
+export * from './entities/config';
+export * from './entities/errorResponse';
+export * from './entities/event';
+export * from './entities/identity';
+export * from './entities/policy';
+export * from './entities/policyHandlerLoader';
+export * from './entities/response';
+export * from './entities/route';
+export * from './entities/service';
+export * from './entities/request';
+export * from './interfaces/iClaim';
+export * from './interfaces/iEvent';
+export * from './interfaces/iIdentity';
+export * from './interfaces/iRequest';
+export * from './interfaces/iResponse';
+export * from './interfaces/iService';
+export * from './interfaces/iServiceListener';
+export * from './interfaces/logLevel';
+export * from './interfaces/result';
+export * from './interfaces/iRoute';
+export * from './interfaces/iPolicy';

package/dist/configurapi.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entities/config"), exports);
+__exportStar(require("./entities/errorResponse"), exports);
+__exportStar(require("./entities/event"), exports);
+__exportStar(require("./entities/identity"), exports);
+__exportStar(require("./entities/policy"), exports);
+__exportStar(require("./entities/policyHandlerLoader"), exports);
+__exportStar(require("./entities/response"), exports);
+__exportStar(require("./entities/route"), exports);
+__exportStar(require("./entities/service"), exports);
+__exportStar(require("./entities/request"), exports);
+__exportStar(require("./interfaces/iClaim"), exports);
+__exportStar(require("./interfaces/iEvent"), exports);
+__exportStar(require("./interfaces/iIdentity"), exports);
+__exportStar(require("./interfaces/iRequest"), exports);
+__exportStar(require("./interfaces/iResponse"), exports);
+__exportStar(require("./interfaces/iService"), exports);
+__exportStar(require("./interfaces/iServiceListener"), exports);
+__exportStar(require("./interfaces/logLevel"), exports);
+__exportStar(require("./interfaces/result"), exports);
+__exportStar(require("./interfaces/iRoute"), exports);
+__exportStar(require("./interfaces/iPolicy"), exports);

package/dist/entities/config.d.ts

@@ -0,0 +1,20 @@
+import { IConfig } from '../interfaces/iConfig';
+import { IPolicy } from '../interfaces/iPolicy';
+import { IRoute } from '../interfaces/iRoute';
+import { IYamlApi, IYamlConfig } from '../interfaces/iYamlConfig';
+export declare class Config implements IConfig {
+    modules: string[];
+    events: Map<String, IRoute>;
+    constructor(modules?: string[], events?: Map<String, IRoute>);
+    static getPathParentDir(path: any): string;
+    static load(path: string): IConfig;
+    static parse(content: string, parentDirectory?: string): IConfig;
+    static parseImport(document: object, parentDirectory?: string): string[];
+    static parseApi(document: Partial<IYamlConfig>): Map<String, IRoute>;
+    static parseRoutes(api: IYamlApi): Map<String, IRoute>;
+    static parseRoute(route: IRoute, routeIndex: number): IRoute;
+    static parsePolicies(route: IRoute, routeName: string): IPolicy[];
+    static parsePolicy(policy: IPolicy, routeName: string, policyIndex: number): IPolicy;
+    static parsePolicyName(policy: IPolicy): string;
+    static parseParameter(policy: IPolicy, policyName: string): any[];
+}

package/dist/entities/config.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const fs_1 = require("fs");
+const js_yaml_1 = require("js-yaml");
+const NestedError = require("nested-error-stacks");
+const path_1 = require("path");
+const logLevel_1 = require("../interfaces/logLevel");
+const policy_1 = require("./policy");
+const route_1 = require("./route");
+class Config {
+    constructor(modules = [], events = new Map()) {
+        this.modules = modules;
+        this.events = events;
+    }
+    static getPathParentDir(path) {
+        if (!path_1.isAbsolute(path)) {
+            path = path_1.resolve(process.cwd(), path);
+        }
+        return path_1.parse(path).dir;
+    }
+    static load(path) {
+        let content = "";
+        try {
+            content = fs_1.readFileSync(path, 'utf8');
+        }
+        catch (error) {
+            throw new NestedError(`Failed to load '${path}'`, error);
+        }
+        return this.parse(content, this.getPathParentDir(path));
+    }
+    static parse(content, parentDirectory) {
+        let document = js_yaml_1.load(content);
+        if (document instanceof Object) {
+            return new Config(this.parseImport(document, parentDirectory), this.parseApi(document));
+        }
+        else {
+            throw new Error("The specified config file is not an invalid yaml.");
+        }
+    }
+    static parseImport(document, parentDirectory) {
+        let result = [];
+        //Check for an optional "import"
+        if ('import' in document) {
+            if (typeof document['import'][Symbol.iterator] !== 'function') {
+                throw new Error(`Could not load 'import.${document['import']}' in the config document`);
+            }
+            for (let module of document['import']) {
+                if (module.startsWith('.')) {
+                    module = path_1.resolve(parentDirectory, module);
+                }
+                result.push(module);
+            }
+        }
+        return result;
+    }
+    static parseApi(document) {
+        if ('api' in document) {
+            return this.parseRoutes(document.api);
+        }
+        else {
+            throw new Error('Could not find \'api\' in the config document');
+        }
+    }
+    static parseRoutes(api) {
+        if ((api instanceof Object) && 'events' in api) {
+            let result = new Map();
+            if (typeof api.events[Symbol.iterator] !== 'function') {
+                throw new Error(`Events could not be empty in the config document.`);
+            }
+            let routeIndex = 0;
+            for (let r of api.events) {
+                let route = this.parseRoute(r, routeIndex);
+                if (route.enabled) {
+                    result.set(route.name, route);
+                }
+            }
+            return result;
+        }
+        else {
+            throw new Error('Could not find \'api.events\' in the config document');
+        }
+    }
+    static parseRoute(route, routeIndex) {
+        let result = new route_1.Route();
+        if (route instanceof Object && 'name' in route) {
+            result.name = route.name;
+            result.logLevel = logLevel_1.LogLevel[Object.keys(logLevel_1.LogLevel).find(key => key.toLowerCase() === (route.logLevel || logLevel_1.LogLevel.Trace).toLowerCase())];
+            if (route.when) {
+                if (process.env.NODE_ENV === undefined) {
+                    result.enabled = false;
+                }
+                else {
+                    result.enabled = process.env.NODE_ENV === route.when;
+                }
+            }
+            result.policies = this.parsePolicies(route, result.name);
+            return result;
+        }
+        else {
+            throw new Error(`Could not find 'api.events[${routeIndex}].name' in the config document`);
+        }
+    }
+    static parsePolicies(route, routeName) {
+        let result = [];
+        if (route instanceof Object && 'policies' in route) {
+            let policyIndex = 0;
+            if (typeof route.policies[Symbol.iterator] !== 'function') {
+                throw new Error(`Policies 'api.events[${routeName}].policies' could not be empty in the config document.`);
+            }
+            for (let policy of route.policies) {
+                result.push(this.parsePolicy(policy, routeName, policyIndex));
+            }
+            return result;
+        }
+        else {
+            throw new Error(`Could not find 'api.events[${routeName}].policies' in the config document`);
+        }
+    }
+    static parsePolicy(policy, routeName, policyIndex) {
+        let policyName = this.parsePolicyName(policy);
+        if (!policyName) {
+            throw new Error(`Could not find 'api.events[${routeName}].policies[${policyIndex}]' in the config document`);
+        }
+        return new policy_1.Policy({
+            name: policyName,
+            parameters: this.parseParameter(policy, policyName),
+            logLevel: policy.logLevel || logLevel_1.LogLevel.Trace
+        });
+    }
+    static parsePolicyName(policy) {
+        if (typeof policy == 'string') {
+            return policy;
+        }
+        for (var key in policy) {
+            if (policy.hasOwnProperty(key)) {
+                return key;
+            }
+            return undefined;
+        }
+    }
+    static parseParameter(policy, policyName) {
+        if (policy[policyName] instanceof Array) {
+            return policy[policyName];
+        }
+        return policy.parameters || [];
+    }
+}
+exports.Config = Config;

package/dist/entities/errorResponse.d.ts

@@ -0,0 +1,9 @@
+import { IErrorResponse } from "../interfaces/iErrorResponse";
+import { Response } from "./response";
+export declare class ErrorResponse extends Response implements IErrorResponse {
+    error: Error | ErrorResponse | string;
+    message: Error | ErrorResponse | any;
+    details: string;
+    constructor(message: Error | ErrorResponse | any, statusCode?: number, details?: string);
+    static isErrorResponse(obj: any): boolean;
+}

package/dist/entities/errorResponse.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorResponse = void 0;
+const response_1 = require("./response");
+class ErrorResponse extends response_1.Response {
+    constructor(message, statusCode = 500, details = '') {
+        super('', statusCode, { 'Content-Type': 'application/json' });
+        this.error = message;
+        this.message = message;
+        this.details = details;
+        if (message instanceof ErrorResponse) {
+            let e = message;
+            this.message = e.message;
+            this.details = e.details;
+            this.statusCode = e.statusCode;
+        }
+        else if (message instanceof Error) {
+            this.message = message.message;
+            this.details = message.stack;
+        }
+        else {
+            this.message = message;
+            this.details = details;
+        }
+        this.body = { 'statusCode': this.statusCode, 'message': this.message, 'details': this.details };
+    }
+    static isErrorResponse(obj) {
+        return typeof obj === 'object' && 'statusCode' in obj && 'error' in obj && 'message' in obj && 'details' in obj && 'body' in obj;
+    }
+}
+exports.ErrorResponse = ErrorResponse;

package/dist/entities/event.d.ts

@@ -0,0 +1,22 @@
+import { IIdentity } from '../configurapi';
+import { IEvent } from '../interfaces/iEvent';
+import { IRequest } from '../interfaces/iRequest';
+import { IResponse } from '../interfaces/iResponse';
+export declare class Event implements IEvent {
+    #private;
+    id: string;
+    params: Record<string, any>;
+    name: string;
+    request: Partial<IRequest>;
+    response: Partial<IResponse>;
+    method: string;
+    version: string;
+    correlationId: string;
+    identity: IIdentity;
+    payload: string | Record<string, any> | undefined;
+    constructor(request?: Partial<IRequest>);
+    objectToString(o: any, s: any): string;
+    resolve(obj: any): any;
+    resolveStr(str: any): any;
+    toString(): string;
+}

package/dist/entities/event.js

@@ -0,0 +1,154 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _versionRegExp;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const inflection_1 = require("inflection");
+const uuid_1 = require("uuid");
+const response_1 = require("./response");
+class Event {
+    constructor(request) {
+        _versionRegExp.set(this, void 0);
+        this.id = uuid_1.v4();
+        if ('query' in request && 'correlationid' in request.query) {
+            this.correlationId = request.query['correlationid'].toString();
+        }
+        else if ('headers' in request && 'correlation-id' in request.headers) {
+            this.correlationId = request.headers['correlation-id'];
+        }
+        else {
+            this.correlationId = this.id;
+        }
+        __classPrivateFieldSet(this, _versionRegExp, new RegExp("^v\\d+(\\.\\d+)*$"));
+        this.params = {};
+        this.name = request.name || "";
+        this.request = request;
+        this.response = new response_1.Response();
+        this.identity = undefined;
+        this.payload = this.request.payload;
+        this.method = request.method;
+        let segments = request.path.split("/").filter(Boolean);
+        if (segments.length === 0)
+            return;
+        //Extract version, if any.
+        if (__classPrivateFieldGet(this, _versionRegExp).test(segments[0])) {
+            this.version = segments[0];
+            segments = segments.slice(1);
+        }
+        //Extract resource-resourceId pair.
+        for (let i = 0, end = segments.length; i < end; i += 2) {
+            let resource;
+            let resourceId = '';
+            if (i < end) {
+                resource = segments[i];
+            }
+            if (i + 1 < end) {
+                resourceId = segments[i + 1];
+            }
+            if (resource.length === 0)
+                break;
+            let singularizedResource = inflection_1.singularize(resource);
+            //Change 'get' to 'list'
+            if (!resourceId && this.method == 'get') {
+                this.method = 'list';
+            }
+            else {
+                resource = singularizedResource;
+            }
+            this.params[singularizedResource] = resourceId;
+            this.name += `_${resource}`;
+        }
+        for (let key in request.query) {
+            this.params[key] = request.query[key];
+        }
+        this.name = this.method + (this.version ? `_${this.version}` : "") + this.name;
+    }
+    objectToString(o, s) {
+        s = s.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
+        s = s.replace(/^\./, ''); // strip a leading dot
+        var a = s.split('.');
+        for (var i = 0, n = a.length; i < n; ++i) {
+            var k = a[i];
+            if (k in o) {
+                o = o[k];
+            }
+            else {
+                return;
+            }
+        }
+        return o;
+    }
+    resolve(obj) {
+        if (typeof obj === 'string') {
+            return this.resolveStr(obj);
+        }
+        else if (typeof obj === 'object') {
+            for (let property in obj) {
+                obj[property] = this.resolve(obj[property]);
+            }
+            return obj;
+        }
+        else {
+            return obj;
+        }
+    }
+    resolveStr(str) {
+        let regex = /\$\([^\)]*\)/g;
+        let matches = str.match(regex);
+        if (!matches) {
+            return str;
+        }
+        for (let match of matches) {
+            let key = match.substr(2, match.length - 3);
+            let value = undefined;
+            if (key.startsWith('$env.')) {
+                //handle environment variables
+                let variableName = key.substr(5);
+                value = process.env[variableName];
+            }
+            else if (key.startsWith('$event.payload.') && this.payload) {
+                //handle environment variables
+                let path = key.substr(15);
+                value = this.objectToString(this.payload, path);
+            }
+            else if (key === '$event.payload' && this.payload) {
+                value = this.payload;
+            }
+            else if (this.params[key] !== undefined) {
+                value = this.params[key];
+            }
+            else if (key.indexOf('.') !== -1 || key.indexOf('[') !== -1) {
+                //handle resolving object using string path such as obj.prop.subprop.list[0]
+                let index = key.indexOf('.');
+                let objSection = key.substr(0, index);
+                let propSection = key.substr(index + 1);
+                value = this.params[objSection];
+                if (typeof value === 'object') {
+                    value = this.objectToString(value, propSection);
+                }
+            }
+            if (value === undefined) {
+                value = match;
+            }
+            str = str.replace(match, value);
+        }
+        return str;
+    }
+    toString() {
+        return `${this.name}(${Object.values(this.params)})`;
+    }
+}
+exports.Event = Event;
+_versionRegExp = new WeakMap();

package/dist/entities/identity.d.ts

@@ -0,0 +1,17 @@
+import { IClaim } from '../interfaces/iClaim';
+import { IIdentity } from '../interfaces/iIdentity';
+export declare class Identity implements IIdentity {
+    private _claims;
+    private _claimsTable;
+    id: string;
+    issuer: string;
+    name: string;
+    email: string;
+    get claims(): Partial<IClaim>[];
+    set claims(value: Partial<IClaim>[]);
+    getClaimId(type: string, value: string, scope: string): string;
+    constructor(identity?: Partial<IIdentity>);
+    hasClaim(type: string, valueOrValues: string | string[], scopeOrScopes?: string | string[]): boolean;
+    getClaim(type: string, value: string, scope?: string): Partial<IClaim>;
+    getClaims(type: string, value: string, scope?: string): IClaim[];
+}

package/dist/entities/identity.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Identity = void 0;
+class Identity {
+    constructor(identity) {
+        this._claims = [];
+        this._claimsTable = new Map();
+        this.id = identity?.id;
+        this.claims = identity?.claims || [];
+        this.issuer = identity?.issuer;
+        this.name = identity?.name;
+        this.email = identity?.email;
+    }
+    get claims() {
+        return this._claims;
+    }
+    set claims(value) {
+        this._claims = value;
+        this._claimsTable.clear();
+        for (let claim of this._claims) {
+            let scopes = Array.isArray(claim.scope) ? claim.scope : [claim.scope];
+            for (let scope of scopes) {
+                this._claimsTable.set(this.getClaimId(claim.type, claim.value, scope), claim);
+            }
+        }
+    }
+    getClaimId(type, value, scope) {
+        return `${scope || ''}::${type || ''}::${value || ''}`;
+    }
+    hasClaim(type, valueOrValues, scopeOrScopes) {
+        if (!this.claims)
+            return false;
+        let values = Array.isArray(valueOrValues) ? [...new Set(valueOrValues)] : [valueOrValues];
+        let scopes = Array.isArray(scopeOrScopes) ? [...new Set(scopeOrScopes)] : [scopeOrScopes];
+        for (let value of values) {
+            for (let scope of scopes) {
+                if (this._claimsTable.has(this.getClaimId(type, value, scope))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    getClaim(type, value, scope) {
+        if (!this._claimsTable.has(this.getClaimId(type, value, scope)))
+            return undefined;
+        return this._claimsTable.get(this.getClaimId(type, value, scope));
+    }
+    getClaims(type, value, scope) {
+        if (!this.claims)
+            return [];
+        let result = [];
+        let matchingTypeValueClaims = this.claims.filter((c) => c.type === type && c.value === value);
+        for (let claim of matchingTypeValueClaims) {
+            if (claim.scope === scope) {
+                result.push(claim);
+                continue;
+            }
+            //For arrays
+            let scopes = Array.isArray(claim.scope) ? claim.scope : [claim.scope];
+            if (scopes.includes(scope)) {
+                result.push(claim);
+            }
+        }
+        return result;
+    }
+}
+exports.Identity = Identity;

package/dist/entities/policy.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { IEvent, Result } from '../configurapi';
+import { IPolicy } from '../interfaces/iPolicy';
+import { LogLevel } from '../interfaces/logLevel';
+export declare class Policy extends EventEmitter implements IPolicy {
+    name: string;
+    parameters: any[];
+    logLevel: LogLevel;
+    handler: Function;
+    constructor(policy?: Partial<IPolicy>);
+    process(event: IEvent): Promise<Result>;
+}

package/dist/entities/policy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Policy = void 0;
+const events_1 = require("events");
+const configurapi_1 = require("../configurapi");
+const logLevel_1 = require("../interfaces/logLevel");
+class Policy extends events_1.EventEmitter {
+    constructor(policy) {
+        super();
+        this.name = policy?.name || "";
+        this.parameters = policy?.parameters || [];
+        this.logLevel = policy?.logLevel || logLevel_1.LogLevel.Trace;
+        this.handler = policy?.handler || undefined;
+    }
+    async process(event) {
+        let state = configurapi_1.Result.Continue;
+        let context = {
+            'continue': () => state = configurapi_1.Result.Continue,
+            'complete': () => state = configurapi_1.Result.Completed,
+            'catch': (error) => { throw error; },
+            'emit': (level, message) => this.emit(level, `${event.id} - ${event.correlationId} - ${message}`)
+        };
+        let handlerParams = this.parameters instanceof Array ? this.parameters.slice(0) : [];
+        handlerParams.unshift(event);
+        try {
+            await this.handler.apply(context, handlerParams);
+            return state;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+exports.Policy = Policy;

package/dist/entities/policyHandlerLoader.d.ts

@@ -0,0 +1,11 @@
+import { FunctionType, IPolicyHandlerLoader } from '../interfaces/iPolicyHandlerLoader';
+export declare class PolicyHandlerLoader implements IPolicyHandlerLoader {
+    handlers: Map<String, FunctionType>;
+    constructor(handlers?: Map<String, FunctionType>);
+    get(handlerName: string): Function;
+    load(moduleOrFileName: string): void;
+    loadCustomHandlers(directory: string): void;
+    private resolve;
+    loadHandler(obj: any): void;
+    private isHandler;
+}

package/dist/entities/policyHandlerLoader.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyHandlerLoader = void 0;
+const fs_1 = require("fs");
+const NestedError = require("nested-error-stacks");
+const path_1 = require("path");
+class PolicyHandlerLoader {
+    constructor(handlers = new Map()) {
+        this.handlers = handlers;
+    }
+    get(handlerName) {
+        if (this.handlers.has(handlerName)) {
+            return this.handlers.get(handlerName);
+        }
+        else {
+            throw new Error(`Handler '${handlerName}' could not be found.`);
+        }
+    }
+    load(moduleOrFileName) {
+        let exports = this.resolve(moduleOrFileName);
+        if (!exports) {
+            throw new Error(`Cannot find '${moduleOrFileName}'.`);
+        }
+        this.loadHandler(exports);
+    }
+    loadCustomHandlers(directory) {
+        const absoultePath = path_1.resolve(process.cwd(), directory);
+        try {
+            let paths = fs_1.readdirSync(absoultePath);
+            for (const path of paths) {
+                let filePath = `${absoultePath}/${path}`;
+                let stat = fs_1.lstatSync(filePath);
+                if (stat.isFile() && path.match(/\.[jt]s$/i) !== null) {
+                    this.load(absoultePath + "/" + path.replace(/\.[jt]s$/i, ''));
+                }
+            }
+        }
+        catch (error) {
+            throw new NestedError(`Could not load '${absoultePath}'`, error);
+        }
+    }
+    resolve(path) {
+        try {
+            return require(path);
+        }
+        catch (e) {
+            throw new NestedError(`Failed to load ${path}`, e);
+        }
+    }
+    loadHandler(obj) {
+        if (typeof obj === "function") {
+            this.handlers.set(obj.name, obj);
+        }
+        else {
+            for (let key in obj) {
+                if (this.isHandler(obj, key)) {
+                    this.handlers.set(key, obj[key]);
+                }
+            }
+        }
+    }
+    isHandler(obj, key) {
+        return (typeof obj[key] === "function") && key.match(/handler$/i) !== null;
+    }
+}
+exports.PolicyHandlerLoader = PolicyHandlerLoader;

package/dist/entities/request.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { ParsedUrlQuery } from "querystring";
+import { IRequest } from "../interfaces/iRequest";
+export declare class Request implements IRequest {
+    name: string;
+    method: string;
+    headers: Record<string, string>;
+    params: Record<string, string>;
+    payload: string | Record<string, any> | undefined;
+    query: ParsedUrlQuery | undefined;
+    path: string | undefined;
+    pathAndQuery: string;
+    constructor(method: any);
+}

package/dist/entities/request.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+class Request {
+    constructor(method) {
+        this.name = undefined;
+        this.method = (method || "get").toLowerCase();
+        this.headers = {};
+        this.params = {};
+        this.payload = "";
+        this.query = {};
+        this.path = "";
+        this.pathAndQuery = "";
+    }
+}
+exports.Request = Request;

package/dist/entities/response.d.ts

@@ -0,0 +1,7 @@
+import { IResponse } from '../interfaces/iResponse';
+export declare class Response implements IResponse {
+    body: any;
+    statusCode: number;
+    headers: Record<string, string>;
+    constructor(body?: any, statusCode?: number, headers?: Record<string, string>);
+}

package/dist/entities/response.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+class Response {
+    constructor(body = "", statusCode = 200, headers = {}) {
+        this.body = body;
+        this.statusCode = statusCode;
+        this.headers = headers;
+        this.statusCode = statusCode;
+        this.body = body;
+        this.headers = headers;
+    }
+}
+exports.Response = Response;

package/dist/entities/route.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { IEvent } from '../interfaces/iEvent';
+import { IPolicy } from '../interfaces/iPolicy';
+import { IRoute } from '../interfaces/iRoute';
+import { LogLevel } from '../interfaces/logLevel';
+export declare class Route extends EventEmitter implements IRoute {
+    name: string;
+    when: string;
+    enabled: boolean;
+    policies: IPolicy[];
+    logLevel: LogLevel;
+    constructor(route?: Partial<IRoute>);
+    process(event: IEvent): Promise<void>;
+}

package/dist/entities/route.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+const events_1 = require("events");
+const logLevel_1 = require("../interfaces/logLevel");
+const result_1 = require("../interfaces/result");
+const perf_hooks_1 = require("perf_hooks");
+class Route extends events_1.EventEmitter {
+    constructor(route) {
+        super();
+        this.name = route?.name || '';
+        this.enabled = route?.enabled || true;
+        this.policies = route?.policies || [];
+        this.logLevel = route?.logLevel;
+        this.when = route?.when;
+    }
+    async process(event) {
+        for (let policy of this.policies) {
+            let startTime = perf_hooks_1.performance.now();
+            try {
+                const result = await policy.process(event);
+                if (result === result_1.Result.Completed) {
+                    break;
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+            finally {
+                let endTime = perf_hooks_1.performance.now();
+                if (logLevel_1.LogLevel.gte(policy.logLevel, logLevel_1.LogLevel.Trace)) {
+                    this.emit(logLevel_1.LogLevel.Trace, `${event.id} - ${event.correlationId} - Executed ${policy.name} policy [${endTime - startTime}ms]`);
+                }
+            }
+        }
+    }
+}
+exports.Route = Route;

package/dist/entities/service.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { IConfig } from '../interfaces/iConfig';
+import { IEvent } from '../interfaces/iEvent';
+import { IPolicyHandlerLoader } from '../interfaces/iPolicyHandlerLoader';
+import { IService } from '../interfaces/iService';
+import { LogLevel } from '../interfaces/logLevel';
+export declare class Service extends EventEmitter implements IService {
+    private config;
+    private loader;
+    isReady: boolean;
+    onStartPromise: Promise<boolean>;
+    constructor(config: IConfig, loader?: IPolicyHandlerLoader);
+    configureLogs(svc: EventEmitter & {
+        logLevel: LogLevel;
+    }): void;
+    process(event: IEvent): Promise<void>;
+    _handleEvent(eventName: string, event?: IEvent): Promise<boolean>;
+    _handleError(event: IEvent, error: object): Promise<void>;
+}

package/dist/entities/service.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const events_1 = require("events");
+const fs_1 = require("fs");
+const oneliner = require("one-liner");
+const perf_hooks_1 = require("perf_hooks");
+const logLevel_1 = require("../interfaces/logLevel");
+const errorResponse_1 = require("./errorResponse");
+const policyHandlerLoader_1 = require("./policyHandlerLoader");
+class Service extends events_1.EventEmitter {
+    constructor(config, loader = new policyHandlerLoader_1.PolicyHandlerLoader()) {
+        super();
+        this.config = config;
+        this.loader = loader;
+        this.isReady = false;
+        for (let module of this.config.modules) {
+            this.loader.load(module);
+        }
+        let customHandlerPath = 'handlers';
+        if (fs_1.existsSync(customHandlerPath)) {
+            this.loader.loadCustomHandlers(customHandlerPath);
+        }
+        else {
+            this.emit(logLevel_1.LogLevel.Trace, `configurapi -  - Warning. Custom handlers directory does not exist.`);
+        }
+        for (let route of this.config.events.values()) {
+            for (let policy of route.policies) {
+                policy.handler = loader.get(policy.name);
+                policy.logLevel = policy.logLevel || route.logLevel;
+                this.configureLogs(policy);
+            }
+            this.configureLogs(route);
+            this.emit(logLevel_1.LogLevel.Trace, `configurapi -  - Registerd ${route.name} route.`);
+        }
+        this.onStartPromise = this._handleEvent('on_start');
+    }
+    configureLogs(svc) {
+        for (const level of [logLevel_1.LogLevel.Trace, logLevel_1.LogLevel.Debug, logLevel_1.LogLevel.Error]) {
+            if (logLevel_1.LogLevel.gte(svc.logLevel, level))
+                svc.on(level, (msg) => this.emit(level, oneliner(msg)));
+        }
+    }
+    async process(event) {
+        if (!this.isReady) {
+            await this.onStartPromise;
+            this.isReady = true;
+        }
+        let startTime = perf_hooks_1.performance.now();
+        try {
+            await this._handleEvent('on_before_request', event);
+            if (await this._handleEvent(event.name, event) || await this._handleEvent(event.method, event)) {
+                //Great
+            }
+            else if (await this._handleEvent('catchall', event)) {
+                //Great
+            }
+            else {
+                throw new errorResponse_1.ErrorResponse('Not Implemented.', 501, `Route for '${event.name}' event could not be found.'`);
+            }
+            if (event.response && event.response instanceof errorResponse_1.ErrorResponse) {
+                throw event.response;
+            }
+            await this._handleEvent('on_success', event);
+        }
+        catch (error) {
+            await this._handleError(event, error);
+        }
+        finally {
+            try {
+                await this._handleEvent('on_after_request', event);
+            }
+            catch (error) {
+                await this._handleError(event, error);
+            }
+            let endTime = perf_hooks_1.performance.now();
+            let route = this.config.events.get(event.name);
+            if (route) {
+                if (logLevel_1.LogLevel.gte(route.logLevel, logLevel_1.LogLevel.Trace)) {
+                    this.emit(logLevel_1.LogLevel.Trace, `${event.id} - ${event.correlationId} - Handled ${event.name} [${endTime - startTime}ms]`);
+                }
+            }
+        }
+    }
+    async _handleEvent(eventName, event) {
+        let result = false;
+        if (this.config.events.has(eventName)) {
+            await this.config.events.get(eventName).process(event);
+            result = true;
+        }
+        return result;
+    }
+    async _handleError(event, error) {
+        if (error instanceof Error) {
+            this.emit(logLevel_1.LogLevel.Error, `${event.id} - ${event.correlationId} - Failed to handle ${event.name}: ${error.message}`);
+            event.response = new errorResponse_1.ErrorResponse(error, error['statusCode'] || 500);
+        }
+        else if (error instanceof errorResponse_1.ErrorResponse || errorResponse_1.ErrorResponse.isErrorResponse(error)) {
+            this.emit(logLevel_1.LogLevel.Error, `${event.id} - ${event.correlationId} - Failed to handle ${event.name}: ${error.error}`);
+            event.response = error;
+        }
+        else {
+            this.emit(logLevel_1.LogLevel.Error, `${event.id} - ${event.correlationId} - Failed to handle ${event.name}: ${error === undefined ? 'undefined' : error.toString()}`);
+            event.response = new errorResponse_1.ErrorResponse("Internal Server Error", 500, error.toString());
+        }
+        if (this.config.events.has('on_error')) {
+            try {
+                this.emit(logLevel_1.LogLevel.Error, `${event.id} - ${event.correlationId} - Failed to handle ${event.name}: ${error}`);
+                await this._handleEvent('on_error', event);
+            }
+            catch (reason) {
+                this.emit(logLevel_1.LogLevel.Error, `${event.id} - ${event.correlationId} - ${reason}`);
+            }
+            return;
+        }
+    }
+}
+exports.Service = Service;

package/dist/interfaces/iClaim.d.ts

@@ -0,0 +1,6 @@
+export interface IClaim {
+    type: string;
+    value: string;
+    scope: string | string[];
+    readonly scopes: string[];
+}

package/dist/interfaces/iClaim.js

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

package/dist/interfaces/iConfig.d.ts

@@ -0,0 +1,5 @@
+import { IRoute } from './iRoute';
+export interface IConfig {
+    modules: string[];
+    events: Map<String, IRoute>;
+}

package/dist/interfaces/iConfig.js

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

package/dist/interfaces/iErrorResponse.d.ts

@@ -0,0 +1,5 @@
+import { IResponse } from "./iResponse";
+export interface IErrorResponse extends IResponse {
+    message: Error | IResponse | string;
+    details: string;
+}

package/dist/interfaces/iErrorResponse.js

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

package/dist/interfaces/iEvent.d.ts

@@ -0,0 +1,16 @@
+import { IIdentity } from "./iIdentity";
+import { IRequest } from "./iRequest";
+import { IResponse } from "./iResponse";
+export interface IEvent {
+    id: string;
+    correlationId: string;
+    params: Record<string, any>;
+    name: string;
+    request: Partial<IRequest>;
+    response: Partial<IResponse>;
+    method: string;
+    version: string;
+    identity: IIdentity;
+    payload: Record<string, any> | string | undefined;
+    resolve(str: string): string;
+}

package/dist/interfaces/iEvent.js

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

package/dist/interfaces/iIdentity.d.ts

@@ -0,0 +1,11 @@
+import { IClaim } from './iClaim';
+export interface IIdentity {
+    id: string;
+    issuer: string;
+    name: string;
+    email: string;
+    claims: Partial<IClaim>[];
+    hasClaim(type: string, valueOrValues: string | string[], scopeOrScopes?: string | string[]): boolean;
+    getClaim(type: string, value: string, scope?: string): Partial<IClaim>;
+    getClaims(type: string, value: string, scope?: string): IClaim[];
+}

package/dist/interfaces/iIdentity.js

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

package/dist/interfaces/iPolicy.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import EventEmitter = require("events");
+import { IEvent } from "./iEvent";
+import { LogLevel } from "./logLevel";
+import { Result } from "./result";
+export interface IPolicy extends EventEmitter {
+    name: string;
+    parameters: any[];
+    logLevel: LogLevel;
+    handler: Function;
+    process(event: IEvent): Promise<Result>;
+}

package/dist/interfaces/iPolicy.js

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

package/dist/interfaces/iPolicyHandlerLoader.d.ts

@@ -0,0 +1,7 @@
+export declare type FunctionType = (...args: any[]) => any | Function;
+export interface IPolicyHandlerLoader {
+    handlers: Map<String, FunctionType>;
+    loadCustomHandlers(handler: string): void;
+    load(moduleOrFileName: string): void;
+    get(handlerName: string): Function;
+}

package/dist/interfaces/iPolicyHandlerLoader.js

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

package/dist/interfaces/iRequest.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { ParsedUrlQuery } from "querystring";
+export interface IRequest {
+    name: string;
+    method: string;
+    headers: Record<string, string>;
+    params: Record<string, string>;
+    payload: string | Record<string, any> | undefined;
+    query: ParsedUrlQuery | undefined;
+    path: string | undefined;
+    pathAndQuery: string;
+}

package/dist/interfaces/iRequest.js

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

package/dist/interfaces/iResponse.d.ts

@@ -0,0 +1,5 @@
+export interface IResponse {
+    body: any;
+    statusCode: number;
+    headers: Record<string, string>;
+}

package/dist/interfaces/iResponse.js

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

package/dist/interfaces/iRoute.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { IEvent } from './iEvent';
+import { IPolicy } from './iPolicy';
+import { LogLevel } from './logLevel';
+export interface IRoute extends EventEmitter {
+    name: string;
+    when: string;
+    enabled: boolean;
+    policies: IPolicy[];
+    logLevel: LogLevel;
+    process(event: IEvent): Promise<void>;
+}

package/dist/interfaces/iRoute.js

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

package/dist/interfaces/iService.d.ts

@@ -0,0 +1,6 @@
+import { IEvent } from "./iEvent";
+import { IServiceListener } from "./iServiceListener";
+export interface IService {
+    on(type: string, listener: IServiceListener): void;
+    process(event: IEvent): Promise<void>;
+}

package/dist/interfaces/iService.js

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

package/dist/interfaces/iServiceListener.d.ts

@@ -0,0 +1,3 @@
+export interface IServiceListener {
+    (data: string): void;
+}

package/dist/interfaces/iServiceListener.js

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

package/dist/interfaces/iYamlConfig.d.ts

@@ -0,0 +1,7 @@
+import { IRoute } from "./iRoute";
+export interface IYamlApi {
+    events: Set<IRoute>;
+}
+export interface IYamlConfig {
+    api: IYamlApi;
+}

package/dist/interfaces/iYamlConfig.js

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

package/dist/interfaces/logLevel.d.ts

@@ -0,0 +1,11 @@
+export declare enum LogLevel {
+    Debug = "debug",
+    Trace = "trace",
+    Info = "info",
+    Warn = "warn",
+    Error = "error",
+    None = "none"
+}
+export declare namespace LogLevel {
+    function gte(l1: LogLevel, l2: LogLevel): boolean;
+}

package/dist/interfaces/logLevel.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Trace"] = "trace";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+    LogLevel["None"] = "none";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+(function (LogLevel) {
+    const LogLevelRank = {
+        [LogLevel.Debug]: 100,
+        [LogLevel.Trace]: 75,
+        [LogLevel.Info]: 25,
+        [LogLevel.Warn]: 50,
+        [LogLevel.Error]: 10,
+        [LogLevel.None]: 1
+    };
+    function gte(l1, l2) {
+        return (LogLevelRank[l1?.toString()] || 0) >= (LogLevelRank[l2?.toString()] || 0);
+    }
+    LogLevel.gte = gte;
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));

package/dist/interfaces/result.d.ts

@@ -0,0 +1,4 @@
+export declare enum Result {
+    Continue = 1,
+    Completed = 2
+}

package/dist/interfaces/result.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = void 0;
+var Result;
+(function (Result) {
+    Result[Result["Continue"] = 1] = "Continue";
+    Result[Result["Completed"] = 2] = "Completed";
+})(Result = exports.Result || (exports.Result = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configurapi",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "A configurable API framework",
   "main": "dist/configurapi.js",
   "typings": "dist/configurapi.d.ts",