@shadow-library/fastify 0.0.1

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

@@ -0,0 +1,23 @@
+import { Route } from '@shadow-library/app';
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["ALL"] = "ALL";
+})(HttpMethod || (HttpMethod = {}));
+export function HttpRoute(options) {
+    return Route(options);
+}
+export const Get = (path) => HttpRoute({ method: HttpMethod.GET, path });
+export const Post = (path) => HttpRoute({ method: HttpMethod.POST, path });
+export const Put = (path) => HttpRoute({ method: HttpMethod.PUT, path });
+export const Delete = (path) => HttpRoute({ method: HttpMethod.DELETE, path });
+export const Patch = (path) => HttpRoute({ method: HttpMethod.PATCH, path });
+export const Options = (path) => HttpRoute({ method: HttpMethod.OPTIONS, path });
+export const Head = (path) => HttpRoute({ method: HttpMethod.HEAD, path });
+export const All = (path) => HttpRoute({ method: HttpMethod.ALL, path });

package/esm/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './http-controller.decorator.js';
+export * from './http-input.decorator.js';
+export * from './http-output.decorator.js';
+export * from './http-route.decorator.js';
+export * from './middleware.decorator.js';

package/esm/decorators/index.js

@@ -0,0 +1,5 @@
+export * from './http-controller.decorator.js';
+export * from './http-input.decorator.js';
+export * from './http-output.decorator.js';
+export * from './http-route.decorator.js';
+export * from './middleware.decorator.js';

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

@@ -0,0 +1,11 @@
+import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+export type MiddlewareType = 'onRequest' | 'preParsing' | 'preValidation' | 'preHandler' | 'preSerialization' | 'onSend' | 'onResponse' | 'onError';
+export interface MiddlewareOptions {
+    type: MiddlewareType;
+    weight: number;
+}
+export interface MiddlewareMetadata extends MiddlewareOptions {
+    [HTTP_CONTROLLER_TYPE]: 'middleware';
+    generates: boolean;
+}
+export declare function Middleware(options?: Partial<MiddlewareOptions>): ClassDecorator;

package/esm/decorators/middleware.decorator.js

@@ -0,0 +1,15 @@
+import assert from 'assert';
+import { Controller } from '@shadow-library/app';
+import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+const propertyKeys = ['generate', 'use'];
+export function Middleware(options = {}) {
+    if (!options.type)
+        options.type = 'preHandler';
+    if (!options.weight)
+        options.weight = 0;
+    return target => {
+        const key = propertyKeys.find(key => key in target.prototype);
+        assert(key, `Cannot apply @Middleware to a class without a 'generate()' or 'use()' method`);
+        Controller({ ...options, [HTTP_CONTROLLER_TYPE]: 'middleware', generates: key === 'generate' })(target);
+    };
+}

package/esm/index.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+export * from './classes/index.js';
+export * from './decorators/index.js';
+export * from './interfaces/index.js';
+export * from './module/index.js';
+export * from './services/index.js';
+export * from './server.error.js';

package/esm/index.js

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+export * from './classes/index.js';
+export * from './decorators/index.js';
+export * from './interfaces/index.js';
+export * from './module/index.js';
+export * from './services/index.js';
+export * from './server.error.js';

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

@@ -0,0 +1,4 @@
+import { HttpRequest, HttpResponse } from './route-handler.interface.js';
+export interface ErrorHandler {
+    handle(err: Error, req: HttpRequest, res: HttpResponse): any | Promise<any>;
+}

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

@@ -0,0 +1 @@
+export {};

package/esm/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './error-handler.interface.js';
+export * from './middleware.interface.js';
+export * from './route-handler.interface.js';
+export * from './server-metadata.interface.js';

package/esm/interfaces/index.js

@@ -0,0 +1,4 @@
+export * from './error-handler.interface.js';
+export * from './middleware.interface.js';
+export * from './route-handler.interface.js';
+export * from './server-metadata.interface.js';

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

