schema-dsl 1.0.0

package/lib/exporters/MySQLExporter.js

@@ -0,0 +1,212 @@
+/**
+ * MySQL DDL导出器
+ *
+ * 将JSON Schema转换为MySQL CREATE TABLE语句
+ *
+ * @module lib/exporters/MySQLExporter
+ * @version 1.0.0
+ */
+
+const TypeConverter = require('../utils/TypeConverter');
+const SchemaHelper = require('../utils/SchemaHelper');
+
+/**
+ * MySQL导出器类
+ * @class MySQLExporter
+ */
+class MySQLExporter {
+  /**
+   * 构造函数
+   * @param {Object} options - 配置选项
+   * @param {string} options.engine - 存储引擎（默认InnoDB）
+   * @param {string} options.charset - 字符集（默认utf8mb4）
+   * @param {string} options.collate - 排序规则（默认utf8mb4_unicode_ci）
+   */
+  constructor(options = {}) {
+    this.options = {
+      engine: options.engine || 'InnoDB',
+      charset: options.charset || 'utf8mb4',
+      collate: options.collate || 'utf8mb4_unicode_ci',
+      ...options
+    };
+  }
+
+  /**
+   * 导出为MySQL CREATE TABLE语句
+   * @param {string} tableName - 表名
+   * @param {Object} jsonSchema - JSON Schema对象
+   * @returns {string} MySQL DDL语句
+   */
+  export(tableName, jsonSchema) {
+    if (!tableName || typeof tableName !== 'string') {
+      throw new Error('Table name is required');
+    }
+    if (!jsonSchema || jsonSchema.type !== 'object') {
+      throw new Error('JSON Schema must be an object type');
+    }
+
+    const columns = this._convertProperties(jsonSchema);
+    const primaryKey = this._detectPrimaryKey(jsonSchema);
+
+    let ddl = `CREATE TABLE \`${tableName}\` (\n`;
+
+    // 添加列定义
+    const columnDefs = columns.map(col => `  ${col}`).join(',\n');
+    ddl += columnDefs;
+
+    // 添加主键
+    if (primaryKey) {
+      ddl += `,\n  PRIMARY KEY (\`${primaryKey}\`)`;
+    }
+
+    ddl += `\n)`;
+
+    // 添加表选项
+    ddl += ` ENGINE=${this.options.engine}`;
+    ddl += ` DEFAULT CHARSET=${this.options.charset}`;
+    ddl += ` COLLATE=${this.options.collate};`;
+
+    return ddl;
+  }
+
+  /**
+   * 转换properties为列定义
+   * @private
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Array<string>} 列定义数组
+   */
+  _convertProperties(schema) {
+    if (!schema.properties) {
+      return [];
+    }
+
+    const columns = [];
+    const required = schema.required || [];
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const columnDef = this._convertColumn(name, propSchema, required.includes(name));
+      columns.push(columnDef);
+    }
+
+    return columns;
+  }
+
+  /**
+   * 转换单个列
+   * @private
+   * @param {string} name - 列名
+   * @param {Object} schema - 属性Schema
+   * @param {boolean} isRequired - 是否必填
+   * @returns {string} 列定义字符串
+   */
+  _convertColumn(name, schema, isRequired) {
+    const constraints = TypeConverter.extractConstraints(schema);
+    const mysqlType = TypeConverter.toMySQLType(schema.type, constraints);
+
+    let def = `\`${name}\` ${mysqlType}`;
+
+    // NULL约束
+    if (isRequired) {
+      def += ' NOT NULL';
+    } else {
+      def += ' NULL';
+    }
+
+    // 默认值
+    if (schema.default !== undefined) {
+      const defaultValue = this._formatDefaultValue(schema.default, schema.type);
+      def += ` DEFAULT ${defaultValue}`;
+    }
+
+    // 注释
+    if (schema.description) {
+      def += ` COMMENT '${this._escapeString(schema.description)}'`;
+    }
+
+    return def;
+  }
+
+  /**
+   * 格式化默认值
+   * @private
+   * @param {*} value - 默认值
+   * @param {string} type - 类型
+   * @returns {string} 格式化后的默认值
+   */
+  _formatDefaultValue(value, type) {
+    if (value === null) {
+      return 'NULL';
+    }
+
+    if (type === 'string') {
+      return `'${this._escapeString(value)}'`;
+    }
+
+    if (type === 'boolean') {
+      return value ? '1' : '0';
+    }
+
+    return value.toString();
+  }
+
+  /**
+   * 转义字符串
+   * @private
+   * @param {string} str - 字符串
+   * @returns {string} 转义后的字符串
+   */
+  _escapeString(str) {
+    return str.replace(/'/g, "''");
+  }
+
+  /**
+   * 检测主键
+   * @private
+   * @param {Object} schema - JSON Schema对象
+   * @returns {string|null} 主键列名
+   */
+  _detectPrimaryKey(schema) {
+    if (!schema.properties) {
+      return null;
+    }
+
+    // 查找名为id或_id的字段
+    if (schema.properties.id) {
+      return 'id';
+    }
+    if (schema.properties._id) {
+      return '_id';
+    }
+
+    return null;
+  }
+
+  /**
+   * 生成索引DDL
+   * @param {string} tableName - 表名
+   * @param {string} columnName - 列名
+   * @param {Object} options - 索引选项
+   * @returns {string} CREATE INDEX语句
+   */
+  generateIndex(tableName, columnName, options = {}) {
+    const indexName = options.name || `idx_${tableName}_${columnName}`;
+    const unique = options.unique ? 'UNIQUE ' : '';
+
+    return `CREATE ${unique}INDEX \`${indexName}\` ON \`${tableName}\` (\`${columnName}\`);`;
+  }
+
+  /**
+   * 静态方法：快速导出
+   * @static
+   * @param {string} tableName - 表名
+   * @param {Object} jsonSchema - JSON Schema对象
+   * @returns {string} MySQL DDL语句
+   */
+  static export(tableName, jsonSchema) {
+    const exporter = new MySQLExporter();
+    return exporter.export(tableName, jsonSchema);
+  }
+}
+
+module.exports = MySQLExporter;
+

