@shadow-library/fastify 0.0.5 → 0.0.7

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

@@ -47,7 +47,7 @@ __decorate([
     __metadata("design:type", String)
 ], ErrorResponseDto.prototype, "message", void 0);
 __decorate([
-    (0, class_schema_1.Field)(() => [ErrorFieldDto], { required: false }),
+    (0, class_schema_1.Field)(() => [ErrorFieldDto], { optional: true }),
     __metadata("design:type", Array)
 ], ErrorResponseDto.prototype, "fields", void 0);
 exports.ErrorResponseDto = ErrorResponseDto = __decorate([

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

@@ -8,12 +8,17 @@ export interface FastifyConfig extends FastifyServerOptions {
     port: number;
     errorHandler: ErrorHandler;
     responseSchema?: Record<string | number, JSONSchema>;
+    enableChildRoutes?: boolean;
+    maskSensitiveData?: boolean;
 }
 export interface FastifyModuleOptions extends Partial<FastifyConfig> {
     imports?: ModuleMetadata['imports'];
     fastifyFactory?: (instance: FastifyInstance) => Promisable<FastifyInstance>;
+    controllers?: ModuleMetadata['controllers'];
+    providers?: ModuleMetadata['providers'];
+    exports?: ModuleMetadata['exports'];
 }
-export interface FastifyModuleAsyncOptions extends Pick<FastifyModuleOptions, 'imports' | 'fastifyFactory'> {
+export interface FastifyModuleAsyncOptions extends Pick<FastifyModuleOptions, 'imports' | 'controllers' | 'providers' | 'exports' | 'fastifyFactory'> {
     useFactory: (...args: any[]) => Promisable<FastifyConfig>;
     inject?: FactoryProvider['inject'];
 }

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

@@ -1,16 +1,18 @@
 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 { JsonObject, JsonValue } from 'type-fest';
+import { HttpMethod } from '../decorators/index.js';
 import { HttpRequest, HttpResponse, ServerMetadata } from '../interfaces/index.js';
-import { Context } from '../services/index.js';
+import { ContextService } from '../services/index.js';
 import { type FastifyConfig } from './fastify-module.interface.js';
 declare module 'fastify' {
     interface FastifyRequest {
         rawBody?: Buffer;
     }
     interface FastifyContextConfig {
-        metadata: ServerMetadata;
+        metadata?: ServerMetadata;
+        artifacts?: RouteArtifacts;
     }
 }
 export interface RequestContext {
@@ -35,21 +37,42 @@ export interface RequestMetadata {
     service?: string;
     [key: string]: any;
 }
+export interface ChildRouteRequest {
+    method: HttpMethod.GET;
+    url: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+}
+interface RouteArtifacts {
+    transforms: {
+        maskBody?(body: object): object;
+        maskQuery?(query: object): object;
+        maskParams?(params: object): object;
+    };
+}
 export declare class FastifyRouter extends Router {
     private readonly config;
     private readonly instance;
     private readonly context;
+    static readonly name = "FastifyRouter";
     private readonly logger;
-    constructor(config: FastifyConfig, instance: FastifyInstance, context: Context);
+    private readonly cachedDynamicMiddlewares;
+    private readonly childRouter;
+    private readonly sensitiveTransformer;
+    constructor(config: FastifyConfig, instance: FastifyInstance, context: ContextService);
     getInstance(): FastifyInstance;
     private registerRawBody;
+    private maskField;
     private getRequestLogger;
     private parseControllers;
     private getStatusCode;
     private generateRouteHandler;
+    private getMiddlewareHandler;
     register(controllers: ControllerRouteMetadata[]): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
+    resolveChildRoute<T extends JsonValue = JsonObject>(url: string): Promise<T>;
     mockRequest(): MockRequestChain;
     mockRequest(options: MockRequestOptions): Promise<MockResponse>;
 }
+export {};

package/cjs/module/fastify-router.js

@@ -16,24 +16,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyRouter = void 0;
-const assert_1 = __importDefault(require("assert"));
+const node_assert_1 = __importDefault(require("node:assert"));
 const app_1 = require("@shadow-library/app");
+const class_schema_1 = require("@shadow-library/class-schema");
 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"));
 const constants_1 = require("../constants.js");
 const decorators_1 = require("../decorators/index.js");
 const services_1 = require("../services/index.js");
 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 {
     config;
     instance;
     context;
+    static name = 'FastifyRouter';
     logger = common_1.Logger.getLogger(constants_1.NAMESPACE, 'FastifyRouter');
+    cachedDynamicMiddlewares = new Map();
+    childRouter = null;
+    sensitiveTransformer = new class_schema_1.TransformerFactory(s => s['x-fastify']?.sensitive === true);
     constructor(config, instance, context) {
         super();
         this.config = config;
         this.instance = instance;
         this.context = context;
+        if (config.enableChildRoutes) {
+            const options = common_1.utils.object.pickKeys(config, ['ignoreTrailingSlash', 'ignoreDuplicateSlashes', 'allowUnsafeRegex', 'caseSensitive', 'maxParamLength', 'querystringParser']);
+            this.childRouter = (0, find_my_way_1.default)(options);
+        }
     }
     getInstance() {
         return this.instance;
@@ -43,21 +55,34 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
         const parser = this.instance.getDefaultJsonParser('error', 'error');
         this.instance.addContentTypeParser('application/json', opts, (req, body, done) => {
             const { metadata } = req.routeOptions.config;
-            if (metadata.rawBody)
+            if (metadata?.rawBody)
                 req.rawBody = body;
             return parser(req, body.toString(), done);
         });
     }
+    maskField(value, schema) {
+        const type = schema['x-fastify']?.type;
+        const stringified = typeof value === 'string' ? value : typeof value === 'object' ? JSON.stringify(value) : String(value);
+        if (type === 'email')
+            return common_1.utils.string.maskEmail(stringified);
+        if (type === 'number')
+            return common_1.utils.string.maskNumber(stringified);
+        if (type === 'words')
+            return common_1.utils.string.maskWords(stringified);
+        return '****';
+    }
     getRequestLogger() {
         return (req, res, done) => {
             const startTime = process.hrtime();
             res.raw.on('finish', () => {
                 const isLoggingDisabled = this.context.get('DISABLE_REQUEST_LOGGING') ?? false;
                 if (isLoggingDisabled)
-                    return done();
+                    return;
+                const { url, config } = req.routeOptions;
+                const { transforms } = config.artifacts ?? DEFAULT_ARTIFACTS;
                 const metadata = {};
                 metadata.rid = this.context.getRID();
-                metadata.url = req.url;
+                metadata.url = url ?? req.raw.url;
                 metadata.method = req.method;
                 metadata.status = res.statusCode;
                 metadata.service = req.headers['x-service'];
@@ -66,13 +91,15 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
                 metadata.resLen = res.getHeader('content-length');
                 const resTime = process.hrtime(startTime);
                 metadata.timeTaken = (resTime[0] * 1e3 + resTime[1] * 1e-6).toFixed(3);
-                if (req.query)
-                    metadata.query = req.query;
                 if (req.body)
-                    metadata.body = req.body;
-                this.logger.http('http', metadata);
+                    metadata.body = transforms.maskBody ? transforms.maskBody(structuredClone(req.body)) : req.body;
+                if (req.query)
+                    metadata.query = transforms.maskQuery ? transforms.maskQuery(structuredClone(req.query)) : req.query;
+                if (req.params)
+                    metadata.params = transforms.maskParams ? transforms.maskParams(structuredClone(req.params)) : req.params;
+                this.logger.http(`${req.method} ${metadata.url} -> ${res.statusCode} (${metadata.timeTaken}ms)`, metadata);
             });
-            return done();
+            done();
         };
     }
     parseControllers(controllers) {
@@ -146,6 +173,18 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
                 return response.send(data);
         };
     }
+    async getMiddlewareHandler(middleware, metadata) {
+        if (!middleware.metadata.generates)
+            return middleware.handler.bind(middleware.instance);
+        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;
+        const handler = await middleware.handler.apply(middleware.instance, [metadata]);
+        this.cachedDynamicMiddlewares.set(cacheKey, handler);
+        return handler;
+    }
     async register(controllers) {
         const { middlewares, routes } = this.parseControllers(controllers);
         const defaultResponseSchemas = this.config.responseSchema ?? {};
@@ -158,18 +197,19 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
         this.logger.info('Registered global middlewares');
         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');
+            (0, node_assert_1.default)(metadata.path, 'Route path is required');
+            (0, node_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 } };
+            const artifacts = { transforms: {} };
+            const routeOptions = { ...fastifyRouteOptions, config: { metadata, artifacts } };
             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);
+                const { type } = middleware.metadata;
+                const handler = await this.getMiddlewareHandler(middleware, metadata);
                 if (typeof handler === 'function') {
                     this.logger.debug(`applying '${type}' middleware '${name}'`);
                     const middlewareHandler = routeOptions[type];
@@ -182,12 +222,35 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
             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;
+            const { body: bodySchema, params: paramsSchema, query: querySchema } = metadata.schemas ?? {};
+            const isMaskEnabled = this.config.maskSensitiveData ?? true;
+            if (bodySchema) {
+                const schema = typeof bodySchema === 'function' ? class_schema_1.ClassSchema.generate(bodySchema) : bodySchema;
+                routeOptions.schema.body = schema;
+                if (class_schema_1.ClassSchema.isBranded(schema) && isMaskEnabled) {
+                    const transformer = this.sensitiveTransformer.maybeCompile(schema);
+                    if (transformer)
+                        artifacts.transforms.maskBody = obj => transformer(obj, this.maskField);
+                }
+            }
+            if (paramsSchema) {
+                const schema = typeof paramsSchema === 'function' ? class_schema_1.ClassSchema.generate(paramsSchema) : paramsSchema;
+                routeOptions.schema.params = schema;
+                if (class_schema_1.ClassSchema.isBranded(schema) && isMaskEnabled) {
+                    const transformer = this.sensitiveTransformer.maybeCompile(schema);
+                    if (transformer)
+                        artifacts.transforms.maskParams = obj => transformer(obj, this.maskField);
+                }
+            }
+            if (querySchema) {
+                const schema = typeof querySchema === 'function' ? class_schema_1.ClassSchema.generate(querySchema) : querySchema;
+                routeOptions.schema.querystring = schema;
+                if (class_schema_1.ClassSchema.isBranded(schema) && isMaskEnabled) {
+                    const transformer = this.sensitiveTransformer.maybeCompile(schema);
+                    if (transformer)
+                        artifacts.transforms.maskQuery = obj => transformer(obj, this.maskField);
+                }
+            }
             this.logger.debug('route options', { options: routeOptions });
             this.instance.route(routeOptions);
             this.logger.info(`registered route ${metadata.method} ${routeOptions.url}`);
@@ -203,6 +266,12 @@ let FastifyRouter = class FastifyRouter extends app_1.Router {
         await this.instance.close();
         this.logger.info('server stopped');
     }
+    async resolveChildRoute(url) {
+        if (!this.childRouter)
+            throw new common_1.InternalError('Child routes are not enabled');
+        const response = await this.instance.inject({ method: 'GET', url, headers: { 'x-service': 'internal-child-route' } });
+        return response.json();
+    }
     mockRequest(options) {
         return options ? this.instance.inject(options) : this.instance.inject();
     }
@@ -212,5 +281,5 @@ exports.FastifyRouter = FastifyRouter = __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, services_1.Context])
+    __metadata("design:paramtypes", [Object, Object, services_1.ContextService])
 ], FastifyRouter);

