zero_ruby 0.1.0.alpha1 → 0.1.0.alpha4

data/lib/zero_ruby/input_object.rb

@@ -1,120 +1,83 @@
 # frozen_string_literal: true
 
-require_relative "argument"
-require_relative "errors"
-require_relative "validator"
+require "dry-struct"
+require_relative "types"
+require_relative "type_names"
 
 module ZeroRuby
   # Base class for input objects (nested argument types).
-  # Similar to GraphQL-Ruby's InputObject pattern.
+  # Uses Dry::Struct for type coercion and validation.
+  #
+  # Includes ZeroRuby::TypeNames for convenient type access:
+  #   - ID, Boolean, ISO8601Date, ISO8601DateTime (direct constants)
+  #   - Types::String, Types::Integer, Types::Float (via Types module)
   #
   # @example
   #   class Types::PostInput < ZeroRuby::InputObject
-  #     argument :id, ID, required: true
-  #     argument :title, String, required: true
-  #     argument :body, String, required: false
+  #     argument :id, ID
+  #     argument :title, Types::String.constrained(min_size: 1, max_size: 200)
+  #     argument :body, Types::String.optional
+  #     argument :published, Boolean.default(false)
   #   end
   #
   #   class PostCreate < ZeroRuby::Mutation
-  #     argument :post_input, Types::PostInput, required: true
-  #     argument :notify, Boolean, required: false
+  #     argument :post_input, Types::PostInput
+  #     argument :notify, Boolean.default(false)
   #
-  #     def execute(post_input:, notify: nil)
-  #       Post.create!(**post_input)
+  #     def execute
+  #       # args[:post_input].title, args[:post_input].body, etc.
+  #       # Or use **args[:post_input] to splat into method calls
   #     end
   #   end
-  class InputObject
-    include TypeNames
+  class InputObject < Dry::Struct
+    include ZeroRuby::TypeNames
+
+    # Transform string keys to symbols (for JSON input)
+    transform_keys(&:to_sym)
+
+    # Use permissive schema that allows omitting optional attributes
+    # This matches the behavior where missing optional keys are omitted from result
+    schema schema.strict(false)
 
     class << self
-      # Declare an argument for this input object
-      def argument(name, type, required: true, validates: nil, default: Argument::NOT_PROVIDED, description: nil, **options)
-        arguments[name.to_sym] = Argument.new(
-          name: name,
-          type: type,
-          required: required,
-          validates: validates,
-          default: default,
-          description: description,
-          **options
-        )
-      end
+      # Alias attribute to argument for DSL compatibility
+      # @param name [Symbol] The argument name
+      # @param type [Dry::Types::Type] The type (from ZeroRuby::Types)
+      # @param description [String, nil] Optional description (stored for documentation, not passed to Dry::Struct)
+      def argument(name, type, description: nil, **_options)
+        # Store description for documentation/TypeScript generation
+        argument_descriptions[name.to_sym] = description if description
 
-      # Get all declared arguments (including inherited)
-      def arguments
-        @arguments ||= if superclass.respond_to?(:arguments)
-          superclass.arguments.dup
+        # Use attribute? for optional types (allows key to be omitted)
+        # Use attribute for required types (key must be present)
+        if optional_type?(type)
+          attribute?(name, type)
         else
-          {}
+          attribute(name, type)
         end
       end
 
-      # Coerce and validate raw input
-      # @param raw_args [Hash] Raw input
-      # @param ctx [Hash] The context hash
-      # @return [Hash] Validated and coerced hash (only includes keys present in input or with defaults)
-      # @raise [ZeroRuby::ValidationError] If validation fails
-      def coerce(value, ctx)
-        return nil if value.nil?
-        return nil unless value.is_a?(Hash)
-
-        validated = {}
-        errors = []
-
-        arguments.each do |name, arg|
-          key_present = value.key?(name) || value.key?(name.to_s)
-          val = if key_present
-            value[name].nil? ? value[name.to_s] : value[name]
-          end
-
-          # Check required
-          if arg.required? && !key_present && !arg.has_default?
-            errors << "#{name} is required"
-            next
-          end
-
-          # Apply default if key not present
-          if !key_present && arg.has_default?
-            validated[name] = arg.default
-            next
-          end
-
-          # Skip if key not present (don't add to validated hash)
-          next unless key_present
-
-          # Handle nil values - include in hash but skip coercion
-          if val.nil?
-            validated[name] = nil
-            next
-          end
-
-          # Type coercion (handles nested InputObjects)
-          begin
-            coerced = arg.coerce(val, ctx)
-          rescue CoercionError => e
-            errors << "#{name}: #{e.message}"
-            next
-          rescue ValidationError => e
-            # Nested InputObject validation errors - prefix with field name
-            e.errors.each do |err|
-              errors << "#{name}.#{err}"
-            end
-            next
-          end
+      # Get stored argument descriptions
+      def argument_descriptions
+        @argument_descriptions ||= {}
+      end
 
