@noxfly/noxus 1.0.2 → 1.0.4

package/README.md

@@ -334,6 +334,51 @@ const response: User[] = await electronService.request<User[]>({
 ![Startup image](./images/screenshot-requests.png)
 
 
+### Error Handling
+
+You have a bunch of `*Exception` classes that are at your disposal to help you have a clean code.
+
+Replace `*` By any of the HTTP status code's name that is available in the list below.
+
+If you throw any of these exception, the response to the renderer will contains the associated status code.
+
+You can specify a message in the constructor.
+
+You throw it as follow : 
+```ts
+throw new UnauthorizedException("Invalid credentials");
+throw new BadRequestException("id is missing in the body");
+throw new UnavailableException();
+// ...
+```
+
+| status code | class to throw                         |
+| ----------- | -------------------------------------- |
+| 400         | BadRequestException                    |
+| 401         | UnauthorizedException                  |
+| 402         | PaymentRequiredException               |
+| 403         | ForbiddenException                     |
+| 404         | NotFoundException                      |
+| 405         | MethodNotAllowedException              |
+| 406         | NotAcceptableException                 |
+| 408         | RequestTimeoutException                |
+| 409         | ConflictException                      |
+| 426         | UpgradeRequiredException               |
+| 429         | TooManyRequestsException               |
+| 500         | InternalServerException                |
+| 501         | NotImplementedException                |
+| 502         | BadGatewayException                    |
+| 503         | ServiceUnavailableException            |
+| 504         | GatewayTimeoutException                |
+| 505         | HttpVersionNotSupportedException       |
+| 506         | VariantAlsoNegotiatesException         |
+| 507         | InsufficientStorageException           |
+| 508         | LoopDetectedException                  |
+| 510         | NotExtendedException                   |
+| 511         | NetworkAuthenticationRequiredException |
+| 599         | NetworkConnectTimeoutException         |
+
+
 ## Contributing
 
 1. Clone the repo

package/dist/noxus.d.mts

@@ -1,36 +1,56 @@
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
 type MaybeAsync<T> = T | Promise<T>;
 
+type Lifetime = 'singleton' | 'scope' | 'transient';
+interface IBinding {
+    lifetime: Lifetime;
+    implementation: Type<unknown>;
+    instance?: InstanceType<Type<unknown>>;
+}
+declare class AppInjector {
+    readonly name: string | null;
+    bindings: Map<Type<unknown>, IBinding>;
+    singletons: Map<Type<unknown>, unknown>;
+    scoped: Map<Type<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Utilisé généralement pour créer un scope d'injection de dépendances
+     * au niveau "scope" (donc durée de vie d'une requête)
+     */
+    createScope(): AppInjector;
+    /**
+     * Appelé lorsqu'on souhaite résoudre une dépendance,
+     * c'est-à-dire récupérer l'instance d'une classe donnée.
+     */
+    resolve<T extends Type<unknown>>(target: T): InstanceType<T>;
+    /**
+     *
+     */
+    private instantiate;
+}
+declare const RootInjector: AppInjector;
+
 interface IApp {
     dispose(): Promise<void>;
     onReady(): Promise<void>;
 }
-declare function Injectable(lifetime?: Lifetime): ClassDecorator;
-declare function Module(metadata: IModuleMetadata): ClassDecorator;
 
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-interface IRouteDefinition {
-    method: string;
+interface IRouteMetadata {
+    method: HttpMethod;
     path: string;
-    controller: Type<any>;
     handler: string;
     guards: Type<IGuard>[];
 }
-type ControllerAction = (request: Request, response: IResponse) => any;
-declare function Controller(path: string): ClassDecorator;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 declare const Get: (path: string) => MethodDecorator;
 declare const Post: (path: string) => MethodDecorator;
 declare const Put: (path: string) => MethodDecorator;
 declare const Patch: (path: string) => MethodDecorator;
 declare const Delete: (path: string) => MethodDecorator;
-declare class Router {
-    private readonly routes;
-    registerController(controllerClass: Type<unknown>): Router;
-    handle(request: Request): Promise<IResponse>;
-    private findRoute;
-    private resolveController;
-    private verifyRequestBody;
-    private extractParams;
-}
+declare const ROUTE_METADATA_KEY: unique symbol;
+declare function getRouteMetadata(target: Type<unknown>): IRouteMetadata[];
 
 declare class Request {
     readonly app: IApp;
@@ -67,62 +87,23 @@ declare function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & C
 declare function getGuardForController(controllerName: string): Type<IGuard>[];
 declare function getGuardForControllerAction(controllerName: string, actionName: string): Type<IGuard>[];
 
-interface Type<T> extends Function {
-    new (...args: any[]): T;
-}
-declare const MODULE_METADATA_KEY: unique symbol;
-declare const INJECTABLE_METADATA_KEY: unique symbol;
-declare const CONTROLLER_METADATA_KEY: unique symbol;
-declare const ROUTE_METADATA_KEY: unique symbol;
-interface IModuleMetadata {
-    imports?: Type<unknown>[];
-    providers?: Type<unknown>[];
-    controllers?: Type<unknown>[];
-    exports?: Type<unknown>[];
-}
-interface IRouteMetadata {
-    method: HttpMethod;
+interface IRouteDefinition {
+    method: string;
     path: string;
+    controller: Type<any>;
     handler: string;
     guards: Type<IGuard>[];
 }
-interface IControllerMetadata {
-    path: string;
-    guards: Type<IGuard>[];
-}
-declare function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined;
-declare function getRouteMetadata(target: Type<unknown>): IRouteMetadata[];
-declare function getModuleMetadata(target: Function): IModuleMetadata | undefined;
-declare function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined;
-
-type Lifetime = 'singleton' | 'scope' | 'transient';
-interface IBinding {
-    lifetime: Lifetime;
-    implementation: Type<unknown>;
-    instance?: InstanceType<Type<unknown>>;
-}
-declare class AppInjector {
-    readonly name: string | null;
-    bindings: Map<Type<unknown>, IBinding>;
-    singletons: Map<Type<unknown>, unknown>;
-    scoped: Map<Type<unknown>, unknown>;
-    constructor(name?: string | null);
-    /**
-     * Utilisé généralement pour créer un scope d'injection de dépendances
-     * au niveau "scope" (donc durée de vie d'une requête)
-     */
-    createScope(): AppInjector;
-    /**
-     * Appelé lorsqu'on souhaite résoudre une dépendance,
-     * c'est-à-dire récupérer l'instance d'une classe donnée.
-     */
-    resolve<T extends Type<unknown>>(target: T): InstanceType<T>;
-    /**
-     *
-     */
-    private instantiate;
+type ControllerAction = (request: Request, response: IResponse) => any;
+declare class Router {
+    private readonly routes;
+    registerController(controllerClass: Type<unknown>): Router;
+    handle(request: Request): Promise<IResponse>;
+    private findRoute;
+    private resolveController;
+    private verifyRequestBody;
+    private extractParams;
 }
-declare const RootInjector: AppInjector;
 
 /**
  *
@@ -131,7 +112,7 @@ declare function bootstrapApplication(root: Type<IApp>, rootModule: Type<any>):
 
 declare abstract class ResponseException extends Error {
     abstract readonly status: number;
-    constructor(message: string);
+    constructor(message?: string);
 }
 declare class BadRequestException extends ResponseException {
     readonly status = 400;
@@ -200,6 +181,28 @@ declare class NetworkConnectTimeoutException extends ResponseException {
     readonly status = 599;
 }
 
+interface IControllerMetadata {
+    path: string;
+    guards: Type<IGuard>[];
+}
+declare function Controller(path: string): ClassDecorator;
+declare const CONTROLLER_METADATA_KEY: unique symbol;
+declare function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined;
+
+declare function Injectable(lifetime?: Lifetime): ClassDecorator;
+declare const INJECTABLE_METADATA_KEY: unique symbol;
+declare function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined;
+
+declare function Module(metadata: IModuleMetadata): ClassDecorator;
+declare const MODULE_METADATA_KEY: unique symbol;
+interface IModuleMetadata {
+    imports?: Type<unknown>[];
+    exports?: Type<unknown>[];
+    providers?: Type<unknown>[];
+    controllers?: Type<unknown>[];
+}
+declare function getModuleMetadata(target: Function): IModuleMetadata | undefined;
+
 type LogLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
 declare namespace Logger {
     function setLogLevel(level: LogLevel): void;

package/dist/noxus.d.ts

@@ -1,36 +1,56 @@
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
 type MaybeAsync<T> = T | Promise<T>;
 
+type Lifetime = 'singleton' | 'scope' | 'transient';
+interface IBinding {
+    lifetime: Lifetime;
+    implementation: Type<unknown>;
+    instance?: InstanceType<Type<unknown>>;
+}
+declare class AppInjector {
+    readonly name: string | null;
+    bindings: Map<Type<unknown>, IBinding>;
+    singletons: Map<Type<unknown>, unknown>;
+    scoped: Map<Type<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Utilisé généralement pour créer un scope d'injection de dépendances
+     * au niveau "scope" (donc durée de vie d'une requête)
+     */
+    createScope(): AppInjector;
+    /**
+     * Appelé lorsqu'on souhaite résoudre une dépendance,
+     * c'est-à-dire récupérer l'instance d'une classe donnée.
+     */
+    resolve<T extends Type<unknown>>(target: T): InstanceType<T>;
+    /**
+     *
+     */
+    private instantiate;
+}
+declare const RootInjector: AppInjector;
+
 interface IApp {
     dispose(): Promise<void>;
     onReady(): Promise<void>;
 }
-declare function Injectable(lifetime?: Lifetime): ClassDecorator;
-declare function Module(metadata: IModuleMetadata): ClassDecorator;
 
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-interface IRouteDefinition {
-    method: string;
+interface IRouteMetadata {
+    method: HttpMethod;
     path: string;
-    controller: Type<any>;
     handler: string;
     guards: Type<IGuard>[];
 }
-type ControllerAction = (request: Request, response: IResponse) => any;
-declare function Controller(path: string): ClassDecorator;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 declare const Get: (path: string) => MethodDecorator;
 declare const Post: (path: string) => MethodDecorator;
 declare const Put: (path: string) => MethodDecorator;
 declare const Patch: (path: string) => MethodDecorator;
 declare const Delete: (path: string) => MethodDecorator;
-declare class Router {
-    private readonly routes;
-    registerController(controllerClass: Type<unknown>): Router;
-    handle(request: Request): Promise<IResponse>;
-    private findRoute;
-    private resolveController;
-    private verifyRequestBody;
-    private extractParams;
-}
+declare const ROUTE_METADATA_KEY: unique symbol;
+declare function getRouteMetadata(target: Type<unknown>): IRouteMetadata[];
 
 declare class Request {
     readonly app: IApp;
@@ -67,62 +87,23 @@ declare function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & C
 declare function getGuardForController(controllerName: string): Type<IGuard>[];
 declare function getGuardForControllerAction(controllerName: string, actionName: string): Type<IGuard>[];
 
-interface Type<T> extends Function {
-    new (...args: any[]): T;
-}
-declare const MODULE_METADATA_KEY: unique symbol;
-declare const INJECTABLE_METADATA_KEY: unique symbol;
-declare const CONTROLLER_METADATA_KEY: unique symbol;
-declare const ROUTE_METADATA_KEY: unique symbol;
-interface IModuleMetadata {
-    imports?: Type<unknown>[];
-    providers?: Type<unknown>[];
-    controllers?: Type<unknown>[];
-    exports?: Type<unknown>[];
-}
-interface IRouteMetadata {
-    method: HttpMethod;
+interface IRouteDefinition {
+    method: string;
     path: string;
+    controller: Type<any>;
     handler: string;
     guards: Type<IGuard>[];
 }
-interface IControllerMetadata {
-    path: string;
-    guards: Type<IGuard>[];
-}
-declare function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined;
-declare function getRouteMetadata(target: Type<unknown>): IRouteMetadata[];
-declare function getModuleMetadata(target: Function): IModuleMetadata | undefined;
-declare function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined;
-
-type Lifetime = 'singleton' | 'scope' | 'transient';
-interface IBinding {
-    lifetime: Lifetime;
-    implementation: Type<unknown>;
-    instance?: InstanceType<Type<unknown>>;
-}
-declare class AppInjector {
-    readonly name: string | null;
-    bindings: Map<Type<unknown>, IBinding>;
-    singletons: Map<Type<unknown>, unknown>;
-    scoped: Map<Type<unknown>, unknown>;
-    constructor(name?: string | null);
-    /**
-     * Utilisé généralement pour créer un scope d'injection de dépendances
-     * au niveau "scope" (donc durée de vie d'une requête)
-     */
-    createScope(): AppInjector;
-    /**
-     * Appelé lorsqu'on souhaite résoudre une dépendance,
-     * c'est-à-dire récupérer l'instance d'une classe donnée.
-     */
-    resolve<T extends Type<unknown>>(target: T): InstanceType<T>;
-    /**
-     *
-     */
-    private instantiate;
+type ControllerAction = (request: Request, response: IResponse) => any;
+declare class Router {
+    private readonly routes;
+    registerController(controllerClass: Type<unknown>): Router;
+    handle(request: Request): Promise<IResponse>;
+    private findRoute;
+    private resolveController;
+    private verifyRequestBody;
+    private extractParams;
 }
-declare const RootInjector: AppInjector;
 
 /**
  *
@@ -131,7 +112,7 @@ declare function bootstrapApplication(root: Type<IApp>, rootModule: Type<any>):
 
 declare abstract class ResponseException extends Error {
     abstract readonly status: number;
-    constructor(message: string);
+    constructor(message?: string);
 }
 declare class BadRequestException extends ResponseException {
     readonly status = 400;
@@ -200,6 +181,28 @@ declare class NetworkConnectTimeoutException extends ResponseException {
     readonly status = 599;
 }
 
+interface IControllerMetadata {
+    path: string;
+    guards: Type<IGuard>[];
+}
+declare function Controller(path: string): ClassDecorator;
+declare const CONTROLLER_METADATA_KEY: unique symbol;
+declare function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined;
+
+declare function Injectable(lifetime?: Lifetime): ClassDecorator;
+declare const INJECTABLE_METADATA_KEY: unique symbol;
+declare function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined;
+
+declare function Module(metadata: IModuleMetadata): ClassDecorator;
+declare const MODULE_METADATA_KEY: unique symbol;
+interface IModuleMetadata {
+    imports?: Type<unknown>[];
+    exports?: Type<unknown>[];
+    providers?: Type<unknown>[];
+    controllers?: Type<unknown>[];
+}
+declare function getModuleMetadata(target: Function): IModuleMetadata | undefined;
+
 type LogLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
 declare namespace Logger {
     function setLogLevel(level: LogLevel): void;