@shadow-library/fastify 0.0.5 → 0.0.7

package/esm/decorators/middleware.decorator.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { Controller } from '@shadow-library/app';
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
 const propertyKeys = ['generate', 'use'];

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

@@ -0,0 +1,4 @@
+import { MaskOptions } from '@shadow-library/common';
+export type SensitiveDataType = 'secret' | 'email' | 'number' | 'words';
+export declare function Sensitive(type?: SensitiveDataType): PropertyDecorator;
+export declare function Sensitive(maskOptions: MaskOptions): PropertyDecorator;

package/esm/decorators/sensitive.decorator.js

@@ -0,0 +1,12 @@
+import { FieldMetadata } from '@shadow-library/class-schema';
+export function Sensitive(typeOrMaskOptions = 'secret') {
+    return (target, propertyKey) => {
+        const options = { sensitive: true };
+        if (typeof typeOrMaskOptions === 'string')
+            options.type = typeOrMaskOptions;
+        else
+            options.maskOptions = typeOrMaskOptions;
+        const decorator = FieldMetadata({ 'x-fastify': options });
+        decorator(target, propertyKey);
+    };
+}

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

@@ -1,9 +1,12 @@
-import { RouteMetdata } from '@shadow-library/app';
-import { HttpRequest, HttpResponse } from './route-handler.interface.js';
-export type MiddlewareHandler = (request: HttpRequest, response: HttpResponse) => Promise<any>;
+import { RouteMetadata } from '@shadow-library/app';
+import { HttpCallback, HttpRequest, HttpResponse, RouteHandler } from './route-handler.interface.js';
 export interface MiddlewareGenerator {
-    generate(metadata: RouteMetdata): MiddlewareHandler | undefined | Promise<MiddlewareHandler | undefined>;
+    cacheKey?: (metadata: RouteMetadata) => string;
+    generate(metadata: RouteMetadata): RouteHandler | undefined | Promise<RouteHandler | undefined>;
 }