package/lib/exporters/PostgreSQLExporter.js

@@ -0,0 +1,289 @@
+/**
+ * PostgreSQL DDL导出器
+ *
+ * 将JSON Schema转换为PostgreSQL CREATE TABLE语句
+ *
+ * @module lib/exporters/PostgreSQLExporter
+ * @version 1.0.0
+ */
+
+const TypeConverter = require('../utils/TypeConverter');
+
+/**
+ * PostgreSQL导出器类
+ * @class PostgreSQLExporter
+ */
+class PostgreSQLExporter {
+  /**
+   * 构造函数
+   * @param {Object} options - 配置选项
+   * @param {string} options.schema - PostgreSQL schema名称（默认public）
+   */
+  constructor(options = {}) {
+    this.options = {
+      schema: options.schema || 'public',
+      ...options
+    };
+  }
+
+  /**
+   * 导出为PostgreSQL CREATE TABLE语句
+   * @param {string} tableName - 表名
+   * @param {Object} jsonSchema - JSON Schema对象
+   * @returns {string} PostgreSQL DDL语句
+   */
+  export(tableName, jsonSchema) {
+    if (!tableName || typeof tableName !== 'string') {
+      throw new Error('Table name is required');
+    }
+    if (!jsonSchema || jsonSchema.type !== 'object') {
+      throw new Error('JSON Schema must be an object type');
+    }
+
+    const fullTableName = `${this.options.schema}.${tableName}`;
+    const columns = this._convertProperties(jsonSchema);
+    const primaryKey = this._detectPrimaryKey(jsonSchema);
+
+    let ddl = `CREATE TABLE ${fullTableName} (\n`;
+
+    // 添加列定义
+    const columnDefs = columns.map(col => `  ${col}`).join(',\n');
+    ddl += columnDefs;
+
+    // 添加主键
+    if (primaryKey) {
+      ddl += `,\n  PRIMARY KEY (${primaryKey})`;
+    }
+
+    ddl += `\n);`;
+
+    // 添加表注释
+    if (jsonSchema.description) {
+      ddl += `\n\nCOMMENT ON TABLE ${fullTableName} IS '${this._escapeString(jsonSchema.description)}';`;
+    }
+
+    // 添加列注释
+    const commentDdls = this._generateColumnComments(fullTableName, jsonSchema);
+    if (commentDdls.length > 0) {
+      ddl += '\n\n' + commentDdls.join('\n');
+    }
+
+    return ddl;
+  }
+
+  /**
+   * 转换properties为列定义
+   * @private
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Array<string>} 列定义数组
+   */
+  _convertProperties(schema) {
+    if (!schema.properties) {
+      return [];
+    }
+
+    const columns = [];
+    const required = schema.required || [];
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const columnDef = this._convertColumn(name, propSchema, required.includes(name));
+      columns.push(columnDef);
+    }
+
+    return columns;
+  }
+
+  /**
+   * 转换单个列
+   * @private
+   * @param {string} name - 列名
+   * @param {Object} schema - 属性Schema
+   * @param {boolean} isRequired - 是否必填
+   * @returns {string} 列定义字符串
+   */
+  _convertColumn(name, schema, isRequired) {
+    const constraints = TypeConverter.extractConstraints(schema);
+    const pgType = TypeConverter.toPostgreSQLType(schema.type, constraints);
+
+    let def = `${name} ${pgType}`;
+
+    // NULL约束
+    if (isRequired) {
+      def += ' NOT NULL';
+    }
+
+    // 默认值
+    if (schema.default !== undefined) {
+      const defaultValue = this._formatDefaultValue(schema.default, schema.type);
+      def += ` DEFAULT ${defaultValue}`;
+    }
+
+    // UNIQUE约束
+    if (schema.format === 'email' || schema.format === 'uuid') {
+      // email和uuid通常是唯一的
+      // def += ' UNIQUE'; // 可选
+    }
+
+    // CHECK约束
+    const checkConstraints = this._generateCheckConstraints(name, schema);
+    if (checkConstraints.length > 0) {
+      def += ' ' + checkConstraints.join(' ');
+    }
+
+    return def;
+  }
+
+  /**
+   * 生成CHECK约束
+   * @private
+   * @param {string} columnName - 列名
+   * @param {Object} schema - 属性Schema
+   * @returns {Array<string>} CHECK约束数组
+   */
+  _generateCheckConstraints(columnName, schema) {
+    const checks = [];
+
+    // 字符串长度
+    if (schema.minLength !== undefined || schema.maxLength !== undefined) {
+      if (schema.minLength !== undefined && schema.maxLength !== undefined) {
+        checks.push(`CHECK (LENGTH(${columnName}) BETWEEN ${schema.minLength} AND ${schema.maxLength})`);
+      } else if (schema.minLength !== undefined) {
+        checks.push(`CHECK (LENGTH(${columnName}) >= ${schema.minLength})`);
+      } else {
+        checks.push(`CHECK (LENGTH(${columnName}) <= ${schema.maxLength})`);
+      }
+    }
+
+    // 数值范围
+    if (schema.minimum !== undefined || schema.maximum !== undefined) {
+      if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        checks.push(`CHECK (${columnName} BETWEEN ${schema.minimum} AND ${schema.maximum})`);
+      } else if (schema.minimum !== undefined) {
+        checks.push(`CHECK (${columnName} >= ${schema.minimum})`);
+      } else {
+        checks.push(`CHECK (${columnName} <= ${schema.maximum})`);
+      }
+    }
+
+    // 枚举
+    if (schema.enum) {
+      const values = schema.enum.map(v => `'${this._escapeString(v)}'`).join(', ');
+      checks.push(`CHECK (${columnName} IN (${values}))`);
+    }
+
+    return checks;
+  }
+
+  /**
+   * 格式化默认值
+   * @private
+   * @param {*} value - 默认值
+   * @param {string} type - 类型
+   * @returns {string} 格式化后的默认值
+   */
+  _formatDefaultValue(value, type) {
+    if (value === null) {
+      return 'NULL';
+    }
+
+    if (type === 'string') {
+      return `'${this._escapeString(value)}'`;
+    }
+
+    if (type === 'boolean') {
+      return value ? 'TRUE' : 'FALSE';
+    }
+
+    if (type === 'object' || type === 'array') {
+      return `'${JSON.stringify(value)}'::JSONB`;
+    }
+
+    return value.toString();
+  }
+
+  /**
+   * 转义字符串
+   * @private
+   * @param {string} str - 字符串
+   * @returns {string} 转义后的字符串
+   */
+  _escapeString(str) {
+    return str.replace(/'/g, "''");
+  }
+
+  /**
+   * 检测主键
+   * @private
+   * @param {Object} schema - JSON Schema对象
+   * @returns {string|null} 主键列名
+   */
+  _detectPrimaryKey(schema) {
+    if (!schema.properties) {
+      return null;
+    }
+
+    // 查找名为id或_id的字段
+    if (schema.properties.id) {
+      return 'id';
+    }
+    if (schema.properties._id) {
+      return '_id';
+    }
+
+    return null;
+  }
+
+  /**
+   * 生成列注释
+   * @private
+   * @param {string} tableName - 表名
+   * @param {Object} schema - JSON Schema对象
+   * @returns {Array<string>} COMMENT语句数组
+   */
+  _generateColumnComments(tableName, schema) {
+    if (!schema.properties) {
+      return [];
+    }
+
+    const comments = [];
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      if (propSchema.description) {
+        comments.push(`COMMENT ON COLUMN ${tableName}.${name} IS '${this._escapeString(propSchema.description)}';`);
+      }
+    }
+
+    return comments;
+  }
+
+  /**
+   * 生成索引DDL
+   * @param {string} tableName - 表名
+   * @param {string} columnName - 列名
+   * @param {Object} options - 索引选项
+   * @returns {string} CREATE INDEX语句
+   */
+  generateIndex(tableName, columnName, options = {}) {
+    const fullTableName = `${this.options.schema}.${tableName}`;
+    const indexName = options.name || `idx_${tableName}_${columnName}`;
+    const unique = options.unique ? 'UNIQUE ' : '';
+    const method = options.method || 'btree'; // btree, hash, gin, gist
+
+    return `CREATE ${unique}INDEX ${indexName} ON ${fullTableName} USING ${method} (${columnName});`;
+  }
+
+  /**
+   * 静态方法：快速导出
+   * @static
+   * @param {string} tableName - 表名
+   * @param {Object} jsonSchema - JSON Schema对象
+   * @returns {string} PostgreSQL DDL语句
+   */
+  static export(tableName, jsonSchema) {
+    const exporter = new PostgreSQLExporter();
+    return exporter.export(tableName, jsonSchema);
+  }
+}
+
+module.exports = PostgreSQLExporter;
+

