@noxfly/noxus 1.0.2 → 1.0.4

package/src/{injector-explorer.ts → DI/injector-explorer.ts}

@@ -1,7 +1,11 @@
-import { Lifetime, RootInjector } from "src/app-injector";
-import { Logger } from "src/logger";
-import { Type, getModuleMetadata, getControllerMetadata, getRouteMetadata, getInjectableMetadata } from "src/metadata";
+import { getControllerMetadata } from "src/decorators/controller.decorator";
+import { getInjectableMetadata } from "src/decorators/injectable.decorator";
+import { getRouteMetadata } from "src/decorators/method.decorator";
+import { getModuleMetadata } from "src/decorators/module.decorator";
+import { Lifetime, RootInjector } from "src/DI/app-injector";
 import { Router } from "src/router";
+import { Logger } from "src/utils/logger";
+import { Type } from "src/utils/types";
 
 export class InjectorExplorer {
     /**

package/src/app.ts

@@ -1,72 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
-
-import { Lifetime } from "src/app-injector";
-import { InjectorExplorer } from "src/injector-explorer";
-import { CONTROLLER_METADATA_KEY, INJECTABLE_METADATA_KEY, MODULE_METADATA_KEY, IModuleMetadata, Type } from "src/metadata";
-
 export interface IApp {
     dispose(): Promise<void>;
     onReady(): Promise<void>;
 }
-
-export function Injectable(lifetime: Lifetime = 'scope'): ClassDecorator {
-    return (target) => {
-        if(typeof target !== 'function' || !target.prototype) {
-            throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
-        }
-
-        Reflect.defineMetadata(INJECTABLE_METADATA_KEY, lifetime, target);
-        InjectorExplorer.register(target as unknown as Type<any>, lifetime);
-    };
-}
-
-// ---
-
-
-export function Module(metadata: IModuleMetadata): ClassDecorator {
-    return (target: Function) => {
-        // Validate imports and exports: must be decorated with @Module
-        const checkModule = (arr?: Type<unknown>[], arrName?: string): void => {
-            if(!arr)
-                return;
-            
-            for(const clazz of arr) {
-                if(!Reflect.getMetadata(MODULE_METADATA_KEY, clazz)) {
-                    throw new Error(`Class ${clazz.name} in ${arrName} must be decorated with @Module`);
-                }
-            }
-        };
-
-        // Validate providers: must be decorated with @Injectable
-        const checkInjectable = (arr?: Type<unknown>[]): void => {
-            if(!arr)
-                return;
-
-            for(const clazz of arr) {
-                if(!Reflect.getMetadata(INJECTABLE_METADATA_KEY, clazz)) {
-                    throw new Error(`Class ${clazz.name} in providers must be decorated with @Injectable`);
-                }
-            }
-        };
-
-        // Validate controllers: must be decorated with @Controller
-        const checkController = (arr?: Type<unknown>[]): void => {
-            if(!arr) return;
-            for(const clazz of arr) {
-                if(!Reflect.getMetadata(CONTROLLER_METADATA_KEY, clazz)) {
-                    throw new Error(`Class ${clazz.name} in controllers must be decorated with @Controller`);
-                }
-            }
-        };
-
-        checkModule(metadata.imports, 'imports');
-        checkModule(metadata.exports, 'exports');
-        checkInjectable(metadata.providers);
-        checkController(metadata.controllers);
-
-        Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, target);
-
-        Injectable('singleton')(target);
-    };
-}
-

package/src/bootstrap.ts

@@ -1,10 +1,12 @@
 import { ipcMain } from "electron";
 import { app, BrowserWindow, MessageChannelMain } from "electron/main";
 import { IApp } from "src/app";
-import { RootInjector } from "src/app-injector";
-import { getInjectableMetadata, getModuleMetadata, Type } from "src/metadata";
-import { Request, IResponse, IRequest } from "src/request";
+import { getInjectableMetadata } from "src/decorators/injectable.decorator";
+import { getModuleMetadata } from "src/decorators/module.decorator";
+import { RootInjector } from "src/DI/app-injector";
+import { IRequest, IResponse, Request } from "src/request";
 import { Router } from "src/router";
+import { Type } from "src/utils/types";
 
 /**
  * 

package/src/decorators/controller.decorator.ts

@@ -0,0 +1,26 @@
+import { getGuardForController, IGuard } from "src/decorators/guards.decorator";
+import { Injectable } from "src/decorators/injectable.decorator";
+import { Type } from "src/utils/types";
+
+export interface IControllerMetadata {
+    path: string;
+    guards: Type<IGuard>[];
+}
+
+export function Controller(path: string): ClassDecorator {
+    return (target) => {
+        const data: IControllerMetadata = {
+            path,
+            guards: getGuardForController(target.name)
+        };
+
+        Reflect.defineMetadata(CONTROLLER_METADATA_KEY, data, target);
+        Injectable('scope')(target);
+    };
+}
+
+export const CONTROLLER_METADATA_KEY = Symbol('CONTROLLER_METADATA_KEY');
+
+export function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined {
+    return Reflect.getMetadata(CONTROLLER_METADATA_KEY, target);
+}

package/src/{guards.ts → decorators/guards.decorator.ts}

@@ -1,7 +1,6 @@
-import { Logger } from 'src/logger';
-import { Type } from 'src/metadata';
-import { MaybeAsync } from 'src/misc';
 import { Request } from 'src/request';
+import { Logger } from 'src/utils/logger';
+import { MaybeAsync, Type } from 'src/utils/types';
 
 export interface IGuard {
     canActivate(request: Request): MaybeAsync<boolean>;

package/src/decorators/injectable.decorator.ts

@@ -0,0 +1,20 @@
+import { Lifetime } from "src/DI/app-injector";
+import { InjectorExplorer } from "src/DI/injector-explorer";
+import { Type } from "src/utils/types";
+
+export function Injectable(lifetime: Lifetime = 'scope'): ClassDecorator {
+    return (target) => {
+        if(typeof target !== 'function' || !target.prototype) {
+            throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
+        }
+
+        Reflect.defineMetadata(INJECTABLE_METADATA_KEY, lifetime, target);
+        InjectorExplorer.register(target as unknown as Type<any>, lifetime);
+    };
+}
+
+export const INJECTABLE_METADATA_KEY = Symbol('INJECTABLE_METADATA_KEY');
+
+export function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined {
+    return Reflect.getMetadata(INJECTABLE_METADATA_KEY, target);
+}

package/src/decorators/method.decorator.ts

@@ -0,0 +1,42 @@
+import { getGuardForControllerAction, IGuard } from "src/decorators/guards.decorator";
+import { Type } from "src/utils/types";
+
+function createRouteDecorator(verb: HttpMethod): (path: string) => MethodDecorator {
+    return (path: string): MethodDecorator => {
+        return (target, propertyKey) => {
+            const existingRoutes: IRouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) || [];
+
+            const metadata: IRouteMetadata = {
+                method: verb,
+                path: path.trim().replace(/^\/|\/$/g, ''),
+                handler: propertyKey as string,
+                guards: getGuardForControllerAction((target.constructor as any).__controllerName, propertyKey as string),
+            };
+
+            existingRoutes.push(metadata);
+
+            Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target.constructor);
+        };
+    };
+}
+
+export interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Type<IGuard>[];
+}
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+export const Get = createRouteDecorator('GET');
+export const Post = createRouteDecorator('POST');
+export const Put = createRouteDecorator('PUT');
+export const Patch = createRouteDecorator('PATCH');
+export const Delete = createRouteDecorator('DELETE');
+
+export const ROUTE_METADATA_KEY = Symbol('ROUTE_METADATA_KEY');
+
+export function getRouteMetadata(target: Type<unknown>): IRouteMetadata[] {
+    return Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+}

package/src/decorators/module.decorator.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+
+import { CONTROLLER_METADATA_KEY } from "src/decorators/controller.decorator";
+import { Injectable, INJECTABLE_METADATA_KEY } from "src/decorators/injectable.decorator";
+import { Type } from "src/utils/types";
+
+export function Module(metadata: IModuleMetadata): ClassDecorator {
+    return (target: Function) => {
+        // Validate imports and exports: must be decorated with @Module
+        const checkModule = (arr?: Type<unknown>[], arrName?: string): void => {
+            if(!arr)
+                return;
+            
+            for(const clazz of arr) {
+                if(!Reflect.getMetadata(MODULE_METADATA_KEY, clazz)) {
+                    throw new Error(`Class ${clazz.name} in ${arrName} must be decorated with @Module`);
+                }
+            }
+        };
+
+        // Validate providers: must be decorated with @Injectable
+        const checkInjectable = (arr?: Type<unknown>[]): void => {
+            if(!arr)
+                return;
+
+            for(const clazz of arr) {
+                if(!Reflect.getMetadata(INJECTABLE_METADATA_KEY, clazz)) {
+                    throw new Error(`Class ${clazz.name} in providers must be decorated with @Injectable`);
+                }
+            }
+        };
+
+        // Validate controllers: must be decorated with @Controller
+        const checkController = (arr?: Type<unknown>[]): void => {
+            if(!arr) return;
+            for(const clazz of arr) {
+                if(!Reflect.getMetadata(CONTROLLER_METADATA_KEY, clazz)) {
+                    throw new Error(`Class ${clazz.name} in controllers must be decorated with @Controller`);
+                }
+            }
+        };
+
+        checkModule(metadata.imports, 'imports');
+        checkModule(metadata.exports, 'exports');
+        checkInjectable(metadata.providers);
+        checkController(metadata.controllers);
+
+        Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, target);
+
+        Injectable('singleton')(target);
+    };
+}
+
+export const MODULE_METADATA_KEY = Symbol('MODULE_METADATA_KEY');
+
+export interface IModuleMetadata {
+    imports?: Type<unknown>[];
+    exports?: Type<unknown>[];
+    providers?: Type<unknown>[];
+    controllers?: Type<unknown>[];
+}
+
+export function getModuleMetadata(target: Function): IModuleMetadata | undefined {
+    return Reflect.getMetadata(MODULE_METADATA_KEY, target);
+}

package/src/exceptions.ts

@@ -1,7 +1,7 @@
 export abstract class ResponseException extends Error {
     public abstract readonly status: number;
 
-    constructor(message: string) {
+    constructor(message: string = "") {
         super(message);
         
         this.name = this.constructor.name

package/src/index.ts

@@ -1,10 +1,13 @@
-export * from './app-injector';
+export * from './DI/app-injector';
 export * from './router';
 export * from './app';
 export * from './bootstrap';
 export * from './exceptions';
-export * from './guards';
-export * from './logger';
-export * from './metadata';
-export * from './misc';
+export * from './decorators/guards.decorator';
+export * from './decorators/controller.decorator';
+export * from './decorators/injectable.decorator';
+export * from './decorators/method.decorator';
+export * from './decorators/module.decorator';
+export * from './utils/logger';
+export * from './utils/types';
 export * from './request';

package/src/request.ts

@@ -1,7 +1,7 @@
-import { IApp } from 'src/app';
-import { RootInjector } from 'src/app-injector';
-import { HttpMethod } from 'src/router';
 import 'reflect-metadata';
+import { IApp } from 'src/app';
+import { HttpMethod } from 'src/decorators/method.decorator';
+import { RootInjector } from 'src/DI/app-injector';
 
 
 //

package/src/router.ts

@@ -1,16 +1,16 @@
 import 'reflect-metadata';
-import { Injectable } from 'src/app';
+import { getControllerMetadata } from 'src/decorators/controller.decorator';
+import { getGuardForController, getGuardForControllerAction, IGuard } from 'src/decorators/guards.decorator';
+import { Injectable } from 'src/decorators/injectable.decorator';
+import { getRouteMetadata } from 'src/decorators/method.decorator';
 import { MethodNotAllowedException, NotFoundException, ResponseException, UnauthorizedException } from 'src/exceptions';
-import { getGuardForController, getGuardForControllerAction, IGuard } from 'src/guards';
-import { Logger } from 'src/logger';
-import { CONTROLLER_METADATA_KEY, IControllerMetadata, getControllerMetadata, getRouteMetadata, ROUTE_METADATA_KEY, IRouteMetadata, Type } from 'src/metadata';
-import { RadixTree } from 'src/radix-tree';
-import { Request, IResponse } from 'src/request';
+import { IResponse, Request } from 'src/request';
+import { Logger } from 'src/utils/logger';
+import { RadixTree } from 'src/utils/radix-tree';
+import { Type } from 'src/utils/types';
 
 // types & interfaces
 
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-
 export interface IRouteDefinition {
     method: string;
     path: string;
@@ -21,42 +21,6 @@ export interface IRouteDefinition {
 
 export type ControllerAction = (request: Request, response: IResponse) => any;
 
-export function Controller(path: string): ClassDecorator {
-    return (target) => {
-        const data: IControllerMetadata = {
-            path,
-            guards: getGuardForController(target.name)
-        };
-
-        Reflect.defineMetadata(CONTROLLER_METADATA_KEY, data, target);
-        Injectable('scope')(target);
-    };
-}
-
-function createRouteDecorator(verb: HttpMethod): (path: string) => MethodDecorator {
-    return (path: string): MethodDecorator => {
-        return (target, propertyKey) => {
-            const existingRoutes: IRouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) || [];
-
-            const metadata: IRouteMetadata = {
-                method: verb,
-                path: path.trim().replace(/^\/|\/$/g, ''),
-                handler: propertyKey as string,
-                guards: getGuardForControllerAction((target.constructor as any).__controllerName, propertyKey as string),
-            };
-
-            existingRoutes.push(metadata);
-
-            Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target.constructor);
-        };
-    };
-}
-
-export const Get = createRouteDecorator('GET');
-export const Post = createRouteDecorator('POST');
-export const Put = createRouteDecorator('PUT');
-export const Patch = createRouteDecorator('PATCH');
-export const Delete = createRouteDecorator('DELETE');
 
 @Injectable('singleton')
 export class Router {

package/src/utils/types.ts

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+
+
+declare const Type: FunctionConstructor;
+export interface Type<T> extends Function {
+    // eslint-disable-next-line @typescript-eslint/prefer-function-type
+    new (...args: any[]): T;
+}
+
+export type MaybeAsync<T> = T | Promise<T>;

package/src/metadata.ts

@@ -1,52 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
-
-import { Lifetime } from "src/app-injector";
-import { IGuard } from "src/guards";
-import { HttpMethod } from "src/router";
-
-declare const Type: FunctionConstructor;
-export interface Type<T> extends Function {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    new (...args: any[]): T;
-}
-
-export const MODULE_METADATA_KEY = Symbol('MODULE_METADATA_KEY');
-export const INJECTABLE_METADATA_KEY = Symbol('INJECTABLE_METADATA_KEY');
-export const CONTROLLER_METADATA_KEY = Symbol('CONTROLLER_METADATA_KEY');
-export const ROUTE_METADATA_KEY = Symbol('ROUTE_METADATA_KEY');
-
-export interface IModuleMetadata {
-    imports?: Type<unknown>[];
-    providers?: Type<unknown>[];
-    controllers?: Type<unknown>[];
-    exports?: Type<unknown>[];
-}
-
-export interface IRouteMetadata {
-    method: HttpMethod;
-    path: string;
-    handler: string;
-    guards: Type<IGuard>[];
-}
-
-export interface IControllerMetadata {
-    path: string;
-    guards: Type<IGuard>[];
-}
-
-
-export function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined {
-    return Reflect.getMetadata(CONTROLLER_METADATA_KEY, target);
-}
-
-export function getRouteMetadata(target: Type<unknown>): IRouteMetadata[] {
-    return Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
-}
-
-export function getModuleMetadata(target: Function): IModuleMetadata | undefined {
-    return Reflect.getMetadata(MODULE_METADATA_KEY, target);
-}
-
-export function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined {
-    return Reflect.getMetadata(INJECTABLE_METADATA_KEY, target);
-}

package/src/misc.ts

@@ -1 +0,0 @@
-export type MaybeAsync<T> = T | Promise<T>;