plutonium 0.39.2 → 0.40.0

data/lib/generators/pu/invites/install_generator.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/active_record/migration"
+require_relative "../lib/plutonium_generators"
+
+module Pu
+  module Invites
+    class InstallGenerator < ::Rails::Generators::Base
+      include ::ActiveRecord::Generators::Migration
+      include PlutoniumGenerators::Generator
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Install user invites package"
+
+      class_option :entity_model, type: :string, default: "Entity",
+        desc: "The entity model name for scoping invites"
+
+      class_option :user_model, type: :string, default: "User",
+        desc: "The user model name"
+
+      class_option :membership_model, type: :string,
+        desc: "The membership model name (defaults to <Entity>User)"
+
+      class_option :roles, type: :array, default: %w[member admin],
+        desc: "Available roles for invitations"
+
+      class_option :rodauth, type: :string, default: "user",
+        desc: "Rodauth configuration name for signup integration"
+
+      class_option :enforce_domain, type: :boolean, default: false,
+        desc: "Require invited user email to match entity domain"
+
+      def validate_requirements
+        errors = []
+
+        unless File.exist?(Rails.root.join(entity_model_path))
+          errors << "Entity model not found: #{entity_model_path}"
+        end
+
+        unless File.exist?(Rails.root.join(entity_definition_path))
+          errors << "Entity definition not found: #{entity_definition_path}"
+        end
+
+        unless File.exist?(Rails.root.join(entity_policy_path))
+          errors << "Entity policy not found: #{entity_policy_path}"
+        end
+
+        unless File.exist?(Rails.root.join(user_definition_path))
+          errors << "User definition not found: #{user_definition_path}"
+        end
+
+        unless File.exist?(Rails.root.join(user_policy_path))
+          errors << "User policy not found: #{user_policy_path}"
+        end
+
+        if errors.any?
+          errors.each { |e| say_status :error, e, :red }
+          raise Thor::Error, "Required files missing. Ensure #{entity_model} and #{user_model} resources exist."
+        end
+      end
+
+      def create_package
+        generate "pu:pkg:package", "invites"
+      end
+
+      def create_user_invites_migration
+        migration_template "db/migrate/create_user_invites.rb",
+          "db/migrate/create_user_invites.rb"
+      end
+
+      def create_model
+        template "packages/invites/app/models/invites/user_invite.rb",
+          "packages/invites/app/models/invites/user_invite.rb"
+      end
+
+      def create_mailer
+        template "packages/invites/app/mailers/invites/user_invite_mailer.rb",
+          "packages/invites/app/mailers/invites/user_invite_mailer.rb"
+
+        template "packages/invites/app/views/invites/user_invite_mailer/invitation.html.erb",
+          "packages/invites/app/views/invites/user_invite_mailer/invitation.html.erb"
+
+        template "packages/invites/app/views/invites/user_invite_mailer/invitation.text.erb",
+          "packages/invites/app/views/invites/user_invite_mailer/invitation.text.erb"
+      end
+
+      def create_controllers
+        template "packages/invites/app/controllers/invites/user_invitations_controller.rb",
+          "packages/invites/app/controllers/invites/user_invitations_controller.rb"
+
+        template "packages/invites/app/controllers/invites/welcome_controller.rb",
+          "packages/invites/app/controllers/invites/welcome_controller.rb"
+      end
+
+      def create_views
+        %w[landing show signup error].each do |view|
+          template "packages/invites/app/views/invites/user_invitations/#{view}.html.erb",
+            "packages/invites/app/views/invites/user_invitations/#{view}.html.erb"
+        end
+
+        template "packages/invites/app/views/invites/welcome/pending_invitation.html.erb",
+          "packages/invites/app/views/invites/welcome/pending_invitation.html.erb"
+
+        template "packages/invites/app/views/layouts/invites/invitation.html.erb",
+          "packages/invites/app/views/layouts/invites/invitation.html.erb"
+      end
+
+      def create_interactions
+        template "packages/invites/app/interactions/invites/resend_invite_interaction.rb",
+          "packages/invites/app/interactions/invites/resend_invite_interaction.rb"
+
+        template "packages/invites/app/interactions/invites/cancel_invite_interaction.rb",
+          "packages/invites/app/interactions/invites/cancel_invite_interaction.rb"
+      end
+
+      def create_definition
+        template "packages/invites/app/definitions/invites/user_invite_definition.rb",
+          "packages/invites/app/definitions/invites/user_invite_definition.rb"
+      end
+
+      def create_policy
+        template "packages/invites/app/policies/invites/user_invite_policy.rb",
+          "packages/invites/app/policies/invites/user_invite_policy.rb"
+      end
+
+      def add_entity_association
+        inject_into_file entity_model_path,
+          "has_many :user_invites, class_name: \"Invites::UserInvite\", dependent: :destroy\n  ",
+          before: "# add has_many associations above."
+      end
+
+      def create_entity_interaction
+        template "app/interactions/invite_user_interaction.rb",
+          "app/interactions/#{entity_table}/invite_user_interaction.rb"
+      end
+
+      def add_entity_action
+        inject_into_file entity_definition_path,
+          "  action :invite_user, interaction: #{entity_model}::InviteUserInteraction, category: :secondary\n",
+          after: /class #{entity_model}Definition < .+\n/
+      end
+
+      def add_entity_policy
+        inject_into_file entity_policy_path,
+          "def invite_user?\n    user.is_a?(Admin) || current_membership&.admin?\n  end\n\n  ",
+          before: "# Core attributes"
+      end
+
+      def create_user_interaction
+        template "app/interactions/user_invite_user_interaction.rb",
+          "app/interactions/#{user_table}/invite_user_interaction.rb"
+      end
+
+      def add_user_action
+        inject_into_file user_definition_path,
+          "  action :invite_user, interaction: #{user_model}::InviteUserInteraction, category: :primary\n",
+          after: /class #{user_model}Definition < .+\n/
+      end
+
+      def add_user_policy
+        inject_into_file user_policy_path,
+          "def invite_user?\n    user.is_a?(Admin) || current_membership&.admin?\n  end\n\n  ",
+          before: "# Core attributes"
+      end
+
+      def add_resource_policy_helper
+        resource_policy_path = "app/policies/resource_policy.rb"
+
+        return unless File.exist?(Rails.root.join(resource_policy_path))
+
+        file_content = File.read(Rails.root.join(resource_policy_path))
+
+        helper_code = <<-RUBY
+  def current_membership
+    return unless entity_scope && user
+
+    cache(entity_scope, user, :current_membership) { #{membership_model}.find_by(#{entity_table}: entity_scope, user: user) }
+  end
+        RUBY
+
+        if file_content.include?("private\n")
+          inject_into_file resource_policy_path,
+            "\n#{helper_code}",
+            after: "private\n"
+        else
+          inject_into_file resource_policy_path,
+            "\n  private\n\n#{helper_code}",
+            before: /^end\s*\z/
+        end
+      end
+
+      def add_routes
+        route_code = <<-RUBY
+
+  # User invitation routes (public, unauthenticated)
+  scope module: :invites do
+    get "welcome", to: "welcome#index", as: :invites_welcome
+    get "invitations/:token", to: "user_invitations#show", as: :invitation
+    post "invitations/:token/accept", to: "user_invitations#accept", as: :accept_invitation
+    get "invitations/:token/signup", to: "user_invitations#signup", as: :invitation_signup
+    post "invitations/:token/signup", to: "user_invitations#signup"
+  end
+        RUBY
+
+        inject_into_file "config/routes.rb",
+          route_code,
+          before: /^end\s*\z/
+      end
+
+      def configure_rodauth
+        return unless rodauth?
+
+        rodauth_file = "app/rodauth/#{rodauth_config}_rodauth_plugin.rb"
+
+        unless File.exist?(Rails.root.join(rodauth_file))
+          say_status :skip, "Rodauth plugin not found: #{rodauth_file}", :yellow
+          return
+        end
+
+        file_content = File.read(Rails.root.join(rodauth_file))
+
+        # Check if already configured
+        if file_content.include?("after_welcome_redirect")
+          say_status :skip, "Rodauth already configured for invites", :yellow
+          return
+        end
+
+        # Check for existing after_login block (non-commented)
+        # Single-line: after_login { remember_login }
+        single_line_match = file_content.match(/^(\s*)after_login\s*\{\s*(.+?)\s*\}/)
+        # Multi-line: after_login do ... end
+        multi_line_match = file_content.match(/^(\s*)after_login\s+do\s*\n(.*?)\n(\s*)end/m)
+
+        if single_line_match
+          # Convert single-line block to multi-line with our code added
+          indent = single_line_match[1]
+          existing_code = single_line_match[2]
+          original_line = single_line_match[0]
+
+          new_block = <<~RUBY.chomp
+            #{indent}after_login do
+            #{indent}  #{existing_code}
+            #{indent}  session[:after_welcome_redirect] = session.delete(:login_redirect)
+            #{indent}end
+          RUBY
+
+          gsub_file rodauth_file, original_line, new_block
+          say_status :info, "Added session redirect to existing after_login block", :green
+        elsif multi_line_match
+          # Multi-line block - add our line before the end
+          indent = multi_line_match[1]
+          block_content = multi_line_match[2]
+          end_indent = multi_line_match[3]
+          original_block = multi_line_match[0]
+
+          new_block = <<~RUBY.chomp
+            #{indent}after_login do
+            #{block_content}
+            #{indent}  session[:after_welcome_redirect] = session.delete(:login_redirect)
+            #{end_indent}end
+          RUBY
+
+          gsub_file rodauth_file, original_block, new_block
+          say_status :info, "Added session redirect to existing after_login block", :green
+        else
+          # Add new after_login block
+          after_login_code = <<-RUBY
+
+    # ==> User Invites - Move captured path to session for WelcomeController
+    after_login do
+      session[:after_welcome_redirect] = session.delete(:login_redirect)
+    end
+          RUBY
+
+          inject_into_file rodauth_file,
+            after_login_code,
+            before: /^  end\s*\n/
+
+          say_status :info, "Added after_login block for invites", :green
+        end
+
+        # Add other config options if not present
+        unless file_content.include?("login_return_to_requested_location?")
+          inject_into_file rodauth_file,
+            "\n    # Enable path capture so Rodauth stores the originally requested URL\n    login_return_to_requested_location? true\n",
+            after: /login_redirect.*\n/
+        end
+
+        # Update login_redirect to /welcome
+        gsub_file rodauth_file,
+          /login_redirect\s+["']\/["']/,
+          'login_redirect "/welcome"'
+      end
+
+      def show_instructions
+        readme "INSTRUCTIONS" if behavior == :invoke
+      end
+
+      private
+
+      def entity_model
+        options[:entity_model].camelize
+      end
+
+      def entity_table
+        options[:entity_model].underscore
+      end
+
+      def entity_model_path
+        "app/models/#{entity_table}.rb"
+      end
+
+      def entity_definition_path
+        "app/definitions/#{entity_table}_definition.rb"
+      end
+
+      def entity_policy_path
+        "app/policies/#{entity_table}_policy.rb"
+      end
+
+      def user_model
+        options[:user_model].camelize
+      end
+
+      def user_table
+        options[:user_model].underscore
+      end
+
+      def user_definition_path
+        "app/definitions/#{user_table}_definition.rb"
+      end
+
+      def user_policy_path
+        "app/policies/#{user_table}_policy.rb"
+      end
+
+      def membership_model
+        options[:membership_model] || "#{entity_model}User"
+      end
+
+      def roles
+        Array(options[:roles]).flat_map { |r| r.split(",") }.map(&:strip)
+      end
+
+      def roles_enum
+        roles.each_with_index.map { |r, i| "#{r}: #{i}" }.join(", ")
+      end
+
+      def rodauth_config
+        options[:rodauth]
+      end
+
+      def rodauth?
+        rodauth_config.present?
+      end
+
+      def enforce_domain?
+        options[:enforce_domain]
+      end
+    end
+  end
+end

data/lib/generators/pu/invites/invitable/USAGE

@@ -0,0 +1,31 @@
+Description:
+    Connect an invitable model to send user invites.
+    The invitable is a model that triggers invites and gets notified on acceptance.
+
+Example:
+    rails g pu:invites:invitable Tenant
+    rails g pu:invites:invitable Tenant --role=tenant
+    rails g pu:invites:invitable TeamMember --role=member
+    rails g pu:invites:invitable Tenant --no-email-templates
+
+    This will create:
+        app/interactions/tenant/invite_user_interaction.rb
+        packages/invites/app/views/invites/user_invite_mailer/invitation_tenant.html.erb
+        packages/invites/app/views/invites/user_invite_mailer/invitation_tenant.text.erb
+
+    And inject:
+        - include Plutonium::Invites::Concerns::Invitable in the model
+        - action :invite_user in the definition
+        - invite_user? policy method
+
+    After generation, implement Tenant#on_invite_accepted(user):
+        def on_invite_accepted(user)
+          update!(user: user)
+        end
+
+Options:
+    --role=ROLE                 Role to assign to invited users (default: member)
+    --user-model=NAME           User model name (default: User)
+    --membership-model=NAME     Membership model (default: EntityUser)
+    --dest=PACKAGE              Destination package (default: main_app)
+    --[no-]email-templates      Generate custom email templates (default: true)

data/lib/generators/pu/invites/invitable_generator.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require_relative "../lib/plutonium_generators"
+
+module Pu
+  module Invites
+    class InvitableGenerator < ::Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Connect an invitable model to send user invites"
+
+      argument :model, type: :string,
+        desc: "The invitable model (e.g., Tenant, TeamMember)"
+
+      class_option :role, type: :string, default: "member",
+        desc: "Role to assign to invited users"
+
+      class_option :user_model, type: :string, default: "User",
+        desc: "The user model name"
+
+      class_option :membership_model, type: :string,
+        desc: "The membership model name (defaults to EntityUser)"
+
+      class_option :dest, type: :string, default: "main_app",
+        desc: "Destination package for the interaction"
+
+      class_option :email_templates, type: :boolean, default: true,
+        desc: "Generate custom email templates for this invitable"
+
+      def validate_requirements
+        errors = []
+
+        unless File.exist?(Rails.root.join(model_file_path))
+          errors << "Model file not found: #{model_file_path}"
+        end
+
+        unless File.exist?(Rails.root.join(definition_file_path))
+          errors << "Definition file not found: #{definition_file_path}"
+        end
+
+        unless File.exist?(Rails.root.join(policy_file_path))
+          errors << "Policy file not found: #{policy_file_path}"
+        end
+
+        if errors.any?
+          errors.each { |e| say_status :error, e, :red }
+          raise Thor::Error, "Required files missing. Ensure #{model_class} resource exists."
+        end
+      end
+
+      def create_interaction
+        template "invitable/invite_user_interaction.rb",
+          interaction_path
+      end
+
+      def add_invitable_concern
+        inject_into_file model_file_path,
+          "include Plutonium::Invites::Concerns::Invitable\n  ",
+          before: "# add concerns above."
+      end
+
+      def add_definition_action
+        inject_into_file definition_file_path,
+          "  action :invite_user, interaction: #{model_class}::InviteUserInteraction, category: :secondary\n",
+          after: /class #{model_class}Definition < .+\n/
+      end
+
+      def add_policy_method
+        inject_into_file policy_file_path,
+          "def invite_user?\n    record.can_invite_user?\n  end\n\n  ",
+          before: "# Core attributes"
+      end
+
+      def create_email_templates
+        return unless options[:email_templates]
+
+        template "invitable/invitation.html.erb",
+          "packages/invites/app/views/invites/user_invite_mailer/invitation_#{model_table}.html.erb"
+
+        template "invitable/invitation.text.erb",
+          "packages/invites/app/views/invites/user_invite_mailer/invitation_#{model_table}.text.erb"
+      end
+
+      def show_instructions
+        say "\n"
+        say "Connected #{model_class} as invitable!", :green
+        say "\n"
+        say "Implement #{model_class}#on_invite_accepted(user) to handle post-acceptance logic."
+        say "\n"
+      end
+
+      private
+
+      def model_class
+        model.camelize
+      end
+
+      def model_table
+        model.underscore
+      end
+
+      def user_model
+        options[:user_model].camelize
+      end
+
+      def user_table
+        options[:user_model].underscore
+      end
+
+      def model_file_path
+        "app/models/#{model_table}.rb"
+      end
+
+      def definition_file_path
+        "app/definitions/#{model_table}_definition.rb"
+      end
+
+      def policy_file_path
+        "app/policies/#{model_table}_policy.rb"
+      end
+
+      def role
+        options[:role]
+      end
+
+      def membership_model
+        options[:membership_model] || "EntityUser"
+      end
+
+      def interaction_path
+        dest = options[:dest]&.underscore
+        if dest == "main_app"
+          "app/interactions/#{model_table}/invite_user_interaction.rb"
+        else
+          "packages/#{dest}/app/interactions/#{dest}/#{model_table}/invite_user_interaction.rb"
+        end
+      end
+    end
+  end
+end

data/lib/generators/pu/invites/templates/INSTRUCTIONS

@@ -0,0 +1,22 @@
+
+===============================================================================
+
+User invites package installed successfully!
+
+Next steps:
+
+1. Run migrations:
+   rails db:migrate
+
+2. Register Invites::UserInvite in your portal routes:
+   # packages/<portal>/config/routes.rb
+   register_resource ::Invites::UserInvite
+
+3. (Optional) Connect invitable models that trigger invites:
+   rails g pu:invites:invitable Tenant
+   rails g pu:invites:invitable TeamMember --role=member
+
+   Then implement on_invite_accepted(user) in your invitable model.
+
+===============================================================================
+

data/lib/generators/pu/invites/templates/app/interactions/invite_user_interaction.rb.tt

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class <%= entity_model %>::InviteUserInteraction < Plutonium::Resource::Interaction
+  include Plutonium::Invites::Concerns::InviteUser
+
+  attribute :role
+  input :role, as: :select, choices: Invites::UserInvite.roles.keys
+<% if membership_model != "EntityUser" || user_model != "User" -%>
+
+  private
+<% end -%>
+<% if membership_model != "EntityUser" -%>
+
+  def membership_class
+    <%= membership_model %>
+  end
+<% end -%>
+<% if user_model != "User" -%>
+
+  def user_class
+    <%= user_model %>
+  end
+<% end -%>
+end

data/lib/generators/pu/invites/templates/app/interactions/user_invite_user_interaction.rb.tt

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class <%= user_model %>::InviteUserInteraction < Plutonium::Resource::Interaction
+  include Plutonium::Invites::Concerns::InviteUser
+
+  attribute :role
+  input :role, as: :select, choices: Invites::UserInvite.roles.keys
+
+  private
+
+  def entity
+    current_entity
+  end
+<% if membership_model != "EntityUser" -%>
+
+  def membership_class
+    <%= membership_model %>
+  end
+<% end -%>
+<% if user_model != "User" -%>
+
+  def user_class
+    <%= user_model %>
+  end
+<% end -%>
+end

data/lib/generators/pu/invites/templates/db/migrate/create_user_invites.rb.tt

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class CreateUserInvites < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :user_invites do |t|
+      # Entity association
+      t.belongs_to :<%= entity_table %>, null: false, foreign_key: true
+
+      # Invitation details
+      t.string :email, null: false
+      t.text :token, null: false
+      t.integer :role, null: false, default: 0
+      t.integer :state, null: false, default: 0
+
+      # Timestamps
+      t.datetime :expires_at
+      t.datetime :accepted_at
+
+      # Who sent the invite (polymorphic for flexibility)
+      t.belongs_to :invited_by, null: false, polymorphic: true
+
+      # User who accepted (filled after acceptance)
+      t.belongs_to :<%= user_table %>, null: true, foreign_key: true
+
+      # Invitable: model that triggered this invite (optional, polymorphic)
+      t.belongs_to :invitable, null: true, polymorphic: true
+
+      # Additional data
+      t.jsonb :metadata, default: {}
+
+      t.timestamps
+
+      # Unique token index
+      t.index :token, unique: true
+
+      # Only one pending invite per email per entity
+      t.index [:<%= entity_table %>_id, :email], unique: true, where: "state = 0",
+        name: "index_user_invites_on_entity_email_pending"
+
+      # Only one pending invite per invitable (when invitable is present)
+      t.index [:invitable_type, :invitable_id],
+        unique: true,
+        where: "state = 0 AND invitable_id IS NOT NULL",
+        name: "index_user_invites_on_invitable_pending"
+    end
+  end
+end