node-honest 0.0.7 → 0.1.0

package/dist/loggers/noop.logger.js

@@ -1,8 +0,0 @@
-/**
- * Logger implementation that intentionally does nothing.
- */
-export class NoopLogger {
-    emit(_event) {
-        // no-op
-    }
-}

package/dist/managers/component.manager.d.ts

@@ -1,48 +0,0 @@
-import type { Context, Next } from 'hono';
-import type { ArgumentMetadata, DiContainer, FilterType, GuardType, ILogger, IMetadataRepository, IGuard, IPipe, MiddlewareType, PipeType } from '../interfaces';
-import { type ComponentType, type ComponentTypeMap } from '../registries';
-import type { Constructor } from '../types';
-/**
- * Manager class for handling all component types in the Honest framework.
- *
- * Each Application instance owns a ComponentManager, which holds per-app
- * global components and a reference to the DI container. Controller-level
- * and handler-level components remain in MetadataRegistry (static, set at
- * class-definition time by decorators).
- */
-export declare class ComponentManager {
-    private readonly container;
-    private readonly metadataRepository;
-    private readonly logger;
-    private readonly globalComponents;
-    constructor(container: DiContainer, metadataRepository: IMetadataRepository, logger?: ILogger);
-    /**
-     * Configures global components from application options.
-     */
-    setupGlobalComponents(options: {
-        components?: {
-            middleware?: MiddlewareType[];
-            guards?: GuardType[];
-            pipes?: PipeType[];
-            filters?: FilterType[];
-        };
-    }): void;
-    registerGlobal<T extends ComponentType>(type: T, ...components: ComponentTypeMap[T][]): void;
-    getGlobal<T extends ComponentType>(type: T): Set<ComponentTypeMap[T]>;
-    /**
-     * Gets all components of a specific type for a handler.
-     * Merges: instance global → static controller → static handler.
-     */
-    getComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
-    resolveMiddleware(middlewareItems: MiddlewareType[]): ((c: Context, next: Next) => Promise<Response | void>)[];
-    getHandlerMiddleware(controller: Constructor, handlerName: string | symbol): ((c: Context, next: Next) => Promise<Response | void>)[];
-    getGlobalMiddleware(): ((c: Context, next: Next) => Promise<Response | void>)[];
-    resolveGuards(guardItems: GuardType[]): IGuard[];
-    getHandlerGuards(controller: Constructor, handlerName: string | symbol): IGuard[];
-    resolvePipes(pipeItems: PipeType[]): IPipe[];
-    getHandlerPipes(controller: Constructor, handlerName: string | symbol): IPipe[];
-    executePipes(value: unknown, metadata: ArgumentMetadata, pipes: ReadonlyArray<IPipe>): Promise<unknown>;
-    handleException(exception: unknown, context: Context): Promise<Response | undefined>;
-    private executeFilters;
-    registerModule(moduleClass: Constructor, registered?: Set<Constructor>): Promise<Constructor[]>;
-}

package/dist/managers/component.manager.js

