@shadow-library/fastify 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 shadow-library
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# Shadow Fastify Server
+
+This TypeScript package is a powerful Node.js server implementation built as a wrapper around the Fastify package. It offers features such as body, query,
+and URL parameter validation using AJV for speed, response formatting with fast-json-stringify, and a unified approach to authentication and authorization.
+The package uses decorators to define controller classes and HTTP methods, and includes a render decorator for templating engine support.
+
+## Features
+
+**Fastify Wrapper:** Built on top of the high-performance Fastify framework.
+**Validation:** Fast validation for body, query, and URL parameters using AJV.
+**Response Serialization:** Consistent serialization of response types with fast-json-stringify to ensure only expected fields are returned.
+**Decorator-Based:** Use decorators to define controllers and HTTP methods.
+**Authentication and Authorization:** Unified methods to implement authentication and authorization.
+**Templating Support:** Render decorator for integrating templating engines.
+
+## Usage
+
+```ts
+import {} from '@shadow-library/server';
+```
+
+## License
+
+This package is licensed under the MIT License. See the `LICENSE` file for more information.

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

@@ -0,0 +1,12 @@
+import { AppErrorObject } from '@shadow-library/common';
+import { FastifyError } from 'fastify';
+import { ErrorHandler, HttpRequest, HttpResponse } from '../interfaces/index.js';
+export interface ParsedFastifyError {
+    statusCode: number;
+    error: AppErrorObject;
+}
+export declare class DefaultErrorHandler implements ErrorHandler {
+    private readonly logger;
+    protected parseFastifyError(err: FastifyError): ParsedFastifyError;
+    handle(err: Error, _req: HttpRequest, res: HttpResponse): HttpResponse;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorHandler = void 0;
+const common_1 = require("@shadow-library/common");
+const server_error_1 = require("../server.error.js");
+const unexpectedError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S001);
+const validationError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S003);
+class DefaultErrorHandler {
+    logger = common_1.Logger.getLogger(DefaultErrorHandler.name);
+    parseFastifyError(err) {
+        if (err.statusCode === 500)
+            return { statusCode: 500, error: unexpectedError.toObject() };
+        return {
+            statusCode: err.statusCode,
+            error: {
+                code: err.code,
+                type: common_1.ErrorType.CLIENT_ERROR,
+                message: err.message,
+            },
+        };
+    }
+    handle(err, _req, res) {
+        this.logger.warn('Handling error', err);
+        if (err.cause)
+            this.logger.warn('Caused by:', err.cause);
+        if (err instanceof server_error_1.ServerError)
+            return res.status(err.getStatusCode()).send(err.toObject());
+        else if (err instanceof common_1.ValidationError)
+            return res.status(400).send({ ...err.toObject(), code: validationError.getCode() });
+        else if (err instanceof common_1.AppError)
+            return res.status(500).send(err.toObject());
+        else if (err.name === 'FastifyError') {
+            const { statusCode, error } = this.parseFastifyError(err);
+            return res.status(statusCode).send(error);
+        }
+        this.logger.error('Unhandler error has occurred:', err);
+        return res.status(500).send(unexpectedError.toObject());
+    }
+}
+exports.DefaultErrorHandler = DefaultErrorHandler;

package/cjs/classes/index.d.ts

@@ -0,0 +1 @@
+export * from './default-error-handler.js';

package/cjs/classes/index.js

@@ -0,0 +1,17 @@
+"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("./default-error-handler.js"), exports);

package/cjs/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const PARAMTYPES_METADATA = "design:paramtypes";
+export declare const FASTIFY_CONFIG: unique symbol;
+export declare const FASTIFY_INSTANCE: unique symbol;
+export declare const HTTP_CONTROLLER_TYPE: unique symbol;
+export declare const HTTP_CONTROLLER_INPUTS: unique symbol;

package/cjs/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_CONTROLLER_INPUTS = exports.HTTP_CONTROLLER_TYPE = exports.FASTIFY_INSTANCE = exports.FASTIFY_CONFIG = exports.PARAMTYPES_METADATA = void 0;
+exports.PARAMTYPES_METADATA = 'design:paramtypes';
+exports.FASTIFY_CONFIG = Symbol('fastify-config');
+exports.FASTIFY_INSTANCE = Symbol('fastify-instance');
+exports.HTTP_CONTROLLER_TYPE = Symbol('http-controller-type');
+exports.HTTP_CONTROLLER_INPUTS = Symbol('http-controller-inputs');

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

@@ -0,0 +1 @@
+export declare function HttpController(path?: string): ClassDecorator;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpController = HttpController;
+const app_1 = require("@shadow-library/app");
+const constants_1 = require("../constants.js");
+function HttpController(path = '') {
+    return target => (0, app_1.Controller)({ [constants_1.HTTP_CONTROLLER_TYPE]: 'router', path })(target);
+}

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

