synthra 0.1.0

data/lib/synthra/export/protobuf.rb

@@ -0,0 +1,483 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Export
+    # Protocol Buffers / gRPC Export
+    #
+    # Generates .proto files from Synthra schemas for use with gRPC services.
+    #
+    # @example Generate proto file
+    #   exporter = Synthra::Export::Protobuf.new(schema, registry: registry)
+    #   proto = exporter.export
+    #
+    # @example CLI usage
+    #   $ synthra export User -d schemas -f protobuf -o user.proto
+    #
+    class Protobuf
+      # Type mapping from Synthra to Protocol Buffers
+      TYPE_MAP = {
+        # Strings
+        "text" => "string",
+        "name" => "string",
+        "full_name" => "string",
+        "first_name" => "string",
+        "last_name" => "string",
+        "email" => "string",
+        "url" => "string",
+        "phone" => "string",
+        "address" => "string",
+        "city" => "string",
+        "state" => "string",
+        "country" => "string",
+        "country_code" => "string",
+        "postal_code" => "string",
+        "street" => "string",
+        "company" => "string",
+        "job_title" => "string",
+        "username" => "string",
+        "password" => "string",
+        "slug" => "string",
+        "sentence" => "string",
+        "paragraph" => "string",
+        "domain" => "string",
+        "ip" => "string",
+        "ipv6" => "string",
+        "mac_address" => "string",
+        "user_agent" => "string",
+        "color" => "string",
+        "hex_color" => "string",
+        "file_name" => "string",
+        "file_path" => "string",
+        "mime_type" => "string",
+        "credit_card" => "string",
+        "iban" => "string",
+        "bic" => "string",
+        "ssn" => "string",
+        "ein" => "string",
+        "license_plate" => "string",
+        "vin" => "string",
+
+        # IDs
+        "uuid" => "string",
+        "ulid" => "string",
+        "nanoid" => "string",
+
+        # Numbers (integers)
+        "number" => "int64",
+        "integer" => "int64",
+        "int" => "int32",
+        "int32" => "int32",
+        "int64" => "int64",
+        "age" => "int32",
+        "airport_elevation" => "int64",
+        "discount" => "int64",
+        "formula" => "int64",
+        "row_number" => "int64",
+        "sequence" => "int64",
+        "id_sequence" => "int64",
+
+        # Numbers (floats)
+        "float" => "double",
+        "double" => "double",
+        "money" => "double",
+        "decimal" => "string", # Decimal as string for precision
+        "percentage" => "double",
+        "latitude" => "double",
+        "longitude" => "double",
+        "airport_latitude" => "double",
+        "airport_longitude" => "double",
+        "product_price" => "double",
+        "tax_rate" => "double",
+        "transaction_amount" => "double",
+
+        # Boolean
+        "boolean" => "bool",
+        "bool" => "bool",
+
+        # Timestamps
+        "timestamp" => "google.protobuf.Timestamp",
+        "date" => "string", # ISO date string
+        "date_between" => "string",
+        "time" => "string", # ISO time string
+        "datetime" => "google.protobuf.Timestamp",
+        "now" => "string", # Date value rendered as ISO date string
+        "past_date" => "string",
+        "future_date" => "string",
+        "mobile_device_release_date" => "string",
+
+        # Binary
+        "binary" => "bytes",
+        "base64" => "bytes",
+
+        # Complex
+        "object" => "google.protobuf.Struct",
+        "json" => "string",
+        "array" => "repeated"
+      }.freeze
+
+      attr_reader :schema, :registry, :options
+
+      # Create a new Protobuf exporter
+      #
+      # @param schema [Schema] the schema to export
+      # @param registry [Registry] registry for resolving references
+      # @param options [Hash] export options
+      # @option options [String] :package package name (default: "generated")
+      # @option options [String] :go_package Go package path
+      # @option options [Boolean] :with_service generate gRPC service definition
+      # @option options [String] :syntax proto syntax version (default: "proto3")
+      #
+      def initialize(schema, registry: nil, **options)
+        @schema = schema
+        @registry = registry
+        @options = {
+          package: "generated",
+          syntax: "proto3",
+          with_service: true
+        }.merge(options)
+      end
+
+      # Export schema to Protocol Buffers format
+      #
+      # @return [String] .proto file content
+      #
+      def export
+        lines = []
+        
+        # Syntax declaration
+        lines << "syntax = \"#{@options[:syntax]}\";"
+        lines << ""
+        
+        # Package
+        lines << "package #{@options[:package]};"
+        lines << ""
+        
+        # Options
+        if @options[:go_package]
+          lines << "option go_package = \"#{@options[:go_package]}\";"
+          lines << ""
+        end
+        
+        # Imports
+        imports = collect_imports
+        if imports.any?
+          imports.each { |imp| lines << "import \"#{imp}\";" }
+          lines << ""
+        end
+        
+        # Enums (extracted from enum fields)
+        enums = extract_enums
+        enums.each do |enum|
+          lines << generate_enum(enum)
+          lines << ""
+        end
+        
+        # Message definition
+        lines << generate_message(@schema)
+        
+        # Generate referenced schemas
+        if @registry
+          referenced = collect_referenced_schemas
+          referenced.each do |ref_schema|
+            lines << ""
+            lines << generate_message(ref_schema)
+          end
+        end
+        
+        # gRPC Service definition
+        if @options[:with_service]
+          lines << ""
+          lines << generate_service
+        end
+        
+        lines.join("\n")
+      end
+
+      # Export all schemas from registry
+      #
+      # @param registry [Registry] schema registry
+      # @param options [Hash] export options
+      # @return [String] combined .proto file
+      #
+      def self.export_all(registry, **options)
+        lines = []
+        package = options[:package] || "generated"
+        
+        lines << "syntax = \"proto3\";"
+        lines << ""
+        lines << "package #{package};"
+        lines << ""
+        
+        if options[:go_package]
+          lines << "option go_package = \"#{options[:go_package]}\";"
+          lines << ""
+        end
+        
+        # Collect all imports
+        lines << "import \"google/protobuf/timestamp.proto\";"
+        lines << "import \"google/protobuf/struct.proto\";"
+        lines << ""
+        
+        # All enums first
+        all_enums = []
+        registry.names.each do |name|
+          schema = registry.schema(name)
+          schema.fields.each do |field|
+            if field.type_name == "enum" && field.type_args[:values]
+              enum_name = "#{schema.name}#{field.name.capitalize}"
+              all_enums << { name: enum_name, values: field.type_args[:values] }
+            end
+          end
+        end
+        
+        all_enums.uniq { |e| e[:name] }.each do |enum|
+          lines << generate_enum_static(enum)
+          lines << ""
+        end
+        
+        # All messages
+        registry.names.sort.each do |name|
+          schema = registry.schema(name)
+          exporter = new(schema, registry: registry, **options.merge(with_service: false))
+          lines << exporter.generate_message(schema)
+          lines << ""
+        end
+        
+        # Combined service
+        if options[:with_service] != false
+          lines << generate_combined_service(registry, package)
+        end
+        
+        lines.join("\n")
+      end
+
+      def generate_message(schema)
+        lines = []
+        lines << "message #{schema.name} {"
+        
+        schema.fields.each_with_index do |field, index|
+          field_num = index + 1
+          proto_type, field_options = field_to_proto(field)
+          
+          optional = field.optional? ? "optional " : ""
+          lines << "  #{optional}#{proto_type} #{to_snake_case(field.name)} = #{field_num};"
+        end
+        
+        lines << "}"
+        lines.join("\n")
+      end
+
+      private
+
+      def collect_imports
+        imports = Set.new
+        
+        @schema.fields.each do |field|
+          type = field.type_name
+          if %w[timestamp datetime now].include?(type)
+            imports.add("google/protobuf/timestamp.proto")
+          elsif type == "object"
+            imports.add("google/protobuf/struct.proto")
+          end
+        end
+        
+        imports.to_a.sort
+      end
+
+      def extract_enums
+        enums = []
+        @schema.fields.each do |field|
+          if field.type_name == "enum" && field.type_args[:values]
+            enum_name = "#{@schema.name}#{field.name.capitalize}"
+            enums << { name: enum_name, values: field.type_args[:values], field: field.name }
+          end
+        end
+        enums
+      end
+
+      def generate_enum(enum)
+        lines = []
+        lines << "enum #{enum[:name]} {"
+        lines << "  #{enum[:name].upcase}_UNSPECIFIED = 0;"
+        
+        enum[:values].each_with_index do |value, index|
+          value_str = value.respond_to?(:value) ? value.value : value.to_s
+          enum_value = "#{enum[:name].upcase}_#{value_str.upcase.gsub(/[^A-Z0-9]/, '_')}"
+          lines << "  #{enum_value} = #{index + 1};"
+        end
+        
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def self.generate_enum_static(enum)
+        lines = []
+        lines << "enum #{enum[:name]} {"
+        lines << "  #{enum[:name].upcase}_UNSPECIFIED = 0;"
+        
+        enum[:values].each_with_index do |value, index|
+          value_str = value.respond_to?(:value) ? value.value : value.to_s
+          enum_value = "#{enum[:name].upcase}_#{value_str.upcase.gsub(/[^A-Z0-9]/, '_')}"
+          lines << "  #{enum_value} = #{index + 1};"
+        end
+        
+        lines << "}"
+        lines.join("\n")
+      end
+
+      def field_to_proto(field)
+        type_name = field.type_name
+        
+        # Handle arrays
+        if type_name == "array"
+          element_type = field.type_args[:element]
+          if element_type && @registry&.schema?(element_type.to_s)
+            return ["repeated #{element_type}", {}]
+          else
+            inner_type = TYPE_MAP[element_type.to_s] || "string"
+            return ["repeated #{inner_type}", {}]
+          end
+        end
+        
+        # Handle enums
+        if type_name == "enum"
+          enum_name = "#{@schema.name}#{field.name.capitalize}"
+          return [enum_name, {}]
+        end
+        
+        # Handle schema references
+        if @registry&.schema?(type_name)
+          return [type_name, {}]
+        end
+        
+        # Handle const
+        if type_name == "const"
+          value = field.type_args[:value]
+          case value
+          when Integer then return ["int64", {}]
+          when Float then return ["double", {}]
+          when TrueClass, FalseClass then return ["bool", {}]
+          else return ["string", {}]
+          end
+        end
+        
+        # Standard type mapping
+        proto_type = TYPE_MAP[type_name] || "string"
+        [proto_type, {}]
+      end
+
+      def collect_referenced_schemas
+        return [] unless @registry
+        
+        referenced = Set.new
+        
+        @schema.fields.each do |field|
+          type_name = field.type_name
+          
+          if @registry.schema?(type_name)
+            referenced.add(@registry.schema(type_name))
+          end
+          
+          if type_name == "array"
+            element = field.type_args[:element]
+            if element && @registry.schema?(element.to_s)
+              referenced.add(@registry.schema(element.to_s))
+            end
+          end
+        end
+        
+        referenced.to_a
+      end
+
+      def generate_service
+        name = @schema.name
+        snake_name = to_snake_case(name)
+        
+        <<~SERVICE
+          // gRPC Service for #{name}
+          service #{name}Service {
+            // Get a single #{name} by ID
+            rpc Get#{name}(Get#{name}Request) returns (#{name});
+            
+            // List multiple #{name} records
+            rpc List#{name}s(List#{name}sRequest) returns (List#{name}sResponse);
+            
+            // Generate fake #{name} data
+            rpc Generate#{name}(Generate#{name}Request) returns (#{name});
+            
+            // Generate multiple fake #{name} records
+            rpc GenerateMany#{name}s(GenerateMany#{name}sRequest) returns (stream #{name});
+          }
+
+          message Get#{name}Request {
+            string id = 1;
+          }
+
+          message List#{name}sRequest {
+            int32 page = 1;
+            int32 page_size = 2;
+          }
+
+          message List#{name}sResponse {
+            repeated #{name} #{snake_name}s = 1;
+            int32 total_count = 2;
+            int32 page = 3;
+            int32 page_size = 4;
+          }
+
+          message Generate#{name}Request {
+            optional int64 seed = 1;
+            optional string mode = 2; // random, edge, invalid, hostile
+            map<string, string> overrides = 3;
+          }
+
+          message GenerateMany#{name}sRequest {
+            int32 count = 1;
+            optional int64 seed = 2;
+            optional string mode = 3;
+          }
+        SERVICE
+      end
+
+      def self.generate_combined_service(registry, package)
+        lines = []
+        lines << "// Combined Data Generation Service"
+        lines << "service DataGenerationService {"
+        
+        registry.names.sort.each do |name|
+          snake_name = name.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '')
+          lines << "  // Generate #{name}"
+          lines << "  rpc Generate#{name}(Generate#{name}Request) returns (#{name});"
+          lines << "  rpc GenerateMany#{name}s(GenerateManyRequest) returns (stream #{name});"
+        end
+        
+        lines << "}"
+        lines << ""
+        
+        # Common request messages
+        lines << "message GenerateManyRequest {"
+        lines << "  int32 count = 1;"
+        lines << "  optional int64 seed = 2;"
+        lines << "  optional string mode = 3;"
+        lines << "}"
+        
+        registry.names.sort.each do |name|
+          lines << ""
+          lines << "message Generate#{name}Request {"
+          lines << "  optional int64 seed = 1;"
+          lines << "  optional string mode = 2;"
+          lines << "  map<string, string> overrides = 3;"
+          lines << "}"
+        end
+        
+        lines.join("\n")
+      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