framework-do-dede 0.0.2 → 0.0.4

package/dist/ElysiaHttpServer.d.ts

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

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

@@ -36,9 +36,10 @@ export default abstract class HttpServer {
         return this;
     }
 
-    register(httpServerParams: HttpServerParams, handler: CallableFunction) {
+    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 {
@@ -84,4 +85,30 @@ export default abstract class HttpServer {
               }
         })
     }
+
+    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/dede.d.ts

@@ -0,0 +1,47 @@
+export declare type Register = {
+    name: string,
+    classLoader: any,
+    autoLoad?: boolean
+}
+
+export type Options = {
+    framework: {
+        use: 'elysia' | 'express',
+        port?: number,
+        middlewares?: CallableFunction[]
+    },
+    registries: Register[]
+}
+
+
+export class Dede {
+    static async init ({ framework, registries }: Options): Promise<void> {
+        this.registerControllers();
+        await this.loadRegistries(registries);
+        let httpServer!: HttpServer
+        if (framework.use === 'elysia') {
+            httpServer = new ElysiaHttpServer(framework.middlewares || [])
+        }
+        if (framework.use === 'express') {
+            httpServer = new ExpressHttpServer(framework.middlewares || [])
+        }
+        new ControllerHandler(httpServer, framework.port || 80)
+        this.clearControllers()
+    }
+
+
+    private static registerControllers() {
+        Registry.register('controllers', []);
+    }
+
+    private static clearControllers() {
+        Registry.clear('controllers');
+    }
+
+    private static async loadRegistries(registries: Register []) {
+        registries.forEach(({ classLoader, name, autoLoad = true}) => {
+            if (autoLoad) Registry.register(name, Registry.classLoader(classLoader));
+            else Registry.register(name, classLoader);
+        })
+    }
+}

package/dist/example.d.ts

@@ -0,0 +1,40 @@
+declare type Input = { name: string, age: number, email: string, password: string };
+type Output = void;
+declare interface UserRepository {
+    create: (input: any) => Promise<void>
+}
+declare type RequestData = {
+    headers: any,
+    data: any,
+    middlewareData: any
+}
+
+
+@Controller('/users')
+class UserController {
+    
+    @Post({ statusCode: 201 })
+    @Validator(ValidateUser)
+    @Middleware(UserAuth)
+    createUser(input: any, request: RequestData) {
+        console.log('request', request)
+        return UseCaseHandler.load(CreateUser, request).execute(input)
+    }
+
+}
+
+
+
+
+Dede.init({
+    framework: {
+        port: 3000,
+        use: 'elysia'
+    },
+    registries: [
+        {
+            name: 'UserRepository',
+            classLoader: UserRepositoryDatabase
+        }
+    ]
+})