node-honest 0.0.1 → 0.1.0

package/dist/registries/metadata.repository.js

@@ -1,151 +0,0 @@
-import { MetadataRegistry } from './metadata.registry';
-/**
- * Immutable metadata repository for a single Application instance.
- * Captures a deep copy of all metadata reachable from a root module at creation time,
- * isolating the application from later mutations to the static MetadataRegistry.
- */
-export class MetadataRepository {
-    controllerPaths = new Map();
-    controllerOptions = new Map();
-    routes = new Map();
-    parameters = new Map();
-    contextIndices = new Map();
-    modules = new Map();
-    controllerComponents = new Map([
-        ['middleware', new Map()],
-        ['guard', new Map()],
-        ['pipe', new Map()],
-        ['filter', new Map()]
-    ]);
-    handlerComponents = new Map([
-        ['middleware', new Map()],
-        ['guard', new Map()],
-        ['pipe', new Map()],
-        ['filter', new Map()]
-    ]);
-    static fromRootModule(rootModule) {
-        const snapshot = new MetadataRepository();
-        snapshot.captureModuleGraph(rootModule);
-        return snapshot;
-    }
-    hasController(controller) {
-        return this.controllerPaths.has(controller);
-    }
-    getControllerPath(controller) {
-        return this.controllerPaths.get(controller) || '';
-    }
-    getControllerOptions(controller) {
-        const options = this.controllerOptions.get(controller);
-        return options ? { ...options } : {};
-    }
-    getRoutes(controller) {
-        return (this.routes.get(controller) || []).map((route) => this.cloneRouteDefinition(route));
-    }
-    getParameters(controller) {
-        const parameters = this.parameters.get(controller);
-        if (!parameters) {
-            return new Map();
-        }
-        const cloned = new Map();
-        for (const [handlerName, entries] of parameters.entries()) {
-            cloned.set(handlerName, entries.map((entry) => ({ ...entry })));
-        }
-        return cloned;
-    }
-    getContextIndices(controller) {
-        return new Map(this.contextIndices.get(controller) || new Map());
-    }
-    getModuleOptions(module) {
-        const options = this.modules.get(module);
-        if (!options) {
-            return undefined;
-        }
-        return {
-            controllers: options.controllers ? [...options.controllers] : undefined,
-            services: options.services ? [...options.services] : undefined,
-            imports: options.imports ? [...options.imports] : undefined
-        };
-    }
-    getControllerComponents(type, controller) {
-        const map = this.controllerComponents.get(type);
-        const components = (map.get(controller) || []);
-        return [...components];
-    }
-    getHandlerComponents(type, controller, handlerName) {
-        const typeMap = this.handlerComponents.get(type);
-        const controllerMap = typeMap.get(controller);
-        if (!controllerMap) {
-            return [];
-        }
-        const components = (controllerMap.get(handlerName) || []);
-        return [...components];
-    }
-    captureModuleGraph(rootModule) {
-        const visitedModules = new Set();
-        const controllers = new Set();
-        const visitModule = (moduleClass) => {
-            if (visitedModules.has(moduleClass)) {
-                return;
-            }
-            visitedModules.add(moduleClass);
-            const moduleOptions = MetadataRegistry.getModuleOptions(moduleClass);
-            if (!moduleOptions) {
-                return;
-            }
-            const moduleSnapshot = {
-                controllers: moduleOptions.controllers ? [...moduleOptions.controllers] : undefined,
-                services: moduleOptions.services ? [...moduleOptions.services] : undefined,
-                imports: moduleOptions.imports ? [...moduleOptions.imports] : undefined
-            };
-            this.modules.set(moduleClass, moduleSnapshot);
-            for (const controller of moduleSnapshot.controllers || []) {
-                controllers.add(controller);
-            }
-            for (const importedModule of moduleSnapshot.imports || []) {
-                visitModule(importedModule);
-            }
-        };
-        visitModule(rootModule);
-        for (const controller of controllers) {
-            this.captureController(controller);
-        }
-    }
-    captureController(controller) {
-        if (!MetadataRegistry.hasController(controller)) {
-            return;
-        }
-        this.controllerPaths.set(controller, MetadataRegistry.getControllerPath(controller) || '');
-        this.controllerOptions.set(controller, { ...MetadataRegistry.getControllerOptions(controller) });
-        const routes = (MetadataRegistry.getRoutes(controller) || []).map((route) => this.cloneRouteDefinition(route));
-        this.routes.set(controller, routes);
-        const parameters = MetadataRegistry.getParameters(controller);
-        const parameterSnapshot = new Map();
-        for (const [handlerName, entries] of parameters.entries()) {
-            parameterSnapshot.set(handlerName, (entries || []).map((entry) => ({ ...entry })));
-        }
-        this.parameters.set(controller, parameterSnapshot);
-        this.contextIndices.set(controller, new Map(MetadataRegistry.getContextIndices(controller) || new Map()));
-        for (const type of ['middleware', 'guard', 'pipe', 'filter']) {
-            const controllerMap = this.controllerComponents.get(type);
-            controllerMap.set(controller, [...(MetadataRegistry.getController(type, controller) || [])]);
-        }
-        for (const route of routes) {
-            for (const type of ['middleware', 'guard', 'pipe', 'filter']) {
-                const typeMap = this.handlerComponents.get(type);
-                if (!typeMap.has(controller)) {
-                    typeMap.set(controller, new Map());
-                }
-                const controllerHandlers = typeMap.get(controller);
-                controllerHandlers.set(route.handlerName, [
-                    ...MetadataRegistry.getHandler(type, controller, route.handlerName)
-                ]);
-            }
-        }
-    }
-    cloneRouteDefinition(route) {
-        return {
-            ...route,
-            version: Array.isArray(route.version) ? [...route.version] : route.version
-        };
-    }
-}

