schema-dsl 1.0.0

package/lib/locales/fr-FR.js

@@ -0,0 +1,66 @@
+module.exports = {
+  required: '{{#label}} est requis',
+  type: '{{#label}} doit être de type {{#expected}}, mais a obtenu {{#actual}}',
+  min: 'La longueur de {{#label}} doit être d\'au moins {{#limit}}',
+  max: 'La longueur de {{#label}} doit être au maximum de {{#limit}}',
+  length: 'La longueur de {{#label}} doit être exactement {{#expected}}',
+  pattern: 'Le format de {{#label}} est invalide',
+  enum: '{{#label}} doit être l\'un des suivants: {{#allowed}}',
+  custom: 'Échec de la validation pour {{#label}}: {{#message}}',
+  circular: 'Référence circulaire détectée dans {{#label}}',
+  'max-depth': 'Profondeur de récursion maximale ({{#depth}}) dépassée dans {{#label}}',
+  exception: 'Exception de validation dans {{#label}}: {{#message}}',
+
+  // Patterns
+  'pattern.phone': 'Numéro de téléphone invalide',
+  'pattern.phone.international': 'Numéro de téléphone international invalide',
+
+  'pattern.idCard': 'Numéro de carte d\'identité invalide',
+
+  'pattern.creditCard': 'Numéro de carte de crédit invalide',
+  'pattern.creditCard.visa': 'Numéro de carte Visa invalide',
+  'pattern.creditCard.mastercard': 'Numéro Mastercard invalide',
+  'pattern.creditCard.amex': 'Numéro de carte American Express invalide',
+  'pattern.creditCard.discover': 'Numéro de carte Discover invalide',
+  'pattern.creditCard.jcb': 'Numéro de carte JCB invalide',
+  'pattern.creditCard.unionpay': 'Numéro de carte UnionPay invalide',
+
+  'pattern.licensePlate': 'Numéro de plaque d\'immatriculation invalide',
+
+  'pattern.postalCode': 'Code postal invalide',
+
+  'pattern.passport': 'Numéro de passeport invalide',
+
+  // New Types
+  'pattern.objectId': 'ObjectId invalide',
+  'pattern.hexColor': 'Couleur hexadécimale invalide',
+  'pattern.macAddress': 'Adresse MAC invalide',
+  'pattern.cron': 'Expression Cron invalide',
+  'pattern.slug': 'Le slug d\'URL ne peut contenir que des lettres minuscules, des chiffres et des traits d\'union',
+
+  // Username & Password
+  'pattern.username': 'Le nom d\'utilisateur doit commencer par une lettre et ne contenir que des lettres, des chiffres et des traits de soulignement',
+  'pattern.password.weak': 'Le mot de passe doit contenir au moins 6 caractères',
+  'pattern.password.medium': 'Le mot de passe doit contenir au moins 8 caractères et contenir des lettres et des chiffres',
+  'pattern.password.strong': 'Le mot de passe doit contenir au moins 8 caractères et contenir des lettres majuscules, minuscules et des chiffres',
+  'pattern.password.veryStrong': 'Le mot de passe doit contenir au moins 10 caractères et contenir des lettres majuscules, minuscules, des chiffres et des caractères spéciaux',
+
+  // Unknown error fallback
+  'UNKNOWN_ERROR': 'Erreur de validation inconnue',
+
+  // Custom validation
+  'CUSTOM_VALIDATION_FAILED': 'Échec de la validation',
+  'ASYNC_VALIDATION_NOT_SUPPORTED': 'La validation asynchrone n\'est pas prise en charge dans validate() synchrone',
+  'VALIDATE_MUST_BE_FUNCTION': 'validate doit être une fonction',
+
+  // Formats
+  'format.email': 'Adresse e-mail invalide',
+  'format.url': 'URL invalide',
+  'format.uuid': 'UUID invalide',
+  'format.date': 'Format de date invalide (YYYY-MM-DD)',
+  'format.datetime': 'Format de date et heure invalide (ISO 8601)',
+  'format.time': 'Format de l\'heure invalide (HH:mm:ss)',
+  'format.ipv4': 'Adresse IPv4 invalide',
+  'format.ipv6': 'Adresse IPv6 invalide'
+};
+

