framework-do-dede 0.0.13 → 0.0.14

package/dist/protocols/Controller.d.ts

@@ -0,0 +1,14 @@
+import type { AllowedMethods, HttpStatusCode } from "@/http/HttpServer";
+import type { Validation } from "./Validation";
+import type { HttpMiddleware } from "./HttpMiddleware";
+export type Controller = {
+    instance: any;
+    instanceMethod: string;
+    route: string;
+    method: AllowedMethods;
+    middlewares?: HttpMiddleware[];
+    statusCode?: HttpStatusCode;
+    validation?: Validation;
+    params?: any;
+    query?: any;
+};

package/dist/protocols/Controller.js

@@ -0,0 +1 @@
+export {};

package/dist/protocols/HttpMiddleware.d.ts

@@ -0,0 +1,3 @@
+export interface HttpMiddleware {
+    execute(input: any): Promise<any>;
+}

package/dist/protocols/HttpMiddleware.js

@@ -0,0 +1 @@
+export {};

package/dist/protocols/UseCase.d.ts

@@ -0,0 +1,3 @@
+export interface UseCase<Input, Output> {
+    execute(input: Input): Promise<Output>;
+}

package/dist/protocols/UseCase.js

@@ -0,0 +1 @@
+export {};

package/dist/protocols/Validation.d.ts

@@ -0,0 +1,3 @@
+export interface Validation {
+    validate(input: any): any;
+}

package/dist/protocols/Validation.js

@@ -0,0 +1 @@
+export {};

package/dist/protocols/index.d.ts

@@ -0,0 +1,4 @@
+import type { HttpMiddleware } from './HttpMiddleware';
+import type { UseCase } from './UseCase';
+import type { Validation } from './Validation';
+export type { HttpMiddleware, UseCase, Validation };

package/dist/protocols/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-do-dede",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -12,8 +12,10 @@
     "require": "./dist/index.cjs"
   },
   "scripts": {
-    "build": "bun run build.ts",
-    "prepare": "bun run build"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build"
   },
   "files": [
     "dist"
@@ -30,14 +32,21 @@
   "bugs": "https://github.com/marcossaore/framework-do-dede/issues",
   "author": "Marcos Soares",
   "devDependencies": {
+    "@babel/core": "^7.26.10",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-typescript": "^7.27.0",
+    "@types/jest": "^29.5.14",
     "@types/reflect-metadata": "^0.1.0",
-    "bun-plugin-dtsx": "^0.21.9"
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.0",
+    "typescript": "^5.8.2"
   },
   "peerDependencies": {
+    "elysia": "^1.2.25",
+    "express": "^4.21.2",
     "typescript": "^5.8.2"
   },
   "dependencies": {
-    "@types/bun": "^1.2.5",
     "reflect-metadata": "^0.2.2"
   }
-}
+}

package/dist/Controller.d.ts

@@ -1,13 +0,0 @@
-import type { AllowedMethods, HttpStatusCode } from '@/http/HttpServer';
-
-export declare type Controller = {
-    instance: any
-    instanceMethod: string
-    route: string
-    method: AllowedMethods
-    middlewares?: HttpMiddleware[]
-    statusCode?: HttpStatusCode
-    validation?: Validation
-    params?: any
-    query?: any
-}

package/dist/ElysiaHttpServer.d.ts

@@ -1,12 +0,0 @@
-export declare class ElysiaHttpServer extends HttpServer {
-    
-    constructor(uses?: CallableFunction[]) {
-        super(new Elysia(), 'elysia')
-        uses?.forEach(use => this.framework.use(use))
-    }
-
-    listen(port: number): void {
-        super.listen(port)
-        console.log(`Server listening on port ${port}`)
-    }
-}

package/dist/ExpressHttpServer.d.ts

@@ -1,13 +0,0 @@
-declare const app: unknown;
-export declare class ExpressHttpServer extends HttpServer {
-    
-    constructor(uses?: CallableFunction[]) {
-        super(app, 'express')
-        uses?.forEach(use => this.framework.use(use))
-    }
-
-    listen(port: number): void {
-        super.listen(port)
-        console.log(`Server listening on port ${port}`)
-    }
-}

