framework-do-dede 0.0.12 → 0.0.14

package/dist/decorators/controller.d.ts

@@ -0,0 +1,35 @@
+import { Validation } from "@/protocols/Validation";
+import { HttpMiddleware } from "@/protocols";
+export declare function Controller(basePath: string): (target: any) => void;
+export declare function Middleware(middlewareClass: new () => HttpMiddleware): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Post(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Get(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Put(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Patch(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Delete(config?: {
+    path?: string;
+    statusCode?: number;
+    params?: string[];
+    query?: string[];
+}): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Validator(validationClass: new () => Validation): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/decorators/controller.js

@@ -0,0 +1,88 @@
+import { FrameworkError } from "@/http/FrameworkError";
+import { Registry } from "@/di/registry";
+const middlewares = new Map();
+export function Controller(basePath) {
+    return function (target) {
+        Reflect.defineMetadata('basePath', basePath, target);
+        if (!Registry.has('controllers'))
+            Registry.register('controllers', []);
+        Registry.addDependency('controllers', target);
+    };
+}
+export function Middleware(middlewareClass) {
+    return function (target, propertyKey, descriptor) {
+        if (typeof middlewareClass.prototype.execute !== 'function') {
+            throw new FrameworkError('The concrete class does not implement the Middleware interface.');
+        }
+        // Retrieve existing middlewares for this method or initialize an empty array
+        const middlewares = Reflect.getMetadata('middlewares', target, propertyKey) || [];
+        // Create a new instance of the middleware and add it to the array
+        const middlewareInstance = new middlewareClass();
+        middlewares.push(middlewareInstance);
+        // Update the metadata with the new array of middleware instances
+        Reflect.defineMetadata('middlewares', middlewares, target, propertyKey);
+    };
+}
+export function Post(config = {}) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata('route', {
+            method: 'post',
+            path: config.path || '',
+            params: config.params,
+            query: config.query,
+            statusCode: config.statusCode || 200
+        }, target, propertyKey);
+    };
+}
+export function Get(config = {}) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata('route', {
+            method: 'get',
+            path: config.path || '',
+            params: config.params,
+            query: config.query,
+            statusCode: config.statusCode || 200
+        }, target, propertyKey);
+    };
+}
+export function Put(config = {}) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata('route', {
+            method: 'put',
+            path: config.path || '',
+            params: config.params,
+            query: config.query,
+            statusCode: config.statusCode || 200
+        }, target, propertyKey);
+    };
+}
+export function Patch(config = {}) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata('route', {
+            method: 'patch',
+            path: config.path || '',
+            params: config.params,
+            query: config.query,
+            statusCode: config.statusCode || 200
+        }, target, propertyKey);
+    };
+}
+export function Delete(config = {}) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata('route', {
+            method: 'delete',
+            path: config.path || '',
+            params: config.params,
+            query: config.query,
+            statusCode: config.statusCode || 200
+        }, target, propertyKey);
+    };
+}
+export function Validator(validationClass) {
+    return function (target, propertyKey, descriptor) {
+        if (typeof validationClass.prototype.validate !== 'function') {
+            throw new FrameworkError('the concrete class does not implement Validation class".');
+        }
+        Reflect.defineMetadata('validation', new validationClass(), target, propertyKey);
+    };
+}

package/dist/decorators/di.d.ts

@@ -0,0 +1 @@
+export declare function Inject(token: string): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/di.js

@@ -0,0 +1,7 @@
+export function Inject(token) {
+    return function (target, propertyKey, parameterIndex) {
+        const injections = Reflect.getMetadata('injections', target) || [];
+        injections[parameterIndex] = token;
+        Reflect.defineMetadata('injections', injections, target);
+    };
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,4 @@
+import { Controller, Post, Get, Put, Delete, Patch, Validator, Middleware } from './controller';
+import { Auth } from './usecase';
+import { Inject } from './di';
+export { Controller, Middleware, Validator, Post, Get, Put, Delete, Patch, Auth, Inject };

package/dist/decorators/index.js

@@ -0,0 +1,4 @@
+import { Controller, Post, Get, Put, Delete, Patch, Validator, Middleware } from './controller';
+import { Auth } from './usecase';
+import { Inject } from './di';
+export { Controller, Middleware, Validator, Post, Get, Put, Delete, Patch, Auth, Inject };

package/dist/decorators/usecase.d.ts

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

package/dist/decorators/usecase.js

@@ -0,0 +1,5 @@
+export function Auth(propertyName = 'auth') {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata("auth", propertyName, target.constructor);
+    };
+}