package/lib/locales/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+  'zh-CN': require('./zh-CN'),
+  'en-US': require('./en-US'),
+  'ja-JP': require('./ja-JP'),
+  'es-ES': require('./es-ES'),
+  'fr-FR': require('./fr-FR')
+};
+

package/lib/locales/ja-JP.js

@@ -0,0 +1,66 @@
+module.exports = {
+  required: '{{#label}}は必須です',
+  type: '{{#label}}は {{#expected}} 型である必要がありますが、{{#actual}} でした',
+  min: '{{#label}}の長さは少なくとも {{#limit}} である必要があります',
+  max: '{{#label}}の長さは最大 {{#limit}} である必要があります',
+  length: '{{#label}}の長さは {{#expected}} である必要があります',
+  pattern: '{{#label}}の形式が無効です',
+  enum: '{{#label}}は次のいずれかである必要があります: {{#allowed}}',
+  custom: '{{#label}}の検証に失敗しました: {{#message}}',
+  circular: '{{#label}}で循環参照が検出されました',
+  'max-depth': '{{#label}}で最大再帰深度 ({{#depth}}) を超えました',
+  exception: '{{#label}}検証例外: {{#message}}',
+
+  // Patterns
+  'pattern.phone': '無効な電話番号です',
+  'pattern.phone.international': '無効な国際電話番号です',
+
+  'pattern.idCard': '無効なIDカード番号です',
+
+  'pattern.creditCard': '無効なクレジットカード番号です',
+  'pattern.creditCard.visa': '無効なVisaカード番号です',
+  'pattern.creditCard.mastercard': '無効なMastercard番号です',
+  'pattern.creditCard.amex': '無効なAmerican Expressカード番号です',
+  'pattern.creditCard.discover': '無効なDiscoverカード番号です',
+  'pattern.creditCard.jcb': '無効なJCBカード番号です',
+  'pattern.creditCard.unionpay': '無効な銀聯カード番号です',
+
+  'pattern.licensePlate': '無効なナンバープレート番号です',
+
+  'pattern.postalCode': '無効な郵便番号です',
+
+  'pattern.passport': '無効なパスポート番号です',
+
+  // New Types
+  'pattern.objectId': '無効なObjectIdです',
+  'pattern.hexColor': '無効な16進数カラーコードです',
+  'pattern.macAddress': '無効なMACアドレスです',
+  'pattern.cron': '無効なCron式です',
+  'pattern.slug': 'URLスラッグには、小文字、数字、ハイフンのみを含めることができます',
+
+  // Username & Password
+  'pattern.username': 'ユーザー名は文字で始まり、文字、数字、アンダースコアのみを含める必要があります',
+  'pattern.password.weak': 'パスワードは少なくとも6文字である必要があります',
+  'pattern.password.medium': 'パスワードは少なくとも8文字で、文字と数字を含める必要があります',
+  'pattern.password.strong': 'パスワードは少なくとも8文字で、大文字、小文字、数字を含める必要があります',
+  'pattern.password.veryStrong': 'パスワードは少なくとも10文字で、大文字、小文字、数字、特殊文字を含める必要があります',
+
+  // Unknown error fallback
+  'UNKNOWN_ERROR': '未知の検証エラー',
+
+  // Custom validation
+  'CUSTOM_VALIDATION_FAILED': '検証に失敗しました',
+  'ASYNC_VALIDATION_NOT_SUPPORTED': '同期検証では非同期操作はサポートされていません',
+  'VALIDATE_MUST_BE_FUNCTION': 'validateは関数である必要があります',
+
+  // Formats
+  'format.email': '無効なメールアドレスです',
+  'format.url': '無効なURLです',
+  'format.uuid': '無効なUUIDです',
+  'format.date': '無効な日付形式です (YYYY-MM-DD)',
+  'format.datetime': '無効な日時形式です (ISO 8601)',
+  'format.time': '無効な時間形式です (HH:mm:ss)',
+  'format.ipv4': '無効なIPv4アドレスです',
+  'format.ipv6': '無効なIPv6アドレスです'
+};
+