@@ -1,209 +0,0 @@
-import { HONEST_PIPELINE_CONTROLLER_KEY, HONEST_PIPELINE_HANDLER_KEY } from '../constants';
-import { createErrorResponse } from '../helpers';
-import { NoopLogger } from '../loggers';
-import { isObject } from '../utils';
-/**
- * Manager class for handling all component types in the Honest framework.
- *
- * Each Application instance owns a ComponentManager, which holds per-app
- * global components and a reference to the DI container. Controller-level
- * and handler-level components remain in MetadataRegistry (static, set at
- * class-definition time by decorators).
- */
-export class ComponentManager {
-    container;
-    metadataRepository;
-    logger;
-    globalComponents = new Map([
-        ['middleware', new Set()],
-        ['guard', new Set()],
-        ['pipe', new Set()],
-        ['filter', new Set()]
-    ]);
-    constructor(container, metadataRepository, logger = new NoopLogger()) {
-        this.container = container;
-        this.metadataRepository = metadataRepository;
-        this.logger = logger;
-    }
-    /**
-     * Configures global components from application options.
-     */
-    setupGlobalComponents(options) {
-        const components = options.components || {};
-        if (components.middleware) {
-            this.registerGlobal('middleware', ...components.middleware);
-        }
-        if (components.guards) {
-            this.registerGlobal('guard', ...components.guards);
-        }
-        if (components.pipes) {
-            this.registerGlobal('pipe', ...components.pipes);
-        }
-        if (components.filters) {
-            this.registerGlobal('filter', ...components.filters);
-        }
-    }
-    registerGlobal(type, ...components) {
-        components.forEach((component) => {
-            this.globalComponents.get(type).add(component);
-        });
-    }
-    getGlobal(type) {
-        return this.globalComponents.get(type);
-    }
-    /**
-     * Gets all components of a specific type for a handler.
-     * Merges: instance global → static controller → static handler.
-     */
-    getComponents(type, controller, handlerName) {
-        const handlerComponents = this.metadataRepository.getHandlerComponents(type, controller, handlerName);
-        const controllerComponents = this.metadataRepository.getControllerComponents(type, controller);
-        const globalComponents = Array.from(this.globalComponents.get(type) || []);
-        return [...globalComponents, ...controllerComponents, ...handlerComponents];
-    }
-    // -- Middleware --
-    resolveMiddleware(middlewareItems) {
-        return middlewareItems.map((middlewareItem) => {
-            if (isObject(middlewareItem) && 'use' in middlewareItem) {
-                return middlewareItem.use.bind(middlewareItem);
-            }
-            const middleware = this.container.resolve(middlewareItem);
-            return middleware.use.bind(middleware);
-        });
-    }
-    getHandlerMiddleware(controller, handlerName) {
-        const controllerMiddleware = this.metadataRepository.getControllerComponents('middleware', controller);
-        const handlerMiddleware = this.metadataRepository.getHandlerComponents('middleware', controller, handlerName);
-        return this.resolveMiddleware([...controllerMiddleware, ...handlerMiddleware]);
-    }
-    getGlobalMiddleware() {
-        const globalMiddleware = Array.from(this.globalComponents.get('middleware') || []);
-        return this.resolveMiddleware(globalMiddleware);
-    }
-    // -- Guards --
-    resolveGuards(guardItems) {
-        return guardItems.map((guardItem) => {
-            if (isObject(guardItem) && 'canActivate' in guardItem) {
-                return guardItem;
-            }
-            return this.container.resolve(guardItem);
-        });
-    }
-    getHandlerGuards(controller, handlerName) {
-        const guardItems = this.getComponents('guard', controller, handlerName);
-        return this.resolveGuards(guardItems);
-    }
-    // -- Pipes --
-    resolvePipes(pipeItems) {
-        return pipeItems.map((pipeItem) => {
-            if (isObject(pipeItem) && 'transform' in pipeItem) {
-                return pipeItem;
-            }
-            return this.container.resolve(pipeItem);
-        });
-    }
-    getHandlerPipes(controller, handlerName) {
-        const pipeItems = this.getComponents('pipe', controller, handlerName);
-        return this.resolvePipes(pipeItems);
-    }
-    async executePipes(value, metadata, pipes) {
-        let transformedValue = value;
-        for (const pipe of pipes) {
-            transformedValue = await pipe.transform(transformedValue, metadata);
-        }
-        return transformedValue;
-    }
-    // -- Filters --
-    async handleException(exception, context) {
-        const normalizedException = exception instanceof Error ? exception : new Error(String(exception));
-        const controller = context.get(HONEST_PIPELINE_CONTROLLER_KEY);
-        const handlerName = context.get(HONEST_PIPELINE_HANDLER_KEY);
-        if (controller && handlerName) {
-            const handlerFilters = this.metadataRepository.getHandlerComponents('filter', controller, handlerName);
-            if (handlerFilters.length > 0) {
-                const response = await this.executeFilters(handlerFilters, normalizedException, context);
-                if (response)
-                    return response;
-            }
-        }
-        if (controller) {
-            const controllerFilters = this.metadataRepository.getControllerComponents('filter', controller);
-            if (controllerFilters.length > 0) {
-                const response = await this.executeFilters(controllerFilters, normalizedException, context);
-                if (response)
-                    return response;
-            }
-        }
-        const globalFilters = Array.from(this.globalComponents.get('filter') || []);
-        if (globalFilters.length > 0) {
-            const response = await this.executeFilters(globalFilters, normalizedException, context);
-            if (response)
-                return response;
-        }
-        const { response, status } = createErrorResponse(normalizedException, context);
-        return context.json(response, status);
-    }
-    async executeFilters(filterItems, exception, context) {
-        for (const filterItem of filterItems) {
-            let filter;
-            if (isObject(filterItem) && 'catch' in filterItem) {
-                filter = filterItem;
-            }
-            else {
-                filter = this.container.resolve(filterItem);
-            }
-            try {
-                const result = await filter.catch(exception, context);
-                if (result !== undefined) {
-                    return result;
-                }
-            }
-            catch (filterError) {
-                const filterName = filter.constructor?.name || 'UnknownFilter';
-                this.logger.emit({
-                    level: 'error',
-                    category: 'errors',
-                    message: `Error in exception filter ${filterName}`,
-                    details: {
-                        error: filterError instanceof Error ? filterError.message : String(filterError)
-                    }
-                });
-                const { response, status } = createErrorResponse(filterError, context);
-                return context.json(response, status);
-            }
-        }
-        return undefined;
-    }
-    // -- Module registration --
-    async registerModule(moduleClass, registered = new Set()) {
-        if (registered.has(moduleClass)) {
-            return [];
-        }
-        registered.add(moduleClass);
-        const moduleOptions = this.metadataRepository.getModuleOptions(moduleClass);
-        if (!moduleOptions) {
-            this.logger.emit({
-                level: 'error',
-                category: 'startup',
-                message: `Module ${moduleClass.name} is not properly decorated with @Module()`
-            });
-            throw new Error(`Module ${moduleClass.name} is not properly decorated with @Module()`);
-        }
-        const controllers = [];
-        if (moduleOptions.imports && moduleOptions.imports.length > 0) {
-            for (const importedModule of moduleOptions.imports) {
-                const importedControllers = await this.registerModule(importedModule, registered);
-                controllers.push(...importedControllers);
-            }
-        }
-        if (moduleOptions.services && moduleOptions.services.length > 0) {
-            for (const serviceClass of moduleOptions.services) {
-                this.container.resolve(serviceClass);
-            }
-        }
-        if (moduleOptions.controllers && moduleOptions.controllers.length > 0) {
-            controllers.push(...moduleOptions.controllers);
-        }
-        return controllers;
-    }
-}

