framework-do-dede 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# Framework do Dedé
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.1.42. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/dist/Controller.d.ts

@@ -0,0 +1,13 @@
+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/FrameworkError.d.ts

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

package/dist/HttpMiddleware.d.ts

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

package/dist/HttpServer.d.ts

@@ -0,0 +1,87 @@
+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) {
+        const route = this.mountRoute(httpServerParams)
+        if (this.frameworkName === 'elysia') return this.elysia(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
+                }
+              }
+        })
+    }
+}

package/dist/ServerError.d.ts

@@ -0,0 +1,42 @@
+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

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

package/dist/Validation.d.ts

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

package/dist/controller.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,86 @@
+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

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

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { Auth, Controller, Delete, Get, Post, Put, Validator } from '@/decorators';
+import { ControllerHandler, UseCaseHandler } from '@/handlers';
+import { HttpMiddleware, UseCase, Validation } from '@/protocols';
+import { HttpServer, ServerError } from '@/http';
+import { Registry } from './di/registry';
+
+
+export {
+    Registry,
+    Auth,
+    Controller,
+    Delete,
+    Get,
+    Post,
+    Put,
+    Validator,
+    HttpMiddleware,
+    UseCase,
+    Validation,
+    HttpServer,
+    ServerError,
+    UseCaseHandler,
+    ControllerHandler
+}

package/dist/registry.d.ts

@@ -0,0 +1,4 @@
+declare const dependency: unknown;
+declare const dependency: unknown;
+declare const paramtypes: (...args: any[]) => unknown;
+export declare const Registry: unknown;

package/dist/usecase.d.ts

@@ -0,0 +1 @@
+export declare function Auth(propertyName: string): void;

package/dist/usecase.handler.d.ts

@@ -0,0 +1,23 @@
+import type { UseCase } from '@/protocols';
+
+declare type RequestData = {
+  headers: any,
+  data?: any,
+  middlewareData?: any
+}
+
+
+export class UseCaseHandler {
+  static load<T extends UseCase<any, any>>(
+    useCaseClass: new (...args: any[]) => T,
+    request?: RequestData
+  ): T {
+    const instance = Registry.classLoader(useCaseClass);
+    const auth = Reflect.getMetadata("auth", useCaseClass);
+    const context = request
+    if (auth && context?.middlewareData) {
+      (instance as any)[auth] = context.middlewareData[auth]
+    }
+    return instance
+  }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "framework-do-dede",
+  "version": "0.0.1",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "description": "",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "prepare": "bun run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "bun"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/marcossaore/framework-do-dede#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marcossaore/framework-do-dede.git"
+  },
+  "bugs": "https://github.com/marcossaore/framework-do-dede/issues",
+  "author": "Marcos Soares",
+  "devDependencies": {
+    "@types/reflect-metadata": "^0.1.0",
+    "bun-plugin-dtsx": "^0.21.9"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "@types/bun": "^1.2.5",
+    "reflect-metadata": "^0.2.2"
+  }
+}