@carno.js/core 1.0.2 → 1.0.3

package/src/testing/TestHarness.ts

@@ -1,177 +1,177 @@
-import type { Server } from 'bun';
-import { Carno, type CarnoConfig } from '../Carno';
-import { Container, type Token } from '../container/Container';
-
-/**
- * Test configuration options.
- */
-export interface TestOptions {
-    config?: CarnoConfig;
-    listen?: boolean | number;
-    port?: number;
-    controllers?: (new (...args: any[]) => any)[];
-    services?: (Token | any)[];
-}
-
-/**
- * Test harness - provides utilities for testing Carno applications.
- */
-export interface TestHarness {
-    /** The Carno app instance */
-    app: Carno;
-
-    /** The internal DI container */
-    container: Container;
-
-    /** The HTTP server (if listening) */
-    server?: Server<any>;
-
-    /** The port the server is running on */
-    port?: number;
-
-    /** Resolve a service from the container */
-    resolve<T>(token: Token<T>): T;
-
-    /** Make an HTTP request to the app */
-    request(path: string, init?: RequestInit): Promise<Response>;
-
-    /** Make a GET request */
-    get(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
-
-    /** Make a POST request */
-    post(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
-
-    /** Make a PUT request */
-    put(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
-
-    /** Make a DELETE request */
-    delete(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
-
-    /** Close the test harness and cleanup */
-    close(): Promise<void>;
-}
-
-/**
- * Create a test harness for Turbo applications.
- * 
- * @example
- * ```typescript
- * const harness = await createTestHarness({
- *   controllers: [UserController],
- *   services: [UserService],
- *   listen: true
- * });
- * 
- * const response = await harness.get('/users');
- * expect(response.status).toBe(200);
- * 
- * await harness.close();
- * ```
- */
-export async function createTestHarness(options: TestOptions = {}): Promise<TestHarness> {
-    const config: CarnoConfig = {
-        ...options.config,
-        disableStartupLog: true
-    };
-
-    const app = new Carno(config);
-
-    // Register controllers
-    if (options.controllers) {
-        app.controllers(options.controllers);
-    }
-
-    // Register services
-    if (options.services) {
-        app.services(options.services);
-    }
-
-    const port = resolvePort(options);
-    let server: Server<any> | undefined;
-
-    if (shouldListen(options.listen)) {
-        app.listen(port);
-        server = (app as any).server;
-    }
-
-    const actualPort = server?.port ?? port;
-    const container = (app as any).container as Container;
-
-    // Pre-bind methods for performance
-    const baseUrl = `http://127.0.0.1:${actualPort}`;
-
-    const request = async (path: string, init?: RequestInit): Promise<Response> => {
-        if (!server) {
-            throw new Error('Server not running. Set listen: true in options.');
-        }
-        const url = path.startsWith('http') ? path : `${baseUrl}${path.startsWith('/') ? path : '/' + path}`;
-        return fetch(url, init);
-    };
-
-    return {
-        app,
-        container,
-        server,
-        port: actualPort,
-
-        resolve: <T>(token: Token<T>): T => container.get(token),
-
-        request,
-
-        get: (path, init) => request(path, { ...init, method: 'GET' }),
-
-        post: (path, body, init) => request(path, {
-            ...init,
-            method: 'POST',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: { 'Content-Type': 'application/json', ...init?.headers }
-        }),
-
-        put: (path, body, init) => request(path, {
-            ...init,
-            method: 'PUT',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: { 'Content-Type': 'application/json', ...init?.headers }
-        }),
-
-        delete: (path, init) => request(path, { ...init, method: 'DELETE' }),
-
-        close: async () => {
-            app.stop();
-        }
-    };
-}
-
-/**
- * Run a test routine with automatic harness cleanup.
- * 
- * @example
- * ```typescript
- * await withTestApp(async (harness) => {
- *   const response = await harness.get('/health');
- *   expect(response.status).toBe(200);
- * }, { controllers: [HealthController], listen: true });
- * ```
- */
-export async function withTestApp(
-    routine: (harness: TestHarness) => Promise<void>,
-    options: TestOptions = {}
-): Promise<void> {
-    const harness = await createTestHarness(options);
-
-    try {
-        await routine(harness);
-    } finally {
-        await harness.close();
-    }
-}
-
-function shouldListen(value: TestOptions['listen']): boolean {
-    return typeof value === 'number' || Boolean(value);
-}
-
-function resolvePort(options: TestOptions): number {
-    if (typeof options.listen === 'number') return options.listen;
-    if (typeof options.port === 'number') return options.port;
-    return 0; // Random port
-}
+import type { Server } from 'bun';
+import { Carno, type CarnoConfig } from '../Carno';
+import { Container, type Token } from '../container/Container';
+
+/**
+ * Test configuration options.
+ */
+export interface TestOptions {
+    config?: CarnoConfig;
+    listen?: boolean | number;
+    port?: number;
+    controllers?: (new (...args: any[]) => any)[];
+    services?: (Token | any)[];
+}
+
+/**
+ * Test harness - provides utilities for testing Carno applications.
+ */
+export interface TestHarness {
+    /** The Carno app instance */
+    app: Carno;
+
+    /** The internal DI container */
+    container: Container;
+
+    /** The HTTP server (if listening) */
+    server?: Server<any>;
+
+    /** The port the server is running on */
+    port?: number;
+
+    /** Resolve a service from the container */
+    resolve<T>(token: Token<T>): T;
+
+    /** Make an HTTP request to the app */
+    request(path: string, init?: RequestInit): Promise<Response>;
+
+    /** Make a GET request */
+    get(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
+
+    /** Make a POST request */
+    post(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
+
+    /** Make a PUT request */
+    put(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
+
+    /** Make a DELETE request */
+    delete(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
+
+    /** Close the test harness and cleanup */
+    close(): Promise<void>;
+}
+
+/**
+ * Create a test harness for Turbo applications.
+ * 
+ * @example
+ * ```typescript
+ * const harness = await createTestHarness({
+ *   controllers: [UserController],
+ *   services: [UserService],
+ *   listen: true
+ * });
+ * 
+ * const response = await harness.get('/users');
+ * expect(response.status).toBe(200);
+ * 
+ * await harness.close();
+ * ```
+ */
+export async function createTestHarness(options: TestOptions = {}): Promise<TestHarness> {
+    const config: CarnoConfig = {
+        ...options.config,
+        disableStartupLog: true
+    };
+
+    const app = new Carno(config);
+
+    // Register controllers
+    if (options.controllers) {
+        app.controllers(options.controllers);
+    }
+
+    // Register services
+    if (options.services) {
+        app.services(options.services);
+    }
+
+    const port = resolvePort(options);
+    let server: Server<any> | undefined;
+
+    if (shouldListen(options.listen)) {
+        app.listen(port);
+        server = (app as any).server;
+    }
+
+    const actualPort = server?.port ?? port;
+    const container = (app as any).container as Container;
+
+    // Pre-bind methods for performance
+    const baseUrl = `http://127.0.0.1:${actualPort}`;
+
+    const request = async (path: string, init?: RequestInit): Promise<Response> => {
+        if (!server) {
+            throw new Error('Server not running. Set listen: true in options.');
+        }
+        const url = path.startsWith('http') ? path : `${baseUrl}${path.startsWith('/') ? path : '/' + path}`;
+        return fetch(url, init);
+    };
+
+    return {
+        app,
+        container,
+        server,
+        port: actualPort,
+
+        resolve: <T>(token: Token<T>): T => container.get(token),
+
+        request,
+
+        get: (path, init) => request(path, { ...init, method: 'GET' }),
+
+        post: (path, body, init) => request(path, {
+            ...init,
+            method: 'POST',
+            body: body ? JSON.stringify(body) : undefined,
+            headers: { 'Content-Type': 'application/json', ...init?.headers }
+        }),
+
+        put: (path, body, init) => request(path, {
+            ...init,
+            method: 'PUT',
+            body: body ? JSON.stringify(body) : undefined,
+            headers: { 'Content-Type': 'application/json', ...init?.headers }
+        }),
+
+        delete: (path, init) => request(path, { ...init, method: 'DELETE' }),
+
+        close: async () => {
+            app.stop();
+        }
+    };
+}
+
+/**
+ * Run a test routine with automatic harness cleanup.
+ * 
+ * @example
+ * ```typescript
+ * await withTestApp(async (harness) => {
+ *   const response = await harness.get('/health');
+ *   expect(response.status).toBe(200);
+ * }, { controllers: [HealthController], listen: true });
+ * ```
+ */
+export async function withTestApp(
+    routine: (harness: TestHarness) => Promise<void>,
+    options: TestOptions = {}
+): Promise<void> {
+    const harness = await createTestHarness(options);
+
+    try {
+        await routine(harness);
+    } finally {
+        await harness.close();
+    }
+}
+
+function shouldListen(value: TestOptions['listen']): boolean {
+    return typeof value === 'number' || Boolean(value);
+}
+
+function resolvePort(options: TestOptions): number {
+    if (typeof options.listen === 'number') return options.listen;
+    if (typeof options.port === 'number') return options.port;
+    return 0; // Random port
+}

package/src/utils/Metadata.ts

@@ -1,43 +1,43 @@
-/**
- * Utility class for handling metadata operations.
- * Wraps Reflect.getMetadata and Reflect.defineMetadata.
- */
-export class Metadata {
-  static get<T = any>(key: string | symbol, target: any): T | undefined {
-    return Reflect.getMetadata(key, target);
-  }
-
-  static set(key: string | symbol, value: any, target: any): void {
-    Reflect.defineMetadata(key, value, target);
-  }
-
-  static has(key: string | symbol, target: any): boolean {
-    return Reflect.hasMetadata(key, target);
-  }
-
-  static delete(key: string | symbol, target: any): boolean {
-    return Reflect.deleteMetadata(key, target);
-  }
-
-  static keys(target: any): (string | symbol)[] {
-    return Reflect.getMetadataKeys(target);
-  }
-
-  static getType(target: any, propertyKey: string | symbol): any {
-    return Reflect.getMetadata('design:type', target, propertyKey);
-  }
-}
-
-/**
- * Type guard for checking if value is an object.
- */
-export function isObject(value: unknown): value is Record<string, any> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/**
- * Type guard for checking if value is a string.
- */
-export function isString(value: unknown): value is string {
-  return typeof value === 'string';
-}
+/**
+ * Utility class for handling metadata operations.
+ * Wraps Reflect.getMetadata and Reflect.defineMetadata.
+ */
+export class Metadata {
+  static get<T = any>(key: string | symbol, target: any): T | undefined {
+    return Reflect.getMetadata(key, target);
+  }
+
+  static set(key: string | symbol, value: any, target: any): void {
+    Reflect.defineMetadata(key, value, target);
+  }
+
+  static has(key: string | symbol, target: any): boolean {
+    return Reflect.hasMetadata(key, target);
+  }
+
+  static delete(key: string | symbol, target: any): boolean {
+    return Reflect.deleteMetadata(key, target);
+  }
+
+  static keys(target: any): (string | symbol)[] {
+    return Reflect.getMetadataKeys(target);
+  }
+
+  static getType(target: any, propertyKey: string | symbol): any {
+    return Reflect.getMetadata('design:type', target, propertyKey);
+  }
+}
+
+/**
+ * Type guard for checking if value is an object.
+ */
+export function isObject(value: unknown): value is Record<string, any> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Type guard for checking if value is a string.
+ */
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}

package/src/validation/ValibotAdapter.ts

@@ -1,95 +1,95 @@
-import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
-import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
-import { ValidationException } from './ZodAdapter';
-
-/**
- * Valibot Adapter for Turbo validation.
- * 
- * Usage:
- * ```typescript
- * import * as v from 'valibot';
- * 
- * @Schema(v.object({
- *   name: v.pipe(v.string(), v.minLength(1)),
- *   email: v.pipe(v.string(), v.email())
- * }))
- * class CreateUserDto {
- *   name: string;
- *   email: string;
- * }
- * ```
- */
-export class ValibotAdapter implements ValidatorAdapter {
-    readonly name = 'ValibotAdapter';
-
-    private schemaCache = new Map<any, any>();
-    private valibot: any = null;
-
-    constructor() {
-        // Lazy load valibot
-        try {
-            this.valibot = require('valibot');
-        } catch {
-            // Will be loaded on first use
-        }
-    }
-
-    private ensureValibot(): any {
-        if (!this.valibot) {
-            this.valibot = require('valibot');
-        }
-        return this.valibot;
-    }
-
-    hasValidation(target: any): boolean {
-        return getSchema(target) !== undefined;
-    }
-
-    validate<T>(target: any, value: unknown): ValidationResult<T> {
-        const schema = this.getOrCacheSchema(target);
-
-        if (!schema) {
-            return { success: true, data: value as T };
-        }
-
-        const v = this.ensureValibot();
-        const result = v.safeParse(schema, value);
-
-        if (result.success) {
-            return { success: true, data: result.output };
-        }
-
-        return {
-            success: false,
-            errors: this.formatErrors(result.issues)
-        };
-    }
-
-    validateOrThrow<T>(target: any, value: unknown): T {
-        const result = this.validate<T>(target, value);
-
-        if (result.success) {
-            return result.data!;
-        }
-
-        throw new ValidationException(result.errors!);
-    }
-
-    private getOrCacheSchema(target: any): any {
-        let schema = this.schemaCache.get(target);
-
-        if (schema === undefined) {
-            schema = getSchema(target) ?? null;
-            this.schemaCache.set(target, schema);
-        }
-
-        return schema;
-    }
-
-    private formatErrors(issues: any[]): ValidationError[] {
-        return issues.map((issue: any) => ({
-            path: issue.path?.map((p: any) => p.key).join('.') || '',
-            message: issue.message
-        }));
-    }
-}
+import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
+import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
+import { ValidationException } from './ZodAdapter';
+
+/**
+ * Valibot Adapter for Turbo validation.
+ * 
+ * Usage:
+ * ```typescript
+ * import * as v from 'valibot';
+ * 
+ * @Schema(v.object({
+ *   name: v.pipe(v.string(), v.minLength(1)),
+ *   email: v.pipe(v.string(), v.email())
+ * }))
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ * ```
+ */
+export class ValibotAdapter implements ValidatorAdapter {
+    readonly name = 'ValibotAdapter';
+
+    private schemaCache = new Map<any, any>();
+    private valibot: any = null;
+
+    constructor() {
+        // Lazy load valibot
+        try {
+            this.valibot = require('valibot');
+        } catch {
+            // Will be loaded on first use
+        }
+    }
+
+    private ensureValibot(): any {
+        if (!this.valibot) {
+            this.valibot = require('valibot');
+        }
+        return this.valibot;
+    }
+
+    hasValidation(target: any): boolean {
+        return getSchema(target) !== undefined;
+    }
+
+    validate<T>(target: any, value: unknown): ValidationResult<T> {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return { success: true, data: value as T };
+        }
+
+        const v = this.ensureValibot();
+        const result = v.safeParse(schema, value);
+
+        if (result.success) {
+            return { success: true, data: result.output };
+        }
+
+        return {
+            success: false,
+            errors: this.formatErrors(result.issues)
+        };
+    }
+
+    validateOrThrow<T>(target: any, value: unknown): T {
+        const result = this.validate<T>(target, value);
+
+        if (result.success) {
+            return result.data!;
+        }
+
+        throw new ValidationException(result.errors!);
+    }
+
+    private getOrCacheSchema(target: any): any {
+        let schema = this.schemaCache.get(target);
+
+        if (schema === undefined) {
+            schema = getSchema(target) ?? null;
+            this.schemaCache.set(target, schema);
+        }
+
+        return schema;
+    }
+
+    private formatErrors(issues: any[]): ValidationError[] {
+        return issues.map((issue: any) => ({
+            path: issue.path?.map((p: any) => p.key).join('.') || '',
+            message: issue.message
+        }));
+    }
+}