@@ -0,0 +1,9 @@
+import { RouteMetdata } from '@shadow-library/app';
+import { HttpRequest, HttpResponse } from './route-handler.interface.js';
+export type MiddlewareHandler = (request: HttpRequest, response: HttpResponse) => Promise<any>;
+export interface MiddlewareGenerator {
+    generate(metadata: RouteMetdata): MiddlewareHandler | undefined | Promise<MiddlewareHandler | undefined>;
+}
+export interface HttpMiddleware {
+    use(request: HttpRequest, response: HttpResponse): Promise<any>;
+}

package/esm/interfaces/middleware.interface.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+export type HttpRequest = FastifyRequest;
+export type HttpResponse = FastifyReply;
+export type RouteHandler = (req: HttpRequest, res: HttpResponse) => unknown | Promise<unknown>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import { RouteMetdata } from '@shadow-library/app';
+import { JSONSchema } from '@shadow-library/class-schema';
+import { RouteShorthandOptions } from 'fastify';
+import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+import { HttpMethod, RouteInputSchemas } from '../decorators/index.js';
+declare module '@shadow-library/app' {
+    interface RouteMetdata extends Omit<RouteShorthandOptions, 'config'> {
+        method?: HttpMethod;
+        path?: string;
+        schemas?: RouteInputSchemas & {
+            response?: Record<number | string, JSONSchema>;
+        };
+        rawBody?: boolean;
+        status?: number;
+        headers?: Record<string, string | (() => string)>;
+        redirect?: string;
+        render?: string | true;
+    }
+    interface ControllerMetdata {
+        [HTTP_CONTROLLER_TYPE]?: 'router' | 'middleware';
+        path?: string;
+    }
+}
+export type ServerMetadata = RouteMetdata;

package/esm/interfaces/server-metadata.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/module/error-response.dto.d.ts

@@ -0,0 +1,10 @@
+export declare class ErrorFieldDto {
+    field: string;
+    msg: string;
+}
+export declare class ErrorResponseDto {
+    code: string;
+    type: string;
+    message: string;
+    fields: ErrorFieldDto[];
+}

package/esm/module/error-response.dto.js

@@ -0,0 +1,52 @@
+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);
+};
+import { Field, Schema } from '@shadow-library/class-schema';
+let ErrorFieldDto = class ErrorFieldDto {
+    field;
+    msg;
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ErrorFieldDto.prototype, "field", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ErrorFieldDto.prototype, "msg", void 0);
+ErrorFieldDto = __decorate([
+    Schema()
+], ErrorFieldDto);
+export { ErrorFieldDto };
+let ErrorResponseDto = class ErrorResponseDto {
+    code;
+    type;
+    message;
+    fields;
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ErrorResponseDto.prototype, "code", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ErrorResponseDto.prototype, "type", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], ErrorResponseDto.prototype, "message", void 0);
+__decorate([
+    Field(() => [ErrorFieldDto], { required: false }),
+    __metadata("design:type", Array)
+], ErrorResponseDto.prototype, "fields", void 0);
+ErrorResponseDto = __decorate([
+    Schema()
+], ErrorResponseDto);
+export { ErrorResponseDto };

package/esm/module/fastify-module.interface.d.ts

@@ -0,0 +1,19 @@
+import { FactoryProvider, ModuleMetadata } from '@shadow-library/app';
+import { JSONSchema } from '@shadow-library/class-schema';
+import { FastifyInstance, FastifyServerOptions } from 'fastify';
+import { Promisable } from 'type-fest';
+import { ErrorHandler } from '../interfaces/index.js';
+export interface FastifyConfig extends FastifyServerOptions {
+    host: string;
+    port: number;
+    errorHandler: ErrorHandler;
+    responseSchema?: Record<string | number, JSONSchema>;
+}
+export interface FastifyModuleOptions extends Partial<FastifyConfig> {
+    imports?: ModuleMetadata['imports'];
+    fastifyFactory?: (instance: FastifyInstance) => Promisable<FastifyInstance>;
+}
+export interface FastifyModuleAsyncOptions extends Pick<FastifyModuleOptions, 'imports' | 'fastifyFactory'> {
+    useFactory: (...args: any[]) => Promisable<FastifyConfig>;
+    inject?: FactoryProvider['inject'];
+}

package/esm/module/fastify-module.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/module/fastify-router.d.ts