package/dist/managers/handler.invoker.d.ts

@@ -1,7 +0,0 @@
-import type { HandlerInvocationInput } from '../interfaces';
-/**
- * Invokes route handlers and maps non-Response results to Hono responses.
- */
-export declare class HandlerInvoker {
-    invoke({ handler, args, context, contextIndex }: HandlerInvocationInput): Promise<unknown>;
-}

package/dist/managers/handler.invoker.js

@@ -1,37 +0,0 @@
-import { FrameworkError } from '../errors';
-import { isNil, isString } from '../utils';
-/**
- * Invokes route handlers and maps non-Response results to Hono responses.
- */
-export class HandlerInvoker {
-    async invoke({ handler, args, context, contextIndex }) {
-        const result = await handler(...args);
-        if (contextIndex !== undefined) {
-            return result;
-        }
-        if (result instanceof Response) {
-            return result;
-        }
-        if (isNil(result)) {
-            return context.json(null);
-        }
-        if (isString(result)) {
-            return context.text(result);
-        }
-        try {
-            return context.json(result);
-        }
-        catch (error) {
-            throw new FrameworkError('Handler return value could not be serialized as JSON.', {
-                status: 500,
-                code: 'RESPONSE_SERIALIZATION_FAILED',
-                category: 'pipeline',
-                remediation: 'Return JSON-serializable values from handlers or map custom values in a filter before returning.',
-                details: {
-                    handlerResultType: typeof result
-                },
-                cause: error
-            });
-        }
-    }
-}

package/dist/managers/index.d.ts

@@ -1,5 +0,0 @@
-export * from './component.manager';
-export * from './handler.invoker';
-export * from './parameter.resolver';
-export * from './pipeline.executor';
-export * from './route.manager';

package/dist/managers/index.js

@@ -1,5 +0,0 @@
-export * from './component.manager';
-export * from './handler.invoker';
-export * from './parameter.resolver';
-export * from './pipeline.executor';
-export * from './route.manager';

package/dist/managers/parameter.resolver.d.ts