package/lib/exporters/index.js

@@ -0,0 +1,24 @@
+/**
+ * Exporters - 导出器统一导出
+ * @module lib/exporters
+ */
+
+const MongoDBExporter = require('./MongoDBExporter');
+const MySQLExporter = require('./MySQLExporter');
+const PostgreSQLExporter = require('./PostgreSQLExporter');
+const MarkdownExporter = require('./MarkdownExporter');
+
+module.exports = {
+  MongoDBExporter,
+  MySQLExporter,
+  PostgreSQLExporter,
+  MarkdownExporter,
+
+  // 别名
+  MongoDB: MongoDBExporter,
+  MySQL: MySQLExporter,
+  PostgreSQL: PostgreSQLExporter,
+  Postgres: PostgreSQLExporter,
+  Markdown: MarkdownExporter
+};
+

package/lib/locales/en-US.js

@@ -0,0 +1,65 @@
+module.exports = {
+  required: '{{#label}} is required',
+  type: '{{#label}} should be {{#expected}}, got {{#actual}}',
+  min: '{{#label}} length must be at least {{#limit}}',
+  max: '{{#label}} length must be at most {{#limit}}',
+  length: '{{#label}} length must be exactly {{#expected}}',
+  pattern: '{{#label}} format is invalid',
+  enum: '{{#label}} must be one of: {{#allowed}}',
+  custom: '{{#label}} validation failed: {{#message}}',
+  circular: 'Circular reference detected at {{#label}}',
+  'max-depth': 'Maximum recursion depth ({{#depth}}) exceeded at {{#label}}',
+  exception: '{{#label}} validation exception: {{#message}}',
+
+  // Patterns
+  'pattern.phone': 'Invalid phone number',
+  'pattern.phone.international': 'Invalid international phone number',
+
+  'pattern.idCard': 'Invalid ID card number',
+
+  'pattern.creditCard': 'Invalid credit card number',
+  'pattern.creditCard.visa': 'Invalid Visa card number',
+  'pattern.creditCard.mastercard': 'Invalid Mastercard number',
+  'pattern.creditCard.amex': 'Invalid American Express card number',
+  'pattern.creditCard.discover': 'Invalid Discover card number',
+  'pattern.creditCard.jcb': 'Invalid JCB card number',
+  'pattern.creditCard.unionpay': 'Invalid UnionPay card number',
+
+  'pattern.licensePlate': 'Invalid license plate number',
+
+  'pattern.postalCode': 'Invalid postal code',
+
+  'pattern.passport': 'Invalid passport number',
+
+  // New Types
+  'pattern.objectId': 'Invalid ObjectId',
+  'pattern.hexColor': 'Invalid Hex Color',
+  'pattern.macAddress': 'Invalid MAC Address',
+  'pattern.cron': 'Invalid Cron Expression',
+  'pattern.slug': 'URL slug can only contain lowercase letters, numbers, and hyphens',
+
+  // Username & Password
+  'pattern.username': 'Username must start with a letter and contain only letters, numbers, and underscores',
+  'pattern.password.weak': 'Password must be at least 6 characters',
+  'pattern.password.medium': 'Password must be at least 8 characters and contain letters and numbers',
+  'pattern.password.strong': 'Password must be at least 8 characters and contain uppercase, lowercase letters and numbers',
+  'pattern.password.veryStrong': 'Password must be at least 10 characters and contain uppercase, lowercase letters, numbers and special characters',
+
+  // Unknown error fallback
+  'UNKNOWN_ERROR': 'Unknown validation error',
+
+  // Custom validation
+  'CUSTOM_VALIDATION_FAILED': 'Validation failed',
+  'ASYNC_VALIDATION_NOT_SUPPORTED': 'Async validation not supported in synchronous validate()',
+  'VALIDATE_MUST_BE_FUNCTION': 'validate must be a function',
+
+  // Formats
+  'format.email': '{{#label}} must be a valid email address',
+  'format.url': '{{#label}} must be a valid URL',
+  'format.uuid': '{{#label}} must be a valid UUID',
+  'format.date': '{{#label}} must be a valid date (YYYY-MM-DD)',
+  'format.datetime': '{{#label}} must be a valid date-time (ISO 8601)',
+  'format.time': '{{#label}} must be a valid time (HH:mm:ss)',
+  'format.ipv4': '{{#label}} must be a valid IPv4 address',
+  'format.ipv6': '{{#label}} must be a valid IPv6 address'
+};

