nexus_cqrs 0.3.1 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22851e4cf72bdb9d4895163003f9ccaef81182f71ba64de7b9729c80f06ea40b
-  data.tar.gz: a39184dedf35d590ad9b7f3dab51facbd233fd5e9ec7ddeab27c714604c47018
+  metadata.gz: 9be679b93bcb87378a6a0bd75dc5925b05e6f9dffef3fea2ec74d3482e883dda
+  data.tar.gz: 2749a963dbcd1a7b8d48cf18844b1fe106774b976d76b19f5fd6255211bece01
 SHA512:
-  metadata.gz: 5dd0e3cf9cb2014329a289bb94a9659144109988775709566996eb69aeaf663cc504ceb9cc83fb33b9e99fe2fc3e424c2584d0269d0b57564cecb148c1e0006c
-  data.tar.gz: 92497f3e118eb6bfad46e842fc0713fb64a8785ac0251296215003449593515c445de351c0afe9ff5f30efb9e5df1e0c4cf72c9c5c486ec253293c0e1e3094d4
+  metadata.gz: 7b4e7ec0a0b1fb59524d835d4fe181aff5d1bb94e5f0ea8b27497dd7fc8daf44984b0329d898b290fce84ed53ef013f74f0fe14a3fd4fbddda1b63f2aac18191
+  data.tar.gz: ce8df945c033cac10d106581adf226a55e9615594335606f1ea9ecbd19f00eb378dc1e7cf88fb7fab632d95281a77f35cbae32938cb697fb2c12968f6d69d95f

data/.gitignore

@@ -11,3 +11,6 @@
 *.gem
 
 results/rubocop.html
+
+# Ignore IDE configuration
+nexus_cqrs.iml

data/.rubocop.yml

@@ -3,9 +3,14 @@ inherit_gem:
 
 AllCops:
   Exclude:
-    - 'lib/generators/nexus_cqrs/templates/**/*.rb'
+    - db/schema.rb
+    - db/seeds.rb
+    - db/migrate/*.rb
+    - config/initializers/devise.rb
+    - spec/**/*
+
+Style/Documentation:
+  Enabled: false
 
 Style/GlobalVars:
   Enabled: false
-Style/FrozenStringLiteralComment:
-  Enabled: false

data/Gemfile

@@ -11,3 +11,4 @@ gem 'rspec'
 gem "generator_spec"
 gem 'thread_safe'
 gem 'ibsciss-middleware'
+gem 'request_store'

data/Gemfile.lock

@@ -1,9 +1,12 @@
 PATH
   remote: .
   specs:
-    nexus_cqrs (0.3.1)
+    nexus_cqrs (0.1.0)
       generator_spec
       ibsciss-middleware
+      pundit
+      request_store
+      strings-case
       thread_safe
 
 GEM
@@ -52,6 +55,8 @@ GEM
     parallel (1.21.0)
     parser (3.0.2.0)
       ast (~> 2.4.1)
+    pundit (2.1.1)
+      activesupport (>= 3.0.0)
     racc (1.6.0)
     rack (2.2.3)
     rack-test (1.1.0)
@@ -70,6 +75,8 @@ GEM
     rainbow (3.0.0)
     rake (13.0.6)
     regexp_parser (2.1.1)
+    request_store (1.5.0)
+      rack (>= 1.4)
     rexml (3.2.5)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -98,6 +105,7 @@ GEM
     rubocop-shopify (1.0.7)
       rubocop (~> 1.4)
     ruby-progressbar (1.11.0)
+    strings-case (0.3.0)
     thor (1.1.0)
     thread_safe (0.3.6)
     tzinfo (2.0.4)
@@ -112,6 +120,7 @@ DEPENDENCIES
   generator_spec
   ibsciss-middleware
   nexus_cqrs!
+  request_store
   rspec
   rubocop
   rubocop-shopify (~> 1.0.4)

data/README.md

