synthra 0.1.0

data/lib/synthra/export/base.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Synthra
+  module Export
+    # Base class for all exporters
+    #
+    # Provides common functionality for exporting schemas to different formats.
+    #
+    # @abstract Subclass and implement {#export} to create an exporter
+    #
+    class Base
+      # @return [Schema] the schema to export
+      attr_reader :schema
+
+      # @return [Registry] the registry for resolving references
+      attr_reader :registry
+
+      # @return [Hash] export options
+      attr_reader :options
+
+      # Create a new exporter
+      #
+      # @param schema [Schema] the schema to export
+      # @param registry [Registry] the registry for resolving references
+      # @param options [Hash] export options
+      #
+      def initialize(schema, registry: nil, **options)
+        @schema = schema
+        @registry = registry
+        @options = options
+      end
+
+      # Export the schema to the target format
+      #
+      # @return [String] the exported content
+      # @abstract
+      #
+      def export
+        raise NotImplementedError, "Subclasses must implement #export"
+      end
+
+      # Save export to a file
+      #
+      # @param path [String] file path
+      # @return [void]
+      #
+      def save(path)
+        File.write(path, export)
+      end
+
+      protected
+
+      # Get all fields including from nested schemas
+      #
+      # @return [Array<Field>] all fields
+      #
+      def all_fields
+        schema.fields
+      end
+
+      # Check if a type is a schema reference
+      #
+      # @param type_name [String] the type name
+      # @return [Boolean]
+      #
+      def schema_reference?(type_name)
+        registry&.schema?(type_name) || false
+      end
+
+      # Get referenced schema
+      #
+      # @param type_name [String] the type name
+      # @return [Schema, nil]
+      #
+      def get_schema(type_name)
+        registry&.schema(type_name)
+      rescue KeyError
+        nil # schema not found
+      end
+    end
+    # :nocov:
+  end
+end
+

data/lib/synthra/export/csv.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "csv"
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports generated data as CSV
+    #
+    # @example Export schema data as CSV
+    #   exporter = Csv.new(schema, registry: registry, count: 100)
+    #   csv = exporter.export
+    #
+    class Csv < Base
+      def export
+        count = options[:count] || 10
+        seed = options[:seed]
+        mode = options[:mode] || :random
+        
+        records = schema.generate_many(count, seed: seed, mode: mode, registry: registry)
+        
+        return "" if records.empty?
+
+        # Flatten nested objects for CSV
+        flat_records = records.map { |r| flatten_record(r) }
+        
+        # Get all possible headers
+        headers = flat_records.flat_map(&:keys).uniq.sort
+
+        CSV.generate do |csv|
+          csv << headers
+          flat_records.each do |record|
+            csv << headers.map { |h| format_value(record[h]) }
+          end
+        end
+      end
+
+      # Export with headers only (no data)
+      #
+      # @return [String] CSV header row
+      #
+      def export_headers
+        headers = schema.fields.map(&:name)
+        CSV.generate { |csv| csv << headers }
+      end
+
+      private
+
+      def flatten_record(record, prefix = "")
+        result = {}
+
+        record.each do |key, value|
+          full_key = prefix.empty? ? key : "#{prefix}.#{key}"
+
+          case value
+          when Hash
+            result.merge!(flatten_record(value, full_key))
+          when Array
+            if value.first.is_a?(Hash)
+              # Array of objects - just count them
+              result[full_key] = "[#{value.length} items]"
+            else
+              result[full_key] = value.join("; ")
+            end
+          else
+            result[full_key] = value
+          end
+        end
+
+        result
+      end
+
+      def format_value(value)
+        case value
+        when nil
+          ""
+        when true
+          "true"
+        when false
+          "false"
+        when Array
+          escape_csv_formula(value.join("; "))
+        when Hash
+          escape_csv_formula(JSON.generate(value))
+        when String
+          escape_csv_formula(value)
+        else
+          value.to_s # numerics/dates are safe — never prefix them (would break -5, =NA values stay strings)
+        end
+      end
+
+      # SECURITY (CSV injection): a string value beginning with = + - @ tab or CR is treated as a
+      # formula by spreadsheet apps that open the export. Prefix it with a single quote so the cell
+      # is rendered as literal text. The gem ships a `hostile_payloads` type that emits exactly these.
+      def escape_csv_formula(str)
+        str.match?(/\A[=+\-@\t\r]/) ? "'#{str}" : str
+      end
+    end
+    # :nocov:
+  end
+end

