@morojs/moro 1.6.2 → 1.6.3

package/src/core/utilities/hooks.ts

@@ -1,142 +0,0 @@
-// Hook System for Moro
-import { EventEmitter } from 'events';
-import { HookFunction, HookContext, MoroMiddleware } from '../../types/hooks.js';
-import { createFrameworkLogger } from '../logger/index.js';
-
-export const HOOK_EVENTS = {
-  BEFORE_REQUEST: 'before:request',
-  AFTER_REQUEST: 'after:request',
-  BEFORE_RESPONSE: 'before:response',
-  AFTER_RESPONSE: 'after:response',
-  ERROR: 'error',
-} as const;
-
-export class HookManager extends EventEmitter {
-  private hooks = new Map<string, HookFunction[]>();
-  private beforeHooks = new Map<string, HookFunction[]>();
-  private afterHooks = new Map<string, HookFunction[]>();
-  private logger = createFrameworkLogger('Hooks');
-
-  constructor() {
-    super();
-    // Initialize hook arrays
-    Object.values(HOOK_EVENTS).forEach(event => {
-      this.hooks.set(event, []);
-      this.beforeHooks.set(event, []);
-      this.afterHooks.set(event, []);
-    });
-  }
-
-  // Register a hook for a specific event
-  hook(event: string, fn: HookFunction): this {
-    if (!this.hooks.has(event)) {
-      this.hooks.set(event, []);
-    }
-    this.hooks.get(event)!.push(fn);
-    return this;
-  }
-
-  // Register a before hook
-  before(event: string, fn: HookFunction): this {
-    if (!this.beforeHooks.has(event)) {
-      this.beforeHooks.set(event, []);
-    }
-    this.beforeHooks.get(event)!.push(fn);
-    return this;
-  }
-
-  // Register an after hook
-  after(event: string, fn: HookFunction): this {
-    if (!this.afterHooks.has(event)) {
-      this.afterHooks.set(event, []);
-    }
-    this.afterHooks.get(event)!.push(fn);
-    return this;
-  }
-
-  // Execute hooks for an event
-  async execute(event: string, context: HookContext = {}): Promise<HookContext> {
-    // Execute before hooks
-    const beforeHooks = this.beforeHooks.get(event) || [];
-    for (const hook of beforeHooks) {
-      await this.executeHook(hook, context);
-    }
-
-    // Execute main hooks
-    const hooks = this.hooks.get(event) || [];
-    for (const hook of hooks) {
-      await this.executeHook(hook, context);
-    }
-
-    // Execute after hooks
-    const afterHooks = this.afterHooks.get(event) || [];
-    for (const hook of afterHooks) {
-      await this.executeHook(hook, context);
-    }
-
-    // Emit event for listeners
-    this.emit(event, context);
-
-    return context;
-  }
-
-  // Execute a single hook with error handling
-  private async executeHook(hook: HookFunction, context: HookContext): Promise<void> {
-    try {
-      await hook(context);
-    } catch (error) {
-      this.logger.error('Hook execution error', 'HookExecution', {
-        error: error instanceof Error ? error.message : String(error),
-        context: context.request?.method || 'unknown',
-      });
-      throw error;
-    }
-  }
-
-  // Remove hooks
-  removeHook(event: string, fn?: HookFunction): this {
-    if (!fn) {
-      this.hooks.delete(event);
-      this.beforeHooks.delete(event);
-      this.afterHooks.delete(event);
-    } else {
-      [this.hooks, this.beforeHooks, this.afterHooks].forEach(map => {
-        const hooks = map.get(event);
-        if (hooks) {
-          const index = hooks.indexOf(fn);
-          if (index !== -1) {
-            hooks.splice(index, 1);
-          }
-        }
-      });
-    }
-    return this;
-  }
-
-  // Get all registered hooks for debugging
-  getHooks(event?: string): Record<string, any> {
-    if (event) {
-      return {
-        before: this.beforeHooks.get(event) || [],
-        main: this.hooks.get(event) || [],
-        after: this.afterHooks.get(event) || [],
-      };
-    }
-
-    const allHooks: Record<string, any> = {};
-    const allEvents = new Set([
-      ...this.hooks.keys(),
-      ...this.beforeHooks.keys(),
-      ...this.afterHooks.keys(),
-    ]);
-
-    allEvents.forEach(event => {
-      allHooks[event] = this.getHooks(event);
-    });
-
-    return allHooks;
-  }
-}
-
-// Built-in middleware - now organized in individual files
-export { simpleMiddleware as middleware } from '../middleware/index.js';

