plutonium 0.42.0 → 0.43.1

data/lib/generators/pu/core/typespec/typespec_generator.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require_relative "../../lib/plutonium_generators"
+
+module Pu
+  module Core
+    class TypespecGenerator < Rails::Generators::Base
+      include PlutoniumGenerators::Generator
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate TypeSpec API specifications from Plutonium resources"
+
+      class_option :output, type: :string, default: "typespec", desc: "Output directory for TypeSpec files"
+      class_option :portal, type: :string, desc: "Generate specs for a specific portal only"
+
+      def start
+        load_application
+        check_pending_migrations!
+        detect_portals
+        generate_typespec_files
+      end
+
+      private
+
+      attr_reader :portals
+
+      def load_application
+        say_status :loading, "Rails application", :blue
+        Rails.application.eager_load!
+        Rails.application.reload_routes!
+      end
+
+      def check_pending_migrations!
+        context = ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths)
+        pending = context.migrations.select { |m| !context.get_all_versions.include?(m.version) }
+
+        return if pending.empty?
+
+        say_status :error, "Pending migrations detected!", :red
+        pending.each do |migration|
+          say_status :pending, "#{migration.version} - #{migration.name}", :yellow
+        end
+        say ""
+        say "Run `bin/rails db:migrate` before generating TypeSpec specifications.", :red
+        raise Thor::Error, "Cannot generate TypeSpec with pending migrations"
+      end
+
+      def detect_portals
+        say_status :detecting, "portals", :blue
+        @portals = []
+
+        Rails::Engine.subclasses.each do |engine|
+          next unless engine.included_modules.any? { |m| m.name&.include?("Plutonium::Portal") }
+
+          portal_name = engine.name.sub(/::Engine$/, "")
+          route_path = find_engine_route_path(engine)
+
+          next if options[:portal] && portal_name.underscore != options[:portal].underscore
+
+          @portals << build_portal_data(engine, portal_name, route_path)
+        end
+
+        if @portals.empty?
+          say_status :warning, "No portals found#{" matching '#{options[:portal]}'" if options[:portal]}", :yellow
+        else
+          @portals.each do |portal|
+            say_status :found, "#{portal[:name]} (#{portal[:resources].size} resources)", :green
+          end
+        end
+      end
+
+      def find_engine_route_path(engine)
+        Rails.application.routes.routes.find do |route|
+          route.app.app == engine
+        end&.path&.spec&.to_s&.gsub(/\(\.:format\)$/, "")
+      end
+
+      def build_portal_data(engine, portal_name, route_path)
+        resources = []
+
+        engine.resource_register.resources.each do |resource|
+          route_config = engine.routes.resource_route_config_lookup[resource.model_name.plural]
+          next unless route_config
+
+          resource_data = build_resource_data(resource, route_config, portal_name, route_path)
+          resources << resource_data if resource_data
+        end
+
+        {
+          name: portal_name,
+          engine: engine,
+          route_path: route_path || "/#{portal_name.underscore}",
+          file_name: portal_name.underscore.tr("/", "_"),
+          resources: resources
+        }
+      end
+
+      def build_resource_data(resource, route_config, portal_name, portal_route_path)
+        return nil unless resource.table_exists?
+
+        # Try portal-specific definition first, then fall back to base definition
+        definition_class = safe_constantize("#{portal_name}::#{resource.name.demodulize}Definition") ||
+          safe_constantize("#{resource.name}Definition")
+
+        resource_path = route_config[:route_options][:path]
+        full_route = [portal_route_path, resource_path].compact.join("/").gsub(%r{//+}, "/")
+
+        {
+          name: resource.name,
+          typespec_name: resource.name.demodulize,
+          file_name: resource.name.underscore.tr("/", "_"),
+          table_name: resource.table_name,
+          route_path: full_route,
+          primary_key: resource.primary_key,
+          primary_key_type: primary_key_type(resource),
+          columns: build_columns_data(resource),
+          associations: build_associations_data(resource),
+          enums: build_enums_data(resource),
+          definition: definition_class ? build_definition_data(definition_class, resource) : nil
+        }
+      rescue NameError => e
+        say_status :skip, "#{resource.name}: #{e.message}", :yellow
+        nil
+      end
+
+      def primary_key_type(resource)
+        column_to_typespec_type(resource.columns.find { |c| c.name == resource.primary_key })
+      end
+
+      def column_to_typespec_type(column)
+        return "int64" unless column
+        TYPE_MAPPING[column.type] || "int64"
+      end
+
+      def build_columns_data(resource)
+        resource.columns.map do |column|
+          {
+            name: column.name,
+            type: column.type.to_s,
+            null: column.null,
+            default: column.default,
+            typespec_type: TYPE_MAPPING[column.type] || "string"
+          }
+        end
+      end
+
+      def build_associations_data(resource)
+        resource.reflect_on_all_associations.map do |assoc|
+          fk_type = resolve_foreign_key_type(assoc, resource)
+
+          {
+            name: assoc.name.to_s,
+            macro: assoc.macro.to_s,
+            class_name: safe_association_attr(assoc, :klass)&.name,
+            foreign_key: safe_association_attr(assoc, :foreign_key),
+            foreign_key_type: fk_type,
+            polymorphic: !!assoc.polymorphic?
+          }
+        end
+      end
+
+      def resolve_foreign_key_type(assoc, resource)
+        return "int64" if assoc.polymorphic?
+
+        # For belongs_to, look up the associated model's primary key type
+        if assoc.macro == :belongs_to
+          target_class = safe_association_attr(assoc, :klass)
+          if target_class&.table_exists?
+            pk_column = target_class.columns.find { |c| c.name == target_class.primary_key }
+            return column_to_typespec_type(pk_column)
+          end
+        end
+
+        # For has_many/has_one, use this resource's primary key type
+        primary_key_type(resource)
+      end
+
+      def safe_association_attr(assoc, attr)
+        assoc.public_send(attr)
+      rescue NameError
+        nil
+      end
+
+      def build_enums_data(resource)
+        return {} unless resource.respond_to?(:defined_enums)
+        resource.defined_enums.transform_values(&:keys)
+      end
+
+      def build_definition_data(definition_class, resource)
+        inputs = extract_inputs(definition_class, resource)
+
+        {
+          class_name: definition_class.name,
+          inputs: inputs
+        }
+      end
+
+      def extract_inputs(definition_class, resource)
+        return [] unless definition_class.respond_to?(:defined_inputs)
+
+        defined_inputs = definition_class.defined_inputs
+        return [] if defined_inputs.empty?
+
+        defined_inputs.map do |name, config|
+          input_config = config[:options] || {}
+          column = resource.columns_hash[name.to_s]
+          assoc = resource.reflect_on_association(name)
+
+          {
+            name: name.to_s,
+            as: input_config[:as]&.to_s,
+            required: !input_config[:optional],
+            type: determine_input_type(name, input_config, column, assoc, resource),
+            typespec_type: determine_typespec_input_type(name, input_config, column, assoc, resource),
+            is_association: assoc.present?,
+            is_polymorphic: assoc&.polymorphic?,
+            association_macro: assoc&.macro&.to_s,
+            nested: input_config[:nested].present?
+          }
+        end
+      end
+
+      def determine_input_type(name, config, column, assoc, resource)
+        return config[:as].to_s if config[:as]
+        return "association" if assoc
+        return "enum" if resource.defined_enums.key?(name.to_s)
+        return column.type.to_s if column
+        "string"
+      end
+
+      def determine_typespec_input_type(name, config, column, assoc, resource)
+        # Associations use SGIDs
+        if assoc
+          return "SignedGlobalId[]" if %i[has_many has_and_belongs_to_many].include?(assoc.macro)
+          return "SignedGlobalId"
+        end
+
+        # Enums use the enum type
+        return "#{resource.name.demodulize}#{name.to_s.camelize}" if resource.defined_enums.key?(name.to_s)
+
+        # Use column type
+        return TYPE_MAPPING[column.type] || "string" if column
+
+        # Infer from as: option
+        AS_TYPE_MAPPING[config[:as]&.to_sym] || "string"
+      end
+
+      def generate_typespec_files
+        say_status :generating, "TypeSpec files", :blue
+
+        empty_directory output_dir
+        @single_portal = @portals.size == 1
+        template "common.tsp.tt", "#{output_dir}/common.tsp"
+
+        if @single_portal
+          # Single portal - generate flat structure
+          @current_portal = @portals.first
+          generate_portal_files(@current_portal, output_dir)
+        else
+          # Multiple portals - generate per-portal directories
+          @portals.each do |portal|
+            portal_dir = "#{output_dir}/#{portal[:file_name]}"
+            empty_directory portal_dir
+            generate_portal_files(portal, portal_dir)
+          end
+
+          # Generate root main.tsp that imports all portals
+          template "main_multi.tsp.tt", "#{output_dir}/main.tsp"
+        end
+
+        say_status :complete, "TypeSpec files generated in #{output_dir}/", :green
+      end
+
+      def generate_portal_files(portal, dir)
+        @current_portal = portal
+        template "main.tsp.tt", "#{dir}/main.tsp"
+
+        empty_directory "#{dir}/models"
+
+        portal[:resources].each do |resource|
+          @current_resource = resource
+          template "model.tsp.tt", "#{dir}/models/#{resource[:file_name]}.tsp"
+        end
+      end
+
+      def output_dir
+        options[:output]
+      end
+
+      def safe_constantize(name)
+        name.constantize
+      rescue NameError
+        nil
+      end
+
+      TYPE_MAPPING = {
+        string: "string",
+        text: "string",
+        integer: "int32",
+        bigint: "int64",
+        float: "float64",
+        decimal: "decimal",
+        boolean: "boolean",
+        date: "plainDate",
+        datetime: "utcDateTime",
+        time: "plainTime",
+        binary: "bytes",
+        json: "Record<string, unknown>",
+        jsonb: "Record<string, unknown>",
+        uuid: "string",
+        hstore: "Record<string, string>"
+      }.freeze
+
+      AS_TYPE_MAPPING = {
+        text: "string",
+        textarea: "string",
+        markdown: "string",
+        rich_text: "string",
+        number: "int32",
+        integer: "int32",
+        decimal: "decimal",
+        boolean: "boolean",
+        checkbox: "boolean",
+        date: "plainDate",
+        datetime: "utcDateTime",
+        time: "plainTime",
+        file: "bytes",
+        attachment: "bytes",
+        email: "string",
+        url: "url",
+        phone: "string",
+        password: "string",
+        color: "string",
+        json: "Record<string, unknown>",
+        jsonb: "Record<string, unknown>",
+        hstore: "Record<string, string>",
+        key_value: "Record<string, string>"
+      }.freeze
+    end
+  end
+end

data/lib/generators/pu/invites/USAGE

@@ -18,7 +18,6 @@ Options:
     --entity-model=NAME       Entity model name for scoping (default: Entity)
     --user-model=NAME         User model name (default: User)
     --membership-model=NAME   Membership model name (default: <Entity>User)
-    --roles=ROLES             Comma-separated roles (default: member,admin)
     --rodauth=NAME            Rodauth configuration for signup (default: user)
     --enforce-domain          Require user email domain to match entity domain
 

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

@@ -23,15 +23,15 @@ module Pu
       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"
 
+      class_option :dest, type: :string, default: "main_app",
+        desc: "Package where entity model is located (default: main_app)"
+
       def validate_requirements
         errors = []
 
@@ -55,9 +55,13 @@ module Pu
           errors << "User policy not found: #{user_policy_path}"
         end
 
+        unless File.exist?(membership_model_file)
+          errors << "Membership model not found: #{membership_model_file.relative_path_from(Rails.root)}"
+        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."
+          raise Thor::Error, "Required files missing:\n  - #{errors.join("\n  - ")}"
         end
       end
 
@@ -132,8 +136,13 @@ module Pu
       end
 
       def create_entity_interaction
-        template "app/interactions/invite_user_interaction.rb",
+        dest_path = if entity_in_package?
+          "packages/#{entity_package}/app/interactions/#{entity_table}/invite_user_interaction.rb"
+        else
           "app/interactions/#{entity_table}/invite_user_interaction.rb"
+        end
+
+        template "app/interactions/invite_user_interaction.rb", dest_path
       end
 
       def add_entity_action
@@ -144,7 +153,7 @@ module Pu
 
       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  ",
+          "def invite_user?\n    false # TODO: e.g., current_membership&.admin? or user.is_a?(Admin)\n  end\n\n  ",
           before: "# Core attributes"
       end
 
@@ -161,7 +170,7 @@ module Pu
 
       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  ",
+          "def invite_user?\n    false # TODO: e.g., current_membership&.admin? or user.is_a?(Admin)\n  end\n\n  ",
           before: "# Core attributes"
       end
 
@@ -176,7 +185,7 @@ module Pu
   def current_membership
     return unless entity_scope && user
 
-    cache(entity_scope, user, :current_membership) { #{membership_model}.find_by(#{entity_table}: entity_scope, user: user) }
+    @current_membership ||= #{membership_model}.find_by(#{entity_association_name}: entity_scope, user: user)
   end
         RUBY
 
@@ -308,16 +317,43 @@ module Pu
         options[:entity_model].underscore
       end
 
+      # Returns the association name for entity on the membership model.
+      # Strips shared namespace between membership and entity models.
+      # e.g., Competition::TeamUser -> Competition::Team uses :team (not :competition_team)
+      def entity_association_name
+        PlutoniumGenerators::Generator.derive_association_name(membership_model, entity_model)
+      end
+
+      def entity_in_package?
+        options[:dest] != "main_app"
+      end
+
+      def entity_package
+        options[:dest]
+      end
+
       def entity_model_path
-        "app/models/#{entity_table}.rb"
+        if entity_in_package?
+          "packages/#{entity_package}/app/models/#{entity_table}.rb"
+        else
+          "app/models/#{entity_table}.rb"
+        end
       end
 
       def entity_definition_path
-        "app/definitions/#{entity_table}_definition.rb"
+        if entity_in_package?
+          "packages/#{entity_package}/app/definitions/#{entity_table}_definition.rb"
+        else
+          "app/definitions/#{entity_table}_definition.rb"
+        end
       end
 
       def entity_policy_path
-        "app/policies/#{entity_table}_policy.rb"
+        if entity_in_package?
+          "packages/#{entity_package}/app/policies/#{entity_table}_policy.rb"
+        else
+          "app/policies/#{entity_table}_policy.rb"
+        end
       end
 
       def user_model
@@ -340,12 +376,23 @@ module Pu
         options[:membership_model] || "#{entity_model}User"
       end
 
-      def roles
-        Array(options[:roles]).flat_map { |r| r.split(",") }.map(&:strip)
+      def membership_model_file
+        model_path = "#{membership_model.underscore}.rb"
+        if entity_in_package?
+          Rails.root.join("packages", options[:dest], "app/models", model_path)
+        else
+          Rails.root.join("app/models", model_path)
+        end
       end
 
-      def roles_enum
-        roles.each_with_index.map { |r, i| "#{r}: #{i}" }.join(", ")
+      # Read roles from the membership model's enum definition
+      def roles
+        content = File.read(membership_model_file)
+        if (match = content.match(/enum\s+:role,\s*(.+?)(?:\n|$)/))
+          match[1].scan(/(\w+):/).flatten
+        else
+          raise Thor::Error, "Could not find 'enum :role' in #{membership_model_file.relative_path_from(Rails.root)}"
+        end
       end
 
       def rodauth_config

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

@@ -4,7 +4,7 @@ class CreateUserInvites < ActiveRecord::Migration[<%= ActiveRecord::Migration.cu
   def change
     create_table :user_invites do |t|
       # Entity association
-      t.belongs_to :<%= entity_table %>, null: false, foreign_key: true
+      t.belongs_to :<%= entity_association_name %>, null: false, foreign_key: true
 
       # Invitation details
       t.string :email, null: false
@@ -34,7 +34,7 @@ class CreateUserInvites < ActiveRecord::Migration[<%= ActiveRecord::Migration.cu
       t.index :token, unique: true
 
       # Only one pending invite per email per entity
-      t.index [:<%= entity_table %>_id, :email], unique: true, where: "state = 0",
+      t.index [:<%= entity_association_name %>_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)

data/lib/generators/pu/invites/templates/packages/invites/app/controllers/invites/user_invitations_controller.rb.tt

@@ -4,7 +4,9 @@ module Invites
   class UserInvitationsController < ApplicationController
     include Plutonium::Invites::Controller
 
+    prepend_view_path Invites::Engine.root.join("app/views")
     layout "invites/invitation"
+    helper_method :login_path
 
     private
 

data/lib/generators/pu/invites/templates/packages/invites/app/controllers/invites/welcome_controller.rb.tt

@@ -4,6 +4,7 @@ module Invites
   class WelcomeController < ApplicationController
     include Plutonium::Invites::PendingInviteCheck
 
+    prepend_view_path Invites::Engine.root.join("app/views")
     layout "invites/invitation"
 
 <% if rodauth? -%>

data/lib/generators/pu/invites/templates/packages/invites/app/models/invites/user_invite.rb.tt

@@ -4,11 +4,11 @@ module Invites
   class UserInvite < Invites::ResourceRecord
     include Plutonium::Invites::Concerns::InviteToken
 
-    enum :role, <%= roles_enum %>
+    enum :role, <%= membership_model %>.roles
 
     encrypts :token, deterministic: true
 
-    belongs_to :<%= entity_table %>
+    belongs_to :<%= entity_association_name %>, class_name: "<%= entity_model %>"
     belongs_to :invited_by, polymorphic: true
     belongs_to :<%= user_table %>, optional: true
     belongs_to :invitable, polymorphic: true, optional: true
@@ -30,12 +30,12 @@ module Invites
     end
 
     def create_membership_for(user)
-      <%= membership_model %>.create!(<%= entity_table %>: <%= entity_table %>, user: user, role: role)
+      <%= membership_model %>.create!(<%= entity_association_name %>: <%= entity_association_name %>, user: user, role: role)
     end
-<% if entity_table != "entity" -%>
+<% if entity_association_name != "entity" -%>
 
     # Alias for InviteToken concern compatibility
-    alias_method :entity, :<%= entity_table %>
+    alias_method :entity, :<%= entity_association_name %>
 <% end -%>
   end
 end

data/lib/generators/pu/invites/templates/packages/invites/app/views/invites/user_invitations/signup.html.erb.tt

@@ -15,13 +15,13 @@
     <label for="email" class="pu-label">Email</label>
     <%% if @invite.enforce_email? %>
       <input type="email" name="email" value="<%%= @invite.email %>" disabled
-             class="pu-input cursor-not-allowed opacity-60">
+             autocomplete="email" class="pu-input cursor-not-allowed opacity-60">
       <input type="hidden" name="email" value="<%%= @invite.email %>">
       <p class="pu-hint">This email is required for your invitation</p>
     <%% else %>
       <%%= form.email_field :email, value: @invite.email, required: true,
           placeholder: "you@example.com",
-          class: "pu-input" %>
+          autocomplete: "email", class: "pu-input" %>
       <%% if (domain = @invite.enforce_domain) %>
         <p class="pu-hint">Must be from <%%= domain %> domain</p>
       <%% else %>
@@ -32,12 +32,12 @@
 
   <div>
     <label for="password" class="pu-label">Password</label>
-    <%%= form.password_field :password, required: true, class: "pu-input" %>
+    <%%= form.password_field :password, required: true, autocomplete: "new-password", class: "pu-input" %>
   </div>
 
   <div>
     <label for="password_confirmation" class="pu-label">Confirm Password</label>
-    <%%= form.password_field :password_confirmation, required: true, class: "pu-input" %>
+    <%%= form.password_field :password_confirmation, required: true, autocomplete: "new-password", class: "pu-input" %>
   </div>
 
   <div class="space-y-3 pt-4">

data/lib/generators/pu/lib/plutonium_generators/concerns/actions.rb

@@ -447,7 +447,7 @@ module PlutoniumGenerators
 
       def gem_in_bundle?(name)
         in_root do
-          return true if File.exist?("Gemfile") && File.read("Gemfile").match?(/gem ['"]#{name}['"]/)
+          return true if File.exist?("Gemfile") && File.read("Gemfile").match?(/^\s*gem ['"]#{name}['"]/)
           return true if File.exist?("Gemfile.lock") && File.read("Gemfile.lock").include?("    #{name} ")
         end
         false

data/lib/generators/pu/lib/plutonium_generators/generator.rb

@@ -10,6 +10,35 @@ module PlutoniumGenerators
     include Concerns::Serializer
     include Concerns::Actions
 
+    # Finds the shared namespace prefix between two model names.
+    # Used to derive association names when models share a namespace.
+    # e.g., find_shared_namespace("Competition::TeamUser", "Competition::Team") => "competition"
+    def self.find_shared_namespace(model1, model2, separator: "/")
+      parts1 = model1.underscore.split(separator)
+      parts2 = model2.underscore.split(separator)
+
+      shared = []
+      [parts1.length, parts2.length].min.times do |i|
+        break unless parts1[i] == parts2[i]
+        shared << parts1[i]
+      end
+
+      shared.empty? ? nil : shared.join(separator)
+    end
+
+    # Derives the association name for a reference, stripping shared namespace.
+    # e.g., derive_association_name("Competition::TeamUser", "Competition::Team") => "team"
+    def self.derive_association_name(from_model, to_model)
+      to_parts = to_model.underscore.split("/")
+
+      if (shared = find_shared_namespace(from_model, to_model))
+        shared_parts = shared.split("/")
+        to_parts = to_parts.drop(shared_parts.length)
+      end
+
+      to_parts.join("_")
+    end
+
     def self.included(base)
       base.send :class_option, :interactive, type: :boolean, desc: "Show prompts. Default: true"
       base.send :class_option, :bundle, type: :boolean, desc: "Run bundle after setup. Default: true"