package/dist/registries/route.registry.d.ts

@@ -1,16 +0,0 @@
-import type { RouteInfo } from '../interfaces';
-/**
- * Registry for managing and querying route information in the application.
- *
- * Each Application instance owns its own RouteRegistry, ensuring routes
- * from one app never leak into another.
- */
-export declare class RouteRegistry {
-    private readonly routes;
-    registerRoute(routeInfo: RouteInfo): void;
-    getRoutes(): ReadonlyArray<RouteInfo>;
-    getRoutesByController(controllerName: string | symbol): ReadonlyArray<RouteInfo>;
-    getRoutesByMethod(method: string): ReadonlyArray<RouteInfo>;
-    getRoutesByPath(pattern: RegExp): ReadonlyArray<RouteInfo>;
-    clear(): void;
-}

package/dist/registries/route.registry.js

@@ -1,46 +0,0 @@
-/**
- * Registry for managing and querying route information in the application.
- *
- * Each Application instance owns its own RouteRegistry, ensuring routes
- * from one app never leak into another.
- */
-export class RouteRegistry {
-    routes = [];
-    registerRoute(routeInfo) {
-        if (!routeInfo) {
-            throw new Error('Route info is required');
-        }
-        if (!routeInfo.controller) {
-            throw new Error('Route controller is required');
-        }
-        if (!routeInfo.handler) {
-            throw new Error('Route handler is required');
-        }
-        if (!routeInfo.method) {
-            throw new Error('Route method is required');
-        }
-        if (!routeInfo.fullPath) {
-            throw new Error('Route fullPath is required');
-        }
-        const isDuplicate = this.routes.some((route) => route.fullPath === routeInfo.fullPath && route.method.toUpperCase() === routeInfo.method.toUpperCase());
-        if (isDuplicate) {
-            throw new Error(`Duplicate route detected: ${routeInfo.method.toUpperCase()} ${routeInfo.fullPath} (${String(routeInfo.controller)}.${String(routeInfo.handler)})`);
-        }
-        this.routes.push(routeInfo);
-    }
-    getRoutes() {
-        return this.routes;
-    }
-    getRoutesByController(controllerName) {
-        return this.routes.filter((route) => route.controller === controllerName);
-    }
-    getRoutesByMethod(method) {
-        return this.routes.filter((route) => route.method.toUpperCase() === method.toUpperCase());
-    }
-    getRoutesByPath(pattern) {
-        return this.routes.filter((route) => pattern.test(route.fullPath));
-    }
-    clear() {
-        this.routes.length = 0;
-    }
-}

