@tencentcloud/web-push 1.0.3 → 1.0.4

package/src/utils/validator.ts

@@ -1,267 +0,0 @@
-/**
- * Parameter validation utility class
- */
-
-export interface ValidationRule {
-  required?: boolean;
-  type?: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function';
-  min?: number;
-  max?: number;
-  pattern?: RegExp;
-  custom?: (value: any) => boolean | string;
-  message?: string;
-}
-
-export interface ValidationSchema {
-  [key: string]: ValidationRule;
-}
-
-export class ValidationError extends Error {
-  public field: string;
-  public value: any;
-
-  constructor(field: string, message: string, value?: any) {
-    super(`Parameter validation failed: ${field} - ${message}`);
-    this.name = 'ValidationError';
-    this.field = field;
-    this.value = value;
-  }
-}
-
-export class Validator {
-  /**
-   * Validate single value
-   */
-  static validateValue(
-    fieldName: string,
-    value: any,
-    rule: ValidationRule
-  ): void {
-    if (
-      rule.required &&
-      (value === undefined || value === null || value === '')
-    ) {
-      throw new ValidationError(
-        fieldName,
-        rule.message || `${fieldName} is required`,
-        value
-      );
-    }
-
-    if (
-      !rule.required &&
-      (value === undefined || value === null || value === '')
-    ) {
-      return;
-    }
-
-    if (rule.type && !this.checkType(value, rule.type)) {
-      throw new ValidationError(
-        fieldName,
-        rule.message || `${fieldName} must be of type ${rule.type}`,
-        value
-      );
-    }
-
-    if (rule.type === 'string' && typeof value === 'string') {
-      if (rule.min !== undefined && value.length < rule.min) {
-        throw new ValidationError(
-          fieldName,
-          rule.message ||
-            `${fieldName} length cannot be less than ${rule.min} characters`,
-          value
-        );
-      }
-      if (rule.max !== undefined && value.length > rule.max) {
-        throw new ValidationError(
-          fieldName,
-          rule.message ||
-            `${fieldName} length cannot exceed ${rule.max} characters`,
-          value
-        );
-      }
-    }
-
-    if (rule.type === 'number' && typeof value === 'number') {
-      if (rule.min !== undefined && value < rule.min) {
-        throw new ValidationError(
-          fieldName,
-          rule.message || `${fieldName} cannot be less than ${rule.min}`,
-          value
-        );
-      }
-      if (rule.max !== undefined && value > rule.max) {
-        throw new ValidationError(
-          fieldName,
-          rule.message || `${fieldName} cannot be greater than ${rule.max}`,
-          value
-        );
-      }
-    }
-
-    if (rule.pattern && typeof value === 'string') {
-      if (!rule.pattern.test(value)) {
-        throw new ValidationError(
-          fieldName,
-          rule.message || `${fieldName} format is incorrect`,
-          value
-        );
-      }
-    }
-
-    if (rule.custom) {
-      const result = rule.custom(value);
-      if (result !== true) {
-        const message =
-          typeof result === 'string'
-            ? result
-            : rule.message || `${fieldName} validation failed`;
-        throw new ValidationError(fieldName, message, value);
-      }
-    }
-  }
-
-  /**
-   * Validate object
-   */
-  static validateObject(obj: any, schema: ValidationSchema): void {
-    if (!obj || typeof obj !== 'object') {
-      throw new ValidationError('root', 'Parameter must be an object type');
-    }
-
-    for (const [fieldName, rule] of Object.entries(schema)) {
-      const value = obj[fieldName];
-      this.validateValue(fieldName, value, rule);
-    }
-  }
-
-  /**
-   * Check type
-   */
-  private static checkType(value: any, expectedType: string): boolean {
-    switch (expectedType) {
-      case 'string':
-        return typeof value === 'string';
-      case 'number':
-        return typeof value === 'number' && !isNaN(value);
-      case 'boolean':
-        return typeof value === 'boolean';
-      case 'object':
-        return (
-          value !== null && typeof value === 'object' && !Array.isArray(value)
-        );
-      case 'array':
-        return Array.isArray(value);
-      case 'function':
-        return typeof value === 'function';
-      default:
-        return false;
-    }
-  }
-
-  static validateSDKAppID(SDKAppID: any): void {
-    this.validateValue('SDKAppID', SDKAppID, {
-      required: true,
-      type: 'number',
-      custom: (value) => {
-        if (!Number.isInteger(value)) {
-          return 'SDKAppID must be an integer';
-        }
-        return true;
-      },
-      message: 'SDKAppID must be an integer between 1-999999999',
-    });
-  }
-
-  static validateAppKey(appKey: any): void {
-    this.validateValue('appKey', appKey, {
-      required: true,
-      type: 'string',
-      pattern: /^[a-zA-Z0-9_-]+$/,
-      message:
-        'appKey must be a 1-256 character string composed of letters, numbers, underscores or hyphens',
-    });
-  }
-
-  static validateUserID(userID: any): void {
-    this.validateValue('userID', userID, {
-      required: true,
-      type: 'string',
-      pattern: /^[a-zA-Z0-9_.-]+$/,
-      message:
-        'userID must be a 1-128 character string composed of letters, numbers, underscores, dots or hyphens',
-    });
-  }
-
-  static validateEventType(eventType: any): void {
-    const validEvents = [
-      'message_received',
-      'message_revoked',
-      'notification_clicked',
-    ];
-    this.validateValue('eventType', eventType, {
-      required: true,
-      type: 'string',
-      custom: (value) => {
-        if (!validEvents.includes(value)) {
-          return `eventType must be one of: ${validEvents.join(', ')}`;
-        }
-        return true;
-      },
-    });
-  }
-
-  static validateListener(listener: any): void {
-    this.validateValue('listener', listener, {
-      required: true,
-      type: 'function',
-      message: 'listener must be a function',
-    });
-  }
-
-  static validateRegisterPushOptions(options: any): void {
-    if (!options) {
-      throw new ValidationError(
-        'options',
-        'Registration options cannot be empty'
-      );
-    }
-
-    const schema: ValidationSchema = {
-      SDKAppID: {
-        required: true,
-        type: 'number',
-        custom: (value) => {
-          if (!Number.isInteger(value)) {
-            return 'SDKAppID must be an integer';
-          }
-          return true;
-        },
-      },
-      appKey: {
-        required: true,
-        type: 'string',
-        pattern: /^[a-zA-Z0-9_-]+$/,
-      },
-      userID: {
-        required: true,
-        type: 'string',
-        pattern: /^[a-zA-Z0-9_.-]+$/,
-      },
-    };
-
-    this.validateObject(options, schema);
-  }
-
-  /**
-   * Validate Service Worker path
-   */
-  static validateServiceWorkerPath(path: any): void {
-    this.validateValue('serviceWorkerPath', path, {
-      required: false,
-      type: 'string',
-      pattern: /^[a-zA-Z0-9_./-]+\.js$/,
-      message: 'serviceWorkerPath must be a valid JavaScript file path',
-    });
-  }
-}