honest-node 1.0.0

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

@@ -0,0 +1,230 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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/testing.interface.d.ts

@@ -0,0 +1,96 @@
+import type { Hono } from 'hono';
+import type { Application } from '../application';
+import type { DiContainer, HonestOptions, ILogger, ModuleOptions } from '../interfaces';
+import type { Constructor } from '../types';
+/**
+ * Options for creating a lightweight test module.
+ */
+export interface TestModuleOptions extends ModuleOptions {
+    /**
+     * Optional class name to improve diagnostics in test output.
+     */
+    name?: string;
+}
+/**
+ * Options for creating a test application instance.
+ */
+export interface CreateTestApplicationOptions extends TestModuleOptions {
+    /**
+     * Existing module class to bootstrap.
+     * If omitted, a module is created from controllers/services/imports.
+     */
+    module?: Constructor;
+    /**
+     * Honest application options passed to Application.create.
+     */
+    appOptions?: HonestOptions;
+}
+/**
+ * Options for creating a test application around a single controller.
+ */
+export interface CreateControllerTestApplicationOptions extends Omit<TestModuleOptions, 'controllers'> {
+    /**
+     * Controller class to mount in the generated test module.
+     */
+    controller: Constructor;
+    /**
+     * Honest application options passed to Application.create.
+     */
+    appOptions?: HonestOptions;
+}
+/**
+ * Result object returned by createTestApplication.
+ */
+export interface TestApplication {
+    /**
+     * Honest application instance.
+     */
+    app: Application;
+    /**
+     * Underlying Hono app.
+     */
+    hono: Hono;
+    /**
+     * Convenience request helper for tests.
+     * Relative paths are resolved against http://localhost.
+     */
+    request: (input: string | Request, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Override a service token with a pre-built test instance.
+ */
+export interface ServiceTestOverride<T = unknown> {
+    provide: Constructor<T>;
+    useValue: T;
+}
+/**
+ * Options for creating a service-only test container.
+ */
+export interface CreateServiceTestContainerOptions {
+    /**
+     * Optional service overrides registered before any resolve calls.
+     */
+    overrides?: ServiceTestOverride[];
+    /**
+     * Optional services to resolve immediately so tests can assert warm startup state.
+     */
+    preload?: Constructor[];
+    /**
+     * Optional logger used when debugDi is enabled.
+     */
+    logger?: ILogger;
+    /**
+     * Enable DI diagnostics while resolving services.
+     */
+    debugDi?: boolean;
+}
+/**
+ * Service-only test harness around the DI container.
+ */
+export interface TestServiceContainer {
+    container: DiContainer;
+    get<T>(target: Constructor<T>): T;
+    register<T>(target: Constructor<T>, instance: T): void;
+    has<T>(target: Constructor<T>): boolean;
+    clear(): void;
+}

package/dist/testing/testing.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/types/constructor.type.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Represents a class constructor type
+ * Used throughout the framework for type-safe dependency injection and component registration
+ *
+ * @template T - The type of instance that the constructor creates
+ * @example
+ * ```ts
+ * class MyService {}
+ * const myConstructor: Constructor<MyService> = MyService;
+ * ```
+ */
+export type Constructor<T = any> = new (...args: any[]) => T;

package/dist/types/constructor.type.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

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

package/dist/types/index.js

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

package/dist/utils/common.util.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Type guard that checks if a value is undefined
+ * @param obj - The value to check
+ * @returns True if the value is undefined, false otherwise
+ */
+export declare const isUndefined: (obj: unknown) => obj is undefined;
+/**
+ * Type guard that checks if a value is null or undefined
+ * @param val - The value to check
+ * @returns True if the value is null or undefined, false otherwise
+ */
+export declare const isNil: (val: unknown) => val is null | undefined;
+/**
+ * Type guard that checks if a value is an object (excluding null)
+ * @param val - The value to check
+ * @returns True if the value is a non-null object, false otherwise
+ */
+export declare const isObject: (val: unknown) => val is Record<PropertyKey, unknown>;
+/**
+ * Type guard that checks if a value is a plain object (not a class instance or array)
+ * Determines if an object is a simple key-value store created by object literals
+ *
+ * @param val - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(new Class()) // false
+ * isPlainObject([]) // false
+ * ```
+ */
+export declare const isPlainObject: (val: unknown) => val is Record<string, unknown>;
+/**
+ * Type guard that checks if a value is a function
+ * @param val - The value to check
+ * @returns True if the value is a function, false otherwise
+ */
+export declare const isFunction: (val: unknown) => val is Function;
+/**
+ * Type guard that checks if a value is a string
+ * @param val - The value to check
+ * @returns True if the value is a string, false otherwise
+ */
+export declare const isString: (val: unknown) => val is string;
+/**
+ * Type guard that checks if a value is a number
+ * @param val - The value to check
+ * @returns True if the value is a number, false otherwise
+ */
+export declare const isNumber: (val: unknown) => val is number;
+/**
+ * Checks if an array is empty
+ * @param array - The array to check
+ * @returns True if the array has no elements, false otherwise
+ */
+export declare const isEmpty: (array: unknown[]) => boolean;
+/**
+ * Type guard that checks if a value is a symbol
+ * @param val - The value to check
+ * @returns True if the value is a symbol, false otherwise
+ */
+export declare const isSymbol: (val: unknown) => val is symbol;
+/**
+ * Ensures a path starts with a leading slash
+ * @param path - The path to process
+ * @returns The path with a leading slash, or empty string if path is undefined
+ * @example
+ * ```ts
+ * addLeadingSlash('test') // '/test'
+ * addLeadingSlash('/test') // '/test'
+ * ```
+ */
+export declare const addLeadingSlash: (path?: string) => string;
+/**
+ * Normalizes a path by ensuring:
+ * - Starts with a single slash
+ * - No trailing slashes
+ * - No consecutive slashes
+ *
+ * @param path - The path to normalize
+ * @returns The normalized path
+ * @example
+ * ```ts
+ * normalizePath('//test//') // '/test'
+ * normalizePath('test/path//') // '/test/path'
+ * ```
+ */
+export declare const normalizePath: (path?: string) => string;
+/**
+ * Removes the trailing slash from a path
+ * @param path - The path to process
+ * @returns The path without a trailing slash
+ * @example
+ * ```ts
+ * stripEndSlash('/test/') // '/test'
+ * stripEndSlash('/test') // '/test'
+ * ```
+ */
+export declare const stripEndSlash: (path: string) => string;
+/**
+ * Checks if a value is a constructor function (callable with `new`).
+ * A constructor function must:
+ * - Be a function
+ * - Have a non-null prototype (excludes arrow functions, which have no prototype)
+ * - Have a prototype that is not a function (excludes rare edge cases)
+ * - Have at least the built-in 'constructor' on prototype (so empty classes are constructors)
+ *
+ * @param val - The value to check
+ * @returns True if the value is a constructor function, false otherwise
+ * @example
+ * ```ts
+ * class Test {}
+ * isConstructor(Test) // true
+ * isConstructor(() => {}) // false
+ * ```
+ */
+export declare const isConstructor: (val: unknown) => boolean;

package/dist/utils/common.util.js

@@ -0,0 +1,140 @@
+// Source: https://github.com/nestjs/nest/blob/master/packages/common/utils/shared.utils.ts
+/**
+ * Type guard that checks if a value is undefined
+ * @param obj - The value to check
+ * @returns True if the value is undefined, false otherwise
+ */
+export const isUndefined = (obj) => typeof obj === 'undefined';
+/**
+ * Type guard that checks if a value is null or undefined
+ * @param val - The value to check
+ * @returns True if the value is null or undefined, false otherwise
+ */
+export const isNil = (val) => val === null || typeof val === 'undefined';
+/**
+ * Type guard that checks if a value is an object (excluding null)
+ * @param val - The value to check
+ * @returns True if the value is a non-null object, false otherwise
+ */
+export const isObject = (val) => val !== null && typeof val === 'object';
+/**
+ * Type guard that checks if a value is a plain object (not a class instance or array)
+ * Determines if an object is a simple key-value store created by object literals
+ *
+ * @param val - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(new Class()) // false
+ * isPlainObject([]) // false
+ * ```
+ */
+export const isPlainObject = (val) => {
+    if (!isObject(val)) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(val);
+    if (proto === null) {
+        return true;
+    }
+    const ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+    return (typeof ctor === 'function' &&
+        ctor instanceof ctor &&
+        Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
+};
+/**
+ * Type guard that checks if a value is a function
+ * @param val - The value to check
+ * @returns True if the value is a function, false otherwise
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export const isFunction = (val) => typeof val === 'function';
+/**
+ * Type guard that checks if a value is a string
+ * @param val - The value to check
+ * @returns True if the value is a string, false otherwise
+ */
+export const isString = (val) => typeof val === 'string';
+/**
+ * Type guard that checks if a value is a number
+ * @param val - The value to check
+ * @returns True if the value is a number, false otherwise
+ */
+export const isNumber = (val) => typeof val === 'number';
+/**
+ * Checks if an array is empty
+ * @param array - The array to check
+ * @returns True if the array has no elements, false otherwise
+ */
+export const isEmpty = (array) => array.length === 0;
+/**
+ * Type guard that checks if a value is a symbol
+ * @param val - The value to check
+ * @returns True if the value is a symbol, false otherwise
+ */
+export const isSymbol = (val) => typeof val === 'symbol';
+/**
+ * Ensures a path starts with a leading slash
+ * @param path - The path to process
+ * @returns The path with a leading slash, or empty string if path is undefined
+ * @example
+ * ```ts
+ * addLeadingSlash('test') // '/test'
+ * addLeadingSlash('/test') // '/test'
+ * ```
+ */
+export const addLeadingSlash = (path) => typeof path === 'string' ? (path.charAt(0) !== '/' ? '/' + path : path) : '';
+/**
+ * Normalizes a path by ensuring:
+ * - Starts with a single slash
+ * - No trailing slashes
+ * - No consecutive slashes
+ *
+ * @param path - The path to normalize
+ * @returns The normalized path
+ * @example
+ * ```ts
+ * normalizePath('//test//') // '/test'
+ * normalizePath('test/path//') // '/test/path'
+ * ```
+ */
+export const normalizePath = (path) => path
+    ? path.startsWith('/')
+        ? ('/' + path.replace(/\/+$/, '')).replace(/\/+/g, '/')
+        : '/' + path.replace(/\/+$/, '')
+    : '/';
+/**
+ * Removes the trailing slash from a path
+ * @param path - The path to process
+ * @returns The path without a trailing slash
+ * @example
+ * ```ts
+ * stripEndSlash('/test/') // '/test'
+ * stripEndSlash('/test') // '/test'
+ * ```
+ */
+export const stripEndSlash = (path) => (path.endsWith('/') ? path.slice(0, -1) : path);
+/**
+ * Checks if a value is a constructor function (callable with `new`).
+ * A constructor function must:
+ * - Be a function
+ * - Have a non-null prototype (excludes arrow functions, which have no prototype)
+ * - Have a prototype that is not a function (excludes rare edge cases)
+ * - Have at least the built-in 'constructor' on prototype (so empty classes are constructors)
+ *
+ * @param val - The value to check
+ * @returns True if the value is a constructor function, false otherwise
+ * @example
+ * ```ts
+ * class Test {}
+ * isConstructor(Test) // true
+ * isConstructor(() => {}) // false
+ * ```
+ */
+export const isConstructor = (val) => {
+    return (isFunction(val) &&
+        !isNil(val.prototype) &&
+        !isFunction(val.prototype) &&
+        Object.getOwnPropertyNames(val.prototype).length >= 1);
+};

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "honest-node",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "engines": {
+    "node": ">=20.11.0",
+    "pnpm": ">=10.0.0"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "format": "biome format --write package.json tsconfig.json src",
+    "build": "tsc -p tsconfig.json",
+    "build:preview": "tsc -p tsconfig.json --noEmit",
+    "lint": "biome lint src --ignore='**/*.test.ts'",
+    "lint:fix": "biome lint src --ignore='**/*.test.ts' --fix",
+    "check": "pnpm lint && pnpm test"
+  },
+  "keywords": [],
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.33.0",
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "biome": "^0.3.3",
+    "lefthook": "^2.1.5",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
+  },
+  "dependencies": {
+    "hono": "^4.12.12",
+    "reflect-metadata": "^0.2.2"
+  }
+}