package/lib/locales/es-ES.js

@@ -0,0 +1,66 @@
+module.exports = {
+  required: '{{#label}} es obligatorio',
+  type: '{{#label}} debe ser de tipo {{#expected}}, pero se obtuvo {{#actual}}',
+  min: 'La longitud de {{#label}} debe ser al menos {{#limit}}',
+  max: 'La longitud de {{#label}} debe ser como máximo {{#limit}}',
+  length: 'La longitud de {{#label}} debe ser exactamente {{#expected}}',
+  pattern: 'El formato de {{#label}} no es válido',
+  enum: '{{#label}} debe ser uno de: {{#allowed}}',
+  custom: 'Validación fallida para {{#label}}: {{#message}}',
+  circular: 'Referencia circular detectada en {{#label}}',
+  'max-depth': 'Profundidad máxima de recursión ({{#depth}}) excedida en {{#label}}',
+  exception: 'Excepción de validación en {{#label}}: {{#message}}',
+
+  // Patterns
+  'pattern.phone': 'Número de teléfono no válido',
+  'pattern.phone.international': 'Número de teléfono internacional no válido',
+
+  'pattern.idCard': 'Número de tarjeta de identificación no válido',
+
+  'pattern.creditCard': 'Número de tarjeta de crédito no válido',
+  'pattern.creditCard.visa': 'Número de tarjeta Visa no válido',
+  'pattern.creditCard.mastercard': 'Número de Mastercard no válido',
+  'pattern.creditCard.amex': 'Número de tarjeta American Express no válido',
+  'pattern.creditCard.discover': 'Número de tarjeta Discover no válido',
+  'pattern.creditCard.jcb': 'Número de tarjeta JCB no válido',
+  'pattern.creditCard.unionpay': 'Número de tarjeta UnionPay no válido',
+
+  'pattern.licensePlate': 'Número de matrícula no válido',
+
+  'pattern.postalCode': 'Código postal no válido',
+
+  'pattern.passport': 'Número de pasaporte no válido',
+
+  // New Types
+  'pattern.objectId': 'ObjectId no válido',
+  'pattern.hexColor': 'Color hexadecimal no válido',
+  'pattern.macAddress': 'Dirección MAC no válida',
+  'pattern.cron': 'Expresión Cron no válida',
+  'pattern.slug': 'El slug de URL solo puede contener letras minúsculas, números y guiones',
+
+  // Username & Password
+  'pattern.username': 'El nombre de usuario debe comenzar con una letra y contener solo letras, números y guiones bajos',
+  'pattern.password.weak': 'La contraseña debe tener al menos 6 caracteres',
+  'pattern.password.medium': 'La contraseña debe tener al menos 8 caracteres y contener letras y números',
+  'pattern.password.strong': 'La contraseña debe tener al menos 8 caracteres y contener letras mayúsculas, minúsculas y números',
+  'pattern.password.veryStrong': 'La contraseña debe tener al menos 10 caracteres y contener letras mayúsculas, minúsculas, números y caracteres especiales',
+
+  // Unknown error fallback
+  'UNKNOWN_ERROR': 'Error de validación desconocido',
+
+  // Custom validation
+  'CUSTOM_VALIDATION_FAILED': 'Validación fallida',
+  'ASYNC_VALIDATION_NOT_SUPPORTED': 'La validación asíncrona no es compatible en validate() síncrono',
+  'VALIDATE_MUST_BE_FUNCTION': 'validate debe ser una función',
+
+  // Formats
+  'format.email': 'Dirección de correo electrónico no válida',
+  'format.url': 'URL no válida',
+  'format.uuid': 'UUID no válido',
+  'format.date': 'Formato de fecha no válido (YYYY-MM-DD)',
+  'format.datetime': 'Formato de fecha y hora no válido (ISO 8601)',
+  'format.time': 'Formato de hora no válido (HH:mm:ss)',
+  'format.ipv4': 'Dirección IPv4 no válida',
+  'format.ipv6': 'Dirección IPv6 no válida'
+};
+