@@ -1,8 +1,11 @@
-# Cqrs::Core
+# Nexus CQRS
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/cqrs/core`. To experiment with that code, run `bin/console` for an interactive prompt.
+Built by the NexusMods team for providing a universal way of organising CQRS logic (Command and Queries) and permission
+management. Used by most of NexusMod's rails applications.
 
-TODO: Delete this and the text above, and describe your gem
+The core concept of this gem is to provide a MessageBus that can invoked handlers registered to certain commands.
+This allows developers to separate business and application logic, whilst also seperating read operations from write
+operations (Queries and Commands).
 
 ## Installation
 
@@ -20,39 +23,119 @@ Or install it yourself as:
 
     $ gem install nexus_cqrs
 
-## Usage
+## Getting Started
 
-Generators can be used to aide in the creation of Commands and Queries:
+### Generators
+
+Generators can be used to aid in the creation of Commands and Queries:
 
     rails g nexus_cqrs:command CommandName
     rails g nexus_cqrs:query QueryName
 
-Once installed, a CommandBus is required to control the flow of Commands and/or Queries:
+Optionally, a command can be scaffolded with basic authorisation logic with `--permission`
+
+    rails g nexus_cqrs:command CommandName --permission
+    rails g nexus_cqrs:query QueryName --permission
+
+Once a command has been created, two new files will be created under `/app/domain/command` or `/app/domain/query`
+depending on which generator was used. An initializer will also be created - `register_cqrs_handlers.rb`
+
+### Command Bus and Executor
+
+In `register_cqrs_handlers.rb`, the command bus and executor will be created and used to register queries and commands:
+
+```ruby
+middleware_stack = Middleware::Builder.new do |b|
+  # Configure additional middleware for the CQRS stack here
+end
+
+command_bus = NexusCqrs::CommandBus.new(middleware: middleware_stack)
+query_bus = NexusCqrs::CommandBus.new(middleware: middleware_stack)
+
+$COMMAND_EXECUTOR = NexusCqrs::CommandExecutor.new(command_bus)
+$QUERY_EXECUTOR = NexusCqrs::CommandExecutor.new(query_bus)
+```
+
+*NOTE: By default, all classes extending `BaseCommand` and `BaseQuery` in the `app/domain` directory will be 
+registered automatically.* 
 
 ### Middleware
 
-Middleware can be created by extending the base middleware:
+Middleware can be created by extending the base middleware and injecting into the middleware stack:
 
 ```ruby
+# my_middleware.rb
 class MyMiddleware < NexusCqrs::BaseMiddleware
   def call(command)
     @next.call(command)
   end
 end
+
+# register_cqrs_handlers.rb
+middleware_stack = Middleware::Builder.new do |b|
+  b.use MyMiddleware
+end
+
+command_bus = Bus.new(middleware: middleware_stack)
 ```
 
-The above middleware will pass responsibility for execution to the next responder in the chain.
+The above middleware will pass responsibility for execution to the next responder in the chain and will be ran BEFORE 
+the handler is invoked for every message executed through the `CommandExecutor`
 
 For more information on writing middleware see: https://github.com/Ibsciss/ruby-middleware
 
-When creating a bus, middleware can be attached like so:
+### Metadata
+
+Commands/Queries can contain data, but data can also be injected into the message via metadata before the message is 
+executed:
 
 ```ruby
