@morojs/moro 1.5.17 → 1.6.0

package/src/core/networking/adapters/ws-adapter.ts

@@ -1,6 +1,7 @@
 // Native WebSocket Adapter for Moro Framework
 // Implements the WebSocket adapter interface using the 'ws' library
 
+import { resolveUserPackage } from '../../utilities/package-utils.js';
 import {
   WebSocketAdapter,
   WebSocketAdapterOptions,
@@ -8,8 +9,8 @@ import {
   WebSocketConnection,
   WebSocketEmitter,
   WebSocketMiddleware,
-} from '../websocket-adapter';
-import { createFrameworkLogger } from '../../logger';
+} from '../websocket-adapter.js';
+import { createFrameworkLogger } from '../../logger/index.js';
 
 /**
  * Native WebSocket adapter using the 'ws' library
@@ -25,8 +26,9 @@ export class WSAdapter implements WebSocketAdapter {
 
   async initialize(httpServer: any, options: WebSocketAdapterOptions = {}): Promise<void> {
     try {
-      // Dynamic import to avoid requiring ws as a hard dependency
-      const { WebSocketServer } = await import('ws');
+      // Dynamic import from user's context to find their installed ws library
+      const wsPath = resolveUserPackage('ws');
+      const { WebSocketServer } = await import(wsPath);
 
       this.wss = new WebSocketServer({
         server: httpServer,

package/src/core/networking/index.ts

@@ -1,3 +1,4 @@
 // Networking System - Centralized Exports
-export { WebSocketManager } from './websocket-manager';
-export { ServiceRegistry, ServiceInfo, ServiceDiscoveryOptions } from './service-discovery';
+export { WebSocketManager } from './websocket-manager.js';
+export { ServiceRegistry } from './service-discovery.js';
+export type { ServiceInfo, ServiceDiscoveryOptions } from './service-discovery.js';

package/src/core/networking/service-discovery.ts

@@ -1,6 +1,6 @@
 // Service Discovery Client for Microservices
 // Supports Consul, Kubernetes, and in-memory registry
-import { createFrameworkLogger } from '../logger';
+import { createFrameworkLogger } from '../logger/index.js';
 
 export interface ServiceInfo {
   name: string;

package/src/core/networking/websocket-manager.ts

@@ -1,10 +1,12 @@
 // WebSocket Manager for Moro Framework
 // Manages WebSocket connections using pluggable adapters
-import { Container } from '../utilities';
-import { CircuitBreaker } from '../utilities';
-import { ModuleConfig, WebSocketDefinition } from '../../types/module';
-import { WebSocketAdapter, WebSocketNamespace, WebSocketConnection } from './websocket-adapter';
-import { createFrameworkLogger } from '../logger';
+import * as zlib from 'zlib';
+import { Container } from '../utilities/index.js';
+import { CircuitBreaker } from '../utilities/index.js';
+import { ModuleConfig, WebSocketDefinition } from '../../types/module.js';
+import { WebSocketAdapter, WebSocketNamespace, WebSocketConnection } from './websocket-adapter.js';
+import { createFrameworkLogger } from '../logger/index.js';
+import { normalizeValidationError } from '../validation/schema-interface.js';
 
 export class WebSocketManager {
   private circuitBreakers = new Map<string, CircuitBreaker>();
@@ -134,7 +136,6 @@ export class WebSocketManager {
             data = await wsConfig.validation.parseAsync(data);
           } catch (validationError: any) {
             // Handle universal validation errors
-            const { normalizeValidationError } = require('../validation/schema-interface');
             const normalizedError = normalizeValidationError(validationError);
             const error = {
               success: false,
@@ -264,7 +265,6 @@ export class WebSocketManager {
     if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
       // This is gzipped data
       try {
-        const zlib = require('zlib');
         return zlib.gunzipSync(buffer);
       } catch {
         return buffer;

package/src/core/routing/app-integration.ts

@@ -8,9 +8,9 @@ import {
   createRoute,
   defineRoute,
   HttpMethod,
-} from './index';
-import { HttpRequest, HttpResponse } from '../http';
-import { createFrameworkLogger } from '../logger';
+} from './index.js';
+import { HttpRequest, HttpResponse } from '../http/index.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('AppIntegration');
 

package/src/core/routing/index.ts

@@ -1,9 +1,9 @@
 // Intelligent Routing System for Moro Framework
 // Schema-first with automatic middleware ordering and chainable API
 
-import { ValidationSchema } from '../validation/schema-interface';
-import { HttpRequest, HttpResponse } from '../http';
-import { createFrameworkLogger } from '../logger';
+import { ValidationSchema } from '../validation/schema-interface.js';
+import { HttpRequest, HttpResponse } from '../http/index.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 const logger = createFrameworkLogger('IntelligentRouting');
 

package/src/core/runtime/aws-lambda-adapter.ts

@@ -1,7 +1,7 @@
 // AWS Lambda runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter';
-import { HttpRequest, HttpResponse } from '../../types/http';
-import { RuntimeHttpResponse } from '../../types/runtime';
+import { BaseRuntimeAdapter } from './base-adapter.js';
+import { HttpRequest, HttpResponse } from '../../types/http.js';
+import { RuntimeHttpResponse } from '../../types/runtime.js';
 
 export interface LambdaEvent {
   httpMethod: string;

package/src/core/runtime/base-adapter.ts

@@ -1,6 +1,6 @@
 // Base runtime adapter with common functionality
-import { RuntimeAdapter, RuntimeType, RuntimeHttpResponse } from '../../types/runtime';
-import { HttpRequest, HttpResponse } from '../../types/http';
+import { RuntimeAdapter, RuntimeType, RuntimeHttpResponse } from '../../types/runtime.js';
+import { HttpRequest, HttpResponse } from '../../types/http.js';
 import { randomBytes } from 'crypto';
 
 export abstract class BaseRuntimeAdapter implements RuntimeAdapter {

package/src/core/runtime/cloudflare-workers-adapter.ts

@@ -1,7 +1,7 @@
 // Cloudflare Workers runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter';
-import { HttpRequest, HttpResponse } from '../../types/http';
-import { RuntimeHttpResponse } from '../../types/runtime';
+import { BaseRuntimeAdapter } from './base-adapter.js';
+import { HttpRequest, HttpResponse } from '../../types/http.js';
+import { RuntimeHttpResponse } from '../../types/runtime.js';
 
 export interface WorkersEnv {
   [key: string]: any;

package/src/core/runtime/index.ts

@@ -1,9 +1,9 @@
 // Runtime adapters export
-export { BaseRuntimeAdapter } from './base-adapter';
-export { NodeRuntimeAdapter } from './node-adapter';
-export { VercelEdgeAdapter } from './vercel-edge-adapter';
-export { AWSLambdaAdapter } from './aws-lambda-adapter';
-export { CloudflareWorkersAdapter } from './cloudflare-workers-adapter';
+export { BaseRuntimeAdapter } from './base-adapter.js';
+export { NodeRuntimeAdapter } from './node-adapter.js';
+export { VercelEdgeAdapter } from './vercel-edge-adapter.js';
+export { AWSLambdaAdapter } from './aws-lambda-adapter.js';
+export { CloudflareWorkersAdapter } from './cloudflare-workers-adapter.js';
 
 // Re-export types
 export type {
@@ -12,18 +12,18 @@ export type {
   RuntimeConfig,
   RuntimeMoroOptions,
   RuntimeHttpResponse,
-} from '../../types/runtime';
+} from '../../types/runtime.js';
 
 // Re-export specific runtime types
-export type { LambdaEvent, LambdaContext, LambdaResponse } from './aws-lambda-adapter';
-export type { WorkersEnv, WorkersContext } from './cloudflare-workers-adapter';
+export type { LambdaEvent, LambdaContext, LambdaResponse } from './aws-lambda-adapter.js';
+export type { WorkersEnv, WorkersContext } from './cloudflare-workers-adapter.js';
 
 // Runtime factory functions
-import { NodeRuntimeAdapter } from './node-adapter';
-import { VercelEdgeAdapter } from './vercel-edge-adapter';
-import { AWSLambdaAdapter } from './aws-lambda-adapter';
-import { CloudflareWorkersAdapter } from './cloudflare-workers-adapter';
-import { RuntimeType, RuntimeAdapter } from '../../types/runtime';
+import { NodeRuntimeAdapter } from './node-adapter.js';
+import { VercelEdgeAdapter } from './vercel-edge-adapter.js';
+import { AWSLambdaAdapter } from './aws-lambda-adapter.js';
+import { CloudflareWorkersAdapter } from './cloudflare-workers-adapter.js';
+import { RuntimeType, RuntimeAdapter } from '../../types/runtime.js';
 
 export function createRuntimeAdapter(type: RuntimeType): RuntimeAdapter {
   switch (type) {

package/src/core/runtime/node-adapter.ts

@@ -1,9 +1,9 @@
 // Node.js runtime adapter
 import { IncomingMessage, ServerResponse } from 'http';
-import { BaseRuntimeAdapter } from './base-adapter';
-import { HttpRequest, HttpResponse } from '../../types/http';
-import { RuntimeHttpResponse } from '../../types/runtime';
-import { MoroHttpServer } from '../http/http-server';
+import { BaseRuntimeAdapter } from './base-adapter.js';
+import { HttpRequest, HttpResponse } from '../../types/http.js';
+import { RuntimeHttpResponse } from '../../types/runtime.js';
+import { MoroHttpServer } from '../http/http-server.js';
 
 export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
   readonly type = 'node' as const;

package/src/core/runtime/vercel-edge-adapter.ts

@@ -1,7 +1,7 @@
 // Vercel Edge runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter';
-import { HttpRequest, HttpResponse } from '../../types/http';
-import { RuntimeHttpResponse } from '../../types/runtime';
+import { BaseRuntimeAdapter } from './base-adapter.js';
+import { HttpRequest, HttpResponse } from '../../types/http.js';
+import { RuntimeHttpResponse } from '../../types/runtime.js';
 
 export class VercelEdgeAdapter extends BaseRuntimeAdapter {
   readonly type = 'vercel-edge' as const;

package/src/core/utilities/hooks.ts

@@ -1,7 +1,7 @@
 // Hook System for Moro
 import { EventEmitter } from 'events';
-import { HookFunction, HookContext, MoroMiddleware } from '../../types/hooks';
-import { createFrameworkLogger } from '../logger';
+import { HookFunction, HookContext, MoroMiddleware } from '../../types/hooks.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 export const HOOK_EVENTS = {
   BEFORE_REQUEST: 'before:request',
@@ -139,4 +139,4 @@ export class HookManager extends EventEmitter {
 }
 
 // Built-in middleware - now organized in individual files
-export { simpleMiddleware as middleware } from '../middleware/index';
+export { simpleMiddleware as middleware } from '../middleware/index.js';

package/src/core/utilities/index.ts

@@ -8,9 +8,10 @@ export {
   withCaching,
   withRetry,
   withTimeout,
-} from './container';
-export { CircuitBreaker } from './circuit-breaker';
-export { HookManager, HOOK_EVENTS } from './hooks';
+} 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';
+export { middleware } from './hooks.js';

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

@@ -0,0 +1,59 @@
+// 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,7 +1,7 @@
 // Validation Library Adapters for Moro Framework
 // Makes Joi, Yup, and other libraries compatible with ValidationSchema interface
 
-import { ValidationSchema, ValidationError, normalizeValidationError } from './schema-interface';
+import { ValidationSchema, ValidationError, normalizeValidationError } from './schema-interface.js';
 
 /**
  * Zod Compatibility Check

package/src/core/validation/index.ts

@@ -1,20 +1,78 @@
 // 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 { HttpRequest, HttpResponse } from '../http/index.js';
+import { createFrameworkLogger } from '../logger/index.js';
+import { createUserRequire, isPackageAvailable } from '../utilities/package-utils.js';
 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
+  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;
@@ -195,12 +253,6 @@ export function combineSchemas(schemas: ValidationConfig): ValidationConfig {
 }
 
 // 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
+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';