node-honest 0.0.7 → 0.1.0

package/dist/decorators/http-method.decorator.d.ts

@@ -1,43 +0,0 @@
-/**
- * GET method decorator
- * The GET method requests a representation of the specified resource.
- * Requests using GET should only retrieve data and should not contain a request content.
- * @param path - The route path
- */
-export declare const Get: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * POST method decorator
- * The POST method submits an entity to the specified resource,
- * often causing a change in state or side effects on the server.
- * @param path - The route path
- */
-export declare const Post: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * PUT method decorator
- * The PUT method replaces all current representations of the target resource with the request content.
- * @param path - The route path
- */
-export declare const Put: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * DELETE method decorator
- * The DELETE method deletes the specified resource.
- * @param path - The route path
- */
-export declare const Delete: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * PATCH method decorator
- * The PATCH method applies partial modifications to a resource.
- * @param path - The route path
- */
-export declare const Patch: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * OPTIONS method decorator
- * The OPTIONS method describes the communication options for the target resource.
- * @param path - The route path
- */
-export declare const Options: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * ALL method decorator (matches all HTTP methods)
- * @param path - The route path
- */
-export declare const All: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;

package/dist/decorators/http-method.decorator.js

@@ -1,44 +0,0 @@
-import { createHttpMethodDecorator } from '../helpers';
-/**
- * GET method decorator
- * The GET method requests a representation of the specified resource.
- * Requests using GET should only retrieve data and should not contain a request content.
- * @param path - The route path
- */
-export const Get = createHttpMethodDecorator('get');
-/**
- * POST method decorator
- * The POST method submits an entity to the specified resource,
- * often causing a change in state or side effects on the server.
- * @param path - The route path
- */
-export const Post = createHttpMethodDecorator('post');
-/**
- * PUT method decorator
- * The PUT method replaces all current representations of the target resource with the request content.
- * @param path - The route path
- */
-export const Put = createHttpMethodDecorator('put');
-/**
- * DELETE method decorator
- * The DELETE method deletes the specified resource.
- * @param path - The route path
- */
-export const Delete = createHttpMethodDecorator('delete');
-/**
- * PATCH method decorator
- * The PATCH method applies partial modifications to a resource.
- * @param path - The route path
- */
-export const Patch = createHttpMethodDecorator('patch');
-/**
- * OPTIONS method decorator
- * The OPTIONS method describes the communication options for the target resource.
- * @param path - The route path
- */
-export const Options = createHttpMethodDecorator('options');
-/**
- * ALL method decorator (matches all HTTP methods)
- * @param path - The route path
- */
-export const All = createHttpMethodDecorator('all');

package/dist/decorators/index.d.ts

@@ -1,11 +0,0 @@
-export * from './controller.decorator';
-export * from './http-method.decorator';
-export * from './module.decorator';
-export * from './mvc.decorator';
-export * from './parameter.decorator';
-export * from './service.decorator';
-export * from './use-component.decorator';
-export * from './use-filters.decorator';
-export * from './use-guards.decorator';
-export * from './use-middleware.decorator';
-export * from './use-pipes.decorator';

package/dist/decorators/index.js

@@ -1,11 +0,0 @@
-export * from './controller.decorator';
-export * from './http-method.decorator';
-export * from './module.decorator';
-export * from './mvc.decorator';
-export * from './parameter.decorator';
-export * from './service.decorator';
-export * from './use-component.decorator';
-export * from './use-filters.decorator';
-export * from './use-guards.decorator';
-export * from './use-middleware.decorator';
-export * from './use-pipes.decorator';

package/dist/decorators/module.decorator.d.ts

@@ -1,8 +0,0 @@
-import type { ModuleOptions } from '../interfaces';
-/**
- * Decorator that marks a class as a module
- * Modules are used to organize the application structure and dependencies
- * @param options - Configuration options for the module
- * @returns A class decorator function
- */
-export declare function Module(options?: ModuleOptions): ClassDecorator;

package/dist/decorators/module.decorator.js

@@ -1,12 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Decorator that marks a class as a module
- * Modules are used to organize the application structure and dependencies
- * @param options - Configuration options for the module
- * @returns A class decorator function
- */
-export function Module(options = {}) {
-    return (target) => {
-        MetadataRegistry.setModuleOptions(target, options);
-    };
-}

package/dist/decorators/mvc.decorator.d.ts