package/dist/registries/service.registry.d.ts

@@ -1,8 +0,0 @@
-import type { IServiceRegistry } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Adapter exposing service checks through the DI service registry contract.
- */
-export declare class StaticServiceRegistry implements IServiceRegistry {
-    isService(service: Constructor): boolean;
-}

package/dist/registries/service.registry.js

@@ -1,9 +0,0 @@
-import { MetadataRegistry } from './metadata.registry';
-/**
- * Adapter exposing service checks through the DI service registry contract.
- */
-export class StaticServiceRegistry {
-    isService(service) {
-        return MetadataRegistry.isService(service);
-    }
-}

package/dist/testing/create-controller-test-application.d.ts

@@ -1,5 +0,0 @@
-import type { CreateControllerTestApplicationOptions, TestApplication } from './testing.interface';
-/**
- * Create a test application for a single controller with optional services/imports.
- */
-export declare function createControllerTestApplication(options: CreateControllerTestApplicationOptions): Promise<TestApplication>;

package/dist/testing/create-controller-test-application.js

@@ -1,11 +0,0 @@
-import { createTestApplication } from './create-test-application';
-/**
- * Create a test application for a single controller with optional services/imports.
- */
-export async function createControllerTestApplication(options) {
-    const { controller, ...rest } = options;
-    return createTestApplication({
-        ...rest,
-        controllers: [controller]
-    });
-}

package/dist/testing/create-service-test-container.d.ts

@@ -1,5 +0,0 @@
-import type { CreateServiceTestContainerOptions, TestServiceContainer } from './testing.interface';
-/**
- * Create a lightweight DI container for service-only tests without HTTP bootstrap.
- */
-export declare function createServiceTestContainer(options?: CreateServiceTestContainerOptions): TestServiceContainer;

package/dist/testing/create-service-test-container.js

@@ -1,31 +0,0 @@
-import { NoopLogger } from '../loggers';
-import { Container } from '../di';
-/**
- * Create a lightweight DI container for service-only tests without HTTP bootstrap.
- */
-export function createServiceTestContainer(options = {}) {
-    const logger = options.logger ?? new NoopLogger();
-    const container = new Container(undefined, logger, Boolean(options.debugDi));
-    for (const override of options.overrides ?? []) {
-        const typedOverride = override;
-        container.register(typedOverride.provide, typedOverride.useValue);
-    }
-    for (const service of options.preload ?? []) {
-        container.resolve(service);
-    }
-    return {
-        container,
-        get(target) {
-            return container.resolve(target);
-        },
-        register(target, instance) {
-            container.register(target, instance);
-        },
-        has(target) {
-            return container.has(target);
-        },
-        clear() {
-            container.clear();
-        }
-    };
-}

package/dist/testing/create-test-application.d.ts

@@ -1,5 +0,0 @@
-import type { CreateTestApplicationOptions, TestApplication } from './testing.interface';
-/**
- * Create a test-friendly application instance with a convenience request helper.
- */
-export declare function createTestApplication(options?: CreateTestApplicationOptions): Promise<TestApplication>;

package/dist/testing/create-test-application.js

