tasker-engine 1.0.0

data/lib/generators/tasker/templates/authorization_coordinator_spec.rb.erb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe <%= @coordinator_class_name %>, type: :model do
+  let(:user_class) { Struct.new(:id, :permissions, :roles, :admin, keyword_init: true) }
+
+  let(:admin_user) do
+    user_class.new(
+      id: 1,
+      permissions: [],
+      roles: ['admin'],
+      admin: true
+    )
+  end
+
+  let(:regular_user) do
+    user_class.new(
+      id: 2,
+      permissions: [
+        'tasker.task:index',
+        'tasker.task:show',
+        'tasker.workflow_step:index',
+        'tasker.task_diagram:index'
+      ],
+      roles: ['user'],
+      admin: false
+    )
+  end
+
+  let(:coordinator) { described_class.new(user) }
+
+  # Add required methods to test users
+  before do
+    user_class.class_eval do
+      def has_tasker_permission?(permission)
+        permissions.include?(permission)
+      end
+
+      def tasker_admin?
+        admin == true
+      end
+
+      def tasker_roles
+        roles
+      end
+    end
+  end
+
+  describe '#authorize!' do
+    context 'with admin user' do
+      let(:user) { admin_user }
+
+      it 'allows admin access to all resources' do
+        expect { coordinator.authorize!('tasker.task', :index) }.not_to raise_error
+        expect { coordinator.authorize!('tasker.task', :create) }.not_to raise_error
+        expect { coordinator.authorize!('tasker.workflow_step', :update) }.not_to raise_error
+        expect { coordinator.authorize!('tasker.task_diagram', :show) }.not_to raise_error
+      end
+    end
+
+    context 'with regular user' do
+      let(:user) { regular_user }
+
+      it 'allows access to permitted resources' do
+        expect { coordinator.authorize!('tasker.task', :index) }.not_to raise_error
+        expect { coordinator.authorize!('tasker.task', :show) }.not_to raise_error
+        expect { coordinator.authorize!('tasker.workflow_step', :index) }.not_to raise_error
+        expect { coordinator.authorize!('tasker.task_diagram', :index) }.not_to raise_error
+      end
+
+      it 'denies access to forbidden resources' do
+        expect { coordinator.authorize!('tasker.task', :create) }.to raise_error(Tasker::Authorization::UnauthorizedError)
+        expect { coordinator.authorize!('tasker.task', :destroy) }.to raise_error(Tasker::Authorization::UnauthorizedError)
+        expect { coordinator.authorize!('tasker.workflow_step', :update) }.to raise_error(Tasker::Authorization::UnauthorizedError)
+      end
+    end
+
+    context 'with no user' do
+      let(:user) { nil }
+
+      it 'denies all operations' do
+        expect { coordinator.authorize!('tasker.task', :index) }.to raise_error(Tasker::Authorization::UnauthorizedError)
+        expect { coordinator.authorize!('tasker.workflow_step', :show) }.to raise_error(Tasker::Authorization::UnauthorizedError)
+        expect { coordinator.authorize!('tasker.task_diagram', :show) }.to raise_error(Tasker::Authorization::UnauthorizedError)
+      end
+    end
+  end
+
+  describe '#can?' do
+    context 'with admin user' do
+      let(:user) { admin_user }
+
+      it 'returns true for valid operations' do
+        expect(coordinator.can?('tasker.task', :index)).to be true
+        expect(coordinator.can?('tasker.task', :create)).to be true
+        expect(coordinator.can?('tasker.workflow_step', :update)).to be true
+        expect(coordinator.can?('tasker.task_diagram', :show)).to be true
+      end
+    end
+
+    context 'with regular user' do
+      let(:user) { regular_user }
+
+      it 'returns true for permitted operations' do
+        expect(coordinator.can?('tasker.task', :index)).to be true
+        expect(coordinator.can?('tasker.task', :show)).to be true
+        expect(coordinator.can?('tasker.workflow_step', :index)).to be true
+        expect(coordinator.can?('tasker.task_diagram', :index)).to be true
+      end
+
+      it 'returns false for forbidden operations' do
+        expect(coordinator.can?('tasker.task', :create)).to be false
+        expect(coordinator.can?('tasker.task', :destroy)).to be false
+        expect(coordinator.can?('tasker.workflow_step', :update)).to be false
+      end
+    end
+
+    it 'returns false for unknown resources' do
+      expect(coordinator.can?('unknown.resource', :index)).to be false
+    end
+
+    it 'returns false for unknown actions' do
+      expect(coordinator.can?('tasker.task', :unknown_action)).to be false
+    end
+  end
+
+  describe 'interface compliance' do
+    it 'inherits from BaseCoordinator' do
+      expect(described_class.superclass).to eq(Tasker::Authorization::BaseCoordinator)
+    end
+
+    it 'implements the required authorized? method' do
+      expect(coordinator).to respond_to(:authorized?, true)
+    end
+
+    it 'provides access to the user' do
+      coordinator = described_class.new(regular_user)
+      expect(coordinator.send(:user)).to eq(regular_user)
+    end
+  end
+end

