schema-dsl 1.2.4 → 2.0.0

package/src/exporters/MySQLExporter.ts

@@ -0,0 +1,155 @@
+/**
+ * MySQLExporter — Export JSON Schema as a MySQL CREATE TABLE DDL statement.
+ *
+ * v2 fixes:
+ *   _escapeString uses standard SQL single-quote escaping (`'` → `''`)
+ *   _convertColumn passes the full schema object to TypeConverter.toMySQLType (includes maxLength etc.)
+ */
+
+import type { JSONSchema } from '../types/schema.js'
+import { BaseExporter, type ExporterOptions } from './BaseExporter.js'
+import { TypeConverter } from '../utils/TypeConverter.js'
+
+// ==================== Type definitions ====================
+
+export interface MySQLExporterOptions extends ExporterOptions {
+  engine: string
+  charset: string
+  collate: string
+}
+
+export interface GenerateIndexOptions {
+  name?: string
+  unique?: boolean
+}
+
+// ==================== MySQLExporter ====================
+
+export class MySQLExporter extends BaseExporter<MySQLExporterOptions> {
+  constructor(options: Partial<MySQLExporterOptions> = {}) {
+    super({
+      engine: 'InnoDB',
+      charset: 'utf8mb4',
+      collate: 'utf8mb4_unicode_ci',
+      ...options,
+    })
+  }
+
+  /**
+   * Export as a MySQL CREATE TABLE statement.
+   */
+  export(tableName: string, jsonSchema: JSONSchema): string {
+    if (!tableName || typeof tableName !== 'string') {
+      throw new Error('[schema-dsl] Table name is required')
+    }
+    this._assertObjectSchema(jsonSchema)
+
+    const columns = this._convertProperties(jsonSchema)
+    const primaryKey = this._detectPrimaryKey(jsonSchema)
+
+    let ddl = `CREATE TABLE ${this._quoteIdent(tableName)} (\n`
+    ddl += columns.map(col => `  ${col}`).join(',\n')
+
+    if (primaryKey) {
+      ddl += `,\n  PRIMARY KEY (${this._quoteIdent(primaryKey)})`
+    }
+
+    ddl += `\n)`
+    ddl += ` ENGINE=${this.options.engine}`
+    ddl += ` DEFAULT CHARSET=${this.options.charset}`
+    ddl += ` COLLATE=${this.options.collate};`
+
+    return ddl
+  }
+
+  /**
+   * Generate a CREATE INDEX statement.
+   */
+  generateIndex(tableName: string, columnName: string, options: GenerateIndexOptions = {}): string {
+    const indexName = options.name ?? `idx_${tableName}_${columnName}`
+    const unique = options.unique ? 'UNIQUE ' : ''
+    return `CREATE ${unique}INDEX ${this._quoteIdent(indexName)} ON ${this._quoteIdent(tableName)} (${this._quoteIdent(columnName)});`
+  }
+
+  /**
+   * Static quick-export shorthand.
+   */
+  static export(tableName: string, jsonSchema: JSONSchema): string {
+    return new MySQLExporter().export(tableName, jsonSchema)
+  }
+
+  // ==================== Private methods ====================
+
+  private _quoteIdent(name: string): string {
+    return '`' + name.replace(/`/g, '``') + '`'
+  }
+
+  private _convertProperties(schema: JSONSchema): string[] {
+    if (!schema.properties) return []
+
+    const required = schema.required ?? []
+    const columns: string[] = []
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      columns.push(this._convertColumn(name, propSchema, required.includes(name)))
+    }
+
+    return columns
+  }
+
+  private _convertColumn(name: string, schema: JSONSchema, isRequired: boolean): string {
+    const { jsonType, sqlType } = this._resolveColumnType(name, schema)
+
+    let def = `${this._quoteIdent(name)} ${sqlType}`
+
+    def += isRequired ? ' NOT NULL' : ' NULL'
+
+    if (schema.default !== undefined) {
+      def += ` DEFAULT ${this._formatDefaultValue(schema.default, jsonType)}`
+    }
+
+    if (schema.description) {
+      def += ` COMMENT '${this._escapeString(schema.description)}'`
+    }
+
+    return def
+  }
+
+  private _resolveColumnType(name: string, schema: JSONSchema): { jsonType: string; sqlType: string } {
+    if (schema.type) {
+      return {
+        jsonType: String(schema.type),
+        sqlType: TypeConverter.toMySQLType(schema.type as string | string[], schema),
+      }
+    }
+
+    const variants = (schema.anyOf ?? schema.oneOf) as JSONSchema[] | undefined
+    if (!variants?.length) {
+      return {
+        jsonType: 'string',
+        sqlType: TypeConverter.toMySQLType('string', schema),
+      }
+    }
+
+    const sqlTypes = new Set(
+      variants.map(variant => TypeConverter.toMySQLType((variant.type as string | string[] | undefined) ?? 'string', variant))
+    )
+
+    if (sqlTypes.size !== 1) {
+      const unionKind = schema.anyOf ? 'anyOf' : 'oneOf'
+      throw new Error(`[schema-dsl] MySQL exporter cannot safely map ${unionKind} for column "${name}" to a single SQL type`)
+    }
+
+    return {
+      jsonType: String(variants[0]?.type ?? 'string'),
+      sqlType: [...sqlTypes][0],
+    }
+  }
+
+  private _formatDefaultValue(value: unknown, type: string): string {
+    if (value === null) return 'NULL'
+    if (type === 'string') return `'${this._escapeString(String(value))}'`
+    if (type === 'boolean') return value ? '1' : '0'
+    return String(value)
+  }
+}

