json-rest-api 1.0.14 → 1.0.16

package/lib/enhanced-logger.js

@@ -3,7 +3,7 @@
  * Wraps any logger to provide comprehensive error logging
  */
 
-import { formatError, formatErrorSummary, formatErrorString } from './error-formatter.js';
+import { formatError, formatErrorSummary, formatErrorString } from './error-formatter.js'
 
 /**
  * Creates an enhanced logger that automatically formats errors
@@ -13,55 +13,55 @@ import { formatError, formatErrorSummary, formatErrorString } from './error-form
  * @param {boolean} options.includeStack - Whether to include stack traces (default: true)
  * @returns {Object} Enhanced logger with automatic error formatting
  */
-export function createEnhancedLogger(baseLogger, options = {}) {
-  const { 
-    logFullErrors = true, 
-    includeStack = true 
-  } = options;
-  
+export function createEnhancedLogger (baseLogger, options = {}) {
+  const {
+    logFullErrors = true,
+    includeStack = true
+  } = options
+
   // Helper to process arguments and format errors
-  function processArgs(args) {
+  function processArgs (args) {
     return args.map(arg => {
       // If it's an error object, format it
       if (arg instanceof Error) {
         if (logFullErrors) {
-          return formatError(arg, { includeStack });
+          return formatError(arg, { includeStack })
         } else {
-          return formatErrorSummary(arg);
+          return formatErrorSummary(arg)
         }
       }
-      
+
       // If it's an object with an error property, format the error
       if (arg && typeof arg === 'object' && arg.error instanceof Error) {
         return {
           ...arg,
-          error: logFullErrors 
+          error: logFullErrors
             ? formatError(arg.error, { includeStack })
             : formatErrorSummary(arg.error)
-        };
+        }
       }
-      
-      return arg;
-    });
+
+      return arg
+    })
   }
-  
+
   // Create wrapper methods for each log level
-  const enhancedLogger = {};
-  
+  const enhancedLogger = {}
+
   // Common log levels
-  const logLevels = ['debug', 'info', 'warn', 'error', 'trace', 'fatal', 'log'];
-  
+  const logLevels = ['debug', 'info', 'warn', 'error', 'trace', 'fatal', 'log']
+
   for (const level of logLevels) {
     if (typeof baseLogger[level] === 'function') {
-      enhancedLogger[level] = function(...args) {
-        const processedArgs = processArgs(args);
-        
+      enhancedLogger[level] = function (...args) {
+        const processedArgs = processArgs(args)
+
         // Special handling for error level - always log full details
         if (level === 'error' && args.some(arg => arg instanceof Error || (arg?.error instanceof Error))) {
           // Log a formatted version as well for better readability
-          const errors = args.filter(arg => arg instanceof Error || arg?.error instanceof Error);
+          const errors = args.filter(arg => arg instanceof Error || arg?.error instanceof Error)
           for (const errorArg of errors) {
-            const error = errorArg instanceof Error ? errorArg : errorArg.error;
+            const error = errorArg instanceof Error ? errorArg : errorArg.error
             if (error.details?.violations && Array.isArray(error.details.violations) && error.details.violations.length > 0) {
               // Log violations in a readable format
               baseLogger[level]('Validation error details:', {
@@ -71,34 +71,34 @@ export function createEnhancedLogger(baseLogger, options = {}) {
                   rule: v.rule,
                   message: v.message
                 }))
-              });
+              })
             }
           }
         }
-        
-        return baseLogger[level](...processedArgs);
-      };
+
+        return baseLogger[level](...processedArgs)
+      }
     }
   }
-  
+
   // Preserve any other properties/methods from the base logger
   for (const key in baseLogger) {
     if (!(key in enhancedLogger)) {
-      enhancedLogger[key] = baseLogger[key];
+      enhancedLogger[key] = baseLogger[key]
     }
   }
-  
+
   // Add utility methods
-  enhancedLogger.logError = function(message, error, additionalData = {}) {
-    const errorData = formatError(error, { includeStack });
+  enhancedLogger.logError = function (message, error, additionalData = {}) {
+    const errorData = formatError(error, { includeStack })
     this.error(message, {
       ...additionalData,
       error: errorData,
       errorSummary: formatErrorSummary(error)
-    });
-  };
-  
-  enhancedLogger.logValidationError = function(message, error, additionalData = {}) {
+    })
+  }
+
+  enhancedLogger.logValidationError = function (message, error, additionalData = {}) {
     if (error.details?.violations && Array.isArray(error.details.violations)) {
       this.error(message, {
         ...additionalData,
@@ -107,28 +107,28 @@ export function createEnhancedLogger(baseLogger, options = {}) {
         violations: error.details.violations,
         fields: error.details?.fields || [],
         fullError: formatError(error, { includeStack: false })
-      });
+      })
     } else {
-      this.logError(message, error, additionalData);
+      this.logError(message, error, additionalData)
     }