@@ -1,26 +0,0 @@
-import type { ControllerOptions, ModuleOptions } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Decorator that marks a class as a controller
- * Controllers are responsible for handling incoming requests and returning responses
- * @param route - The base route for all endpoints in this controller
- * @param options - Configuration options for the controller
- * @returns A class decorator function
- */
-export declare function View(route?: string, options?: ControllerOptions): ClassDecorator;
-/**
- * GET method decorator
- * The GET method requests a representation of the specified resource.
- * Requests using GET should only retrieve data and should not contain a request content.
- * @param path - The route path
- */
-export declare const Page: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
-/**
- * Decorator that marks a class as a module
- * Modules are used to organize the application structure and dependencies
- * @param options - Configuration options for the module
- * @returns A class decorator function
- */
-export declare function MvcModule(options?: ModuleOptions & {
-    views?: Constructor[];
-}): ClassDecorator;

package/dist/decorators/mvc.decorator.js

@@ -1,36 +0,0 @@
-import { Controller } from './controller.decorator';
-import { Get } from './http-method.decorator';
-import { Module } from './module.decorator';
-/**
- * Decorator that marks a class as a controller
- * Controllers are responsible for handling incoming requests and returning responses
- * @param route - The base route for all endpoints in this controller
- * @param options - Configuration options for the controller
- * @returns A class decorator function
- */
-export function View(route = '', options = {
-    prefix: null,
-    version: null
-}) {
-    return Controller(route, options);
-}
-/**
- * GET method decorator
- * The GET method requests a representation of the specified resource.
- * Requests using GET should only retrieve data and should not contain a request content.
- * @param path - The route path
- */
-export const Page = Get;
-/**
- * Decorator that marks a class as a module
- * Modules are used to organize the application structure and dependencies
- * @param options - Configuration options for the module
- * @returns A class decorator function
- */
-export function MvcModule(options = {}) {
-    return Module({
-        imports: options.imports,
-        services: options.services,
-        controllers: (options.views || []).concat(options.controllers || [])
-    });
-}

package/dist/decorators/parameter.decorator.d.ts

@@ -1,41 +0,0 @@
-/**
- * Decorator that binds the request body to a parameter
- * @param data - Optional property name to extract from the body
- */
-export declare const Body: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds a route parameter to a parameter
- * @param data - The parameter name in the route
- */
-export declare const Param: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds a query parameter to a parameter
- * @param data - The query parameter name
- */
-export declare const Query: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds a header value to a parameter
- * @param data - The header name
- */
-export declare const Header: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds the request object to a parameter
- */
-export declare const Req: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-export declare const Request: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds the response object to a parameter
- */
-export declare const Res: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-export declare const Response: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds the context object to a parameter
- */
-export declare const Ctx: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-export declare const Context: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Decorator that binds a context variable to a parameter
- * @param data - The variable name to retrieve from context
- */
-export declare const Var: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
-export declare const Variable: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;

package/dist/decorators/parameter.decorator.js

@@ -1,59 +0,0 @@
-import { HONEST_PIPELINE_BODY_CACHE_KEY } from '../constants';
-import { createParamDecorator } from '../helpers';
-/**
- * Decorator that binds the request body to a parameter
- * @param data - Optional property name to extract from the body
- */
-export const Body = createParamDecorator('body', async (data, ctx) => {
-    let body = ctx.get(HONEST_PIPELINE_BODY_CACHE_KEY);
-    if (body === undefined) {
-        body = await ctx.req.json();
-        ctx.set(HONEST_PIPELINE_BODY_CACHE_KEY, body);
-    }
-    if (data && body && typeof body === 'object') {
-        return body[String(data)];
-    }
-    return body;
-});
-/**
- * Decorator that binds a route parameter to a parameter
- * @param data - The parameter name in the route
- */
-export const Param = createParamDecorator('param', (data, ctx) => {
-    return data ? ctx.req.param(String(data)) : ctx.req.param();
-});
-/**
- * Decorator that binds a query parameter to a parameter
- * @param data - The query parameter name
- */
-export const Query = createParamDecorator('query', (data, ctx) => {
-    return data ? ctx.req.query(String(data)) : ctx.req.query();
-});
-/**
- * Decorator that binds a header value to a parameter
- * @param data - The header name
- */
-export const Header = createParamDecorator('header', (data, ctx) => {
-    return data ? ctx.req.header(String(data)) : ctx.req.header();
-});
-/**
- * Decorator that binds the request object to a parameter
- */
-export const Req = createParamDecorator('request', (_, ctx) => ctx.req);
-export const Request = createParamDecorator('request', (_, ctx) => ctx.req);
-/**
- * Decorator that binds the response object to a parameter
- */
-export const Res = createParamDecorator('response', (_, ctx) => ctx.res);
-export const Response = createParamDecorator('response', (_, ctx) => ctx.res);
-/**
- * Decorator that binds the context object to a parameter
- */
-export const Ctx = createParamDecorator('context', (_, ctx) => ctx);
-export const Context = createParamDecorator('context', (_, ctx) => ctx);
-/**
- * Decorator that binds a context variable to a parameter
- * @param data - The variable name to retrieve from context
- */
-export const Var = createParamDecorator('variable', (data, ctx) => data === undefined ? undefined : ctx.get(String(data)));
-export const Variable = createParamDecorator('variable', (data, ctx) => data === undefined ? undefined : ctx.get(String(data)));