-          # Run validators
-          if arg.validators.any?
-            validation_errors = Validator.validate!(arg.validators, nil, ctx, coerced)
-            validation_errors.each do |err|
-              errors << "#{name} #{err}"
-            end
-          end
+      # Check if a type is optional (can accept nil or has a default)
+      def optional_type?(type)
+        return false unless type.respond_to?(:optional?)
+        type.optional? || (type.respond_to?(:default?) && type.default?)
+      end
 
-          validated[name] = coerced
+      # Returns argument metadata for TypeScript generation
+      # @return [Hash<Symbol, Hash>] Map of argument name to metadata
+      def arguments_metadata
+        schema.keys.each_with_object({}) do |key, hash|
+          hash[key.name] = {
+            type: key.type,
+            required: key.required?,
+            name: key.name
+          }
         end
-
-        raise ValidationError.new(errors) if errors.any?
-        validated
       end
     end
   end

data/lib/zero_ruby/lmid_stores/active_record_store.rb

@@ -55,7 +55,6 @@ module ZeroRuby
       private
 
       def default_model_class
-        require_relative "../zero_client"
         ZeroRuby::ZeroClient
       end
     end

data/lib/zero_ruby/mutation.rb

@@ -1,38 +1,88 @@
 # frozen_string_literal: true
 
-require_relative "argument"
+require_relative "types"
+require_relative "type_names"
 require_relative "errors"
-require_relative "validator"
 
 module ZeroRuby
-  # Mixin that provides the argument DSL for mutations.
-  # Inspired by graphql-ruby's HasArguments pattern.
-  module HasArguments
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+  # Base class for Zero mutations.
+  # Provides argument DSL with dry-types validation.
+  #
+  # Includes ZeroRuby::TypeNames for convenient type access:
+  #   - ID, Boolean, ISO8601Date, ISO8601DateTime (direct constants)
+  #   - Types::String, Types::Integer, Types::Float (via Types module)
+  #
+  # By default (auto_transact: true), the entire execute method runs inside
+  # a transaction with LMID tracking. For 3-phase control, set auto_transact false.
+  #
+  # @example Simple mutation (auto_transact: true, default)
+  #   class WorkCreate < ZeroRuby::Mutation
+  #     argument :id, ID
+  #     argument :title, Types::String.constrained(max_size: 200)
+  #
+  #     def execute(id:, title:)
+  #       authorize! Work, to: :create?
+  #       Work.create!(id: id, title: title)  # Runs inside auto-wrapped transaction
+  #     end
+  #   end
+  #
+  # @example 3-phase mutation (skip_auto_transaction)
+  #   class WorkUpdate < ZeroRuby::Mutation
+  #     skip_auto_transaction
+  #
+  #     argument :id, ID
+  #     argument :title, Types::String
+  #
+  #     def execute(id:, title:)
+  #       work = Work.find(id)
+  #       authorize! work, to: :update?  # Pre-transaction
+  #
+  #       transact do
+  #         work.update!(title: title)   # Transaction
+  #       end
+  #
+  #       notify_update(work)            # Post-commit
+  #     end
+  #   end
+  class Mutation
+    include ZeroRuby::TypeNames
+
+    # The context hash containing current_user, etc.
+    attr_reader :ctx
+
+    # The validated arguments hash
+    attr_reader :args
+
+    class << self
+      # Opt-out of auto-transaction wrapping.
+      # By default, execute is wrapped in a transaction with LMID tracking.
+      # Call this to use explicit 3-phase model where you must call transact { }.
+      #
+      # @return [void]
+      def skip_auto_transaction
+        @skip_auto_transaction = true
+      end
+
+      # Check if auto-transaction is skipped for this mutation
+      # @return [Boolean] true if skip_auto_transaction was called
+      def skip_auto_transaction?
+        @skip_auto_transaction == true
+      end
 
-    module ClassMethods
       # Declare an argument for this mutation
       # @param name [Symbol] The argument name
