mastercontroller 1.3.4 → 1.3.6

package/error/SSRErrorHandler.js

@@ -1,273 +0,0 @@
-/**
- * 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/test/security/filters.test.js

@@ -1,276 +0,0 @@
-// Action Filter Tests for MasterActionFilters.js
-const master = require('../../MasterControl');
-require('../../MasterActionFilters');
-
-describe('Action Filters - Fixed Architecture', () => {
-
-	class TestController {
-		constructor() {
-			this.__namespace = 'test';
-			this._beforeActionFilters = [];
-			this._afterActionFilters = [];
-
-			// Import methods from MasterActionFilters
-			Object.assign(this, master.controllerExtensions);
-		}
-	}
-
-	describe('Multiple Filters Support', () => {
-		test('should support multiple beforeAction filters', () => {
-			const controller = new TestController();
-
-			controller.beforeAction(['show'], () => console.log('Filter 1'));
-			controller.beforeAction(['show'], () => console.log('Filter 2'));
-			controller.beforeAction(['edit'], () => console.log('Filter 3'));
-
-			// Should have 3 filters
-			expect(controller._beforeActionFilters).toHaveLength(3);
-		});
-
-		test('should not overwrite previous filters', () => {
-			const controller = new TestController();
-
-			controller.beforeAction(['show'], () => 'first');
-			controller.beforeAction(['show'], () => 'second');
-
-			// Both filters should exist
-			expect(controller._beforeActionFilters[0].callBack()).toBe('first');
-			expect(controller._beforeActionFilters[1].callBack()).toBe('second');
-		});
-
-		test('should support multiple afterAction filters', () => {
-			const controller = new TestController();
-
-			controller.afterAction(['index'], () => {});
-			controller.afterAction(['index'], () => {});
-
-			expect(controller._afterActionFilters).toHaveLength(2);
-		});
-	});
-
-	describe('Instance-Level Filters (Not Global)', () => {
-		test('should not share filters between controllers', () => {
-			const controller1 = new TestController();
-			const controller2 = new TestController();
-
-			controller1.__namespace = 'users';
-			controller2.__namespace = 'posts';
-
-			controller1.beforeAction(['show'], () => 'users filter');
-			controller2.beforeAction(['index'], () => 'posts filter');
-
-			// Each controller has independent filters
-			expect(controller1._beforeActionFilters).toHaveLength(1);
-			expect(controller2._beforeActionFilters).toHaveLength(1);
-
-			expect(controller1._beforeActionFilters[0].namespace).toBe('users');
-			expect(controller2._beforeActionFilters[0].namespace).toBe('posts');
-		});
-
-		test('should not have race conditions between requests', () => {
-			// Simulate two concurrent requests
-			const request1Controller = new TestController();
-			const request2Controller = new TestController();
-
-			request1Controller.__namespace = 'users';
-			request2Controller.__namespace = 'admin';
-
-			request1Controller.beforeAction(['show'], () => 'request 1');
-			request2Controller.beforeAction(['dashboard'], () => 'request 2');
-
-			// Each request has its own filter state
-			expect(request1Controller._beforeActionFilters[0].callBack()).toBe('request 1');
-			expect(request2Controller._beforeActionFilters[0].callBack()).toBe('request 2');
-		});
-	});
-
-	describe('Filter Execution', () => {
-		test('should execute all matching filters in order', async () => {
-			const controller = new TestController();
-			const executionOrder = [];
-
-			controller.beforeAction(['show'], () => executionOrder.push('first'));
-			controller.beforeAction(['show'], () => executionOrder.push('second'));
-			controller.beforeAction(['show'], () => executionOrder.push('third'));
-
-			const request = {
-				toAction: 'show',
-				response: { _headerSent: false, headersSent: false }
-			};
-
-			await controller.__callBeforeAction(controller, request, null);
-
-			expect(executionOrder).toEqual(['first', 'second', 'third']);
-		});
-
-		test('should only execute filters for matching actions', async () => {
-			const controller = new TestController();
-			const executed = [];
-
-			controller.beforeAction(['show'], () => executed.push('show'));
-			controller.beforeAction(['edit'], () => executed.push('edit'));
-			controller.beforeAction(['destroy'], () => executed.push('destroy'));
-
-			const request = {
-				toAction: 'show',
-				response: { _headerSent: false, headersSent: false }
-			};
-
-			await controller.__callBeforeAction(controller, request, null);
-
-			expect(executed).toEqual(['show']);
-		});
-	});
-
-	describe('Async Support', () => {
-		test('should support async filters', async () => {
-			const controller = new TestController();
-			let asyncCompleted = false;
-
-			controller.beforeAction(['index'], async () => {
-				await new Promise(resolve => setTimeout(resolve, 10));
-				asyncCompleted = true;
-			});
-
-			const request = {
-				toAction: 'index',
-				response: { _headerSent: false, headersSent: false }
-			};
-
-			await controller.__callBeforeAction(controller, request, null);
-
-			expect(asyncCompleted).toBe(true);
-		});
-
-		test('should await each filter before continuing', async () => {
-			const controller = new TestController();
-			const order = [];
-
-			controller.beforeAction(['index'], async () => {
-				order.push('start-1');
-				await new Promise(resolve => setTimeout(resolve, 20));
-				order.push('end-1');
-			});
-
-			controller.beforeAction(['index'], async () => {
-				order.push('start-2');
-				await new Promise(resolve => setTimeout(resolve, 10));
-				order.push('end-2');
-			});
-
-			const request = {
-				toAction: 'index',
-				response: { _headerSent: false, headersSent: false }
-			};
-
-			await controller.__callBeforeAction(controller, request, null);
-
-			// Should execute in order, awaiting each
-			expect(order).toEqual(['start-1', 'end-1', 'start-2', 'end-2']);
-		});
-	});
-
-	describe('Error Handling', () => {
-		test('should catch and log filter errors', async () => {
-			const controller = new TestController();
-
-			controller.beforeAction(['index'], () => {
-				throw new Error('Filter error');
-			});
-
-			const request = {
-				toAction: 'index',
-				response: {
-					_headerSent: false,
-					headersSent: false,
-					writeHead: jest.fn(),
-					end: jest.fn()
-				}
-			};
-
-			await expect(
-				controller.__callBeforeAction(controller, request, null)
-			).rejects.toThrow('Filter error');
-
-			// Should send error response
-			expect(request.response.writeHead).toHaveBeenCalledWith(500, expect.any(Object));
-		});
-
-		test('should stop filter chain on error', async () => {
-			const controller = new TestController();
-			const executed = [];
-
-			controller.beforeAction(['index'], () => {
-				executed.push('first');
-				throw new Error('Stop here');
-			});
-
-			controller.beforeAction(['index'], () => {
-				executed.push('second'); // Should not execute
-			});
-
-			const request = {
-				toAction: 'index',
-				response: {
-					_headerSent: false,
-					headersSent: false,
-					writeHead: jest.fn(),
-					end: jest.fn()
-				}
-			};
-
-			try {
-				await controller.__callBeforeAction(controller, request, null);
-			} catch (e) {}
-
-			expect(executed).toEqual(['first']);
-		});
-	});
-
-	describe('Timeout Protection', () => {
-		test('should timeout slow filters', async () => {
-			const controller = new TestController();
-
-			controller.beforeAction(['index'], async () => {
-				// Simulate slow operation (6 seconds, timeout is 5 seconds)
-				await new Promise(resolve => setTimeout(resolve, 6000));
-			});
-
-			const request = {
-				toAction: 'index',
-				response: {
-					_headerSent: false,
-					headersSent: false,
-					writeHead: jest.fn(),
-					end: jest.fn()
-				}
-			};
-
-			await expect(
-				controller.__callBeforeAction(controller, request, null)
-			).rejects.toThrow(/timeout/i);
-		}, 10000); // Increase test timeout
-	});
-
-	describe('Variable Shadowing Fix', () => {
-		test('should not have variable shadowing bugs', async () => {
-			const controller = new TestController();
-			const actions = ['show', 'edit', 'destroy'];
-
-			// This used to cause bugs due to variable shadowing
-			controller.beforeAction(actions, (req) => {
-				// Action list should be properly iterated
-			});
-
-			const request = {
-				toAction: 'edit',
-				response: { _headerSent: false, headersSent: false }
-			};
-
-			// Should execute without errors
-			await expect(
-				controller.__callBeforeAction(controller, request, null)
-			).resolves.not.toThrow();
-		});
-	});
-});