@@ -0,0 +1,17 @@
+import { JSONSchema } from '@shadow-library/class-schema';
+export declare enum RouteInputType {
+    BODY = "body",
+    PARAMS = "params",
+    QUERY = "query",
+    REQUEST = "request",
+    RESPONSE = "response"
+}
+export type RouteInputSchemas = Partial<Record<'body' | 'params' | 'query', JSONSchema>>;
+export declare function HttpInput(type: RouteInputType, schema?: JSONSchema): ParameterDecorator;
+export declare const Body: (schema?: JSONSchema) => ParameterDecorator;
+export declare const Params: (schema?: JSONSchema) => ParameterDecorator;
+export declare const Query: (schema?: JSONSchema) => ParameterDecorator;
+export declare const Request: () => ParameterDecorator;
+export declare const Req: () => ParameterDecorator;
+export declare const Response: () => ParameterDecorator;
+export declare const Res: () => ParameterDecorator;

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Res = exports.Response = exports.Req = exports.Request = exports.Query = exports.Params = exports.Body = exports.RouteInputType = void 0;
+exports.HttpInput = HttpInput;
+const assert_1 = __importDefault(require("assert"));
+const app_1 = require("@shadow-library/app");
+const class_schema_1 = require("@shadow-library/class-schema");
+const constants_1 = require("../constants.js");
+var RouteInputType;
+(function (RouteInputType) {
+    RouteInputType["BODY"] = "body";
+    RouteInputType["PARAMS"] = "params";
+    RouteInputType["QUERY"] = "query";
+    RouteInputType["REQUEST"] = "request";
+    RouteInputType["RESPONSE"] = "response";
+})(RouteInputType || (exports.RouteInputType = RouteInputType = {}));
+function HttpInput(type, schema) {
+    return (target, propertyKey, index) => {
+        (0, assert_1.default)(propertyKey, 'Cannot apply decorator to a constructor parameter');
+        const inputs = Reflect.getMetadata(constants_1.HTTP_CONTROLLER_INPUTS, target, propertyKey) ?? [];
+        Reflect.defineMetadata(constants_1.HTTP_CONTROLLER_INPUTS, inputs, target, propertyKey);
+        inputs[index] = type;
+        if (!schema) {
+            const paramTypes = Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, target, propertyKey);
+            schema = class_schema_1.ClassSchema.generate(paramTypes[index]);
+        }
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, propertyKey);
+        (0, assert_1.default)(descriptor, 'Cannot apply decorator to a non-method');
+        (0, app_1.Route)({ schemas: { [type]: schema } })(target, propertyKey, descriptor);
+    };
+}
+const Body = (schema) => HttpInput(RouteInputType.BODY, schema);
+exports.Body = Body;
+const Params = (schema) => HttpInput(RouteInputType.PARAMS, schema);
+exports.Params = Params;
+const Query = (schema) => HttpInput(RouteInputType.QUERY, schema);
+exports.Query = Query;
+const Request = () => HttpInput(RouteInputType.REQUEST);
+exports.Request = Request;
+exports.Req = exports.Request;
+const Response = () => HttpInput(RouteInputType.RESPONSE);
+exports.Response = Response;
+exports.Res = exports.Response;

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

@@ -0,0 +1,11 @@
+import { JSONSchema, SchemaClass } from '@shadow-library/class-schema';
+import { JsonObject } from 'type-fest';
+export interface DynamicRender<T extends JsonObject> {
+    template: string;
+    data: T;
+}
+export declare const HttpStatus: (status: number) => MethodDecorator;
+export declare const Header: (name: string, value: string | (() => string)) => MethodDecorator;
+export declare const Redirect: (redirect: string, status?: number) => MethodDecorator;
+export declare const Render: (render?: string) => MethodDecorator;
+export declare function RespondFor(statusCode: number, schema: SchemaClass | JSONSchema): MethodDecorator;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Render = exports.Redirect = exports.Header = exports.HttpStatus = void 0;
+exports.RespondFor = RespondFor;
+const app_1 = require("@shadow-library/app");
+const class_schema_1 = require("@shadow-library/class-schema");
+const isClass = (schema) => schema.toString().startsWith('class ');
+const HttpStatus = (status) => (0, app_1.Route)({ status });
+exports.HttpStatus = HttpStatus;
+const Header = (name, value) => (0, app_1.Route)({ headers: { [name]: value } });
+exports.Header = Header;
+const Redirect = (redirect, status = 301) => (0, app_1.Route)({ redirect, status });
+exports.Redirect = Redirect;
+const Render = (render) => (0, app_1.Route)({ render: render ?? true });
+exports.Render = Render;
+function RespondFor(statusCode, schema) {
+    if (isClass(schema))
+        schema = class_schema_1.ClassSchema.generate(schema);
+    return (0, app_1.Route)({ schemas: { response: { [statusCode]: schema } } });
+}

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