-      # @param type [Class] The type class (e.g., ZeroRuby::Types::String)
-      # @param required [Boolean] Whether the argument is required
-      # @param validates [Hash] Validation configuration
-      # @param default [Object] Default value if not provided
-      # @param description [String] Description of the argument
-      def argument(name, type, required: true, validates: nil, default: Argument::NOT_PROVIDED, description: nil, **options)
-        arguments[name.to_sym] = Argument.new(
-          name: name,
+      # @param type [Dry::Types::Type] The type (from ZeroRuby::Types or dry-types)
+      # @param description [String, nil] Optional description for documentation
+      def argument(name, type, description: nil)
+        arguments[name.to_sym] = {
           type: type,
-          required: required,
-          validates: validates,
-          default: default,
           description: description,
-          **options
-        )
+          name: name.to_sym
+        }
       end
 
       # Get all declared arguments for this mutation (including inherited)
+      # @return [Hash<Symbol, Hash>] Map of argument name to config
       def arguments
         @arguments ||= if superclass.respond_to?(:arguments)
           superclass.arguments.dup
@@ -41,100 +91,176 @@ module ZeroRuby
         end
       end
 
-      # Coerce and validate raw arguments
+      # Coerce and validate raw arguments.
+      # Collects "field is required" errors for all missing required fields,
+      # but lets Dry exceptions bubble up for type/constraint errors.
+      #
       # @param raw_args [Hash] Raw input arguments
-      # @param ctx [Hash] The context hash
-      # @return [Hash] Validated and coerced arguments
-      # @raise [ZeroRuby::ValidationError] If validation fails
-      def coerce_and_validate!(raw_args, ctx)
+      # @return [Hash] Validated and coerced arguments (may contain InputObject instances)
+      # @raise [ZeroRuby::ValidationError] If required fields are missing
+      # @raise [Dry::Types::CoercionError] If type coercion fails
+      # @raise [Dry::Types::ConstraintError] If constraint validation fails
+      # @raise [Dry::Struct::Error] If InputObject validation fails
+      def coerce_and_validate!(raw_args)
         validated = {}
         errors = []
 
-        arguments.each do |name, arg|
-          value = raw_args[name]
+        arguments.each do |name, config|
+          type = config[:type]
+          str_key = name.to_s
+          key_present = raw_args.key?(str_key)
+          value = raw_args[str_key]
 
-          # Check required
-          if arg.required? && value.nil? && !arg.has_default?
-            errors << "#{name} is required"
-            next
-          end
-
-          # Apply default if needed, or nil for optional args without defaults
-          if value.nil?
-            validated[name] = arg.has_default? ? arg.default : nil
+          # Handle InputObject types (subclasses of InputObject)
+          if input_object_type?(type)
+            if value.nil? && key_present
+              # Explicit nil
+              validated[name] = nil
+            elsif value.nil? && !key_present
+              # Missing key - check if required
+              if required_type?(type)
+                errors << "#{name} is required"
+              end
+              # Skip if optional and not provided
+            else
+              # Let Dry::Struct errors bubble up
+              validated[name] = type.new(value)
+            end
             next
           end
 
-          # Type coercion
-          begin
-            coerced = arg.coerce(value, ctx)
-          rescue CoercionError => e
-            errors << "#{name}: #{e.message}"
+          # Handle missing key
+          if !key_present
+            if has_default?(type)
+              validated[name] = get_default(type)
+            elsif required_type?(type)
+              errors << "#{name} is required"
+            end
             next
           end
 
-          # Run validators
-          if arg.validators.any?
-            validation_errors = Validator.validate!(arg.validators, nil, ctx, coerced)
-            validation_errors.each do |err|
-              errors << "#{name} #{err}"
+          # Handle explicit null
+          if value.nil?
+            if required_type?(type)
+              errors << "#{name} is required"
+            else
+              validated[name] = nil
             end
+            next
           end
 
-          validated[name] = coerced
+          # Coerce and validate value - let Dry exceptions bubble up
+          validated[name] = type[value]
         end
 
         raise ValidationError.new(errors) if errors.any?
         validated
       end
-    end
-  end
 