package/cjs/module/fastify.module.js

@@ -7,6 +7,7 @@ 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 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");
@@ -18,24 +19,41 @@ class FastifyModule {
             port: 8080,
             responseSchema: { '4xx': errorResponseSchema, '5xx': errorResponseSchema },
             errorHandler: new classes_1.DefaultErrorHandler(),
-            ignoreTrailingSlash: true,
-            ignoreDuplicateSlashes: true,
+            maskSensitiveData: common_1.Config.isProd(),
             requestIdLogLabel: 'rid',
             genReqId: () => (0, uuid_1.v4)(),
+            routerOptions: {
+                ignoreTrailingSlash: true,
+                ignoreDuplicateSlashes: 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 });
+        const config = Object.assign({}, this.getDefaultConfig(), common_1.utils.object.omitKeys(options, ['imports', 'controllers', 'providers', 'exports', 'fastifyFactory']));
+        return this.forRootAsync({
+            imports: options.imports,
+            controllers: options.controllers,
+            providers: options.providers,
+            exports: options.exports,
+            useFactory: () => config,
+            fastifyFactory: options.fastifyFactory,
+        });
     }
     static forRootAsync(options) {
         const imports = options.imports ?? [];
-        const providers = [{ token: app_1.Router, useClass: fastify_router_1.FastifyRouter }];
+        const controllers = options.controllers ?? [];
+        const exports = options.exports ?? [];
+        const providers = [{ token: app_1.Router, useClass: fastify_router_1.FastifyRouter }, services_1.ContextService];
+        if (options.providers)
+            providers.push(...options.providers);
         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;
+        const Class = class extends FastifyModule {
+        };
+        Object.defineProperty(Class, 'name', { value: FastifyModule.name });
+        (0, app_1.Module)({ imports, controllers, providers, exports: [app_1.Router, services_1.ContextService, ...exports] })(Class);
+        return Class;
     }
 }
 exports.FastifyModule = FastifyModule;