package/lib/locales/zh-CN.js

@@ -0,0 +1,93 @@
+module.exports = {
+  // Generic
+  required: '{{#label}}不能为空',
+  type: '{{#label}}应该是 {{#expected}} 类型',
+  min: '{{#label}}长度不能少于{{#limit}}个字符',
+  max: '{{#label}}长度不能超过{{#limit}}个字符',
+  length: '{{#label}}长度必须是{{#limit}}个字符',
+  pattern: '{{#label}}格式不正确',
+  enum: '{{#label}}必须是以下值之一: {{#allowed}}',
+  custom: '{{#label}}验证失败: {{#message}}',
+  circular: '{{#label}}检测到循环引用',
+  'max-depth': '超过最大递归深度 ({{#depth}}) at {{#label}}',
+  exception: '{{#label}}验证异常: {{#message}}',
+
+  // Formats
+  'format.email': '{{#label}}必须是有效的邮箱地址',
+  'format.url': '{{#label}}必须是有效的URL地址',
+  'format.uuid': '{{#label}}必须是有效的UUID',
+  'format.date': '{{#label}}必须是有效的日期格式 (YYYY-MM-DD)',
+  'format.datetime': '{{#label}}必须是有效的日期时间格式 (ISO 8601)',
+  'format.time': '{{#label}}必须是有效的时间格式 (HH:mm:ss)',
+  'format.ipv4': '{{#label}}必须是有效的IPv4地址',
+  'format.ipv6': '{{#label}}必须是有效的IPv6地址',
+
+  // String
+  'string.hostname': '{{#label}}必须是有效的主机名',
+  'string.pattern': '{{#label}}格式不符合要求',
+  'string.enum': '{{#label}}必须是以下值之一: {{#valids}}',
+
+  // Number
+  'number.base': '{{#label}}必须是数字类型',
+  'number.min': '{{#label}}不能小于{{#limit}}',
+  'number.max': '{{#label}}不能大于{{#limit}}',
+  'number.integer': '{{#label}}必须是整数',
+  'number.positive': '{{#label}}必须是正数',
+  'number.negative': '{{#label}}必须是负数',
+
+  // Boolean
+  'boolean.base': '{{#label}}必须是布尔类型',
+
+  // Object
+  'object.base': '{{#label}}必须是对象类型',
+  'object.min': '{{#label}}至少需要{{#limit}}个属性',
+  'object.max': '{{#label}}最多只能有{{#limit}}个属性',
+  'object.unknown': '{{#label}}包含未知属性: {{#key}}',
+
+  // Array
+  'array.base': '{{#label}}必须是数组类型',
+  'array.min': '{{#label}}至少需要{{#limit}}个元素',
+  'array.max': '{{#label}}最多只能有{{#limit}}个元素',
+  'array.length': '{{#label}}必须有{{#limit}}个元素',
+  'array.unique': '{{#label}}不能包含重复元素',
+
+  // Date
+  'date.base': '{{#label}}必须是有效的日期',
+  'date.min': '{{#label}}不能早于{{#limit}}',
+  'date.max': '{{#label}}不能晚于{{#limit}}',
+
+  // Any
+  'any.required': '{{#label}}是必填项',
+  'any.invalid': '{{#label}}包含无效值',
+  'any.only': '{{#label}}必须匹配{{#valids}}',
+  'any.unknown': '不允许字段{{#key}}',
+
+  // Patterns (Legacy/Specific)
+  'pattern.phone': '请输入有效的手机号',
+  'pattern.phone.international': '请输入有效的国际手机号',
+  'pattern.idCard': '请输入有效的身份证号码',
+  'pattern.creditCard': '无效的信用卡号',
+  'pattern.licensePlate': '请输入有效的车牌号',
+  'pattern.postalCode': '请输入有效的邮政编码',
+  'pattern.passport': '请输入有效的护照号码',
+  'pattern.objectId': '无效的 ObjectId',
+  'pattern.hexColor': '无效的十六进制颜色值',
+  'pattern.macAddress': '无效的 MAC 地址',
+  'pattern.cron': '无效的 Cron 表达式',
+  'pattern.slug': 'URL别名只能包含小写字母、数字和连字符',
+
+  // Username & Password
+  'pattern.username': '用户名必须以字母开头，只能包含字母、数字和下划线',
+  'pattern.password.weak': '密码至少6位',
+  'pattern.password.medium': '密码至少8位，需包含字母和数字',
+  'pattern.password.strong': '密码至少8位，需包含大小写字母和数字',
+  'pattern.password.veryStrong': '密码至少10位，需包含大小写字母、数字和特殊字符',
+
+  // Unknown error fallback
+  'UNKNOWN_ERROR': '未知的验证错误',
+
+  // Custom validation
+  'CUSTOM_VALIDATION_FAILED': '自定义验证失败',
+  'ASYNC_VALIDATION_NOT_SUPPORTED': '同步验证不支持异步操作',
+  'VALIDATE_MUST_BE_FUNCTION': 'validate 必须是一个函数'
+};