-  # Base class for Zero mutations.
-  # Provides argument DSL, validation, and error handling.
-  #
-  # @example
-  #   class WorkCreate < ZeroRuby::Mutation
-  #     argument :id, ID, required: true
-  #     argument :title, String, required: true,
-  #       validates: { length: { maximum: 200 } }
-  #
-  #     def execute(id:, title:)
-  #       authorize! Work, to: :create?
-  #       Work.create!(id: id, title: title)
-  #     end
-  #   end
-  class Mutation
-    include HasArguments
-    include TypeNames
+      private
 
-    # The context hash containing current_user, etc.
-    attr_reader :ctx
+      # Check if a type is an InputObject class
+      def input_object_type?(type)
+        type.is_a?(Class) && type < InputObject
+      end
+
+      # Check if a type has a default value
+      def has_default?(type)
+        type.respond_to?(:default?) && type.default?
+      end
+
+      # Get the default value for a type
+      def get_default(type)
+        return nil unless has_default?(type)
+        type[]
+      end
+
+      # Check if a type is required (not optional and not with default)
+      def required_type?(type)
+        return true unless type.respond_to?(:optional?)
+        !type.optional? && !has_default?(type)
+      end
+    end
 
     # Initialize a mutation with raw arguments and context
     # @param raw_args [Hash] Raw input arguments (will be coerced and validated)
     # @param ctx [Hash] The context hash
     def initialize(raw_args, ctx)
       @ctx = ctx
-      @args = self.class.coerce_and_validate!(raw_args, ctx)
+      @args = self.class.coerce_and_validate!(raw_args)
     end
 
     # Execute the mutation
-    # @return [Hash] Empty hash on success
+    # @param transact_proc [Proc] Block that wraps transactional work (internal use)
+    # @return [Hash] Empty hash on success, or {data: ...} if execute returns a Hash
     # @raise [ZeroRuby::Error] On failure (formatted at boundary)
-    def call
-      execute(**@args)
-      {}
+    def call(&transact_proc)
+      @transact_proc = transact_proc
+      data = execute(**@args)
+      result = {}
+      result[:data] = data if data.is_a?(Hash) && !data.empty?
+      result
     end
 
     private
 
+    # Wrap database operations in a transaction with LMID tracking.
+    #
+    # Behavior depends on skip_auto_transaction:
+    # - Default (no skip) - Just executes the block (already in transaction)
+    # - skip_auto_transaction - Wraps block in transaction via transact_proc
+    #
+    # For skip_auto_transaction mutations, you MUST call this method.
+    # For default mutations, calling this is optional (no-op, just runs block).
+    #
+    # @yield Block containing database operations
+    # @return [Object] Result of the block
+    def transact(&block)
+      raise "transact requires a block" unless block_given?
+
+      if @transact_proc
+        # Manual transact mode (auto_transact: false) - use the provided proc
+        @transact_proc.call(&block)
+      else
+        # Auto transact mode - already in transaction, just execute the block
+        block.call
+      end
+    end
+
+    # Convenience method to access current_user from context.
+    # Override in your ApplicationMutation if you need different behavior.
+    def current_user
+      ctx[:current_user]
+    end
+
     # Implement this method in subclasses to define mutation logic.
-    # Arguments declared with `argument` are passed as keyword arguments.
-    # Access context via ctx[:key] (e.g., ctx[:current_user]).
-    # No return value needed - just perform the mutation.
-    # Raise an exception to signal failure.
-    def execute(**)
+    # Arguments are passed as keyword arguments matching your declared arguments.
+    # Access context via ctx[:key] or use the current_user helper.
+    #
+    # By default (auto_transact: true), the entire execute method runs inside
+    # a transaction with LMID tracking. Just write your database operations directly.
+    #
+    # For 3-phase control, use `skip_auto_transaction` and call transact { ... }:
+    # - Pre-transaction: code before transact (auth, validation)
+    # - Transaction: code inside transact { } (database operations)
+    # - Post-commit: code after transact returns (side effects)
+    #
+    # @example Simple mutation (default auto_transact: true)
+    #   def execute(id:, title:)
+    #     authorize! Post, to: :create?
+    #     Post.create!(id: id, title: title)
+    #   end
+    #
+    # @example 3-phase mutation (skip_auto_transaction)
+    #   def execute(id:, title:)
+    #     authorize! Post, to: :create?     # Pre-transaction
+    #     result = transact do
+    #       Post.create!(id: id, title: title)  # Transaction
+    #     end
+    #     NotificationService.notify(result.id)  # Post-commit
+    #     {id: result.id}
+    #   end
+    def execute(**args)
       raise NotImplementedError, "Subclasses must implement #execute"
     end
   end