data/lib/generators/tasker/templates/custom_authenticator.rb.erb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# Custom authenticator for <%= class_name %>
+# Generated by: rails generate tasker:authenticator <%= file_name %> --type=custom
+#
+# This authenticator template provides a starting point for implementing
+# custom authentication logic in your Tasker application.
+#
+# Configuration example:
+#   Tasker.configuration do |config|
+#     config.auth do |auth|
+#       auth.strategy = :custom
+#       auth.options = {
+#         authenticator_class: '<%= class_name %>Authenticator',
+#         user_class: '<%= user_model_class %>'
+#         # Add your custom options here
+#       }
+#     end
+#   end
+
+class <%= class_name %>Authenticator
+  include Tasker::Authentication::Interface
+
+  def initialize(options = {})
+    @user_class = options[:user_class] || '<%= user_model_class %>'
+    @options = options
+  end
+
+  # Required: Authenticate the request, raise exception if fails
+  def authenticate!(controller)
+    user = current_user(controller)
+    unless user
+      raise Tasker::Authentication::AuthenticationError,
+            'Authentication failed. Please provide valid credentials.'
+    end
+    true
+  end
+
+  # Required: Get the current authenticated user
+  def current_user(controller)
+    return @current_user if defined?(@current_user)
+
+    @current_user = begin
+      # TODO: Implement your user lookup logic here
+      # Examples:
+      #   - Check session for user ID
+      #   - Extract token from headers
+      #   - Use existing Rails authentication
+      #   - Custom authentication scheme
+
+      # Example session-based lookup:
+      # user_id = controller.session[:user_id]
+      # return nil unless user_id
+      # user_model.find_by(id: user_id)
+
+      # Example header-based lookup:
+      # token = controller.request.headers['Authorization']
+      # return nil unless token
+      # find_user_by_token(token)
+
+      # Placeholder - replace with your logic
+      nil
+    rescue StandardError => e
+      Rails.logger.error "Authentication error in <%= class_name %>Authenticator: #{e.message}"
+      nil
+    end
+  end
+
+  # Optional: Check if user is authenticated (uses current_user by default)
+  def authenticated?(controller)
+    current_user(controller).present?
+  end
+
+  # Optional: Configuration validation
+  def validate_configuration(options = {})
+    errors = []
+
+    # Validate user class
+    user_class = options[:user_class] || '<%= user_model_class %>'
+    begin
+      user_class.constantize
+    rescue NameError
+      errors << "User class '#{user_class}' not found"
+    end
+
+    # TODO: Add your custom validation logic here
+    # Examples:
+    #   - Required configuration options
+    #   - External service dependencies
+    #   - Security settings validation
+
+    errors
+  end
+
+  private
+
+  attr_reader :options, :user_class
+
+  def user_model
+    @user_model ||= @user_class.constantize
+  end
+
+  # TODO: Add your private helper methods here
+  # Examples:
+  #   def extract_token(request)
+  #   def find_user_by_token(token)
+  #   def validate_credentials(credentials)
+end