@@ -0,0 +1,23 @@
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD",
+    ALL = "ALL"
+}
+export interface RouteOptions {
+    method: HttpMethod;
+    path?: string;
+}
+export declare function HttpRoute(options: RouteOptions): MethodDecorator;
+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;
+export declare const Options: (path?: string) => MethodDecorator;
+export declare const Head: (path?: string) => MethodDecorator;
+export declare const All: (path?: string) => MethodDecorator;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.All = exports.Head = exports.Options = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.HttpMethod = void 0;
+exports.HttpRoute = HttpRoute;
+const app_1 = require("@shadow-library/app");
+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 || (exports.HttpMethod = HttpMethod = {}));
+function HttpRoute(options) {
+    return (0, app_1.Route)(options);
+}
+const Get = (path) => HttpRoute({ method: HttpMethod.GET, path });
+exports.Get = Get;
+const Post = (path) => HttpRoute({ method: HttpMethod.POST, path });
+exports.Post = Post;
+const Put = (path) => HttpRoute({ method: HttpMethod.PUT, path });
+exports.Put = Put;
+const Delete = (path) => HttpRoute({ method: HttpMethod.DELETE, path });
+exports.Delete = Delete;
+const Patch = (path) => HttpRoute({ method: HttpMethod.PATCH, path });
+exports.Patch = Patch;
+const Options = (path) => HttpRoute({ method: HttpMethod.OPTIONS, path });
+exports.Options = Options;
+const Head = (path) => HttpRoute({ method: HttpMethod.HEAD, path });
+exports.Head = Head;
+const All = (path) => HttpRoute({ method: HttpMethod.ALL, path });
+exports.All = All;

package/cjs/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/cjs/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("./http-controller.decorator.js"), exports);
+__exportStar(require("./http-input.decorator.js"), exports);
+__exportStar(require("./http-output.decorator.js"), exports);
+__exportStar(require("./http-route.decorator.js"), exports);
+__exportStar(require("./middleware.decorator.js"), exports);

package/cjs/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/cjs/decorators/middleware.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = Middleware;
+const assert_1 = __importDefault(require("assert"));
+const app_1 = require("@shadow-library/app");
+const constants_1 = require("../constants.js");
+const propertyKeys = ['generate', 'use'];
+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);
+        (0, assert_1.default)(key, `Cannot apply @Middleware to a class without a 'generate()' or 'use()' method`);
+        (0, app_1.Controller)({ ...options, [constants_1.HTTP_CONTROLLER_TYPE]: 'middleware', generates: key === 'generate' })(target);
+    };
+}

package/cjs/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/cjs/index.js

@@ -0,0 +1,23 @@
+"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 });
+require("reflect-metadata");
+__exportStar(require("./classes/index.js"), exports);
+__exportStar(require("./decorators/index.js"), exports);
+__exportStar(require("./interfaces/index.js"), exports);
+__exportStar(require("./module/index.js"), exports);
+__exportStar(require("./services/index.js"), exports);
+__exportStar(require("./server.error.js"), exports);

package/cjs/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/cjs/interfaces/error-handler.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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/cjs/interfaces/index.js

@@ -0,0 +1,20 @@
+"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("./error-handler.interface.js"), exports);
+__exportStar(require("./middleware.interface.js"), exports);
+__exportStar(require("./route-handler.interface.js"), exports);
+__exportStar(require("./server-metadata.interface.js"), exports);

package/cjs/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/cjs/interfaces/middleware.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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/cjs/interfaces/route-handler.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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/cjs/interfaces/server-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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/cjs/module/error-response.dto.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.ErrorResponseDto = exports.ErrorFieldDto = void 0;
+const class_schema_1 = require("@shadow-library/class-schema");
+let ErrorFieldDto = class ErrorFieldDto {
+    field;
+    msg;
+};
+exports.ErrorFieldDto = ErrorFieldDto;
+__decorate([
+    (0, class_schema_1.Field)(),
+    __metadata("design:type", String)
+], ErrorFieldDto.prototype, "field", void 0);
+__decorate([
+    (0, class_schema_1.Field)(),
+    __metadata("design:type", String)
+], ErrorFieldDto.prototype, "msg", void 0);
+exports.ErrorFieldDto = ErrorFieldDto = __decorate([
+    (0, class_schema_1.Schema)()
+], ErrorFieldDto);
+let ErrorResponseDto = class ErrorResponseDto {
+    code;
+    type;
+    message;
+    fields;
+};
+exports.ErrorResponseDto = ErrorResponseDto;
+__decorate([
+    (0, class_schema_1.Field)(),
+    __metadata("design:type", String)
+], ErrorResponseDto.prototype, "code", void 0);
+__decorate([
+    (0, class_schema_1.Field)(),
+    __metadata("design:type", String)
+], ErrorResponseDto.prototype, "type", void 0);
+__decorate([
+    (0, class_schema_1.Field)(),
+    __metadata("design:type", String)
+], ErrorResponseDto.prototype, "message", void 0);
+__decorate([
+    (0, class_schema_1.Field)(() => [ErrorFieldDto], { required: false }),
+    __metadata("design:type", Array)
+], ErrorResponseDto.prototype, "fields", void 0);
+exports.ErrorResponseDto = ErrorResponseDto = __decorate([
+    (0, class_schema_1.Schema)()
+], ErrorResponseDto);

package/cjs/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/cjs/module/fastify-module.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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>;
+}