hati-rails-api 0.1.0.beta1

data/lib/hati_rails_api/context/managers/rollback_manager.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module HatiRailsApi
+  module Context
+    # Manages rollback functionality for generated files
+    # Follows Single Responsibility Principle - only handles rollback operations
+    class RollbackManager
+      TRACKING_FILE = 'config/contexts/.hati_generations.yml'
+
+      def initialize
+        ensure_tracking_directory
+      end
+
+      def track_generation(timestamp, files)
+        tracking_data = load_tracking_data
+        tracking_data[timestamp] = {
+          'generated_at' => Time.now.to_s,
+          'files' => files
+        }
+        save_tracking_data(tracking_data)
+      end
+
+      def rollback_by_timestamp?(timestamp)
+        tracking_data = load_tracking_data
+        generation = tracking_data[timestamp]
+
+        unless generation
+          puts "No generation found with timestamp: #{timestamp}"
+          puts "Available generations: #{tracking_data.keys.join(', ')}"
+          return false
+        end
+
+        rollback_files(generation['files'], timestamp)
+
+        # Remove from tracking
+        tracking_data.delete(timestamp)
+        save_tracking_data(tracking_data)
+
+        puts "Rollback completed for timestamp: #{timestamp}"
+        true
+      end
+
+      def rollback_last?
+        tracking_data = load_tracking_data
+
+        if tracking_data.empty?
+          puts 'No generations to rollback'
+          return false
+        end
+
+        last_timestamp = tracking_data.keys.sort.last
+        rollback_by_timestamp?(last_timestamp)
+      end
+
+      def list_generations
+        tracking_data = load_tracking_data
+
+        if tracking_data.empty?
+          puts 'No context generations found'
+          return
+        end
+
+        puts "\nContext Generations:"
+        puts '=' * 50
+
+        tracking_data.each do |timestamp, data|
+          puts "#{timestamp} (#{data['generated_at']})"
+          puts "   Files: #{data['files'].size} files"
+          data['files'].each { |file| puts "   - #{file}" }
+          puts ''
+        end
+      end
+
+      private
+
+      def load_tracking_data
+        return {} unless File.exist?(TRACKING_FILE)
+
+        YAML.load_file(TRACKING_FILE) || {}
+      rescue StandardError
+        {}
+      end
+
+      def save_tracking_data(data)
+        File.write(TRACKING_FILE, data.to_yaml)
+      end
+
+      def ensure_tracking_directory
+        FileUtils.mkdir_p(File.dirname(TRACKING_FILE))
+      end
+
+      def rollback_files(files, timestamp)
+        puts "Rolling back generation #{timestamp}..."
+
+        files.each do |file_path|
+          if File.exist?(file_path)
+            FileUtils.rm(file_path)
+            puts "   Removed: #{file_path}"
+          else
+            puts "   Already removed: #{file_path}"
+          end
+
+          # Clean up empty directories
+          remove_empty_directories(File.dirname(file_path))
+        end
+      end
+
+      def remove_empty_directories(dir)
+        return unless Dir.exist?(dir)
+        return if ['app', 'app/contexts'].include?(dir) # Don't remove base directories
+
+        return unless Dir.empty?(dir)
+
+        FileUtils.rmdir(dir)
+        puts "   Removed empty directory: #{dir}"
+        remove_empty_directories(File.dirname(dir))
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/shared/content_generators.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Context
+    # Shared content generation methods
+    # Eliminates duplicate content generation across generators
+    module ContentGenerators
+      TIMESTAMP_PATTERN = '%Y%m%d%H%M%S'
+
+      private
+
+      def generate_class_content(class_name:, base_class:, timestamp: nil, &_block)
+        timestamp ||= Time.now.strftime(TIMESTAMP_PATTERN)
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+
+          class #{class_name} < #{base_class}
+            #{block_given? ? yield : '# TODO: Add implementation here'}
+          end
+        RUBY
+      end
+
+      def generate_model_content(name:, base_class:, timestamp: nil)
+        msg = "# TODO: Add #{name} model logic here"
+
+        generate_class_content(
+          class_name: name,
+          base_class: base_class,
+          timestamp: timestamp
+        ) do
+          msg
+        end
+      end
+
+      def generate_controller_content(name:, base_class:, actions_code: nil, timestamp: nil)
+        class_name = "#{name.to_s.camelize}Controller"
+        timestamp ||= Time.now.strftime(TIMESTAMP_PATTERN)
+
+        # Ensure actions are properly indented
+        indented_actions = if actions_code && actions_code.strip != '# TODO: Add controller logic here'
+                             actions_code.split("\n").map { |line| "  #{line}" }.join("\n")
+                           else
+                             '  # TODO: Add controller logic here'
+                           end
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+
+          class #{class_name} < #{base_class}
+            include HatiRailsApi::ResponseHandler
+
+          #{indented_actions}
+          end
+        RUBY
+      end
+
+      def generate_operation_content(class_name:, base_class:, action:, step_content: nil, timestamp: nil)
+        timestamp ||= Time.now.strftime(TIMESTAMP_PATTERN)
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+          class #{class_name} < #{base_class}
+            # Operation configuration
+            #{generate_operation_macros(action)}
+
+            def call(params:)
+              #{step_content || generate_default_steps_for_action(action)}
+            end
+
+            private
+
+            #{generate_private_steps(action)}
+          end
+        RUBY
+      end
+
+      def generate_step_based_operation_content(
+        class_name:, base_class:, step_declarations:, step_calls:, timestamp: nil
+      )
+        timestamp ||= Time.now.strftime(TIMESTAMP_PATTERN)
+
+        <<~RUBY
+          # frozen_string_literal: true
+          # Generated at #{timestamp}
+          class #{class_name} < #{base_class}
+          #{step_declarations}
+
+            def call(params:)
+          #{step_calls}
+
+              Success(rez)
+            end
+          end
+        RUBY
+      end
+
+      def generate_operation_macros(_action)
+        '# Add operation configuration macros here'
+      end
+
+      def generate_default_steps_for_action(action)
+        <<~RUBY.strip
+          # TODO: Implement #{action} business logic
+          # Add your step-based implementation here
+
+          Success(params)
+        RUBY
+      end
+
+      def generate_private_steps(_action)
+        <<~RUBY.strip
+          # TODO: Add your private step methods here
+          # Example:
+          # def validate_params(params)
+          #   Success(params)
+          # end
+        RUBY
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context/shared/layer_factory.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../layers/operation_layer'
+require_relative '../layers/standard_layer'
+
+module HatiRailsApi
+  module Context
+    # Shared layer factory methods
+    # Eliminates duplicate layer creation logic
+    module LayerFactory
+      protected
+
+      def create_operation_layer(&block)
+        layer = OperationLayer.new
+        layer.instance_eval(&block) if block_given?
+        layer
+      end
+
+      def create_standard_layer(layer_name, &block)
+        layer = StandardLayer.new(layer_name.to_sym)
+        if block_given?
+          layer.instance_eval(&block)
+        else
+          # Set default component to :domain for plain layer declarations
+          layer.component(:domain)
+        end
+        layer
+      end
+
+      def create_dynamic_layer(method_name, *args, &block)
+        # Always create a layer for method calls
+        # This handles cases like: domain.validation, domain.query, domain.service
+        create_standard_layer(method_name, &block)
+      end
+    end
+  end
+end

