@morojs/moro 1.6.0 → 1.6.1

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@morojs/moro",
-  "version": "1.6.0",
-  "description": "High-performance Node.js framework with intelligent routing, automatic middleware ordering, enterprise authentication (Auth.js), type-safe validation, and functional architecture",
-  "type": "module",
+  "version": "1.6.1",
+  "description": "High-performance Node.js framework with intelligent routing, automatic middleware ordering, enterprise authentication (Auth.js), type-safe Zod validation, and functional architecture",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "development": "./src/index.ts",
       "import": "./dist/index.js",
+      "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
@@ -29,22 +29,20 @@
     "test:ci": "jest --coverage --watchAll=false --ci --forceExit",
     "test:force": "jest --forceExit",
     "test:all": "npm run test:unit && npm run test:integration && npm run test:e2e",
-    "test:dist": "npm run build && node scripts/validate-dist.mjs",
-    "test:package": "npm run build && node scripts/validate-package.mjs",
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
     "lint-staged": "lint-staged",
     "docs:build": "typedoc --out docs-html src/index.ts",
     "docs:serve": "http-server docs-html -p 8080",
     "docs:json": "typedoc --json docs-json/api.json src/index.ts",
     "docs:markdown": "typedoc --plugin typedoc-plugin-markdown --out docs-md src/index.ts",
     "docs:all": "npm run docs:build && npm run docs:json && npm run docs:markdown",
