mastercontroller 1.3.6 → 1.3.8

package/error/SSRErrorHandler.js

@@ -0,0 +1,273 @@
+/**
+ * SSRErrorHandler - Server-side rendering error handling
+ * Handles component render failures with graceful fallbacks
+ * Version: 1.0.1
+ */
+
+const { MasterControllerError } = require('./MasterErrorHandler');
+
+const isDevelopment = process.env.NODE_ENV !== 'production' && process.env.master === 'development';
+
+/**
+ * Render error component for development mode
+ */
+function renderErrorComponent(options = {}) {
+  const {
+    component,
+    error,
+    stack,
+    file,
+    line,
+    details
+  } = options;
+
+  const errorObj = new MasterControllerError({
+    code: 'MC_ERR_COMPONENT_RENDER_FAILED',
+    message: error || 'Component failed to render on server',
+    component,
+    file,
+    line,
+    details: details || stack,
+    originalError: options.originalError
+  });
+
+  // Return full HTML error page in development
+  return errorObj.toHTML();
+}
+
+/**
+ * Render fallback component for production mode
+ */
+function renderFallback(componentName, options = {}) {
+  const { showSkeleton = true, customMessage } = options;
+
+  if (showSkeleton) {
+    return `
+      <div class="mc-fallback" data-component="${componentName}" style="
+        padding: 20px;
+        background: #f9fafb;
+        border-radius: 8px;
+        border: 1px dashed #d1d5db;
+        min-height: 100px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: #6b7280;
+      ">
+        <div class="mc-fallback-content">
+          ${customMessage || ''}
+          <div class="skeleton-loader" style="
+            width: 100%;
+            height: 20px;
+            background: linear-gradient(90deg, #e5e7eb 25%, #f3f4f6 50%, #e5e7eb 75%);
+            background-size: 200% 100%;
+            animation: skeleton-loading 1.5s ease-in-out infinite;
+            border-radius: 4px;
+          "></div>
+        </div>
+        <style>
+          @keyframes skeleton-loading {
+            0% { background-position: 200% 0; }
+            100% { background-position: -200% 0; }
+          }
+        </style>
+      </div>
+    `;
+  }
+
+  // Minimal fallback - just an empty div
+  return `<div class="mc-fallback" data-component="${componentName}"></div>`;
+}
+
+/**
+ * Safe component render wrapper
+ * Catches errors and returns either error page (dev) or fallback (prod)
+ */
+function safeRenderComponent(component, componentName, filePath) {
+  try {
+    // Try tempRender first
+    if (typeof component.tempRender === 'function') {
+      const startTime = Date.now();
+      const result = component.tempRender();
+      const renderTime = Date.now() - startTime;
+
+      // Warn about slow renders in development
+      if (isDevelopment && renderTime > 100) {
+        console.warn(
+          new MasterControllerError({
+            code: 'MC_ERR_SLOW_RENDER',
+            message: `Component rendering slowly on server (${renderTime}ms)`,
+            component: componentName,
+            file: filePath,
+            details: `Render time exceeded 100ms threshold. Consider optimizing this component.`
+          }).format()
+        );
+      }
+
+      return { success: true, html: result, renderTime };
+    }
+
+    // Fallback to connectedCallback
+    if (typeof component.connectedCallback === 'function') {
+      const startTime = Date.now();
+      component.connectedCallback();
+      const renderTime = Date.now() - startTime;
+
+      // Get the rendered HTML
+      const html = component.innerHTML || '';
+      return { success: true, html, renderTime };
+    }
+
+    // No render method found
+    throw new Error('No tempRender() or connectedCallback() method found');
+
+  } catch (error) {
+    console.error(
+      new MasterControllerError({
+        code: 'MC_ERR_COMPONENT_RENDER_FAILED',
+        message: `Failed to render component: ${error.message}`,
+        component: componentName,
+        file: filePath,
+        originalError: error
+      }).format()
+    );
+
+    if (isDevelopment) {
+      return {
+        success: false,
+        html: renderErrorComponent({
+          component: componentName,
+          error: error.message,
+          stack: error.stack,
+          file: filePath,
+          originalError: error
+        }),
+        renderTime: 0
+      };
+    } else {
+      // Log error for monitoring
+      logProductionError(error, componentName, filePath);
+
+      return {
+        success: false,
+        html: renderFallback(componentName, { showSkeleton: true }),
+        renderTime: 0
+      };
+    }
+  }
+}
+
+/**
+ * Log production errors for monitoring
+ */
+function logProductionError(error, component, file) {
+  const errorData = {
+    timestamp: new Date().toISOString(),
+    component,
+    file,
+    message: error.message,
+    stack: error.stack,
+    environment: 'production'
+  };
+
+  // Log to console (can be captured by monitoring services)
+  console.error('[MasterController Production Error]', JSON.stringify(errorData, null, 2));
+
+  // Hook for external logging services (Sentry, LogRocket, etc.)
+  if (global.masterControllerErrorHook) {
+    try {
+      global.masterControllerErrorHook(errorData);
+    } catch (hookError) {
+      console.error('[MasterController] Error hook failed:', hookError.message);
+    }
+  }
+}
+
+/**
+ * Wrap connectedCallback with try-catch
+ */
+function wrapConnectedCallback(element, componentName, filePath) {
+  if (!element || typeof element.connectedCallback !== 'function') {
+    return;
+  }
+
+  const originalCallback = element.connectedCallback;
+
+  element.connectedCallback = function(...args) {
+    try {
+      return originalCallback.apply(this, args);
+    } catch (error) {
+      console.error(
+        new MasterControllerError({
+          code: 'MC_ERR_COMPONENT_RENDER_FAILED',
+          message: `connectedCallback failed: ${error.message}`,
+          component: componentName,
+          file: filePath,
+          originalError: error
+        }).format()
+      );
+
+      if (isDevelopment) {
+        this.innerHTML = renderErrorComponent({
+          component: componentName,
+          error: error.message,
+          stack: error.stack,
+          file: filePath,
+          originalError: error
+        });
+      } else {
+        logProductionError(error, componentName, filePath);
+        this.innerHTML = renderFallback(componentName);
+      }
+    }
+  };
+}
+
+/**
+ * Check if component has required SSR methods
+ */
+function validateSSRComponent(componentClass, componentName, filePath) {
+  const warnings = [];
+
+  // Check for tempRender method
+  if (!componentClass.prototype.tempRender && !componentClass.prototype.connectedCallback) {
+    warnings.push(
+      new MasterControllerError({
+        code: 'MC_ERR_TEMPRENDER_MISSING',
+        message: 'Component missing tempRender() method for SSR',
+        component: componentName,
+        file: filePath,
+        details: `Add a tempRender() method to enable server-side rendering:\n\n  tempRender() {\n    return \`<div>Your HTML here</div>\`;\n  }`
+      })
+    );
+  }
+
+  // Warn if only render() exists (client-only)
+  if (componentClass.prototype.render && !componentClass.prototype.tempRender) {
+    warnings.push(
+      new MasterControllerError({
+        code: 'MC_ERR_TEMPRENDER_MISSING',
+        message: 'Component has render() but no tempRender() - will not SSR',
+        component: componentName,
+        file: filePath,
+        details: 'For SSR, rename render() to tempRender() or add a separate tempRender() method'
+      })
+    );
+  }
+
+  if (warnings.length > 0 && isDevelopment) {
+    warnings.forEach(warning => console.warn(warning.format()));
+  }
+
+  return warnings.length === 0;
+}
+
+module.exports = {
+  renderErrorComponent,
+  renderFallback,
+  safeRenderComponent,
+  wrapConnectedCallback,
+  validateSSRComponent,
+  logProductionError,
+  isDevelopment
+};