package/dist/dede.d.ts

@@ -1,47 +1,18 @@
-export declare type Register = {
-    name: string,
-    classLoader: any,
-    autoLoad?: boolean
-}
-
+export type Register = {
+    name: string;
+    classLoader: any;
+    autoLoad?: boolean;
+};
 export type Options = {
     framework: {
-        use: 'elysia' | 'express',
-        port?: number,
-        middlewares?: CallableFunction[]
-    },
-    registries: Register[]
+        use: 'elysia' | 'express';
+        port?: number;
+        middlewares?: CallableFunction[];
+    };
+    registries: Register[];
+};
+export declare class Dede {
+    static init({ framework, registries }: Options): Promise<void>;
+    private static clearControllers;
+    private static loadRegistries;
 }
-
-
-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/dede.js

@@ -0,0 +1,29 @@
+import { Registry } from "./di/registry";
+import { ControllerHandler } from "./handlers";
+import { ElysiaHttpServer } from "./http/ElysiaHttpServer";
+import { ExpressHttpServer } from "./http/ExpressHttpServer";
+export class Dede {
+    static async init({ framework, registries }) {
+        await this.loadRegistries(registries);
+        let 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();
+    }
+    static clearControllers() {
+        Registry.clear('controllers');
+    }
+    static async loadRegistries(registries) {
+        registries.forEach(({ classLoader, name, autoLoad = true }) => {
+            if (autoLoad)
+                Registry.register(name, Registry.classLoader(classLoader));
+            else
+                Registry.register(name, classLoader);
+        });
+    }
+}

package/dist/di/registry.d.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+declare class ComponentRegistry {
+    private static instance;
+    private dependencies;
+    static getInstance(): ComponentRegistry;
+    register(token: string, dependency: any): void;
+    has(token: string): boolean;
+    addDependency(token: string, dependency: any): void;
+    resolve<T>(token: string): T;
+    clear(token: string): void;
+    classLoader<T>(target: new (...args: any[]) => T): T;
+    inject(token: string): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
+}
+export declare const Registry: ComponentRegistry;
+export {};

package/dist/di/registry.js

@@ -0,0 +1,47 @@
+import { Inject } from '@/decorators';
+import 'reflect-metadata';
+class ComponentRegistry {
+    static instance;
+    dependencies = new Map();
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ComponentRegistry();
+        }
+        return this.instance;
+    }
+    register(token, dependency) {
+        this.dependencies.set(token, dependency);
+    }
+    has(token) {
+        return this.dependencies.has(token);
+    }
+    addDependency(token, dependency) {
+        if (!this.dependencies.has(token))
+            throw new Error(`Dependency ${token} not registered`);
+        if (!Array.isArray(this.dependencies.get(token)))
+            throw new Error("Dependency must be an array");
+        this.dependencies.get(token).push(dependency);
+    }
+    resolve(token) {
+        const dependency = this.dependencies.get(token);
+        if (!dependency) {
+            throw new Error(`Dependency ${token} not registered`);
+        }
+        return dependency;
+    }
+    clear(token) {
+        const dependency = this.dependencies.get(token);
+        if (!dependency)
+            return;
+        this.dependencies.set(token, null);
+    }
+    classLoader(target) {
+        const paramtypes = Reflect.getMetadata('injections', target) || [];
+        const args = paramtypes.map((token) => ComponentRegistry.getInstance().resolve(token));
+        return new target(...args);
+    }
+    inject(token) {
+        return Inject(token);
+    }
+}
+export const Registry = ComponentRegistry.getInstance();