-    "prerelease": "npm run build && npm test && npm run test:package && node scripts/release.js",
-    "prerelease:patch": "npm run build && npm test && npm run test:package && node scripts/release.js patch",
-    "prerelease:minor": "npm run build && npm test && npm run test:package && node scripts/release.js minor",
-    "prerelease:major": "npm run build && npm test && npm run test:package && node scripts/release.js major"
+    "prerelease": "node scripts/release.js",
+    "prerelease:patch": "node scripts/release.js patch",
+    "prerelease:minor": "node scripts/release.js minor",
+    "prerelease:major": "node scripts/release.js major"
   },
   "keywords": [
     "nodejs",
@@ -91,9 +89,8 @@
     "pg": "^8.16.3",
     "socket.io": "^4.8.1",
     "swagger-ui-dist": "^5.28.1",
-    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.0",
     "ws": "^8.18.0",
-    "yup": "^1.7.1"
+    "yup": "^1.0.0"
   },
   "peerDependenciesMeta": {
     "@auth/core": {
@@ -123,9 +120,6 @@
     "socket.io": {
       "optional": true
     },
-    "uWebSockets.js": {
-      "optional": true
-    },
     "ws": {
       "optional": true
     },
@@ -171,7 +165,6 @@
     "typedoc-plugin-markdown": "^4.8.1",
     "typedoc-theme-hierarchy": "^6.0.0",
     "typescript": "^5.9.2",
-    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.0",
     "ws": "^8.18.3",
     "zod": "^4.1.8"
   },
@@ -181,9 +174,49 @@
     "README.md",
     "LICENSE",
     "API.md",
-    "tsconfig.json",
-    "jest.config.mjs"
+    "tsconfig.json"
   ],
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/src",
+      "<rootDir>/tests"
+    ],
+    "testMatch": [
+      "**/tests/**/*.test.ts",
+      "**/src/**/*.test.ts"
+    ],
+    "transform": {
+      "^.+\\.ts$": [
+        "ts-jest",
+        {}
+      ]
+    },
+    "collectCoverageFrom": [
+      "src/**/*.ts",
+      "!src/**/*.d.ts",
+      "!src/**/*.test.ts",
+      "!src/**/index.ts"
+    ],
+    "coverageDirectory": "coverage",
+    "coverageReporters": [
+      "text",
+      "lcov",
+      "html"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/tests/setup.ts"
+    ],
+    "testTimeout": 15000,
+    "maxWorkers": 1,
+    "forceExit": false,
+    "detectOpenHandles": true,
+    "openHandlesTimeout": 1000,
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ]
+  },
   "lint-staged": {
     "src/**/*.ts": [
       "prettier --write",

package/src/core/auth/morojs-adapter.ts

@@ -8,9 +8,7 @@
  * @see https://github.com/nextauthjs/next-auth/tree/main/packages
  */
 
-import { createFrameworkLogger } from '../logger/index.js';
-
-const logger = createFrameworkLogger('AuthAdapter');
+import { logger } from '../logger';
 
 // Mock Auth.js types until we have the actual package
 // These would come from @auth/core in a real implementation
@@ -251,7 +249,7 @@ export async function MoroJSAuth(config: MoroJSAuthConfig): Promise<{
           basePath,
           raw: (code: any, ...message: any[]) => {
             if (config.morojs?.debug) {
-              logger.debug(`[MoroJS Auth] ${code}:`, 'AuthAdapter', { message });
+              logger.debug(`[MoroJS Auth] ${code}:`, 'AuthAdapter', { code, message });
             }
           },
         });
@@ -265,7 +263,7 @@ export async function MoroJSAuth(config: MoroJSAuthConfig): Promise<{
         // Convert Web API response to MoroJS response
         await fromWebResponse(finalResponse, res);
       } catch (error) {
-        logger.error('[MoroJS Auth] Error', 'AuthAdapter', {
+        logger.error('[MoroJS Auth] Error:', 'AuthAdapter', {
           error: error instanceof Error ? error.message : String(error),
         });
         // Robust error handling - check if response methods exist
@@ -314,7 +312,7 @@ export async function MoroJSAuth(config: MoroJSAuthConfig): Promise<{
         return null;
       } catch (error) {
         if (config.morojs?.debug) {
-          logger.error('[MoroJS Auth] Session error', 'AuthAdapter', {
+          logger.error('[MoroJS Auth] Session error:', 'AuthAdapter', {
             error: error instanceof Error ? error.message : String(error),
           });
         }
@@ -330,21 +328,18 @@ export async function MoroJSAuth(config: MoroJSAuthConfig): Promise<{
  * This creates a MoroJS-compatible middleware for authentication
  */
 export function createAuthMiddleware(config: MoroJSAuthConfig) {
-  logger.info('createAuthMiddleware called - creating middleware function', 'AuthAdapter');
+  logger.info('🏭 createAuthMiddleware called - creating middleware function', 'AuthAdapter');
   // Return a function that MoroJS can call directly
   return async (app: any) => {
-    logger.info('Installing Auth.js middleware...', 'AuthAdapter');
-    logger.debug('App object received', 'AuthAdapter', {
-      appType: typeof app,
-      appConstructor: app.constructor.name,
-    });
+    logger.info('🔧 Installing Auth.js middleware...', 'AuthAdapter');
+    logger.info(`📦 App object received: ${typeof app} ${app.constructor.name}`, 'AuthAdapter');
 
     // Get the hooks from the app's middleware system
     const hooks =
       (app as any).coreFramework?.middlewareManager?.hooks || (app as any).middlewareManager?.hooks;
 
     if (!hooks) {
-      logger.error('Could not access MoroJS hooks system', 'AuthAdapter');
+      logger.error('❌ Could not access MoroJS hooks system', 'AuthAdapter');
       return;
     }
 
@@ -355,9 +350,9 @@ export function createAuthMiddleware(config: MoroJSAuthConfig) {
 
     // Register request hook
     hooks.before('request', async (context: any) => {
-      logger.debug('Native adapter hook starting', 'AuthAdapter');
+      logger.debug('🔒 Native adapter hook starting...', 'AuthAdapter');
       const req = context.request;
-      logger.debug('Request path', 'AuthAdapter', { path: req.path || req.url });
+      logger.debug(`📝 Request path: ${req.path || req.url}`, 'AuthAdapter');
 
       try {
         // Just add auth object to request - don't touch response
@@ -394,16 +389,16 @@ export function createAuthMiddleware(config: MoroJSAuthConfig) {
             return { url: signOutUrl };
           },
         };
-        logger.debug('Native adapter hook completed successfully', 'AuthAdapter');
+        logger.debug('✅ Native adapter hook completed successfully', 'AuthAdapter');
       } catch (error) {
-        logger.error('Error in native adapter hook', 'AuthAdapter', {
+        logger.error('❌ Error in native adapter hook:', 'AuthAdapter', {
           error: error instanceof Error ? error.message : String(error),
         });
         throw error;
       }
     });
 
-    logger.info('Auth.js middleware installed successfully!', 'AuthAdapter');
+    logger.info('✅ Auth.js middleware installed successfully!', 'AuthAdapter');
   };
 }
 

package/src/core/config/file-loader.ts

@@ -1,16 +1,11 @@
 // Configuration File Loader - Load moro.config.js/ts files
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { createRequire } from 'module';
-import { AppConfig } from './schema.js';
-import { createFrameworkLogger } from '../logger/index.js';
+import { AppConfig } from './schema';
+import { createFrameworkLogger } from '../logger';
 
 const logger = createFrameworkLogger('ConfigFile');
 
-// Create require function for ESM to enable synchronous config loading
-// Use process.cwd() as base since we're loading with absolute paths anyway
-const moduleRequire = createRequire(join(process.cwd(), 'index.js'));
-
 /**
  * Supported configuration file names in order of preference
  */
@@ -28,23 +23,55 @@ export function loadConfigFileSync(cwd: string = process.cwd()): Partial<AppConf
     logger.debug('No configuration file found');
     return null;
   }
+  // Handle TypeScript files by trying dynamic import (works with tsx/ts-node runtimes)
+  if (configFile.endsWith('.ts')) {
+    logger.debug('Found TypeScript config file, attempting to load with dynamic import');
+    try {
+      // When running under tsx/ts-node, dynamic imports work synchronously for TypeScript
+      // We can use require() with the current environment that already has TypeScript support
+      const config = require(configFile);
+      const configData = config.default || config;
+
+      if (!configData || typeof configData !== 'object') {
+        logger.warn(`Configuration file ${configFile} did not export a valid configuration object`);
+        return null;
+      }
+
+      logger.info(`TypeScript configuration loaded from: ${configFile}`);
+      return configData;
+    } catch (error) {
+      logger.debug(
+        'TypeScript config loading failed in sync mode, this is expected if not running with tsx/ts-node'
+      );
+      logger.debug('Error details:', String(error));
+      return null;
+    }
+  }
+
+  // Only .js files use the standard synchronous loading
+  if (!configFile.endsWith('.js')) {
+    logger.debug(
+      'Found config file with unsupported extension. Only .js and .ts files are supported.'
+    );
+    return null;
+  }
 
   logger.debug(`Loading configuration from: ${configFile}`);
 
   try {
-    // Use createRequire to enable synchronous loading in ESM
-    // Clear the require cache to ensure fresh config on each load
-    delete moduleRequire.cache[moduleRequire.resolve(configFile)];
+    // Clear module cache to ensure fresh load
+    delete require.cache[require.resolve(configFile)];
 
-    const config = moduleRequire(configFile);
+    const config = require(configFile);
+    const configData = config.default || config;
 
-    if (!config || typeof config !== 'object') {
+    if (!configData || typeof configData !== 'object') {
       logger.warn(`Configuration file ${configFile} did not export a valid configuration object`);
       return null;
     }
 
     logger.info(`Configuration loaded from: ${configFile}`);
-    return config;
+    return configData;
   } catch (error) {
     logger.error(`Failed to load configuration file ${configFile}:`, String(error));
     logger.warn('Falling back to environment variable configuration');
@@ -145,3 +172,236 @@ async function setupTypeScriptLoader(): Promise<void> {
   // the TypeScript transpilation is already handled by those tools.
   logger.debug('TypeScript config loading delegated to runtime environment');
 }
+
+/**
+ * Convert a configuration object to environment variable mappings
+ * This function flattens the config object and sets corresponding environment variables
+ */
+export function applyConfigAsEnvironmentVariables(config: Partial<AppConfig>): void {
+  if (!config || typeof config !== 'object') {
+    return;
+  }
+
+  // Apply server configuration
+  if (config.server) {
+    setEnvIfNotSet('PORT', config.server.port?.toString());
+    setEnvIfNotSet('HOST', config.server.host);
+    setEnvIfNotSet('NODE_ENV', config.server.environment);
+    setEnvIfNotSet('MAX_CONNECTIONS', config.server.maxConnections?.toString());
+    setEnvIfNotSet('REQUEST_TIMEOUT', config.server.timeout?.toString());
+  }
+
+  // Apply database configuration
+  if (config.database) {
+    setEnvIfNotSet('DATABASE_URL', config.database.url);
+
+    if (config.database.redis) {
+      setEnvIfNotSet('REDIS_URL', config.database.redis.url);
+      setEnvIfNotSet('REDIS_MAX_RETRIES', config.database.redis.maxRetries?.toString());
+      setEnvIfNotSet('REDIS_RETRY_DELAY', config.database.redis.retryDelay?.toString());
+      setEnvIfNotSet('REDIS_KEY_PREFIX', config.database.redis.keyPrefix);
+    }
+
+    if (config.database.mysql) {
+      setEnvIfNotSet('MYSQL_HOST', config.database.mysql.host);
+      setEnvIfNotSet('MYSQL_PORT', config.database.mysql.port?.toString());
+      setEnvIfNotSet('MYSQL_DATABASE', config.database.mysql.database);
+      setEnvIfNotSet('MYSQL_USERNAME', config.database.mysql.username);
+      setEnvIfNotSet('MYSQL_PASSWORD', config.database.mysql.password);
+      setEnvIfNotSet('MYSQL_CONNECTION_LIMIT', config.database.mysql.connectionLimit?.toString());
+      setEnvIfNotSet('MYSQL_ACQUIRE_TIMEOUT', config.database.mysql.acquireTimeout?.toString());
+      setEnvIfNotSet('MYSQL_TIMEOUT', config.database.mysql.timeout?.toString());
+    }
+  }
+
+  // Apply service discovery configuration
+  if (config.serviceDiscovery) {
+    setEnvIfNotSet('SERVICE_DISCOVERY_ENABLED', config.serviceDiscovery.enabled?.toString());
+    setEnvIfNotSet('DISCOVERY_TYPE', config.serviceDiscovery.type);
+    setEnvIfNotSet('CONSUL_URL', config.serviceDiscovery.consulUrl);
+    setEnvIfNotSet('K8S_NAMESPACE', config.serviceDiscovery.kubernetesNamespace);
+    setEnvIfNotSet(
+      'HEALTH_CHECK_INTERVAL',
+      config.serviceDiscovery.healthCheckInterval?.toString()
+    );
+    setEnvIfNotSet('DISCOVERY_RETRY_ATTEMPTS', config.serviceDiscovery.retryAttempts?.toString());
+  }
+
+  // Apply logging configuration
+  if (config.logging) {
+    setEnvIfNotSet('LOG_LEVEL', config.logging.level);
+    setEnvIfNotSet('LOG_FORMAT', config.logging.format);
+    setEnvIfNotSet('LOG_COLORS', config.logging.enableColors?.toString());
+    setEnvIfNotSet('LOG_TIMESTAMP', config.logging.enableTimestamp?.toString());
+    setEnvIfNotSet('LOG_CONTEXT', config.logging.enableContext?.toString());
+
+    if (config.logging.outputs) {
+      setEnvIfNotSet('LOG_CONSOLE', config.logging.outputs.console?.toString());
+
+      if (config.logging.outputs.file) {
+        setEnvIfNotSet('LOG_FILE_ENABLED', config.logging.outputs.file.enabled?.toString());
+        setEnvIfNotSet('LOG_FILE_PATH', config.logging.outputs.file.path);
+        setEnvIfNotSet('LOG_FILE_MAX_SIZE', config.logging.outputs.file.maxSize);
+        setEnvIfNotSet('LOG_FILE_MAX_FILES', config.logging.outputs.file.maxFiles?.toString());
+      }
+
+      if (config.logging.outputs.webhook) {
+        setEnvIfNotSet('LOG_WEBHOOK_ENABLED', config.logging.outputs.webhook.enabled?.toString());
+        setEnvIfNotSet('LOG_WEBHOOK_URL', config.logging.outputs.webhook.url);
+        if (config.logging.outputs.webhook.headers) {
+          setEnvIfNotSet(
+            'LOG_WEBHOOK_HEADERS',
+            JSON.stringify(config.logging.outputs.webhook.headers)
+          );
+        }
+      }
+    }
+  }
+
+  // Apply module defaults
+  if (config.modules) {
+    if (config.modules.cache) {
+      setEnvIfNotSet('CACHE_ENABLED', config.modules.cache.enabled?.toString());
+      setEnvIfNotSet('DEFAULT_CACHE_TTL', config.modules.cache.defaultTtl?.toString());
+      setEnvIfNotSet('CACHE_MAX_SIZE', config.modules.cache.maxSize?.toString());
+      setEnvIfNotSet('CACHE_STRATEGY', config.modules.cache.strategy);
+    }
+
+    if (config.modules.rateLimit) {
+      setEnvIfNotSet('RATE_LIMIT_ENABLED', config.modules.rateLimit.enabled?.toString());
+      setEnvIfNotSet(
+        'DEFAULT_RATE_LIMIT_REQUESTS',
+        config.modules.rateLimit.defaultRequests?.toString()
+      );
+      setEnvIfNotSet(
+        'DEFAULT_RATE_LIMIT_WINDOW',
+        config.modules.rateLimit.defaultWindow?.toString()
+      );
+      setEnvIfNotSet(
+        'RATE_LIMIT_SKIP_SUCCESS',
+        config.modules.rateLimit.skipSuccessfulRequests?.toString()
+      );
+      setEnvIfNotSet(
+        'RATE_LIMIT_SKIP_FAILED',
+        config.modules.rateLimit.skipFailedRequests?.toString()
+      );
+    }
+
+    if (config.modules.validation) {
+      setEnvIfNotSet('VALIDATION_ENABLED', config.modules.validation.enabled?.toString());
+      setEnvIfNotSet(
+        'VALIDATION_STRIP_UNKNOWN',
+        config.modules.validation.stripUnknown?.toString()
+      );
+      setEnvIfNotSet('VALIDATION_ABORT_EARLY', config.modules.validation.abortEarly?.toString());
+    }
+  }
+
+  // Apply security configuration
+  if (config.security) {
+    if (config.security.cors) {
+      setEnvIfNotSet('CORS_ENABLED', config.security.cors.enabled?.toString());
+      if (typeof config.security.cors.origin === 'string') {
+        setEnvIfNotSet('CORS_ORIGIN', config.security.cors.origin);
+      } else if (Array.isArray(config.security.cors.origin)) {
+        setEnvIfNotSet('CORS_ORIGIN', config.security.cors.origin.join(','));
+      } else if (typeof config.security.cors.origin === 'boolean') {
+        setEnvIfNotSet('CORS_ORIGIN', config.security.cors.origin.toString());
+      }
+      setEnvIfNotSet('CORS_METHODS', config.security.cors.methods?.join(','));
+      setEnvIfNotSet('CORS_HEADERS', config.security.cors.allowedHeaders?.join(','));
+      setEnvIfNotSet('CORS_CREDENTIALS', config.security.cors.credentials?.toString());
+    }
+
+    if (config.security.helmet) {
+      setEnvIfNotSet('HELMET_ENABLED', config.security.helmet.enabled?.toString());
+      setEnvIfNotSet('HELMET_CSP', config.security.helmet.contentSecurityPolicy?.toString());
+      setEnvIfNotSet('HELMET_HSTS', config.security.helmet.hsts?.toString());
+      setEnvIfNotSet('HELMET_NO_SNIFF', config.security.helmet.noSniff?.toString());
+      setEnvIfNotSet('HELMET_FRAMEGUARD', config.security.helmet.frameguard?.toString());
+    }
+
+    if (config.security.rateLimit?.global) {
+      setEnvIfNotSet(
+        'GLOBAL_RATE_LIMIT_ENABLED',
+        config.security.rateLimit.global.enabled?.toString()
+      );
+      setEnvIfNotSet(
+        'GLOBAL_RATE_LIMIT_REQUESTS',
+        config.security.rateLimit.global.requests?.toString()
+      );
+      setEnvIfNotSet(
+        'GLOBAL_RATE_LIMIT_WINDOW',
+        config.security.rateLimit.global.window?.toString()
+      );
+    }
+  }
+
+  // Apply external services configuration
+  if (config.external) {
+    if (config.external.stripe) {
+      setEnvIfNotSet('STRIPE_SECRET_KEY', config.external.stripe.secretKey);
+      setEnvIfNotSet('STRIPE_PUBLISHABLE_KEY', config.external.stripe.publishableKey);
+      setEnvIfNotSet('STRIPE_WEBHOOK_SECRET', config.external.stripe.webhookSecret);
+      setEnvIfNotSet('STRIPE_API_VERSION', config.external.stripe.apiVersion);
+    }
+
+    if (config.external.paypal) {
+      setEnvIfNotSet('PAYPAL_CLIENT_ID', config.external.paypal.clientId);
+      setEnvIfNotSet('PAYPAL_CLIENT_SECRET', config.external.paypal.clientSecret);
+      setEnvIfNotSet('PAYPAL_WEBHOOK_ID', config.external.paypal.webhookId);
+      setEnvIfNotSet('PAYPAL_ENVIRONMENT', config.external.paypal.environment);
+    }
+
+    if (config.external.smtp) {
+      setEnvIfNotSet('SMTP_HOST', config.external.smtp.host);
+      setEnvIfNotSet('SMTP_PORT', config.external.smtp.port?.toString());
+      setEnvIfNotSet('SMTP_SECURE', config.external.smtp.secure?.toString());
+      setEnvIfNotSet('SMTP_USERNAME', config.external.smtp.username);
+      setEnvIfNotSet('SMTP_PASSWORD', config.external.smtp.password);
+    }
+  }
+
+  // Apply performance configuration
+  if (config.performance) {
+    if (config.performance.compression) {
+      setEnvIfNotSet('COMPRESSION_ENABLED', config.performance.compression.enabled?.toString());
+      setEnvIfNotSet('COMPRESSION_LEVEL', config.performance.compression.level?.toString());
+      setEnvIfNotSet('COMPRESSION_THRESHOLD', config.performance.compression.threshold?.toString());
+    }
+
+    if (config.performance.circuitBreaker) {
+      setEnvIfNotSet(
+        'CIRCUIT_BREAKER_ENABLED',
+        config.performance.circuitBreaker.enabled?.toString()
+      );
+      setEnvIfNotSet(
+        'CIRCUIT_BREAKER_THRESHOLD',
+        config.performance.circuitBreaker.failureThreshold?.toString()
+      );
+      setEnvIfNotSet(
+        'CIRCUIT_BREAKER_RESET',
+        config.performance.circuitBreaker.resetTimeout?.toString()
+      );
+      setEnvIfNotSet(
+        'CIRCUIT_BREAKER_MONITOR',
+        config.performance.circuitBreaker.monitoringPeriod?.toString()
+      );
+    }
+
+    if (config.performance.clustering) {
+      setEnvIfNotSet('CLUSTERING_ENABLED', config.performance.clustering.enabled?.toString());
+      setEnvIfNotSet('CLUSTER_WORKERS', config.performance.clustering.workers?.toString());
+    }
+  }
+}
+
+/**
+ * Set environment variable only if it's not already set
+ * This ensures environment variables take precedence over config file values
+ */
+function setEnvIfNotSet(key: string, value: string | undefined): void {
+  if (value !== undefined && process.env[key] === undefined) {
+    process.env[key] = value;
+  }
+}