rpc-express-toolkit 4.2.1 → 4.3.3

package/src/logger.js

@@ -54,9 +54,14 @@ class Logger {
    */
   safeStringify(obj) {
     try {
+      const seen = new WeakSet();
       return JSON.stringify(obj, (key, value) => {
         if (typeof value === 'bigint') return `${value.toString()}n`;
         if (value instanceof Date) return value.toISOString();
+        if (value && typeof value === 'object') {
+          if (seen.has(value)) return '[Circular]';
+          seen.add(value);
+        }
         return value;
       });
     } catch (e) {
@@ -156,7 +161,8 @@ class Logger {
       duration: `${duration}ms`,
       error: error.message,
       code: error.code,
-      stack: error.stack,
+      stack:
+        this.levels[this.level] >= this.levels.debug ? error.stack : undefined,
     });
   }
 
@@ -175,14 +181,19 @@ class Logger {
       'secret',
       'auth',
       'authorization',
+      'credential',
+      'cookie',
+      'session',
     ];
-    const sanitized = Array.isArray(params) ? [...params] : { ...params };
+    const seen = new WeakSet();
 
     const sanitizeObj = (input) => {
       if (typeof input !== 'object' || input === null) return input;
+      if (seen.has(input)) return '[Circular]';
 
+      seen.add(input);
       const output = Array.isArray(input) ? [] : {};
-      for (const [key, value] of Object.entries(input)) {
+      Object.entries(input).forEach(([key, value]) => {
         const isSensitive = sensitiveKeys.some((sensitive) =>
           key.toLowerCase().includes(sensitive)
         );
@@ -193,11 +204,12 @@ class Logger {
         } else {
           output[key] = value;
         }
-      }
+      });
+      seen.delete(input);
       return output;
     };
 
-    return sanitizeObj(sanitized);
+    return sanitizeObj(params);
   }
 }
 

package/src/protocol.js

@@ -0,0 +1,97 @@
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isValidId(id) {
+  return id === null || typeof id === 'string' || typeof id === 'number';
+}
+
+function isValidParams(params) {
+  return Array.isArray(params) || isObject(params);
+}
+
+function validationError(message, id = null) {
+  return {
+    valid: false,
+    responseId: id,
+    error: {
+      code: -32600,
+      message,
+    },
+  };
+}
+
+function validateEnvelope(request) {
+  if (!isObject(request)) {
+    return validationError('Invalid Request: request must be an object');
+  }
+
+  const hasId = hasOwn(request, 'id');
+  const responseId = hasId && isValidId(request.id) ? request.id : null;
+
+  if (request.jsonrpc !== '2.0') {
+    return validationError(
+      "Invalid Request: 'jsonrpc' must be '2.0'.",
+      responseId
+    );
+  }
+
+  if (typeof request.method !== 'string') {
+    return validationError(
+      "Invalid Request: 'method' must be a string.",
+      responseId
+    );
+  }
+
+  if (request.method.length === 0) {
+    return validationError(
+      "Invalid Request: 'method' must not be empty.",
+      responseId
+    );
+  }
+
+  if (hasOwn(request, 'params') && !isValidParams(request.params)) {
+    return validationError(
+      "Invalid Request: 'params' must be an object or array.",
+      responseId
+    );
+  }
+
+  if (hasId && !isValidId(request.id)) {
+    return validationError(
+      "Invalid Request: 'id' must be a string, number, or null.",
+      null
+    );
+  }
+
+  return {
+    valid: true,
+    hasId,
+    isNotification: !hasId,
+    responseId,
+  };
+}
+
+function addBatchIndex(error, batchIndex) {
+  const data =
+    error.data !== undefined && isObject(error.data) ? error.data : {};
+
+  return {
+    ...error,
+    data: {
+      ...data,
+      ...(error.data !== undefined && !isObject(error.data)
+        ? { value: error.data }
+        : {}),
+      batchIndex,
+    },
+  };
+}
+
+module.exports = {
+  addBatchIndex,
+  hasOwn,
+  validateEnvelope,
+};

package/src/validation.js

