synthra 0.1.0

data/lib/synthra/export/graphql_federation.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Export
+    # GraphQL Federation Export
+    #
+    # Exports schemas to Apollo Federation v2 compatible GraphQL SDL.
+    # Includes @key directives, entity references, and subgraph support.
+    #
+    # @example Export federated schema
+    #   exporter = Synthra::Export::GraphQLFederation.new(registry)
+    #   sdl = exporter.export
+    #
+    # @example CLI
+    #   $ synthra export --all -f graphql-federation -o schema.graphql
+    #
+    class GraphQLFederation
+      # Type mapping from Synthra to GraphQL
+      TYPE_MAP = {
+        "text" => "String",
+        "name" => "String",
+        "email" => "String",
+        "url" => "String",
+        "uuid" => "ID",
+        "id_sequence" => "ID",
+        "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",
+        "timestamp" => "DateTime",
+        "datetime" => "DateTime",
+        "date" => "Date",
+        "object" => "JSON",
+        "map_by_field" => "JSON",
+        "array" => "[String]"
+      }.freeze
+
+      attr_reader :registry, :options
+
+      # Create new exporter
+      #
+      # @param registry [Registry] schema registry
+      # @param options [Hash] export options
+      # @option options [String] :service_name subgraph service name
+      # @option options [String] :service_url subgraph URL
+      # @option options [Array<String>] :key_fields default key fields
+      # @option options [Boolean] :include_mutations include mutation types
+      #
+      def initialize(registry, **options)
+        @registry = registry
+        @options = {
+          service_name: "fake-data-service",
+          service_url: "http://localhost:4000/graphql",
+          key_fields: %w[id uuid],
+          include_mutations: true,
+          include_subscriptions: false
+        }.merge(options)
+      end
+
+      # Export to Federation SDL
+      #
+      # @return [String] GraphQL SDL
+      #
+      def export
+        lines = []
+
+        # Federation schema extension
+        lines << federation_header
+        lines << ""
+
+        # Scalar definitions
+        lines << scalar_definitions
+        lines << ""
+
+        # Type definitions
+        @registry.names.sort.each do |name|
+          schema = @registry.schema(name)
+          lines << generate_type(schema)
+          lines << ""
+        end
+
+        # Query type
+        lines << generate_query_type
+        lines << ""
+
+        # Mutation type
+        if @options[:include_mutations]
+          lines << generate_mutation_type
+          lines << ""
+        end
+
+        # Subscription type
+        if @options[:include_subscriptions]
+          lines << generate_subscription_type
+          lines << ""
+        end
+
+        # Input types
+        @registry.names.sort.each do |name|
+          schema = @registry.schema(name)
+          lines << generate_input_type(schema)
+          lines << ""
+        end
+
+        lines.join("\n").strip
+      end
+
+      private
+
+      def federation_header
+        <<~HEADER
+          extend schema
+            @link(url: "https://specs.apollo.dev/federation/v2.0",
+                  import: ["@key", "@shareable", "@external", "@provides", "@requires"])
+        HEADER
+      end
+
+      def scalar_definitions
+        <<~SCALARS
+          scalar DateTime
+          scalar Date
+          scalar JSON
+        SCALARS
+      end
+
+      def generate_type(schema)
+        lines = []
+
+        # Type declaration with @key directive
+        key_field = find_key_field(schema)
+        key_directive = key_field ? %( @key(fields: "#{key_field}")) : ""
+
+        lines << "type #{schema.name}#{key_directive} {"
+
+        # Fields
+        schema.fields.each do |field|
+          graphql_type = field_to_graphql(field)
+          nullable = field.optional? || field.nullable? ? "" : "!"
+          directives = field_directives(field, schema)
+
+          lines << "  #{field.name}: #{graphql_type}#{nullable}#{directives}"
+        end
+
+        # Add relationship fields
+        add_relationship_fields(lines, schema)
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def generate_input_type(schema)
+        lines = []
+        lines << "input #{schema.name}Input {"
+
+        schema.fields.each do |field|
+          next if %w[id uuid created_at updated_at].include?(field.name)
+
+          graphql_type = field_to_graphql(field, input: true)
+          lines << "  #{field.name}: #{graphql_type}"
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def generate_query_type
+        lines = []
+        lines << "type Query {"
+
+        @registry.names.sort.each do |name|
+          snake_name = to_snake_case(name)
+
+          # Single record by ID
+          lines << "  #{snake_name}(id: ID!): #{name}"
+
+          # List with pagination
+          lines << "  #{snake_name}s(first: Int, after: String, filter: #{name}Input): #{name}Connection!"
+
+          # Generate fake data
+          lines << "  generate#{name}(seed: Int, mode: GenerationMode): #{name}!"
+          lines << "  generate#{name}s(count: Int!, seed: Int, mode: GenerationMode): [#{name}!]!"
+        end
+
+        # Schema introspection
+        lines << ""
+        lines << "  # Schema information"
+        lines << "  _schemas: [SchemaInfo!]!"
+        lines << "  _schema(name: String!): SchemaInfo"
+
+        lines << "}"
+
+        # Add supporting types
+        lines << ""
+        lines << generate_connection_types
+        lines << ""
+        lines << generate_schema_info_type
+        lines << ""
+        lines << generate_generation_mode_enum
+
+        lines.join("\n")
+      end
+
+      def generate_mutation_type
+        lines = []
+        lines << "type Mutation {"
+
+        @registry.names.sort.each do |name|
+          snake_name = to_snake_case(name)
+
+          lines << "  # Generate and optionally persist #{name}"
+          lines << "  create#{name}(input: #{name}Input, seed: Int): #{name}!"
+          lines << "  createMany#{name}s(count: Int!, input: #{name}Input, seed: Int): [#{name}!]!"
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def generate_subscription_type
+        lines = []
+        lines << "type Subscription {"
+
+        @registry.names.sort.each do |name|
+          snake_name = to_snake_case(name)
+          lines << "  #{snake_name}Generated: #{name}!"
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def generate_connection_types
+        types = @registry.names.map do |name|
+          <<~CONNECTION
+            type #{name}Connection {
+              edges: [#{name}Edge!]!
+              pageInfo: PageInfo!
+              totalCount: Int!
+            }
+
+            type #{name}Edge {
+              cursor: String!
+              node: #{name}!
+            }
+          CONNECTION
+        end
+
+        page_info = <<~PAGEINFO
+          type PageInfo {
+            hasNextPage: Boolean!
+            hasPreviousPage: Boolean!
+            startCursor: String
+            endCursor: String
+          }
+        PAGEINFO
+
+        [page_info, *types].join("\n")
+      end
+
+      def generate_schema_info_type
+        <<~SCHEMA_INFO
+          type SchemaInfo {
+            name: String!
+            fields: [FieldInfo!]!
+            behaviors: [String!]!
+          }
+
+          type FieldInfo {
+            name: String!
+            type: String!
+            optional: Boolean!
+            nullable: Boolean!
+          }
+        SCHEMA_INFO
+      end
+
+      def generate_generation_mode_enum
+        <<~ENUM
+          enum GenerationMode {
+            RANDOM
+            EDGE
+            INVALID
+            HOSTILE
+            MIXED
+          }
+        ENUM
+      end
+
+      def field_to_graphql(field, input: false)
+        type_name = field.type_name
+
+        # Handle arrays
+        if type_name == "array"
+          element = field.type_args[:element]
+          inner_type = if @registry.schema?(element.to_s)
+                         input ? "#{element}Input" : element.to_s
+                       else
+                         TYPE_MAP[element.to_s] || "String"
+                       end
+          return "[#{inner_type}!]"
+        end
+
+        # Handle enums
+        if type_name == "enum"
+          return "#{field.name.capitalize}Enum"
+        end
+
+        # Handle references
+        if @registry.schema?(type_name)
+          return input ? "#{type_name}Input" : type_name
+        end
+
+        TYPE_MAP[type_name] || "String"
+      end
+
+      def field_directives(field, schema)
+        directives = []
+
+        # Mark shareable fields
+        if %w[id uuid].include?(field.name)
+          # Key fields are automatically shareable
+        elsif field.type_name == "timestamp"
+          directives << "@shareable"
+        end
+
+        # External references
+        if field.type_name.start_with?("Ref(")
+          directives << "@external"
+        end
+
+        directives.empty? ? "" : " #{directives.join(' ')}"
+      end
+
+      def add_relationship_fields(lines, schema)
+        # Check for relationship indicators in field names
+        schema.fields.each do |field|
+          if field.name.end_with?("_id") && !field.name.start_with?("external_")
+            # Infer relationship
+            related_name = field.name.sub(/_id$/, "").split("_").map(&:capitalize).join
+            if @registry.schema?(related_name)
+              lines << ""
+              lines << "  # Resolved relationship"
+              lines << "  #{to_snake_case(related_name)}: #{related_name} @provides(fields: \"id\")"
+            end
+          end
+        end
+      end
+
+      def find_key_field(schema)
+        @options[:key_fields].each do |key|
+          return key if schema.fields.any? { |f| f.name == key }
+        end
+        nil
+      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
+    end
+  end
+end

