@morojs/moro 1.6.1 → 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';
-import { createFrameworkLogger } from '../logger';
-
-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';

package/src/core/utilities/index.ts

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

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';
-
-/**
- * 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,206 +0,0 @@
-// Universal Validation System for Moro Framework
-// Works with Zod, Joi, Yup, and any validation library via adapters
-
-import { HttpRequest, HttpResponse } from '../http';
-import { createFrameworkLogger } from '../logger';
-import {
-  ValidationSchema,
-  ValidationError,
-  normalizeValidationError,
-  InferSchemaType,
-} from './schema-interface';
-
-// Re-export zod if available (for backward compatibility)
-// The dynamic import is handled in the main index.ts
-
-const logger = createFrameworkLogger('Validation');
-
-// 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 {
-  ValidationSchema,
-  ValidationError,
-  normalizeValidationError,
-  InferSchemaType,
-} from './schema-interface';
-export { joi, yup, fn as customValidator, classValidator } from './adapters';
-
-// Note: z is re-exported from main index.ts with dynamic import

package/src/core/validation/schema-interface.ts

@@ -1,100 +0,0 @@
-// Universal Validation Schema Interface for Moro Framework
-// Allows Zod, Joi, Yup, and other validation libraries to work seamlessly
-
-/**
- * Standard validation error structure
- */
-export interface ValidationIssue {
-  path: (string | number)[];
-  message: string;
-  code: string;
-}
-
-/**
- * Standard validation error class
- * Compatible with ZodError structure
- */
-export class ValidationError extends Error {
-  public readonly issues: ValidationIssue[];
-
-  constructor(issues: ValidationIssue[]) {
-    const message = `Validation failed: ${issues.map(i => i.message).join(', ')}`;
-    super(message);
-    this.name = 'ValidationError';
-    this.issues = issues;
-  }
-}
-
-/**
- * Universal validation schema interface
- * This is what Zod naturally implements! No breaking changes needed.
- */
-export interface ValidationSchema<T = any> {
-  /**
-   * Parse data asynchronously and return validated result
-   * Throws ValidationError on validation failure
-   */
-  parseAsync(data: unknown): Promise<T>;
-}
-
-/**
- * Check if an object implements the ValidationSchema interface
- */
-export function isValidationSchema(obj: any): obj is ValidationSchema {
-  return obj && typeof obj.parseAsync === 'function';
-}
-
-/**
- * Convert various error formats to our standard ValidationError
- */
-export function normalizeValidationError(error: any): ValidationError {
-  // Already our format
-  if (error instanceof ValidationError) {
-    return error;
-  }
-
-  // Zod error format
-  if (error && error.issues && Array.isArray(error.issues)) {
-    return new ValidationError(
-      error.issues.map((issue: any) => ({
-        path: issue.path || [],
-        message: issue.message || 'Validation failed',
-        code: issue.code || 'invalid',
-      }))
-    );
-  }
-
-  // Joi error format
-  if (error && error.details && Array.isArray(error.details)) {
-    return new ValidationError(
-      error.details.map((detail: any) => ({
-        path: detail.path || [],
-        message: detail.message || 'Validation failed',
-        code: detail.type || 'invalid',
-      }))
-    );
-  }
-
-  // Yup error format
-  if (error && error.errors && Array.isArray(error.errors)) {
-    return new ValidationError(
-      error.errors.map((msg: string, index: number) => ({
-        path: error.path ? [error.path] : [index],
-        message: msg,
-        code: error.type || 'invalid',
-      }))
-    );
-  }
-
-  // Generic error
-  return new ValidationError([
-    {
-      path: [],
-      message: error.message || String(error),
-      code: 'unknown',
-    },
-  ]);
-}
-
-// Type helper for inferring types from validation schemas
-export type InferSchemaType<T> = T extends ValidationSchema<infer U> ? U : never;