@@ -0,0 +1,36 @@
+import { ControllerRouteMetadata, Router } from '@shadow-library/app';
+import { type FastifyInstance } from 'fastify';
+import { Chain as MockRequestChain, InjectOptions as MockRequestOptions, Response as MockResponse } from 'light-my-request';
+import { JsonObject } from 'type-fest';
+import { HttpRequest, HttpResponse, ServerMetadata } from '../interfaces/index.js';
+import { type FastifyConfig } from './fastify-module.interface.js';
+declare module 'fastify' {
+    interface FastifyRequest {
+        rawBody?: Buffer;
+    }
+    interface FastifyContextConfig {
+        metadata: ServerMetadata;
+    }
+}
+export interface RequestContext {
+    request: HttpRequest;
+    response: HttpResponse;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: JsonObject;
+}
+export declare class FastifyRouter extends Router {
+    private readonly config;
+    private readonly instance;
+    private readonly logger;
+    constructor(config: FastifyConfig, instance: FastifyInstance);
+    getInstance(): FastifyInstance;
+    private registerRawBody;
+    private parseControllers;
+    private getStatusCode;
+    private generateRouteHandler;
+    register(controllers: ControllerRouteMetadata[]): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    mockRequest(options?: MockRequestOptions): MockRequestChain | Promise<MockResponse>;
+}

package/esm/module/fastify-router.js

