propel_api 0.1.1

data/lib/generators/propel_api/core/configuration_methods.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+##
+# Module providing configuration detection and validation for PropelApi generators
+#
+module PropelApi
+  module ConfigurationMethods
+    
+    # Shared class options across all PropelApi generators
+    def self.included(base)
+      base.class_option :adapter,
+                       type: :string,
+                       default: 'propel_facets',
+                       desc: "Serialization adapter to use: 'propel_facets' or 'graphiti'. Defaults to PropelApi configuration."
+      
+      base.class_option :namespace,
+                       type: :string,
+                       default: 'api',
+                       desc: "API namespace (e.g., 'api', 'admin_api'). Use 'none' for no namespace. Defaults to PropelApi configuration."
+      
+      base.class_option :version,
+                       type: :string,
+                       default: 'v1',
+                       desc: "API version (e.g., 'v1', 'v2'). Use 'none' for no versioning. Defaults to PropelApi configuration."
+
+      base.class_option :all_attributes,
+                       type: :boolean,
+                       default: false,
+                       desc: "Automatically include all model attributes from file and/or database schema for existing models"
+    end
+
+    protected
+
+    # Initialize shared PropelApi settings used across all generators
+    def initialize_propel_api_settings
+      @adapter = determine_adapter
+      @api_namespace = determine_api_namespace
+      @api_version = determine_api_version
+    end
+
+    # Determine the serialization adapter to use
+    # Priority order:
+    # 1. Command line option (--adapter)
+    # 2. Propel orchestration (when called by Propel installer)
+    # 3. PropelApi configuration (if exists)
+    # 4. Check if Api::ApiController exists and determine from it
+    # 5. Default fallback (propel_facets)
+    def determine_adapter
+      if options[:adapter].present?
+        validate_adapter(options[:adapter])
+        return options[:adapter]
+      end
+      
+      # Check for Propel orchestration settings (for install_generator)
+      if respond_to?(:propel_orchestrated_adapter, true)
+        propel_setting = propel_orchestrated_adapter
+        if propel_setting.present?
+          validate_adapter(propel_setting)
+          return propel_setting
+        end
+      end
+      
+      # Try to read from PropelApi configuration
+      begin
+        if defined?(PropelApi) && PropelApi.configuration.respond_to?(:adapter)
+          config_adapter = PropelApi.configuration.adapter
+          if config_adapter.present?
+            validate_adapter(config_adapter)
+            return config_adapter
+          end
+        end
+      rescue => e
+        # Configuration not available, continue to next check
+      end
+      
+      # Check if Api::ApiController exists and try to determine engine from it
+      api_controller_path = File.join(destination_root, 'app/controllers/api/api_controller.rb')
+      if File.exist?(api_controller_path)
+        controller_content = File.read(api_controller_path)
+        if controller_content.include?('FacetRenderer')
+          return 'propel_facets'
+        elsif controller_content.include?('Graphiti')
+          return 'graphiti'
+        end
+      end
+      
+      # If no Api::ApiController found, suggest running install first (for resource generators)
+      if self.class.name.include?('Generator') && !self.class.name.include?('InstallGenerator')
+        say "Warning: No Api::ApiController found. Run 'rails generate propel_api:install' first.", :red
+      end
+      
+      # Default fallback
+      'propel_facets'
+    end
+
+    # Validate that the adapter is supported
+    def validate_adapter(adapter)
+      valid_adapters = %w[propel_facets graphiti]
+      unless valid_adapters.include?(adapter)
+        raise ArgumentError, "Invalid adapter '#{adapter}'. Valid options: #{valid_adapters.join(', ')}"
+      end
+    end
+
+    # Determine the API namespace to use
+    # Priority order:
+    # 1. Command line option (--namespace)
+    # 2. Propel orchestration (when called by Propel installer)
+    # 3. PropelApi configuration (if exists)
+    # 4. Default fallback ('api')
+    def determine_api_namespace
+      if options[:namespace] == 'none'
+        return nil
+      end
+      
+      if options[:namespace].present?
+        return options[:namespace]
+      end
+      
+      # Check for Propel orchestration settings (for install_generator)
+      if respond_to?(:propel_orchestrated_namespace, true)
+        propel_setting = propel_orchestrated_namespace
+        if propel_setting.present?
+          return propel_setting == 'none' ? nil : propel_setting
+        end
+      end
+      
+      # Try to read from PropelApi configuration
+      begin
+        if defined?(PropelApi) && PropelApi.configuration.respond_to?(:namespace)
+          config_namespace = PropelApi.configuration.namespace
+          return config_namespace if config_namespace.present?
+        end
+      rescue => e
+        # Configuration not available, continue to default
+      end
+      
+      # Default fallback
+      'api'
+    end
+
+    # Determine the API version to use
+    # Priority order:
+    # 1. Command line option (--version)
+    # 2. Propel orchestration (when called by Propel installer)
+    # 3. PropelApi configuration (if exists)
+    # 4. Default fallback ('v1')
+    def determine_api_version
+      if options[:version] == 'none'
+        return nil
+      end
+      
+      if options[:version].present?
+        return options[:version]
+      end
+      
+      # Check for Propel orchestration settings (for install_generator)
+      if respond_to?(:propel_orchestrated_version, true)
+        propel_setting = propel_orchestrated_version
+        if propel_setting.present?
+          return propel_setting == 'none' ? nil : propel_setting
+        end
+      end
+      
+      # Try to read from PropelApi configuration
+      begin
+        if defined?(PropelApi) && PropelApi.configuration.respond_to?(:version)
+          config_version = PropelApi.configuration.version
+          return config_version if config_version.present?
+        end
+      rescue => e
+        # Configuration not available, continue to default
+      end
+      
+      # Default fallback
+      'v1'
+    end
+
+    # Display helpers for logging
+    def namespace_display
+      @api_namespace.present? ? @api_namespace : 'none'
+    end
+
+    def version_display
+      @api_version.present? ? @api_version : 'none'
+    end
+  end
+end 