data/lib/hati_rails_api/context.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'context/core'
+
+module HatiRailsApi
+  # Main Context module providing the public API for code generation
+  #
+  # This module serves as the entry point for all context-related operations
+  # including configuration, generation, and rollback functionality.
+  #
+  # @example Basic usage
+  #   HatiRailsApi::Context.configure do |config|
+  #     config.base_path 'app/contexts'
+  #   end
+  #
+  #   HatiRailsApi::Context.generate do |ctx|
+  #     ctx.domain :user do |domain|
+  #       domain.operation { |op| op.component [:create, :update] }
+  #       domain.endpoint enabled: true
+  #     end
+  #   end
+  #
+  # @example Rollback
+  #   HatiRailsApi::Context.rollback('20240101120000')
+  #   HatiRailsApi::Context.rollback  # rolls back last generation
+  #
+  module Context
+    extend Core::PublicAPI
+  end
+end

data/lib/hati_rails_api/errors/unsupported_operation_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Errors
+    class UnsupportedOperationError < StandardError
+      def initialize(message = 'Unsupported operation')
+        super
+      end
+    end
+  end
+end

data/lib/hati_rails_api/macro/serializer_macro.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  module Macro
+    class SerializerMacro
+      include HatiCommand::Cmd
+
+      def call(serializer, status: 200)
+        Success(serializer.call(status: status))
+      end
+    end
+  end
+end