package/dist/FrameworkError.d.ts

@@ -1,5 +0,0 @@
-export declare class FrameworkError extends Error {
-    constructor(message: string) {
-      super(message)
-    }
-  }

package/dist/HttpMiddleware.d.ts

@@ -1,3 +0,0 @@
-export declare interface HttpMiddleware {
-    execute(input: any): Promise<any>
-}

package/dist/HttpServer.d.ts

@@ -1,114 +0,0 @@
-export declare type HttpStatusCode = 200 | 201 | 204 | 401 | 403 | 404 | 409 | 422 | 500
-
-export type AllowedMethods = 'get' | 'post' | 'put' | 'delete' | 'patch'
-
-export type HttpServerParams = {
-    method: AllowedMethods,
-    route: string,
-    statusCode?: number,
-    params?: string[],
-    query?: string[]
-}
-
-type FrameworkWeb = {
-    listen(port: number): void;
-    use(middleware: CallableFunction): void
-    get(route: string, handler: CallableFunction): void
-    post(route: string, handler: CallableFunction): void
-    put(route: string, handler: CallableFunction): void
-    delete(route: string, handler: CallableFunction): void
-    patch(route: string, handler: CallableFunction): void
-}
-
-export default abstract class HttpServer {
-    protected framework: FrameworkWeb
-    protected frameworkName: string;
-    protected defaultMessageError = 'Ops, An unexpected error occurred';
-
-    constructor(framework: FrameworkWeb, frameworkName: 'elysia' | 'express') {
-        if (frameworkName !== 'elysia' && frameworkName !== 'express') throw new FrameworkError('Framework not supported')
-        this.framework = framework
-        this.frameworkName = frameworkName
-    }
-
-    use(middleware: CallableFunction): HttpServer {
-        this.framework.use(middleware)
-        return this;
-    }
-
-    register(httpServerParams: HttpServerParams, handler: CallableFunction): void {
-        const route = this.mountRoute(httpServerParams)
-        if (this.frameworkName === 'elysia') return this.elysia(httpServerParams, route, handler)
-        return this.express(httpServerParams, route, handler)
-    }
-
-    listen(port: number): void {
-        this.framework.listen(port)
-    }
-
-    private mountRoute(httpServerParams: 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
-    }
-
-    private elysia (httpServerParams: HttpServerParams, route: string, handler: CallableFunction) {
-        const method = httpServerParams.method as AllowedMethods
-        (this.framework[method])(route, async ({ headers, set, query, params, body, request, path }: any) => {
-            try {
-                set.status = httpServerParams.statusCode ?? 200
-                const output = await handler({
-                  headers,
-                  query,
-                  params,
-                  body
-                })
-                return output
-              } catch (error: any) {
-                if (error instanceof ServerError) {
-                  set.status = error.getStatusCode()
-                  return {
-                    error: error.message,
-                    statusCode: error.getStatusCode()
-                  }
-                }
-                set.status = 500
-                return {
-                  error: this.defaultMessageError,
-                  statusCode: 500
-                }
-              }
-        })
-    }
-
-    private express (httpServerParams: HttpServerParams, route: string, handler: CallableFunction) {
-        const method = httpServerParams.method as AllowedMethods
-        this.framework[method](route, async (request: any, res: any) => {
-            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: any) {
-                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/ServerError.d.ts

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

package/dist/UseCase.d.ts

@@ -1,3 +0,0 @@
-export declare interface UseCase<Input, Output>  {
-    execute(input: Input): Promise<Output>
-}

package/dist/Validation.d.ts

@@ -1,3 +0,0 @@
-export declare interface Validation {
-    validate(input: any): any;
-}

package/dist/controller.d.ts

@@ -1,11 +0,0 @@
-import type { HttpMiddleware } from '@/protocols';
-
-declare const middlewares: Map<string, HttpMiddleware>;
-export declare function Controller(basePath: string): void;
-export declare function Middleware(middlewareClass: new ()): void;
-export declare function Post(config: { path?: string,, statusCode?: number,, params?: string[],, query?: string[] }): void;
-export declare function Get(config: { path?: string,, statusCode?: number,, params?: string[],, query?: string[] }): void;
-export declare function Put(config: { path?: string,, statusCode?: number,, params?: string[],, query?: string[] }): void;
-export declare function Patch(config: { path?: string,, statusCode?: number,, params?: string[],, query?: string[] }): void;
-export declare function Delete(config: { path?: string,, statusCode?: number,, params?: string[],, query?: string[] }): void;
-export declare function Validator(validationClass: new ()): void;

package/dist/controller.handler.d.ts

@@ -1,86 +0,0 @@
-import type { Controller } from '@/protocols/Controller';
-
-declare type Input = {
-    headers: any
-    body: any
-    params: any
-    query: any
-}
-
-export default class ControllerHandler {
-    constructor(httpServer: HttpServer, port: number) {
-        for (const { instance, instanceMethod, middlewares,  method, route, statusCode, params, query, validation } of this.registryControllers()) {
-            httpServer.register(
-                {
-                    method,
-                    route,
-                    statusCode,
-                    params,
-                    query
-                },
-                async (input: Input) => {
-                    const filterParams = this.filter(input.params, params)
-                    const queryParams = this.filter(input.query, query)
-                    let mergedParams = { ...filterParams, ...queryParams, ...(input.body || {}) }
-                    if (validation) mergedParams = validation.validate({ ...filterParams, ...queryParams, ...(input.body || {}) });
-                    let middlewareData = {}
-                    if (middlewares) {
-                        for (const middleware of middlewares) {
-                            const  middlewareResult = await middleware.execute({ headers: input.headers,  ...mergedParams })
-                            middlewareData = { ...middlewareResult, ...middlewareData }
-                        }
-                    }
-                    const request = { headers: input.headers, data: mergedParams, middlewareData }
-                    return await instance[instanceMethod](mergedParams, request)
-                }
-            )
-        }
-        httpServer.listen(port)
-    }
-
-    private registryControllers() {
-        const registryControllers = Registry.resolve<any[]>('controllers');
-        const controllers: Controller[] = []
-        for (const controller of registryControllers) {
-            const basePath = Reflect.getMetadata('basePath', controller);
-            const injections = Reflect.getMetadata('injections', controller) || [];
-            const args = injections.map((token: string) => Registry.resolve(token))
-            const instance = new controller(...args)
-            const methodNames = Object.getOwnPropertyNames(controller.prototype).filter(method => method !== 'constructor')
-            for (const methodName of methodNames) {
-                const validation = Reflect.getMetadata('validation', controller.prototype, methodName);
-                const routeConfig = Reflect.getMetadata('route', controller.prototype, methodName);
-                const middlewares = Reflect.getMetadata('middlewares', controller.prototype, methodName);
-                controllers.push({
-                    method: routeConfig.method,
-                    route: basePath + routeConfig.path,
-                    params: routeConfig.params,
-                    query: routeConfig.query,
-                    statusCode: routeConfig.statusCode,
-                    instance,
-                    instanceMethod: methodName,
-                    middlewares,
-                    validation
-                });
-            }
-        }
-        return controllers
-    }
-
-    private filter(params: any, filterParams?: string[]): any {
-        const filter: any = {}
-        for (const paramName of filterParams || []) {
-            const [paramNameFiltered, type] = paramName.split('|')
-            let value = params[paramName] || params[paramNameFiltered]
-            if (!value) return
-            if (type === 'boolean') value = value === 'true'
-            if (type === 'integer') {
-                value = value.replace(/[^0-9]/g, '')
-                value = value ? parseInt(value) : 0
-            }
-            if (type === 'string') value = value.toString()
-            filter[paramNameFiltered] = value
-        }
-        return filter
-    }
-}

package/dist/di.d.ts

@@ -1 +0,0 @@
-export declare function Inject(token: string): void;