package/cjs/module/fastify.utils.js

@@ -7,22 +7,35 @@ exports.notFoundHandler = void 0;
 exports.compileValidator = compileValidator;
 exports.formatSchemaErrors = formatSchemaErrors;
 exports.createFastifyInstance = createFastifyInstance;
-const assert_1 = __importDefault(require("assert"));
+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");
 const server_error_1 = require("../server.error.js");
+const keywords = ['x-fastify'];
 const allowedHttpParts = ['body', 'params', 'querystring'];
-const strictValidator = new ajv_1.default({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true });
-const lenientValidator = new ajv_1.default({ allErrors: true, coerceTypes: true, useDefaults: true, removeAdditional: true, strict: true });
+const strictValidator = new ajv_1.default({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true, keywords });
+const lenientValidator = new ajv_1.default({ allErrors: true, coerceTypes: true, useDefaults: true, removeAdditional: true, strict: true, keywords });
 const notFoundError = new server_error_1.ServerError(server_error_1.ServerErrorCode.S002);
 const notFoundHandler = () => (0, common_1.throwError)(notFoundError);
 exports.notFoundHandler = notFoundHandler;
+function compileSchema(ajv, schema) {
+    if (!schema.$id)
+        return ajv.compile(schema);
+    const schemas = [common_1.utils.object.omitKeys(schema, ['definitions']), ...Object.values(schema.definitions ?? {})];
+    for (const schema of schemas) {
+        if (schema.$id && !ajv.getSchema(schema.$id))
+            ajv.addSchema(schema, schema.$id);
+    }
+    return ajv.getSchema(schema.$id);
+}
 function compileValidator(routeSchema) {
-    (0, assert_1.default)(allowedHttpParts.includes(routeSchema.httpPart), `Invalid httpPart: ${routeSchema.httpPart}`);
-    if (routeSchema.httpPart !== 'querystring')
-        return strictValidator.compile(routeSchema.schema);
-    const validate = lenientValidator.compile(routeSchema.schema);
+    (0, node_assert_1.default)(allowedHttpParts.includes(routeSchema.httpPart), `Invalid httpPart: ${routeSchema.httpPart}`);
+    if (routeSchema.httpPart === 'body')
+        return compileSchema(strictValidator, routeSchema.schema);
+    if (routeSchema.httpPart === 'params')
+        return compileSchema(lenientValidator, routeSchema.schema);
+    const validate = compileSchema(lenientValidator, routeSchema.schema);
     return (data) => {
         validate(data);
         for (const error of validate.errors ?? []) {

package/cjs/server.error.d.ts

@@ -13,4 +13,6 @@ export declare class ServerErrorCode extends ErrorCode {
     static readonly S005: ServerErrorCode;
     static readonly S006: ServerErrorCode;
     static readonly S007: ServerErrorCode;
+    static readonly S008: ServerErrorCode;
+    static readonly S009: ServerErrorCode;
 }

package/cjs/server.error.js

@@ -27,12 +27,14 @@ class ServerErrorCode extends common_1.ErrorCode {
     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);
+    static S001 = new ServerErrorCode('S001', common_1.ErrorType.SERVER_ERROR, 'An unexpected server error occurred while processing the request');
+    static S002 = new ServerErrorCode('S002', common_1.ErrorType.NOT_FOUND, 'The requested endpoint does not exist');
+    static S003 = new ServerErrorCode('S003', common_1.ErrorType.VALIDATION_ERROR, 'The provided input data is invalid or does not meet validation requirements');
+    static S004 = new ServerErrorCode('S004', common_1.ErrorType.UNAUTHENTICATED, 'Authentication credentials are required to access this resource');
+    static S005 = new ServerErrorCode('S005', common_1.ErrorType.UNAUTHORIZED, 'Access denied due to insufficient permissions to perform this operation');
+    static S006 = new ServerErrorCode('S006', common_1.ErrorType.CLIENT_ERROR, 'The request is malformed or contains invalid parameters');
+    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);
+    static S008 = new ServerErrorCode('S008', common_1.ErrorType.CONFLICT, 'Resource conflict as the requested operation conflicts with existing data');
+    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,13 +1,21 @@
-import { MiddlewareHandler } from '../interfaces/index.js';
+import { onRequestHookHandler } from 'fastify';
+import { HttpRequest, HttpResponse } from '../interfaces/index.js';
 type Key = string | symbol;
-export declare class Context {
+export declare class ContextService {
+    static readonly name = "ContextService";
     private readonly storage;
-    init(): MiddlewareHandler;
+    init(): onRequestHookHandler;
     get<T>(key: Key, throwOnMissing: true): T;
-    get<T>(key: Key, throwOnMissing?: false): T | null;
+    get<T>(key: Key, throwOnMissing?: boolean): T | null;
+    getFromParent<T>(key: Key, throwOnMissing: true): T;
+    getFromParent<T>(key: Key, throwOnMissing?: boolean): T | null;
+    resolve<T>(key: Key, throwOnMissing: true): T;
+    resolve<T>(key: Key, throwOnMissing?: boolean): T | null;
     set<T>(key: Key, value: T): this;
-    getRequest(): Request;
-    getResponse(): Response;
+    setInParent<T>(key: Key, value: T): this;
+    isChildContext(): boolean;
+    getRequest(): HttpRequest;
+    getResponse(): HttpResponse;
     getRID(): string;
 }
 export {};

package/cjs/services/context.service.js

@@ -6,22 +6,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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");
+exports.ContextService = void 0;
+const node_async_hooks_1 = require("node: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();
+const PARENT_CONTEXT = Symbol('parent-context');
+const CHILD_RID_COUNTER = Symbol('child-rid-counter');
+let ContextService = class ContextService {
+    static name = 'ContextService';
+    storage = new node_async_hooks_1.AsyncLocalStorage();
     init() {
-        return async (req, res) => {
+        return (req, res, done) => {
+            const parentStore = this.storage.getStore();
             const store = new Map();
+            if (parentStore) {
+                const isChildContext = parentStore.has(PARENT_CONTEXT);
+                if (isChildContext)
+                    throw new common_1.InternalError('Cannot create a child context within an existing child context');
+                const childRIDCounter = (this.get(CHILD_RID_COUNTER) ?? 0) + 1;
+                this.set(CHILD_RID_COUNTER, childRIDCounter);
+                req.id = `${this.getRID()}-${childRIDCounter}`;
+                store.set(PARENT_CONTEXT, parentStore);
+            }
             store.set(REQUEST, req);
             store.set(RESPONSE, res);
             store.set(RID, req.id);
-            this.storage.enterWith(store);
+            this.storage.run(store, done);
         };
     }
     get(key, throwOnMissing) {
@@ -29,11 +42,26 @@ let Context = class Context {
         if (!store)
             throw new common_1.InternalError('Context not yet initialized');
         const value = store.get(key);
-        if (throwOnMissing && value === undefined) {
+        if (throwOnMissing && value === undefined)
             throw new common_1.InternalError(`Key '${key.toString()}' not found in the context`);
-        }
         return value ?? null;
     }
+    getFromParent(key, throwOnMissing) {
+        if (!this.isChildContext())
+            return this.get(key, throwOnMissing);
+        const parentStore = this.get(PARENT_CONTEXT, true);
+        const value = parentStore.get(key);
+        if (throwOnMissing && value === undefined)
+            throw new common_1.InternalError(`Key '${key.toString()}' not found in the parent context`);
+        return value ?? null;
+    }
+    resolve(key, throwOnMissing) {
+        const isChild = this.isChildContext();
+        const value = this.get(key, !isChild);
+        if (value !== null || !isChild)
+            return value;
+        return this.getFromParent(key, throwOnMissing);
+    }
     set(key, value) {
         const store = this.storage.getStore();
         if (!store)
@@ -41,6 +69,17 @@ let Context = class Context {
         store.set(key, value);
         return this;
     }
+    setInParent(key, value) {
+        if (!this.isChildContext())
+            return this.set(key, value);
+        const parentStore = this.get(PARENT_CONTEXT, true);
+        parentStore.set(key, value);
+        return this;
+    }
+    isChildContext() {
+        const parentStore = this.get(PARENT_CONTEXT);
+        return parentStore !== null;
+    }
     getRequest() {
         return this.get(REQUEST, true);
     }
@@ -51,7 +90,7 @@ let Context = class Context {
         return this.get(RID, true);
     }
 };
-exports.Context = Context;
-exports.Context = Context = __decorate([
+exports.ContextService = ContextService;
+exports.ContextService = ContextService = __decorate([
     (0, app_1.Injectable)()
-], Context);
+], ContextService);

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

@@ -1,30 +1,31 @@
-import { AppError, ErrorType, Logger, ValidationError } from '@shadow-library/common';
+import { AppError, Logger, ValidationError } from '@shadow-library/common';
 import { NAMESPACE } from '../constants.js';
 import { ServerError, ServerErrorCode } from '../server.error.js';
 const unexpectedError = new ServerError(ServerErrorCode.S001);
 const validationError = new ServerError(ServerErrorCode.S003);
+const invalidRequestError = new ServerError(ServerErrorCode.S006);
 export class DefaultErrorHandler {
     logger = Logger.getLogger(NAMESPACE, 'DefaultErrorHandler');
     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 } };
+        return { statusCode: err.statusCode, error: { ...invalidRequestError.toObject(), message: err.message } };
     }
     handle(err, _req, res) {
         this.logger.warn('Handling error', err);
         if (err.cause)
-            this.logger.warn('Caused by:', 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() });
+            return res.status(validationError.getStatusCode()).send({ ...err.toObject(), ...validationError.toObject() });
         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);
+        this.logger.error('Unhandled error has occurred', err);
         return res.status(500).send(unexpectedError.toObject());
     }
 }

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

@@ -1,4 +1,5 @@
 import { JSONSchema } from '@shadow-library/class-schema';
+import { Class } from 'type-fest';
 export declare enum RouteInputType {
     BODY = "body",
     PARAMS = "params",
@@ -6,7 +7,7 @@ export declare enum RouteInputType {
     REQUEST = "request",
     RESPONSE = "response"
 }
-export type RouteInputSchemas = Partial<Record<'body' | 'params' | 'query', JSONSchema>>;
+export type RouteInputSchemas = Partial<Record<'body' | 'params' | 'query', JSONSchema | Class<unknown>>>;
 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,5 @@
-import assert from 'assert';
+import assert from 'node: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) {
@@ -18,7 +17,7 @@ export function HttpInput(type, schema) {
         inputs[index] = type;
         if (!schema) {
             const paramTypes = Reflect.getMetadata(PARAMTYPES_METADATA, target, propertyKey);
-            schema = ClassSchema.generate(paramTypes[index]);
+            schema = paramTypes[index];
         }
         const descriptor = Reflect.getOwnPropertyDescriptor(target, propertyKey);
         assert(descriptor, 'Cannot apply decorator to a non-method');

package/esm/decorators/index.d.ts

@@ -3,3 +3,4 @@ export * from './http-input.decorator.js';
 export * from './http-output.decorator.js';
 export * from './http-route.decorator.js';
 export * from './middleware.decorator.js';
+export * from './sensitive.decorator.js';

package/esm/decorators/index.js

@@ -3,3 +3,4 @@ export * from './http-input.decorator.js';
 export * from './http-output.decorator.js';
 export * from './http-route.decorator.js';
 export * from './middleware.decorator.js';
+export * from './sensitive.decorator.js';