@carno.js/core 0.2.3

package/dist/Cheetah.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cheetah = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+const index_1 = require("./commons/index");
+const constants_1 = require("./constants");
+const createContainer_1 = require("./container/createContainer");
+const createInjector_1 = require("./container/createInjector");
+const domain_1 = require("./domain");
+const Context_1 = require("./domain/Context");
+const LocalsContainer_1 = require("./domain/LocalsContainer");
+const cors_config_1 = require("./domain/cors-config");
+const on_event_1 = require("./events/on-event");
+const HttpException_1 = require("./exceptions/HttpException");
+const RouteExecutor_1 = require("./route/RouteExecutor");
+const memoirist_1 = __importDefault(require("./route/memoirist"));
+const logger_service_1 = require("./services/logger.service");
+const parseUrl = require("parseurl-fast");
+// todo: change console.log for LoggerService.
+class Cheetah {
+    constructor(config = {}) {
+        this.config = config;
+        this.router = new memoirist_1.default();
+        this.injector = (0, createInjector_1.createInjector)();
+        this.fetch = async (request, server) => {
+            try {
+                return await this.fetcher(request, server);
+            }
+            catch (error) {
+                if (error instanceof HttpException_1.HttpException) {
+                    let response = new Response(JSON.stringify({
+                        message: error.getResponse(),
+                        statusCode: error.getStatus(),
+                    }), {
+                        status: error.statusCode,
+                        headers: { "Content-Type": "application/json" },
+                    });
+                    if (this.isCorsEnabled()) {
+                        const origin = request.headers.get("origin");
+                        if (origin && this.isOriginAllowed(origin)) {
+                            response = this.applyCorsHeaders(response, origin);
+                        }
+                    }
+                    return response;
+                }
+                throw error;
+            }
+        };
+        this.catcher = (error) => {
+            console.error("Unhandled error:", error);
+            return new Response("Internal Server Error", { status: 500 });
+        };
+        void this.bootstrapApplication();
+    }
+    /**
+     * Use the Cheetah plugin.
+     *
+     * @param plugin
+     */
+    use(plugin) {
+        if (!this.config.providers) {
+            this.config.providers = [];
+        }
+        if (!this.config.globalMiddlewares) {
+            this.config.globalMiddlewares = [];
+        }
+        for (const exportProvider of plugin.config.exports || []) {
+            const existingProvider = this.findProviderInConfig(plugin, exportProvider);
+            const providerToAdd = this.shouldCloneProvider(existingProvider)
+                ? this.cloneProvider(existingProvider)
+                : exportProvider;
+            this.config.providers.push(providerToAdd);
+        }
+        if (plugin.config.globalMiddlewares) {
+            this.config.globalMiddlewares.push(...plugin.config.globalMiddlewares);
+        }
+        return this;
+    }
+    findProviderInConfig(plugin, exportProvider) {
+        return plugin.config.providers?.find((p) => this.getProviderToken(p) === this.getProviderToken(exportProvider));
+    }
+    getProviderToken(provider) {
+        return provider?.provide || provider;
+    }
+    shouldCloneProvider(provider) {
+        return !!(provider?.useValue !== undefined || provider?.useClass);
+    }
+    cloneProvider(provider) {
+        return { ...provider };
+    }
+    /**
+     * Set the custom logger provider.
+     * The provider must be a class with the @Service() decorator.
+     * The provider must extend the LoggerService class.
+     *
+     * @param provider
+     */
+    useLogger(provider) {
+        (0, index_1.registerProvider)({ provide: logger_service_1.LoggerService, useClass: provider });
+        return this;
+    }
+    loadProvidersAndControllers() {
+        const providers = domain_1.Metadata.get(constants_1.PROVIDER, Reflect) || [];
+        const controllers = domain_1.Metadata.get(constants_1.CONTROLLER, Reflect) || [];
+        this.registerControllers(controllers);
+        this.registerMetadataProviders(providers);
+        this.registerConfigProviders();
+    }
+    registerControllers(controllers) {
+        for (const controller of controllers) {
+            (0, index_1.registerController)(controller);
+            controller.options?.children &&
+                controller.options.children.forEach((child) => {
+                    (0, index_1.registerController)({ provide: child, parent: controller.provide });
+                });
+        }
+    }
+    registerMetadataProviders(providers) {
+        for (const provider of providers) {
+            (0, index_1.registerProvider)(provider);
+        }
+    }
+    registerConfigProviders() {
+        if (!this.config.providers) {
+            return;
+        }
+        for (const provider of this.config.providers) {
+            const normalized = this.normalizeProvider(provider);
+            (0, index_1.registerProvider)(normalized);
+        }
+    }
+    normalizeProvider(provider) {
+        if (provider?.provide) {
+            return provider;
+        }
+        return {
+            provide: provider,
+            useClass: provider,
+        };
+    }
+    async init() {
+        this.loadProvidersAndControllers();
+        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router);
+    }
+    async listen(port = 3000) {
+        this.registerShutdownHandlers();
+        await this.init();
+        this.createHttpServer(port);
+    }
+    registerShutdownHandlers() {
+        const shutdown = async (signal) => {
+            console.log(`\nReceived ${signal}, starting graceful shutdown...`);
+            await this.handleShutdownHook();
+        };
+        node_process_1.default.on("SIGTERM", () => shutdown("SIGTERM"));
+        node_process_1.default.on("SIGINT", () => shutdown("SIGINT"));
+    }
+    getHttpServer() {
+        return this.server;
+    }
+    getInjector() {
+        return this.injector;
+    }
+    createHttpServer(port) {
+        this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
+        console.log(`Server running on port ${port}`);
+    }
+    async fetcher(request, server) {
+        if (this.isCorsEnabled()) {
+            const origin = request.headers.get("origin");
+            if (request.method === "OPTIONS" && origin) {
+                return this.handlePreflightRequest(request);
+            }
+        }
+        const urlParsed = parseUrl(request);
+        const context = await Context_1.Context.createFromRequest(urlParsed, request, server);
+        await this.injector.callHook(on_event_1.EventType.OnRequest, { context });
+        const local = new LocalsContainer_1.LocalsContainer();
+        const routePath = this.discoverRoutePath(urlParsed);
+        const route = this.router.find(request.method.toLowerCase(), routePath);
+        if (!route) {
+            throw new HttpException_1.HttpException("Method not allowed", 404);
+        }
+        context.param = route.params;
+        local.set(Context_1.Context, context);
+        let response = await RouteExecutor_1.RouteExecutor.executeRoute(route.store, this.injector, context, local);
+        if (this.isCorsEnabled()) {
+            const origin = request.headers.get("origin");
+            if (origin && this.isOriginAllowed(origin)) {
+                response = this.applyCorsHeaders(response, origin);
+            }
+        }
+        return response;
+    }
+    async bootstrapApplication() {
+        try {
+            await this.injector.callHook(on_event_1.EventType.OnApplicationBoot, {});
+        }
+        catch (error) {
+            this.reportHookFailure(on_event_1.EventType.OnApplicationBoot, error);
+        }
+    }
+    async handleShutdownHook() {
+        try {
+            await this.injector.callHook(on_event_1.EventType.OnApplicationShutdown);
+            this.closeHttpServer();
+            this.exitProcess();
+        }
+        catch (error) {
+            this.reportHookFailure(on_event_1.EventType.OnApplicationShutdown, error);
+            this.exitProcess(1);
+        }
+    }
+    closeHttpServer() {
+        if (this.server) {
+            console.log("Closing HTTP server...");
+            this.server.stop(true);
+        }
+    }
+    exitProcess(code = 0) {
+        console.log("Shutdown complete.");
+        node_process_1.default.exit(code);
+    }
+    reportHookFailure(event, error) {
+        console.error(`Lifecycle hook ${event} failed`, error);
+    }
+    isCorsEnabled() {
+        return !!this.config.cors;
+    }
+    isOriginAllowed(origin) {
+        if (!origin || !this.config.cors) {
+            return false;
+        }
+        const { origins } = this.config.cors;
+        if (typeof origins === "string") {
+            return origins === "*" || origins === origin;
+        }
+        if (Array.isArray(origins)) {
+            return origins.includes(origin);
+        }
+        if (origins instanceof RegExp) {
+            return origins.test(origin);
+        }
+        if (typeof origins === "function") {
+            return origins(origin);
+        }
+        return false;
+    }
+    buildCorsHeaders(origin) {
+        const cors = this.config.cors;
+        const headers = {};
+        const allowedOrigin = typeof cors.origins === "string" && cors.origins === "*"
+            ? "*"
+            : origin;
+        headers["Access-Control-Allow-Origin"] = allowedOrigin;
+        if (cors.credentials) {
+            headers["Access-Control-Allow-Credentials"] = "true";
+        }
+        const methods = cors.methods || cors_config_1.DEFAULT_CORS_METHODS;
+        headers["Access-Control-Allow-Methods"] = methods.join(", ");
+        const allowedHeaders = cors.allowedHeaders || cors_config_1.DEFAULT_CORS_ALLOWED_HEADERS;
+        headers["Access-Control-Allow-Headers"] = allowedHeaders.join(", ");
+        if (cors.exposedHeaders && cors.exposedHeaders.length > 0) {
+            headers["Access-Control-Expose-Headers"] = cors.exposedHeaders.join(", ");
+        }
+        if (cors.maxAge !== undefined) {
+            headers["Access-Control-Max-Age"] = cors.maxAge.toString();
+        }
+        return headers;
+    }
+    handlePreflightRequest(request) {
+        const origin = request.headers.get("origin");
+        if (!this.isOriginAllowed(origin)) {
+            return new Response(null, { status: 403 });
+        }
+        const corsHeaders = this.buildCorsHeaders(origin);
+        return new Response(null, {
+            status: 204,
+            headers: corsHeaders,
+        });
+    }
+    applyCorsHeaders(response, origin) {
+        const corsHeaders = this.buildCorsHeaders(origin);
+        const newHeaders = new Headers(response.headers);
+        for (const [key, value] of Object.entries(corsHeaders)) {
+            newHeaders.set(key, value);
+        }
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: newHeaders,
+        });
+    }
+    close(closeActiveConnections = false) {
+        this.server?.stop(closeActiveConnections);
+    }
+    discoverRoutePath(url) {
+        if (url?.pathname) {
+            return url.pathname;
+        }
+        return url?.path || "/";
+    }
+}
+exports.Cheetah = Cheetah;