@@ -1,13 +0,0 @@
-import type { ParameterResolutionInput } from '../interfaces';
-import type { ILogger } from '../interfaces';
-import { ComponentManager } from './component.manager';
-/**
- * Resolves route handler arguments from parameter decorator metadata.
- */
-export declare class ParameterResolver {
-    private readonly componentManager;
-    private readonly logger;
-    private readonly debugPipeline;
-    constructor(componentManager: ComponentManager, logger?: ILogger, debugPipeline?: boolean);
-    resolveArguments(input: ParameterResolutionInput): Promise<unknown[]>;
-}

package/dist/managers/parameter.resolver.js

@@ -1,57 +0,0 @@
-import { NoopLogger } from '../loggers';
-/**
- * Resolves route handler arguments from parameter decorator metadata.
- */
-export class ParameterResolver {
-    componentManager;
-    logger;
-    debugPipeline;
-    constructor(componentManager, logger = new NoopLogger(), debugPipeline = false) {
-        this.componentManager = componentManager;
-        this.logger = logger;
-        this.debugPipeline = debugPipeline;
-    }
-    async resolveArguments(input) {
-        const { controllerName, handlerName, handlerArity, handlerParams, handlerPipes, context } = input;
-        const maxDecoratorIndex = handlerParams.length > 0 ? Math.max(...handlerParams.map((parameter) => parameter.index)) : -1;
-        const args = new Array(Math.max(handlerArity, maxDecoratorIndex + 1));
-        const decoratedIndices = new Set(handlerParams.map((parameter) => parameter.index));
-        if (this.debugPipeline && maxDecoratorIndex >= 0) {
-            const sparseIndices = [];
-            for (let i = 0; i <= maxDecoratorIndex; i++) {
-                if (!decoratedIndices.has(i)) {
-                    sparseIndices.push(i);
-                }
-            }
-            const hasOutOfRangeDecoratorIndex = maxDecoratorIndex >= handlerArity;
-            if (sparseIndices.length > 0 || hasOutOfRangeDecoratorIndex) {
-                this.logger.emit({
-                    level: 'warn',
-                    category: 'pipeline',
-                    message: `Potential parameter binding mismatch at ${controllerName}.${String(handlerName)}`,
-                    details: {
-                        handlerArity,
-                        maxDecoratorIndex,
-                        sparseIndices,
-                        handlerParamCount: handlerParams.length
-                    }
-                });
-            }
-        }
-        for (const parameter of handlerParams) {
-            if (typeof parameter.factory !== 'function') {
-                throw new Error(`Invalid parameter decorator metadata for ${controllerName}.${String(handlerName)}`);
-            }
-            const rawValue = await parameter.factory(parameter.data, context);
-            const transformedValue = await this.componentManager.executePipes(rawValue, {
-                type: parameter.name,
-                metatype: parameter.metatype,
-                data: typeof parameter.data === 'string' || typeof parameter.data === 'undefined'
-                    ? parameter.data
-                    : String(parameter.data)
-            }, handlerPipes);
-            args[parameter.index] = transformedValue;
-        }
-        return args;
-    }
-}

package/dist/managers/pipeline.executor.d.ts

@@ -1,28 +0,0 @@
-import type { Context } from 'hono';
-import type { ILogger, ParameterMetadata } from '../interfaces';
-import type { IPipe } from '../interfaces';
-import { ComponentManager } from './component.manager';
-import { HandlerInvoker } from './handler.invoker';
-import { ParameterResolver } from './parameter.resolver';
-import type { Constructor } from '../types';
-export interface PipelineExecutionInput {
-    controllerClass: Constructor;
-    handlerName: string | symbol;
-    handler: (...args: unknown[]) => Promise<unknown> | unknown;
-    handlerParams: ReadonlyArray<ParameterMetadata>;
-    handlerPipes: ReadonlyArray<IPipe>;
-    contextIndex?: number;
-    context: Context;
-}
-/**
- * Executes guard, parameter-resolution, and handler invocation stages.
- */
-export declare class PipelineExecutor {
-    private readonly componentManager;
-    private readonly parameterResolver;
-    private readonly handlerInvoker;
-    private readonly logger;
-    private readonly debugPipeline;
-    constructor(componentManager: ComponentManager, parameterResolver: ParameterResolver, handlerInvoker: HandlerInvoker, logger?: ILogger, debugPipeline?: boolean);
-    execute(input: PipelineExecutionInput): Promise<unknown>;
-}