data/lib/synthra/export/graphviz.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports schemas as GraphViz DOT format
+    #
+    # @example Export a registry as DOT
+    #   exporter = Graphviz.new(registry: registry)
+    #   dot = exporter.export
+    #
+    class Graphviz < Base
+      # Color schemes for different schema types
+      COLORS = {
+        default: "black",
+        deprecated: "gray",
+        main: "#2563eb",
+        nested: "#059669"
+      }.freeze
+
+      # Edge styles for different relationship types
+      EDGE_STYLES = {
+        embed: "",
+        array: "style=dashed",
+        map_by_field: "style=dotted",
+        reference: "style=bold, color=\"#dc2626\""
+      }.freeze
+
+      def initialize(schema = nil, registry: nil, **options)
+        super
+        @registry = registry
+      end
+
+      def export
+        lines = []
+        lines << "digraph Synthra {"
+        lines << "  // Graph settings"
+        lines << "  rankdir=#{options[:direction] || 'LR'};"
+        lines << "  splines=ortho;" if options[:ortho]
+        lines << "  node [shape=record, fontname=\"#{options[:font] || 'Helvetica'}\", fontsize=10];"
+        lines << "  edge [fontname=\"#{options[:font] || 'Helvetica'}\", fontsize=9];"
+        lines << ""
+
+        if @registry
+          lines << build_registry_graph
+        elsif @schema
+          lines << build_schema_node(@schema)
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      # Render DOT to image format using graphviz
+      #
+      # @param output_path [String] output file path
+      # @param format [Symbol] output format (:png, :svg, :pdf)
+      # @return [Boolean] true if successful
+      #
+      def render(output_path, format: :png)
+        dot_content = export
+        
+        require "tempfile"
+        Tempfile.create(["schema", ".dot"]) do |dot_file|
+          dot_file.write(dot_content)
+          dot_file.flush
+          
+          system("dot", "-T#{format}", dot_file.path, "-o", output_path)
+        end
+      end
+
+      private
+
+      def build_registry_graph
+        lines = []
+
+        # Group schemas by category if specified
+        if options[:group]
+          lines.concat(build_grouped_nodes)
+        else
+          @registry.schemas.each do |name, schema|
+            lines << build_schema_node(schema)
+          end
+        end
+
+        lines << ""
+
+        # Add edges
+        @registry.schemas.each do |name, schema|
+          lines.concat(build_schema_edges(schema))
+        end
+
+        lines
+      end
+
+      def build_grouped_nodes
+        lines = []
+        groups = Hash.new { |h, k| h[k] = [] }
+
+        @registry.schemas.each do |name, schema|
+          group = detect_group(name)
+          groups[group] << schema
+        end
+
+        groups.each do |group, schemas|
+          lines << "  subgraph cluster_#{group} {"
+          lines << "    label=\"#{group.capitalize}\";"
+          lines << "    style=dashed;"
+          schemas.each { |s| lines << build_schema_node(s, indent: 4) }
+          lines << "  }"
+        end
+
+        lines
+      end
+
+      def detect_group(name)
+        case name
+        when /User|Profile|Account/i then "users"
+        when /Order|Cart|Payment/i then "commerce"
+        when /Message|Chat|DM/i then "messaging"
+        when /API|Response|Request/i then "api"
+        else "other"
+        end
+      end
+
+      def build_schema_node(target_schema, indent: 2)
+        prefix = " " * indent
+        name = target_schema.name
+        
+        fields = target_schema.fields.map do |f|
+          optional = f.optional? ? "?" : ""
+          nullable = f.nullable? ? "?" : ""
+          type_info = format_type(f)
+          "#{f.name}#{optional}: #{type_info}#{nullable}"
+        end
+
+        # Escape special characters for DOT
+        escaped_fields = fields.map { |f| escape_dot(f) }.join("\\l")
+        label = "{#{name}|#{escaped_fields}\\l}"
+
+        color = target_schema.deprecated? ? COLORS[:deprecated] : COLORS[:default]
+        style = target_schema.deprecated? ? ", style=dashed" : ""
+
+        "#{prefix}#{name} [label=\"#{label}\", color=\"#{color}\"#{style}];"
+      end
+
+      def build_schema_edges(source_schema)
+        lines = []
+
+        source_schema.fields.each do |field|
+          edges = field_to_edges(source_schema.name, field)
+          lines.concat(edges)
+        end
+
+        lines
+      end
+
+      def field_to_edges(source_name, field)
+        edges = []
+        type_name = field.type_name
+        type_args = field.type_args
+
+        # Direct schema reference
+        if schema_in_registry?(type_name)
+          edges << build_edge(source_name, type_name, field.name, :embed)
+        end
+
+        # Array element type
+        if type_name == "array"
+          element = type_args[:element]
+          if element && schema_in_registry?(element.to_s)
+            edges << build_edge(source_name, element.to_s, "#{field.name}[]", :array)
+          end
+        end
+
+        # map_by_field entries
+        if type_name == "map_by_field"
+          entries = type_args[:entries] || {}
+          entries.each do |entry_name, entry_info|
+            schema_name = entry_info.is_a?(Hash) ? (entry_info[:schema] || entry_info["schema"]) : entry_info.to_s
+            if schema_name && schema_in_registry?(schema_name)
+              shared = entry_info.is_a?(Hash) && entry_info[:shared]
+              label = shared ? "#{field.name}.#{entry_name} (shared)" : "#{field.name}.#{entry_name}"
+              edges << build_edge(source_name, schema_name, label, :map_by_field)
+            end
+          end
+        end
+
+        # one_of schemas
+        if type_name == "one_of"
+          schemas = type_args[:schemas] || []
+          schemas.each do |s|
+            schema_name = s.is_a?(Hash) ? (s[:schema] || s["schema"]) : s.to_s
+            if schema_name && schema_in_registry?(schema_name)
+              edges << build_edge(source_name, schema_name, "#{field.name}|", :reference)
+            end
+          end
+        end
+
+        # Ref() references
+        if type_name == "reference"
+          ref = type_args[:ref]
+          if ref.respond_to?(:schema_name) && schema_in_registry?(ref.schema_name)
+            edges << build_edge(source_name, ref.schema_name, "Ref(#{ref.schema_name}.#{ref.field_path})", :reference)
+          end
+        end
+
+        edges
+      end
+
+      def build_edge(source, target, label, type)
+        style = EDGE_STYLES[type] || ""
+        style_attr = style.empty? ? "" : ", #{style}"
+        "  #{source} -> #{target} [label=\"#{escape_dot(label)}\"#{style_attr}];"
+      end
+
+      def format_type(field)
+        type_name = field.type_name
+        type_args = field.type_args
+
+        case type_name
+        when "array"
+          element = type_args[:element] || "?"
+          "#{element}[]"
+        when "enum"
+          values = type_args[:values]&.map { |v| v.respond_to?(:value) ? v.value : v } || []
+          values.length <= 3 ? values.join("|") : "enum(#{values.length})"
+        when "const"
+          "\"#{type_args[:value]}\""
+        when "one_of"
+          schemas = type_args[:schemas] || []
+          names = schemas.map { |s| s.is_a?(Hash) ? s[:schema] : s.to_s }
+          names.length <= 2 ? names.join("|") : "one_of(#{names.length})"
+        else
+          type_name
+        end
+      end
+
+      def schema_in_registry?(name)
+        @registry&.schema?(name) || false
+      end
+
+      def escape_dot(str)
+        str.to_s
+           .gsub("\\", "\\\\")
+           .gsub("\"", "\\\"")
+           .gsub("{", "\\{")
+           .gsub("}", "\\}")
+           .gsub("<", "\\<")
+           .gsub(">", "\\>")
+           .gsub("|", "\\|")
+      end
+    end
+    # :nocov:
+  end
+end
+
+