framework-do-dede 0.0.13 → 0.0.15

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/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/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 {};

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 };