@shadow-library/fastify 0.0.9 → 0.0.11

package/cjs/module/fastify-router.js

@@ -16,6 +16,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyRouter = void 0;
+/**
+ * Importing npm packages
+ */
 const node_assert_1 = __importDefault(require("node:assert"));
 const app_1 = require("@shadow-library/app");
 const class_schema_1 = require("@shadow-library/class-schema");
@@ -23,9 +26,15 @@ const common_1 = require("@shadow-library/common");
 const deepmerge_1 = __importDefault(require("deepmerge"));
 const find_my_way_1 = __importDefault(require("find-my-way"));
 const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+/**
+ * Importing user defined packages
+ */
 const constants_1 = require("../constants.js");
 const decorators_1 = require("../decorators/index.js");
 const services_1 = require("../services/index.js");
+/**
+ * Declaring the constants
+ */
 const httpMethods = Object.values(decorators_1.HttpMethod).filter(m => m !== decorators_1.HttpMethod.ALL);
 const DEFAULT_ARTIFACTS = { transforms: {} };
 let FastifyRouter = class FastifyRouter extends app_1.Router {
@@ -90,7 +99,7 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
                 metadata.reqIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
                 metadata.resLen = res.getHeader('content-length');
                 const resTime = process.hrtime(startTime);
-                metadata.timeTaken = (resTime[0] * 1e3 + resTime[1] * 1e-6).toFixed(3);
+                metadata.timeTaken = (resTime[0] * 1e3 + resTime[1] * 1e-6).toFixed(3); // Converting time to milliseconds
                 if (req.body)
                     metadata.body = transforms.maskBody ? transforms.maskBody(structuredClone(req.body)) : req.body;
                 if (req.query)
@@ -152,10 +161,12 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
             const query = request.query;
             const body = request.body;
             const context = { request, response, params, query, body };
+            /** Setting the status code and headers */
             response.status(statusCode);
             for (const [key, value] of Object.entries(metadata.headers ?? {})) {
                 response.header(key, typeof value === 'function' ? value() : value);
             }
+            /** Handling the actual route and serializing the output */
             const args = argsOrder.map(arg => arg && context[arg]);
             const data = await route.handler(...args);
             if (metadata.redirect)
@@ -176,11 +187,13 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
     async getMiddlewareHandler(middleware, metadata) {
         if (!middleware.metadata.generates)
             return middleware.handler.bind(middleware.instance);
+        /** Generating the cache key and getting the cached middleware */
         const genCacheKey = 'cacheKey' in middleware.instance && typeof middleware.instance.cacheKey === 'function' ? middleware.instance.cacheKey : json_stable_stringify_1.default;
         const cacheKey = genCacheKey(metadata);
         const cachedMiddleware = this.cachedDynamicMiddlewares.get(cacheKey);
         if (cachedMiddleware)
             return cachedMiddleware;
+        /** Generating the middleware handler */
         const handler = await middleware.handler.apply(middleware.instance, [metadata]);
         this.cachedDynamicMiddlewares.set(cacheKey, handler);
         return handler;
@@ -206,6 +219,7 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
             routeOptions.url = metadata.path;
             routeOptions.method = metadata.method === decorators_1.HttpMethod.ALL ? httpMethods : [metadata.method];
             routeOptions.handler = this.generateRouteHandler(route);
+            /** Applying middlewares */
             for (const middleware of middlewares) {
                 const name = middleware.metatype.name;
                 const { type } = middleware.metadata;
@@ -266,6 +280,11 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
         await this.instance.close();
         this.logger.info('server stopped');
     }
+    /**
+     * Creates a new child context derived from the current one to load route-specific data
+     * during SSR. Automatically reuses middleware results from the parent context to avoid
+     * redundant execution and ensures correct context isolation for nested route data fetching.
+     */
     async resolveChildRoute(url) {
         if (!this.childRouter)
             throw new common_1.InternalError('Child routes are not enabled');

package/cjs/module/fastify.module.d.ts

@@ -1,5 +1,11 @@
 import { Class } from 'type-fest';
 import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-module.interface.js';
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export declare class FastifyModule {
     private static getDefaultConfig;
     static forRoot(options: FastifyModuleOptions): Class<FastifyModule>;

package/cjs/module/fastify.module.js

@@ -1,16 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyModule = void 0;
+/**
+ * Importing npm packages
+ */
 const app_1 = require("@shadow-library/app");
 const class_schema_1 = require("@shadow-library/class-schema");
 const common_1 = require("@shadow-library/common");
 const uuid_1 = require("uuid");
+/**
+ * Importing user defined packages
+ */
 const classes_1 = require("../classes/index.js");
 const constants_1 = require("../constants.js");
 const services_1 = require("../services/index.js");
 const error_response_dto_1 = require("./error-response.dto.js");
 const fastify_router_1 = require("./fastify-router.js");
 const fastify_utils_1 = require("./fastify.utils.js");
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 class FastifyModule {
     static getDefaultConfig() {
         const errorResponseSchema = class_schema_1.ClassSchema.generate(error_response_dto_1.ErrorResponseDto);

package/cjs/module/fastify.utils.js

@@ -7,11 +7,23 @@ exports.notFoundHandler = void 0;
 exports.compileValidator = compileValidator;
 exports.formatSchemaErrors = formatSchemaErrors;
 exports.createFastifyInstance = createFastifyInstance;
+/**
+ * Importing npm packages
+ */
 const node_assert_1 = __importDefault(require("node:assert"));
 const common_1 = require("@shadow-library/common");
 const ajv_1 = __importDefault(require("ajv"));
 const fastify_1 = require("fastify");
+/**
+ * Importing user defined packages
+ */
 const server_error_1 = require("../server.error.js");
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 const keywords = ['x-fastify'];
 const allowedHttpParts = ['body', 'params', 'querystring'];
 const strictValidator = new ajv_1.default({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true, keywords });
@@ -39,12 +51,13 @@ function compileValidator(routeSchema) {
     return (data) => {
         validate(data);
         for (const error of validate.errors ?? []) {
+            /** Since this schema is for querystring there won't be any nested objects so we are directly accessing the path */
             const path = error.instancePath.substring(1);
             const defaultValue = routeSchema.schema.properties?.[path]?.default;
             if (defaultValue !== undefined)
                 data[path] = defaultValue;
             else
-                delete data[path];
+                delete data[path]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
         }
         return { value: data };
     };

package/cjs/server.error.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Importing npm packages
+ */
 import { AppError, ErrorCode, ErrorType } from '@shadow-library/common';
 export declare class ServerError extends AppError<ServerErrorCode> {
     getStatusCode(): number;
@@ -6,13 +9,25 @@ export declare class ServerErrorCode extends ErrorCode {
     private readonly statusCode;
     protected constructor(code: string, type: ErrorType, msg: string, statusCode?: number);
     getStatusCode(): number;
+    /*!
+     * List of all server related errors
+     */
+    /** An unexpected server error occurred while processing the request */
     static readonly S001: ServerErrorCode;
+    /** The requested endpoint does not exist */
     static readonly S002: ServerErrorCode;
+    /** The provided input data is invalid or does not meet validation requirements */
     static readonly S003: ServerErrorCode;
+    /** Authentication credentials are required to access this resource */
     static readonly S004: ServerErrorCode;
+    /** Access denied due to insufficient permissions to perform this operation */
     static readonly S005: ServerErrorCode;
+    /** The request is malformed or contains invalid parameters */
     static readonly S006: ServerErrorCode;
+    /** Rate limit exceeded due to too many requests sent in a given time frame */
     static readonly S007: ServerErrorCode;
+    /** Resource conflict as the requested operation conflicts with existing data */
     static readonly S008: ServerErrorCode;
+    /** The requested resource could not be found */
     static readonly S009: ServerErrorCode;
 }

package/cjs/server.error.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerErrorCode = exports.ServerError = void 0;
+/**
+ * Importing npm packages
+ */
 const common_1 = require("@shadow-library/common");
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 const ERROR_STATUS_CODES = {
     [common_1.ErrorType.CLIENT_ERROR]: 400,
     [common_1.ErrorType.HTTP_ERROR]: 400,
@@ -27,14 +39,26 @@ class ServerErrorCode extends common_1.ErrorCode {
     getStatusCode() {
         return this.statusCode;
     }
+    /*!
+     * List of all server related errors
+     */
+    /** An unexpected server error occurred while processing the request */
     static S001 = new ServerErrorCode('S001', common_1.ErrorType.SERVER_ERROR, 'An unexpected server error occurred while processing the request');
+    /** The requested endpoint does not exist */
     static S002 = new ServerErrorCode('S002', common_1.ErrorType.NOT_FOUND, 'The requested endpoint does not exist');
+    /** The provided input data is invalid or does not meet validation requirements */
     static S003 = new ServerErrorCode('S003', common_1.ErrorType.VALIDATION_ERROR, 'The provided input data is invalid or does not meet validation requirements');
+    /** Authentication credentials are required to access this resource */
     static S004 = new ServerErrorCode('S004', common_1.ErrorType.UNAUTHENTICATED, 'Authentication credentials are required to access this resource');
+    /** Access denied due to insufficient permissions to perform this operation */
     static S005 = new ServerErrorCode('S005', common_1.ErrorType.UNAUTHORIZED, 'Access denied due to insufficient permissions to perform this operation');
+    /** The request is malformed or contains invalid parameters */
     static S006 = new ServerErrorCode('S006', common_1.ErrorType.CLIENT_ERROR, 'The request is malformed or contains invalid parameters');
+    /** Rate limit exceeded due to too many requests sent in a given time frame */
     static S007 = new ServerErrorCode('S007', common_1.ErrorType.CLIENT_ERROR, 'Rate limit exceeded due to too many requests sent in a given time frame', 429);
+    /** Resource conflict as the requested operation conflicts with existing data */
     static S008 = new ServerErrorCode('S008', common_1.ErrorType.CONFLICT, 'Resource conflict as the requested operation conflicts with existing data');
+    /** The requested resource could not be found */
     static S009 = new ServerErrorCode('S009', common_1.ErrorType.NOT_FOUND, 'The requested resource could not be found');
 }
 exports.ServerErrorCode = ServerErrorCode;

package/cjs/services/context.service.d.ts

@@ -1,7 +1,15 @@
 import { onRequestHookHandler } from 'fastify';
+/**
+ * Importing user defined packages
+ */
 import { HttpRequest, HttpResponse } from '../interfaces/index.js';
+/**
+ * Defining types
+ */
 type Key = string | symbol;
-export declare class ContextService {
+export interface ContextExtension {
+}
+export declare class ContextService implements ContextExtension {
     static readonly name = "ContextService";
     private readonly storage;
     init(): onRequestHookHandler;
@@ -21,5 +29,6 @@ export declare class ContextService {
     getResponse(throwOnMissing: false): HttpResponse | null;
     getRID(): string;
     getRID(throwOnMissing: false): string | null;
+    extend<T extends ContextExtension = ContextExtension>(extension: T & ThisType<this & T>): this;
 }
 export {};

package/cjs/services/context.service.js

@@ -7,9 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextService = void 0;
+/**
+ * Importing npm packages
+ */
 const node_async_hooks_1 = require("node:async_hooks");
 const app_1 = require("@shadow-library/app");
 const common_1 = require("@shadow-library/common");
+/**
+ * Declaring the constants
+ */
 const REQUEST = Symbol('request');
 const RESPONSE = Symbol('response');
 const RID = Symbol('rid');
@@ -92,6 +98,9 @@ let ContextService = class ContextService {
     getRID(throwOnMissing = true) {
         return this.get(RID, throwOnMissing);
     }
+    extend(extension) {
+        return Object.assign(this, extension);
+    }
 };
 exports.ContextService = ContextService;
 exports.ContextService = ContextService = __decorate([

package/esm/classes/default-error-handler.d.ts

@@ -1,6 +1,12 @@
+/**
+ * Importing npm packages
+ */
 import { AppErrorObject } from '@shadow-library/common';
 import { FastifyError } from 'fastify';
 import { ErrorHandler, HttpRequest, HttpResponse } from '../interfaces/index.js';
+/**
+ * Defining types
+ */
 export interface ParsedFastifyError {
     statusCode: number;
     error: AppErrorObject;

package/esm/classes/default-error-handler.js

@@ -1,6 +1,15 @@
+/**
+ * Importing npm packages
+ */
 import { AppError, Logger, ValidationError } from '@shadow-library/common';
+/**
+ * Importing user defined packages
+ */
 import { NAMESPACE } from '../constants.js';
 import { ServerError, ServerErrorCode } from '../server.error.js';
+/**
+ * Declaring the constants
+ */
 const unexpectedError = new ServerError(ServerErrorCode.S001);
 const validationError = new ServerError(ServerErrorCode.S003);
 const invalidRequestError = new ServerError(ServerErrorCode.S006);

package/esm/constants.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export declare const NAMESPACE = "@shadow-library/fastify";
 export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const FASTIFY_CONFIG: unique symbol;

package/esm/constants.js

@@ -1,3 +1,15 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export const NAMESPACE = '@shadow-library/fastify';
 export const PARAMTYPES_METADATA = 'design:paramtypes';
 export const FASTIFY_CONFIG = Symbol('fastify-config');

package/esm/decorators/http-controller.decorator.d.ts

@@ -1 +1,7 @@
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export declare function HttpController(path?: string): ClassDecorator;

package/esm/decorators/http-controller.decorator.js

@@ -1,5 +1,17 @@
+/**
+ * Importing npm packages
+ */
 import { Controller } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export function HttpController(path = '') {
     if (path.charAt(0) !== '/')
         path = `/${path}`;

package/esm/decorators/http-input.decorator.d.ts

@@ -1,5 +1,8 @@
 import { JSONSchema } from '@shadow-library/class-schema';
 import { Class } from 'type-fest';
+/**
+ * Defining types
+ */
 export declare enum RouteInputType {
     BODY = "body",
     PARAMS = "params",
@@ -8,6 +11,9 @@ export declare enum RouteInputType {
     RESPONSE = "response"
 }
 export type RouteInputSchemas = Partial<Record<'body' | 'params' | 'query', JSONSchema | Class<unknown>>>;
+/**
+ * Declaring the constants
+ */
 export declare function HttpInput(type: RouteInputType, schema?: JSONSchema): ParameterDecorator;
 export declare const Body: (schema?: JSONSchema) => ParameterDecorator;
 export declare const Params: (schema?: JSONSchema) => ParameterDecorator;

package/esm/decorators/http-input.decorator.js

@@ -1,6 +1,15 @@
+/**
+ * Importing npm packages
+ */
 import assert from 'node:assert';
 import { Route } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_INPUTS, PARAMTYPES_METADATA } from '../constants.js';
+/**
+ * Defining types
+ */
 export var RouteInputType;
 (function (RouteInputType) {
     RouteInputType["BODY"] = "body";
@@ -9,6 +18,9 @@ export var RouteInputType;
     RouteInputType["REQUEST"] = "request";
     RouteInputType["RESPONSE"] = "response";
 })(RouteInputType || (RouteInputType = {}));
+/**
+ * Declaring the constants
+ */
 export function HttpInput(type, schema) {
     return (target, propertyKey, index) => {
         assert(propertyKey, 'Cannot apply decorator to a constructor parameter');

package/esm/decorators/http-output.decorator.d.ts

@@ -1,5 +1,14 @@
+/**
+ * Importing npm packages
+ */
 import { JSONSchema, SchemaClass } from '@shadow-library/class-schema';
 import { JsonObject } from 'type-fest';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export interface DynamicRender<T extends JsonObject> {
     template: string;
     data: T;

package/esm/decorators/http-output.decorator.js

@@ -1,5 +1,11 @@
+/**
+ * Importing npm packages
+ */
 import { Route } from '@shadow-library/app';
 import { ClassSchema } from '@shadow-library/class-schema';
+/**
+ * Declaring the constants
+ */
 const isClass = (schema) => schema.toString().startsWith('class ');
 export const HttpStatus = (status) => Route({ status });
 export const Header = (name, value) => Route({ headers: { [name]: value } });

package/esm/decorators/http-route.decorator.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export declare enum HttpMethod {
     GET = "GET",
     POST = "POST",
@@ -12,6 +18,9 @@ export interface RouteOptions {
     method: HttpMethod;
     path?: string;
 }
+/**
+ * Declaring the constants
+ */
 export declare function HttpRoute(options: RouteOptions): MethodDecorator;
 export declare const Get: (path?: string) => MethodDecorator;
 export declare const Post: (path?: string) => MethodDecorator;

package/esm/decorators/http-route.decorator.js

@@ -1,4 +1,13 @@
+/**
+ * Importing npm packages
+ */
 import { Route } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export var HttpMethod;
 (function (HttpMethod) {
     HttpMethod["GET"] = "GET";
@@ -10,6 +19,9 @@ export var HttpMethod;
     HttpMethod["HEAD"] = "HEAD";
     HttpMethod["ALL"] = "ALL";
 })(HttpMethod || (HttpMethod = {}));
+/**
+ * Declaring the constants
+ */
 export function HttpRoute(options) {
     if (options.path && options.path.charAt(0) !== '/')
         options.path = `/${options.path}`;

package/esm/decorators/middleware.decorator.d.ts

@@ -1,7 +1,18 @@
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+/**
+ * Defining types
+ */
 export type MiddlewareType = 'onRequest' | 'preParsing' | 'preValidation' | 'preHandler' | 'preSerialization' | 'onSend' | 'onResponse' | 'onError';
 export interface MiddlewareOptions {
+    /**
+     * Denotes when to execute the middleware. default value is `preHandler`.
+     * see https://fastify.dev/docs/latest/Reference/Lifecycle for more information
+     */
     type: MiddlewareType;
+    /** Denotes the execution order, the higher value gets executed first */
     weight: number;
 }
 export interface MiddlewareMetadata extends MiddlewareOptions {

package/esm/decorators/middleware.decorator.js

@@ -1,6 +1,15 @@
+/**
+ * Importing npm packages
+ */
 import assert from 'node:assert';
 import { Controller } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+/**
+ * Declaring the constants
+ */
 const propertyKeys = ['generate', 'use'];
 export function Middleware(options = {}) {
     if (!options.type)

package/esm/decorators/sensitive.decorator.d.ts

@@ -1,4 +1,13 @@
 import { MaskOptions } from '@shadow-library/common';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export type SensitiveDataType = 'secret' | 'email' | 'number' | 'words';
+/**
+ * Declaring the constants
+ */
 export declare function Sensitive(type?: SensitiveDataType): PropertyDecorator;
 export declare function Sensitive(maskOptions: MaskOptions): PropertyDecorator;

package/esm/decorators/sensitive.decorator.js

@@ -1,3 +1,6 @@
+/**
+ * Importing npm packages
+ */
 import { FieldMetadata } from '@shadow-library/class-schema';
 export function Sensitive(typeOrMaskOptions = 'secret') {
     return (target, propertyKey) => {

package/esm/index.d.ts

@@ -1,4 +1,10 @@
+/**
+ * Importing npm packages
+ */
 import 'reflect-metadata';
+/**
+ * exporting modules
+ */
 export * from './classes/index.js';
 export * from './decorators/index.js';
 export * from './interfaces/index.js';

package/esm/index.js

@@ -1,4 +1,10 @@
+/**
+ * Importing npm packages
+ */
 import 'reflect-metadata';
+/**
+ * exporting modules
+ */
 export * from './classes/index.js';
 export * from './decorators/index.js';
 export * from './interfaces/index.js';

package/esm/interfaces/error-handler.interface.d.ts

@@ -1,4 +1,16 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
 import { HttpRequest, HttpResponse } from './route-handler.interface.js';
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export interface ErrorHandler {
     handle(err: Error, req: HttpRequest, res: HttpResponse): any | Promise<any>;
 }

package/esm/interfaces/error-handler.interface.js

@@ -1 +1,4 @@
+/**
+ * Importing npm packages
+ */
 export {};

package/esm/interfaces/middleware.interface.d.ts

@@ -1,5 +1,14 @@
+/**
+ * Importing npm packages
+ */
 import { RouteMetadata } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HttpCallback, HttpRequest, HttpResponse, RouteHandler } from './route-handler.interface.js';
+/**
+ * Defining types
+ */
 export interface MiddlewareGenerator {
     cacheKey?: (metadata: RouteMetadata) => string;
     generate(metadata: RouteMetadata): RouteHandler | undefined | Promise<RouteHandler | undefined>;

package/esm/interfaces/route-handler.interface.d.ts

@@ -1,5 +1,17 @@
+/**
+ * Importing npm packages
+ */
 import { SyncValue } from '@shadow-library/common';
 import { DoneFuncWithErrOrRes, FastifyReply, FastifyRequest } from 'fastify';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export type HttpRequest = FastifyRequest;
 export type HttpResponse = FastifyReply;
 export type HttpCallback = DoneFuncWithErrOrRes;

package/esm/interfaces/server-metadata.interface.d.ts

@@ -1,8 +1,17 @@
+/**
+ * Importing npm packages
+ */
 import { RouteMetadata } from '@shadow-library/app';
 import { JSONSchema } from '@shadow-library/class-schema';
 import { RouteShorthandOptions } from 'fastify';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
 import { HttpMethod, RouteInputSchemas } from '../decorators/index.js';
+/**
+ * Defining types
+ */
 declare module '@shadow-library/app' {
     interface RouteMetadata extends Omit<RouteShorthandOptions, 'config'> {
         method?: HttpMethod;