@@ -1,20 +0,0 @@
-import { Application } from '../application';
-import { createTestingModule } from './create-testing-module';
-/**
- * Create a test-friendly application instance with a convenience request helper.
- */
-export async function createTestApplication(options = {}) {
-    const { module, appOptions, ...moduleOptions } = options;
-    const rootModule = (module ?? createTestingModule(moduleOptions));
-    const { app, hono } = await Application.create(rootModule, appOptions);
-    const request = (input, init) => {
-        if (typeof input === 'string') {
-            const normalizedInput = input.startsWith('http://') || input.startsWith('https://')
-                ? input
-                : `http://localhost${input.startsWith('/') ? input : `/${input}`}`;
-            return Promise.resolve(hono.request(normalizedInput, init));
-        }
-        return Promise.resolve(hono.request(input));
-    };
-    return { app, hono, request };
-}

package/dist/testing/create-testing-module.d.ts

@@ -1,6 +0,0 @@
-import type { Constructor } from '../types';
-import type { TestModuleOptions } from './testing.interface';
-/**
- * Create a runtime module class for tests without boilerplate.
- */
-export declare function createTestingModule(options?: TestModuleOptions): Constructor;

package/dist/testing/create-testing-module.js

@@ -1,13 +0,0 @@
-import { Module } from '../decorators';
-/**
- * Create a runtime module class for tests without boilerplate.
- */
-export function createTestingModule(options = {}) {
-    const { controllers, services, imports, name = 'TestModule' } = options;
-    const dynamicModule = {
-        [name]: class {
-        }
-    }[name];
-    Module({ controllers, services, imports })(dynamicModule);
-    return dynamicModule;
-}

package/dist/testing/fixtures/application-test-fixtures.d.ts

@@ -1,17 +0,0 @@
-import type { Constructor } from '../../types';
-export declare function createTestController(): Constructor;
-export declare function createPayloadController(): Constructor;
-export declare function createRawResponseController(): Constructor;
-export declare function createOnlyAController(): Constructor;
-export declare function createOnlyBController(): Constructor;
-export declare function createUndecoratedController(): Constructor;
-export declare function createBrokenControllerModule(): Constructor;
-export declare function createEmptyModule(): Constructor;
-export declare function createDuplicateRouteControllers(): {
-    a: Constructor;
-    b: Constructor;
-};
-export declare function createUnsafeParamController(): Constructor;
-export declare function createDiagnosticsAController(): Constructor;
-export declare function createDiagnosticsBController(): Constructor;
-export declare function createRuntimeMetadataController(): Constructor;

package/dist/testing/fixtures/application-test-fixtures.js