data/lib/generators/tasker/templates/custom_authenticator_spec.rb.erb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe <%= class_name %>Authenticator, type: :model do
+  let(:options) do
+    {
+      user_class: '<%= user_model_class %>'
+      # Add your custom options here
+    }
+  end
+
+  let(:authenticator) { described_class.new(options) }
+  let(:controller) { instance_double('ActionController::Base') }
+  let(:request) { instance_double('ActionDispatch::Request') }
+  let(:headers) { {} }
+
+  before do
+    allow(controller).to receive(:request).and_return(request)
+    allow(request).to receive(:headers).and_return(headers)
+  end
+
+  describe '#initialize' do
+    it 'sets default options' do
+      authenticator = described_class.new
+      expect(authenticator.send(:user_class)).to eq('<%= user_model_class %>')
+    end
+
+    it 'accepts custom options' do
+      custom_options = { user_class: 'CustomUser' }
+      authenticator = described_class.new(custom_options)
+      expect(authenticator.send(:user_class)).to eq('CustomUser')
+    end
+  end
+
+  describe '#authenticate!' do
+    context 'when user is authenticated' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(double('User'))
+      end
+
+      it 'returns true' do
+        expect(authenticator.authenticate!(controller)).to be_truthy
+      end
+    end
+
+    context 'when user is not authenticated' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(nil)
+      end
+
+      it 'raises AuthenticationError' do
+        expect do
+          authenticator.authenticate!(controller)
+        end.to raise_error(Tasker::Authentication::AuthenticationError)
+      end
+    end
+  end
+
+  describe '#current_user' do
+    context 'when user authentication succeeds' do
+      # TODO: Implement test cases based on your authentication logic
+      # Example:
+      # let(:user) { create(:user) }
+      #
+      # before do
+      #   # Set up your authentication scenario
+      #   # e.g., session, headers, tokens, etc.
+      # end
+      #
+      # it 'returns the authenticated user' do
+      #   expect(authenticator.current_user(controller)).to eq(user)
+      # end
+
+      it 'needs implementation based on your authentication logic' do
+        pending 'Implement based on your specific authentication method'
+      end
+    end
+
+    context 'when user authentication fails' do
+      it 'returns nil' do
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+
+    context 'when authentication raises an error' do
+      before do
+        # Simulate an error in your authentication logic
+        allow(controller).to receive(:session).and_raise(StandardError, 'Session error')
+      end
+
+      it 'returns nil and logs the error' do
+        expect(Rails.logger).to receive(:error).with(/Authentication error/)
+        expect(authenticator.current_user(controller)).to be_nil
+      end
+    end
+  end
+
+  describe '#authenticated?' do
+    context 'when current_user returns a user' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(double('User'))
+      end
+
+      it 'returns true' do
+        expect(authenticator.authenticated?(controller)).to be true
+      end
+    end
+
+    context 'when current_user returns nil' do
+      before do
+        allow(authenticator).to receive(:current_user).with(controller).and_return(nil)
+      end
+
+      it 'returns false' do
+        expect(authenticator.authenticated?(controller)).to be false
+      end
+    end
+  end
+
+  describe '#validate_configuration' do
+    context 'with valid configuration' do
+      it 'returns no errors' do
+        errors = authenticator.validate_configuration(options)
+        expect(errors).to be_empty
+      end
+    end
+
+    context 'with invalid user class' do
+      let(:invalid_options) { { user_class: 'NonExistentUser' } }
+
+      it 'returns validation errors' do
+        errors = authenticator.validate_configuration(invalid_options)
+        expect(errors).to include(/not found/)
+      end
+    end
+
+    # TODO: Add more validation test cases based on your specific requirements
+    # Examples:
+    # context 'when required option is missing' do
+    #   let(:invalid_options) { options.except(:required_option) }
+    #
+    #   it 'returns validation error' do
+    #     errors = authenticator.validate_configuration(invalid_options)
+    #     expect(errors).to include(/required/)
+    #   end
+    # end
+  end
+
+  describe 'interface compliance' do
+    it 'includes the authentication interface' do
+      expect(described_class.included_modules).to include(Tasker::Authentication::Interface)
+    end
+
+    it 'responds to required interface methods' do
+      expect(authenticator).to respond_to(:authenticate!)
+      expect(authenticator).to respond_to(:current_user)
+      expect(authenticator).to respond_to(:authenticated?)
+      expect(authenticator).to respond_to(:validate_configuration)
+    end
+  end
+end