@@ -0,0 +1,176 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var FastifyRouter_1;
+import assert from 'assert';
+import { Inject, Injectable, Router } from '@shadow-library/app';
+import { InternalError, Logger, utils } from '@shadow-library/common';
+import merge from 'deepmerge';
+import { FASTIFY_CONFIG, FASTIFY_INSTANCE, HTTP_CONTROLLER_INPUTS, HTTP_CONTROLLER_TYPE } from '../constants.js';
+import { HttpMethod } from '../decorators/index.js';
+const httpMethods = Object.values(HttpMethod).filter(m => m !== HttpMethod.ALL);
+let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends Router {
+    config;
+    instance;
+    logger = Logger.getLogger(FastifyRouter_1.name);
+    constructor(config, instance) {
+        super();
+        this.config = config;
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    registerRawBody() {
+        const opts = { parseAs: 'buffer' };
+        const parser = this.instance.getDefaultJsonParser('error', 'error');
+        this.instance.addContentTypeParser('application/json', opts, (req, body, done) => {
+            const { metadata } = req.routeOptions.config;
+            if (metadata.rawBody)
+                req.rawBody = body;
+            return parser(req, body.toString(), done);
+        });
+    }
+    parseControllers(controllers) {
+        const parsedControllers = { middlewares: [], routes: [] };
+        for (const controller of controllers) {
+            switch (controller.metadata[HTTP_CONTROLLER_TYPE]) {
+                case 'router': {
+                    const { instance, metadata, metatype } = controller;
+                    const basePath = metadata.path ?? '';
+                    for (const route of controller.routes) {
+                        const routePath = route.metadata.path ?? '';
+                        const path = basePath + routePath;
+                        const parsedController = { ...route, instance, metatype };
+                        parsedController.metadata.path = path || '/';
+                        parsedControllers.routes.push(parsedController);
+                    }
+                    break;
+                }
+                case 'middleware': {
+                    const metadata = controller.metadata;
+                    const { instance, metatype } = controller;
+                    const method = metadata.generates ? 'generate' : 'use';
+                    const handler = controller.instance[method].bind(instance);
+                    parsedControllers.middlewares.push({ metadata, handler, paramtypes: [], instance, metatype, handlerName: method });
+                    break;
+                }
+                default: {
+                    throw new InternalError(`Unknown controller type: ${controller.metadata[HTTP_CONTROLLER_TYPE]}`);
+                }
+            }
+        }
+        parsedControllers.middlewares.sort((a, b) => b.metadata.weight - a.metadata.weight);
+        return parsedControllers;
+    }
+    getStatusCode(metadata) {
+        if (metadata.status)
+            return metadata.status;
+        const responseStatusCodes = Object.keys(metadata.schemas?.response ?? {}).map(n => parseInt(n));
+        const statusCodes = responseStatusCodes.filter(code => code >= 200 && code < 600);
+        if (statusCodes.length === 1)
+            return statusCodes[0];
+        return metadata.method === HttpMethod.POST ? 201 : 200;
+    }
+    generateRouteHandler(route) {
+        const metadata = route.metadata;
+        const statusCode = this.getStatusCode(metadata);
+        const argsOrder = Reflect.getMetadata(HTTP_CONTROLLER_INPUTS, route.instance, route.handlerName) ?? [];
+        return async (request, response) => {
+            const params = request.params;
+            const query = request.query;
+            const body = request.body;
+            const context = { request, response, params, query, body };
+            response.status(statusCode);
+            for (const [key, value] of Object.entries(metadata.headers ?? {})) {
+                response.header(key, typeof value === 'function' ? value() : value);
+            }
+            const args = argsOrder.map(arg => arg && context[arg]);
+            const data = await route.handler(...args);
+            if (metadata.redirect)
+                return response.status(metadata.status ?? 301).redirect(metadata.redirect);
+            if (metadata.render) {
+                let template = metadata.render;
+                let templateData = data;
+                if (template === true) {
+                    template = data.template;
+                    templateData = data.data;
+                }
+                return response.viewAsync(template, templateData);
+            }
+            if (!response.sent && data)
+                return response.send(data);
+        };
+    }
+    async register(controllers) {
+        const { middlewares, routes } = this.parseControllers(controllers);
+        const defaultResponseSchemas = this.config.responseSchema ?? {};
+        const hasRawBody = routes.some(r => r.metadata.rawBody);
+        if (hasRawBody)
+            this.registerRawBody();
+        for (const route of routes) {
+            const metadata = route.metadata;
+            assert(metadata.path, 'Route path is required');
+            assert(metadata.method, 'Route method is required');
+            this.logger.debug(`registering route ${metadata.method} ${metadata.path}`);
+            const fastifyRouteOptions = utils.object.omitKeys(metadata, ['path', 'method', 'schemas', 'rawBody', 'status', 'headers', 'redirect', 'render']);
+            const routeOptions = { ...fastifyRouteOptions, config: { metadata } };
+            routeOptions.url = metadata.path;
+            routeOptions.method = metadata.method === HttpMethod.ALL ? httpMethods : [metadata.method];
+            routeOptions.handler = this.generateRouteHandler(route);
+            for (const middleware of middlewares) {
+                const name = middleware.metatype.name;
+                const { generates, type } = middleware.metadata;
+                const handler = generates ? await middleware.handler(metadata) : middleware.handler.bind(middleware);
+                if (typeof handler === 'function') {
+                    this.logger.debug(`applying '${type}' middleware '${name}'`);
+                    const middlewareHandler = routeOptions[type];
+                    if (middlewareHandler)
+                        middlewareHandler.push(handler);
+                    else
+                        routeOptions[type] = [handler];
+                }
+            }
+            routeOptions.schema = {};
+            routeOptions.attachValidation = metadata.silentValidation ?? false;
+            routeOptions.schema.response = merge(metadata.schemas?.response ?? {}, defaultResponseSchemas);
+            if (metadata.schemas?.body)
+                routeOptions.schema.body = metadata.schemas.body;
+            if (metadata.schemas?.params)
+                routeOptions.schema.params = metadata.schemas.params;
+            if (metadata.schemas?.query)
+                routeOptions.schema.querystring = metadata.schemas.query;
+            this.logger.debug('route options', { options: routeOptions });
+            this.instance.route(routeOptions);
+            this.logger.info(`registered route ${metadata.method} ${routeOptions.url}`);
+        }
+    }
+    async start() {
+        const options = utils.object.pickKeys(this.config, ['port', 'host']);
+        const address = await this.instance.listen(options);
+        this.logger.info(`server started at ${address}`);
+    }
+    async stop() {
+        this.logger.info('stopping server');
+        await this.instance.close();
+    }
+    mockRequest(options) {
+        return options ? this.instance.inject(options) : this.instance.inject();
+    }
+};
+FastifyRouter = FastifyRouter_1 = __decorate([
+    Injectable(),
+    __param(0, Inject(FASTIFY_CONFIG)),
+    __param(1, Inject(FASTIFY_INSTANCE)),
+    __metadata("design:paramtypes", [Object, Object])
+], FastifyRouter);
+export { FastifyRouter };

package/esm/module/fastify.module.d.ts

@@ -0,0 +1,7 @@
+import { Class } from 'type-fest';
+import { FastifyModuleAsyncOptions, FastifyModuleOptions } from './fastify-module.interface.js';
+export declare class FastifyModule {
+    private static getDefaultConfig;
+    static forRoot(options: FastifyModuleOptions): Class<FastifyModule>;
+    static forRootAsync(options: FastifyModuleAsyncOptions): Class<FastifyModule>;
+}

package/esm/module/fastify.module.js

@@ -0,0 +1,37 @@
+import { Module, Router } from '@shadow-library/app';
+import { ClassSchema } from '@shadow-library/class-schema';
+import { utils } from '@shadow-library/common';
+import { v4 as uuid } from 'uuid';
+import { DefaultErrorHandler } from '../classes/index.js';
+import { FASTIFY_CONFIG, FASTIFY_INSTANCE } from '../constants.js';
+import { ErrorResponseDto } from './error-response.dto.js';
+import { FastifyRouter } from './fastify-router.js';
+import { createFastifyInstance } from './fastify.utils.js';
+export class FastifyModule {
+    static getDefaultConfig() {
+        const errorResponseSchema = ClassSchema.generate(ErrorResponseDto);
+        return {
+            host: 'localhost',
+            port: 8080,
+            responseSchema: { '4xx': errorResponseSchema, '5xx': errorResponseSchema },
+            errorHandler: new DefaultErrorHandler(),
+            ignoreTrailingSlash: true,
+            requestIdLogLabel: 'rid',
+            genReqId: () => uuid(),
+            ajv: { customOptions: { removeAdditional: true, useDefaults: true, allErrors: true } },
+        };
+    }
+    static forRoot(options) {
+        const config = Object.assign({}, this.getDefaultConfig(), utils.object.omitKeys(options, ['imports', 'fastifyFactory']));
+        return this.forRootAsync({ imports: options.imports, useFactory: () => config, fastifyFactory: options.fastifyFactory });
+    }
+    static forRootAsync(options) {
+        const imports = options.imports ?? [];
+        const providers = [{ token: Router, useClass: FastifyRouter }];
+        providers.push({ token: FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
+        const fastifyFactory = (config) => createFastifyInstance(config, options.fastifyFactory);
+        providers.push({ token: FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [FASTIFY_CONFIG] });
+        Module({ imports, providers, exports: [Router] })(FastifyModule);
+        return FastifyModule;
+    }
+}

package/esm/module/fastify.utils.d.ts

@@ -0,0 +1,7 @@
+import { ValidationError } from '@shadow-library/common';
+import { FastifyInstance } from 'fastify';
+import { FastifySchemaValidationError, SchemaErrorDataVar } from 'fastify/types/schema';
+import { FastifyConfig, FastifyModuleOptions } from './fastify-module.interface.js';
+export declare const notFoundHandler: () => never;
+export declare function formatSchemaErrors(errors: FastifySchemaValidationError[], dataVar: SchemaErrorDataVar): ValidationError;
+export declare function createFastifyInstance(config: FastifyConfig, fastifyFactory?: FastifyModuleOptions['fastifyFactory']): Promise<FastifyInstance>;

package/esm/module/fastify.utils.js

@@ -0,0 +1,27 @@
+import { ValidationError, throwError, utils } from '@shadow-library/common';
+import { fastify } from 'fastify';
+import { ServerError, ServerErrorCode } from '../server.error.js';
+const notFoundError = new ServerError(ServerErrorCode.S002);
+export const notFoundHandler = () => throwError(notFoundError);
+export function formatSchemaErrors(errors, dataVar) {
+    const validationError = new ValidationError();
+    for (const error of errors) {
+        let key = dataVar;
+        let message = error.message ?? 'Field validation failed';
+        if (error.instancePath)
+            key += error.instancePath.replaceAll('/', '.');
+        if (Array.isArray(error.params.allowedValues))
+            message += `: ${error.params.allowedValues.join(', ')}`;
+        validationError.addFieldError(key, message);
+    }
+    return validationError;
+}
+export async function createFastifyInstance(config, fastifyFactory) {
+    const options = utils.object.omitKeys(config, ['port', 'host', 'errorHandler', 'responseSchema']);
+    const { errorHandler } = config;
+    const instance = fastify(options);
+    instance.setSchemaErrorFormatter(formatSchemaErrors);
+    instance.setNotFoundHandler(notFoundHandler);
+    instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
+    return fastifyFactory ? await fastifyFactory(instance) : instance;
+}

package/esm/module/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fastify-module.interface.js';
+export * from './fastify-router.js';
+export * from './fastify.module.js';

package/esm/module/index.js

@@ -0,0 +1,3 @@
+export * from './fastify-module.interface.js';
+export * from './fastify-router.js';
+export * from './fastify.module.js';

package/esm/server.error.d.ts

@@ -0,0 +1,16 @@
+import { AppError, ErrorCode, ErrorType } from '@shadow-library/common';
+export declare class ServerError extends AppError<ServerErrorCode> {
+    getStatusCode(): number;
+}
+export declare class ServerErrorCode extends ErrorCode {
+    private readonly statusCode;
+    protected constructor(code: string, type: ErrorType, msg: string, statusCode?: number);
+    getStatusCode(): number;
+    static readonly S001: ServerErrorCode;
+    static readonly S002: ServerErrorCode;
+    static readonly S003: ServerErrorCode;
+    static readonly S004: ServerErrorCode;
+    static readonly S005: ServerErrorCode;
+    static readonly S006: ServerErrorCode;
+    static readonly S007: ServerErrorCode;
+}

package/esm/server.error.js

@@ -0,0 +1,33 @@
+import { AppError, ErrorCode, ErrorType } from '@shadow-library/common';
+const ERROR_STATUS_CODES = {
+    [ErrorType.CLIENT_ERROR]: 400,
+    [ErrorType.HTTP_ERROR]: 400,
+    [ErrorType.NOT_FOUND]: 404,
+    [ErrorType.SERVER_ERROR]: 500,
+    [ErrorType.UNAUTHENTICATED]: 401,
+    [ErrorType.UNAUTHORIZED]: 403,
+    [ErrorType.VALIDATION_ERROR]: 422,
+    [ErrorType.CONFLICT]: 409,
+};
+export class ServerError extends AppError {
+    getStatusCode() {
+        return this.error.getStatusCode();
+    }
+}
+export class ServerErrorCode extends ErrorCode {
+    statusCode;
+    constructor(code, type, msg, statusCode) {
+        super(code, type, msg);
+        this.statusCode = statusCode ?? ERROR_STATUS_CODES[type];
+    }
+    getStatusCode() {
+        return this.statusCode;
+    }
+    static S001 = new ServerErrorCode('S001', ErrorType.SERVER_ERROR, 'Unexpected Server Error');
+    static S002 = new ServerErrorCode('S002', ErrorType.NOT_FOUND, 'Not Found');
+    static S003 = new ServerErrorCode('S003', ErrorType.VALIDATION_ERROR, 'Invalid Input');
+    static S004 = new ServerErrorCode('S004', ErrorType.CLIENT_ERROR, 'Request body is too large', 413);
+    static S005 = new ServerErrorCode('S005', ErrorType.CLIENT_ERROR, 'Request body size did not match Content-Length');
+    static S006 = new ServerErrorCode('S006', ErrorType.CLIENT_ERROR, "Body cannot be empty when content-type is set to 'application/json'");
+    static S007 = new ServerErrorCode('S007', ErrorType.CLIENT_ERROR, 'Received media type is not supported', 415);
+}

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

@@ -0,0 +1,13 @@
+import { MiddlewareHandler } from '../interfaces/index.js';
+type Key = string | symbol;
+export declare class Context {
+    private readonly storage;
+    init(): MiddlewareHandler;
+    protected get<T>(key: Key, throwOnMissing: true): T;
+    protected get<T>(key: Key, throwOnMissing?: false): T | null;
+    protected set<T>(key: Key, value: T): this;
+    getRequest(): Request;
+    getResponse(): Response;
+    getRID(): string;
+}
+export {};