@morojs/moro 1.6.1 → 1.6.2

package/src/core/config/validation.ts

@@ -1,140 +0,0 @@
-// Configuration Validation Functions
-// Validation for config system with simple TypeScript functions
-
-export class ConfigValidationError extends Error {
-  constructor(
-    public field: string,
-    public value: unknown,
-    message: string
-  ) {
-    super(`Configuration validation failed for '${field}': ${message}`);
-    this.name = 'ConfigValidationError';
-  }
-}
-
-// Type-safe validation functions for configuration
-export function validatePort(value: unknown, field = 'port'): number {
-  const num = Number(value);
-  if (isNaN(num) || num < 1 || num > 65535) {
-    throw new ConfigValidationError(field, value, 'Must be a number between 1 and 65535');
-  }
-  return num;
-}
-
-export function validateBoolean(value: unknown, field = 'boolean'): boolean {
-  if (value === 'true' || value === true) return true;
-  if (value === 'false' || value === false) return false;
-  if (value === '1' || value === 1) return true;
-  if (value === '0' || value === 0) return false;
-  throw new ConfigValidationError(field, value, 'Must be a boolean (true/false) or numeric (1/0)');
-}
-
-export function validateNumber(
-  value: unknown,
-  field = 'number',
-  options: { min?: number; max?: number } = {}
-): number {
-  const num = Number(value);
-  if (isNaN(num)) {
-    throw new ConfigValidationError(field, value, 'Must be a valid number');
-  }
-  if (options.min !== undefined && num < options.min) {
-    throw new ConfigValidationError(field, value, `Must be at least ${options.min}`);
-  }
-  if (options.max !== undefined && num > options.max) {
-    throw new ConfigValidationError(field, value, `Must be at most ${options.max}`);
-  }
-  return num;
-}
-
-export function validateString(value: unknown, field = 'string'): string {
-  if (typeof value !== 'string') {
-    throw new ConfigValidationError(field, value, 'Must be a string');
-  }
-  return value;
-}
-
-export function validateUrl(value: unknown, field = 'url'): string {
-  const str = validateString(value, field);
-  try {
-    new URL(str);
-    return str;
-  } catch {
-    throw new ConfigValidationError(field, value, 'Must be a valid URL');
-  }
-}
-
-export function validateEnum<T extends string>(
-  value: unknown,
-  validValues: readonly T[],
-  field = 'enum'
-): T {
-  const str = validateString(value, field);
-  if (!validValues.includes(str as T)) {
-    throw new ConfigValidationError(field, value, `Must be one of: ${validValues.join(', ')}`);
-  }
-  return str as T;
-}
-
-export function validateStringArray(value: unknown, field = 'string array'): string[] {
-  if (!Array.isArray(value)) {
-    // Try to parse comma-separated string
-    if (typeof value === 'string') {
-      return value
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0);
-    }
-    throw new ConfigValidationError(field, value, 'Must be an array or comma-separated string');
-  }
-  return value.map((item, index) => validateString(item, `${field}[${index}]`));
-}
-
-export function validateOptional<T>(
-  value: unknown,
-  validator: (value: unknown, field: string) => T,
-  field: string
-): T | undefined {
-  if (value === undefined || value === null || value === '') {
-    return undefined;
-  }
-  return validator(value, field);
-}
-
-// Coercion helpers for environment variables
-export function coerceEnvValue(value: string): unknown {
-  // Handle common patterns in environment variables
-
-  // Null/undefined
-  if (value === '' || value === 'null' || value === 'undefined') {
-    return undefined;
-  }
-
-  // Boolean
-  if (value === 'true' || value === 'false') {
-    return value === 'true';
-  }
-
-  // Number (but not if it starts with 0 - could be port, zip code, etc.)
-  if (/^-?\d+(\.\d+)?$/.test(value) && !value.startsWith('0')) {
-    const num = Number(value);
-    if (!isNaN(num)) {
-      return num;
-    }
-  }
-
-  // JSON (for complex objects/arrays)
-  if (
-    (value.startsWith('{') && value.endsWith('}')) ||
-    (value.startsWith('[') && value.endsWith(']'))
-  ) {
-    try {
-      return JSON.parse(value);
-    } catch {
-      // Not valid JSON, treat as string
-    }
-  }
-
-  // Return as string for all other cases
-  return value;
-}