data/lib/synthra/export/graphql.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Export
+    # GraphQL schema export
+    #
+    # Exports Synthra schemas to GraphQL SDL (Schema Definition Language).
+    #
+    # @example Export single schema
+    #   exporter = Graphql.new(schema, registry: registry)
+    #   graphql_schema = exporter.export
+    #
+    # @example Export all schemas
+    #   graphql_schema = Graphql.export_all(registry)
+    #
+    class Graphql < Base
+      # Type mapping from Synthra types to GraphQL scalars
+      TYPE_MAP = {
+        "uuid" => "ID",
+        "ulid" => "ID",
+        "id_sequence" => "ID",
+        "snowflake_id" => "ID",
+        "numeric_string_id" => "ID",
+        "email" => "String",
+        "url" => "String",
+        "text" => "String",
+        "name" => "String",
+        "first_name" => "String",
+        "last_name" => "String",
+        "full_name" => "String",
+        "username" => "String",
+        "phone" => "String",
+        "address" => "String",
+        "city" => "String",
+        "state" => "String",
+        "country" => "String",
+        "country_code" => "String",
+        "postal_code" => "String",
+        "ip" => "String",
+        "ipv6" => "String",
+        "domain" => "String",
+        "user_agent" => "String",
+        "password" => "String",
+        "color" => "String",
+        "hex_color" => "String",
+        "number" => "Int",
+        "integer" => "Int",
+        "age" => "Int",
+        "airport_elevation" => "Int",
+        "discount" => "Int",
+        "formula" => "Int",
+        "row_number" => "Int",
+        "sequence" => "Int",
+        "float" => "Float",
+        "money" => "Float",
+        "latitude" => "Float",
+        "longitude" => "Float",
+        "airport_latitude" => "Float",
+        "airport_longitude" => "Float",
+        "product_price" => "Float",
+        "tax_rate" => "Float",
+        "transaction_amount" => "Float",
+        "boolean" => "Boolean",
+        "date" => "String",
+        "date_between" => "String",
+        "past_date" => "String",
+        "future_date" => "String",
+        "mobile_device_release_date" => "String",
+        "timestamp" => "String",
+        "datetime" => "String",
+        "now" => "String",
+        "time" => "String"
+      }.freeze
+
+      # Export single schema to GraphQL
+      #
+      # @return [String] GraphQL type definition
+      #
+      def export
+        lines = []
+        
+        # Add custom scalar definitions
+        lines << "# Synthra Generated GraphQL Schema"
+        lines << "# Generated at: #{Time.now.iso8601}"
+        lines << ""
+        
+        # Build type
+        lines << build_type(@schema)
+        
+        lines.join("\n")
+      end
+
+      # Export all schemas to GraphQL
+      #
+      # @param registry [Registry] schema registry
+      # @return [String] complete GraphQL schema
+      #
+      def self.export_all(registry)
+        lines = []
+        lines << "# Synthra Generated GraphQL Schema"
+        lines << "# Generated at: #{Time.now.iso8601}"
+        lines << ""
+        
+        enums = []
+        types = []
+        
+        registry.schemas.each_value do |schema|
+          exporter = new(schema, registry: registry)
+          types << exporter.build_type(schema)
+          enums.concat(exporter.collect_enums(schema))
+        end
+        
+        # Add enums first
+        enums.uniq.each do |enum_def|
+          lines << enum_def
+          lines << ""
+        end
+        
+        # Add types
+        types.each do |type_def|
+          lines << type_def
+          lines << ""
+        end
+        
+        # Add Query type
+        lines << build_query_type(registry)
+        
+        lines.join("\n")
+      end
+
+      # Build a GraphQL type from a schema
+      #
+      # @param schema [Schema] the schema to convert
+      # @return [String] GraphQL type definition
+      #
+      def build_type(schema)
+        lines = []
+        
+        # Add description if available
+        if schema.deprecated?
+          lines << "\"\"\"#{schema.deprecation_message || 'This type is deprecated'}\"\"\""
+        end
+        
+        lines << "type #{schema.name} {"
+        
+        schema.fields.each do |field|
+          field_def = build_field(field)
+          lines << "  #{field_def}"
+        end
+        
+        lines << "}"
+        
+        lines.join("\n")
+      end
+
+      # Collect enum definitions from a schema
+      #
+      # @param schema [Schema] the schema to scan
+      # @return [Array<String>] enum definitions
+      #
+      def collect_enums(schema)
+        enums = []
+        
+        schema.fields.each do |field|
+          if field.type_name == "enum"
+            enum_def = build_enum(schema.name, field)
+            enums << enum_def if enum_def
+          end
+        end
+        
+        enums
+      end
+
+      private
+
+      def build_field(field)
+        graphql_type = field_to_graphql_type(field)
+        nullable = field.optional? || field.nullable?
+        required_marker = nullable ? "" : "!"
+        
+        deprecated = ""
+        if field.behaviors.any? { |b| b[:name] == :deprecated }
+          deprecated = " @deprecated"
+        end
+        
+        "#{field.name}: #{graphql_type}#{required_marker}#{deprecated}"
+      end
+
+      def field_to_graphql_type(field)
+        type_name = field.type_name
+        
+        # Handle enums
+        if type_name == "enum"
+          return enum_type_name(field)
+        end
+        
+        # Handle const
+        if type_name == "const"
+          value = field.type_args[:value]
+          return case value
+                 when String then "String"
+                 when Integer then "Int"
+                 when Float then "Float"
+                 when TrueClass, FalseClass then "Boolean"
+                 else "String"
+                 end
+        end
+        
+        # Handle arrays. The element is either a scalar type (map it; unknown scalars → String,
+        # matching the scalar fallback) or a schema reference (a PascalCase schema name — keep it).
+        if type_name == "array"
+          element_str = field.type_args[:element].to_s
+          element_graphql = TYPE_MAP[element_str] || (element_str.match?(/\A[A-Z]/) ? element_str : "String")
+          return "[#{element_graphql}!]"
+        end
+        
+        # Handle schema references
+        if @registry&.schema?(type_name)
+          return type_name
+        end
+        
+        # Handle known types
+        TYPE_MAP[type_name] || "String"
+      end
+
+      def enum_type_name(field)
+        # Generate enum type name from field context
+        "#{@schema.name}#{field.name.split('_').map(&:capitalize).join}Enum"
+      end
+
+      def build_enum(schema_name, field)
+        enum_name = "#{schema_name}#{field.name.split('_').map(&:capitalize).join}Enum"
+        values = field.type_args[:values]
+        
+        return nil unless values&.any?
+        
+        lines = ["enum #{enum_name} {"]
+        
+        values.each do |val|
+          value_str = val.respond_to?(:value) ? val.value : val.to_s
+          # GraphQL enum values must be SCREAMING_SNAKE_CASE
+          graphql_value = value_str.to_s.upcase.gsub(/[^A-Z0-9_]/, "_")
+          lines << "  #{graphql_value}"
+        end
+        
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def self.build_query_type(registry)
+        lines = ["type Query {"]
+        
+        registry.schemas.each do |name, _schema|
+          singular = name.downcase
+          plural = "#{singular}s"
+          
+          lines << "  #{singular}(id: ID!): #{name}"
+          lines << "  #{plural}(limit: Int = 10, offset: Int = 0): [#{name}!]!"
+        end
+        
+        lines << "}"
+        lines.join("\n")
+      end
+    end
+  end
+end