@@ -1,222 +1,222 @@
-/* eslint max-classes-per-file: off */
-const Ajv = require('ajv');
-const addFormats = require('ajv-formats');
-
-/**
- * JSON-RPC 2.0 Schema Validation Error
- */
-class SchemaValidator {
-  constructor(options = {}) {
-    this.ajv = new Ajv({
-      allErrors: true,
-      removeAdditional: options.removeAdditional || false,
-      useDefaults: options.useDefaults !== false,
-      coerceTypes: options.coerceTypes || false,
-      strict: false, // Allow unknown keywords like exposeSchema in method options
-      ...options.ajvOptions,
-    });
-
-    addFormats(this.ajv);
-
-    // Add custom formats
-    this.addCustomFormats();
-  }
-
-  /**
-   * Add custom format validators
-   */
-  addCustomFormats() {
-    // BigInt format
-    this.ajv.addFormat('bigint', {
-      type: 'string',
-      validate: (data) => /^-?\d+n?$/.test(data),
-    });
-
-    // ObjectId format (MongoDB style)
-    this.ajv.addFormat('objectid', {
-      type: 'string',
-      validate: (data) => /^[0-9a-fA-F]{24}$/.test(data),
-    });
-  }
-
-  /**
-   * Validate parameters against a schema
-   * @param {any} params
-   * @param {Object} schema
-   * @returns {Object} validation result
-   */
-  validate(params, schema) {
-    const validator = this.ajv.compile(schema);
-    const valid = validator(params);
-
-    return {
-      valid,
-      errors: valid ? null : validator.errors,
-      data: params,
-    };
-  }
-
-  /**
-   * Create a validation middleware
-   * @param {Object} schema
-   * @returns {Function}
-   */
-  middleware(schema) {
-    return async (context) => {
-      const { params } = context;
-      const result = this.validate(params, schema);
-
-      if (!result.valid) {
-        const error = new Error('Validation failed');
-        error.code = -32602; // Invalid params
-        error.data = {
-          validationErrors: result.errors.map((err) => ({
-            field: err.instancePath || err.schemaPath,
-            message: err.message,
-            value: err.data,
-          })),
-        };
-        throw error;
-      }
-
-      // Update params with validated/coerced data
-      context.params = result.data;
-      return context;
-    };
-  }
-
-  /**
-   * Add a custom keyword
-   * @param {string} name
-   * @param {Object} definition
-   */
-  addKeyword(name, definition) {
-    this.ajv.addKeyword(name, definition);
-  }
-}
-
-/**
- * Common schema definitions
- */
-const commonSchemas = {
-  // Pagination parameters
-  pagination: {
-    type: 'object',
-    properties: {
-      page: { type: 'integer', minimum: 1, default: 1 },
-      limit: { type: 'integer', minimum: 1, maximum: 100, default: 10 },
-      sort: { type: 'string' },
-      order: { type: 'string', enum: ['asc', 'desc'], default: 'asc' },
-    },
-  },
-
-  // User identification
-  userId: {
-    oneOf: [
-      { type: 'string', format: 'objectid' },
-      { type: 'string', format: 'uuid' },
-      { type: 'integer', minimum: 1 },
-    ],
-  },
-
-  // Email validation
-  email: {
-    type: 'string',
-    format: 'email',
-    maxLength: 255,
-  },
-
-  // Password requirements
-  password: {
-    type: 'string',
-    minLength: 8,
-    maxLength: 128,
-    pattern: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)',
-  },
-
-  // BigInt validation
-  bigintString: {
-    type: 'string',
-    format: 'bigint',
-  },
-
-  // Date validation
-  dateString: {
-    type: 'string',
-    format: 'date-time',
-  },
-};
-
-/**
- * Schema builder helper
- */
-class SchemaBuilder {
-  constructor() {
-    this.schema = {
-      type: 'object',
-      properties: {},
-      required: [],
-    };
-  }
-
-  /**
-   * Add a property to the schema
-   * @param {string} name
-   * @param {Object} definition
-   * @param {boolean} required
-   * @returns {SchemaBuilder}
-   */
-  property(name, definition, required = false) {
-    this.schema.properties[name] = definition;
-    if (required) {
-      this.schema.required.push(name);
-    }
-    return this;
-  }
-
-  /**
-   * Add multiple properties
-   * @param {Object} properties
-   * @returns {SchemaBuilder}
-   */
-  properties(properties) {
-    Object.entries(properties).forEach(([name, definition]) => {
-      this.property(name, definition);
-    });
-    return this;
-  }
-
-  /**
-   * Set required fields
-   * @param {string[]} fields
-   * @returns {SchemaBuilder}
-   */
-  required(fields) {
-    this.schema.required = [...new Set([...this.schema.required, ...fields])];
-    return this;
-  }
-
-  /**
-   * Add additional properties setting
-   * @param {boolean} allowed
-   * @returns {SchemaBuilder}
-   */
-  additionalProperties(allowed) {
-    this.schema.additionalProperties = allowed;
-    return this;
-  }
-
-  /**
-   * Build and return the schema
-   * @returns {Object}
-   */
-  build() {
-    return this.schema;
-  }
-}
-
-module.exports = {
-  SchemaValidator,
-  commonSchemas,
-  SchemaBuilder,
-};
+/* eslint max-classes-per-file: off */
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+
+/**
+ * JSON-RPC 2.0 Schema Validation Error
+ */
+class SchemaValidator {
+  constructor(options = {}) {
+    this.ajv = new Ajv({
+      allErrors: true,
+      removeAdditional: options.removeAdditional || false,
+      useDefaults: options.useDefaults !== false,
+      coerceTypes: options.coerceTypes || false,
+      strict: false, // Allow unknown keywords like exposeSchema in method options
+      ...options.ajvOptions,
+    });
+
+    addFormats(this.ajv);
+
+    // Add custom formats
+    this.addCustomFormats();
+  }
+
+  /**
+   * Add custom format validators
+   */
+  addCustomFormats() {
+    // BigInt format
+    this.ajv.addFormat('bigint', {
+      type: 'string',
+      validate: (data) => /^-?\d+n?$/.test(data),
+    });
+
+    // ObjectId format (MongoDB style)
+    this.ajv.addFormat('objectid', {
+      type: 'string',
+      validate: (data) => /^[0-9a-fA-F]{24}$/.test(data),
+    });
+  }
+
+  /**
+   * Validate parameters against a schema
+   * @param {any} params
+   * @param {Object} schema
+   * @returns {Object} validation result
+   */
+  validate(params, schema) {
+    const validator = this.ajv.compile(schema);
+    const valid = validator(params);
+
+    return {
+      valid,
+      errors: valid ? null : validator.errors,
+      data: params,
+    };
+  }
+
+  /**
+   * Create a validation middleware
+   * @param {Object} schema
+   * @returns {Function}
+   */
+  middleware(schema) {
+    return async (context) => {
+      const { params } = context;
+      const result = this.validate(params, schema);
+
+      if (!result.valid) {
+        const error = new Error('Validation failed');
+        error.code = -32602; // Invalid params
+        error.data = {
+          validationErrors: result.errors.map((err) => ({
+            field: err.instancePath || err.schemaPath,
+            message: err.message,
+            value: err.data,
+          })),
+        };
+        throw error;
+      }
+
+      // Update params with validated/coerced data
+      context.params = result.data;
+      return context;
+    };
+  }
+
+  /**
+   * Add a custom keyword
+   * @param {string} name
+   * @param {Object} definition
+   */
+  addKeyword(name, definition) {
+    this.ajv.addKeyword(name, definition);
+  }
+}
+
+/**
+ * Common schema definitions
+ */
+const commonSchemas = {
+  // Pagination parameters
+  pagination: {
+    type: 'object',
+    properties: {
+      page: { type: 'integer', minimum: 1, default: 1 },
+      limit: { type: 'integer', minimum: 1, maximum: 100, default: 10 },
+      sort: { type: 'string' },
+      order: { type: 'string', enum: ['asc', 'desc'], default: 'asc' },
+    },
+  },
+
+  // User identification
+  userId: {
+    oneOf: [
+      { type: 'string', format: 'objectid' },
+      { type: 'string', format: 'uuid' },
+      { type: 'integer', minimum: 1 },
+    ],
+  },
+
+  // Email validation
+  email: {
+    type: 'string',
+    format: 'email',
+    maxLength: 255,
+  },
+
+  // Password requirements
+  password: {
+    type: 'string',
+    minLength: 8,
+    maxLength: 128,
+    pattern: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)',
+  },
+
+  // BigInt validation
+  bigintString: {
+    type: 'string',
+    format: 'bigint',
+  },
+
+  // Date validation
+  dateString: {
+    type: 'string',
+    format: 'date-time',
+  },
+};
+
+/**
+ * Schema builder helper
+ */
+class SchemaBuilder {
+  constructor() {
+    this.schema = {
+      type: 'object',
+      properties: {},
+      required: [],
+    };
+  }
+
+  /**
+   * Add a property to the schema
+   * @param {string} name
+   * @param {Object} definition
+   * @param {boolean} required
+   * @returns {SchemaBuilder}
+   */
+  property(name, definition, required = false) {
+    this.schema.properties[name] = definition;
+    if (required) {
+      this.schema.required.push(name);
+    }
+    return this;
+  }
+
+  /**
+   * Add multiple properties
+   * @param {Object} properties
+   * @returns {SchemaBuilder}
+   */
+  properties(properties) {
+    Object.entries(properties).forEach(([name, definition]) => {
+      this.property(name, definition);
+    });
+    return this;
+  }
+
+  /**
+   * Set required fields
+   * @param {string[]} fields
+   * @returns {SchemaBuilder}
+   */
+  required(fields) {
+    this.schema.required = [...new Set([...this.schema.required, ...fields])];
+    return this;
+  }
+
+  /**
+   * Add additional properties setting
+   * @param {boolean} allowed
+   * @returns {SchemaBuilder}
+   */
+  additionalProperties(allowed) {
+    this.schema.additionalProperties = allowed;
+    return this;
+  }
+
+  /**
+   * Build and return the schema
+   * @returns {Object}
+   */
+  build() {
+    return this.schema;
+  }
+}
+
+module.exports = {
+  SchemaValidator,
+  commonSchemas,
+  SchemaBuilder,
+};