data/lib/generators/tasker/templates/custom_events.yml.erb

@@ -0,0 +1,62 @@
+---
+# <%= application_name.humanize %> Custom Events Configuration
+# Define your application-specific events here
+# The system automatically protects against namespace collisions
+
+events:
+  # Example order processing events
+  custom:
+    order_processed:
+      constant: "order.processed"
+      description: "Fired when an order is fully processed and ready for fulfillment"
+      payload_schema:
+        order_id: { type: "String", required: true }
+        customer_id: { type: "String", required: true }
+        total_amount: { type: "Float", required: true }
+        timestamp: { type: "Time", required: true }
+      fired_by: ["OrderService"]
+
+    payment_completed:
+      constant: "payment.completed"
+      description: "Fired when a payment is successfully processed"
+      payload_schema:
+        payment_id: { type: "String", required: true }
+        order_id: { type: "String", required: true }
+        amount: { type: "Float", required: true }
+        payment_method: { type: "String", required: true }
+        timestamp: { type: "Time", required: true }
+      fired_by: ["PaymentService"]
+
+    notification_sent:
+      constant: "notification.sent"
+      description: "Fired when a notification is successfully sent"
+      payload_schema:
+        notification_id: { type: "String", required: true }
+        recipient: { type: "String", required: true }
+        channel: { type: "String", required: true }
+        success: { type: "Boolean", required: true }
+        timestamp: { type: "Time", required: true }
+      fired_by: ["NotificationService"]
+
+# Uncomment and customize these examples for your application:
+#
+#     user_registered:
+#       constant: "user.registered"
+#       description: "Fired when a new user completes registration"
+#       payload_schema:
+#         user_id: { type: "String", required: true }
+#         email: { type: "String", required: true }
+#         registration_source: { type: "String", required: true }
+#         timestamp: { type: "Time", required: true }
+#       fired_by: ["UserService", "RegistrationController"]
+#
+#     data_exported:
+#       constant: "data.exported"
+#       description: "Fired when data export is completed"
+#       payload_schema:
+#         export_id: { type: "String", required: true }
+#         format: { type: "String", required: true }
+#         record_count: { type: "Integer", required: true }
+#         file_size: { type: "Integer", required: false }
+#         timestamp: { type: "Time", required: true }
+#       fired_by: ["ExportService"]

data/lib/generators/tasker/templates/custom_subscriber.rb.erb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Example Custom Events Subscriber for <%= application_name.humanize %>
+#
+# This subscriber demonstrates how to create custom event handlers
+# for your application-specific events.
+class CustomEventsSubscriber < Tasker::Events::Subscribers::BaseSubscriber
+  # Subscribe to custom events defined in config/tasker/events.yml
+  # Note: Use clean event names - the system handles namespace protection internally
+  subscribe_to 'order.processed',
+               'payment.completed',
+               'notification.sent'
+
+  # Handle order processed events
+  def handle_order_processed(event)
+    order_id = safe_get(event, :order_id)
+    customer_id = safe_get(event, :customer_id)
+    total_amount = safe_get(event, :total_amount)
+
+    Rails.logger.info("Order #{order_id} processed for customer #{customer_id}, total: $#{total_amount}")
+
+    # Example: Send completion notification
+    # OrderCompletionMailer.order_processed(order_id).deliver_later
+
+    # Example: Update analytics
+    # Analytics.track_order_completion(order_id: order_id, amount: total_amount)
+  end
+
+  # Handle payment completion events
+  def handle_payment_completed(event)
+    payment_id = safe_get(event, :payment_id)
+    order_id = safe_get(event, :order_id)
+    payment_method = safe_get(event, :payment_method)
+
+    Rails.logger.info("Payment #{payment_id} completed for order #{order_id} via #{payment_method}")
+
+    # Example: Record payment metrics
+    # PaymentMetrics.record_completion(payment_id: payment_id, method: payment_method)
+
+    # Example: Trigger fulfillment
+    # FulfillmentService.process_order(order_id)
+  end
+
+  # Handle notification sent events
+  def handle_notification_sent(event)
+    notification_id = safe_get(event, :notification_id)
+    recipient = safe_get(event, :recipient)
+    channel = safe_get(event, :channel)
+    success = safe_get(event, :success)
+
+    if success
+      Rails.logger.info("Notification #{notification_id} sent to #{recipient} via #{channel}")
+
+      # Example: Update delivery metrics
+      # NotificationMetrics.record_delivery(notification_id: notification_id, channel: channel)
+    else
+      Rails.logger.warn("Failed to send notification #{notification_id} to #{recipient}")
+
+      # Example: Retry or escalate
+      # NotificationRetryService.schedule_retry(notification_id)
+    end
+  end
+
+  # Optional: Override to add subscriber-specific filtering
+  # def should_process_event?(event_constant)
+  #   # Only process events during business hours
+  #   Time.current.hour.between?(9, 17)
+  # end
+end
+
+# Register the subscriber (add this to an initializer)
+# CustomEventsSubscriber.subscribe(Tasker::Events::Publisher.instance)