package/dist/managers/pipeline.executor.js

@@ -1,68 +0,0 @@
-import { HTTPException } from 'hono/http-exception';
-import { HONEST_PIPELINE_CONTROLLER_KEY, HONEST_PIPELINE_HANDLER_KEY } from '../constants';
-import { NoopLogger } from '../loggers';
-/**
- * Executes guard, parameter-resolution, and handler invocation stages.
- */
-export class PipelineExecutor {
-    componentManager;
-    parameterResolver;
-    handlerInvoker;
-    logger;
-    debugPipeline;
-    constructor(componentManager, parameterResolver, handlerInvoker, logger = new NoopLogger(), debugPipeline = false) {
-        this.componentManager = componentManager;
-        this.parameterResolver = parameterResolver;
-        this.handlerInvoker = handlerInvoker;
-        this.logger = logger;
-        this.debugPipeline = debugPipeline;
-    }
-    async execute(input) {
-        const { controllerClass, handlerName, handler, handlerParams, handlerPipes, contextIndex, context } = input;
-        context.set(HONEST_PIPELINE_CONTROLLER_KEY, controllerClass);
-        context.set(HONEST_PIPELINE_HANDLER_KEY, String(handlerName));
-        const guards = this.componentManager.getHandlerGuards(controllerClass, handlerName);
-        for (const guard of guards) {
-            const canActivate = await guard.canActivate(context);
-            if (!canActivate) {
-                if (this.debugPipeline) {
-                    this.logger.emit({
-                        level: 'warn',
-                        category: 'pipeline',
-                        message: `Guard rejected request at ${controllerClass.name}.${String(handlerName)}`,
-                        details: { guard: guard.constructor?.name || 'UnknownGuard' }
-                    });
-                }
-                throw new HTTPException(403, {
-                    message: `Forbidden by ${guard.constructor?.name || 'UnknownGuard'} at ${controllerClass.name}.${String(handlerName)}`
-                });
-            }
-        }
-        const args = await this.parameterResolver.resolveArguments({
-            controllerName: controllerClass.name,
-            handlerName,
-            handlerArity: handler.length,
-            handlerParams,
-            handlerPipes,
-            context
-        });
-        if (this.debugPipeline) {
-            this.logger.emit({
-                level: 'debug',
-                category: 'pipeline',
-                message: `Resolved handler arguments for ${controllerClass.name}.${String(handlerName)}`,
-                details: {
-                    guardCount: guards.length,
-                    parameterCount: handlerParams.length,
-                    pipeCount: handlerPipes.length
-                }
-            });
-        }
-        return this.handlerInvoker.invoke({
-            handler,
-            args,
-            context,
-            contextIndex
-        });
-    }
-}

package/dist/managers/route.manager.d.ts

@@ -1,36 +0,0 @@
-import type { Hono } from 'hono';
-import { VERSION_NEUTRAL } from '../constants';
-import type { DiContainer, ILogger, IMetadataRepository } from '../interfaces';
-import { ComponentManager } from './component.manager';
-import { RouteRegistry } from '../registries/route.registry';
-import type { Constructor } from '../types';
-/**
- * Manager class for handling route registration in the Honest framework.
- *
- * Receives all per-app dependencies (Hono, Container, RouteRegistry,
- * ComponentManager) via constructor — no static state.
- */
-export declare class RouteManager {
-    private hono;
-    private container;
-    private routeRegistry;
-    private componentManager;
-    private parameterResolver;
-    private pipelineExecutor;
-    private metadataRepository;
-    private logger;
-    private globalPrefix?;
-    private globalVersion?;
-    constructor(hono: Hono, container: DiContainer, routeRegistry: RouteRegistry, componentManager: ComponentManager, metadataRepository: IMetadataRepository, logger?: ILogger, options?: {
-        prefix?: string;
-        version?: number | typeof VERSION_NEUTRAL | number[];
-        debugPipeline?: boolean;
-    });
-    private applyGlobalMiddleware;
-    private normalizePath;
-    private registerRouteHandler;
-    private buildRoutePath;
-    private formatVersionSegment;
-    registerController(controllerClass: Constructor): Promise<void>;
-    private registerRoute;
-}