data/lib/hati_rails_api/response_handler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Load pry only in development
+require 'pry' if defined?(Rails) && Rails.env.development?
+
+# TODO:
+## success macros:
+# - 200
+# - 201
+# - 204
+# - 206
+# - 207
+## on_failure & on_success result mappers
+
+module HatiRailsApi
+  module ResponseHandler
+    # WIP: think about global configs
+    HatiJsonapiError::Config.configure do |config|
+      config.load_errors!
+      config.use_unexpected = HatiJsonapiError::InternalServerError
+      # WIP: map or preload from rails errors to statuses ???
+      # config.map_errors =
+      #   ActiveRecord::RecordNotFound => :not_found,
+      #   ActiveRecord::RecordInvalid => :unprocessable_entity
+      # }
+    end
+
+    def self.included(base)
+      base.include HatiJsonapiError::Helpers
+    end
+
+    private
+
+    # WIP:
+    def unsafe_params
+      params.respond_to?(:permit) ? params.permit.to_unsafe_h : params
+    end
+
+    # specific for api-errror lib !!!!
+    # WIP: debug access ??
+    def run_and_render(operation, &block)
+      result = run_operation(operation, &block)
+      result_value = result.value
+      status = result_value.try(:status)
+
+      if result.success?
+        render_success(result_value, status: status)
+      else
+        # WIP:
+        # render_error(result.error || result.value) ????
+        # setup error object with meta data ???
+        render_error(result.error)
+      end
+    end
+
+    def run_operation(operation, &block)
+      return operation if operation.is_a?(HatiCommand::Result)
+      raise Errors::UnsupportedOperationError, operation unless operation < HatiOperation::Base
+
+      if block_given?
+        operation.call(params: unsafe_params, &block)
+      else
+        operation.call(params: unsafe_params)
+      end
+    end
+
+    def render_success(result_value, status: 200)
+      render json: { data: result_value }, status: status
+    end
+  end
+end

data/lib/hati_rails_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HatiRailsApi
+  VERSION = '0.1.0.beta1'
+end

data/lib/hati_rails_api.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# external dependencies
+require 'rails/generators'
+
+# internal dependencies
+require 'hati_rails_api/version'
+require 'hati_rails_api/response_handler'
+require 'hati_rails_api/context'
+
+# WIP:
+module HatiRailsApi
+  class Engine < Rails::Engine
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: hati-rails-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta1
+platform: ruby
+authors:
+- Mariya Giy
+- Yuri Gi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hati-operation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hati-jsonapi-error
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: A Rails API tool for building API services.
+email:
+- giy.mariya@gmail.com
+- yurigi.pro@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- hati-rails-api.gemspec
+- lib/generators/hati_rails_api/context_generator.rb
+- lib/hati_rails_api.rb
+- lib/hati_rails_api/context.rb
+- lib/hati_rails_api/context/configuration/configuration.rb
+- lib/hati_rails_api/context/configuration/domain_configuration.rb
+- lib/hati_rails_api/context/core.rb
+- lib/hati_rails_api/context/core/error_handler.rb
+- lib/hati_rails_api/context/core/loader.rb
+- lib/hati_rails_api/context/core/migration.rb
+- lib/hati_rails_api/context/core/public_api.rb
+- lib/hati_rails_api/context/extensions/string_extensions.rb
+- lib/hati_rails_api/context/generators/base_generator.rb
+- lib/hati_rails_api/context/generators/domain_generator.rb
+- lib/hati_rails_api/context/generators/file_generation.rb
+- lib/hati_rails_api/context/generators/generator.rb
+- lib/hati_rails_api/context/generators/layer_component_generator.rb
+- lib/hati_rails_api/context/generators/model_endpoint_generator.rb
+- lib/hati_rails_api/context/generators/operation_generator.rb
+- lib/hati_rails_api/context/layers/operation_layer.rb
+- lib/hati_rails_api/context/layers/standard_layer.rb
+- lib/hati_rails_api/context/managers/rollback_manager.rb
+- lib/hati_rails_api/context/shared/content_generators.rb
+- lib/hati_rails_api/context/shared/layer_factory.rb
+- lib/hati_rails_api/errors/unsupported_operation_error.rb
+- lib/hati_rails_api/macro/serializer_macro.rb
+- lib/hati_rails_api/response_handler.rb
+- lib/hati_rails_api/version.rb
+homepage: https://github.com/hackico-ai/hati-rails-api
+licenses:
+- MIT
+metadata:
+  repo_homepage: https://github.com/hackico-ai/hati-rails-api
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/hackico-ai/hati-rails-api
+  changelog_uri: https://github.com/hackico-ai/hati-rails-api/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/hackico-ai/hati-rails-api
+  bug_tracker_uri: https://github.com/hackico-ai/hati-rails-api/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A Rails API tool for building API services.
+test_files: []