-export interface HttpMiddleware {
-    use(request: HttpRequest, response: HttpResponse): Promise<any>;
+export interface AsyncHttpMiddleware {
+    use(request: HttpRequest, response: HttpResponse): Promise<unknown>;
+}
+export interface CallbackHttpMiddleware {
+    use(request: HttpRequest, response: HttpResponse, done: HttpCallback): void;
 }

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

@@ -1,4 +1,8 @@
-import { FastifyReply, FastifyRequest } from 'fastify';
+import { SyncValue } from '@shadow-library/common';
+import { DoneFuncWithErrOrRes, FastifyReply, FastifyRequest } from 'fastify';
 export type HttpRequest = FastifyRequest;
 export type HttpResponse = FastifyReply;
-export type RouteHandler = (req: HttpRequest, res: HttpResponse) => unknown | Promise<unknown>;
+export type HttpCallback = DoneFuncWithErrOrRes;
+export type CallbackRouteHandler = (request: HttpRequest, response: HttpResponse, done: HttpCallback) => SyncValue<unknown>;
+export type AsyncRouteHandler = (request: HttpRequest, response: HttpResponse) => Promise<unknown>;
+export type RouteHandler<T extends (...args: any[]) => any = any> = ReturnType<T> extends Promise<unknown> ? AsyncRouteHandler : CallbackRouteHandler;

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

@@ -1,24 +1,25 @@
-import { RouteMetdata } from '@shadow-library/app';
+import { RouteMetadata } 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'> {
+    interface RouteMetadata extends Omit<RouteShorthandOptions, 'config'> {
         method?: HttpMethod;
         path?: string;
         schemas?: RouteInputSchemas & {
             response?: Record<number | string, JSONSchema>;
         };
         rawBody?: boolean;
+        silentValidation?: boolean;
         status?: number;
         headers?: Record<string, string | (() => string)>;
         redirect?: string;
         render?: string | true;
     }
-    interface ControllerMetdata {
+    interface ControllerMetadata {
         [HTTP_CONTROLLER_TYPE]?: 'router' | 'middleware';
         path?: string;
     }
 }
-export type ServerMetadata = RouteMetdata;
+export type ServerMetadata = RouteMetadata;

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

@@ -6,5 +6,5 @@ export declare class ErrorResponseDto {
     code: string;
     type: string;
     message: string;
-    fields: ErrorFieldDto[];
+    fields?: ErrorFieldDto[];
 }

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

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

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

@@ -10,24 +10,36 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import assert from 'assert';
+import assert from 'node:assert';
 import { Inject, Injectable, Router } from '@shadow-library/app';
+import { ClassSchema, TransformerFactory } from '@shadow-library/class-schema';
 import { InternalError, Logger, utils } from '@shadow-library/common';
 import merge from 'deepmerge';
+import findMyWay from 'find-my-way';
+import stringify from 'json-stable-stringify';
 import { FASTIFY_CONFIG, FASTIFY_INSTANCE, HTTP_CONTROLLER_INPUTS, HTTP_CONTROLLER_TYPE, NAMESPACE } from '../constants.js';
 import { HttpMethod } from '../decorators/index.js';
-import { Context } from '../services/index.js';
+import { ContextService } from '../services/index.js';
 const httpMethods = Object.values(HttpMethod).filter(m => m !== HttpMethod.ALL);
+const DEFAULT_ARTIFACTS = { transforms: {} };
 let FastifyRouter = class FastifyRouter extends Router {
     config;
     instance;
     context;
+    static name = 'FastifyRouter';
     logger = Logger.getLogger(NAMESPACE, 'FastifyRouter');
+    cachedDynamicMiddlewares = new Map();
+    childRouter = null;
+    sensitiveTransformer = new 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 = utils.object.pickKeys(config, ['ignoreTrailingSlash', 'ignoreDuplicateSlashes', 'allowUnsafeRegex', 'caseSensitive', 'maxParamLength', 'querystringParser']);
+            this.childRouter = findMyWay(options);
+        }
     }
     getInstance() {
         return this.instance;
@@ -37,21 +49,34 @@ let FastifyRouter = class FastifyRouter extends 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 utils.string.maskEmail(stringified);
+        if (type === 'number')
+            return utils.string.maskNumber(stringified);
+        if (type === 'words')
+            return 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'];
@@ -60,13 +85,15 @@ let FastifyRouter = class FastifyRouter extends 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) {
@@ -140,6 +167,18 @@ let FastifyRouter = class FastifyRouter extends 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 : stringify;
+        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 ?? {};
@@ -156,14 +195,15 @@ let FastifyRouter = class FastifyRouter extends Router {
             assert(metadata.method, 'Route method is required');
             this.logger.debug(`registering route ${metadata.method} ${metadata.path}`);
             const fastifyRouteOptions = utils.object.omitKeys(metadata, ['path', 'method', 'schemas', 'rawBody', 'status', 'headers', 'redirect', 'render']);
-            const routeOptions = { ...fastifyRouteOptions, config: { metadata } };
+            const artifacts = { transforms: {} };
+            const routeOptions = { ...fastifyRouteOptions, config: { metadata, artifacts } };
             routeOptions.url = metadata.path;
             routeOptions.method = metadata.method === HttpMethod.ALL ? httpMethods : [metadata.method];
             routeOptions.handler = this.generateRouteHandler(route);
             for (const middleware of middlewares) {
                 const name = middleware.metatype.name;
-                const { generates, type } = middleware.metadata;
-                const handler = generates ? await middleware.handler(metadata) : middleware.handler.bind(middleware);
+                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];
@@ -176,12 +216,35 @@ let FastifyRouter = class FastifyRouter extends Router {
             routeOptions.schema = {};
             routeOptions.attachValidation = metadata.silentValidation ?? false;
             routeOptions.schema.response = merge(metadata.schemas?.response ?? {}, defaultResponseSchemas);
-            if (metadata.schemas?.body)
-                routeOptions.schema.body = metadata.schemas.body;
-            if (metadata.schemas?.params)
-                routeOptions.schema.params = metadata.schemas.params;
-            if (metadata.schemas?.query)
-                routeOptions.schema.querystring = metadata.schemas.query;
+            const { body: bodySchema, params: paramsSchema, query: querySchema } = metadata.schemas ?? {};
+            const isMaskEnabled = this.config.maskSensitiveData ?? true;
+            if (bodySchema) {
+                const schema = typeof bodySchema === 'function' ? ClassSchema.generate(bodySchema) : bodySchema;
+                routeOptions.schema.body = schema;
+                if (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' ? ClassSchema.generate(paramsSchema) : paramsSchema;
+                routeOptions.schema.params = schema;
+                if (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' ? ClassSchema.generate(querySchema) : querySchema;
+                routeOptions.schema.querystring = schema;
+                if (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}`);
@@ -197,6 +260,12 @@ let FastifyRouter = class FastifyRouter extends Router {
         await this.instance.close();
         this.logger.info('server stopped');
     }
+    async resolveChildRoute(url) {
+        if (!this.childRouter)
+            throw new 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();
     }
@@ -205,6 +274,6 @@ FastifyRouter = __decorate([
     Injectable(),
     __param(0, Inject(FASTIFY_CONFIG)),
     __param(1, Inject(FASTIFY_INSTANCE)),
-    __metadata("design:paramtypes", [Object, Object, Context])
+    __metadata("design:paramtypes", [Object, Object, ContextService])
 ], FastifyRouter);
 export { FastifyRouter };

package/esm/module/fastify.module.js

@@ -1,9 +1,10 @@
 import { Module, Router } from '@shadow-library/app';
 import { ClassSchema } from '@shadow-library/class-schema';
-import { utils } from '@shadow-library/common';
+import { Config, utils } from '@shadow-library/common';
 import { v4 as uuid } from 'uuid';
 import { DefaultErrorHandler } from '../classes/index.js';
 import { FASTIFY_CONFIG, FASTIFY_INSTANCE } from '../constants.js';
+import { ContextService } from '../services/index.js';
 import { ErrorResponseDto } from './error-response.dto.js';
 import { FastifyRouter } from './fastify-router.js';
 import { createFastifyInstance } from './fastify.utils.js';
@@ -15,23 +16,40 @@ export class FastifyModule {
             port: 8080,
             responseSchema: { '4xx': errorResponseSchema, '5xx': errorResponseSchema },
             errorHandler: new DefaultErrorHandler(),
-            ignoreTrailingSlash: true,
-            ignoreDuplicateSlashes: true,
+            maskSensitiveData: Config.isProd(),
             requestIdLogLabel: 'rid',
             genReqId: () => uuid(),
+            routerOptions: {
+                ignoreTrailingSlash: true,
+                ignoreDuplicateSlashes: true,
+            },
         };
     }
     static forRoot(options) {
-        const config = Object.assign({}, this.getDefaultConfig(), utils.object.omitKeys(options, ['imports', 'fastifyFactory']));
-        return this.forRootAsync({ imports: options.imports, useFactory: () => config, fastifyFactory: options.fastifyFactory });
+        const config = Object.assign({}, this.getDefaultConfig(), 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: Router, useClass: FastifyRouter }];
+        const controllers = options.controllers ?? [];
+        const exports = options.exports ?? [];
+        const providers = [{ token: Router, useClass: FastifyRouter }, ContextService];
+        if (options.providers)
+            providers.push(...options.providers);
         providers.push({ token: FASTIFY_CONFIG, useFactory: options.useFactory, inject: options.inject });
         const fastifyFactory = (config) => createFastifyInstance(config, options.fastifyFactory);
         providers.push({ token: FASTIFY_INSTANCE, useFactory: fastifyFactory, inject: [FASTIFY_CONFIG] });
-        Module({ imports, providers, exports: [Router] })(FastifyModule);
-        return FastifyModule;
+        const Class = class extends FastifyModule {
+        };
+        Object.defineProperty(Class, 'name', { value: FastifyModule.name });
+        Module({ imports, controllers, providers, exports: [Router, ContextService, ...exports] })(Class);
+        return Class;
     }
 }

package/esm/module/fastify.utils.js

@@ -1,18 +1,31 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { ValidationError, throwError, utils } from '@shadow-library/common';
 import Ajv from 'ajv';
 import { fastify } from 'fastify';
 import { ServerError, ServerErrorCode } from '../server.error.js';
+const keywords = ['x-fastify'];
 const allowedHttpParts = ['body', 'params', 'querystring'];
-const strictValidator = new Ajv({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true });
-const lenientValidator = new Ajv({ allErrors: true, coerceTypes: true, useDefaults: true, removeAdditional: true, strict: true });
+const strictValidator = new Ajv({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true, keywords });
+const lenientValidator = new Ajv({ allErrors: true, coerceTypes: true, useDefaults: true, removeAdditional: true, strict: true, keywords });
 const notFoundError = new ServerError(ServerErrorCode.S002);
 export const notFoundHandler = () => throwError(notFoundError);
+function compileSchema(ajv, schema) {
+    if (!schema.$id)
+        return ajv.compile(schema);
+    const schemas = [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);
+}
 export function compileValidator(routeSchema) {
     assert(allowedHttpParts.includes(routeSchema.httpPart), `Invalid httpPart: ${routeSchema.httpPart}`);
-    if (routeSchema.httpPart !== 'querystring')
-        return strictValidator.compile(routeSchema.schema);
-    const validate = lenientValidator.compile(routeSchema.schema);
+    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/esm/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/esm/server.error.js

@@ -23,11 +23,13 @@ export class ServerErrorCode extends ErrorCode {
     getStatusCode() {
         return this.statusCode;
     }
-    static S001 = new ServerErrorCode('S001', ErrorType.SERVER_ERROR, 'Unexpected Server Error');
-    static S002 = new ServerErrorCode('S002', ErrorType.NOT_FOUND, 'Not Found');
-    static S003 = new ServerErrorCode('S003', ErrorType.VALIDATION_ERROR, 'Invalid Input');
-    static S004 = new ServerErrorCode('S004', ErrorType.CLIENT_ERROR, 'Request body is too large', 413);
-    static S005 = new ServerErrorCode('S005', ErrorType.CLIENT_ERROR, 'Request body size did not match Content-Length');
-    static S006 = new ServerErrorCode('S006', ErrorType.CLIENT_ERROR, "Body cannot be empty when content-type is set to 'application/json'");
-    static S007 = new ServerErrorCode('S007', ErrorType.CLIENT_ERROR, 'Received media type is not supported', 415);
+    static S001 = new ServerErrorCode('S001', ErrorType.SERVER_ERROR, 'An unexpected server error occurred while processing the request');
+    static S002 = new ServerErrorCode('S002', ErrorType.NOT_FOUND, 'The requested endpoint does not exist');
+    static S003 = new ServerErrorCode('S003', ErrorType.VALIDATION_ERROR, 'The provided input data is invalid or does not meet validation requirements');
+    static S004 = new ServerErrorCode('S004', ErrorType.UNAUTHENTICATED, 'Authentication credentials are required to access this resource');
+    static S005 = new ServerErrorCode('S005', ErrorType.UNAUTHORIZED, 'Access denied due to insufficient permissions to perform this operation');
+    static S006 = new ServerErrorCode('S006', ErrorType.CLIENT_ERROR, 'The request is malformed or contains invalid parameters');
+    static S007 = new ServerErrorCode('S007', ErrorType.CLIENT_ERROR, 'Rate limit exceeded due to too many requests sent in a given time frame', 429);
+    static S008 = new ServerErrorCode('S008', ErrorType.CONFLICT, 'Resource conflict as the requested operation conflicts with existing data');
+    static S009 = new ServerErrorCode('S009', ErrorType.NOT_FOUND, 'The requested resource could not be found');
 }

package/esm/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/esm/services/context.service.js

@@ -4,21 +4,34 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-import { AsyncLocalStorage } from 'async_hooks';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Injectable } from '@shadow-library/app';
 import { InternalError } from '@shadow-library/common';
 const REQUEST = Symbol('request');
 const RESPONSE = Symbol('response');
 const RID = Symbol('rid');
-let Context = class Context {
+const PARENT_CONTEXT = Symbol('parent-context');
+const CHILD_RID_COUNTER = Symbol('child-rid-counter');
+let ContextService = class ContextService {
+    static name = 'ContextService';
     storage = new 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 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) {
@@ -26,11 +39,26 @@ let Context = class Context {
         if (!store)
             throw new InternalError('Context not yet initialized');
         const value = store.get(key);
-        if (throwOnMissing && value === undefined) {
+        if (throwOnMissing && value === undefined)
             throw new 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 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)
@@ -38,6 +66,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);
     }
@@ -48,7 +87,7 @@ let Context = class Context {
         return this.get(RID, true);
     }
 };
-Context = __decorate([
+ContextService = __decorate([
     Injectable()
-], Context);
-export { Context };
+], ContextService);
+export { ContextService };