package/log/mastercontroller.log

@@ -0,0 +1,2 @@
+{"timestamp":"2026-01-16T04:37:33.476Z","sessionId":"1768538253474-z0w973cmg","level":"INFO","code":"MC_INFO_FRAMEWORK_START","message":"MasterController framework initializing","component":null,"file":null,"line":null,"route":null,"context":{"version":"1.0.247","nodeVersion":"v20.19.4","platform":"darwin","env":"development"},"stack":null,"originalError":null,"environment":"development","nodeVersion":"v20.19.4","platform":"darwin","memory":{"rss":46104576,"heapTotal":10027008,"heapUsed":5720488,"external":2111800,"arrayBuffers":65875},"uptime":0.022275917}
+{"timestamp":"2026-01-16T04:37:33.477Z","sessionId":"1768538253474-z0w973cmg","level":"INFO","code":"MC_INFO_SECURITY_INITIALIZED","message":"Security features initialized","component":null,"file":null,"line":null,"route":null,"context":{"environment":"development","features":{"securityHeaders":true,"csp":true,"csrf":true,"rateLimit":true,"sessionSecurity":true}},"stack":null,"originalError":null,"environment":"development","nodeVersion":"v20.19.4","platform":"darwin","memory":{"rss":46186496,"heapTotal":10027008,"heapUsed":5729744,"external":2111840,"arrayBuffers":65875},"uptime":0.022643334}