package/lib/utils/LRUCache.js

@@ -0,0 +1,174 @@
+/**
+ * 带内存管理的 LRU 缓存实现
+ * 用于安全缓存语言包消息，防止内存泄漏
+ * 
+ * @module lib/utils/LRUCache
+ * @version 2.2.1
+ */
+
+/**
+ * LRU (Least Recently Used) 缓存
+ * 自动清理最少使用的条目，确保内存占用可控
+ */
+class LRUCache {
+    /**
+     * 创建 LRU 缓存实例
+     * @param {Object} options - 配置选项
+     * @param {number} [options.maxSize=10] - 最大缓存数量
+     * @param {boolean} [options.enableStats=false] - 是否启用统计
+     */
+    constructor(options = {}) {
+        this.maxSize = options.maxSize || 10;
+        this.enableStats = options.enableStats || false;
+        this.cache = new Map();
+
+        if (this.enableStats) {
+            this.stats = {
+                hits: 0,
+                misses: 0,
+                evictions: 0,
+                sets: 0
+            };
+        }
+    }
+
+    /**
+     * 获取缓存值
+     * @param {string} key - 键
+     * @returns {*} 缓存的值，不存在则返回 undefined
+     */
+    get(key) {
+        if (!this.cache.has(key)) {
+            if (this.enableStats) this.stats.misses++;
+            return undefined;
+        }
+
+        if (this.enableStats) this.stats.hits++;
+
+        // LRU: 移到最后（标记为最近使用）
+        const value = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, value);
+
+        return value;
+    }
+
+    /**
+     * 设置缓存值
+     * @param {string} key - 键
+     * @param {*} value - 值
+     */
+    set(key, value) {
+        if (this.enableStats) this.stats.sets++;
+
+        // 如果已存在，先删除（更新顺序）
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+
+        // 如果超过容量，删除最旧的（最少使用）
+        if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+
+            if (this.enableStats) this.stats.evictions++;
+
+            // 开发环境警告
+            if (process.env.NODE_ENV === 'development') {
+                console.warn(`[LRUCache] Evicted key: ${firstKey} (cache full: ${this.maxSize})`);
+            }
+        }
+
+        this.cache.set(key, value);
+    }
+
+    /**
+     * 检查键是否存在
+     * @param {string} key - 键
+     * @returns {boolean} 是否存在
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+
+    /**
+     * 删除指定键
+     * @param {string} key - 键
+     * @returns {boolean} 是否删除成功
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        this.cache.clear();
+
+        if (this.enableStats) {
+            this.stats = {
+                hits: 0,
+                misses: 0,
+                evictions: 0,
+                sets: 0
+            };
+        }
+    }
+
+    /**
+     * 获取当前缓存大小
+     * @returns {number} 缓存条目数量
+     */
+    get size() {
+        return this.cache.size;
+    }
+
+    /**
+     * 获取所有键
+     * @returns {Array<string>} 键数组
+     */
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+
+    /**
+     * 获取缓存统计信息
+     * @returns {Object} 统计信息
+     */
+    getStats() {
+        if (!this.enableStats) {
+            return { message: 'Stats not enabled. Set enableStats: true in constructor.' };
+        }
+
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? (this.stats.hits / total * 100).toFixed(2) : 0;
+
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            evictions: this.stats.evictions,
+            sets: this.stats.sets,
+            hitRate: `${hitRate}%`,
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            efficiency: hitRate >= 80 ? '优秀' : hitRate >= 60 ? '良好' : '需优化'
+        };
+    }
+
+    /**
+     * 重置统计信息
+     */
+    resetStats() {
+        if (this.enableStats) {
+            this.stats = {
+                hits: 0,
+                misses: 0,
+                evictions: 0,
+                sets: 0
+            };
+        }
+    }
+}
+
+module.exports = LRUCache;

