plutonium 0.42.0 → 0.43.0

data/lib/generators/pu/core/typespec/templates/model.tsp.tt

@@ -0,0 +1,226 @@
+<%-
+# Helper methods for template
+def optional_marker(column)
+  column[:null] ? '?' : ''
+end
+
+resource = @current_resource
+model_name = resource[:typespec_name]
+all_columns = resource[:columns]
+all_column_names = all_columns.map { |c| c[:name] }
+
+# Extract special columns if they exist
+primary_key_column = all_columns.find { |c| c[:name] == resource[:primary_key] }
+created_at_column = all_columns.find { |c| c[:name] == 'created_at' }
+updated_at_column = all_columns.find { |c| c[:name] == 'updated_at' }
+
+# Regular columns exclude primary key and timestamps
+columns = all_columns.reject { |c| [resource[:primary_key], 'created_at', 'updated_at'].include?(c[:name]) }
+associations = resource[:associations]
+enums = resource[:enums] || {}
+definition = resource[:definition]
+inputs = definition ? definition[:inputs] : []
+
+# Separate association columns (foreign keys) from regular columns
+belongs_to_assocs = associations.select { |a| a[:macro] == 'belongs_to' }
+has_many_assocs = associations.select { |a| a[:macro] == 'has_many' }
+has_one_assocs = associations.select { |a| a[:macro] == 'has_one' }
+
+# Foreign key columns to exclude from regular attributes
+fk_columns = belongs_to_assocs.map { |a| a[:foreign_key] }.compact
+regular_columns = columns.reject { |c| fk_columns.include?(c[:name]) }
+
+# Check if we have definition-based inputs
+has_definition_inputs = inputs.any?
+-%>
+/**
+ * <%= model_name %> resource
+ * Table: <%= resource[:table_name] %>
+ * Route: <%= resource[:route_path] %>
+ */
+
+<%- if @single_portal -%>
+import "../common.tsp";
+<%- else -%>
+import "../../common.tsp";
+<%- end -%>
+
+using TypeSpec.Http;
+
+<%- enums.each do |enum_name, values| -%>
+/** <%= enum_name.humanize %> options */
+enum <%= model_name %><%= enum_name.camelize %> {
+<%- values.each do |value| -%>
+  <%= value %>,
+<%- end -%>
+}
+
+<%- end -%>
+/**
+ * <%= model_name %> response model
+ */
+model <%= model_name %> extends ResourceBase {
+<%- if primary_key_column -%>
+  @doc("Unique identifier")
+  <%= resource[:primary_key] %>: <%= resource[:primary_key_type] %>;
+<%- end -%>
+<%- if created_at_column -%>
+  @doc("Creation timestamp")
+  created_at: utcDateTime;
+<%- end -%>
+<%- if updated_at_column -%>
+  @doc("Last update timestamp")
+  updated_at: utcDateTime;
+<%- end -%>
+<%- if (primary_key_column || created_at_column || updated_at_column) && regular_columns.any? -%>
+
+<%- end -%>
+<%- regular_columns.each do |column| -%>
+<%- if enums.key?(column[:name]) -%>
+  <%= column[:name] %><%= optional_marker(column) %>: <%= model_name %><%= column[:name].camelize %>;
+<%- else -%>
+  <%= column[:name] %><%= optional_marker(column) %>: <%= column[:typespec_type] %>;
+<%- end -%>
+<%- end -%>
+
+<%- belongs_to_assocs.each do |assoc| -%>
+<%- if assoc[:polymorphic] -%>
+  /** Polymorphic association type */
+  <%= assoc[:name] %>_type?: string;
+  /** Polymorphic association ID */
+  <%= assoc[:name] %>_id?: <%= assoc[:foreign_key_type] %>;
+  /** Polymorphic association SGID */
+  <%= assoc[:name] %>_sgid?: SignedGlobalId;
+<%- else -%>
+  /** <%= assoc[:name].humanize %> ID */
+  <%= assoc[:foreign_key] || "#{assoc[:name]}_id" %>?: <%= assoc[:foreign_key_type] %>;
+  /** <%= assoc[:name].humanize %> SGID */
+  <%= assoc[:name] %>_sgid?: SignedGlobalId;
+<%- end -%>
+<%- end -%>
+
+<%- has_many_assocs.each do |assoc| -%>
+  /** <%= assoc[:name].to_s.singularize.humanize %> IDs */
+  <%= assoc[:name].to_s.singularize %>_ids?: <%= assoc[:foreign_key_type] %>[];
+  /** <%= assoc[:name].to_s.singularize.humanize %> SGIDs */
+  <%= assoc[:name].to_s.singularize %>_sgids?: SignedGlobalId[];
+<%- end -%>
+<%- has_one_assocs.each do |assoc| -%>
+  /** <%= assoc[:name].humanize %> ID */
+  <%= assoc[:name] %>_id?: <%= assoc[:foreign_key_type] %>;
+  /** <%= assoc[:name].humanize %> SGID */
+  <%= assoc[:name] %>_sgid?: SignedGlobalId;
+<%- end -%>
+}
+
+/**
+ * <%= model_name %> input model for create/update operations
+<%- if has_definition_inputs -%>
+ * Based on definition: <%= definition[:class_name] %>
+<%- end -%>
+ */
+model <%= model_name %>Input {
+<%- if has_definition_inputs -%>
+<%# Use definition inputs -%>
+<%- inputs.each do |input| -%>
+<%- next if input[:nested] # Skip nested inputs for now -%>
+<%- if input[:is_association] -%>
+<%- if input[:is_polymorphic] -%>
+  /** Polymorphic <%= input[:name] %> (SGID) */
+  <%= input[:name] %>_sgid<%= input[:required] ? '' : '?' %>: SignedGlobalId;
+<%- elsif input[:association_macro] == 'has_many' || input[:association_macro] == 'has_and_belongs_to_many' -%>
+  /** <%= input[:name].singularize.humanize %> SGIDs */
+  <%= input[:name].singularize %>_sgids<%= input[:required] ? '' : '?' %>: SignedGlobalId[];
+<%- else -%>
+  /** <%= input[:name].humanize %> (SGID) */
+  <%= input[:name] %>_sgid<%= input[:required] ? '' : '?' %>: SignedGlobalId;
+<%- end -%>
+<%- else -%>
+  <%= input[:name] %><%= input[:required] ? '' : '?' %>: <%= input[:typespec_type] %>;
+<%- end -%>
+<%- end -%>
+<%- else -%>
+<%# Fallback to column-based inputs -%>
+<%- regular_columns.each do |column| -%>
+<%- next if column[:name].end_with?('_count') # skip counter caches -%>
+<%- if enums.key?(column[:name]) -%>
+  <%= column[:name] %><%= optional_marker(column) %>: <%= model_name %><%= column[:name].camelize %>;
+<%- else -%>
+  <%= column[:name] %><%= optional_marker(column) %>: <%= column[:typespec_type] %>;
+<%- end -%>
+<%- end -%>
+
+<%- belongs_to_assocs.each do |assoc| -%>
+<%- if assoc[:polymorphic] -%>
+  /** Polymorphic <%= assoc[:name] %> (SGID) */
+  <%= assoc[:name] %>_sgid?: SignedGlobalId;
+<%- else -%>
+  /** <%= assoc[:name].humanize %> (SGID) */
+  <%= assoc[:name] %>_sgid?: SignedGlobalId;
+<%- end -%>
+<%- end -%>
+
+<%- has_many_assocs.each do |assoc| -%>
+  /** <%= assoc[:name].to_s.singularize.humanize %> SGIDs */
+  <%= assoc[:name].to_s.singularize %>_sgids?: SignedGlobalId[];
+<%- end -%>
+<%- end -%>
+}
+
+/**
+ * <%= model_name %> list response
+ */
+model <%= model_name %>ListResponse {
+  <%= model_name.underscore.pluralize %>: <%= model_name %>[];
+}
+
+/**
+ * <%= model_name %> CRUD operations
+ */
+@route("<%= resource[:route_path] %>")
+@tag("<%= model_name.pluralize %>")
+interface <%= model_name %>Operations {
+  /**
+   * List all <%= model_name.underscore.humanize.pluralize.downcase %>
+   */
+  @get
+  list(...ListQueryParams): <%= model_name %>ListResponse;
+
+  /**
+   * Get a single <%= model_name.underscore.humanize.downcase %>
+   */
+  @route("{id}")
+  @get
+  show(@path id: <%= resource[:primary_key_type] %>): <%= model_name %>;
+
+  /**
+   * Create a new <%= model_name.underscore.humanize.downcase %>
+   */
+  @post
+  create(@body input: <%= model_name %>Input): {
+    @statusCode statusCode: 201;
+    @body body: <%= model_name %>;
+  } | {
+    @statusCode statusCode: 422;
+    @body body: ErrorResponse;
+  };
+
+  /**
+   * Update a <%= model_name.underscore.humanize.downcase %>
+   */
+  @route("{id}")
+  @patch
+  update(@path id: <%= resource[:primary_key_type] %>, @body input: <%= model_name %>Input): <%= model_name %> | {
+    @statusCode statusCode: 422;
+    @body body: ErrorResponse;
+  };
+
+  /**
+   * Delete a <%= model_name.underscore.humanize.downcase %>
+   */
+  @route("{id}")
+  @delete
+  destroy(@path id: <%= resource[:primary_key_type] %>): {
+    @statusCode statusCode: 204;
+  };
+}

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