-middleware_stack = Middleware::Builder.new do |b|
-  b.use MyMiddleware
-end
+command.set_metadata(:current_user, user)
+execute(command)
+```
 
-command_bus = Bus.new(middleware: middleware_stack)
+### Authorisation
+
+There are various tools and helpers to aid with authorisation in this gem. Firstly, the system must be aware of the 
+user that is calling the command, this can be done by providing the current user and global permissions as metadata: 
+
+```ruby
+message.set_metadata(:current_user, current_user)
+message.set_metadata(:global_permissions, @access_token[:global_permissions])
+execute(message)
+```
+Once the metadata is set, the handler can than access the metadata - which in turn can invoke the `authorize` method:
+
+```ruby
+  class ModerateHandler < BaseCommandHandler
+    include NexusCqrs::Helpers
+
+    # @param [Commands::Moderate] command
+    def call(command)
+      mod = Mod.kept.find(command.mod_id)
+
+      authorize(command, mod)
+    ...
+```
+
+This will look up the correct Policy and automatically pass the metadata from the command, converting it into a 
+`UserContext` object:
+
+```ruby
+# Pull context variables from command
+user = message.metadata[:current_user]
+global_permissions = message.metadata[:global_permissions]
+
+# Instantiate new policy class, with context
+policy = policy_class.new(UserContext.new(user, global_permissions), record)
+```
+
+This will allow the policy class to access the `PermissionProvider` and retrieve any permission:
+
+```ruby
+def moderate?
+  permissions.has_permission?('mod:moderate', ModPermission, record.id)
+end
 ```
 
 ## Development
@@ -66,4 +149,4 @@ To contribute to this gem, simple pull the repository, run `bundle install` and
 
 ## Releasing
 
-The release process is tied to the git tags. Simply creating a new tag and pushing will trigger a new release to reubygems.
+The release process is tied to the git tags. Simply creating a new tag and pushing will trigger a new release to rubygems.

data/lib/generators/nexus_cqrs/templates/register_cqrs_handlers.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 Rails.configuration.to_prepare do
   middleware_stack = Middleware::Builder.new do |b|
-    b.use(NexusCqrsAuth::AuthMiddleware)
   end
 
   command_bus = NexusCqrs::CommandBus.new(middleware: middleware_stack)

data/lib/nexus_cqrs/auth/auth.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'pundit'
+require 'strings-case'
+
+module NexusCqrs
+  # Concern used to provide authorisation abilities to handlers and other classes. Overrides pundit's `authorize` method
+  # and creates helpers for the permission_provider
+  module Auth
+    include Pundit
+
+    # Overrides pundit's `authorize` method, allowing the message to be passed
+    #
+    # @see Pundit#authorize
+    # @param [NexusCqrs::BaseMessage] message Message to authorise against
+    def authorize(message, record, query = nil, policy_class: nil)
+      # Populate the query from the command, or the params if it's being overriden
+      query ||= Strings::Case.snakecase(message.demodularised_class_name) + '?'
+
+      # Retreive the policy class object from the type of record we are passing in
+      policy_class ||= PolicyFinder.new(record).policy
+
+      # Pull context variables from command
+      user = message.metadata[:current_user]
+      global_permissions = message.metadata[:global_permissions]
+
+      # Instantiate new policy class, with context
+      policy = policy_class.new(UserContext.new(user, global_permissions), record)
+      raise NotAuthorizedError, query: query, record: record, policy: policy unless policy.public_send(query)
+
+      record.is_a?(Array) ? record.last : record
+    end
+
+    # Helper method for creating a permissions provider object from a query object. This allows certain permissions
+    # to be checked inside the command handler, as opposed to inside the policy
+    #
+    # @param [NexusCqrs::BaseMessage] message Create the PermissionProvider using the message metadata
+    # @return [PermissionProvider] A new instance of the permission provider
+    def permission_provider(message)
+      PermissionProvider.new(message.metadata[:current_user], message.metadata[:global_permissions])
+    end
+
+    def pundit_user
+      nil
+    end
+
+    def current_user
+      return super if defined?(super)
+
+      nil
+    end
+  end
+end

data/lib/nexus_cqrs/auth/ownable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module NexusCqrs
+  module Auth
+    # Concern used to integrate models to the permissions system. Including this module to a model will assume the
+    # model can be "owned" by a user. When the model is created, permissions will automatically be assigned to the user
+    # and permissions can be validated and "repaired" retroactively.
+    module Ownable
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :granted_permissions, default: {}
+
+        # Default relationship to <class>_permissions
+        class_attribute :permissions_relation, default: top_ancestor_class.name.downcase + "_permissions"
+        class_attribute :owner_column, default: :user_id
+
+        before_create :assign_permissions
+
+        define_model_callbacks :create_permissions
+      end
+
+      module ClassMethods
+        # Gets the class that this module is included in
+        def top_ancestor_class
+          ancestors.first
+        end
+      end
+
+      def assign_permissions
+        # As we are doing this on before_create, we must "build" this association, as opposed to creating it. This
+        # ensures validation is passed before saving this parent Collection.
+        granted_permissions.each do |p|
+          unless permissions.where(permission: p, entity_id: id, user_id: owner_id).exists?
+            permissions.build(user_id: owner_id, permission: p)
+          end
+        end
+      end
+
+      def owner_id
+        send(owner_column)
+      end
+
+      def permissions
+        if respond_to?(permissions_relation)
+          return send(permissions_relation)
+        end
+
+        raise OwnableRelationshipNotSet, "Permissions relation not set.
+  Set it on your model with `self.permissions_relation = :xxx_permissions`, and ensure relationship has been created"
+      end
+    end
+
+    class OwnableRelationshipNotSet < StandardError
+    end
+  end
+end

data/lib/nexus_cqrs/auth/permission_provider.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+require 'request_store'
+
+module NexusCqrs
+  module Auth
+    class PermissionProvider
+      def initialize(user_id, global_permissions)
+        @user_id = user_id
+        @global_permissions = parse_permissions_array(global_permissions)
+      end
+
+      # Returns true if the current user has the requested permission on the requested entity (if passed), or globally
+      #
+      # @param [String] permission_key Permission key to check against
+      # @param [ApplicationRecord] permission_model Permission model
+      # @param [Integer] entity_id ID of the entity
+      # @return [Boolean] Returns true if the current user has this permission on this entity
+      # @example Check for permission
+      #   permissions.has_permission?('collection:publish', CollectionPermissions, collection.id) #=> true
+      def has_permission?(permission_key, permission_model = nil, entity_id = nil)
+        return false if @user_id.nil?
+
+        return true if @global_permissions.include?(permission_key)
+
+        # check entity-specific permissions
+        unless permission_model.nil?
+
+          # get all permissions for this entity. NOTE: This will be cached per-request.
+          permissions = cached_permissions(permission_model)
+
+          # if there are no permissions for this entity and user, return false
+          return false if permissions[entity_id].nil?
+
+          # if the permission key is in the user's permissions for this entity, return true
+          return true if permissions[entity_id].include?(permission_key)
+        end
+
+        false
+      end
+
+      # Retrieves a list of permissions assigned to a user for a specific entity
+      #
+      # @param [ApplicationRecord] permission_model Permission model
+      # @param [Integer] entity_id ID of the entity
+      # @return [Array] Returns an array of hashes representing permission keys, along with their global status
+      # @example Get a list of permissions
+      #   permissions.for_user_on_entity(CollectionPermissions, collection.id) #=>
+      #     [
+      #       {:global=>false, :key=>"collection:discard"},
+      #       {:global=>false, :key=>"collection:publish"},
+      #       {:global=>false, :key=>"collection:view_under_moderation"},
+      #       {:global=>false, :key=>"collection:set_status"}
+      #     ]
+      def for_user_on_entity(permission_model, entity_id)
+        return [] if @user_id.nil?
+
+        # retrieve entity-specific permissions from DB and map to hash
+        entity_permissions = permission_model.where(user_id: @user_id, entity_id: entity_id)
+          .map { |p| { global: false, key: p.permission } }
+
+        # Map global permissions to hash
+        global_permissions = @global_permissions.map { |p| { global: true, key: p } }
+
+        # Combine hashes and ensure global permissions take priority
+        (global_permissions + entity_permissions).uniq { |p| p[:key] }
+      end
+
+      # Retrieves a list of permissions assigned to a user for ANY entity ID
+      #
+      # @param [ApplicationRecord] permission_model Permission model
+      # @return [Hash] Returns a hash representing each entity and the user's permissions
+      # @example Get a list of permissions
+      #   permissions.for_user(CollectionPermissions) #=>
+      #     {
+      #       1 => ["collection:discard"],
+      #       2 => ["collection:discard"],
+      #       3 => ["collection:discard", "collection:edit"],
+      #       4 => ["collection:discard"],
+      #     }
+      def for_user(permission_model)
+        return {} if @user_id.nil?
+
+        permissions = {}
+
+        # retrieve entity-specific permissions from DB and map to hash
+        permission_model.where(user_id: @user_id).each do |p|
+          if permissions[p.entity_id].nil?
+            permissions[p.entity_id] = [p.permission]
+          else
+            permissions[p.entity_id] << p.permission
+          end
+        end
+
+        permissions
+      end
+
+      private
+
+      def parse_permissions_array(permissions_array)
+        return [] if permissions_array.nil?
+
+        permissions = []
+
+        permissions_array.each do |entity, action_array|
+          action_array.each do |action|
+            permissions << entity + ":" + action
+          end
+        end
+
+        permissions
+      end
+
+      # Retrieve all the permissions for this user for a specific model and cache it for this request (as all calls to
+      # a PermissionProvider in the same request will all have the same permissions, this saves on many SQL calls)
+      #
+      # @param [ApplicationRecord] permission_model Permission model
+      # @see PermissionProvider#for_user
+      def cached_permissions(permission_model)
+        ::RequestStore.store[:permissions] ||= for_user(permission_model)
+      end
+    end
+  end
+end

data/lib/nexus_cqrs/auth/user_context.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module NexusCqrs
+  module Auth
+    # Class used to provide additional context into pundit. This enables us to not only pass the user model, but also
+    # the global permissions for that user - as those are pulled from the user's request, not the model.
+    class UserContext
+      attr_reader :user, :global_permissions
+
+      def initialize(user, global_permissions)
+        @user = user
+        @global_permissions = global_permissions
+      end
+    end
+  end
+end

data/lib/nexus_cqrs/base_command.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # Base class for all commands. Should declare value types for passing to handlers
+  #
+  # @since 0.1.0
   class BaseCommand < BaseMessage
   end
 end

data/lib/nexus_cqrs/base_command_handler.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # Base class for all command handlers. Should always declare a `call` method for invoking the handler.
+  #
+  # @since 0.1.0
   class BaseCommandHandler
+    include NexusCqrs::Auth
+
+    # Method for invoking this handler - all command logic should be contained in this method.
+    #
+    # @param [NexusCqrs::BaseCommand] command Command to be executed by this handler
     def call(command)
     end
   end

data/lib/nexus_cqrs/base_message.rb

@@ -1,27 +1,52 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # All messages passed through the message bus will extend this class. Commands and Queries are both extended types of
+  # `BaseMessage`. This is mainly used to store metadata for Commands/Queries (such as the user context), as well
+  # as helper methods for retrieving the policy method for this Command/Query/Message
+  #
+  # @since 0.1.0
   class BaseMessage
+    # Sets metadata on this message.
+    #
+    # @param [Symbol] key Metadata key
+    # @param [Object] value Metadata value
+    # @example Set the current user on a command/query
+    #   command.set_metadata(:current_user, user)
+    # @since 0.1.0
     def set_metadata(key, value)
       @metadata = {} unless @metadata
       @metadata[key.to_sym] = value
     end
 
+    # Getter for retrieving the metadata on this message
+    #
+    # @return [Hash] Any metadata attached to this message
+    # @since 0.1.0
     def metadata
       @metadata || {}
     end
 
-    def to_h
-      hash = instance_variables.each_with_object({}) do |var, acc|
-        acc[var.to_s[1..-1].to_sym] = instance_variable_get(var)
-      end
-      hash[:metadata] = @metadata || {}
-      hash
-    end
-
+    # Helper method for retrieving the name of the class used to define the auth policy for this message
+    #
+    # @example Get the policy_class on a `Commands::Mods::DeleteMod` command
+    #   command.policy_class #=> "DeleteModPolicy"
+    #
+    # @return [String] Name of the policy class
+    # @deprecated This used to be used to authorise policies before they hit the command bus - requiring a new policy
+    #   for every message. E.g. `DeleteModPolicy`, `UpdateModPolicy`, `CreateModPolicy` etc. It is now recommended to
+    #   simple call `authorise` within the handler as it is far more flexible
+    # @since 0.1.0
     def policy_class
       demodularised_class_name + 'Policy'
     end
 
+    # Helper method for retrieving the demodularised name of the class used to define the auth policy for this message
+    #
+    # @example Get the demodularised_class_name on a `Commands::Mods::DeleteMod` command
+    #   command.policy_class #=> "DeleteMod"
+    #
+    # @return [String] Name of the policy class
+    # @since 0.1.0
     def demodularised_class_name
       self.class.name.split('::').last
     end

data/lib/nexus_cqrs/base_middleware.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # Base middleware class to allow custom middleware to be injected into the command bus
+  #
+  # @abstract
+  # @since 0.1.0
   class BaseMiddleware
     def initialize(next_)
       @next = next_
     end
 
-    # @param [BaseMessage] message
+    # Invoke middleware
+    #
+    # @param [BaseMessage] message Message object being passed to the bus
     def call(message)
     end
   end

data/lib/nexus_cqrs/base_query.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # Base class for all queries. Should declare value types for passing to handlers
+  #
+  # @since 0.1.0
   class BaseQuery < BaseMessage
   end
 end

data/lib/nexus_cqrs/base_query_handler.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # Base class for all query handlers. Should always declare a `call` method for invoking the handler.
+  #
+  # @since 0.1.0
   class BaseQueryHandler
+    include NexusCqrs::Auth
+
+    # Method for invoking this handler - all query logic should be contained in this method.
+    #
+    # @param [NexusCqrs::BaseQuery] query Query to be executed by this handler
     def call(query)
     end
   end

data/lib/nexus_cqrs/command_bus.rb

@@ -3,6 +3,11 @@ require 'thread_safe'
 require 'middleware'
 
 module NexusCqrs
+  # The command bus is responsible for registering and invoking the handlers. It stores a simple list of all registered
+  # commands, along with their handlers. When a message is passed to `call`, the middleware is triggered for the message
+  # then the handler is invoked.
+  #
+  # @since 0.1.0
   class CommandBus
     UnregisteredHandler = Class.new(StandardError)
     MultipleHandlers    = Class.new(StandardError)
@@ -12,23 +17,44 @@ module NexusCqrs
       @middleware = middleware || Middleware::Builder.new
     end
 
-    def register(klass, handler)
-      raise MultipleHandlers, "Multiple handlers not allowed for #{klass}" if handlers[klass]
+    # Registers a handler for a command.
+    #
+    # @param [NexusCqrs::BaseMessage] message Message to register a handler for
+    # @param [NexusCqrs::BaseCommandHandler] handler CommandHandler/QueryHandler to be invoked for this message
+    # @raise [MultipleHandlers] If the message already has a handler registered, an error will be raised
+    #
+    # @since 0.1.0
+    def register(message, handler)
+      raise MultipleHandlers, "Multiple handlers not allowed for #{message}" if handlers[message]
 
-      handlers[klass] = handler
+      handlers[message] = handler
     end
 
-    def call(command)
+    # Invokes a handler from a message
+    #
+    # @param [NexusCqrs::BaseMessage] message Message used to determine which handler to invoke
+    #
+    # @since 0.1.0
+    def call(message)
       runner = Middleware::Builder.new
       runner.use(@middleware)
-      runner.use(->(command_) { handler_for_command(command_).call(command_) })
-      runner.call(command)
+      runner.use(->(message_) { handler_for_command(message_).call(message_) })
+      runner.call(message)
     end
 
+    # Return a list of registered handlers
+    #
+    # @return [ThreadSafe::Cache] ThreadSafe::Cache object containing a list of all the registered handlers
+    #
+    # @since 0.1.0
     def registered_handlers
       handlers
     end
 
+    # Removes all registered handlers from the bus. This can be useful in tests - as we don't want state to persist
+    # across handlers
+    #
+    # @since 0.1.0
     def clear_handlers
       @handlers = ThreadSafe::Cache.new
     end
@@ -37,6 +63,9 @@ module NexusCqrs
 
     private
 
+    # Looks up the handler for a specific command
+    #
+    # @since 0.1.0
     def handler_for_command(command)
       unregistered_handler = proc { raise UnregisteredHandler, "Missing handler for #{command.class}" }
       handlers.fetch(command.class, &unregistered_handler)

data/lib/nexus_cqrs/command_executor.rb

@@ -1,42 +1,49 @@
 # frozen_string_literal: true
+
 module NexusCqrs
   class CommandExecutor
     # @param [NexusCqrs::CommandBus] command_bus
     def initialize(command_bus)
       @bus = command_bus
+      @logger = logger
+    end
+
+    # Get logger instance depending on runtime environment.
+    def logger
+      defined?(Rails) && defined?(Rails.logger) ? Rails.logger : Logger.new(STDOUT)
     end
 
     def autoregister(base_class, dir = 'app/domain/commands', ignore_strings = ['.rb', 'app/domain/'])
-      # Iterate over the director passed and find all ruby files, removing unwanted parts of the string.
-      Dir["#{dir}/*.rb"].each do |file|
-        ignore_strings.each do |i|
-          file.slice!(i)
-        end
-        begin
-          # Constantize class name to constant to force rails to autoload this class
+      if defined?(Rails)
+        # Iterate over the directory passed and find all ruby files.
+        Dir["#{dir}/**/*.rb"].each do |file|
+          # Constantize class name to constant to force rails to autoload this class.
+          # Note that autoloading won't work when testing this gem standalone, but this does trigger the necessary
+          # loading when in a rails environment.
+          ignore_strings.each do |i|
+            file.slice!(i)
+          end
+          @logger.debug { "Attempting constantize of #{file}" }
           file.camelize.constantize
-        rescue NameError
-          puts "WARN: Tried to autoregister #{file.camelize} but class could not be found"
+        rescue NameError => e
+          @logger.warn { "Failed autoregister #{file.camelize}, received NameError: #{e}" }
         end
       end
 
       ObjectSpace.each_object(Class).select { |klass| klass < base_class }.each do |c|
+        @logger.debug { "Attempting auto registration of #{c}" }
         handler_name = (c.to_s + "Handler")
         begin
           handler = handler_name.constantize.new
         rescue NameError
-          Rails.logger.error(
-            "WARN: A command `#{c}` tried to autoregister `#{handler_name}` but the class was not found"
-          )
+          @logger.warn { "Command `#{c}` tried to autoregister `#{handler_name}` but the class was not found" }
           next
         end
 
         if handler.respond_to?(:call)
           register_command(c, handler)
         else