package/src/core/utilities/index.ts

@@ -1,17 +0,0 @@
-// Core Utilities - Centralized Exports
-export {
-  Container,
-  FunctionalContainer,
-  ServiceScope,
-  ServiceLifecycle,
-  withLogging,
-  withCaching,
-  withRetry,
-  withTimeout,
-} from './container.js';
-export { CircuitBreaker } from './circuit-breaker.js';
-export { HookManager, HOOK_EVENTS } from './hooks.js';
-export { isPackageAvailable, resolveUserPackage, createUserRequire } from './package-utils.js';
-
-// Re-export middleware from hooks
-export { middleware } from './hooks.js';

package/src/core/utilities/package-utils.ts

@@ -1,59 +0,0 @@
-// Package and Module Resolution Utilities
-// ESM-compatible helpers for detecting and resolving optional dependencies
-
-import { createRequire } from 'module';
-import { join } from 'path';
-
-/**
- * Check if a package is available in the user's node_modules
- * Uses ESM-compatible module resolution from the user's working directory
- *
- * @param packageName - The name of the package to check (e.g., 'socket.io', 'zod')
- * @returns true if the package is installed, false otherwise
- *
- * @example
- * if (isPackageAvailable('socket.io')) {
- *   // socket.io is installed, safe to import
- *   const { Server } = await import('socket.io');
- * }
- */
-export function isPackageAvailable(packageName: string): boolean {
-  try {
-    const userRequire = createRequire(join(process.cwd(), 'package.json'));
-    userRequire.resolve(packageName);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Resolve a package path from the user's node_modules
- * Uses ESM-compatible module resolution from the user's working directory
- *
- * @param packageName - The name of the package to resolve
- * @returns The resolved package path
- * @throws Error if the package is not found
- *
- * @example
- * const socketIOPath = resolveUserPackage('socket.io');
- * const { Server } = await import(socketIOPath);
- */
-export function resolveUserPackage(packageName: string): string {
-  const userRequire = createRequire(join(process.cwd(), 'package.json'));
-  return userRequire.resolve(packageName);
-}
-
-/**
- * Create a require function for the user's working directory
- * Useful for resolving packages installed by the user, not in Moro's dependencies
- *
- * @returns A require function scoped to the user's working directory
- *
- * @example
- * const userRequire = createUserRequire();
- * const packagePath = userRequire.resolve('some-package');
- */
-export function createUserRequire() {
-  return createRequire(join(process.cwd(), 'package.json'));
-}

package/src/core/validation/adapters.ts

@@ -1,147 +0,0 @@
-// Validation Library Adapters for Moro Framework
-// Makes Joi, Yup, and other libraries compatible with ValidationSchema interface
-
-import { ValidationSchema, ValidationError, normalizeValidationError } from './schema-interface.js';
-
-/**
- * Zod Compatibility Check
- * Zod ALREADY implements ValidationSchema interface natively!
- * No adapter needed - it just works.
- */
-
-/**
- * Joi Adapter - makes Joi schemas compatible with ValidationSchema
- */
-export class JoiAdapter<T = any> implements ValidationSchema<T> {
-  constructor(private joiSchema: any) {
-    if (!joiSchema || typeof joiSchema.validateAsync !== 'function') {
-      throw new Error('Invalid Joi schema provided to JoiAdapter');
-    }
-  }
-
-  async parseAsync(data: unknown): Promise<T> {
-    try {
-      const result = await this.joiSchema.validateAsync(data, { abortEarly: false });
-      return result as T;
-    } catch (error) {
-      throw normalizeValidationError(error);
-    }
-  }
-}
-
-/**
- * Yup Adapter - makes Yup schemas compatible with ValidationSchema
- */
-export class YupAdapter<T = any> implements ValidationSchema<T> {
-  constructor(private yupSchema: any) {
-    if (!yupSchema || typeof yupSchema.validate !== 'function') {
-      throw new Error('Invalid Yup schema provided to YupAdapter');
-    }
-  }
-
-  async parseAsync(data: unknown): Promise<T> {
-    try {
-      const result = await this.yupSchema.validate(data, { abortEarly: false });
-      return result as T;
-    } catch (error) {
-      throw normalizeValidationError(error);
-    }
-  }
-}
-
-/**
- * Custom Validation Function Adapter
- * Allows users to use simple validation functions
- */
-export class FunctionAdapter<T = any> implements ValidationSchema<T> {
-  constructor(
-    private validateFn: (data: unknown) => T | Promise<T>,
-    private name: string = 'custom'
-  ) {
-    if (typeof validateFn !== 'function') {
-      throw new Error('Validation function is required for FunctionAdapter');
-    }
-  }
-
-  async parseAsync(data: unknown): Promise<T> {
-    try {
-      return await this.validateFn(data);
-    } catch (error) {
-      throw new ValidationError([
-        {
-          path: [],
-          message: error instanceof Error ? error.message : String(error),
-          code: this.name,
-        },
-      ]);
-    }
-  }
-}
-
-/**
- * Class Validator Adapter (for TypeScript decorators)
- */
-export class ClassValidatorAdapter<T extends object = any> implements ValidationSchema<T> {
-  constructor(
-    private ClassType: new () => T,
-    private validate?: (obj: any) => Promise<any[]>
-  ) {
-    if (typeof ClassType !== 'function') {
-      throw new Error('Class constructor is required for ClassValidatorAdapter');
-    }
-  }
-
-  async parseAsync(data: unknown): Promise<T> {
-    try {
-      const instance = Object.assign(new this.ClassType(), data as Record<string, any>);
-
-      if (this.validate) {
-        const errors = await this.validate(instance);
-        if (errors && errors.length > 0) {
-          throw new ValidationError(
-            errors.map((error: any, index: number) => ({
-              path: error.property ? [error.property] : [index],
-              message: Object.values(error.constraints || {}).join(', ') || 'Validation failed',
-              code: 'class_validator',
-            }))
-          );
-        }
-      }
-
-      return instance as T;
-    } catch (error) {
-      if (error instanceof ValidationError) throw error;
-      throw normalizeValidationError(error);
-    }
-  }
-}
-
-/**
- * Utility functions for creating adapters
- */
-export function joi<T = any>(joiSchema: any): ValidationSchema<T> {
-  return new JoiAdapter<T>(joiSchema);
-}
-
-export function yup<T = any>(yupSchema: any): ValidationSchema<T> {
-  return new YupAdapter<T>(yupSchema);
-}
-
-export function fn<T = any>(
-  validateFn: (data: unknown) => T | Promise<T>,
-  name?: string
-): ValidationSchema<T> {
-  return new FunctionAdapter<T>(validateFn, name);
-}
-
-export function classValidator<T extends object = any>(
-  ClassType: new () => T,
-  validate?: (obj: any) => Promise<any[]>
-): ValidationSchema<T> {
-  return new ClassValidatorAdapter<T>(ClassType, validate);
-}
-
-// Type helpers
-export type JoiSchema<T> = ValidationSchema<T>;
-export type YupSchema<T> = ValidationSchema<T>;
-export type CustomValidator<T> = ValidationSchema<T>;

package/src/core/validation/index.ts

@@ -1,258 +0,0 @@
-// Universal Validation System for Moro Framework
-// Works with Zod, Joi, Yup, and any validation library via adapters
-
-import { HttpRequest, HttpResponse } from '../http/index.js';
-import { createFrameworkLogger } from '../logger/index.js';
-import { createUserRequire, isPackageAvailable } from '../utilities/package-utils.js';
-import {
-  ValidationSchema,
-  normalizeValidationError,
-  InferSchemaType,
-  ValidationError,
-} from './schema-interface.js';
-
-const logger = createFrameworkLogger('Validation');
-
-// Convenience re-export of Zod (optional - only works if zod is installed)
-// Lazy-loads Zod synchronously on first access
-// If zod is not installed, z will throw a helpful error
-let zodModule: any = null;
-let zodLoadAttempted = false;
-
-function loadZodSync() {
-  if (zodLoadAttempted) {
-    return zodModule;
-  }
-
-  zodLoadAttempted = true;
-
-  try {
-    if (!isPackageAvailable('zod')) {
-      zodModule = null;
-      return zodModule;
-    }
-
-    // Use synchronous require for immediate availability
-    const userRequire = createUserRequire();
-    zodModule = userRequire('zod');
-  } catch {
-    // Zod not installed or failed to load
-    zodModule = null;
-  }
-
-  return zodModule;
-}
-
-export const z = new Proxy({} as any, {
-  get(_target, prop) {
-    const zod = loadZodSync();
-
-    if (!zod) {
-      throw new Error(
-        'Zod is not installed. Please install it with: npm install zod\n' +
-          'Or use an alternative validation library (joi, yup, class-validator) via adapters.'
-      );
-    }
-
-    if (!zod.z) {
-      throw new Error(
-        'Zod module loaded but z export not found. This may be a version compatibility issue.'
-      );
-    }
-
-    return zod.z[prop];
-  },
-  apply(_target, thisArg, args) {
-    const zod = loadZodSync();
-
-    if (!zod?.z) {
-      throw new Error('Zod is not installed. Please install it with: npm install zod');
-    }
-
-    return zod.z.apply(thisArg, args);
-  },
-});
-
-// Universal validation configuration interface
-export interface ValidationConfig {
-  body?: ValidationSchema;
-  query?: ValidationSchema;
-  params?: ValidationSchema;
-  headers?: ValidationSchema;
-}
-
-// Validation result types
-export interface ValidationResult<T = any> {
-  success: boolean;
-  data?: T;
-  errors?: ValidationErrorDetail[];
-}
-
-export interface ValidationErrorDetail {
-  field: string;
-  message: string;
-  code: string;
-}
-
-// Enhanced request type with validated data
-export interface ValidatedRequest<T = any> extends HttpRequest {
-  validatedBody?: T;
-  validatedQuery?: any;
-  validatedParams?: any;
-  validatedHeaders?: any;
-}
-
-// Main validation wrapper function
-export function validate<TBody = any, TQuery = any, TParams = any>(
-  config: ValidationConfig,
-  handler: (req: ValidatedRequest<TBody>, res: HttpResponse) => any | Promise<any>
-) {
-  return async (req: HttpRequest, res: HttpResponse): Promise<any> => {
-    try {
-      const validatedReq = req as ValidatedRequest<TBody>;
-
-      // Validate body
-      if (config.body) {
-        const result = await validateField(config.body, req.body, 'body');
-        if (!result.success) {
-          return sendValidationError(res, result.errors!, 'body');
-        }
-        validatedReq.validatedBody = result.data;
-        validatedReq.body = result.data; // Also update original body for compatibility
-      }
-
-      // Validate query parameters
-      if (config.query) {
-        const result = await validateField(config.query, req.query, 'query');
-        if (!result.success) {
-          return sendValidationError(res, result.errors!, 'query');
-        }
-        validatedReq.validatedQuery = result.data;
-        validatedReq.query = result.data; // Also update original query for compatibility
-      }
-
-      // Validate path parameters
-      if (config.params) {
-        const result = await validateField(config.params, req.params, 'params');
-        if (!result.success) {
-          return sendValidationError(res, result.errors!, 'params');
-        }
-        validatedReq.validatedParams = result.data;
-        validatedReq.params = result.data; // Also update original params for compatibility
-      }
-
-      // Validate headers
-      if (config.headers) {
-        const result = await validateField(config.headers, req.headers, 'headers');
-        if (!result.success) {
-          return sendValidationError(res, result.errors!, 'headers');
-        }
-        validatedReq.validatedHeaders = result.data;
-      }
-
-      logger.debug('Request validation passed', 'ValidationSuccess', {
-        path: req.path,
-        method: req.method,
-        validatedFields: Object.keys(config),
-      });
-
-      // Execute the handler with validated request
-      return await handler(validatedReq, res);
-    } catch (error) {
-      logger.error('Validation wrapper error', 'ValidationError', {
-        error: error instanceof Error ? error.message : String(error),
-        path: req.path,
-        method: req.method,
-      });
-
-      if (!res.headersSent) {
-        res.status(500).json({
-          success: false,
-          error: 'Internal validation error',
-          requestId: req.requestId,
-        });
-      }
-    }
-  };
-}
-
-// Validate individual field using universal schema interface
-async function validateField(
-  schema: ValidationSchema,
-  data: any,
-  fieldName: string
-): Promise<ValidationResult> {
-  try {
-    const validated = await schema.parseAsync(data);
-    return {
-      success: true,
-      data: validated,
-    };
-  } catch (error) {
-    const normalizedError = normalizeValidationError(error);
-    const errors: ValidationErrorDetail[] = normalizedError.issues.map(issue => ({
-      field: issue.path.length > 0 ? issue.path.join('.') : fieldName,
-      message: issue.message,
-      code: issue.code,
-    }));
-
-    logger.debug('Field validation failed', 'ValidationFailed', {
-      field: fieldName,
-      errors: errors.length,
-      details: errors,
-    });
-
-    return {
-      success: false,
-      errors,
-    };
-  }
-}
-
-// Send validation error response
-function sendValidationError(
-  res: HttpResponse,
-  errors: ValidationErrorDetail[],
-  field: string
-): void {
-  logger.debug('Sending validation error response', 'ValidationResponse', {
-    field,
-    errorCount: errors.length,
-  });
-
-  res.status(400).json({
-    success: false,
-    error: `Validation failed for ${field}`,
-    details: errors,
-    requestId: (res as any).req?.requestId,
-  });
-}
-
-// Convenience functions for single-field validation
-export function body<T>(schema: ValidationSchema<T>) {
-  return (handler: (req: ValidatedRequest<T>, res: HttpResponse) => any | Promise<any>) => {
-    return validate({ body: schema }, handler);
-  };
-}
-
-export function query<T>(schema: ValidationSchema<T>) {
-  return (handler: (req: ValidatedRequest<any>, res: HttpResponse) => any | Promise<any>) => {
-    return validate({ query: schema }, handler);
-  };
-}
-
-export function params<T>(schema: ValidationSchema<T>) {
-  return (handler: (req: ValidatedRequest<any>, res: HttpResponse) => any | Promise<any>) => {
-    return validate({ params: schema }, handler);
-  };
-}
-
-// Schema composition helpers
-export function combineSchemas(schemas: ValidationConfig): ValidationConfig {
-  return schemas;
-}
-
-// Re-export common validation tools
-export { ValidationError, normalizeValidationError } from './schema-interface.js';
-export type { ValidationSchema, InferSchemaType } from './schema-interface.js';
-export { joi, yup, fn as customValidator, classValidator } from './adapters.js';