tasker-engine 1.0.0

data/lib/tasker/authorization/resource_registry.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'resource_constants'
+
+module Tasker
+  module Authorization
+    # Resource registry defining available resources and their permitted actions
+    # for authorization purposes.
+    #
+    # This registry serves as a central catalog of all resources that can be
+    # authorized within the Tasker system. Each resource defines a set of
+    # actions that can be performed on it.
+    #
+    # @example Checking if a resource exists
+    #   ResourceRegistry.resource_exists?(RESOURCES::TASK) # => true
+    #
+    # @example Checking if an action is valid for a resource
+    #   ResourceRegistry.action_exists?(RESOURCES::TASK, ACTIONS::SHOW) # => true
+    #
+    # @example Getting all available permissions
+    #   ResourceRegistry.all_permissions
+    #   # => ["tasker.task:index", "tasker.task:show", ...]
+    class ResourceRegistry
+      include ResourceConstants
+
+      # Registry of all available resources and their permitted actions
+      RESOURCES = {
+        ResourceConstants::RESOURCES::TASK => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX,
+            ResourceConstants::ACTIONS::SHOW,
+            ResourceConstants::ACTIONS::CREATE,
+            ResourceConstants::ACTIONS::UPDATE,
+            ResourceConstants::ACTIONS::DESTROY,
+            ResourceConstants::ACTIONS::RETRY,
+            ResourceConstants::ACTIONS::CANCEL
+          ],
+          description: 'Tasker workflow tasks'
+        },
+        ResourceConstants::RESOURCES::WORKFLOW_STEP => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX,
+            ResourceConstants::ACTIONS::SHOW,
+            ResourceConstants::ACTIONS::UPDATE,
+            ResourceConstants::ACTIONS::DESTROY,
+            ResourceConstants::ACTIONS::RETRY,
+            ResourceConstants::ACTIONS::CANCEL
+          ],
+          description: 'Individual workflow steps'
+        },
+        ResourceConstants::RESOURCES::TASK_DIAGRAM => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX,
+            ResourceConstants::ACTIONS::SHOW
+          ],
+          description: 'Task workflow diagrams'
+        },
+        ResourceConstants::RESOURCES::HEALTH_STATUS => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX
+          ],
+          description: 'Health status endpoint information'
+        },
+        ResourceConstants::RESOURCES::HANDLER => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX,
+            ResourceConstants::ACTIONS::SHOW
+          ],
+          description: 'Handler discovery and metadata'
+        },
+        ResourceConstants::RESOURCES::METRICS => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX
+          ],
+          description: 'Prometheus metrics endpoint'
+        },
+        ResourceConstants::RESOURCES::ANALYTICS => {
+          actions: [
+            ResourceConstants::ACTIONS::INDEX
+          ],
+          description: 'Analytics and performance monitoring endpoints'
+        }
+      }.freeze
+
+      class << self
+        # Get all registered resources
+        #
+        # @return [Hash] The complete resource registry
+        def resources
+          RESOURCES
+        end
+
+        # Check if a resource exists in the registry
+        #
+        # @param resource [String] The resource name (e.g., 'tasker.task')
+        # @return [Boolean] True if the resource exists
+        def resource_exists?(resource)
+          RESOURCES.key?(resource)
+        end
+
+        # Check if an action is valid for a given resource
+        #
+        # @param resource [String] The resource name
+        # @param action [Symbol, String] The action name
+        # @return [Boolean] True if the action exists for the resource
+        def action_exists?(resource, action)
+          return false unless resource_exists?(resource)
+
+          RESOURCES[resource][:actions].include?(action.to_sym)
+        end
+
+        # Get all available permissions in "resource:action" format
+        #
+        # @return [Array<String>] All available permissions
+        def all_permissions
+          RESOURCES.flat_map do |resource, config|
+            config[:actions].map { |action| "#{resource}:#{action}" }
+          end
+        end
+
+        # Get all actions for a specific resource
+        #
+        # @param resource [String] The resource name
+        # @return [Array<Symbol>] Available actions for the resource
+        def actions_for_resource(resource)
+          return [] unless resource_exists?(resource)
+
+          RESOURCES[resource][:actions]
+        end
+
+        # Get description for a resource
+        #
+        # @param resource [String] The resource name
+        # @return [String, nil] Description of the resource
+        def resource_description(resource)
+          return nil unless resource_exists?(resource)
+
+          RESOURCES[resource][:description]
+        end
+      end
+    end
+  end
+end

