@typetron/framework 0.3.17 → 0.3.18

package/Router/Route.d.ts

@@ -1,24 +1,24 @@
-import { Container } from '../Container';
-import { Abstract, Constructor, Type } from '../Support';
-import { MiddlewareInterface } from './Middleware';
-import { Guard } from './Guard';
-export declare class Route {
-    uri: string;
-    method: string;
-    controller: Constructor;
-    action: string;
-    name: string;
-    parametersTypes: (Type<Function> | FunctionConstructor)[];
-    middleware: Abstract<MiddlewareInterface>[];
-    parameters: Record<string, string>;
-    guards: (typeof Guard)[];
-    private readonly uriParts;
-    constructor(uri: string, method: string, controller: Constructor, action: string, name?: string, parametersTypes?: (Type<Function> | FunctionConstructor)[], middleware?: Abstract<MiddlewareInterface>[]);
-    run(container: Container): Promise<object | string>;
-    matches(uri: string): boolean;
-    splitUriParts(): void;
-    getUrl(): string;
-    private resolveParameters;
-    private hasCorrectPrimitiveType;
-}
+import { Container } from '../Container';
+import { Abstract, Constructor, Type } from '../Support';
+import { MiddlewareInterface } from './Middleware';
+import { Guard } from './Guard';
+export declare class Route {
+    uri: string;
+    method: string;
+    controller: Constructor;
+    action: string;
+    name: string;
+    parametersTypes: (Type<Function> | FunctionConstructor)[];
+    middleware: Abstract<MiddlewareInterface>[];
+    parameters: Record<string, string>;
+    guards: (typeof Guard)[];
+    private readonly uriParts;
+    constructor(uri: string, method: string, controller: Constructor, action: string, name?: string, parametersTypes?: (Type<Function> | FunctionConstructor)[], middleware?: Abstract<MiddlewareInterface>[]);
+    run(container: Container): Promise<object | string>;
+    matches(uri: string): boolean;
+    splitUriParts(): void;
+    getUrl(): string;
+    private resolveParameters;
+    private hasCorrectPrimitiveType;
+}
 //# sourceMappingURL=Route.d.ts.map

package/Router/Route.js

