synthra 0.1.0

data/lib/synthra/engine.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Synthra
+  # Rails Engine for zero-configuration integration
+  #
+  # Provides automatic setup for Rails applications:
+  # - Auto-discovers schemas from standard locations
+  # - Mounts API in development mode
+  # - Integrates with Factory Bot if present
+  # - Auto-configures for test environment
+  #
+  # @example Gemfile
+  #   gem 'synthra'
+  #
+  # @example Generate initializer
+  #   rails generate synthra:install
+  #
+  class Engine < ::Rails::Engine
+    isolate_namespace Synthra
+
+    # Schema search paths (in priority order)
+    SCHEMA_PATHS = %w[
+      db/schemas
+      app/schemas
+      schemas
+      spec/schemas
+      test/schemas
+    ].freeze
+
+    config.synthra = ActiveSupport::OrderedOptions.new
+    config.synthra.auto_discover = true
+    config.synthra.auto_mount = true
+    config.synthra.mount_path = "/fake_data"
+    config.synthra.factory_bot_integration = true
+    config.synthra.infer_from_models = false
+
+    # Initialize configuration
+    initializer "synthra.configure", before: :load_config_initializers do |app|
+      # Set default schema directory
+      config.synthra.schema_dir ||= find_schema_directory(app.root)
+    end
+
+    # Auto-discover and load schemas
+    initializer "synthra.load_schemas", after: :load_config_initializers do |app|
+      next unless config.synthra.auto_discover
+
+      schema_dir = config.synthra.schema_dir
+      if schema_dir && Dir.exist?(schema_dir)
+        # Set schema_dir on configuration if the method exists
+        if Synthra.configuration.respond_to?(:schema_dir=)
+          Synthra.configuration.schema_dir = schema_dir.to_s
+        end
+
+        # Load all schemas
+        Dir.glob(File.join(schema_dir, "**/*.dsl")).each do |file|
+          Synthra.load(file)
+        rescue StandardError => e
+          Rails.logger.warn "[Synthra] Failed to load schema #{file}: #{e.message}"
+        end
+
+        Rails.logger.info "[Synthra] Loaded #{Synthra.registry.names.count} schemas from #{schema_dir}"
+      end
+    end
+
+    # Mount API in development
+    initializer "synthra.routes", after: :add_routing_paths do |app|
+      next unless config.synthra.auto_mount
+      next unless Rails.env.development? || Rails.env.test?
+
+      schema_dir = config.synthra.schema_dir
+      next unless schema_dir && Dir.exist?(schema_dir)
+
+      mount_path = config.synthra.mount_path
+
+      app.routes.append do
+        mount Synthra::Engine, at: mount_path
+      end
+
+      Rails.logger.info "[Synthra] API mounted at #{mount_path}"
+    end
+
+    # Integrate with Factory Bot
+    initializer "synthra.factory_bot", after: "factory_bot.set_factory_paths" do |_app|
+      next unless config.synthra.factory_bot_integration
+
+      if defined?(FactoryBot)
+        Synthra::FactoryBotBridge.integrate!
+        Rails.logger.info "[Synthra] Integrated with Factory Bot"
+      end
+    end
+
+    # Configure for test environment
+    initializer "synthra.test_setup" do |_app|
+      next unless Rails.env.test?
+
+      # Enable deterministic generation in tests
+      # Note: default_seed is not currently supported
+      # Synthra.configure do |c|
+      #   c.default_seed = 42
+      # end
+
+      # Add test helpers
+      if defined?(RSpec) && RSpec.respond_to?(:configure)
+        RSpec.configure do |rspec|
+          rspec.include Synthra::TestHelpers
+        end
+      end
+
+      if defined?(ActiveSupport::TestCase)
+        ActiveSupport::TestCase.include Synthra::TestHelpers
+      end
+    end
+
+    # Auto-infer schemas from ActiveRecord models
+    initializer "synthra.infer_models", after: :load_active_record do |_app|
+      next unless config.synthra.infer_from_models
+
+      ActiveSupport.on_load(:active_record) do
+        Rails.application.eager_load! if Rails.env.development?
+
+        ActiveRecord::Base.descendants.each do |model|
+          next if model.abstract_class?
+          next if model.name.start_with?("ActiveRecord::")
+
+          begin
+            schema = Synthra::ActiveRecordInference.infer(model)
+            Synthra.registry.register_schema(model.name, schema)
+          rescue StandardError => e
+            Rails.logger.debug "[Synthra] Could not infer schema for #{model.name}: #{e.message}"
+          end
+        end
+      end
+    end
+
+    # Engine routes
+    def self.routes
+      @routes ||= ActionDispatch::Routing::RouteSet.new.tap do |routes|
+        routes.draw do
+          get "/", to: "synthra/api#index"
+          get "/schemas", to: "synthra/api#schemas"
+          get "/:schema", to: "synthra/api#generate"
+          get "/:schema/batch", to: "synthra/api#batch"
+          get "/:schema/stream", to: "synthra/api#stream"
+          post "/:schema", to: "synthra/api#create"
+        end
+      end
+    end
+
+    private
+
+    def find_schema_directory(root)
+      SCHEMA_PATHS.each do |path|
+        full_path = root.join(path)
+        return full_path if Dir.exist?(full_path)
+      end
+      nil
+    end
+  end
+
+  # Factory Bot bridge for automatic integration
+  module FactoryBotBridge
+    class << self
+      def integrate!
+        return unless defined?(FactoryBot)
+
+        # Add Synthra strategy to Factory Bot
+        FactoryBot.register_strategy(:fake_data, FakeDataStrategy)
+
+        # Auto-define factories for all schemas
+        Synthra.registry.names.each do |name|
+          define_factory_for(name)
+        end
+      end
+
+      def define_factory_for(schema_name)
+        factory_name = schema_name.underscore.to_sym
+        schema = Synthra.registry.schema(schema_name)
+
+        FactoryBot.define do
+          factory factory_name, class: OpenStruct do
+            transient do
+              fake_data_seed { nil }
+              fake_data_mode { :random }
+            end
+
+            initialize_with do
+              data = Synthra.registry.schema(schema_name.to_s).generate(
+                seed: fake_data_seed,
+                mode: fake_data_mode
+              )
+              OpenStruct.new(data)
+            end
+          end
+        end
+      rescue FactoryBot::DuplicateDefinitionError
+        # Factory already exists, skip
+      end
+    end
+
+    # Custom Factory Bot strategy
+    class FakeDataStrategy
+      def association(runner)
+        runner.run
+      end
+
+      def result(evaluation)
+        evaluation.object
+      end
+    end
+  end
+
+  # Test helpers for RSpec and Minitest
+  module TestHelpers
+    extend ActiveSupport::Concern
+
+    # Generate fake data for a schema
+    #
+    # @param schema_name [String, Symbol] schema name
+    # @param options [Hash] generation options
+    # @return [Hash] generated data
+    #
+    def fake_data(schema_name, **options)
+      Synthra.generate(schema_name.to_s, **options)
+    end
+
+    # Generate multiple fake data records
+    #
+    # @param schema_name [String, Symbol] schema name
+    # @param count [Integer] number of records
+    # @param options [Hash] generation options
+    # @return [Array<Hash>] generated data
+    #
+    def fake_data_list(schema_name, count = 10, **options)
+      Synthra.generate_many(schema_name.to_s, count, **options)
+    end
+
+    # Shorthand accessor
+    #
+    # @example
+    #   Synthra[:User]
+    #   Synthra[:Order, seed: 42]
+    #
+    def Synthra.[](*args, **options)
+      if args.length == 1
+        generate(args.first.to_s, **options)
+      else
+        args.map { |name| generate(name.to_s, **options) }
+      end
+    end
+  end
+end