synthra 0.1.0

data/lib/synthra/mock_server.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "json"
+require "fileutils"
+require "monitor" # thread-safety for recordings + rate-limit counters (WEBrick = 1 thread/req)
+
+module Synthra
+  # Production-Ready Mock Server with Recording
+  #
+  # A full-featured mock server that can:
+  # - Serve generated data via REST API
+  # - Record real API responses for replay
+  # - Support multiple response modes
+  # - Handle rate limiting and behaviors
+  #
+  # @example Start server
+  #   Synthra::MockServer.start(schema_dir: "schemas/", port: 3000)
+  #
+  # @example With recording
+  #   server = Synthra::MockServer.new(schema_dir: "schemas/", recording: true)
+  #   server.start
+  #
+  class MockServer
+    attr_reader :registry, :options, :recordings
+
+    DEFAULT_PORT = 3000
+
+    # Create a new mock server
+    #
+    # @param schema_dir [String] directory containing DSL schemas
+    # @param options [Hash] server options
+    # @option options [Integer] :port Server port (default: 3000)
+    # @option options [Boolean] :recording Enable request recording
+    # @option options [String] :recordings_dir Directory for recordings
+    # @option options [Boolean] :cors Enable CORS headers
+    # @option options [Integer] :rate_limit Requests per minute (0 = unlimited)
+    # @option options [Symbol] :default_mode Default generation mode
+    #
+    def initialize(schema_dir:, **options)
+      @options = {
+        port: DEFAULT_PORT,
+        recording: false,
+        recordings_dir: "recordings",
+        cors: true,
+        rate_limit: 0,
+        default_mode: :random
+      }.merge(options)
+
+      @registry = Registry.new
+      @registry.load_dir(schema_dir)
+      @recordings = {}
+      @request_counts = Hash.new(0)
+      @last_reset = Time.now
+      # Monitor (reentrant) so handle_recording can call save_recordings without self-deadlock.
+      @mutex = Monitor.new
+
+      load_recordings if @options[:recording]
+    end
+
+    # Start the mock server
+    def start
+      # :nocov: binds a real TCP port and blocks on WEBrick#start — exercised via integration use.
+      puts banner
+      puts ""
+      puts "📊 Available schemas: #{@registry.names.sort.join(', ')}"
+      puts ""
+      puts "🔗 Endpoints:"
+      puts "   GET  /api/schemas              - List all schemas"
+      puts "   GET  /api/:schema              - Generate single record"
+      puts "   GET  /api/:schema/batch        - Generate multiple records"
+      puts "   GET  /api/:schema/stream       - Stream records (NDJSON)"
+      puts "   POST /api/:schema              - Generate with overrides"
+      puts "   GET  /api/:schema/schema       - Get schema definition"
+      puts ""
+      if @options[:recording]
+        puts "📼 Recording mode: ENABLED"
+        puts "   POST /api/recordings/:name     - Save recording"
+        puts "   GET  /api/recordings/:name     - Replay recording"
+        puts ""
+      end
+      puts "Press Ctrl+C to stop"
+      puts ""
+
+      @server = WEBrick::HTTPServer.new(
+        Port: @options[:port],
+        Logger: WEBrick::Log.new($stderr, WEBrick::Log::INFO),
+        AccessLog: [[File.open("/dev/null", "w"), WEBrick::AccessLog::COMBINED_LOG_FORMAT]]
+      )
+
+      setup_routes
+
+      trap("INT") { @server.shutdown }
+      @server.start
+      # :nocov:
+    end
+
+    # Start server in background thread
+    def start_async
+      # :nocov: spawns a thread that binds a port — integration-only.
+      Thread.new { start }
+      # :nocov:
+    end
+
+    # Stop the server
+    def stop
+      @server&.shutdown
+    end
+
+    class << self
+      def start(**options)
+        new(**options).start
+      end
+    end
+
+    private
+
+    def banner
+      <<~BANNER
+        ╔═══════════════════════════════════════════════════════════════╗
+        ║                                                               ║
+        ║   🎲 Synthra Mock Server                                  ║
+        ║                                                               ║
+        ║   Production-ready data generation API                        ║
+        ║   http://localhost:#{@options[:port].to_s.ljust(5)}                                     ║
+        ║                                                               ║
+        ╚═══════════════════════════════════════════════════════════════╝
+      BANNER
+    end
+
+    def setup_routes
+      # CORS preflight
+      @server.mount_proc "/" do |req, res|
+        add_cors_headers(res) if @options[:cors]
+        
+        if req.request_method == "OPTIONS"
+          res.status = 204
+          next
+        end
+
+        # Rate limiting
+        if @options[:rate_limit] > 0 && rate_limited?(req)
+          res.status = 429
+          res["Content-Type"] = "application/json"
+          res.body = JSON.generate({ error: "Rate limit exceeded" })
+          next
+        end
+
+        route_request(req, res)
+      end
+    end
+
+    def route_request(req, res)
+      path = req.path
+      method = req.request_method
+
+      case path
+      when "/api/schemas"
+        handle_list_schemas(req, res)
+      when %r{^/api/recordings/(.+)$}
+        handle_recording(req, res, $1)
+      when %r{^/api/([^/]+)/batch$}
+        handle_batch_generate(req, res, $1)
+      when %r{^/api/([^/]+)/stream$}
+        handle_stream_generate(req, res, $1)
+      when %r{^/api/([^/]+)/schema$}
+        handle_schema_info(req, res, $1)
+      when %r{^/api/([^/]+)$}
+        if method == "POST"
+          handle_generate_with_overrides(req, res, $1)
+        else
+          handle_generate(req, res, $1)
+        end
+      else
+        res.status = 404
+        res["Content-Type"] = "application/json"
+        res.body = JSON.generate({ error: "Not found", path: path })
+      end
+    end
+
+    def handle_list_schemas(_req, res)
+      res["Content-Type"] = "application/json"
+      res.body = JSON.pretty_generate({
+        schemas: @registry.names.sort,
+        count: @registry.names.count,
+        endpoints: @registry.names.map { |n| "/api/#{to_snake_case(n)}" }
+      })
+    end
+
+    def handle_generate(req, res, schema_name)
+      schema_name = normalize_schema_name(schema_name)
+      
+      unless @registry.schema?(schema_name)
+        res.status = 404
+        res["Content-Type"] = "application/json"
+        res.body = JSON.generate({
+          error: "Schema not found",
+          schema: schema_name,
+          available: @registry.names
+        })
+        return
+      end
+
+      schema = @registry.schema(schema_name)
+      params = parse_query_params(req)
+      
+      data = schema.generate(
+        seed: params[:seed],
+        mode: params[:mode] || @options[:default_mode],
+        registry: @registry
+      )
+
+      # Apply behaviors (latency, failure)
+      apply_behaviors(schema, res)
+
+      res["Content-Type"] = "application/json"
+      res.body = JSON.pretty_generate(data)
+
+      record_response(schema_name, data) if @options[:recording]
+    end
+
+    def handle_generate_with_overrides(req, res, schema_name)
+      schema_name = normalize_schema_name(schema_name)
+      
+      unless @registry.schema?(schema_name)
+        res.status = 404
+        res["Content-Type"] = "application/json"
+        res.body = JSON.generate({ error: "Schema not found" })
+        return
+      end
+
+      schema = @registry.schema(schema_name)
+      body = JSON.parse(req.body || "{}") rescue {}
+      
+      overrides = body["overrides"] || {}
+      count = body["count"] || 1
+      seed = body["seed"]
+      mode = (body["mode"] || @options[:default_mode]).to_sym
+
+      if count > 1
+        data = schema.generate_many(count, seed: seed, mode: mode, registry: @registry, overrides: overrides)
+      else
+        data = schema.generate(seed: seed, mode: mode, registry: @registry, overrides: overrides)
+      end
+
+      apply_behaviors(schema, res)
+
+      res["Content-Type"] = "application/json"
+      res.body = JSON.pretty_generate(data)
+    end
+
+    def handle_batch_generate(req, res, schema_name)
+      schema_name = normalize_schema_name(schema_name)
+      
+      unless @registry.schema?(schema_name)
+        res.status = 404
+        res["Content-Type"] = "application/json"
+        res.body = JSON.generate({ error: "Schema not found" })
+        return
+      end
+
+      schema = @registry.schema(schema_name)
+      params = parse_query_params(req)
+      count = [params[:count] || 10, 10000].min
+
+      data = schema.generate_many(
+        count,
+        seed: params[:seed],
+        mode: params[:mode] || @options[:default_mode],
+        registry: @registry
+      )
+
+      apply_behaviors(schema, res)
+
+      res["Content-Type"] = "application/json"
+      res.body = JSON.pretty_generate({
+        data: data,
+        meta: {
+          count: data.length,
+          seed: params[:seed],
+          mode: (params[:mode] || @options[:default_mode]).to_s,
+          schema: schema_name
+        }
+      })
+    end
+
+    def handle_stream_generate(req, res, schema_name)
+      schema_name = normalize_schema_name(schema_name)
+      
+      unless @registry.schema?(schema_name)
+        res.status = 404
+        res["Content-Type"] = "application/json"
+        res.body = JSON.generate({ error: "Schema not found" })
+        return
+      end
+
+      schema = @registry.schema(schema_name)
+      params = parse_query_params(req)
+      count = [params[:count] || 100, 100000].min
+
+      res["Content-Type"] = "application/x-ndjson"
+      res["Transfer-Encoding"] = "chunked"
+
+      # Stream NDJSON
+      output = +""
+      schema.generate_stream(count: count, mode: params[:mode] || @options[:default_mode]).each do |record|
+        output << JSON.generate(record) << "\n"
+      end
+      res.body = output
+    end
+
+    def handle_schema_info(_req, res, schema_name)
+      schema_name = normalize_schema_name(schema_name)
+      
+      unless @registry.schema?(schema_name)
+        res.status = 404
+        res["Content-Type"] = "application/json"
+        res.body = JSON.generate({ error: "Schema not found" })
+        return
+      end
+
+      schema = @registry.schema(schema_name)
+      
+      res["Content-Type"] = "application/json"
+      res.body = JSON.pretty_generate({
+        name: schema.name,
+        fields: schema.fields.map do |f|
+          {
+            name: f.name,
+            type: f.type_name,
+            optional: f.optional?,
+            nullable: f.nullable?,
+            args: f.type_args
+          }
+        end,
+        behaviors: schema.behaviors,
+        version: schema.respond_to?(:version) ? schema.version : nil
+      })
+    end
+
+    def handle_recording(req, res, name)
+      @mutex.synchronize do
+        if req.request_method == "POST"
+          # Save recording
+          body = JSON.parse(req.body || "{}") rescue {}
+          @recordings[name] = {
+            data: body["data"],
+            recorded_at: Time.now.iso8601,
+            content_type: body["content_type"] || "application/json"
+          }
+          save_recordings
+
+          res["Content-Type"] = "application/json"
+          res.body = JSON.generate({ saved: name })
+        elsif @recordings[name]
+          recording = @recordings[name]
+          res["Content-Type"] = recording["content_type"] || "application/json"
+          res.body = recording["data"].is_a?(String) ? recording["data"] : JSON.generate(recording["data"])
+        else
+          res.status = 404
+          res["Content-Type"] = "application/json"
+          res.body = JSON.generate({ error: "Recording not found", name: name })
+        end
+      end
+    end
+
+    def parse_query_params(req)
+      query = req.query || {}
+      {
+        seed: query["seed"]&.to_i,
+        mode: query["mode"]&.to_sym,
+        count: query["count"]&.to_i
+      }
+    end
+
+    def normalize_schema_name(name)
+      # Convert snake_case to PascalCase
+      name.split("_").map(&:capitalize).join
+    end
+
+    def apply_behaviors(schema, res)
+      schema.behaviors.each do |behavior|
+        case behavior[:type]
+        when :latency
+          min_ms = behavior[:min_ms] || 0
+          max_ms = behavior[:max_ms] || min_ms
+          delay = rand(min_ms..max_ms) / 1000.0
+          sleep(delay)
+        when :failure
+          if rand < (behavior[:rate] || 0)
+            res.status = behavior[:status] || 500
+            throw :response_sent
+          end
+        end
+      end
+    end
+
+    def add_cors_headers(res)
+      res["Access-Control-Allow-Origin"] = "*"
+      res["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+      res["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+      res["Access-Control-Max-Age"] = "86400"
+    end
+
+    def rate_limited?(req)
+      client_ip = req.peeraddr[2]
+      @mutex.synchronize do
+        # Reset counts every minute
+        if Time.now - @last_reset > 60
+          @request_counts.clear
+          @last_reset = Time.now
+        end
+
+        @request_counts[client_ip] += 1
+        @request_counts[client_ip] > @options[:rate_limit]
+      end
+    end
+
+    def record_response(schema_name, data)
+      @mutex.synchronize do
+        @recordings["#{schema_name}_#{Time.now.to_i}"] = {
+          data: data,
+          recorded_at: Time.now.iso8601,
+          schema: schema_name
+        }
+      end
+    end
+
+    def load_recordings
+      dir = @options[:recordings_dir]
+      return unless Dir.exist?(dir)
+
+      @mutex.synchronize do
+        Dir.glob(File.join(dir, "*.json")).each do |file|
+          name = File.basename(file, ".json")
+          @recordings[name] = JSON.parse(File.read(file))
+        end
+      end
+    end
+
+    def save_recordings
+      dir = @options[:recordings_dir]
+      FileUtils.mkdir_p(dir)
+
+      @mutex.synchronize do
+        @recordings.each do |name, data|
+          File.write(File.join(dir, "#{name}.json"), JSON.pretty_generate(data))
+        end
+      end
+    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