configurapi 1.7.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/{src → dist/entities}/identity.js

@@ -1,100 +1,68 @@
-let Dictionary = require('./dict');
-
-module.exports = class Identity 
-{
-    get claims()
-    {
+"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)
-    {
+    set claims(value) {
         this._claims = value;
-        
         this._claimsTable.clear();
-
-        for(let claim of this._claims)
-        {
+        for (let claim of this._claims) {
             let scopes = Array.isArray(claim.scope) ? claim.scope : [claim.scope];
-
-            for(let scope of scopes)
-            {
+            for (let scope of scopes) {
                 this._claimsTable.set(this.getClaimId(claim.type, claim.value, scope), claim);
             }
         }
     }
-
-    getClaimId(type, value, scope)
-    {
+    getClaimId(type, value, scope) {
         return `${scope || ''}::${type || ''}::${value || ''}`;
     }
-
-    constructor(id, claims = [])
-    {
-        this._claims = [];
-        this._claimsTable = new Dictionary();
-
-        this.id = id;
-        this.claims = claims;
-        this.issuer = undefined;
-        this.name = undefined;
-        this.email = undefined;
-    }
-
-    hasClaim(type, valueOrValues, scopeOrScopes)
-    {
-        if(!this.claims) return false;
-
+    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)))
-                {
+        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;
-
+    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 [];
-
+    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) 
-            {
+        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))
-            {
+            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;
+}