@shadow-library/fastify 0.0.10 → 0.0.12

package/cjs/module/fastify.module.js

@@ -1,16 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastifyModule = void 0;
+/**
+ * Importing npm packages
+ */
 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");
+/**
+ * Importing user defined packages
+ */
 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");
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 class FastifyModule {
     static getDefaultConfig() {
         const errorResponseSchema = class_schema_1.ClassSchema.generate(error_response_dto_1.ErrorResponseDto);

package/cjs/module/fastify.utils.js

@@ -7,11 +7,23 @@ exports.notFoundHandler = void 0;
 exports.compileValidator = compileValidator;
 exports.formatSchemaErrors = formatSchemaErrors;
 exports.createFastifyInstance = createFastifyInstance;
+/**
+ * Importing npm packages
+ */
 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");
+/**
+ * Importing user defined packages
+ */
 const server_error_1 = require("../server.error.js");
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 const keywords = ['x-fastify'];
 const allowedHttpParts = ['body', 'params', 'querystring'];
 const strictValidator = new ajv_1.default({ allErrors: true, useDefaults: true, removeAdditional: true, strict: true, keywords });
@@ -39,12 +51,13 @@ function compileValidator(routeSchema) {
     return (data) => {
         validate(data);
         for (const error of validate.errors ?? []) {
+            /** Since this schema is for querystring there won't be any nested objects so we are directly accessing the path */
             const path = error.instancePath.substring(1);
             const defaultValue = routeSchema.schema.properties?.[path]?.default;
             if (defaultValue !== undefined)
                 data[path] = defaultValue;
             else
-                delete data[path];
+                delete data[path]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
         }
         return { value: data };
     };

package/cjs/server.error.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Importing npm packages
+ */
 import { AppError, ErrorCode, ErrorType } from '@shadow-library/common';
 export declare class ServerError extends AppError<ServerErrorCode> {
     getStatusCode(): number;
@@ -6,13 +9,27 @@ export declare class ServerErrorCode extends ErrorCode {
     private readonly statusCode;
     protected constructor(code: string, type: ErrorType, msg: string, statusCode?: number);
     getStatusCode(): number;
+    /*!
+     * List of all server related errors
+     */
+    /** An unexpected server error occurred while processing the request */
     static readonly S001: ServerErrorCode;
+    /** The requested endpoint does not exist */
     static readonly S002: ServerErrorCode;
+    /** The provided input data is invalid or does not meet validation requirements */
     static readonly S003: ServerErrorCode;
+    /** Authentication credentials are required to access this resource */
     static readonly S004: ServerErrorCode;
+    /** Access denied due to insufficient permissions to perform this operation */
     static readonly S005: ServerErrorCode;
+    /** The request is malformed or contains invalid parameters */
     static readonly S006: ServerErrorCode;
+    /** Rate limit exceeded due to too many requests sent in a given time frame */
     static readonly S007: ServerErrorCode;
+    /** Resource conflict as the requested operation conflicts with existing data */
     static readonly S008: ServerErrorCode;
+    /** The requested resource could not be found */
     static readonly S009: ServerErrorCode;
+    /** Access blocked due to security policy restrictions */
+    static readonly S010: ServerErrorCode;
 }

package/cjs/server.error.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerErrorCode = exports.ServerError = void 0;
+/**
+ * Importing npm packages
+ */
 const common_1 = require("@shadow-library/common");
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 const ERROR_STATUS_CODES = {
     [common_1.ErrorType.CLIENT_ERROR]: 400,
     [common_1.ErrorType.HTTP_ERROR]: 400,
@@ -27,14 +39,28 @@ class ServerErrorCode extends common_1.ErrorCode {
     getStatusCode() {
         return this.statusCode;
     }
+    /*!
+     * List of all server related errors
+     */
+    /** An unexpected server error occurred while processing the request */
     static S001 = new ServerErrorCode('S001', common_1.ErrorType.SERVER_ERROR, 'An unexpected server error occurred while processing the request');
+    /** The requested endpoint does not exist */
     static S002 = new ServerErrorCode('S002', common_1.ErrorType.NOT_FOUND, 'The requested endpoint does not exist');
+    /** The provided input data is invalid or does not meet validation requirements */
     static S003 = new ServerErrorCode('S003', common_1.ErrorType.VALIDATION_ERROR, 'The provided input data is invalid or does not meet validation requirements');
+    /** Authentication credentials are required to access this resource */
     static S004 = new ServerErrorCode('S004', common_1.ErrorType.UNAUTHENTICATED, 'Authentication credentials are required to access this resource');
+    /** Access denied due to insufficient permissions to perform this operation */
     static S005 = new ServerErrorCode('S005', common_1.ErrorType.UNAUTHORIZED, 'Access denied due to insufficient permissions to perform this operation');
+    /** The request is malformed or contains invalid parameters */
     static S006 = new ServerErrorCode('S006', common_1.ErrorType.CLIENT_ERROR, 'The request is malformed or contains invalid parameters');
+    /** Rate limit exceeded due to too many requests sent in a given time frame */
     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);
+    /** Resource conflict as the requested operation conflicts with existing data */
     static S008 = new ServerErrorCode('S008', common_1.ErrorType.CONFLICT, 'Resource conflict as the requested operation conflicts with existing data');
+    /** The requested resource could not be found */
     static S009 = new ServerErrorCode('S009', common_1.ErrorType.NOT_FOUND, 'The requested resource could not be found');
+    /** Access blocked due to security policy restrictions */
+    static S010 = new ServerErrorCode('S010', common_1.ErrorType.UNAUTHORIZED, 'Access blocked due to security policy restrictions');
 }
 exports.ServerErrorCode = ServerErrorCode;

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

@@ -1,5 +1,11 @@
 import { onRequestHookHandler } from 'fastify';
+/**
+ * Importing user defined packages
+ */
 import { HttpRequest, HttpResponse } from '../interfaces/index.js';
+/**
+ * Defining types
+ */
 type Key = string | symbol;
 export interface ContextExtension {
 }

package/cjs/services/context.service.js

@@ -7,9 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextService = void 0;
+/**
+ * Importing npm packages
+ */
 const node_async_hooks_1 = require("node:async_hooks");
 const app_1 = require("@shadow-library/app");
 const common_1 = require("@shadow-library/common");
+/**
+ * Declaring the constants
+ */
 const REQUEST = Symbol('request');
 const RESPONSE = Symbol('response');
 const RID = Symbol('rid');

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

@@ -1,6 +1,12 @@
+/**
+ * Importing npm packages
+ */
 import { AppErrorObject } from '@shadow-library/common';
 import { FastifyError } from 'fastify';
 import { ErrorHandler, HttpRequest, HttpResponse } from '../interfaces/index.js';
+/**
+ * Defining types
+ */
 export interface ParsedFastifyError {
     statusCode: number;
     error: AppErrorObject;

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

@@ -1,6 +1,15 @@
+/**
+ * Importing npm packages
+ */
 import { AppError, Logger, ValidationError } from '@shadow-library/common';
+/**
+ * Importing user defined packages
+ */
 import { NAMESPACE } from '../constants.js';
 import { ServerError, ServerErrorCode } from '../server.error.js';
+/**
+ * Declaring the constants
+ */
 const unexpectedError = new ServerError(ServerErrorCode.S001);
 const validationError = new ServerError(ServerErrorCode.S003);
 const invalidRequestError = new ServerError(ServerErrorCode.S006);

package/esm/constants.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export declare const NAMESPACE = "@shadow-library/fastify";
 export declare const PARAMTYPES_METADATA = "design:paramtypes";
 export declare const FASTIFY_CONFIG: unique symbol;

package/esm/constants.js

@@ -1,3 +1,15 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export const NAMESPACE = '@shadow-library/fastify';
 export const PARAMTYPES_METADATA = 'design:paramtypes';
 export const FASTIFY_CONFIG = Symbol('fastify-config');

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

@@ -1 +1,7 @@
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export declare function HttpController(path?: string): ClassDecorator;

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

@@ -1,5 +1,17 @@
+/**
+ * Importing npm packages
+ */
 import { Controller } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export function HttpController(path = '') {
     if (path.charAt(0) !== '/')
         path = `/${path}`;

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

@@ -1,5 +1,8 @@
 import { JSONSchema } from '@shadow-library/class-schema';
 import { Class } from 'type-fest';
+/**
+ * Defining types
+ */
 export declare enum RouteInputType {
     BODY = "body",
     PARAMS = "params",
@@ -8,6 +11,9 @@ export declare enum RouteInputType {
     RESPONSE = "response"
 }
 export type RouteInputSchemas = Partial<Record<'body' | 'params' | 'query', JSONSchema | Class<unknown>>>;
+/**
+ * Declaring the constants
+ */
 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,15 @@
+/**
+ * Importing npm packages
+ */
 import assert from 'node:assert';
 import { Route } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_INPUTS, PARAMTYPES_METADATA } from '../constants.js';
+/**
+ * Defining types
+ */
 export var RouteInputType;
 (function (RouteInputType) {
     RouteInputType["BODY"] = "body";
@@ -9,6 +18,9 @@ export var RouteInputType;
     RouteInputType["REQUEST"] = "request";
     RouteInputType["RESPONSE"] = "response";
 })(RouteInputType || (RouteInputType = {}));
+/**
+ * Declaring the constants
+ */
 export function HttpInput(type, schema) {
     return (target, propertyKey, index) => {
         assert(propertyKey, 'Cannot apply decorator to a constructor parameter');

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

@@ -1,5 +1,14 @@
+/**
+ * Importing npm packages
+ */
 import { JSONSchema, SchemaClass } from '@shadow-library/class-schema';
 import { JsonObject } from 'type-fest';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export interface DynamicRender<T extends JsonObject> {
     template: string;
     data: T;

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

@@ -1,5 +1,11 @@
+/**
+ * Importing npm packages
+ */
 import { Route } from '@shadow-library/app';
 import { ClassSchema } from '@shadow-library/class-schema';
+/**
+ * Declaring the constants
+ */
 const isClass = (schema) => schema.toString().startsWith('class ');
 export const HttpStatus = (status) => Route({ status });
 export const Header = (name, value) => Route({ headers: { [name]: value } });

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

@@ -1,3 +1,9 @@
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export declare enum HttpMethod {
     GET = "GET",
     POST = "POST",
@@ -12,6 +18,9 @@ export interface RouteOptions {
     method: HttpMethod;
     path?: string;
 }
+/**
+ * Declaring the constants
+ */
 export declare function HttpRoute(options: RouteOptions): MethodDecorator;
 export declare const Get: (path?: string) => MethodDecorator;
 export declare const Post: (path?: string) => MethodDecorator;

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

@@ -1,4 +1,13 @@
+/**
+ * Importing npm packages
+ */
 import { Route } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export var HttpMethod;
 (function (HttpMethod) {
     HttpMethod["GET"] = "GET";
@@ -10,6 +19,9 @@ export var HttpMethod;
     HttpMethod["HEAD"] = "HEAD";
     HttpMethod["ALL"] = "ALL";
 })(HttpMethod || (HttpMethod = {}));
+/**
+ * Declaring the constants
+ */
 export function HttpRoute(options) {
     if (options.path && options.path.charAt(0) !== '/')
         options.path = `/${options.path}`;

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

@@ -1,7 +1,18 @@
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+/**
+ * Defining types
+ */
 export type MiddlewareType = 'onRequest' | 'preParsing' | 'preValidation' | 'preHandler' | 'preSerialization' | 'onSend' | 'onResponse' | 'onError';
 export interface MiddlewareOptions {
+    /**
+     * Denotes when to execute the middleware. default value is `preHandler`.
+     * see https://fastify.dev/docs/latest/Reference/Lifecycle for more information
+     */
     type: MiddlewareType;
+    /** Denotes the execution order, the higher value gets executed first */
     weight: number;
 }
 export interface MiddlewareMetadata extends MiddlewareOptions {

package/esm/decorators/middleware.decorator.js

@@ -1,6 +1,15 @@
+/**
+ * Importing npm packages
+ */
 import assert from 'node:assert';
 import { Controller } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
+/**
+ * Declaring the constants
+ */
 const propertyKeys = ['generate', 'use'];
 export function Middleware(options = {}) {
     if (!options.type)

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

@@ -1,4 +1,13 @@
 import { MaskOptions } from '@shadow-library/common';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
 export type SensitiveDataType = 'secret' | 'email' | 'number' | 'words';
+/**
+ * Declaring the constants
+ */
 export declare function Sensitive(type?: SensitiveDataType): PropertyDecorator;
 export declare function Sensitive(maskOptions: MaskOptions): PropertyDecorator;

package/esm/decorators/sensitive.decorator.js

@@ -1,3 +1,6 @@
+/**
+ * Importing npm packages
+ */
 import { FieldMetadata } from '@shadow-library/class-schema';
 export function Sensitive(typeOrMaskOptions = 'secret') {
     return (target, propertyKey) => {

package/esm/index.d.ts

@@ -1,4 +1,10 @@
+/**
+ * Importing npm packages
+ */
 import 'reflect-metadata';
+/**
+ * exporting modules
+ */
 export * from './classes/index.js';
 export * from './decorators/index.js';
 export * from './interfaces/index.js';

package/esm/index.js

@@ -1,4 +1,10 @@
+/**
+ * Importing npm packages
+ */
 import 'reflect-metadata';
+/**
+ * exporting modules
+ */
 export * from './classes/index.js';
 export * from './decorators/index.js';
 export * from './interfaces/index.js';

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

@@ -1,4 +1,16 @@
+/**
+ * Importing npm packages
+ */
+/**
+ * Importing user defined packages
+ */
 import { HttpRequest, HttpResponse } from './route-handler.interface.js';
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export interface ErrorHandler {
     handle(err: Error, req: HttpRequest, res: HttpResponse): any | Promise<any>;
 }

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

@@ -1 +1,4 @@
+/**
+ * Importing npm packages
+ */
 export {};

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

@@ -1,5 +1,14 @@
+/**
+ * Importing npm packages
+ */
 import { RouteMetadata } from '@shadow-library/app';
+/**
+ * Importing user defined packages
+ */
 import { HttpCallback, HttpRequest, HttpResponse, RouteHandler } from './route-handler.interface.js';
+/**
+ * Defining types
+ */
 export interface MiddlewareGenerator {
     cacheKey?: (metadata: RouteMetadata) => string;
     generate(metadata: RouteMetadata): RouteHandler | undefined | Promise<RouteHandler | undefined>;

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

@@ -1,5 +1,17 @@
+/**
+ * Importing npm packages
+ */
 import { SyncValue } from '@shadow-library/common';
 import { DoneFuncWithErrOrRes, FastifyReply, FastifyRequest } from 'fastify';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export type HttpRequest = FastifyRequest;
 export type HttpResponse = FastifyReply;
 export type HttpCallback = DoneFuncWithErrOrRes;

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

@@ -1,8 +1,17 @@
+/**
+ * Importing npm packages
+ */
 import { RouteMetadata } from '@shadow-library/app';
 import { JSONSchema } from '@shadow-library/class-schema';
 import { RouteShorthandOptions } from 'fastify';
+/**
+ * Importing user defined packages
+ */
 import { HTTP_CONTROLLER_TYPE } from '../constants.js';
 import { HttpMethod, RouteInputSchemas } from '../decorators/index.js';
+/**
+ * Defining types
+ */
 declare module '@shadow-library/app' {
     interface RouteMetadata extends Omit<RouteShorthandOptions, 'config'> {
         method?: HttpMethod;

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

@@ -1,3 +1,12 @@
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 export declare class ErrorFieldDto {
     field: string;
     msg: string;

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

@@ -7,7 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+/**
+ * Importing npm packages
+ */
 import { Field, Schema } from '@shadow-library/class-schema';
+/**
+ * Importing user defined packages
+ */
+/**
+ * Defining types
+ */
+/**
+ * Declaring the constants
+ */
 let ErrorFieldDto = class ErrorFieldDto {
     field;
     msg;

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

@@ -1,24 +1,79 @@
+/**
+ * Importing npm packages
+ */
 import { FactoryProvider, ModuleMetadata } from '@shadow-library/app';
 import { JSONSchema } from '@shadow-library/class-schema';
 import { FastifyInstance, FastifyServerOptions } from 'fastify';
 import { Promisable } from 'type-fest';
+/**
+ * Importing user defined packages
+ */
 import { ErrorHandler } from '../interfaces/index.js';
+/**
+ * Defining types
+ */
 export interface FastifyConfig extends FastifyServerOptions {
+    /**
+     * The host on which the Fastify instance is to be started
+     * @default '127.0.0.1'
+     */
     host: string;
+    /**
+     * The port on which the Fastify instance is to be started
+     * @default 8080
+     */
     port: number;
+    /**
+     * The error handler to be used to handle errors thrown by the Fastify instance
+     * @default DefaultErrorHandler
+     */
     errorHandler: ErrorHandler;
+    /**
+     * The schema to be used to validate the response of the Fastify instance
+     * @default { '4xx': errorResponseSchema, '5xx': errorResponseSchema }
+     */
     responseSchema?: Record<string | number, JSONSchema>;
+    /**
+     * Enables internal execution of child routes (e.g., for SSR data fetching) without making actual HTTP requests.
+     * Useful for loading data while reusing middleware logic and shared context.
+     * @default false
+     */
     enableChildRoutes?: boolean;
+    /**
+     * Masks fields marked as sensitive in API inputs (body, query, and URL params) when written to logs.
+     * @default true
+     */
     maskSensitiveData?: boolean;
 }
 export interface FastifyModuleOptions extends Partial<FastifyConfig> {
+    /**
+     * The list of modules whose controllers are to be registered in the Fastify instance
+     */
     imports?: ModuleMetadata['imports'];
+    /**
+     * Factory function to modify the Fastify instance before it is used to register the controllers
+     */
     fastifyFactory?: (instance: FastifyInstance) => Promisable<FastifyInstance>;
+    /**
+     * The list of controllers to be registered in the Fastify instance
+     */
     controllers?: ModuleMetadata['controllers'];
+    /**
+     * The list of providers to be registered in the Fastify instance
+     */
     providers?: ModuleMetadata['providers'];
+    /**
+     * The list of providers to be exported by the Fastify module
+     */
     exports?: ModuleMetadata['exports'];
 }
 export interface FastifyModuleAsyncOptions extends Pick<FastifyModuleOptions, 'imports' | 'controllers' | 'providers' | 'exports' | 'fastifyFactory'> {
+    /**
+     * Factory function to create the FastifyModuleOptions
+     */
     useFactory: (...args: any[]) => Promisable<FastifyConfig>;
+    /**
+     * The list of providers to be injected into the factory function
+     */
     inject?: FactoryProvider['inject'];
 }