@@ -1,230 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Body, Controller, Get, Module, Post } from '../../decorators';
-import { createParamDecorator } from '../../helpers';
-export function createTestController() {
-    let TestController = class TestController {
-        index() {
-            return { ok: true };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], TestController.prototype, "index", null);
-    TestController = __decorate([
-        Controller('/health')
-    ], TestController);
-    return TestController;
-}
-export function createPayloadController() {
-    let PayloadController = class PayloadController {
-        async echo(a, b) {
-            return { a, b };
-        }
-    };
-    __decorate([
-        Post('echo'),
-        __param(0, Body('a')),
-        __param(1, Body('b')),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String, String]),
-        __metadata("design:returntype", Promise)
-    ], PayloadController.prototype, "echo", null);
-    PayloadController = __decorate([
-        Controller('/payload')
-    ], PayloadController);
-    return PayloadController;
-}
-export function createRawResponseController() {
-    let RawResponseController = class RawResponseController {
-        raw() {
-            return new Response('raw-ok', {
-                status: 201,
-                headers: { 'x-honest': 'yes' }
-            });
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], RawResponseController.prototype, "raw", null);
-    RawResponseController = __decorate([
-        Controller('/raw')
-    ], RawResponseController);
-    return RawResponseController;
-}
-export function createOnlyAController() {
-    let OnlyAController = class OnlyAController {
-        index() {
-            return { app: 'a' };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], OnlyAController.prototype, "index", null);
-    OnlyAController = __decorate([
-        Controller('/only-a')
-    ], OnlyAController);
-    return OnlyAController;
-}
-export function createOnlyBController() {
-    let OnlyBController = class OnlyBController {
-        index() {
-            return { app: 'b' };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], OnlyBController.prototype, "index", null);
-    OnlyBController = __decorate([
-        Controller('/only-b')
-    ], OnlyBController);
-    return OnlyBController;
-}
-export function createUndecoratedController() {
-    class UndecoratedController {
-        hello() {
-            return 'hello';
-        }
-    }
-    return UndecoratedController;
-}
-export function createBrokenControllerModule() {
-    const UndecoratedController = createUndecoratedController();
-    let BrokenControllerModule = class BrokenControllerModule {
-    };
-    BrokenControllerModule = __decorate([
-        Module({ controllers: [UndecoratedController] })
-    ], BrokenControllerModule);
-    return BrokenControllerModule;
-}
-export function createEmptyModule() {
-    let EmptyModule = class EmptyModule {
-    };
-    EmptyModule = __decorate([
-        Module()
-    ], EmptyModule);
-    return EmptyModule;
-}
-export function createDuplicateRouteControllers() {
-    let DuplicateAController = class DuplicateAController {
-        index() {
-            return { ok: 'a' };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], DuplicateAController.prototype, "index", null);
-    DuplicateAController = __decorate([
-        Controller('/dup')
-    ], DuplicateAController);
-    let DuplicateBController = class DuplicateBController {
-        index() {
-            return { ok: 'b' };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], DuplicateBController.prototype, "index", null);
-    DuplicateBController = __decorate([
-        Controller('/dup')
-    ], DuplicateBController);
-    return { a: DuplicateAController, b: DuplicateBController };
-}
-export function createUnsafeParamController() {
-    const unsafeParam = createParamDecorator('unsafe');
-    let UnsafeParamController = class UnsafeParamController {
-        check(value) {
-            return { hasValue: value !== undefined };
-        }
-    };
-    __decorate([
-        Get(),
-        __param(0, unsafeParam()),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", void 0)
-    ], UnsafeParamController.prototype, "check", null);
-    UnsafeParamController = __decorate([
-        Controller('/unsafe')
-    ], UnsafeParamController);
-    return UnsafeParamController;
-}
-export function createDiagnosticsAController() {
-    let DiagnosticsAController = class DiagnosticsAController {
-        index() {
-            return { controller: 'a' };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], DiagnosticsAController.prototype, "index", null);
-    DiagnosticsAController = __decorate([
-        Controller('/diag-a')
-    ], DiagnosticsAController);
-    return DiagnosticsAController;
-}
-export function createDiagnosticsBController() {
-    let DiagnosticsBController = class DiagnosticsBController {
-        index() {
-            return { controller: 'b' };
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], DiagnosticsBController.prototype, "index", null);
-    DiagnosticsBController = __decorate([
-        Controller('/diag-b')
-    ], DiagnosticsBController);
-    return DiagnosticsBController;
-}
-export function createRuntimeMetadataController() {
-    let RuntimeMetadataController = class RuntimeMetadataController {
-        index() {
-            throw new Error('runtime metadata baseline error');
-        }
-    };
-    __decorate([
-        Get(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], RuntimeMetadataController.prototype, "index", null);
-    RuntimeMetadataController = __decorate([
-        Controller('/runtime-metadata')
-    ], RuntimeMetadataController);
-    return RuntimeMetadataController;
-}

package/dist/testing/index.d.ts

@@ -1,5 +0,0 @@
-export * from './create-test-application';
-export * from './create-controller-test-application';
-export * from './create-service-test-container';
-export * from './create-testing-module';
-export * from './testing.interface';

package/dist/testing/index.js

@@ -1,5 +0,0 @@
-export * from './create-test-application';
-export * from './create-controller-test-application';
-export * from './create-service-test-container';
-export * from './create-testing-module';
-export * from './testing.interface';