zero_ruby 0.1.0.alpha2 → 0.1.0.alpha4

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,88 +91,111 @@ 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
+    # @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
+    def call(&transact_proc)
+      @transact_proc = transact_proc
       data = execute(**@args)
       result = {}
       result[:data] = data if data.is_a?(Hash) && !data.empty?
@@ -131,12 +204,63 @@ module ZeroRuby
 
     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

data/lib/zero_ruby/push_processor.rb

@@ -15,15 +15,13 @@ module ZeroRuby
   # @see https://github.com/rocicorp/mono/blob/main/packages/zero-server/src/process-mutations.ts
   # @see https://github.com/rocicorp/mono/blob/main/packages/zero-server/src/zql-database.ts
   class PushProcessor
-    attr_reader :schema, :lmid_store, :max_retries
+    attr_reader :schema, :lmid_store
 
     # @param schema [Class] The schema class for mutation processing
     # @param lmid_store [LmidStore] The LMID store instance
-    # @param max_retries [Integer] Maximum retry attempts for retryable errors
-    def initialize(schema:, lmid_store:, max_retries: 3)
+    def initialize(schema:, lmid_store:)
       @schema = schema
       @lmid_store = lmid_store
-      @max_retries = max_retries
     end
 
     # Process a Zero push request
@@ -39,6 +37,10 @@ module ZeroRuby
       mutations.each_with_index do |mutation_data, index|
         result = process_mutation_with_lmid(mutation_data, client_group_id, context)
         results << result
+      rescue MutationNotFoundError => e
+        # Unknown mutation - return error response and continue batch
+        mutation_id_obj = {id: mutation_data["id"], clientID: mutation_data["clientID"]}
+        results << {id: mutation_id_obj, result: format_error_response(e)}
       rescue OutOfOrderMutationError => e
         # Return top-level PushFailedBody with all unprocessed mutation IDs
         unprocessed_ids = mutations[index..].map { |m| {id: m["id"], clientID: m["clientID"]} }
@@ -49,7 +51,7 @@ module ZeroRuby
           message: e.message,
           mutationIDs: unprocessed_ids
         }