package/dist/example.d.ts

@@ -1,40 +0,0 @@
-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
-        }
-    ]
-})

package/dist/example.js

@@ -0,0 +1,102 @@
+"use strict";
+// import { Auth, Controller, Get, Inject, Middleware, Post, Validator } from "@/decorators";
+// import ControllerHandler from "@/handlers/controller.handler";
+// import { UseCaseHandler } from "@/handlers/usecase.handler";
+// import HttpServer from "@/http/HttpServer";
+// import { BadRequest } from "@/http/ServerError";
+// import type { HttpMiddleware } from "@/protocols/HttpMiddleware";
+// import type { UseCase } from "@/protocols/UseCase";
+// import { Registry } from "@/di/registry";
+// import Elysia from "elysia";
+// import type { Validation } from "@/protocols";
+// Registry.register('controllers', []);
+// class ValidateUser implements Validation {
+//     validate(input: any) {
+//         if (!input.name) {
+//             throw new BadRequest('name is required')
+//         }
+//         return input
+//     }
+// }
+// class UserAuth implements HttpMiddleware {
+//     async execute(input: any) {
+//         return {
+//             auth: true
+//         }
+//     }
+// }
+// class Test implements HttpMiddleware {
+//     async execute(input: any) {
+//         return {
+//             test: true
+//         }
+//     }
+// }
+// type Input = { name: string, age: number, email: string, password: string };
+// type Output = void;
+// interface UserRepository {
+//     create: (input: any) => Promise<void>
+// }
+// class UserRepositoryDatabase implements UserRepository {
+//     async create(data: any): Promise<void> {
+//         console.log('creating user', data)
+//     }
+// }
+// Registry.register('UserRepository', Registry.classLoader(UserRepositoryDatabase))
+// class CreateUser implements UseCase<Input, Output> {
+//     @Auth() 
+//     private auth: any;
+//     constructor(
+//         @Inject('UserRepository') 
+//         private readonly userRepository: UserRepository
+//     ) {}
+//     async execute(input: Input): Promise<Output> {
+//         this.userRepository.create(input)
+//     }
+// }
+// class GetUser implements UseCase<Input, Output> {
+//     @Auth()
+//     private auth!: boolean
+//     constructor(
+//         @Inject('UserRepository') 
+//         private readonly userRepository: UserRepository
+//     ) {}
+//     async execute(input: Input): Promise<Output> {
+//         console.log(' testing', this.auth)
+//         await this.userRepository.create(input)
+//     }
+// }
+// type RequestData = {
+//     headers: any,
+//     data: any,
+//     middlewareData: any
+// }
+// @Controller('/users')
+// class UserController {
+//     @Post({ statusCode: 201 })
+//     @Validator(ValidateUser)
+//     @Middleware(UserAuth)
+//     // @Middleware(Test)
+//     createUser(input: any, request: RequestData) {
+//         console.log('request', request)
+//         return UseCaseHandler.load(CreateUser, request).execute(input)
+//     }
+//     @Get({ query: ['time|string'], statusCode: 200 })
+//     @Middleware(UserAuth)
+//     // @Middleware(Test)
+//     getUser(input: any, request: RequestData) {
+//         console.log('middlewareData', request.middlewareData)
+//         return UseCaseHandler.load(GetUser, request).execute(input)
+//     }
+// }
+// class ExpressHttpServer extends HttpServer {
+//     constructor() {
+//         super(new Elysia(), 'elysia')
+//     }
+//     listen(port: number): void {
+//         super.listen(port)
+//         console.log(`Server listening on port ${port}`)
+//     }
+// }
+// const server = new ExpressHttpServer()
+// new ControllerHandler(server, 3000)

package/dist/handlers/controller.handler.d.ts

@@ -0,0 +1,6 @@
+import HttpServer from "@/http/HttpServer";
+export default class ControllerHandler {
+    constructor(httpServer: HttpServer, port: number);
+    private registryControllers;
+    private filter;
+}

package/dist/handlers/controller.handler.js