package/dist/cache/bento-cache.driver.d.ts

@@ -0,0 +1,13 @@
+import { LoggerService } from '../services/logger.service';
+import { CacheService } from './cache.service';
+export declare class BentoCacheDriver extends CacheService {
+    private readonly logger;
+    private cache;
+    constructor(logger: LoggerService);
+    set(key: string, value: any, ttl?: number): Promise<boolean>;
+    get(key: string): Promise<any>;
+    del(key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    getOrSet(key: string, cb: () => Promise<any>, ttl?: number): Promise<any>;
+}

package/dist/cache/bento-cache.driver.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BentoCacheDriver = void 0;
+const service_decorator_1 = require("../commons/decorators/service.decorator");
+const logger_service_1 = require("../services/logger.service");
+const cache_service_1 = require("./cache.service");
+const bentocache_1 = require("bentocache");
+// @ts-ignore
+const memory_1 = require("bentocache/drivers/memory");
+let BentoCacheDriver = class BentoCacheDriver extends cache_service_1.CacheService {
+    constructor(logger) {
+        super();
+        this.logger = logger;
+        this.cache = new bentocache_1.BentoCache({
+            //@ts-ignore
+            logger: this.logger.getLogger(),
+            default: 'defaultCache',
+            stores: {
+                defaultCache: (0, bentocache_1.bentostore)().useL1Layer(((0, memory_1.memoryDriver)({ maxSize: 10_000 }))), // TODO: Not default, custom with properties.
+            }
+        });
+    }
+    set(key, value, ttl) {
+        return this.cache.set({ key, value, ttl: ttl ?? '1h' });
+    }
+    get(key) {
+        return this.cache.get({ key });
+    }
+    del(key) {
+        return this.cache.delete({ key });
+    }
+    has(key) {
+        return this.cache.has({ key });
+    }
+    clear() {
+        return this.cache.clear();
+    }
+    getOrSet(key, cb, ttl) {
+        return this.cache.getOrSet({ key, factory: cb, ttl: ttl ?? '1h' });
+    }
+};
+exports.BentoCacheDriver = BentoCacheDriver;
+exports.BentoCacheDriver = BentoCacheDriver = __decorate([
+    (0, service_decorator_1.Service)({ provide: cache_service_1.CacheService }),
+    __metadata("design:paramtypes", [logger_service_1.LoggerService])
+], BentoCacheDriver);

package/dist/cache/cache.service.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class CacheService {
+    abstract set(key: string, value: any, ttl?: number): Promise<boolean>;
+    abstract get(key: string): Promise<any>;
+    abstract del(key: string): Promise<boolean>;
+    abstract has(key: string): Promise<boolean>;
+    abstract clear(): Promise<void>;
+    abstract getOrSet<T>(key: string, cb: () => Promise<T>, ttl?: number): Promise<T>;
+}

package/dist/cache/cache.service.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = void 0;
+class CacheService {
+}
+exports.CacheService = CacheService;

package/dist/commons/decorators/Injectable.decorator.d.ts

@@ -0,0 +1,20 @@
+import { Provider } from "../../domain/provider";
+/**
+ * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
+ * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
+ *
+ * ::: tip
+ * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
+ * :::
+ *
+ * ### Options
+ *
+ * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
+ * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
+ * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
+ * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
+ *
+ * @returns {Function}
+ * @decorator
+ */
+export declare function Injectable(options?: Partial<Provider>): ClassDecorator;

package/dist/commons/decorators/Injectable.decorator.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = Injectable;
+const Metadata_1 = require("../../domain/Metadata");
+const constants_1 = require("../../constants");
+/**
+ * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
+ * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
+ *
+ * ::: tip
+ * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
+ * :::
+ *
+ * ### Options
+ *
+ * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
+ * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
+ * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
+ * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
+ *
+ * @returns {Function}
+ * @decorator
+ */
+function Injectable(options = {}) {
+    return (target) => {
+        const providers = Metadata_1.Metadata.get(constants_1.PROVIDER, Reflect) || [];
+        providers.push({
+            ...options,
+            ...(options.provide ? { useClass: target } : { provide: target }),
+        });
+        Metadata_1.Metadata.set(constants_1.PROVIDER, providers, Reflect);
+    };
+}

package/dist/commons/decorators/controller.decorator.d.ts

@@ -0,0 +1,8 @@
+import { ProviderScope } from "../../domain/provider-scope";
+type ControllerOptions = {
+    path?: string;
+    scope?: ProviderScope;
+    children?: any[];
+};
+export declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
+export {};

package/dist/commons/decorators/controller.decorator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = Controller;
+const constants_1 = require("../../constants");
+const Metadata_1 = require("../../domain/Metadata");
+function normalizeOptions(pathOrOptions) {
+    if (!pathOrOptions) {
+        return {};
+    }
+    if (typeof pathOrOptions === 'string') {
+        return { path: pathOrOptions };
+    }
+    return pathOrOptions;
+}
+function Controller(pathOrOptions) {
+    return (target) => {
+        const options = normalizeOptions(pathOrOptions);
+        const controllers = Metadata_1.Metadata.get(constants_1.CONTROLLER, Reflect) || [];
+        controllers.push({ provide: target, ...options });
+        Metadata_1.Metadata.set(constants_1.CONTROLLER, controllers, Reflect);
+    };
+}

package/dist/commons/decorators/http.decorators.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "../../domain/Context";
+export declare function createParamDecorator(func: (context: Context, data?: any) => any): (data?: any) => ParameterDecorator;
+export declare const Body: (data?: any) => ParameterDecorator;
+export declare const Query: (data?: any) => ParameterDecorator;
+export declare const Param: (data?: any) => ParameterDecorator;
+export declare const Req: (data?: any) => ParameterDecorator;
+export declare const Headers: (data?: any) => ParameterDecorator;
+export declare const Locals: (data?: any) => ParameterDecorator;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;

package/dist/commons/decorators/http.decorators.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.Locals = exports.Headers = exports.Req = exports.Param = exports.Query = exports.Body = void 0;
+exports.createParamDecorator = createParamDecorator;
+const Metadata_1 = require("../../domain/Metadata");
+const constants_1 = require("../../constants");
+const createMethodDecorator = (methodType) => {
+    return (path = "") => {
+        return (target, propertyKey) => {
+            const routes = [];
+            if (!path.startsWith("/")) {
+                path = `/${path}`;
+            }
+            if (Metadata_1.Metadata.has(constants_1.CONTROLLER_ROUTES, target)) {
+                routes.push(...Metadata_1.Metadata.get(constants_1.CONTROLLER_ROUTES, target));
+            }
+            routes.push({
+                method: methodType,
+                path,
+                methodName: propertyKey.toString(),
+                middlewares: [],
+            });
+            Metadata_1.Metadata.set(constants_1.CONTROLLER_ROUTES, routes, target);
+        };
+    };
+};
+function createParamDecorator(func) {
+    return (data) => (target, propertyKey, parameterIndex) => {
+        const existingArgs = Metadata_1.Metadata.get(constants_1.ROUTE_PARAM, target.constructor, propertyKey) || {};
+        existingArgs[parameterIndex] = { fun: func, param: data };
+        Metadata_1.Metadata.set(constants_1.ROUTE_PARAM, existingArgs, target.constructor, propertyKey);
+    };
+}
+exports.Body = createParamDecorator((context, data) => data ? context.body[data] : context.body || {});
+exports.Query = createParamDecorator((context, data) => data ? context.query[data] : context.query || {});
+exports.Param = createParamDecorator((context, data) => data ? context.param[data] : null);
+exports.Req = createParamDecorator((context) => context.req);
+exports.Headers = createParamDecorator((context, data) => data ? (context.headers.has(data) ? context.headers.get(data) : undefined) : context.headers || {});
+exports.Locals = createParamDecorator((context) => context.locals || {});
+exports.Get = createMethodDecorator("GET");
+exports.Post = createMethodDecorator("POST");
+exports.Put = createMethodDecorator("PUT");
+exports.Delete = createMethodDecorator("DELETE");
+exports.Patch = createMethodDecorator("PATCH");

package/dist/commons/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './controller.decorator';
+export * from './http.decorators';
+export * from './service.decorator';
+export * from './middleware.decorator';
+export * from './Injectable.decorator';

package/dist/commons/decorators/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./controller.decorator"), exports);
+__exportStar(require("./http.decorators"), exports);
+__exportStar(require("./service.decorator"), exports);
+__exportStar(require("./middleware.decorator"), exports);
+__exportStar(require("./Injectable.decorator"), exports);

package/dist/commons/decorators/inject.decorator.d.ts

@@ -0,0 +1 @@
+export declare const Inject: (data?: any) => ParameterDecorator;

package/dist/commons/decorators/inject.decorator.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = void 0;
+const http_decorators_1 = require("./http.decorators");
+exports.Inject = (0, http_decorators_1.createParamDecorator)(() => { });

package/dist/commons/decorators/middleware.decorator.d.ts

@@ -0,0 +1,2 @@
+import { CarnoMiddleware } from "../../domain/CarnoMiddleware";
+export declare function Middleware(...middlewares: (new (...args: any[]) => CarnoMiddleware)[]): ClassDecorator & MethodDecorator;

package/dist/commons/decorators/middleware.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = Middleware;
+const constants_1 = require("../../constants");
+function Middleware(...middlewares) {
+    return (target, propertyKey) => {
+        let definedMiddlewares;
+        if (propertyKey)
+            definedMiddlewares = getMethodMiddlewares(target, propertyKey.toString());
+        else
+            definedMiddlewares = getControllerMiddlewares(target);
+        definedMiddlewares.push(...middlewares);
+        if (propertyKey)
+            setMethodMiddlewares(target, propertyKey.toString(), definedMiddlewares);
+        else
+            setControllerMiddlewares(target, definedMiddlewares);
+    };
+}
+function getControllerMiddlewares(target) {
+    return Reflect.getMetadata(constants_1.CONTROLLER_MIDDLEWARES, target) || [];
+}
+function setControllerMiddlewares(target, middlewares) {
+    Reflect.defineMetadata(constants_1.CONTROLLER_MIDDLEWARES, middlewares, target);
+}
+function getMethodMiddlewares(target, methodName) {
+    return Reflect.getMetadata(constants_1.ROUTE_MIDDLEWARES, target.constructor, methodName) || [];
+}
+function setMethodMiddlewares(target, methodName, middlewares) {
+    Reflect.defineMetadata(constants_1.ROUTE_MIDDLEWARES, middlewares, target.constructor, methodName);
+}

package/dist/commons/decorators/service.decorator.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '../../domain/provider';
+export declare function Service(options?: Partial<Provider>): ClassDecorator;

package/dist/commons/decorators/service.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = Service;
+const Injectable_decorator_1 = require("./Injectable.decorator");
+function Service(options = {}) {
+    return (0, Injectable_decorator_1.Injectable)(options);
+}