-          Rails.logger.error(
-            "WARN: A command `#{c}` tried to autoregister `#{handler_name}` but `call` method did not exist"
-          )
+          @logger.warn { "Command `#{c}` tried to autoregister `#{handler_name}` but `call` method did not exist" }
         end
       end
     end
@@ -48,16 +55,24 @@ module NexusCqrs
       @bus
     end
 
-    # @param [NexusCqrs::BaseCommand] command
-    def execute(command)
-      @bus.call(command)
+    # Executes a specific handler on the bus, passing in the provided message (Query/Command)
+    #
+    # @param [NexusCqrs::BaseMessage] message
+    def execute(message)
+      @bus.call(message)
     end
 
+    # Helper method for registering a handler on the bus
+    #
+    # @see CommandBus#register
+    # @param [NexusCqrs::BaseMessage] message
     # @param [NexusCqrs::BaseCommandHandler] handler
-    def register_command(klass, handler)
-      @bus.register(klass, handler)
+    def register_command(message, handler)
+      @bus.register(message, handler)
     end
 
+    # Clears all handlers from the bus and invokes the block passed to `configure_handlers` to re-register all the
+    # handlers again. This can be useful in tests - as we don't want state to persist across handlers
     def reregister_handlers
       return if @register_handlers.nil?
 
