framework-do-dede 0.0.13 → 0.0.14

package/dist/http/HttpServer.js

@@ -0,0 +1,91 @@
+import { FrameworkError } from "./FrameworkError";
+import { ServerError } from "./ServerError";
+export default class HttpServer {
+    framework;
+    frameworkName;
+    defaultMessageError = 'Ops, An unexpected error occurred';
+    constructor(framework, frameworkName) {
+        if (frameworkName !== 'elysia' && frameworkName !== 'express')
+            throw new FrameworkError('Framework not supported');
+        this.framework = framework;
+        this.frameworkName = frameworkName;
+    }
+    use(middleware) {
+        this.framework.use(middleware);
+        return this;
+    }
+    register(httpServerParams, handler) {
+        const route = this.mountRoute(httpServerParams);
+        if (this.frameworkName === 'elysia')
+            return this.elysia(httpServerParams, route, handler);
+        return this.express(httpServerParams, route, handler);
+    }
+    listen(port) {
+        this.framework.listen(port);
+    }
+    mountRoute(httpServerParams) {
+        const params = httpServerParams.params?.map((param) => param.split('|')[0]);
+        if (params && params.length > 0) {
+            const paramsMounted = params.map((v) => {
+                return v.includes('_') ? `${v.replace('_', '/')}` : `/:${v}`;
+            }).join('');
+            return `${httpServerParams.route}${paramsMounted}`;
+        }
+        return httpServerParams.route;
+    }
+    elysia(httpServerParams, route, handler) {
+        const method = httpServerParams.method;
+        (this.framework[method])(route, async ({ headers, set, query, params, body, request, path }) => {
+            try {
+                set.status = httpServerParams.statusCode ?? 200;
+                const output = await handler({
+                    headers,
+                    query,
+                    params,
+                    body
+                });
+                return output;
+            }
+            catch (error) {
+                if (error instanceof ServerError) {
+                    set.status = error.getStatusCode();
+                    return {
+                        error: error.message,
+                        statusCode: error.getStatusCode()
+                    };
+                }
+                set.status = 500;
+                return {
+                    error: this.defaultMessageError,
+                    statusCode: 500
+                };
+            }
+        });
+    }
+    express(httpServerParams, route, handler) {
+        const method = httpServerParams.method;
+        this.framework[method](route, async (request, res) => {
+            try {
+                const output = await handler({
+                    headers: request.headers,
+                    query: request.query,
+                    params: request.params,
+                    body: request.body
+                });
+                return res.status(httpServerParams.statusCode ?? 200).json(output);
+            }
+            catch (error) {
+                if (error instanceof ServerError) {
+                    return res.status(error.getStatusCode()).json({
+                        error: error.message,
+                        statusCode: error.getStatusCode()
+                    });
+                }
+                return res.status(500).json({
+                    error: this.defaultMessageError,
+                    statusCode: 500
+                });
+            }
+        });
+    }
+}

package/dist/http/ServerError.d.ts

@@ -0,0 +1,23 @@
+export declare abstract class ServerError extends Error {
+    private statusCode;
+    constructor(message: string, statusCode: number);
+    getStatusCode(): number;
+}
+export declare class NotFound extends ServerError {
+    constructor(message: string);
+}
+export declare class Forbidden extends ServerError {
+    constructor(message: string);
+}
+export declare class UnprocessableEntity extends ServerError {
+    constructor(message: string);
+}
+export declare class Conflict extends ServerError {
+    constructor(message: string);
+}
+export declare class Unauthorized extends ServerError {
+    constructor(message: string);
+}
+export declare class BadRequest extends ServerError {
+    constructor(message: string);
+}

package/dist/http/ServerError.js

@@ -0,0 +1,41 @@
+export class ServerError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+    }
+    getStatusCode() {
+        return this.statusCode;
+    }
+}
+export class NotFound extends ServerError {
+    constructor(message) {
+        super(message, 404);
+    }
+}
+export class Forbidden extends ServerError {
+    constructor(message) {
+        super(message, 403);
+    }
+}
+export class UnprocessableEntity extends ServerError {
+    constructor(message) {
+        super(message, 422);
+    }
+}
+export class Conflict extends ServerError {
+    constructor(message) {
+        super(message, 409);
+    }
+}
+export class Unauthorized extends ServerError {
+    constructor(message) {
+        super(message, 401);
+    }
+}
+export class BadRequest extends ServerError {
+    constructor(message) {
+        super(message, 400);
+    }
+}

package/dist/http/index.d.ts

@@ -0,0 +1,3 @@
+import HttpServer from "./HttpServer";
+import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest } from "./ServerError";
+export { ServerError, BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, HttpServer };

package/dist/http/index.js

@@ -0,0 +1,3 @@
+import HttpServer from "./HttpServer";
+import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest } from "./ServerError";
+export { ServerError, BadRequest, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, HttpServer };

package/dist/index.d.ts

@@ -1,37 +1,14 @@
-import { Auth, Controller, Delete, Get, Inject, Middleware, Patch, Post, Put, Validator } from './decorators';
-import { Dede, Options as DedeOptions, Register as DedeRegister } from './dede';
-import { ServerError } from './http';
-import { UseCaseHandler } from './handlers';
-
-declare interface HttpMiddleware {
-    execute(input: any): Promise<any>
+import { Dede, Register as DedeRegister, Options as DedeOptions } from './dede';
+import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Auth, Inject } from './decorators';
+import { BadRequest, Conflict, Forbidden, HttpServer, NotFound, ServerError, Unauthorized, UnprocessableEntity } from './http';
+import { Validation, HttpMiddleware, UseCase } from './protocols';
+declare class RequestData {
+    headers: any;
+    data: any;
+    middlewareData: any;
+    constructor(headers: any, data: any, middlewareData: any);
 }
-declare interface UseCase<Input, Output>  {
-    execute(input: Input): Promise<Output>
+declare class UseCaseHandler {
+    static load<T extends UseCase<any, any>>(useCaseClass: new (...args: any[]) => T, request?: RequestData): T;
 }
-declare interface Validation {
-    validate(input: any): any;
-}
-declare const instance: unknown;
-
-export {
-    UseCase,
-    HttpMiddleware,
-    Validation,
-    RequestData,
-    Dede,
-    DedeRegister,
-    DedeOptions,
-    UseCaseHandler,
-    ServerError,
-    Controller,
-    Post,
-    Put,
-    Get,
-    Delete,
-    Patch,
-    Validator,
-    Middleware,
-    Auth,
-    Inject
-}
+export { UseCase, HttpMiddleware, Validation, RequestData, Dede, DedeRegister, DedeOptions, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Auth, Inject };