-  };
-  
-  return enhancedLogger;
+  }
+
+  return enhancedLogger
 }
 
 /**
  * Middleware to enhance an existing logger instance
  * Can be used to patch global loggers
  */
-export function enhanceLogger(logger, options = {}) {
-  const enhanced = createEnhancedLogger(logger, options);
-  
+export function enhanceLogger (logger, options = {}) {
+  const enhanced = createEnhancedLogger(logger, options)
+
   // Replace methods on the original logger
   for (const key in enhanced) {
     if (typeof enhanced[key] === 'function') {
-      logger[key] = enhanced[key];
+      logger[key] = enhanced[key]
     }
   }
-  
-  return logger;
-}
+
+  return logger
+}

package/lib/error-formatter.js

@@ -11,100 +11,100 @@
  * @param {number} options.maxDepth - Maximum depth for nested objects (default: 5)
  * @returns {Object} Formatted error object safe for JSON serialization
  */
-export function formatError(error, options = {}) {
-  const { includeStack = true, maxDepth = 5 } = options;
-  
+export function formatError (error, options = {}) {
+  const { includeStack = true, maxDepth = 5 } = options
+
   if (!error) {
-    return null;
+    return null
   }
-  
+
   // Handle circular references
-  const seen = new WeakSet();
-  
-  function serialize(obj, depth = 0) {
+  const seen = new WeakSet()
+
+  function serialize (obj, depth = 0) {
     if (depth > maxDepth) {
-      return '[Max depth exceeded]';
+      return '[Max depth exceeded]'
     }
-    
+
     if (obj === null || obj === undefined) {
-      return obj;
+      return obj
     }
-    
+
     if (typeof obj !== 'object') {
-      return obj;
+      return obj
     }
-    
+
     if (seen.has(obj)) {
-      return '[Circular reference]';
+      return '[Circular reference]'
     }
-    
+
     if (obj instanceof Date) {
-      return obj.toISOString();
+      return obj.toISOString()
     }
-    
+
     if (obj instanceof RegExp) {
-      return obj.toString();
+      return obj.toString()
     }
-    
-    seen.add(obj);
-    
+
+    seen.add(obj)
+
     if (Array.isArray(obj)) {
-      return obj.map(item => serialize(item, depth + 1));
+      return obj.map(item => serialize(item, depth + 1))
     }
-    
-    const result = {};
+
+    const result = {}
     for (const key of Object.keys(obj)) {
       try {
-        result[key] = serialize(obj[key], depth + 1);
+        result[key] = serialize(obj[key], depth + 1)
       } catch (e) {
-        result[key] = `[Error serializing: ${e.message}]`;
+        result[key] = `[Error serializing: ${e.message}]`
       }
     }
-    
-    return result;
+
+    return result
   }
-  
+
   // Start with basic error properties
   const formatted = {
     name: error.name || 'Error',
     message: error.message || '',
     ...(includeStack && error.stack ? { stack: error.stack } : {})
-  };
-  
+  }
+
   // If error has a toJSON method, use it
   if (typeof error.toJSON === 'function') {
     try {
-      const jsonError = error.toJSON();
-      Object.assign(formatted, serialize(jsonError));
+      const jsonError = error.toJSON()
+      Object.assign(formatted, serialize(jsonError))
     } catch (e) {
-      formatted.toJSONError = `Failed to call toJSON: ${e.message}`;
+      formatted.toJSONError = `Failed to call toJSON: ${e.message}`
     }
   }
-  
+
   // Add all enumerable properties
   for (const key of Object.keys(error)) {
     if (!(key in formatted)) {
       try {
-        formatted[key] = serialize(error[key]);
+        formatted[key] = serialize(error[key])
       } catch (e) {
-        formatted[key] = `[Error serializing: ${e.message}]`;
+        formatted[key] = `[Error serializing: ${e.message}]`
       }
     }
   }
-  
+
   // Ensure specific error properties are included
-  const importantProps = ['code', 'type', 'details', 'violations', 'subtype', 'path', 'fields'];
+  const importantProps = ['code', 'type', 'details', 'violations', 'subtype', 'path', 'fields']
   for (const prop of importantProps) {
     if (error[prop] !== undefined && !(prop in formatted)) {
       try {
-        formatted[prop] = serialize(error[prop]);
+        formatted[prop] = serialize(error[prop])
       } catch (e) {
-        formatted[prop] = `[Error serializing: ${e.message}]`;
+        formatted[prop] = `[Error serializing: ${e.message}]`
       }
     }
   }
-  
-  return formatted;
+
+  return formatted
 }
 
 /**
@@ -113,9 +113,9 @@ export function formatError(error, options = {}) {
  * @param {Object} options - Formatting options
  * @returns {string} Formatted error string
  */
-export function formatErrorString(error, options = {}) {
-  const formatted = formatError(error, options);
-  return JSON.stringify(formatted, null, 2);
+export function formatErrorString (error, options = {}) {
+  const formatted = formatError(error, options)
+  return JSON.stringify(formatted, null, 2)
 }
 
 /**
@@ -123,25 +123,25 @@ export function formatErrorString(error, options = {}) {
  * @param {Error} error - The error to summarize
  * @returns {string} One-line error summary
  */
-export function formatErrorSummary(error) {
-  if (!error) return 'Unknown error';
-  
-  const parts = [error.message || 'No message'];
-  
+export function formatErrorSummary (error) {
+  if (!error) return 'Unknown error'
+
+  const parts = [error.message || 'No message']
+
   if (error.code) {
-    parts.push(`code: ${error.code}`);
+    parts.push(`code: ${error.code}`)
   }
-  
+
   if (error.details?.violations && Array.isArray(error.details.violations) && error.details.violations.length > 0) {
     const violationSummary = error.details.violations
       .map(v => `${v.field}: ${v.message}`)
-      .join(', ');
-    parts.push(`violations: [${violationSummary}]`);
+      .join(', ')
+    parts.push(`violations: [${violationSummary}]`)
   }
-  
+
   if (error.details?.fields && Array.isArray(error.details.fields) && error.details.fields.length > 0) {
-    parts.push(`fields: ${error.details.fields.join(', ')}`);
+    parts.push(`fields: ${error.details.fields.join(', ')}`)
   }
-  
-  return parts.join(' | ');
-}
+
+  return parts.join(' | ')
+}

package/lib/rest-api-errors.js

@@ -1,4 +1,4 @@
-import { HookedApiError } from 'hooked-api';
+import { HookedApiError } from 'hooked-api'
 
 /**
  * REST API specific error classes that can be mapped to HTTP status codes
@@ -10,17 +10,17 @@ import { HookedApiError } from 'hooked-api';
  * HTTP plugin should map this to 422 Unprocessable Entity
  */
 export class RestApiValidationError extends HookedApiError {
-  constructor(message, { fields = [], violations = [] } = {}) {
-    super(message, 'REST_API_VALIDATION_ERROR');
-    this.code = 'REST_API_VALIDATION';
-    this.type = 'rest_api_validation';
+  constructor (message, { fields = [], violations = [] } = {}) {
+    super(message, 'REST_API_VALIDATION_ERROR')
+    this.code = 'REST_API_VALIDATION'
+    this.type = 'rest_api_validation'
     this.details = {
       fields,
       violations
-    };
+    }
   }
-  
-  toJSON() {
+
+  toJSON () {
     return {
       name: this.name,
       message: this.message,
@@ -28,7 +28,7 @@ export class RestApiValidationError extends HookedApiError {
       type: this.type,
       details: this.details,
       stack: this.stack
-    };
+    }
   }
 }
 
@@ -37,18 +37,18 @@ export class RestApiValidationError extends HookedApiError {
  * HTTP plugin should map based on subtype
  */
 export class RestApiResourceError extends HookedApiError {
-  constructor(message, { subtype, resourceType, resourceId } = {}) {
-    super(message, 'REST_API_RESOURCE_ERROR');
-    this.code = 'REST_API_RESOURCE';
-    this.type = 'rest_api_resource';
-    this.subtype = subtype; // 'not_found', 'conflict', 'forbidden'
+  constructor (message, { subtype, resourceType, resourceId } = {}) {
+    super(message, 'REST_API_RESOURCE_ERROR')
+    this.code = 'REST_API_RESOURCE'
+    this.type = 'rest_api_resource'
+    this.subtype = subtype // 'not_found', 'conflict', 'forbidden'
     this.details = {
       resourceType,
       resourceId
-    };
+    }
   }
-  
-  toJSON() {
+
+  toJSON () {
     return {
       name: this.name,
       message: this.message,
@@ -57,7 +57,7 @@ export class RestApiResourceError extends HookedApiError {
       subtype: this.subtype,
       details: this.details,
       stack: this.stack
-    };
+    }
   }
 }
 
@@ -66,19 +66,19 @@ export class RestApiResourceError extends HookedApiError {
  * HTTP plugin should map this to 400 Bad Request
  */
 export class RestApiPayloadError extends HookedApiError {
-  constructor(message, { path, expected, received } = {}) {
-    super(message, 'REST_API_PAYLOAD_ERROR');
-    this.code = 'REST_API_PAYLOAD';
-    this.type = 'rest_api_payload';
-    this.path = path;
+  constructor (message, { path, expected, received } = {}) {
+    super(message, 'REST_API_PAYLOAD_ERROR')
+    this.code = 'REST_API_PAYLOAD'
+    this.type = 'rest_api_payload'
+    this.path = path
     this.details = {
       path,
       expected,
       received
-    };
+    }
   }
-  
-  toJSON() {
+
+  toJSON () {
     return {
       name: this.name,
       message: this.message,
@@ -87,6 +87,6 @@ export class RestApiPayloadError extends HookedApiError {
       path: this.path,
       details: this.details,
       stack: this.stack
-    };
+    }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-rest-api",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "main": "index.js",
   "type": "module",
   "scripts": {