data/lib/generators/tasker/templates/devise_authenticator.rb.erb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Devise authenticator for <%= class_name %>
+# Generated by: rails generate tasker:authenticator <%= file_name %> --type=devise
+#
+# This authenticator integrates with Devise authentication system.
+# Uses Devise's built-in authentication methods and scopes.
+#
+# Configuration example:
+#   Tasker.configuration do |config|
+#     config.auth do |auth|
+#       auth.strategy = :custom
+#       auth.options = {
+#         authenticator_class: '<%= class_name %>Authenticator',
+#         scope: :user
+#       }
+#     end
+#   end
+
+class <%= class_name %>Authenticator
+  include Tasker::Authentication::Interface
+
+  def initialize(options = {})
+    @scope = options[:scope] || :user
+    @failure_app = options[:failure_app]
+    @options = options
+  end
+
+  # Required: Authenticate the request, raise exception if fails
+  def authenticate!(controller)
+    # Use Devise's built-in authentication
+    result = controller.send("authenticate_#{@scope}!")
+
+    # Devise authenticate_*! methods return true on success or redirect/halt on failure
+    # If we reach here, authentication was successful
+    result
+  rescue StandardError => e
+    # Devise authentication failed
+    raise Tasker::Authentication::AuthenticationError,
+          "Devise authentication failed: #{e.message}"
+  end
+
+  # Required: Get the current authenticated user
+  def current_user(controller)
+    # Use Devise's current_user helper
+    controller.send("current_#{@scope}")
+  rescue StandardError => e
+    Rails.logger.error "Error getting current #{@scope}: #{e.message}"
+    nil
+  end
+
+  # Optional: Check if user is authenticated
+  def authenticated?(controller)
+    # Use Devise's user_signed_in? helper if available
+    signed_in_method = "#{@scope}_signed_in?"
+
+    if controller.respond_to?(signed_in_method)
+      controller.send(signed_in_method)
+    else
+      # Fallback to checking current_user presence
+      current_user(controller).present?
+    end
+  end
+
+  # Optional: Configuration validation
+  def validate_configuration(options = {})
+    errors = []
+
+    # Check if Devise is available
+    unless defined?(Devise)
+      errors << 'Devise gem is required for DeviseAuthenticator'
+    end
+
+    # Validate scope
+    scope = options[:scope] || :user
+    unless scope.is_a?(Symbol)
+      errors << 'Devise scope must be a symbol'
+    end
+
+    # Check if scope is configured in Devise
+    if defined?(Devise) && Devise.mappings[scope].nil?
+      errors << "Devise scope '#{scope}' is not configured. Available scopes: #{Devise.mappings.keys.join(', ')}"
+    end
+
+    errors
+  end
+
+  private
+
+  attr_reader :scope, :failure_app, :options
+
+  # Helper method to get the user model class for the scope
+  def user_model_class
+    return nil unless defined?(Devise)
+
+    mapping = Devise.mappings[@scope]
+    mapping&.class_name&.constantize
+  rescue StandardError
+    nil
+  end
+end