@@ -65,6 +80,18 @@ module NexusCqrs
       @register_handlers.call(self)
     end
 
+    # Configuration method for allowing handlers to be registered in bulk
+    #
+    # @see CommandBus#register
+    # @param [Proc] block Block to execute to register handlers
+    # @example Registering all queries
+    #   executor.configure_handlers do |executor|
+    #     executor.autoregister(NexusCqrs::BaseQuery, 'app/domain/queries')
+    #   end
+    # @example Registering a query manually
+    #   executor.configure_handlers do |executor|
+    #     executor.register_command(NexusCqrs::BaseQuery, NexusCqrs::BaseQueryHandler)
+    #   end
     def configure_handlers(&block)
       @register_handlers = block
       @register_handlers.call(self)

data/lib/nexus_cqrs/helpers.rb

@@ -1,21 +1,36 @@
 # frozen_string_literal: true
 module NexusCqrs
+  # Simple module to inject execution methods into a class. Used to execute commands and queries from controllers and/or
+  # graphql resolvers.
   module Helpers
     # Executes a CQRS Command
+    #
+    # @param [NexusCqrs::BaseCommand] command Command to execute
+    # @example Execute a command
+    #     execute(DeleteMod.new(mod.id))
     def execute(command)
       command_executor.execute(command)
     end
 
     # Executes a CQRS Query