@@ -1,111 +1,111 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Route = void 0;
-const Metadata_1 = require("./Metadata");
-class Route {
-    constructor(uri, method, controller, action, name = '', parametersTypes = [], middleware = []) {
-        this.uri = uri;
-        this.method = method;
-        this.controller = controller;
-        this.action = action;
-        this.name = name;
-        this.parametersTypes = parametersTypes;
-        this.middleware = middleware;
-        this.parameters = {};
-        this.guards = [];
-        this.uriParts = [];
-        this.splitUriParts();
-    }
-    async run(container) {
-        const controller = await container.get(this.controller);
-        try {
-            const metadata = Metadata_1.ControllerMetadata.get(this.controller).routes[this.action];
-            const parameters = await this.resolveParameters(metadata.parametersTypes, metadata.parametersOverrides, container);
-            for await (const guardClass of this.guards) {
-                const guard = container.get(guardClass);
-                if (!await guard.condition(...parameters)) {
-                    guard.onFail();
-                }
-            }
-            return controller[this.action].apply(controller, parameters);
-        }
-        catch (error) {
-            error.stack = `Controller: ${controller.constructor.name}.${this.action} \n at ` + error.stack;
-            throw error;
-        }
-    }
-    matches(uri) {
-        const uriParts = uri.split('/'); // ex: ['users', '1', 'posts'];
-        let part;
-        let parameterTypeIndex = 0;
-        for (part = 0; part < uriParts.length; part++) {
-            if (!this.uriParts[part]) {
-                return false;
-            }
-            if (this.uriParts[part].type === 'parameter' && this.hasCorrectPrimitiveType(parameterTypeIndex, uriParts[part])) {
-                parameterTypeIndex++;
-                this.parameters[this.uriParts[part].name] = uriParts[part];
-                continue;
-            }
-            if (this.uriParts[part].name !== uriParts[part]) {
-                return false;
-            }
-        }
-        if (part !== this.uriParts.length) {
-            return false;
-        }
-        return true;
-    }
-    splitUriParts() {
-        this.uri.split('/').forEach(uriPart => {
-            const matches = uriPart.match(/:(\w+)/);
-            if (matches) {
-                this.uriParts.push({
-                    name: matches[1],
-                    type: 'parameter'
-                });
-            }
-            else {
-                this.uriParts.push({
-                    name: uriPart,
-                    type: 'part'
-                });
-            }
-        });
-    }
-    getUrl() {
-        return this.uriParts.map(part => {
-            if (part.type === 'parameter') {
-                return this.parameters[part.name];
-            }
-            return part.name;
-        }).join('/');
-    }
-    async resolveParameters(parameters, overrides, container) {
-        let parameterIndex = 0;
-        const routeParameters = Object.values(this.parameters);
-        return parameters.mapAsync(async (parameter, index) => {
-            const newValueFunction = overrides[index];
-            if (newValueFunction) {
-                return await newValueFunction.call(undefined, container);
-            }
-            if (parameter.name === 'String') {
-                return routeParameters[parameterIndex++];
-            }
-            if (parameter.name === 'Number') {
-                const value = routeParameters[parameterIndex++];
-                return value === undefined || value === 'undefined' ? undefined : Number(value);
-            }
-            return container.get(parameter);
-        });
-    }
-    hasCorrectPrimitiveType(parameterTypeIndex, uriPart) {
-        const parameterType = this.parametersTypes[parameterTypeIndex];
-        return (primitiveTypes[parameterType.name] || (value => value))(uriPart);
-    }
-}
-exports.Route = Route;
-const primitiveTypes = {
-    Number: (value) => !isNaN(Number(value)),
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+const Metadata_1 = require("./Metadata");
+class Route {
+    constructor(uri, method, controller, action, name = '', parametersTypes = [], middleware = []) {
+        this.uri = uri;
+        this.method = method;
+        this.controller = controller;
+        this.action = action;
+        this.name = name;
+        this.parametersTypes = parametersTypes;
+        this.middleware = middleware;
+        this.parameters = {};
+        this.guards = [];
+        this.uriParts = [];
+        this.splitUriParts();
+    }
+    async run(container) {
+        const controller = await container.get(this.controller);
+        try {
+            const metadata = Metadata_1.ControllerMetadata.get(this.controller).routes[this.action];
+            const parameters = await this.resolveParameters(metadata.parametersTypes, metadata.parametersOverrides, container);
+            for await (const guardClass of this.guards) {
+                const guard = container.get(guardClass);
+                if (!await guard.condition(...parameters)) {
+                    guard.onFail();
+                }
+            }
+            return controller[this.action].apply(controller, parameters);
+        }
+        catch (error) {
+            error.stack = `Controller: ${controller.constructor.name}.${this.action} \n at ` + error.stack;
+            throw error;
+        }
+    }
+    matches(uri) {
+        const uriParts = uri.split('/'); // ex: ['users', '1', 'posts'];
+        let part;
+        let parameterTypeIndex = 0;
+        for (part = 0; part < uriParts.length; part++) {
+            if (!this.uriParts[part]) {
+                return false;
+            }
+            if (this.uriParts[part].type === 'parameter' && this.hasCorrectPrimitiveType(parameterTypeIndex, uriParts[part])) {
+                parameterTypeIndex++;
+                this.parameters[this.uriParts[part].name] = uriParts[part];
+                continue;
+            }
+            if (this.uriParts[part].name !== uriParts[part]) {
+                return false;
+            }
+        }
+        if (part !== this.uriParts.length) {
+            return false;
+        }
+        return true;
+    }
+    splitUriParts() {
+        this.uri.split('/').forEach(uriPart => {
+            const matches = uriPart.match(/:(\w+)/);
+            if (matches) {
+                this.uriParts.push({
+                    name: matches[1],
+                    type: 'parameter'
+                });
+            }
+            else {
+                this.uriParts.push({
+                    name: uriPart,
+                    type: 'part'
+                });
+            }
+        });
+    }
+    getUrl() {
+        return this.uriParts.map(part => {
+            if (part.type === 'parameter') {
+                return this.parameters[part.name];
+            }
+            return part.name;
+        }).join('/');
+    }
+    async resolveParameters(parameters, overrides, container) {
+        let parameterIndex = 0;
+        const routeParameters = Object.values(this.parameters);
+        return parameters.mapAsync(async (parameter, index) => {
+            const newValueFunction = overrides[index];
+            if (newValueFunction) {
+                return await newValueFunction.call(undefined, container);
+            }
+            if (parameter.name === 'String') {
+                return routeParameters[parameterIndex++];
+            }
+            if (parameter.name === 'Number') {
+                const value = routeParameters[parameterIndex++];
+                return value === undefined || value === 'undefined' ? undefined : Number(value);
+            }
+            return container.get(parameter);
+        });
+    }
+    hasCorrectPrimitiveType(parameterTypeIndex, uriPart) {
+        const parameterType = this.parametersTypes[parameterTypeIndex];
+        return (primitiveTypes[parameterType.name] || (value => value))(uriPart);
+    }
+}
+exports.Route = Route;
+const primitiveTypes = {
+    Number: (value) => !isNaN(Number(value)),
+};
 //# sourceMappingURL=Route.js.map

package/Router/RouteNotFoundError.d.ts

@@ -1,4 +1,4 @@
-export declare class RouteNotFoundError extends Error {
-    constructor(path: string);
-}
+export declare class RouteNotFoundError extends Error {
+    constructor(path: string);
+}
 //# sourceMappingURL=RouteNotFoundError.d.ts.map

package/Router/RouteNotFoundError.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteNotFoundError = void 0;
-class RouteNotFoundError extends Error {
-    constructor(path) {
-        super(`Route '${path}' not found`);
-    }
-}
-exports.RouteNotFoundError = RouteNotFoundError;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteNotFoundError = void 0;
+class RouteNotFoundError extends Error {
+    constructor(path) {
+        super(`Route '${path}' not found`);
+    }
+}
+exports.RouteNotFoundError = RouteNotFoundError;
 //# sourceMappingURL=RouteNotFoundError.js.map

package/Router/Router.d.ts

@@ -1,13 +1,13 @@
-import { Container } from '../Container';
-import { Abstract } from '../Support';
-import { MiddlewareInterface } from './Middleware';
-import { Route } from './Route';
-import { WebsocketEvent } from './Websockets/WebsocketEvent';
-export declare class Router {
-    app: Container;
-    routes: Route[];
-    events: Map<string, WebsocketEvent>;
-    middleware: Abstract<MiddlewareInterface>[];
-    loadControllers(directory: string): void;
-}
+import { Container } from '../Container';
+import { Abstract } from '../Support';
+import { MiddlewareInterface } from './Middleware';
+import { Route } from './Route';
+import { WebsocketEvent } from './Websockets/WebsocketEvent';
+export declare class Router {
+    app: Container;
+    routes: Route[];
+    events: Map<string, WebsocketEvent>;
+    middleware: Abstract<MiddlewareInterface>[];
+    loadControllers(directory: string): void;
+}
 //# sourceMappingURL=Router.d.ts.map

package/Router/Router.js

@@ -1,33 +1,33 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = void 0;
-const Container_1 = require("../Container");
-const Storage_1 = require("../Storage");
-class Router {
-    constructor() {
-        this.routes = [];
-        this.events = new Map();
-        this.middleware = [];
-    }
-    loadControllers(directory) {
-        this.app.get(Storage_1.Storage)
-            .files(directory, true)
-            .whereIn('extension', ['ts'])
-            .forEach(file => require(file.path));
-    }
-}
-__decorate([
-    Container_1.Inject(),
-    __metadata("design:type", Container_1.Container)
-], Router.prototype, "app", void 0);
-exports.Router = Router;
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const Container_1 = require("../Container");
+const Storage_1 = require("../Storage");
+class Router {
+    constructor() {
+        this.routes = [];
+        this.events = new Map();
+        this.middleware = [];
+    }
+    loadControllers(directory) {
+        this.app.get(Storage_1.Storage)
+            .files(directory, true)
+            .whereIn('extension', ['ts'])
+            .forEach(file => require(file.path));
+    }
+}
+__decorate([
+    Container_1.Inject(),
+    __metadata("design:type", Container_1.Container)
+], Router.prototype, "app", void 0);
+exports.Router = Router;
 //# sourceMappingURL=Router.js.map

package/Router/Websockets/Handler.d.ts

@@ -1,13 +1,13 @@
-import { Container } from '../../Container';
-import { MiddlewareInterface, Router } from '../../Router';
-import { Request, Response } from '../Http';
-import { Abstract, Constructor, Type } from '../../Support';
-import { WebsocketEvent } from './WebsocketEvent';
-export declare class Handler {
-    router: Router;
-    onOpen?: WebsocketEvent;
-    onClose?: WebsocketEvent;
-    addEvent(name: string, controller: Constructor, action: string, parametersTypes?: (Type<Function> | FunctionConstructor)[], middleware?: Abstract<MiddlewareInterface>[]): WebsocketEvent;
-    handle(container: Container, request: Request): Promise<Response>;
-}
+import { Container } from '../../Container';
+import { MiddlewareInterface, Router } from '../../Router';
+import { Request, Response } from '../Http';
+import { Abstract, Constructor, Type } from '../../Support';
+import { WebsocketEvent } from './WebsocketEvent';
+export declare class Handler {
+    router: Router;
+    onOpen?: WebsocketEvent;
+    onClose?: WebsocketEvent;
+    addEvent(name: string, controller: Constructor, action: string, parametersTypes?: (Type<Function> | FunctionConstructor)[], middleware?: Abstract<MiddlewareInterface>[]): WebsocketEvent;
+    handle(container: Container, request: Request): Promise<Response>;
+}
 //# sourceMappingURL=Handler.d.ts.map

package/Router/Websockets/Handler.js

@@ -1,60 +1,60 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Handler = void 0;
-const Container_1 = require("../../Container");
-const Router_1 = require("../../Router");
-const Http_1 = require("../Http");
-const WebsocketEvent_1 = require("./WebsocketEvent");
-class Handler {
-    addEvent(name, controller, action, parametersTypes = [], middleware = []) {
-        const event = new WebsocketEvent_1.WebsocketEvent(name, controller, action, parametersTypes, middleware);
-        if (this.router.events.has(name)) {
-            throw new Error(`There is already an event with the same name: '${name}'`);
-        }
-        this.router.events.set(name, event);
-        return event;
-    }
-    async handle(container, request) {
-        container.set(Http_1.Request, request);
-        let stack = async () => {
-            const route = this.router.events.get(request.uri);
-            if (!route) {
-                throw new Error(`Event '${request.uri}' not found`);
-            }
-            // TODO - add the Websocket route in the container
-            // container.set(Route, route)
-            let routeStack = async () => {
-                const content = await route.run(container, request.parameters);
-                if (content instanceof Http_1.Response) {
-                    return content;
-                }
-                return Http_1.Response.ok(content);
-            };
-            route.middleware.forEach(middlewareClass => {
-                const middleware = container.get(middlewareClass);
-                routeStack = middleware.handle.bind(middleware, request, routeStack);
-            });
-            return await routeStack(request);
-        };
-        this.router.middleware.forEach(middlewareClass => {
-            const middleware = container.get(middlewareClass);
-            stack = middleware.handle.bind(middleware, request, stack);
-        });
-        return await stack(request);
-    }
-}
-__decorate([
-    Container_1.Inject(),
-    __metadata("design:type", Router_1.Router)
-], Handler.prototype, "router", void 0);
-exports.Handler = Handler;
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handler = void 0;
+const Container_1 = require("../../Container");
+const Router_1 = require("../../Router");
+const Http_1 = require("../Http");
+const WebsocketEvent_1 = require("./WebsocketEvent");
+class Handler {
+    addEvent(name, controller, action, parametersTypes = [], middleware = []) {
+        const event = new WebsocketEvent_1.WebsocketEvent(name, controller, action, parametersTypes, middleware);
+        if (this.router.events.has(name)) {
+            throw new Error(`There is already an event with the same name: '${name}'`);
+        }
+        this.router.events.set(name, event);
+        return event;
+    }
+    async handle(container, request) {
+        container.set(Http_1.Request, request);
+        let stack = async () => {
+            const route = this.router.events.get(request.uri);
+            if (!route) {
+                throw new Error(`Event '${request.uri}' not found`);
+            }
+            // TODO - add the Websocket route in the container
+            // container.set(Route, route)
+            let routeStack = async () => {
+                const content = await route.run(container, request.parameters);
+                if (content instanceof Http_1.Response) {
+                    return content;
+                }
+                return Http_1.Response.ok(content);
+            };
+            route.middleware.forEach(middlewareClass => {
+                const middleware = container.get(middlewareClass);
+                routeStack = middleware.handle.bind(middleware, request, routeStack);
+            });
+            return await routeStack(request);
+        };
+        this.router.middleware.forEach(middlewareClass => {
+            const middleware = container.get(middlewareClass);
+            stack = middleware.handle.bind(middleware, request, stack);
+        });
+        return await stack(request);
+    }
+}
+__decorate([
+    Container_1.Inject(),
+    __metadata("design:type", Router_1.Router)
+], Handler.prototype, "router", void 0);
+exports.Handler = Handler;
 //# sourceMappingURL=Handler.js.map

package/Router/Websockets/WebsocketEvent.d.ts

@@ -1,16 +1,16 @@
-import { Container } from '../../Container';
-import { Abstract, Constructor, Type } from '../../Support';
-import { MiddlewareInterface } from '../Middleware';
-import { Guard } from '../Guard';
-export declare class WebsocketEvent {
-    name: string;
-    controller: Constructor;
-    action: string;
-    parametersTypes: (Type<Function> | FunctionConstructor)[];
-    middleware: Abstract<MiddlewareInterface>[];
-    guards: (typeof Guard)[];
-    constructor(name: string, controller: Constructor, action: string, parametersTypes?: (Type<Function> | FunctionConstructor)[], middleware?: Abstract<MiddlewareInterface>[]);
-    run(container: Container, requestParameters: Record<string, unknown>): Promise<object | string>;
-    private resolveParameters;
-}
+import { Container } from '../../Container';
+import { Abstract, Constructor, Type } from '../../Support';
+import { MiddlewareInterface } from '../Middleware';
+import { Guard } from '../Guard';
+export declare class WebsocketEvent {
+    name: string;
+    controller: Constructor;
+    action: string;
+    parametersTypes: (Type<Function> | FunctionConstructor)[];
+    middleware: Abstract<MiddlewareInterface>[];
+    guards: (typeof Guard)[];
+    constructor(name: string, controller: Constructor, action: string, parametersTypes?: (Type<Function> | FunctionConstructor)[], middleware?: Abstract<MiddlewareInterface>[]);
+    run(container: Container, requestParameters: Record<string, unknown>): Promise<object | string>;
+    private resolveParameters;
+}
 //# sourceMappingURL=WebsocketEvent.d.ts.map