synthra 0.1.0

data/lib/synthra/export/xml_data.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports generated data as XML
+    #
+    # @example Export schema data as XML
+    #   exporter = XmlData.new(schema, registry: registry, count: 10)
+    #   xml = exporter.export
+    #
+    class XmlData < Base
+      def export
+        count = options[:count] || 10
+        seed = options[:seed]
+        mode = options[:mode] || :random
+        indent = options[:indent] || 2
+
+        records = schema.generate_many(count, seed: seed, mode: mode, registry: registry)
+
+        lines = []
+        lines << '<?xml version="1.0" encoding="UTF-8"?>'
+        lines << "<!-- Generated from Synthra schema: #{schema.name} -->"
+        lines << "<!-- Records: #{count}, Generated at: #{Time.now.iso8601} -->"
+
+        root_name = options[:root] || "#{to_snake_case(schema.name)}s"
+        item_name = options[:item] || to_snake_case(schema.name)
+
+        lines << "<#{root_name}>"
+
+        records.each do |record|
+          lines << build_xml_element(item_name, record, indent)
+        end
+
+        lines << "</#{root_name}>"
+        lines.join("\n")
+      end
+
+      private
+
+      def build_xml_element(name, value, indent, depth = 1)
+        prefix = " " * (indent * depth)
+
+        case value
+        when Hash
+          lines = ["#{prefix}<#{name}>"]
+          value.each do |k, v|
+            lines << build_xml_element(to_snake_case(k.to_s), v, indent, depth + 1)
+          end
+          lines << "#{prefix}</#{name}>"
+          lines.join("\n")
+        when Array
+          if value.empty?
+            "#{prefix}<#{name}/>"
+          else
+            lines = ["#{prefix}<#{name}>"]
+            item_name = singularize(name)
+            value.each do |item|
+              lines << build_xml_element(item_name, item, indent, depth + 1)
+            end
+            lines << "#{prefix}</#{name}>"
+            lines.join("\n")
+          end
+        when nil
+          "#{prefix}<#{name} nil=\"true\"/>"
+        when true, false
+          "#{prefix}<#{name}>#{value}</#{name}>"
+        else
+          escaped = escape_xml(value.to_s)
+          "#{prefix}<#{name}>#{escaped}</#{name}>"
+        end
+      end
+
+      def escape_xml(str)
+        str.gsub("&", "&amp;")
+           .gsub("<", "&lt;")
+           .gsub(">", "&gt;")
+           .gsub("\"", "&quot;")
+           .gsub("'", "&apos;")
+      end
+
+      def to_snake_case(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+
+      def singularize(str)
+        # Simple singularization
+        case str
+        when /ies$/
+          str.sub(/ies$/, "y")
+        when /es$/
+          str.sub(/es$/, "")
+        when /s$/
+          str.sub(/s$/, "")
+        else
+          str
+        end
+      end
+    end
+    # :nocov:
+  end
+end

data/lib/synthra/export/yaml_data.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports generated data as YAML
+    #
+    # @example Export schema data as YAML
+    #   exporter = YamlData.new(schema, registry: registry, count: 10)
+    #   yaml = exporter.export
+    #
+    class YamlData < Base
+      def export
+        count = options[:count] || 10
+        seed = options[:seed]
+        mode = options[:mode] || :random
+
+        records = if count == 1
+                    schema.generate(seed: seed, mode: mode, registry: registry) # single record
+                  else
+                    schema.generate_many(count, seed: seed, mode: mode, registry: registry)
+                  end
+
+        output = wrap_output(records)
+
+        # Add header comment
+        lines = []
+        lines << "# Generated from Synthra schema: #{schema.name}"
+        lines << "# Version: #{schema.version}" if schema.version
+        lines << "# Records: #{count}"
+        lines << "# Generated at: #{Time.now.iso8601}"
+        lines << ""
+        lines << YAML.dump(output)
+
+        lines.join("\n")
+      end
+
+      private
+
+      def wrap_output(records)
+        # :nocov:
+        if options[:wrap] == false
+          records
+        # :nocov:
+        elsif options[:root_key]
+          { options[:root_key] => records }
+        else
+          records
+        end
+      end
+    end
+    # :nocov:
+  end
+end

data/lib/synthra/export.rb

@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+require_relative "export/base"
+require_relative "export/json_schema"
+require_relative "export/typescript"
+require_relative "export/javascript"
+require_relative "export/python"
+require_relative "export/sql"
+require_relative "export/csv"
+require_relative "export/graphviz"
+require_relative "export/graphql"
+require_relative "export/json_data"
+require_relative "export/sql_insert"
+require_relative "export/yaml_data"
+require_relative "export/xml_data"
+
+module Synthra
+  # Export module for converting schemas to various formats
+  #
+  # Supports two categories of exports:
+  #
+  # ## Schema Exports (structure/types)
+  # - JSON Schema (draft 2020-12)
+  # - TypeScript interfaces
+  # - JavaScript with JSDoc types
+  # - SQL CREATE TABLE statements
+  # - GraphViz DOT diagrams
+  #
+  # ## Data Exports (generated records)
+  # - JSON data
+  # - CSV data
+  # - SQL INSERT statements
+  # - YAML data
+  # - XML data
+  #
+  # @example Export schema as TypeScript
+  #   Synthra::Export.typescript(schema, registry: registry)
+  #
+  # @example Export generated data as JSON
+  #   Synthra::Export.json_data(schema, registry: registry, count: 100)
+  #
+  # @example Export generated data as SQL INSERTs
+  #   Synthra::Export.sql_insert(schema, count: 50, dialect: :postgresql)
+  #
+  module Export
+    # =========================================================================
+    # Schema Export Formats (types/structure)
+    # =========================================================================
+    SCHEMA_FORMATS = {
+      "json-schema" => JsonSchema,
+      "typescript" => Typescript,
+      "ts" => Typescript,
+      "javascript" => Javascript,
+      "js" => Javascript,
+      "python" => Python,
+      "py" => Python,
+      "pydantic" => Python,
+      "dataclass" => Python,
+      "sql" => Sql,
+      "sql-ddl" => Sql,
+      "postgresql" => Sql,
+      "mysql" => Sql,
+      "sqlite" => Sql,
+      "graphviz" => Graphviz,
+      "dot" => Graphviz,
+      "graphql" => Graphql,
+      "gql" => Graphql
+    }.freeze
+
+    # File extensions for auto-generated filenames
+    FILE_EXTENSIONS = {
+      "json-schema" => ".schema.json",
+      "typescript" => ".ts",
+      "ts" => ".ts",
+      "javascript" => ".js",
+      "js" => ".js",
+      "python" => ".py",
+      "py" => ".py",
+      "pydantic" => ".py",
+      "dataclass" => ".py",
+      "sql" => ".sql",
+      "sql-ddl" => ".sql",
+      "postgresql" => ".sql",
+      "mysql" => ".sql",
+      "sqlite" => ".sql",
+      "graphviz" => ".dot",
+      "dot" => ".dot",
+      "graphql" => ".graphql",
+      "gql" => ".graphql",
+      "json" => ".json",
+      "json-data" => ".json",
+      "csv" => ".csv",
+      "sql-insert" => ".sql",
+      "insert" => ".sql",
+      "yaml" => ".yaml",
+      "yml" => ".yaml",
+      "xml" => ".xml"
+    }.freeze
+
+    # =========================================================================
+    # Data Export Formats (generated records)
+    # =========================================================================
+    DATA_FORMATS = {
+      "json" => JsonData,
+      "json-data" => JsonData,
+      "csv" => Csv,
+      "sql-insert" => SqlInsert,
+      "insert" => SqlInsert,
+      "yaml" => YamlData,
+      "yml" => YamlData,
+      "xml" => XmlData
+    }.freeze
+
+    # All available formats
+    FORMATS = SCHEMA_FORMATS.merge(DATA_FORMATS).freeze
+
+    class << self
+      # Export schema to specified format
+      #
+      # @param format [String, Symbol] the export format
+      # @param schema [Schema] the schema to export
+      # @param registry [Registry] the registry for resolving references
+      # @param options [Hash] format-specific options
+      # @return [String] the exported content
+      #
+      def export(format, schema, registry: nil, **options)
+        format_key = format.to_s.downcase
+        exporter_class = FORMATS[format_key]
+
+        unless exporter_class
+          available = available_formats.join(", ")
+          raise ArgumentError, "Unknown format: #{format}. Available: #{available}"
+        end
+
+        # Set dialect for SQL formats
+        if %w[postgresql mysql sqlite].include?(format_key)
+          options[:dialect] = format_key.to_sym
+        end
+
+        exporter = exporter_class.new(schema, registry: registry, **options)
+        exporter.export
+      end
+
+      # =====================================================================
+      # Schema Export Methods
+      # =====================================================================
+
+      # Export schema as JSON Schema
+      #
+      # @param schema [Schema] the schema to export
+      # @param options [Hash] export options
+      # @return [String] JSON Schema string
+      #
+      def json_schema(schema, **options)
+        JsonSchema.new(schema, **options).export
+      end
+
+      # Export schema as TypeScript interface
+      #
+      # @param schema [Schema] the schema to export
+      # @param options [Hash] export options
+      # @return [String] TypeScript interface string
+      #
+      def typescript(schema, **options)
+        Typescript.new(schema, **options).export
+      end
+
+      # Export schema as JavaScript with JSDoc
+      #
+      # @param schema [Schema] the schema to export
+      # @param options [Hash] export options
+      # @return [String] JavaScript with JSDoc types
+      #
+      def javascript(schema, **options)
+        Javascript.new(schema, **options).export
+      end
+
+      # Export schema as Python (Pydantic/dataclass/TypedDict)
+      #
+      # @param schema [Schema] the schema to export
+      # @param options [Hash] export options (style: :pydantic/:dataclass/:typed_dict)
+      # @return [String] Python code
+      #
+      def python(schema, **options)
+        Python.new(schema, **options).export
+      end
+
+      # Export schema as SQL CREATE TABLE
+      #
+      # @param schema [Schema] the schema to export
+      # @param options [Hash] export options (dialect: :postgresql/:mysql/:sqlite)
+      # @return [String] SQL statement string
+      #
+      def sql(schema, **options)
+        Sql.new(schema, **options).export
+      end
+
+      # Export schemas as GraphViz DOT
+      #
+      # @param schema [Schema, nil] single schema or nil for registry
+      # @param options [Hash] export options (registry, direction)
+      # @return [String] DOT string
+      #
+      def graphviz(schema = nil, **options)
+        Graphviz.new(schema, **options).export
+      end
+
+      # Export schema as GraphQL SDL
+      #
+      # @param schema [Schema] the schema to export
+      # @param options [Hash] export options (registry)
+      # @return [String] GraphQL SDL string
+      #
+      def graphql(schema, **options)
+        Graphql.new(schema, **options).export
+      end
+
+      # =====================================================================
+      # Data Export Methods
+      # =====================================================================
+
+      # Export generated data as JSON
+      #
+      # @param schema [Schema] the schema to generate from
+      # @param options [Hash] export options (count, seed, mode, pretty, envelope)
+      # @return [String] JSON string
+      #
+      def json_data(schema, **options)
+        JsonData.new(schema, **options).export
+      end
+
+      # Export generated data as CSV
+      #
+      # @param schema [Schema] the schema to generate from
+      # @param options [Hash] export options (count, seed, mode)
+      # @return [String] CSV string
+      #
+      def csv(schema, **options)
+        Csv.new(schema, **options).export
+      end
+
+      # Export generated data as SQL INSERT statements
+      #
+      # @param schema [Schema] the schema to generate from
+      # @param options [Hash] export options (count, seed, mode, dialect, batch_insert)
+      # @return [String] SQL INSERT statements
+      #
+      def sql_insert(schema, **options)
+        SqlInsert.new(schema, **options).export
+      end
+
+      # Export generated data as YAML
+      #
+      # @param schema [Schema] the schema to generate from
+      # @param options [Hash] export options (count, seed, mode, root_key)
+      # @return [String] YAML string
+      #
+      def yaml_data(schema, **options)
+        YamlData.new(schema, **options).export
+      end
+
+      # Export generated data as XML
+      #
+      # @param schema [Schema] the schema to generate from
+      # @param options [Hash] export options (count, seed, mode, root, item, indent)
+      # @return [String] XML string
+      #
+      def xml_data(schema, **options)
+        XmlData.new(schema, **options).export
+      end
+
+      # =====================================================================
+      # Bulk Export Methods
+      # =====================================================================
+
+      # Export all schemas from a registry to a format
+      #
+      # @param registry [Registry] the registry
+      # @param format [String, Symbol] the export format
+      # @param options [Hash] format-specific options
+      # @return [String] the exported content
+      #
+      def export_all(registry, format, **options)
+        format_key = format.to_s.downcase
+
+        case format_key
+        when "typescript", "ts"
+          Typescript.export_all(registry, **options)
+        when "javascript", "js"
+          Javascript.export_all(registry, **options)
+        when "python", "py", "pydantic", "dataclass"
+          options[:style] = :dataclass if format_key == "dataclass"
+          Python.export_all(registry, **options)
+        when "sql", "postgresql", "mysql", "sqlite", "sql-ddl"
+          options[:dialect] = format_key.to_sym if %w[postgresql mysql sqlite].include?(format_key)
+          Sql.export_all(registry, **options)
+        when "graphviz", "dot"
+          Graphviz.new(nil, registry: registry, **options).export
+        when "graphql", "gql"
+          Graphql.export_all(registry)
+        else
+          raise ArgumentError, "Bulk export not supported for format: #{format}"
+        end
+      end
+
+      # =====================================================================
+      # Utility Methods
+      # =====================================================================
+
+      # List available formats
+      #
+      # @return [Array<String>] available format names
+      #
+      def available_formats
+        FORMATS.keys.uniq.sort
+      end
+
+      # List schema export formats
+      #
+      # @return [Array<String>] schema format names
+      #
+      def schema_formats
+        SCHEMA_FORMATS.keys.uniq.sort
+      end
+
+      # List data export formats
+      #
+      # @return [Array<String>] data format names
+      #
+      def data_formats
+        DATA_FORMATS.keys.uniq.sort
+      end
+
+      # Check if format is for schema export
+      #
+      # @param format [String] format name
+      # @return [Boolean]
+      #
+      def schema_format?(format)
+        SCHEMA_FORMATS.key?(format.to_s.downcase)
+      end
+
+      # Check if format is for data export
+      #
+      # @param format [String] format name
+      # @return [Boolean]
+      #
+      def data_format?(format)
+        DATA_FORMATS.key?(format.to_s.downcase)
+      end
+
+      # Get file extension for a format
+      #
+      # @param format [String] format name
+      # @return [String] file extension with dot
+      #
+      def file_extension(format)
+        FILE_EXTENSIONS[format.to_s.downcase] || ".txt"
+      end
+
+      # Generate automatic filename
+      #
+      # @param schema_name [String] schema name
+      # @param format [String] format name
+      # @param options [Hash] additional options (prefix, suffix)
+      # @return [String] generated filename
+      #
+      def auto_filename(schema_name, format, **options)
+        prefix = options[:prefix] || ""
+        suffix = options[:suffix] || ""
+        ext = file_extension(format)
+        
+        base = to_snake_case(schema_name)
+        "#{prefix}#{base}#{suffix}#{ext}"
+      end
+
+      # Export and save to auto-generated file
+      #
+      # @param format [String] format name
+      # @param schema [Schema] schema to export
+      # @param output_dir [String] output directory
+      # @param options [Hash] export options
+      # @return [String] path to generated file
+      #
+      def export_to_file(format, schema, output_dir: ".", **options)
+        filename = auto_filename(schema.name, format, **options)
+        path = File.join(output_dir, filename)
+        
+        content = export(format, schema, **options)
+        File.write(path, content)
+        
+        path
+      end
+
+      private
+
+      def to_snake_case(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+  end
+end