package/lib/utils/SchemaHelper.js

@@ -0,0 +1,240 @@
+/**
+ * SchemaHelper - Schema辅助函数
+ *
+ * 提供Schema操作的常用辅助方法
+ *
+ * @module lib/utils/SchemaHelper
+ * @version 1.0.0
+ */
+
+/**
+ * Schema辅助工具类
+ * @class SchemaHelper
+ */
+class SchemaHelper {
+  /**
+   * 检查是否为有效的JSON Schema
+   * @static
+   * @param {Object} schema - 待检查的Schema对象
+   * @returns {boolean} 是否有效
+   */
+  static isValidSchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+      return false;
+    }
+
+    // 至少要有type或properties或items之一
+    return !!(schema.type || schema.properties || schema.items || schema.$ref);
+  }
+
+  /**
+   * 生成Schema的唯一ID
+   * @static
+   * @param {Object} schema - JSON Schema对象
+   * @returns {string} 唯一ID
+   */
+  static generateSchemaId(schema) {
+    // 使用简单hash生成ID
+    const str = JSON.stringify(schema);
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return `schema_${Math.abs(hash).toString(36)}`;
+  }
+
+  /**
+   * 深度克隆Schema对象
+   * @static
+   * @param {Object} schema - 原Schema对象
+   * @returns {Object} 克隆的Schema对象
+   */
+  static cloneSchema(schema) {
+    return JSON.parse(JSON.stringify(schema));
+  }
+
+  /**
+   * 扁平化嵌套Schema
+   * @static
+   * @param {Object} schema - 嵌套的Schema对象
+   * @param {string} prefix - 属性前缀
+   * @returns {Object} 扁平化的Schema对象
+   */
+  static flattenSchema(schema, prefix = '') {
+    const result = {};
+
+    if (schema.properties) {
+      for (const [key, value] of Object.entries(schema.properties)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+
+        if (value.type === 'object' && value.properties) {
+          // 递归扁平化嵌套对象
+          Object.assign(result, this.flattenSchema(value, fullKey));
+        } else {
+          result[fullKey] = value;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 获取Schema中所有字段路径
+   * @static
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Array} 字段路径数组
+   */
+  static getFieldPaths(schema) {
+    const paths = [];
+
+    function traverse(obj, currentPath = '') {
+      if (obj.properties) {
+        for (const [key, value] of Object.entries(obj.properties)) {
+          const path = currentPath ? `${currentPath}.${key}` : key;
+          paths.push(path);
+
+          if (value.type === 'object') {
+            traverse(value, path);
+          } else if (value.type === 'array' && value.items) {
+            traverse(value.items, `${path}[]`);
+          }
+        }
+      }
+    }
+
+    traverse(schema);
+    return paths;
+  }
+
+  /**
+   * 提取Schema中的所有required字段
+   * @static
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Array} required字段数组
+   */
+  static extractRequiredFields(schema) {
+    const required = [];
+
+    function traverse(obj, prefix = '') {
+      if (obj.required && Array.isArray(obj.required)) {
+        obj.required.forEach(field => {
+          const fullPath = prefix ? `${prefix}.${field}` : field;
+          required.push(fullPath);
+        });
+      }
+
+      if (obj.properties) {
+        for (const [key, value] of Object.entries(obj.properties)) {
+          if (value.type === 'object') {
+            const newPrefix = prefix ? `${prefix}.${key}` : key;
+            traverse(value, newPrefix);
+          }
+        }
+      }
+    }
+
+    traverse(schema);
+    return required;
+  }
+
+  /**
+   * 比较两个Schema是否相同
+   * @static
+   * @param {Object} schema1 - Schema对象1
+   * @param {Object} schema2 - Schema对象2
+   * @returns {boolean} 是否相同
+   */
+  static compareSchemas(schema1, schema2) {
+    return JSON.stringify(schema1) === JSON.stringify(schema2);
+  }
+
+  /**
+   * 简化Schema（移除不必要的字段）
+   * @static
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Object} 简化后的Schema
+   */
+  static simplifySchema(schema) {
+    const simplified = this.cloneSchema(schema);
+
+    // 移除$schema
+    delete simplified.$schema;
+
+    // 移除空的properties
+    if (simplified.properties && Object.keys(simplified.properties).length === 0) {
+      delete simplified.properties;
+    }
+
+    // 移除空的required
+    if (simplified.required && simplified.required.length === 0) {
+      delete simplified.required;
+    }
+
+    return simplified;
+  }
+
+  /**
+   * 验证属性名是否合法
+   * @static
+   * @param {string} name - 属性名
+   * @returns {boolean} 是否合法
+   */
+  static isValidPropertyName(name) {
+    // 属性名只能包含字母、数字、下划线、连字符
+    return /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name);
+  }
+
+  /**
+   * 获取Schema的复杂度（嵌套层级）
+   * @static
+   * @param {Object} schema - JSON Schema对象
+   * @returns {number} 复杂度（最大嵌套层级）
+   */
+  static getSchemaComplexity(schema) {
+    let maxDepth = 0;
+
+    function traverse(obj, depth = 0) {
+      maxDepth = Math.max(maxDepth, depth);
+
+      if (obj.properties) {
+        for (const value of Object.values(obj.properties)) {
+          if (value.type === 'object') {
+            traverse(value, depth + 1);
+          } else if (value.type === 'array' && value.items) {
+            traverse(value.items, depth + 1);
+          }
+        }
+      }
+    }
+
+    traverse(schema);
+    return maxDepth;
+  }
+
+  /**
+   * 生成Schema摘要信息
+   * @static
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Object} 摘要信息
+   */
+  static summarizeSchema(schema) {
+    const paths = this.getFieldPaths(schema);
+    const required = this.extractRequiredFields(schema);
+    const complexity = this.getSchemaComplexity(schema);
+
+    return {
+      type: schema.type || 'unknown',
+      fieldCount: paths.length,
+      requiredCount: required.length,
+      complexity,
+      hasNested: complexity > 0,
+      fields: paths
+    };
+  }
+}
+
+module.exports = SchemaHelper;
+