package/dist/decorators/service.decorator.d.ts

@@ -1,6 +0,0 @@
-/**
- * Decorator that marks a class as a service
- * Services are singleton classes that can be injected as dependencies
- * @returns A class decorator function
- */
-export declare function Service(): ClassDecorator;

package/dist/decorators/service.decorator.js

@@ -1,11 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Decorator that marks a class as a service
- * Services are singleton classes that can be injected as dependencies
- * @returns A class decorator function
- */
-export function Service() {
-    return (target) => {
-        MetadataRegistry.addService(target);
-    };
-}

package/dist/decorators/use-component.decorator.d.ts

@@ -1,10 +0,0 @@
-import type { ComponentType, ComponentTypeMap } from '../registries';
-import type { Constructor } from '../types';
-/**
- * Generic decorator that applies components of a specific type to a controller class or method
- * @template T - The type of component being applied
- * @param type - The component type identifier
- * @param components - Array of components to apply
- * @returns A decorator function that can be used at class or method level
- */
-export declare function UseComponent<T extends ComponentType>(type: T, ...components: ComponentTypeMap[T][]): (target: Constructor | object, propertyKey?: string | symbol) => void;

package/dist/decorators/use-component.decorator.js

@@ -1,19 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Generic decorator that applies components of a specific type to a controller class or method
- * @template T - The type of component being applied
- * @param type - The component type identifier
- * @param components - Array of components to apply
- * @returns A decorator function that can be used at class or method level
- */
-export function UseComponent(type, ...components) {
-    return (target, propertyKey) => {
-        if (propertyKey) {
-            const controllerClass = target.constructor;
-            components.forEach((component) => MetadataRegistry.registerHandler(type, controllerClass, propertyKey, component));
-        }
-        else {
-            components.forEach((component) => MetadataRegistry.registerController(type, target, component));
-        }
-    };
-}

package/dist/decorators/use-filters.decorator.d.ts