package/src/exporters/PostgreSQLExporter.ts

@@ -0,0 +1,222 @@
+/**
+ * PostgreSQLExporter — Export JSON Schema as a PostgreSQL CREATE TABLE DDL statement.
+ *
+ * v2 fixes:
+ *   Identifiers are escaped with double quotes (`"identifier"` format) instead of v1's unescaped raw identifiers.
+ *   Column comments use the fully-qualified `"schema"."table"."column"` format.
+ */
+
+import type { JSONSchema } from '../types/schema.js'
+import { BaseExporter, type ExporterOptions } from './BaseExporter.js'
+import { TypeConverter } from '../utils/TypeConverter.js'
+
+// ==================== Type definitions ====================
+
+export interface PostgreSQLExporterOptions extends ExporterOptions {
+  /** PostgreSQL schema name (default: public). */
+  schema: string
+  /** Whether to wrap identifiers in double quotes (default false — compatible with v1 behaviour). */
+  quoteIdentifiers?: boolean
+}
+
+export interface GeneratePgIndexOptions {
+  name?: string
+  unique?: boolean
+  method?: 'btree' | 'hash' | 'gin' | 'gist'
+}
+
+// ==================== PostgreSQLExporter ====================
+
+export class PostgreSQLExporter extends BaseExporter<PostgreSQLExporterOptions> {
+  constructor(options: Partial<PostgreSQLExporterOptions> = {}) {
+    super({ schema: 'public', ...options })
+  }
+
+  /**
+   * Export as a PostgreSQL CREATE TABLE statement.
+   */
+  export(tableName: string, jsonSchema: JSONSchema): string {
+    if (!tableName || typeof tableName !== 'string') {
+      throw new Error('[schema-dsl] Table name is required')
+    }
+    this._assertObjectSchema(jsonSchema)
+
+    // Fix: wrap identifiers in double quotes to avoid reserved-word conflicts
+    const schemaIdent = this._quoteIdent(this.options.schema)
+    const tableIdent = this._quoteIdent(tableName)
+    const fullTableName = `${schemaIdent}.${tableIdent}`
+
+    const columns = this._convertProperties(jsonSchema)
+    const primaryKey = this._detectPrimaryKey(jsonSchema)
+
+    let ddl = `CREATE TABLE ${fullTableName} (\n`
+    ddl += columns.map(col => `  ${col}`).join(',\n')
+
+    if (primaryKey) {
+      ddl += `,\n  PRIMARY KEY (${this._quoteIdent(primaryKey)})`
+    }
+
+    ddl += `\n);`
+
+    if (jsonSchema.description) {
+      ddl += `\n\nCOMMENT ON TABLE ${fullTableName} IS '${this._escapeString(jsonSchema.description)}';`
+    }
+
+    const commentDdls = this._generateColumnComments(fullTableName, tableName, jsonSchema)
+    if (commentDdls.length > 0) {
+      ddl += '\n\n' + commentDdls.join('\n')
+    }
+
+    return ddl
+  }
+
+  /**
+   * Generate a CREATE INDEX statement.
+   */
+  generateIndex(tableName: string, columnName: string, options: GeneratePgIndexOptions = {}): string {
+    const fullTableName = `${this._quoteIdent(this.options.schema)}.${this._quoteIdent(tableName)}`
+    const indexName = options.name ?? `idx_${tableName}_${columnName}`
+    const unique = options.unique ? 'UNIQUE ' : ''
+    const method = options.method ?? 'btree'
+    return `CREATE ${unique}INDEX ${this._quoteIdent(indexName)} ON ${fullTableName} USING ${method} (${this._quoteIdent(columnName)});`
+  }
+
+  /**
+   * Static quick-export shorthand.
+   */
+  static export(tableName: string, jsonSchema: JSONSchema): string {
+    return new PostgreSQLExporter().export(tableName, jsonSchema)
+  }
+
+  // ==================== Private methods ====================
+
+  /** Conditionally wrap a PG identifier in double quotes (when quoteIdentifiers=true). */
+  private _quoteIdent(name: string): string {
+    if (this.options.quoteIdentifiers) {
+      return `"${name.replace(/"/g, '""')}"`
+    }
+    return name
+  }
+
+  private _convertProperties(schema: JSONSchema): string[] {
+    if (!schema.properties) return []
+
+    const required = schema.required ?? []
+    const columns: string[] = []
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      columns.push(this._convertColumn(name, propSchema, required.includes(name)))
+    }
+
+    return columns
+  }
+
+  private _convertColumn(name: string, schema: JSONSchema, isRequired: boolean): string {
+    const { jsonType, sqlType } = this._resolveColumnType(name, schema)
+
+    let def = `${this._quoteIdent(name)} ${sqlType}`
+
+    if (isRequired) def += ' NOT NULL'
+
+    if (schema.default !== undefined) {
+      def += ` DEFAULT ${this._formatDefaultValue(schema.default, jsonType)}`
+    }
+
+    const checkConstraints = this._generateCheckConstraints(name, schema)
+    if (checkConstraints.length > 0) {
+      def += ' ' + checkConstraints.join(' ')
+    }
+
+    return def
+  }
+
+  private _resolveColumnType(name: string, schema: JSONSchema): { jsonType: string; sqlType: string } {
+    if (schema.type) {
+      return {
+        jsonType: String(schema.type),
+        sqlType: TypeConverter.toPostgreSQLType(schema.type as string | string[], schema),
+      }
+    }
+
+    const variants = (schema.anyOf ?? schema.oneOf) as JSONSchema[] | undefined
+    if (!variants?.length) {
+      return {
+        jsonType: 'string',
+        sqlType: TypeConverter.toPostgreSQLType('string', schema),
+      }
+    }
+
+    const sqlTypes = new Set(
+      variants.map(variant => TypeConverter.toPostgreSQLType((variant.type as string | string[] | undefined) ?? 'string', variant))
+    )
+
+    if (sqlTypes.size !== 1) {
+      const unionKind = schema.anyOf ? 'anyOf' : 'oneOf'
+      throw new Error(`[schema-dsl] PostgreSQL exporter cannot safely map ${unionKind} for column "${name}" to a single SQL type`)
+    }
+
+    return {
+      jsonType: String(variants[0]?.type ?? 'string'),
+      sqlType: [...sqlTypes][0],
+    }
+  }
+
+  private _generateCheckConstraints(columnName: string, schema: JSONSchema): string[] {
+    const checks: string[] = []
+    const col = this._quoteIdent(columnName)
+
+    if (schema.minLength !== undefined || schema.maxLength !== undefined) {
+      if (schema.minLength !== undefined && schema.maxLength !== undefined) {
+        checks.push(`CHECK (LENGTH(${col}) BETWEEN ${schema.minLength} AND ${schema.maxLength})`)
+      } else if (schema.minLength !== undefined) {
+        checks.push(`CHECK (LENGTH(${col}) >= ${schema.minLength})`)
+      } else if (schema.maxLength !== undefined) {
+        checks.push(`CHECK (LENGTH(${col}) <= ${schema.maxLength})`)
+      }
+    }
+
+    if (schema.minimum !== undefined || schema.maximum !== undefined) {
+      if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        checks.push(`CHECK (${col} BETWEEN ${schema.minimum} AND ${schema.maximum})`)
+      } else if (schema.minimum !== undefined) {
+        checks.push(`CHECK (${col} >= ${schema.minimum})`)
+      } else if (schema.maximum !== undefined) {
+        checks.push(`CHECK (${col} <= ${schema.maximum})`)
+      }
+    }
+
+    if (schema.enum) {
+      const values = (schema.enum as unknown[]).map(v => `'${this._escapeString(String(v))}'`).join(', ')
+      checks.push(`CHECK (${col} IN (${values}))`)
+    }
+
+    return checks
+  }
+
+  private _formatDefaultValue(value: unknown, type: string): string {
+    if (value === null) return 'NULL'
+    if (type === 'string') return `'${this._escapeString(String(value))}'`
+    if (type === 'boolean') return value ? 'TRUE' : 'FALSE'
+    if (type === 'object' || type === 'array') return `'${JSON.stringify(value)}'::JSONB`
+    return String(value)
+  }
+
+  private _generateColumnComments(_fullTableName: string, tableName: string, schema: JSONSchema): string[] {
+    if (!schema.properties) return []
+
+    const comments: string[] = []
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      if (propSchema.description) {
+        // fullTableName is already quoted; quote the column identifier separately
+        const schemaIdent = this._quoteIdent(this.options.schema)
+        const tableIdent = this._quoteIdent(tableName)
+        const colIdent = this._quoteIdent(name)
+        comments.push(
+          `COMMENT ON COLUMN ${schemaIdent}.${tableIdent}.${colIdent} IS '${this._escapeString(propSchema.description)}';`,
+        )
+      }
+    }
+
+    return comments
+  }
+}

package/src/exporters/index.ts

@@ -0,0 +1,18 @@
+/**
+ * src/exporters/index.ts — Unified re-export for all exporters
+ */
+
+export { BaseExporter } from './BaseExporter.js'
+export type { ExporterOptions } from './BaseExporter.js'
+
+export { MongoDBExporter } from './MongoDBExporter.js'
+export type { MongoDBExporterOptions, MongoDBValidationSchema, MongoDBCreateCommand } from './MongoDBExporter.js'
+
+export { MySQLExporter } from './MySQLExporter.js'
+export type { MySQLExporterOptions, GenerateIndexOptions } from './MySQLExporter.js'
+
+export { PostgreSQLExporter } from './PostgreSQLExporter.js'
+export type { PostgreSQLExporterOptions, GeneratePgIndexOptions } from './PostgreSQLExporter.js'
+
+export { MarkdownExporter } from './MarkdownExporter.js'
+export type { MarkdownExporterOptions } from './MarkdownExporter.js'