+    #
+    # @param [NexusCqrs::BaseQuery] query Query to execute
+    # @example Execute a query
+    #     execute(GetMod.new(mod.id))
     def query(query)
       query_executor.execute(query)
     end
 
-    # Provide access to the CQRS executor
+    # Provide access to the CQRS command executor
+    #
+    # @return [NexusCqrs::CommandExecutor] Returns the executor used for commands
     def command_executor
       @command_executor ||= $COMMAND_EXECUTOR
     end
 
+    # Provide access to the CQRS query executor
+    #
+    # @return [NexusCqrs::CommandExecutor] Returns the executor used for queries
     def query_executor
       @query_executor ||= $QUERY_EXECUTOR
     end

data/lib/nexus_cqrs/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 module NexusCqrs
-  VERSION = '0.3.1'
+  # Leave this as 0.4.4 in order for CI process to replace with the tagged version.
+  VERSION = '0.4.4'
 end

data/lib/nexus_cqrs.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 require 'nexus_cqrs/base_message'
 require 'nexus_cqrs/base_middleware'
+require 'nexus_cqrs/auth/auth'
+require 'nexus_cqrs/auth/user_context'
+require 'nexus_cqrs/auth/permission_provider'
+require 'nexus_cqrs/auth/ownable'
 require 'nexus_cqrs/base_command'
 require 'nexus_cqrs/base_command_handler'
 require 'nexus_cqrs/base_query'

