@shadow-library/fastify 0.0.1

package/cjs/module/fastify-router.js

@@ -0,0 +1,182 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var FastifyRouter_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyRouter = void 0;
+const assert_1 = __importDefault(require("assert"));
+const app_1 = require("@shadow-library/app");
+const common_1 = require("@shadow-library/common");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const constants_1 = require("../constants.js");
+const decorators_1 = require("../decorators/index.js");
+const httpMethods = Object.values(decorators_1.HttpMethod).filter(m => m !== decorators_1.HttpMethod.ALL);
+let FastifyRouter = FastifyRouter_1 = class FastifyRouter extends app_1.Router {
+    config;
+    instance;
+    logger = common_1.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[constants_1.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 common_1.InternalError(`Unknown controller type: ${controller.metadata[constants_1.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 === decorators_1.HttpMethod.POST ? 201 : 200;
+    }
+    generateRouteHandler(route) {
+        const metadata = route.metadata;
+        const statusCode = this.getStatusCode(metadata);
+        const argsOrder = Reflect.getMetadata(constants_1.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;
+            (0, assert_1.default)(metadata.path, 'Route path is required');
+            (0, assert_1.default)(metadata.method, 'Route method is required');
+            this.logger.debug(`registering route ${metadata.method} ${metadata.path}`);
+            const fastifyRouteOptions = common_1.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 === decorators_1.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 = (0, deepmerge_1.default)(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 = common_1.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();
+    }
+};
+exports.FastifyRouter = FastifyRouter;
+exports.FastifyRouter = FastifyRouter = FastifyRouter_1 = __decorate([
+    (0, app_1.Injectable)(),
+    __param(0, (0, app_1.Inject)(constants_1.FASTIFY_CONFIG)),
+    __param(1, (0, app_1.Inject)(constants_1.FASTIFY_INSTANCE)),
+    __metadata("design:paramtypes", [Object, Object])
+], FastifyRouter);

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyModule = void 0;
+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");
+const classes_1 = require("../classes/index.js");
+const constants_1 = require("../constants.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");
+class FastifyModule {
+    static getDefaultConfig() {
+        const errorResponseSchema = class_schema_1.ClassSchema.generate(error_response_dto_1.ErrorResponseDto);
+        return {
+            host: 'localhost',
+            port: 8080,
+            responseSchema: { '4xx': errorResponseSchema, '5xx': errorResponseSchema },
+            errorHandler: new classes_1.DefaultErrorHandler(),
+            ignoreTrailingSlash: true,
+            requestIdLogLabel: 'rid',
+            genReqId: () => (0, uuid_1.v4)(),
+            ajv: { customOptions: { removeAdditional: true, useDefaults: true, allErrors: true } },
+        };
+    }
+    static forRoot(options) {
+        const config = Object.assign({}, this.getDefaultConfig(), common_1.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: app_1.Router, useClass: fastify_router_1.FastifyRouter }];
+        providers.push({ token: constants_1.FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
+        const fastifyFactory = (config) => (0, fastify_utils_1.createFastifyInstance)(config, options.fastifyFactory);
+        providers.push({ token: constants_1.FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [constants_1.FASTIFY_CONFIG] });
+        (0, app_1.Module)({ imports, providers, exports: [app_1.Router] })(FastifyModule);
+        return FastifyModule;
+    }
+}
+exports.FastifyModule = FastifyModule;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundHandler = void 0;
+exports.formatSchemaErrors = formatSchemaErrors;
+exports.createFastifyInstance = createFastifyInstance;
+const common_1 = require("@shadow-library/common");
+const fastify_1 = require("fastify");
+const server_error_1 = require("../server.error.js");
+const notFoundError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S002);
+const notFoundHandler = () => (0, common_1.throwError)(notFoundError);
+exports.notFoundHandler = notFoundHandler;
+function formatSchemaErrors(errors, dataVar) {
+    const validationError = new common_1.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;
+}
+async function createFastifyInstance(config, fastifyFactory) {
+    const options = common_1.utils.object.omitKeys(config, ['port', 'host', 'errorHandler', 'responseSchema']);
+    const { errorHandler } = config;
+    const instance = (0, fastify_1.fastify)(options);
+    instance.setSchemaErrorFormatter(formatSchemaErrors);
+    instance.setNotFoundHandler(exports.notFoundHandler);
+    instance.setErrorHandler(errorHandler.handle.bind(errorHandler));
+    return fastifyFactory ? await fastifyFactory(instance) : instance;
+}

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

@@ -0,0 +1,19 @@
+"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("./fastify-module.interface.js"), exports);
+__exportStar(require("./fastify-router.js"), exports);
+__exportStar(require("./fastify.module.js"), exports);

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerErrorCode = exports.ServerError = void 0;
+const common_1 = require("@shadow-library/common");
+const ERROR_STATUS_CODES = {
+    [common_1.ErrorType.CLIENT_ERROR]: 400,
+    [common_1.ErrorType.HTTP_ERROR]: 400,
+    [common_1.ErrorType.NOT_FOUND]: 404,
+    [common_1.ErrorType.SERVER_ERROR]: 500,
+    [common_1.ErrorType.UNAUTHENTICATED]: 401,
+    [common_1.ErrorType.UNAUTHORIZED]: 403,
+    [common_1.ErrorType.VALIDATION_ERROR]: 422,
+    [common_1.ErrorType.CONFLICT]: 409,
+};
+class ServerError extends common_1.AppError {
+    getStatusCode() {
+        return this.error.getStatusCode();
+    }
+}
+exports.ServerError = ServerError;
+class ServerErrorCode extends common_1.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', common_1.ErrorType.SERVER_ERROR, 'Unexpected Server Error');
+    static S002 = new ServerErrorCode('S002', common_1.ErrorType.NOT_FOUND, 'Not Found');
+    static S003 = new ServerErrorCode('S003', common_1.ErrorType.VALIDATION_ERROR, 'Invalid Input');
+    static S004 = new ServerErrorCode('S004', common_1.ErrorType.CLIENT_ERROR, 'Request body is too large', 413);
+    static S005 = new ServerErrorCode('S005', common_1.ErrorType.CLIENT_ERROR, 'Request body size did not match Content-Length');
+    static S006 = new ServerErrorCode('S006', common_1.ErrorType.CLIENT_ERROR, "Body cannot be empty when content-type is set to 'application/json'");
+    static S007 = new ServerErrorCode('S007', common_1.ErrorType.CLIENT_ERROR, 'Received media type is not supported', 415);
+}
+exports.ServerErrorCode = ServerErrorCode;

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

package/cjs/services/context.service.js

@@ -0,0 +1,57 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const async_hooks_1 = require("async_hooks");
+const app_1 = require("@shadow-library/app");
+const common_1 = require("@shadow-library/common");
+const REQUEST = Symbol('request');
+const RESPONSE = Symbol('response');
+const RID = Symbol('rid');
+let Context = class Context {
+    storage = new async_hooks_1.AsyncLocalStorage();
+    init() {
+        return async (req, res) => {
+            const store = new Map();
+            store.set(REQUEST, req);
+            store.set(RESPONSE, res);
+            store.set(RID, req.id);
+            this.storage.enterWith(store);
+        };
+    }
+    get(key, throwOnMissing) {
+        const store = this.storage.getStore();
+        if (!store)
+            throw new common_1.InternalError('Context not yet initialized');
+        const value = store.get(key);
+        if (throwOnMissing && value === undefined) {
+            throw new common_1.InternalError(`Key '${key.toString()}' not found in the context`);
+        }
+        return value ?? null;
+    }
+    set(key, value) {
+        const store = this.storage.getStore();
+        if (!store)
+            throw new common_1.InternalError('Context not yet initialized');
+        store.set(key, value);
+        return this;
+    }
+    getRequest() {
+        return this.get(REQUEST, true);
+    }
+    getResponse() {
+        return this.get(RESPONSE, true);
+    }
+    getRID() {
+        return this.get(RID, true);
+    }
+};
+exports.Context = Context;
+exports.Context = Context = __decorate([
+    (0, app_1.Injectable)()
+], Context);

package/cjs/services/index.d.ts

@@ -0,0 +1 @@
+export * from './context.service.js';

package/cjs/services/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("./context.service.js"), exports);

package/esm/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/esm/classes/default-error-handler.js

@@ -0,0 +1,36 @@
+import { AppError, ErrorType, Logger, ValidationError } from '@shadow-library/common';
+import { ServerError, ServerErrorCode } from '../server.error.js';
+const unexpectedError = new ServerError(ServerErrorCode.S001);
+const validationError = new ServerError(ServerErrorCode.S003);
+export class DefaultErrorHandler {
+    logger = 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: 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 ServerError)
+            return res.status(err.getStatusCode()).send(err.toObject());
+        else if (err instanceof ValidationError)
+            return res.status(400).send({ ...err.toObject(), code: validationError.getCode() });
+        else if (err instanceof 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());
+    }
+}

package/esm/classes/index.d.ts

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

package/esm/classes/index.js

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

package/esm/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/esm/constants.js

@@ -0,0 +1,5 @@
+export const PARAMTYPES_METADATA = 'design:paramtypes';
+export const FASTIFY_CONFIG = Symbol('fastify-config');
+export const FASTIFY_INSTANCE = Symbol('fastify-instance');
+export const HTTP_CONTROLLER_TYPE = Symbol('http-controller-type');
+export const HTTP_CONTROLLER_INPUTS = Symbol('http-controller-inputs');

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

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

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

@@ -0,0 +1,5 @@
+import { Controller } from '@shadow-library/app';
+import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+export function HttpController(path = '') {
+    return target => Controller({ [HTTP_CONTROLLER_TYPE]: 'router', path })(target);
+}

package/esm/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/esm/decorators/http-input.decorator.js

@@ -0,0 +1,34 @@
+import assert from 'assert';
+import { Route } from '@shadow-library/app';
+import { ClassSchema } from '@shadow-library/class-schema';
+import { HTTP_CONTROLLER_INPUTS, PARAMTYPES_METADATA } from '../constants.js';
+export var RouteInputType;
+(function (RouteInputType) {
+    RouteInputType["BODY"] = "body";
+    RouteInputType["PARAMS"] = "params";
+    RouteInputType["QUERY"] = "query";
+    RouteInputType["REQUEST"] = "request";
+    RouteInputType["RESPONSE"] = "response";
+})(RouteInputType || (RouteInputType = {}));
+export function HttpInput(type, schema) {
+    return (target, propertyKey, index) => {
+        assert(propertyKey, 'Cannot apply decorator to a constructor parameter');
+        const inputs = Reflect.getMetadata(HTTP_CONTROLLER_INPUTS, target, propertyKey) ?? [];
+        Reflect.defineMetadata(HTTP_CONTROLLER_INPUTS, inputs, target, propertyKey);
+        inputs[index] = type;
+        if (!schema) {
+            const paramTypes = Reflect.getMetadata(PARAMTYPES_METADATA, target, propertyKey);
+            schema = ClassSchema.generate(paramTypes[index]);
+        }
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, propertyKey);
+        assert(descriptor, 'Cannot apply decorator to a non-method');
+        Route({ schemas: { [type]: schema } })(target, propertyKey, descriptor);
+    };
+}
+export const Body = (schema) => HttpInput(RouteInputType.BODY, schema);
+export const Params = (schema) => HttpInput(RouteInputType.PARAMS, schema);
+export const Query = (schema) => HttpInput(RouteInputType.QUERY, schema);
+export const Request = () => HttpInput(RouteInputType.REQUEST);
+export const Req = Request;
+export const Response = () => HttpInput(RouteInputType.RESPONSE);
+export const Res = Response;

package/esm/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/esm/decorators/http-output.decorator.js

@@ -0,0 +1,12 @@
+import { Route } from '@shadow-library/app';
+import { ClassSchema } from '@shadow-library/class-schema';
+const isClass = (schema) => schema.toString().startsWith('class ');
+export const HttpStatus = (status) => Route({ status });
+export const Header = (name, value) => Route({ headers: { [name]: value } });
+export const Redirect = (redirect, status = 301) => Route({ redirect, status });
+export const Render = (render) => Route({ render: render ?? true });
+export function RespondFor(statusCode, schema) {
+    if (isClass(schema))
+        schema = ClassSchema.generate(schema);
+    return Route({ schemas: { response: { [statusCode]: schema } } });
+}

package/esm/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;