data/lib/generators/propel_api/core/named_base.rb

@@ -0,0 +1,457 @@
+# frozen_string_literal: true
+
+require_relative 'configuration_methods'
+require_relative 'path_generation_methods'
+
+##
+# Named base class for PropelApi generators that work with named resources
+# Inherits name handling from Rails::Generators::NamedBase and adds PropelApi functionality
+#
+module PropelApi
+  class NamedBase < Rails::Generators::NamedBase
+    include PropelApi::ConfigurationMethods
+    include PropelApi::PathGenerationMethods
+    
+    protected
+
+    def model_exists?
+      File.exist?(File.join(destination_root, "app/models/#{file_name}.rb"))
+    end
+
+    # Controller generation helper methods
+    def controller_file_name
+      "#{controller_name.underscore}_controller"
+    end
+
+    def controller_name
+      "#{class_name.pluralize}"
+    end
+
+    def controller_class_name_with_namespace
+      class_parts = []
+      class_parts << @api_namespace.camelize if @api_namespace.present?
+      class_parts << @api_version.upcase if @api_version.present?
+      class_parts << controller_name
+      class_parts.join('::')
+    end
+
+    def controller_class_name
+      "#{class_name.pluralize}"
+    end
+
+    # Route helper methods
+    def route_name
+      file_name.pluralize
+    end
+
+    def api_route_path
+      path_parts = []
+      path_parts << @api_namespace if @api_namespace.present?
+      path_parts << @api_version if @api_version.present?
+      path_parts << route_name
+      '/' + path_parts.join('/')
+    end
+
+    def api_route_helper
+      path_parts = []
+      path_parts << @api_namespace if @api_namespace.present?
+      path_parts << @api_version if @api_version.present?
+      path_parts << route_name
+      path_parts.join("_")
+    end
+
+    # Model introspection methods for existing models
+    def introspect_model_attributes
+      return [] unless model_exists?
+      
+      model_file_path = File.join(destination_root, "app/models/#{file_name}.rb")
+      model_content = File.read(model_file_path)
+      
+      # Extract basic attribute information from model file
+      attributes = []
+      
+      # Look for belongs_to associations
+      model_content.scan(/belongs_to\s+:(\w+)(?:,\s*(.*))?/) do |association, options|
+        # Convert belongs_to to reference attribute
+        attr_name = "#{association}_id"
+        unless should_exclude_from_permitted_params?(attr_name, :integer)
+          attributes << {
+            name: attr_name,
+            type: :integer,
+            reference: association
+          }
+        end
+      end
+      
+      # Look for basic validations that might indicate attributes
+      model_content.scan(/validates\s+:(\w+)/) do |attr|
+        attr_name = attr.first
+        unless attributes.any? { |a| a[:name] == attr_name } || should_exclude_from_permitted_params?(attr_name, :string)
+          attributes << {
+            name: attr_name,
+            type: :string  # Default to string for validated attributes
+          }
+        end
+      end
+      
+      # Try to introspect from schema if available
+      if defined?(ActiveRecord::Base) && model_class_defined?
+        begin
+          model_class = class_name.constantize
+          if model_class.table_exists?
+            model_class.columns.each do |column|
+              attr_name = column.name
+              attr_type = schema_type_to_generator_type(column.type)
+              
+              # Skip if we already have this attribute or if it should be excluded
+              next if attributes.any? { |a| a[:name] == attr_name } || should_exclude_from_permitted_params?(attr_name, attr_type)
+              
+              attributes << {
+                name: attr_name,
+                type: attr_type
+              }
+            end
+          end
+        rescue => e
+          # Model class not available or database not connected
+          # Fall back to file-based introspection
+        end
+      end
+      
+      attributes
+    end
+
+    def introspected_permitted_params
+      return [] unless model_exists?
+      
+      attributes = introspect_model_attributes
+      
+      # Convert attributes to permitted param names (filtering already applied in introspect_model_attributes)
+      params = attributes.map do |attr|
+        attr[:name]
+      end
+      
+      # Always include common multi-tenancy params if not already included
+      %w[organization_id agency_id].each do |param|
+        params << param unless params.include?(param)
+      end
+      
+      params
+    end
+
+    def validate_attributes_exist
+      return if options[:all_attributes] || !model_exists?
+      
+      # If attributes were specified but model exists, validate they exist
+      return if attributes.empty?
+      
+      model_attributes = introspect_model_attributes
+      model_attr_names = model_attributes.map { |attr| attr[:name] }
+      
+      # Check if any specified attributes don't exist in the model
+      missing_attributes = attributes.map(&:name) - model_attr_names
+      
+      if missing_attributes.any?
+        say "Warning: The following attributes don't exist in #{class_name}:", :yellow
+        missing_attributes.each { |attr| say "  - #{attr}", :yellow }
+        say "Use --all-attributes to auto-detect model attributes", :cyan
+      end
+    end
+
+    # Shared controller and route generation methods
+    def create_propel_controller
+      initialize_propel_api_settings
+      
+      if behavior == :revoke
+        controller_file_path = "app/controllers/#{controller_path}/#{controller_file_name}.rb"
+        remove_file controller_file_path
+        say "Removed controller: #{controller_file_path}", :red
+      else
+        case @adapter
+        when 'propel_facets'
+          template "scaffold/facet_controller_template.rb.tt", "app/controllers/#{controller_path}/#{controller_file_name}.rb"
+        when 'graphiti'
+          template "scaffold/graphiti_controller_template.rb.tt", "app/controllers/#{controller_path}/#{controller_file_name}.rb"
+          
+          # Generate Graphiti resource if this generator supports it
+          if should_generate_graphiti_resource?
+            template "scaffold/graphiti_resource_template.rb.tt", "app/resources/#{file_name}_resource.rb"
+          end
+        else
+          raise "Unknown adapter: #{@adapter}. Run 'rails generate propel_api:install' first."
+        end
+      end
+    end
+
+    def create_propel_routes
+      if behavior == :revoke
+        remove_routes
+      else
+        insert_routes
+      end
+    end
+
+    def create_propel_tests(test_types: [])
+      if behavior == :revoke
+        # Remove test files
+        test_types.each do |test_type|
+          case test_type
+          when :model
+            remove_file "test/models/#{file_name}_test.rb"
+          when :controller
+            remove_file "test/controllers/#{controller_path}/#{controller_file_name}_test.rb"
+          when :integration
+            remove_file "test/integration/#{file_name}_api_test.rb"
+          when :fixtures
+            remove_file "test/fixtures/#{table_name}.yml"
+          end
+        end
+      else
+        # Generate test files
+        test_types.each do |test_type|
+          case test_type
+          when :model
+            template "tests/model_test_template.rb.tt", "test/models/#{file_name}_test.rb"
+          when :controller
+            template "tests/controller_test_template.rb.tt", "test/controllers/#{controller_path}/#{controller_file_name}_test.rb"
+          when :integration
+            template "tests/integration_test_template.rb.tt", "test/integration/#{file_name}_api_test.rb"
+          when :fixtures
+            template "tests/fixtures_template.yml.tt", "test/fixtures/#{table_name}.yml"
+          end
+        end
+      end
+    end
+
+    def show_propel_completion_message(resource_type:, generated_files:, next_steps:)
+      if behavior == :revoke
+        say "\n" + "="*70, :red
+        say "#{resource_type} Destroyed Successfully!", :red
+        say "="*70, :red
+        say "\n🗑️  Removed files:", :red
+        generated_files.each { |file| say "   #{file}", :red }
+        say "\n💡 Don't forget to:", :blue
+        say "   • Remove any manual customizations", :blue
+        say "   • Check for any remaining references", :blue
+        say "="*70, :red
+      else
+        say "\n" + "="*70, :green
+        say "#{resource_type} Generated Successfully!", :green
+        say "="*70, :green
+        say "\n📦 Generated files:", :green
+        generated_files.each { |file| say "   #{file}", :green }
+        say "\n🔧 Configuration:", :cyan
+        say "   • Adapter: #{@adapter}", :cyan
+        say "   • Namespace: #{namespace_display}", :cyan
+        say "   • Version: #{version_display}", :cyan
+        say "\n🚀 Next steps:", :blue
+        next_steps.each { |step| say "   • #{step}", :blue }
+        say "="*70, :green
+      end
+    end
+
+    private
+
+    def should_exclude_from_permitted_params?(attribute_name, attribute_type)
+      # Try to use the centralized configurable filter if available
+      begin
+        if defined?(PropelApi) && PropelApi.respond_to?(:attribute_filter)
+          return PropelApi.attribute_filter.exclude_from_permitted_params?(attribute_name, attribute_type)
+        end
+      rescue => e
+        # Configuration not available, fall back to default patterns
+      end
+      
+      # Fallback: Use the same patterns as templates for consistency
+      attr_str = attribute_name.to_s
+      
+      # Exclude timestamps and internal fields (same as templates)
+      excluded_patterns = /\A(created_at|updated_at|deleted_at|password_digest|reset_password_token|confirmation_token|unlock_token)\z/i
+      
+      # Always exclude security-sensitive fields (same as templates)
+      security_patterns = /(password|digest|token|secret|key|salt|encrypted|confirmation|unlock|reset|api_key|access_token|refresh_token)/i
+      
+      # Exclude binary and large data types (same as templates)
+      excluded_types = [:binary]
+      
+      # Apply the same filtering logic as templates
+      excluded_patterns.match?(attr_str) || 
+      security_patterns.match?(attr_str) ||
+      excluded_types.include?(attribute_type)
+    end
+
+    def model_class_defined?
+      begin
+        class_name.constantize
+        true
+      rescue NameError
+        false
+      end
+    end
+
+    def schema_type_to_generator_type(schema_type)
+      case schema_type
+      when :integer
+        :integer
+      when :decimal, :float
+        :decimal
+      when :boolean
+        :boolean
+      when :text
+        :text
+      when :datetime, :timestamp
+        :datetime
+      when :date
+        :date
+      when :time
+        :time
+      else
+        :string
+      end
+    end
+
+    # Subclasses can override this to control Graphiti resource generation
+    def should_generate_graphiti_resource?
+      false
+    end
+
+    # Route management helper methods
+    def insert_routes
+      routes_file = File.join(destination_root, "config/routes.rb")
+      return unless File.exist?(routes_file)
+      
+      routes_content = File.read(routes_file)
+      
+      if @api_namespace.present? && @api_version.present?
+        # Both namespace and version: insert into existing or create new structure
+        if has_nested_namespace?(routes_content, @api_namespace, @api_version)
+          resource_line = "    resources :#{route_name}"
+          insert_into_nested_namespace(routes_content, @api_namespace, @api_version, resource_line)
+        else
+          # Create new nested namespace structure
+          # Rails route method adds 2 spaces to each line, so we need to adjust for that
+          route_content = "namespace :#{@api_namespace} do\n  namespace :#{@api_version} do\n    resources :#{route_name}\n  end\nend"
+          route route_content
+        end
+      elsif @api_namespace.present?
+        # Only namespace: insert into existing or create new
+        if has_single_namespace?(routes_content, @api_namespace)
+          resource_line = "  resources :#{route_name}"
+          insert_into_single_namespace(routes_content, @api_namespace, resource_line)
+        else
+          # Create new namespace
+          # Rails route method adds 2 spaces to each line, so we need to adjust for that
+          route_content = "namespace :#{@api_namespace} do\n  resources :#{route_name}\nend"
+          route route_content
+        end
+      else
+        # No namespace: simple resources
+        route "resources :#{route_name}"
+      end
+    end
+
+    def remove_routes
+      routes_file = File.join(destination_root, "config/routes.rb")
+      return unless File.exist?(routes_file)
+      
+      routes_content = File.read(routes_file)
+      
+      # Try to remove the resources line specifically
+      resource_line_patterns = [
+        /^\s*resources :#{route_name}\s*$/m,
+        /^\s*resources :#{route_name},.*$/m,
+        /\s*resources :#{route_name}\s*\n/m
+      ]
+      
+      updated_content = routes_content
+      removed = false
+      
+      resource_line_patterns.each do |pattern|
+        if updated_content.match?(pattern)
+          updated_content = updated_content.gsub(pattern, '')
+          removed = true
+          break
+        end
+      end
+      
+      if removed
+        # Clean up empty namespace blocks after removing resources
+        updated_content = cleanup_empty_namespaces(updated_content)
+        
+        # Clean up extra newlines
+        updated_content = updated_content.gsub(/\n\n+/, "\n\n")
+        
+        File.write(routes_file, updated_content)
+        say "Removed resources :#{route_name} from routes", :red
+      else
+        say "Could not find routes for #{route_name} to remove. Please check config/routes.rb manually", :yellow
+      end
+    end
+
+    def has_nested_namespace?(content, namespace, version)
+      content.match?(/namespace\s+:#{namespace}\s+do.*?namespace\s+:#{version}\s+do/m)
+    end
+    
+    def has_single_namespace?(content, namespace)
+      content.match?(/namespace\s+:#{namespace}\s+do/)
+    end
+    
+    def insert_into_nested_namespace(content, namespace, version, resource_line)
+      # Check if resource already exists
+      existing_pattern = /namespace\s+:#{namespace}\s+do.*?namespace\s+:#{version}\s+do.*?resources\s+:#{route_name}/m
+      
+      if content.match?(existing_pattern)
+        say "Route for #{route_name} already exists in #{namespace}/#{version} namespace", :yellow
+        return
+      end
+      
+      # Find the position to insert the resource line
+      # Look for the end of the nested namespace's opening line
+      after_pattern = /namespace\s+:#{namespace}\s+do\s*\n\s*namespace\s+:#{version}\s+do\s*\n/
+      
+      if content.match?(after_pattern)
+        # Insert the resource line with proper indentation (4 spaces for nested namespace)
+        insert_into_file "config/routes.rb", "#{resource_line}\n", :after => after_pattern
+      else
+        # This shouldn't happen if has_nested_namespace? returned true, but handle it
+        route_content = "namespace :#{namespace} do\n  namespace :#{version} do\n#{resource_line}\n  end\nend"
+        route route_content
+      end
+    end
+
+    def insert_into_single_namespace(content, namespace, resource_line)
+      # Check if resource already exists
+      existing_pattern = /namespace\s+:#{namespace}\s+do.*?resources\s+:#{route_name}/m
+      
+      if content.match?(existing_pattern)
+        say "Route for #{route_name} already exists in #{namespace} namespace", :yellow
+        return
+      end
+      
+      # Find the position to insert the resource line
+      # Look for the end of the namespace's opening line
+      after_pattern = /namespace\s+:#{namespace}\s+do\s*\n/
+      
+      if content.match?(after_pattern)
+        # Insert the resource line with proper indentation (resource_line already has correct 2 spaces)
+        insert_into_file "config/routes.rb", "#{resource_line}\n", :after => after_pattern
+      else
+        # This shouldn't happen if has_single_namespace? returned true, but handle it
+        route_content = "namespace :#{namespace} do\n    resources :#{route_name}\n  end"
+        route route_content
+      end
+    end
+
+    def cleanup_empty_namespaces(content)
+      # Remove empty nested namespaces (namespace with only whitespace)
+      # This handles: namespace :api do\n  namespace :v1 do\n\n  end\nend
+      content = content.gsub(/namespace\s+:\w+\s+do\s*\n\s*namespace\s+:\w+\s+do\s*\n\s*end\s*\n\s*end/m, '')
+      
+      # Remove empty single namespaces
+      # This handles: namespace :api do\n\nend
+      content = content.gsub(/namespace\s+:\w+\s+do\s*\n\s*end/m, '')
+      
+      content
+    end
+  end
+end 

data/lib/generators/propel_api/core/path_generation_methods.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+##
+# Module providing API path generation methods for PropelApi generators
+#
+module PropelApi
+  module PathGenerationMethods
+    
+    protected
+
+    # Generate the full API controller class name with namespace and version
+    def api_controller_class_name
+      class_parts = []
+      class_parts << @api_namespace.camelize if @api_namespace.present?
+      class_parts << @api_version.upcase if @api_version.present?
+      class_parts << 'ApiController'
+      class_parts.join('::')
+    end
+
+    # Generate controller path for file creation
+    def controller_path
+      path_parts = []
+      path_parts << @api_namespace if @api_namespace.present?
+      path_parts << @api_version if @api_version.present?
+      path_parts.join('/')
+    end
+
+    # Generate API route path prefix
+    def api_route_prefix
+      path_parts = []
+      path_parts << @api_namespace if @api_namespace.present?
+      path_parts << @api_version if @api_version.present?
+      '/' + path_parts.join('/')
+    end
+
+    # Generate API controller file path
+    def api_controller_path
+      path_parts = ['app', 'controllers']
+      path_parts << @api_namespace if @api_namespace.present?
+      path_parts << @api_version if @api_version.present?
+      path_parts << 'api_controller.rb'
+      path_parts.join('/')
+    end
+  end
+end