package/src/core/http/router.ts

@@ -1,141 +0,0 @@
-// src/core/router.ts
-import {
-  HttpRequest,
-  HttpResponse,
-  HttpHandler,
-  Middleware,
-  RouteDefinition,
-} from '../../types/http';
-import { createFrameworkLogger } from '../logger';
-
-export class Router {
-  private routes: RouteDefinition[] = [];
-  private logger = createFrameworkLogger('Router');
-
-  get(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute('GET', path, handlers);
-  }
-
-  post(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute('POST', path, handlers);
-  }
-
-  put(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute('PUT', path, handlers);
-  }
-
-  delete(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute('DELETE', path, handlers);
-  }
-
-  patch(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
-    this.addRoute('PATCH', path, handlers);
-  }
-
-  private addRoute(method: string, path: string, handlers: (Middleware | HttpHandler)[]): void {
-    const { pattern, paramNames } = this.pathToRegex(path);
-    const handler = handlers.pop() as HttpHandler;
-    const middleware = handlers as Middleware[];
-
-    this.routes.push({
-      method,
-      path,
-      pattern,
-      paramNames,
-      handler,
-      middleware,
-    });
-  }
-
-  private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
-    const paramNames: string[] = [];
-
-    // Convert parameterized routes to regex
-    const regexPattern = path
-      .replace(/\/:([^/]+)/g, (match, paramName) => {
-        paramNames.push(paramName);
-        return '/([^/]+)';
-      })
-      .replace(/\//g, '\\/');
-
-    return {
-      pattern: new RegExp(`^${regexPattern}$`),
-      paramNames,
-    };
-  }
-
-  async handle(req: HttpRequest, res: HttpResponse, basePath: string = ''): Promise<boolean> {
-    let path = req.path.startsWith(basePath) ? req.path.substring(basePath.length) : req.path;
-
-    // If removing basePath results in empty string, default to '/'
-    if (path === '' || path === undefined) {
-      path = '/';
-    }
-
-    this.logger.debug(
-      `Router processing: originalPath="${req.path}", basePath="${basePath}", processedPath="${path}"`,
-      'Processing'
-    );
-
-    const route = this.routes.find(r => r.method === req.method && r.pattern.test(path));
-
-    this.logger.debug(
-      `Found route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
-      'RouteMatch'
-    );
-
-    if (!route) {
-      return false; // Route not found
-    }
-
-    // Extract path parameters
-    const matches = path.match(route.pattern);
-    if (matches) {
-      req.params = {};
-      route.paramNames.forEach((name, index) => {
-        req.params[name] = matches[index + 1];
-      });
-    }
-
-    // Execute middleware
-    for (const mw of route.middleware) {
-      await new Promise<void>((resolve, reject) => {
-        let nextCalled = false;
-
-        const next = () => {
-          if (nextCalled) return;
-          nextCalled = true;
-          resolve();
-        };
-
-        try {
-          const result = mw(req, res, next);
-
-          if (result instanceof Promise) {
-            result
-              .then(() => {
-                if (!nextCalled) next();
-              })
-              .catch(reject);
-          }
-        } catch (error) {
-          reject(error);
-        }
-      });
-    }
-
-    // Execute handler
-    const result = await route.handler(req, res);
-
-    // If handler returns data and response hasn't been sent, send it
-    if (result !== undefined && result !== null && !res.headersSent) {
-      res.json(result);
-    }
-
-    return true;
-  }
-
-  getRoutes(): RouteDefinition[] {
-    return [...this.routes];
-  }
-}