data/nexus_cqrs.gemspec

@@ -21,4 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency('generator_spec')
   spec.add_dependency('thread_safe')
   spec.add_dependency('ibsciss-middleware')
+  spec.add_dependency('pundit')
+  spec.add_dependency('strings-case')
+  spec.add_dependency('request_store')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexus_cqrs
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.4
 platform: ruby
 authors:
 - Dean Lovett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-11 00:00:00.000000000 Z
+date: 2021-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: generator_spec
@@ -52,6 +52,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pundit
+  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: strings-case
+  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: request_store
+  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'
 description: 
 email:
 - dean.lovett@nexusmods.com
@@ -79,6 +121,10 @@ files:
 - lib/generators/nexus_cqrs/templates/query_handler.rb
 - lib/generators/nexus_cqrs/templates/register_cqrs_handlers.rb
 - lib/nexus_cqrs.rb
+- lib/nexus_cqrs/auth/auth.rb
+- lib/nexus_cqrs/auth/ownable.rb
+- lib/nexus_cqrs/auth/permission_provider.rb
+- lib/nexus_cqrs/auth/user_context.rb
 - lib/nexus_cqrs/base_command.rb
 - lib/nexus_cqrs/base_command_handler.rb
 - lib/nexus_cqrs/base_message.rb
@@ -108,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: Core package for the nexus cqrs gem