@@ -0,0 +1,77 @@
+import { Registry } from "@/di/registry";
+export default class ControllerHandler {
+    constructor(httpServer, port) {
+        for (const { instance, instanceMethod, middlewares, method, route, statusCode, params, query, validation } of this.registryControllers()) {
+            httpServer.register({
+                method,
+                route,
+                statusCode,
+                params,
+                query
+            }, async (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);
+    }
+    registryControllers() {
+        const registryControllers = Registry.resolve('controllers');
+        const controllers = [];
+        for (const controller of registryControllers) {
+            const basePath = Reflect.getMetadata('basePath', controller);
+            const injections = Reflect.getMetadata('injections', controller) || [];
+            const args = injections.map((token) => 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;
+    }
+    filter(params, filterParams) {
+        const filter = {};
+        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/handlers/index.d.ts

@@ -0,0 +1,2 @@
+import ControllerHandler from "./controller.handler";
+export { ControllerHandler };

package/dist/handlers/index.js

@@ -0,0 +1,2 @@
+import ControllerHandler from "./controller.handler";
+export { ControllerHandler };

package/dist/handlers/usecase.handler.d.ts

@@ -0,0 +1,5 @@
+import { UseCase } from "@/protocols";
+import { RequestData } from "..";
+export declare class UseCaseHandler {
+    static load<T extends UseCase<any, any>>(useCaseClass: new (...args: any[]) => T, request?: RequestData): T;
+}

package/dist/handlers/usecase.handler.js

@@ -0,0 +1,12 @@
+import { Registry } from "@/di/registry";
+export class UseCaseHandler {
+    static load(useCaseClass, request) {
+        const instance = Registry.classLoader(useCaseClass);
+        const auth = Reflect.getMetadata("auth", useCaseClass);
+        const context = request;
+        if (auth && context?.middlewareData) {
+            instance[auth] = context.middlewareData[auth];
+        }
+        return instance;
+    }
+}

package/dist/http/ElysiaHttpServer.d.ts

@@ -0,0 +1,5 @@
+import HttpServer from "./HttpServer";
+export declare class ElysiaHttpServer extends HttpServer {
+    constructor(uses?: CallableFunction[]);
+    listen(port: number): void;
+}

package/dist/http/ElysiaHttpServer.js

@@ -0,0 +1,13 @@
+// @ts-ignore 
+import Elysia from "elysia";
+import HttpServer from "./HttpServer";
+export class ElysiaHttpServer extends HttpServer {
+    constructor(uses) {
+        super(new Elysia(), 'elysia');
+        uses?.forEach(use => this.framework.use(use));
+    }
+    listen(port) {
+        super.listen(port);
+        console.log(`Server listening on port ${port}`);
+    }
+}

package/dist/http/ExpressHttpServer.d.ts

@@ -0,0 +1,5 @@
+import HttpServer from "./HttpServer";
+export declare class ExpressHttpServer extends HttpServer {
+    constructor(uses?: CallableFunction[]);
+    listen(port: number): void;
+}

package/dist/http/ExpressHttpServer.js

@@ -0,0 +1,14 @@
+// @ts-ignore 
+import express from "express";
+import HttpServer from "./HttpServer";
+const app = express();
+export class ExpressHttpServer extends HttpServer {
+    constructor(uses) {
+        super(app, 'express');
+        uses?.forEach(use => this.framework.use(use));
+    }
+    listen(port) {
+        super.listen(port);
+        console.log(`Server listening on port ${port}`);
+    }
+}

package/dist/http/FrameworkError.d.ts

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

package/dist/http/FrameworkError.js

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

package/dist/http/HttpServer.d.ts

@@ -0,0 +1,31 @@
+export 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: string;
+    constructor(framework: FrameworkWeb, frameworkName: 'elysia' | 'express');
+    use(middleware: CallableFunction): HttpServer;
+    register(httpServerParams: HttpServerParams, handler: CallableFunction): void;
+    listen(port: number): void;
+    private mountRoute;
+    private elysia;
+    private express;
+}
+export {};