hati-rails-api 0.1.0.beta1

data/lib/hati_rails_api/context/generators/generator.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative 'base_generator'
+require_relative 'domain_generator'
+require_relative '../managers/rollback_manager'
+require_relative '../shared/content_generators'
+
+module HatiRailsApi
+  module Context
+    # Main orchestrator for the generation process
+    # Coordinates all generation activities with clean separation of concerns
+    class Generator < BaseGenerator
+      include ContentGenerators
+
+      # Default configurations for models and endpoints
+      DEFAULT_MODEL = { path: 'app/models', base: 'ApplicationRecord' }.freeze
+      DEFAULT_ENDPOINT = { path: 'app/controllers/api', base: 'ApplicationController' }.freeze
+
+      attr_reader :domains, :models, :endpoints
+
+      def initialize(config = nil, force: false)
+        super
+        @domains = {}
+        @models = []
+        @endpoints = []
+      end
+
+      # Register global models for generation
+      #
+      # @param names_or_options [String, Array, Hash] Model names or options
+      # @param options [Hash] Additional options
+      def model(names_or_options = nil, **options)
+        return unless names_or_options
+
+        names, opts = extract_names_and_options(names_or_options, options)
+        names.each { |name| @models << { name: name, options: opts } }
+      end
+
+      # Register global endpoints for generation
+      #
+      # @param names_or_options [String, Array, Hash] Endpoint names or options
+      # @param options [Hash] Additional options
+      def endpoint(names_or_options = nil, **options)
+        return unless names_or_options
+
+        names, opts = extract_names_and_options(names_or_options, options)
+        names.each { |name| @endpoints << { name: name, options: opts } }
+      end
+
+      # Define a domain with its configuration
+      #
+      # @param name [Symbol, String] Domain name
+      # @param options [Hash] Domain-specific options
+      # @param block [Proc] Domain configuration block
+      def domain(name, **options, &block)
+        domain_generator = create_domain_generator(name, options)
+        domain_generator.instance_eval(&block) if block_given?
+        @domains[name] = domain_generator
+      end
+
+      # Execute the complete generation process
+      #
+      # @return [Boolean] True if generation was successful
+      def execute
+        return false if nothing_to_generate?
+
+        generate_all_components
+        track_generation_results
+        true
+      end
+
+      private
+
+      # Extract names and options from flexible parameter format
+      def extract_names_and_options(names_or_options, options)
+        if names_or_options.is_a?(Hash)
+          [[], names_or_options]
+        else
+          names = Array(names_or_options)
+          [names, options]
+        end
+      end
+
+      # Create a properly configured domain generator
+      def create_domain_generator(name, options)
+        DomainGenerator.new(
+          name: name,
+          config: @config,
+          options: options,
+          generated_files: @generated_files,
+          force: @force,
+          override_all: method(:override_all_state)
+        ).tap do |generator|
+          generator.context_reference = self
+        end
+      end
+
+      # Check if there's anything to generate
+      def nothing_to_generate?
+        @models.empty? && @endpoints.empty? && @domains.empty?
+      end
+
+      # Generate all components in the correct order
+      def generate_all_components
+        generate_global_models
+        generate_global_endpoints
+        generate_domains
+      end
+
+      # Generate all registered global models
+      def generate_global_models
+        @models.each { |model_config| generate_single_model(model_config) }
+      end
+
+      # Generate all registered global endpoints
+      def generate_global_endpoints
+        @endpoints.each { |endpoint_config| generate_single_endpoint(endpoint_config) }
+      end
+
+      # Generate all defined domains
+      def generate_domains
+        @domains.each_value(&:generate)
+      end
+
+      # Generate a single model with error handling
+      def generate_single_model(model_config)
+        file_path = model_file_path(model_config)
+        content = model_content(model_config)
+
+        generate_file?(file_path, content)
+      end
+
+      # Generate a single endpoint with error handling
+      def generate_single_endpoint(endpoint_config)
+        file_path = endpoint_file_path(endpoint_config)
+        content = endpoint_content(endpoint_config)
+
+        generate_file?(file_path, content)
+      end
+
+      # Build model file path
+      def model_file_path(model_config)
+        path = resolve_model_path(model_config[:options])
+        File.join(path, "#{model_config[:name]}.rb")
+      end
+
+      # Build endpoint file path
+      def endpoint_file_path(endpoint_config)
+        path = resolve_endpoint_path(endpoint_config[:options])
+        File.join(path, "#{endpoint_config[:name]}_controller.rb")
+      end
+
+      # Generate model content
+      def model_content(model_config)
+        generate_model_content(
+          name: model_config[:name],
+          base_class: resolve_model_base_class,
+          timestamp: @timestamp
+        )
+      end
+
+      # Generate endpoint content
+      def endpoint_content(endpoint_config)
+        generate_controller_content(
+          name: endpoint_config[:name],
+          base_class: resolve_endpoint_base_class,
+          timestamp: @timestamp
+        )
+      end
+
+      # Resolve model path with fallbacks
+      def resolve_model_path(options)
+        options[:path] ||
+          @config&.model_config&.dig(:path) ||
+          DEFAULT_MODEL[:path]
+      end
+
+      # Resolve model base class with fallbacks
+      def resolve_model_base_class
+        @config&.model_config&.dig(:base) || DEFAULT_MODEL[:base]
+      end
+
+      # Resolve endpoint path with fallbacks
+      def resolve_endpoint_path(options)
+        options[:path] ||
+          @config&.endpoint_config&.dig(:path) ||
+          DEFAULT_ENDPOINT[:path]
+      end
+
+      # Resolve endpoint base class with fallbacks
+      def resolve_endpoint_base_class
+        @config&.endpoint_config&.dig(:base) || DEFAULT_ENDPOINT[:base]
+      end
+
+      # Track generation results for rollback functionality
+      def track_generation_results
+        return if @generated_files.empty?
+
+        RollbackManager.new.track_generation(@timestamp, @generated_files)
+        log_generation_summary
+      end
+
+      # Log a summary of the generation results
+      def log_generation_summary
+        puts "\nGeneration completed successfully!"
+        puts "   Timestamp: #{@timestamp}"
+        puts "   Files generated: #{@generated_files.length}"
+        puts "   To rollback: rails generate hati_rails_api:context rollback --timestamp=#{@timestamp}"
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/generators/layer_component_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Context
+    # Concern for layer and component generation
+    # Follows Single Responsibility Principle - handles only layer/component generation
+    module LayerComponentGenerator
+      private
+
+      def generate_layer(base_path:, layer_name:, layer_config:)
+        layer_path = File.join(base_path, layer_name.to_s)
+        FileUtils.mkdir_p(layer_path)
+
+        layer_config.components.each do |component|
+          generate_component(
+            layer_path: layer_path,
+            component: component,
+            layer_config: layer_config
+          )
+        end
+      end
+
+      def generate_component(layer_path:, component:, layer_config:)
+        component_name = resolve_component_name(component: component, layer_config: layer_config)
+        file_path = File.join(layer_path, "#{component_name}.rb")
+        content = generate_component_content(component: component, layer_config: layer_config)
+
+        generate_file?(file_path, content)
+      end
+
+      def resolve_component_name(component:, layer_config:)
+        if component.is_a?(Hash)
+          name = component.keys.first.to_s
+          suffix = component.values.first[:suffix]
+        else
+          name = component == :domain ? @name.to_s : component.to_s
+          suffix = layer_config.default_suffix
+        end
+
+        suffix && suffix != false ? "#{name}_#{layer_config.layer_name}" : name
+      end
+
+      def generate_component_content(component:, layer_config:)
+        class_name = generate_class_name(component: component, layer_config: layer_config)
+
+        if layer_config.is_a?(OperationLayer)
+          generate_component_operation_content(
+            component: component,
+            class_name: class_name,
+            layer_config: layer_config
+          )
+        else
+          generate_standard_content(
+            component: component,
+            class_name: class_name,
+            layer_config: layer_config
+          )
+        end
+      end
+
+      def generate_class_name(component:, layer_config:)
+        if component.is_a?(Hash)
+          base_name = component.keys.first.to_s.camelize
+          suffix    = component.values.first[:suffix]
+        else
+          name = component == :domain ? @name : component
+          base_name = name.to_s.camelize
+          suffix = layer_config.default_suffix
+        end
+
+        suffix && suffix != false ? "#{base_name}#{layer_config.layer_name.to_s.camelize}" : base_name
+      end
+
+      def generate_standard_content(component:, class_name:, layer_config:)
+        base_requirement = layer_config.base_class ? "require_relative '#{layer_config.base_class}'\n\n" : ''
+        base_class_inheritance = (" < #{layer_config.base_class.split('/').last.camelize}" if layer_config.base_class)
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{Time.now.strftime('%Y%m%d%H%M%S')}
+          #{base_requirement}class #{class_name}#{base_class_inheritance}
+            # TODO: Implement #{class_name} logic
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/generators/model_endpoint_generator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../shared/content_generators'
+
+module HatiRailsApi
+  module Context
+    # Concern for model and endpoint generation
+    # Follows Single Responsibility Principle - handles only model/endpoint generation
+    module ModelEndpointGenerator
+      include ContentGenerators
+
+      DEFAULT_MODEL = {
+        path: 'app/models',
+        base: 'ApplicationRecord'
+      }.freeze
+
+      DEFAULT_ENDPOINT = {
+        path: 'app/controllers/api',
+        base: 'ApplicationController'
+      }.freeze
+
+      def generate_domain_model
+        options = @domain_model[:options] || {}
+
+        path = @config&.model_config&.dig(:path)
+        base_path = options[:path] || path || DEFAULT_MODEL[:path]
+
+        base = @config&.model_config&.dig(:base)
+        base_class = base || DEFAULT_MODEL[:base]
+
+        file_path = File.join(base_path, "#{@name}.rb")
+        content = generate_model_content(name: @name, base_class: base_class)
+
+        generate_file?(file_path, content)
+      end
+
+      def generate_domain_endpoint
+        options = @domain_endpoint[:options] || {}
+
+        path = @config&.endpoint_config&.dig(:path)
+        base_path = options[:path] || path || DEFAULT_ENDPOINT[:path]
+
+        base = @config&.endpoint_config&.dig(:base)
+        base_class = base || DEFAULT_ENDPOINT[:base]
+
+        file_path = File.join(base_path, "#{@name}_controller.rb")
+        content = generate_endpoint_content(base_class)
+
+        generate_file?(file_path, content)
+      end
+
+      def generate_endpoint_content(base_class)
+        # Get operation components to generate actions
+        operation_components = get_operation_components
+        actions_code = generate_controller_actions(operation_components)
+
+        generate_controller_content(
+          name: @name,
+          base_class: base_class,
+          actions_code: actions_code
+        )
+      end
+
+      def get_operation_components
+        # If explicit components are provided in endpoint declaration, use those
+        return @domain_endpoint[:explicit_components] if @domain_endpoint&.dig(:explicit_components)
+
+        # Otherwise, use operation layer components
+        operation_layer = @layers[:operation]
+        return [] unless operation_layer
+
+        operation_layer.components.reject { |comp| comp == :domain }
+      end
+
+      def generate_controller_actions(components)
+        return '  # TODO: Add controller actions here' if components.empty?
+
+        actions = components.map do |component|
+          action_name = component.to_s
+          operation_class = "#{action_name.camelize}Operation"
+
+          generate_custom_action(action_name, operation_class)
+        end
+
+        actions.join("\n\n")
+      end
+
+      def generate_custom_action(action_name, operation_class)
+        <<~RUBY.chomp
+          def #{action_name}
+            run_and_render #{operation_class}
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/generators/operation_generator.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative '../shared/content_generators'
+
+module HatiRailsApi
+  module Context
+    # Concern for operation generation
+    # Follows Single Responsibility Principle - handles only operation generation
+    module OperationGenerator
+      include ContentGenerators
+
+      TIMESTAMP_FORMAT = '%Y%m%d%H%M%S'
+
+      def generate_component_operation_content(component:, class_name:, layer_config:)
+        base_class = resolve_base_class(layer_config)
+        action = extract_action_from_component(component)
+        timestamp = Time.now.strftime(TIMESTAMP_FORMAT)
+
+        # Check if we should generate step-based operations
+        if should_use_steps?(layer_config)
+          generate_step_based_operation_content(
+            class_name: class_name,
+            base_class: base_class,
+            action: action,
+            layer_config: layer_config,
+            timestamp: timestamp
+          )
+        else
+          generate_simple_operation_content(
+            class_name: class_name,
+            base_class: base_class,
+            action: action,
+            timestamp: timestamp
+          )
+        end
+      end
+
+      def generate_step_based_operation(class_name:, base_class:, action:, steps:)
+        step_declarations = generate_step_declarations(action, steps)
+        step_calls = generate_step_calls(steps)
+
+        generate_step_based_operation_content(
+          class_name: class_name,
+          base_class: base_class,
+          step_declarations: step_declarations,
+          step_calls: step_calls
+        )
+      end
+
+      def generate_standard_operation(class_name:, base_class:, action:, base_requirement:)
+        steps_content = generate_default_steps_for_action(action)
+        timestamp = Time.now.strftime(TIMESTAMP_FORMAT)
+
+        if base_requirement.blank?
+          generate_operation_content(
+            class_name: class_name,
+            base_class: base_class,
+            action: action,
+            steps_content: steps_content
+          )
+          return
+        end
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+
+          #{base_requirement}class #{class_name} < #{base_class}
+            # Operation configuration
+            #{generate_operation_macros(action)}
+
+            def call(params:)
+              #{steps_content}
+            end
+
+            private
+
+            #{generate_private_steps(action)}
+          end
+        RUBY
+      end
+
+      private
+
+      def should_use_steps?(layer_config)
+        # If operation layer has explicit steps, use those
+        return true if layer_config.respond_to?(:steps) && layer_config.steps.any?
+
+        # If step options include granular: true, use steps from other layers
+        return true if layer_config.respond_to?(:granular_steps?) && layer_config.granular_steps?
+
+        # If domain has multiple layers besides operation, use steps
+        other_layers = @layers.keys.reject { |name| name == :operation }
+        other_layers.any?
+      end
+
+      def generate_step_based_operation_content(class_name:, base_class:, action:, layer_config:, timestamp:)
+        steps = determine_steps_for_operation(layer_config)
+        step_declarations = generate_step_declarations(action, steps)
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+
+          class #{class_name} < #{base_class}
+          #{step_declarations}
+
+            def call(params:)
+              Success(params)
+            end
+          end
+        RUBY
+      end
+
+      def generate_simple_operation_content(class_name:, base_class:, action:, timestamp:)
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+
+          class #{class_name} < #{base_class}
+            def call(params:)
+              # TODO: Implement #{action} business logic
+              # Add your implementation here
+
+              Success(params)
+            end
+
+            private
+
+            # TODO: Add your private methods here
+            # Example:
+            # def validate_params(params)
+            #   # validation logic
+            # end
+          end
+        RUBY
+      end
+
+      def determine_steps_for_operation(layer_config)
+        # If operation has explicit steps configured, use those
+        return layer_config.steps if layer_config.respond_to?(:steps) && layer_config.steps.any?
+
+        # If granular steps enabled, use other domain layers as steps
+        if layer_config.respond_to?(:granular_steps?) && layer_config.granular_steps?
+          return @layers.keys.reject { |name| name == :operation }
+        end
+
+        # Otherwise, use domain layers (excluding operation itself)
+        @layers.keys.reject { |name| name == :operation }
+      end
+
+      def generate_step_declarations(action, steps)
+        steps_arr = steps.map do |step_name|
+          service_class = "#{action.camelize}#{step_name.to_s.camelize}"
+          "  step #{step_name}: \"#{service_class}\""
+        end
+
+        steps_arr.join("\n")
+      end
+
+      def generate_step_calls(steps)
+        step_calls = steps.map do |step_name|
+          "      rez = #{step_name}.call(rez)"
+        end
+
+        (['      rez = params'] + step_calls).join("\n")
+      end
+
+      def resolve_base_class(layer_config)
+        if layer_config.base_class
+          layer_config.base_class.split('/').last.camelize
+        else
+          'HatiOperation::Base'
+        end
+      end
+
+      def extract_action_from_component(component)
+        component.is_a?(Hash) ? component.keys.first.to_s : component.to_s
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/layers/operation_layer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'standard_layer'
+
+module HatiRailsApi
+  module Context
+    # Operation layer configuration class
+    # Extends StandardLayer for operation-specific functionality
+    class OperationLayer < StandardLayer
+      attr_reader :step_options
+
+      def initialize
+        super(:operation)
+        @base_class = 'hati_operation/base'
+        @step_options = {}
+      end
+
+      def step(*step_names, **options)
+        if step_names.empty? && options.any?
+          # Handle: operation.step true, granular: true
+          @step_options.merge!(options)
+        elsif step_names.any?
+          # Handle: operation.step :validate, :encrypt, :store
+          @steps = step_names.flatten
+          @step_options.merge!(options) if options.any?
+        end
+      end
+
+      def steps
+        @steps || []
+      end
+
+      def granular_steps?
+        @step_options[:granular] == true
+      end
+
+      def dup
+        new_layer = super
+        new_layer.instance_variable_set(:@steps, @steps&.dup)
+        new_layer.instance_variable_set(:@step_options, @step_options.dup)
+        new_layer
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/layers/standard_layer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Context
+    # Standard layer configuration class
+    # Follows Single Responsibility Principle - handles standard layer configuration
+    class StandardLayer
+      attr_reader :layer_name, :base_class, :components, :default_suffix
+
+      def initialize(layer_name)
+        @layer_name = layer_name
+        @base_class = nil
+        @components = []
+        @default_suffix = true
+      end
+
+      def base(base_class)
+        @base_class = base_class
+      end
+
+      def component(*names, **options)
+        if names.empty?
+          @components = [:domain]
+        else
+          names.each do |name|
+            if name.is_a?(Array)
+              @components.concat(name)
+            else
+              @components << (options.empty? ? name : { name => options })
+            end
+          end
+        end
+      end
+
+      def dup
+        new_layer = self.class.new(@layer_name)
+        new_layer.instance_variable_set(:@base_class, @base_class)
+        new_layer.instance_variable_set(:@components, @components.dup)
+        new_layer.instance_variable_set(:@default_suffix, @default_suffix)
+        new_layer
+      end
+    end
+  end
+end