data/lib/tasker/authorization.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Require all authorization components
+require_relative 'authorization/errors'
+require_relative 'authorization/resource_constants'
+require_relative 'authorization/resource_registry'
+require_relative 'authorization/base_coordinator'
+
+module Tasker
+  # Authorization module providing resource-based authorization for Tasker.
+  #
+  # This module implements a flexible, configuration-driven authorization system
+  # that follows the same dependency injection pattern as the authentication system.
+  # It provides:
+  #
+  # - Resource-based permissions using "resource:action" patterns
+  # - Pluggable authorization coordinators for custom logic
+  # - Automatic controller integration via concerns
+  # - User model integration via the Authorizable concern
+  #
+  # @example Basic configuration
+  #   Tasker.configuration do |config|
+  #     config.auth do |auth|
+  #       auth.enabled = true
+  #       auth.coordinator_class = 'MyAuthorizationCoordinator'
+  #       auth.user_class = 'User'
+  #     end
+  #   end
+  #
+  # @example Custom authorization coordinator
+  #   class MyAuthorizationCoordinator < Tasker::Authorization::BaseCoordinator
+  #     protected
+  #
+  #     def authorized?(resource, action, context = {})
+  #       case resource
+  #       when 'tasker.task'
+  #         user.can_manage_tasks?
+  #       else
+  #         false
+  #       end
+  #     end
+  #   end
+  module Authorization
+    # Get all available resources and their actions
+    #
+    # @return [Hash] Resource registry
+    def self.resources
+      ResourceRegistry.resources
+    end
+
+    # Get all available permissions in "resource:action" format
+    #
+    # @return [Array<String>] All available permissions
+    def self.all_permissions
+      ResourceRegistry.all_permissions
+    end
+
+    # Check if a resource exists
+    #
+    # @param resource [String] Resource name
+    # @return [Boolean] True if resource exists
+    def self.resource_exists?(resource)
+      ResourceRegistry.resource_exists?(resource)
+    end
+
+    # Check if an action exists for a resource
+    #
+    # @param resource [String] Resource name
+    # @param action [Symbol, String] Action name
+    # @return [Boolean] True if action exists for the resource
+    def self.action_exists?(resource, action)
+      ResourceRegistry.action_exists?(resource, action)
+    end
+  end
+end

data/lib/tasker/cache_capabilities.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Tasker
+  # Module for custom cache stores to declare their capabilities
+  #
+  # This module provides a clean, developer-friendly API for custom cache store
+  # implementations to declare their capabilities explicitly. This enables the
+  # CacheStrategy system to make optimal coordination decisions without relying
+  # on runtime introspection.
+  #
+  # **Usage Patterns**:
+  # 1. Include the module in your custom cache store class
+  # 2. Use convenience methods like `supports_distributed_caching!`
+  # 3. Or declare capabilities explicitly with `declare_cache_capability`
+  #
+  # @example Basic usage with convenience methods
+  #   class MyAwesomeCacheStore < ActiveSupport::Cache::Store
+  #     include Tasker::CacheCapabilities
+  #
+  #     supports_distributed_caching!
+  #     supports_atomic_increment!
+  #     supports_locking!
+  #   end
+  #
+  # @example Advanced usage with explicit declarations
+  #   class MyCustomCacheStore < ActiveSupport::Cache::Store
+  #     include Tasker::CacheCapabilities
+  #
+  #     declare_cache_capability(:distributed, true)
+  #     declare_cache_capability(:atomic_increment, true)
+  #     declare_cache_capability(:locking, false)
+  #     declare_cache_capability(:custom_feature, true)
+  #   end
+  #
+  # @example Runtime capability checking
+  #   store = MyAwesomeCacheStore.new
+  #   store.class.declared_cache_capabilities
+  #   # => { distributed: true, atomic_increment: true, locking: true }
+  module CacheCapabilities
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Declare a specific cache capability
+      #
+      # @param capability [Symbol] The capability name (e.g., :distributed, :atomic_increment)
+      # @param supported [Boolean] Whether this capability is supported
+      def declare_cache_capability(capability, supported)
+        cache_capabilities_hash[capability] = supported
+      end
+
+      # Declare support for distributed caching
+      #
+      # Indicates that this cache store shares data across multiple processes/containers.
+      # This enables distributed coordination strategies in IntelligentCacheManager.
+      def supports_distributed_caching!
+        declare_cache_capability(:distributed, true)
+      end
+
+      # Declare support for atomic increment operations
+      #
+      # Indicates that increment/decrement operations are truly atomic at the store level.
+      # This enables more efficient performance tracking and coordination.
+      def supports_atomic_increment!
+        declare_cache_capability(:atomic_increment, true)
+      end
+
+      # Declare support for distributed locking
+      #
+      # Indicates that the cache store supports distributed locking mechanisms.
+      # This enables the most sophisticated coordination strategies.
+      def supports_locking!
+        declare_cache_capability(:locking, true)
+      end
+
+      # Declare support for TTL inspection and management
+      #
+      # Indicates that the cache store supports checking and extending TTL values.
+      # This enables more sophisticated adaptive TTL strategies.
+      def supports_ttl_inspection!
+        declare_cache_capability(:ttl_inspection, true)
+      end
+
+      # Declare support for namespace isolation
+      #
+      # Indicates that the cache store supports namespace-based key isolation.
+      # This enables multi-tenant cache strategies.
+      def supports_namespace_isolation!
+        declare_cache_capability(:namespace_support, true)
+      end
+
+      # Declare support for automatic compression
+      #
+      # Indicates that the cache store supports automatic value compression.
+      # This enables memory-efficient caching strategies.
+      def supports_compression!
+        declare_cache_capability(:compression_support, true)
+      end
+
+      # Get all declared cache capabilities
+      #
+      # @return [Hash] Hash of capability => supported mappings
+      def declared_cache_capabilities
+        cache_capabilities_hash.dup
+      end
+
+      # Check if a specific capability has been declared
+      #
+      # @param capability [Symbol] The capability to check
+      # @return [Boolean, nil] True/false if declared, nil if not declared
+      def declared_capability_support(capability)
+        cache_capabilities_hash[capability]
+      end
+
+      # Check if any capabilities have been declared
+      #
+      # @return [Boolean] True if any capabilities have been explicitly declared
+      def has_declared_capabilities?
+        cache_capabilities_hash.any?
+      end
+
+      private
+
+      # Internal hash for storing declared capabilities
+      #
+      # @return [Hash] The internal capabilities hash
+      def cache_capabilities_hash
+        @cache_capabilities_hash ||= {}
+      end
+    end
+  end
+end