@@ -1,8 +0,0 @@
-import type { FilterType } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Decorator that applies exception filters to a controller class or method
- * @param filters - Array of exception filters to apply
- * @returns A decorator function that can be used at class or method level
- */
-export declare function UseFilters(...filters: FilterType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;

package/dist/decorators/use-filters.decorator.js

@@ -1,17 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Decorator that applies exception filters to a controller class or method
- * @param filters - Array of exception filters to apply
- * @returns A decorator function that can be used at class or method level
- */
-export function UseFilters(...filters) {
-    return (target, propertyKey) => {
-        if (propertyKey) {
-            const controllerClass = target.constructor;
-            filters.forEach((filter) => MetadataRegistry.registerHandler('filter', controllerClass, propertyKey, filter));
-        }
-        else {
-            filters.forEach((filter) => MetadataRegistry.registerController('filter', target, filter));
-        }
-    };
-}

package/dist/decorators/use-guards.decorator.d.ts

@@ -1,9 +0,0 @@
-import type { GuardType } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Decorator that applies guards to a controller class or method
- * Guards determine whether a request should be handled by the route handler
- * @param guards - Array of guards to apply
- * @returns A decorator function that can be used at class or method level
- */
-export declare function UseGuards(...guards: GuardType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;

package/dist/decorators/use-guards.decorator.js

@@ -1,18 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Decorator that applies guards to a controller class or method
- * Guards determine whether a request should be handled by the route handler
- * @param guards - Array of guards to apply
- * @returns A decorator function that can be used at class or method level
- */
-export function UseGuards(...guards) {
-    return (target, propertyKey) => {
-        if (propertyKey) {
-            const controllerClass = target.constructor;
-            guards.forEach((guard) => MetadataRegistry.registerHandler('guard', controllerClass, propertyKey, guard));
-        }
-        else {
-            guards.forEach((guard) => MetadataRegistry.registerController('guard', target, guard));
-        }
-    };
-}

package/dist/decorators/use-middleware.decorator.d.ts

@@ -1,9 +0,0 @@
-import type { MiddlewareType } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Decorator that applies middleware to a controller class or method
- * Middleware functions run before the route handler and can modify the request/response
- * @param middleware - Array of middleware functions to apply
- * @returns A decorator function that can be used at class or method level
- */
-export declare function UseMiddleware(...middleware: MiddlewareType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;

package/dist/decorators/use-middleware.decorator.js

@@ -1,18 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Decorator that applies middleware to a controller class or method
- * Middleware functions run before the route handler and can modify the request/response
- * @param middleware - Array of middleware functions to apply
- * @returns A decorator function that can be used at class or method level
- */
-export function UseMiddleware(...middleware) {
-    return (target, propertyKey) => {
-        if (propertyKey) {
-            const controllerClass = target.constructor;
-            middleware.forEach((mw) => MetadataRegistry.registerHandler('middleware', controllerClass, propertyKey, mw));
-        }
-        else {
-            middleware.forEach((mw) => MetadataRegistry.registerController('middleware', target, mw));
-        }
-    };
-}

package/dist/decorators/use-pipes.decorator.d.ts

@@ -1,9 +0,0 @@
-import type { PipeType } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Decorator that applies transformation pipes to a controller class or method
- * Pipes transform input data before it reaches the route handler
- * @param pipes - Array of pipes to apply
- * @returns A decorator function that can be used at class or method level
- */
-export declare function UsePipes(...pipes: PipeType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;

package/dist/decorators/use-pipes.decorator.js

@@ -1,18 +0,0 @@
-import { MetadataRegistry } from '../registries';
-/**
- * Decorator that applies transformation pipes to a controller class or method
- * Pipes transform input data before it reaches the route handler
- * @param pipes - Array of pipes to apply
- * @returns A decorator function that can be used at class or method level
- */
-export function UsePipes(...pipes) {
-    return (target, propertyKey) => {
-        if (propertyKey) {
-            const controllerClass = target.constructor;
-            pipes.forEach((pipe) => MetadataRegistry.registerHandler('pipe', controllerClass, propertyKey, pipe));
-        }
-        else {
-            pipes.forEach((pipe) => MetadataRegistry.registerController('pipe', target, pipe));
-        }
-    };
-}

package/dist/di/container.d.ts

@@ -1,34 +0,0 @@
-import type { DiContainer, ILogger, IServiceRegistry } from '../interfaces';
-import type { Constructor } from '../types';
-/**
- * Dependency Injection container that manages class instances and their dependencies
- */
-export declare class Container implements DiContainer {
-    private readonly serviceRegistry;
-    private readonly logger;
-    private readonly debugDi;
-    constructor(serviceRegistry?: IServiceRegistry, logger?: ILogger, debugDi?: boolean);
-    /**
-     * Map of class constructors to their instances
-     */
-    private instances;
-    private emitLog;
-    /**
-     * Resolves a class instance, creating it if necessary and injecting its dependencies
-     * @param target - The class constructor to resolve
-     * @returns An instance of the target class
-     */
-    resolve<T>(target: Constructor<T>): T;
-    /**
-     * Internal recursive resolver with circular dependency tracking
-     */
-    private resolveWithTracking;
-    /**
-     * Registers a pre-created instance for a class
-     * @param target - The class constructor to register
-     * @param instance - The instance to register
-     */
-    register<T>(target: Constructor<T>, instance: T): void;
-    has<T>(target: Constructor<T>): boolean;
-    clear(): void;
-}

package/dist/di/container.js

@@ -1,114 +0,0 @@
-import { NoopLogger } from '../loggers';
-import { StaticServiceRegistry } from '../registries';
-/**
- * Dependency Injection container that manages class instances and their dependencies
- */
-export class Container {
-    serviceRegistry;
-    logger;
-    debugDi;
-    constructor(serviceRegistry = new StaticServiceRegistry(), logger = new NoopLogger(), debugDi = false) {
-        this.serviceRegistry = serviceRegistry;
-        this.logger = logger;
-        this.debugDi = debugDi;
-    }
-    /**
-     * Map of class constructors to their instances
-     */
-    instances = new Map();
-    emitLog(event) {
-        if (!this.debugDi) {
-            return;
-        }
-        this.logger.emit(event);
-    }
-    /**
-     * Resolves a class instance, creating it if necessary and injecting its dependencies
-     * @param target - The class constructor to resolve
-     * @returns An instance of the target class
-     */
-    resolve(target) {
-        return this.resolveWithTracking(target, new Set());
-    }
-    /**
-     * Internal recursive resolver with circular dependency tracking
-     */
-    resolveWithTracking(target, resolving) {
-        if (this.instances.has(target)) {
-            this.emitLog({
-                level: 'debug',
-                category: 'di',
-                message: `Resolved ${target.name} from DI cache`
-            });
-            return this.instances.get(target);
-        }
-        if (resolving.has(target)) {
-            const cycle = [...resolving.keys(), target].map((t) => t.name).join(' -> ');
-            this.emitLog({
-                level: 'error',
-                category: 'di',
-                message: `Circular dependency detected while resolving ${target.name}`,
-                details: { cycle }
-            });
-            throw new Error(`Circular dependency detected: ${cycle}`);
-        }
-        resolving.add(target);
-        this.emitLog({
-            level: 'debug',
-            category: 'di',
-            message: `Resolving ${target.name}`,
-            details: { resolving: [...resolving].map((constructor) => constructor.name) }
-        });
-        const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
-        if (target.length > 0 && paramTypes.length === 0) {
-            if (!this.serviceRegistry.isService(target)) {
-                this.emitLog({
-                    level: 'error',
-                    category: 'di',
-                    message: `Cannot resolve ${target.name}: missing @Service() decorator`
-                });
-                throw new Error(`Cannot resolve ${target.name}: it is not decorated with @Service(). Did you forget to add @Service() to the class?`);
-            }
-            this.emitLog({
-                level: 'error',
-                category: 'di',
-                message: `Cannot resolve ${target.name}: missing constructor metadata`
-            });
-            throw new Error(`Cannot resolve dependencies for ${target.name}: constructor metadata is missing. Ensure 'reflect-metadata' is imported and 'emitDecoratorMetadata' is enabled.`);
-        }
-        const dependencies = paramTypes.map((paramType, index) => {
-            if (!paramType || paramType === Object || paramType === Array || paramType === Function) {
-                this.emitLog({
-                    level: 'error',
-                    category: 'di',
-                    message: `Cannot resolve dependency at index ${index} of ${target.name}`
-                });
-                throw new Error(`Cannot resolve dependency at index ${index} of ${target.name}. Use concrete class types for constructor dependencies.`);
-            }
-            return this.resolveWithTracking(paramType, new Set(resolving));
-        });
-        const instance = new target(...dependencies);
-        this.instances.set(target, instance);
-        this.emitLog({
-            level: 'debug',
-            category: 'di',
-            message: `Created ${target.name} instance`,
-            details: { dependencyCount: dependencies.length }
-        });
-        return instance;
-    }
-    /**
-     * Registers a pre-created instance for a class
-     * @param target - The class constructor to register
-     * @param instance - The instance to register
-     */
-    register(target, instance) {
-        this.instances.set(target, instance);
-    }
-    has(target) {
-        return this.instances.has(target);
-    }
-    clear() {
-        this.instances.clear();
-    }
-}

package/dist/di/index.d.ts

@@ -1 +0,0 @@
-export * from './container';

package/dist/di/index.js

@@ -1 +0,0 @@
-export * from './container';

package/dist/errors/framework.error.d.ts

@@ -1,19 +0,0 @@
-export interface FrameworkErrorOptions {
-    status?: number;
-    code: string;
-    category: string;
-    remediation?: string;
-    details?: Record<string, unknown>;
-    cause?: unknown;
-}
-/**
- * Structured framework-level error with machine-readable metadata.
- */
-export declare class FrameworkError extends Error {
-    readonly status?: number;
-    readonly code: string;
-    readonly category: string;
-    readonly remediation?: string;
-    readonly details?: Record<string, unknown>;
-    constructor(message: string, options: FrameworkErrorOptions);
-}