package/package.json

@@ -1,10 +1,11 @@
 {
   "dependencies": {
-    "qs" : "^6.14.1",
-    "formidable": "^3.5.4",
+    "content-type": "^1.0.5",
     "cookie": "^1.1.1",
-    "winston": "^3.19.0",
-    "glob" :"^13.0.0"
+    "formidable": "^3.5.4",
+    "glob": "^13.0.0",
+    "qs": "^6.14.1",
+    "winston": "^3.19.0"
   },
   "description": "A class library that makes using the Master Framework a breeze",
   "homepage": "https://github.com/Tailor/MasterController#readme",
@@ -18,5 +19,5 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.3.6"
-}
+  "version": "1.3.8"
+}

package/test-json-empty-body.js

@@ -0,0 +1,76 @@
+// Test for JSON parsing bug fix - empty body on GET requests
+
+const http = require('http');
+const EventEmitter = require('events');
+
+console.log('🧪 Testing MasterRequest jsonStream with empty body...\n');
+
+// Load MasterRequest
+const { MasterRequest } = require('./MasterRequest');
+
+// Create mock request with empty body (simulates GET request)
+class MockRequest extends EventEmitter {
+  constructor() {
+    super();
+    this.headers = {
+      'content-type': 'application/json'
+    };
+  }
+
+  simulateEmptyBody() {
+    // Simulate empty body - no data events, just end
+    setImmediate(() => {
+      this.emit('end');
+    });
+  }
+}
+
+// Test 1: Empty body should not throw error
+console.log('Test 1: Empty body (GET request scenario)...');
+const masterRequest1 = new MasterRequest();
+masterRequest1.init({ maxJsonSize: 1024 * 1024 });
+const mockReq1 = new MockRequest();
+
+masterRequest1.jsonStream(mockReq1, (result) => {
+  if (result && typeof result === 'object' && !result.error) {
+    console.log('✅ Empty body handled correctly');
+    console.log('   Result:', JSON.stringify(result));
+
+    // Test 2: Valid JSON body
+    console.log('\nTest 2: Valid JSON body...');
+    const masterRequest2 = new MasterRequest();
+    masterRequest2.init({ maxJsonSize: 1024 * 1024 });
+    const mockReq2 = new MockRequest();
+
+    masterRequest2.jsonStream(mockReq2, (result) => {
+      if (result && result.name === 'test' && result.value === 123) {
+        console.log('✅ Valid JSON parsed correctly');
+        console.log('   Result:', JSON.stringify(result));
+
+        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('✨ ALL TESTS PASSED');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('\nFix verified:');
+        console.log('✅ Empty body returns {} instead of throwing error');
+        console.log('✅ Valid JSON still parses correctly');
+        console.log('✅ No more "Unexpected end of JSON input" errors on GET requests');
+      } else {
+        console.log('❌ Valid JSON parsing failed');
+        console.log('   Result:', JSON.stringify(result));
+      }
+    });
+
+    // Simulate valid JSON body
+    setImmediate(() => {
+      mockReq2.emit('data', Buffer.from('{"name":"test","value":123}'));
+      mockReq2.emit('end');
+    });
+
+  } else {
+    console.log('❌ Empty body test failed');
+    console.log('   Result:', JSON.stringify(result));
+  }
+});
+
+// Start test
+mockReq1.simulateEmptyBody();