-      rescue DatabaseError => e
+      rescue DatabaseTransactionError => e
         # Database errors trigger top-level PushFailed per Zero protocol
         unprocessed_ids = mutations[index..].map { |m| {id: m["id"], clientID: m["clientID"]} }
         return {
@@ -66,30 +68,117 @@ module ZeroRuby
 
     private
 
-    # Process a single mutation with LMID validation and transaction support.
-    # Uses atomic increment-then-validate pattern matching Zero's TypeScript implementation.
+    # Process a single mutation with LMID validation, transaction support, and phase tracking.
+    #
+    # Supports two execution modes:
+    #
+    # **Default (auto-transaction)**
+    # - Entire execute method is wrapped in a transaction with LMID tracking
+    # - User does NOT need to call transact {} - it's automatic
+    # - Simple mutations benefit from less boilerplate
+    #
+    # **skip_auto_transaction**
+    # - Uses three-phase model matching Zero's TypeScript implementation:
+    #   1. Pre-transaction: User code runs before calling transact (auth, validation)
+    #   2. Transaction: User code inside transact { } block (database operations, LMID tracking)
+    #   3. Post-commit: User code after transact returns (side effects)
+    # - User MUST call transact {} or TransactNotCalledError is raised
+    #
+    # LMID semantics by phase:
+    # - Pre-transaction error: LMID advanced in separate transaction
+    # - Transaction error: LMID advanced in separate transaction (original tx rolled back)
+    # - Post-commit error: LMID already committed with transaction
     def process_mutation_with_lmid(mutation_data, client_group_id, context)
       mutation_id = mutation_data["id"]
       client_id = mutation_data["clientID"]
+      mutation_id_obj = {id: mutation_id, clientID: client_id}
+      mutation_name = mutation_data["name"]
 
-      mutation_id_obj = {
-        id: mutation_id,
-        clientID: client_id
-      }
+      handler_class = schema.handler_for(mutation_name)
+      raise MutationNotFoundError.new(mutation_name) unless handler_class
 
-      lmid_store.transaction do
-        # Atomically increment LMID first, then validate.
-        # This matches the TypeScript implementation's approach for minimal lock duration.
+      if handler_class.skip_auto_transaction?
+        process_manual_transact(mutation_data, client_group_id, client_id, mutation_id, mutation_id_obj, context)
+      else
+        process_auto_transact(mutation_data, client_group_id, client_id, mutation_id, mutation_id_obj, context)
+      end
+    end
+
+    # Process mutation with auto-transact (entire execute wrapped in transaction)
+    def process_auto_transact(mutation_data, client_group_id, client_id, mutation_id, mutation_id_obj, context)
+      result = lmid_store.transaction do
         last_mutation_id = lmid_store.fetch_and_increment(client_group_id, client_id)
         check_lmid!(client_id, mutation_id, last_mutation_id)
-
-        result = execute_with_retry(mutation_data, context)
-        {id: mutation_id_obj, result: result}
+        schema.execute_mutation(mutation_data, context)
       end
-    rescue OutOfOrderMutationError, DatabaseError
+      {id: mutation_id_obj, result: result}
+    rescue MutationAlreadyProcessedError => e
+      {id: mutation_id_obj, result: format_error_response(e)}
+    rescue OutOfOrderMutationError, DatabaseTransactionError
       raise
-    rescue ZeroRuby::Error => e
+    rescue ActiveRecord::StatementInvalid => e
+      raise DatabaseTransactionError.new("Transaction failed: #{e.message}")
+    rescue ZeroRuby::Error, FloatDomainError => e
+      # No retry - matches TypeScript behavior (TS does NOT retry user code)
+      # Transaction rolled back - advance LMID separately to prevent replay
+      persist_lmid_on_application_error(client_group_id, client_id)
+      error = e.is_a?(FloatDomainError) ?
+        ValidationError.new(["Invalid numeric value: #{e.message}"]) : e
+      {id: mutation_id_obj, result: format_error_response(error)}
+    rescue => e
+      raise DatabaseTransactionError.new("Transaction failed: #{e.message}")
+    end
+
+    # Process mutation with manual transact (3-phase model)
+    # No retry - matches TypeScript behavior (TS does NOT retry user code)
+    def process_manual_transact(mutation_data, client_group_id, client_id, mutation_id, mutation_id_obj, context)
+      phase = :pre_transaction
+      transact_called = false
+
+      transact_proc = proc { |&user_block|
+        transact_called = true
+        phase = :transaction
+        result = lmid_store.transaction do
+          last_mutation_id = lmid_store.fetch_and_increment(client_group_id, client_id)
+          check_lmid!(client_id, mutation_id, last_mutation_id)
+          user_block.call
+        end
+        phase = :post_commit
+        result
+      }
+
+      result = schema.execute_mutation(mutation_data, context, &transact_proc)
+      raise TransactNotCalledError.new unless transact_called
+      {id: mutation_id_obj, result: result}
+    rescue MutationAlreadyProcessedError => e
       {id: mutation_id_obj, result: format_error_response(e)}
+    rescue OutOfOrderMutationError, DatabaseTransactionError
+      raise
+    rescue ActiveRecord::StatementInvalid => e
+      raise DatabaseTransactionError.new("Transaction failed: #{e.message}")
+    rescue ZeroRuby::Error, FloatDomainError => e
+      # LMID semantics by phase (no retry - matches TS):
+      # - Pre-transaction: LMID advanced separately
+      # - Transaction (rolled back): LMID advanced separately
+      # - Post-commit: LMID already committed with transaction
+      if phase != :post_commit
+        persist_lmid_on_application_error(client_group_id, client_id)
+      end
+      error = e.is_a?(FloatDomainError) ?
+        ValidationError.new(["Invalid numeric value: #{e.message}"]) : e
+      {id: mutation_id_obj, result: format_error_response(error)}
+    rescue => e
+      raise DatabaseTransactionError.new("Transaction failed: #{e.message}")
+    end
+
+    # Persist LMID advancement after an application error.
+    # Called for pre-transaction and transaction errors to prevent replay attacks.
+    def persist_lmid_on_application_error(client_group_id, client_id)
+      lmid_store.transaction do
+        lmid_store.fetch_and_increment(client_group_id, client_id)
+      end
+    rescue => e
+      warn "Failed to persist LMID after application error: #{e.message}"
     end
 
     # Validate LMID against the post-increment value.
@@ -113,21 +202,6 @@ module ZeroRuby
       end
     end
 
-    # Execute mutation with retry logic for app errors
-    def execute_with_retry(mutation_data, context)
-      attempts = 0
-
-      loop do
-        attempts += 1
-
-        begin
-          return schema.execute_mutation(mutation_data, context)
-        rescue ZeroRuby::Error => e
-          raise e unless attempts < max_retries
-        end
-      end
-    end
-
     # Format an error into Zero protocol response
     def format_error_response(error)
       result = {error: error.error_type}

data/lib/zero_ruby/schema.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "error_formatter"
 
 module ZeroRuby
   # Schema class for registering and processing Zero mutations.
@@ -28,6 +29,13 @@ module ZeroRuby
         end
       end
 
+      # Get handler class for a mutation name
+      # @param name [String] The mutation name
+      # @return [Class, nil] The handler class or nil if not found
+      def handler_for(name)
+        mutations[normalize_mutation_name(name)]
+      end
+
       # Generate TypeScript type definitions from registered mutations
       # @return [String] TypeScript type definitions
       def to_typescript
@@ -67,8 +75,7 @@ module ZeroRuby
         store = lmid_store || ZeroRuby.configuration.lmid_store_instance
         processor = PushProcessor.new(
           schema: self,
-          lmid_store: store,
-          max_retries: ZeroRuby.configuration.max_retry_attempts
+          lmid_store: store
         )
         processor.process(push_data, context)
       rescue ParseError => e
@@ -85,32 +92,45 @@ module ZeroRuby
       # Used by PushProcessor for LMID-tracked mutations.
       # @param mutation_data [Hash] The mutation data from Zero
       # @param context [Hash] Context hash to pass to mutations
+      # @param transact [Proc] Block that wraps transactional work
       # @return [Hash] Empty hash on success
       # @raise [MutationNotFoundError] If the mutation is not registered
       # @raise [ZeroRuby::Error] If the mutation fails
-      def execute_mutation(mutation_data, context)
+      def execute_mutation(mutation_data, context, &transact)
         name = normalize_mutation_name(mutation_data["name"])
-        raw_args = extract_args(mutation_data)
-        params = transform_keys(raw_args)
-
-        ctx = context.freeze
         handler = mutations[name]
-
         raise MutationNotFoundError.new(name) unless handler
 
-        handler.new(params, ctx).call
+        raw_args = extract_args(mutation_data)
+        params = transform_keys(raw_args)
+
+        handler.new(params, context).call(&transact)
+      rescue Dry::Struct::Error => e
+        raise ValidationError.new(ErrorFormatter.format_struct_error(e))
+      rescue Dry::Types::CoercionError => e
+        raise ValidationError.new([ErrorFormatter.format_coercion_error(e)])
+      rescue Dry::Types::ConstraintError => e
+        raise ValidationError.new([ErrorFormatter.format_constraint_error(e)])
       end
 
       private
 
-      # Validate push data structure
+      # Validate push data structure per Zero protocol
+      # Required fields: clientGroupID, mutations, pushVersion, timestamp, requestID
       # @raise [ParseError] If push data is malformed
       def validate_push_structure!(push_data)
         unless push_data.is_a?(Hash)
           raise ParseError.new("Push data must be a hash")
         end
-        unless push_data.key?("clientGroupID")
-          raise ParseError.new("Missing required field: clientGroupID")
+
+        %w[clientGroupID mutations pushVersion timestamp requestID].each do |field|
+          unless push_data.key?(field)
+            raise ParseError.new("Missing required field: #{field}")
+          end
+        end
+
+        unless push_data["mutations"].is_a?(Array)
+          raise ParseError.new("Field 'mutations' must be an array")
         end
       end
 
@@ -129,12 +149,16 @@ module ZeroRuby
         args.is_a?(Array) ? (args.first || {}) : args
       end
 
-      # Transform camelCase string keys to snake_case symbols (deep)
+      # Transform camelCase string keys to snake_case strings (deep).
+      # Keys are kept as strings to prevent symbol table DoS attacks.
+      # Symbolization happens later in coerce_and_validate! using schema-defined keys.
+      # @param object [Object] The object to transform
+      # @return [Object] Transformed object with string keys
       def transform_keys(object)
         case object
         when Hash
           object.each_with_object({}) do |(key, value), result|
-            new_key = key.to_s.gsub(/([A-Z])/, '_\1').downcase.delete_prefix("_").to_sym
+            new_key = key.to_s.gsub(/([A-Z])/, '_\1').downcase.delete_prefix("_")
             result[new_key] = transform_keys(value)
           end
         when Array

data/lib/zero_ruby/type_names.rb

@@ -1,24 +1,29 @@
 # frozen_string_literal: true
 
+require_relative "types"
+
 module ZeroRuby
   # Provides shorthand constants for ZeroRuby types.
   # Include this module to use ID, Boolean, etc. without the ZeroRuby::Types:: prefix.
   #
-  # This is automatically included in Mutation and InputObject, so you can write:
-  #
+  # @example Including in your own classes
   #   class PostCreate < ZeroRuby::Mutation
-  #     argument :id, ID, required: true
-  #     argument :title, String, required: true
-  #     argument :active, Boolean, required: true
+  #     include ZeroRuby::TypeNames
+  #
+  #     argument :id, ID
+  #     argument :title, Types::String
+  #     argument :active, Boolean
   #   end
   #
-  # Note: String, Integer, and Float work automatically because Ruby's built-in
-  # classes are resolved to ZeroRuby types by the argument system.
+  # Note: Ruby's built-in String, Integer, and Float cannot be aliased since
+  # they are actual classes. Use ZeroRuby::Types::String, etc. instead.
   module TypeNames
     ID = ZeroRuby::Types::ID
     Boolean = ZeroRuby::Types::Boolean
-    BigInt = ZeroRuby::Types::BigInt
     ISO8601Date = ZeroRuby::Types::ISO8601Date
     ISO8601DateTime = ZeroRuby::Types::ISO8601DateTime
+
+    # Provide Types module access without prefix
+    Types = ZeroRuby::Types
   end
 end