Add proper types for arguments and outputs

Author: akodkod

lib/tapioca/dsl/compilers/operandi.rb

@@ -15,6 +15,10 @@ module Compilers
       # - Predicate: `def name?` - returns boolean
       # - Setter: `def name=` (private) - sets the value
       #
+      # Additionally, typed inner classes are generated:
+      # - `Arguments` - T::Struct representing all service arguments
+      # - `Outputs` - T::Struct representing all service outputs
+      #
       # @example Service definition
       #   class CreateUser < Operandi::Base
       #     arg :name, type: String
@@ -26,6 +30,22 @@ module Compilers
       #
       # @example Generated RBI
       #   class CreateUser
+      #     class Arguments < T::Struct
+      #       prop :name, ::String
+      #       prop :email, T.nilable(::String), default: nil
+      #       prop :role, T.any(::Symbol, ::String)
+      #     end
+      #
+      #     class Outputs < T::Struct
+      #       prop :user, ::User
+      #     end
+      #
+      #     sig { returns(Arguments) }
+      #     def arguments; end
+      #
+      #     sig { returns(Outputs) }
+      #     def outputs; end
+      #
       #     sig { returns(String) }
       #     def name; end
       #
@@ -81,6 +101,10 @@ def decorate
             # Generate class methods (.run, .run!, .with)
             generate_class_methods(klass)
 
+            # Generate typed inner classes for arguments and outputs
+            generate_arguments_type(klass)
+            generate_outputs_type(klass)
+
             # Generate argument methods
             constant.arguments.each_value do |field|
               generate_field_methods(klass, field)
@@ -102,6 +126,22 @@ def generate_class_methods(klass)
           generate_with_method(klass)
         end
 
+        sig { params(klass: RBI::Scope).void }
+        def generate_arguments_type(klass)
+          return if constant.arguments.empty?
+
+          generate_struct_class(klass, "Arguments", constant.arguments)
+          klass.create_method("arguments", return_type: "Arguments")
+        end
+
+        sig { params(klass: RBI::Scope).void }
+        def generate_outputs_type(klass)
+          return if constant.outputs.empty?
+
+          generate_struct_class(klass, "Outputs", constant.outputs)
+          klass.create_method("outputs", return_type: "Outputs")
+        end
+
         sig { params(klass: RBI::Scope).void }
         def generate_run_method(klass)
           klass.create_method(
@@ -248,6 +288,33 @@ def as_nilable_type(type)
 
           "T.nilable(#{type})"
         end
+
+        sig do
+          params(
+            klass: RBI::Scope,
+            class_name: String,
+            fields: T::Hash[Symbol, ::Operandi::Settings::Field],
+          ).void
+        end
+        def generate_struct_class(klass, class_name, fields)
+          return if fields.empty?
+
+          klass.create_class(class_name, superclass_name: "T::Struct") do |struct_klass|
+            fields.each_value do |field|
+              generate_struct_prop(struct_klass, field)
+            end
+          end
+        end
+
+        sig { params(struct_klass: RBI::Scope, field: ::Operandi::Settings::Field).void }
+        def generate_struct_prop(struct_klass, field)
+          name = field.name.to_s
+          ruby_type = resolve_type(field)
+          prop_type = field.optional ? as_nilable_type(ruby_type) : ruby_type
+          default_value = format_default_value(field) if field.optional || field.default_exists
+
+          struct_klass << RBI::TStructProp.new(name, prop_type, default: default_value)
+        end
       end
     end
   end

rbi/operandi.rbi

@@ -7,12 +7,6 @@
 module Operandi
   class Base
     # Attributes
-    sig { returns(Operandi::Collection::Base) }
-    def outputs; end
-
-    sig { returns(Operandi::Collection::Base) }
-    def arguments; end
-
     sig { returns(Operandi::Messages) }
     def errors; end
 

spec/tapioca/dsl/compilers/operandi_spec.rb

@@ -67,15 +67,28 @@ def create_kw_opt_param(name, type:, default:)
 # Mock RBI module
 module RBI
   class Scope
-    attr_reader :methods
+    attr_reader :methods, :classes, :nodes
 
     def initialize
       @methods = []
+      @classes = []
+      @nodes = []
     end
 
     def create_method(name, parameters: [], return_type: nil, visibility: nil, class_method: false)
       @methods << MockMethod.new(name, parameters, return_type, visibility, class_method)
     end
+
+    def create_class(name, superclass_name: nil)
+      child_scope = Scope.new
+      yield child_scope if block_given?
+      @classes << MockClass.new(name, superclass_name, child_scope)
+      child_scope
+    end
+
+    def <<(node)
+      @nodes << node
+    end
   end
 
   class Tree
@@ -91,6 +104,27 @@ def to_s
       "private"
     end
   end
+
+  class TStructProp
+    attr_reader :name, :type, :default
+
+    def initialize(name, type, default: nil)
+      @name = name
+      @type = type
+      @default = default
+    end
+  end
+end
+
+# Mock class for generated inner classes
+class MockClass
+  attr_reader :name, :superclass_name, :scope
+
+  def initialize(name, superclass_name, scope)
+    @name = name
+    @superclass_name = superclass_name
+    @scope = scope
+  end
 end
 
 # Mock classes for testing
@@ -310,11 +344,11 @@ def self.name
         expect(find_method(scope, "output")).not_to be_nil
       end
 
-      it "generates 9 methods total (3 per field + 3 class methods)" do
+      it "generates 11 methods total (3 per field + 3 class methods + 2 collection accessors)" do
         scope = compiler.decorate
 
-        # 3 class methods (run, run!, with) + 6 field methods (3 per field)
-        expect(scope.methods.size).to eq(9)
+        # 3 class methods (run, run!, with) + 6 field methods (3 per field) + 2 collection accessors (arguments, outputs)
+        expect(scope.methods.size).to eq(11)
       end
     end