zero_ruby 0.1.0.alpha4 → 0.1.0.alpha5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d78f7995f5a44093ed0202e53dd345587f73a2d2a675e31c158fe01ed392e6e
-  data.tar.gz: 9fbbb4cdce370fca8c035e0fad0cd0dbbeaa9ace5cf92061cdab6274223987ae
+  metadata.gz: 68451ec0c319aab33578ee4ac8aa28f61426ade64f4185047528387c5c95f3e5
+  data.tar.gz: fc5b90718c5c0aa5ee11020b02e01d422cee0108bb1095c9aac8eb184dd6c050
 SHA512:
-  metadata.gz: 6b4e963190e7911e4b9b137933165bd20eebabf2e9a183f9ae7404e0f3ab6b00c2f321098fdf58aaf2ab84fbca7490e1e82b47bb5ed2e3616aa10151173ba2ba
-  data.tar.gz: 35b53c46c18655067e7e393893539fa451baf956a3f3a827cd9edfd340e33b29eb55ef9327297ae279a3604717244f3d04cf5ddb2bba5f28308b200c6f724b19
+  metadata.gz: b60c2a285735db948bf33ebd52f78fc09329ed3c0a012cc000dab2eda668bf37920058dd4444317ff8bde80fcf70713014ed24186037fdf6b9acf35f32f3dc6b
+  data.tar.gz: bb7c53048a48d3c65c0303be1d67bf59368e3a2eec7ae8ce482c50e94304a8295be05ffb062e4591162a5d2cfb53f66d322b807e9c9c26c0039ec5ac3967e5d9

data/README.md

@@ -27,7 +27,7 @@ By default, the entire `execute` method runs inside a transaction with LMID (Las
 # app/zero/mutations/post_update.rb
 module Mutations
   class PostUpdate < ApplicationMutation
-    argument :id, ID
+    argument :id, Types::ID
     argument :post_input, Types::PostInput
 
     def execute(id:, post_input:)
@@ -101,14 +101,14 @@ module Types
   class PostInput < Types::BaseInputObject
     argument :title, Types::String.constrained(min_size: 1, max_size: 200)
     argument :body, Types::String.optional
-    argument :published, Boolean.default(false)
+    argument :published, Types::Boolean.default(false)
   end
 end
 ```
 
 ## Configuration
 
-Create an initializer to customize settings (all options have sensible defaults):
+Create an initializer to customize settings:
 
 ```ruby
 # config/initializers/zero_ruby.rb
@@ -168,29 +168,24 @@ export type Mutators = typeof mutators
 
 ## Types
 
-ZeroRuby provides types built on [dry-types](https://dry-rb.org/gems/dry-types/). When you inherit from `ZeroRuby::Mutation` or `ZeroRuby::InputObject`, the following are available:
-
-- **Direct constants**: `ID`, `Boolean`, `ISO8601Date`, `ISO8601DateTime`
-- **Via Types module**: `Types::String`, `Types::Integer`, `Types::Float`
-
-(Note: `String`, `Integer`, `Float` can't be direct constants because they conflict with Ruby's built-in classes)
+ZeroRuby provides types built on [dry-types](https://dry-rb.org/gems/dry-types/). When you inherit from `ZeroRuby::Mutation` or `ZeroRuby::InputObject`, types are available via the `Types` module:
 
 ```ruby
 # Basic types
 argument :name, Types::String
 argument :count, Types::Integer
 argument :price, Types::Float
-argument :active, Boolean
-argument :id, ID                    # Non-empty string
-argument :date, ISO8601Date
-argument :timestamp, ISO8601DateTime
+argument :active, Types::Boolean
+argument :id, Types::ID               # Non-empty string
+argument :date, Types::ISO8601Date
+argument :timestamp, Types::ISO8601DateTime
 
 # Optional types (accepts nil)
 argument :nickname, Types::String.optional
 
 # Default values
 argument :status, Types::String.default("draft")
-argument :enabled, Boolean.default(false)
+argument :enabled, Types::Boolean.default(false)
 ```
 
 ## Validation with Constraints
@@ -260,7 +255,7 @@ By default, the entire `execute` method runs inside a transaction in order to at
 class PostUpdate < ApplicationMutation
   skip_auto_transaction
 
-  argument :id, ID
+  argument :id, Types::ID
   argument :post_input, Types::PostInput
 
   def execute(id:, post_input:)

data/lib/zero_ruby/error_formatter.rb

@@ -21,7 +21,9 @@ module ZeroRuby
           field = match ? match[1] : "field"
           ["#{field} is required"]
         elsif message.include?("has invalid type")
-          match = message.match(/:(\w+) has invalid type/)
+          # Matches both ":title has invalid type" and "has invalid type for :title"
+          match = message.match(/:(\w+) has invalid type/) ||
+            message.match(/has invalid type for :(\w+)/)
           field = match ? match[1] : "field"
           ["#{field}: invalid type"]
         elsif message.include?("violates constraints")
@@ -81,7 +83,7 @@ module ZeroRuby
         begin
           result = MESSAGES.call(key, path: [:base], tokens: build_tokens(key, args))
           result&.text
-        rescue StandardError
+        rescue
           nil
         end
       end

data/lib/zero_ruby/errors.rb

@@ -91,7 +91,7 @@ module ZeroRuby
   # Raised for database transaction errors.
   # Triggers top-level PushFailed with reason: "database"
   # Wraps unexpected errors during transaction execution (matching TS behavior).
-  class DatabaseTransactionError < Error
+  class TransactionError < Error
   end
 
   # Raised when push data is malformed or missing required fields.

data/lib/zero_ruby/input_object.rb

@@ -8,21 +8,20 @@ module ZeroRuby
   # Base class for input objects (nested argument types).
   # 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)
+  # Includes ZeroRuby::TypeNames for convenient type access via the Types module
+  # (e.g., Types::String, Types::ID, Types::Boolean).
   #
   # @example
   #   class Types::PostInput < ZeroRuby::InputObject
-  #     argument :id, ID
+  #     argument :id, Types::ID
   #     argument :title, Types::String.constrained(min_size: 1, max_size: 200)
   #     argument :body, Types::String.optional
-  #     argument :published, Boolean.default(false)
+  #     argument :published, Types::Boolean.default(false)
   #   end
   #
   #   class PostCreate < ZeroRuby::Mutation
   #     argument :post_input, Types::PostInput
-  #     argument :notify, Boolean.default(false)
+  #     argument :notify, Types::Boolean.default(false)
   #
   #     def execute
   #       # args[:post_input].title, args[:post_input].body, etc.

data/lib/zero_ruby/mutation.rb

@@ -3,21 +3,21 @@
 require_relative "types"
 require_relative "type_names"
 require_relative "errors"
+require_relative "error_formatter"
 
 module ZeroRuby
   # 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)
+  # Includes ZeroRuby::TypeNames for convenient type access via the Types module
+  # (e.g., Types::String, Types::ID, Types::Boolean).
   #
   # 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 :id, Types::ID
   #     argument :title, Types::String.constrained(max_size: 200)
   #
   #     def execute(id:, title:)
@@ -30,7 +30,7 @@ module ZeroRuby
   #   class WorkUpdate < ZeroRuby::Mutation
   #     skip_auto_transaction
   #
-  #     argument :id, ID
+  #     argument :id, Types::ID
   #     argument :title, Types::String
   #
   #     def execute(id:, title:)
@@ -92,16 +92,21 @@ module ZeroRuby
       end
 
       # 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.
+      # Collects ALL validation errors (missing fields, type coercion, constraints)
+      # and raises a single ValidationError with all issues.
       #
-      # @param raw_args [Hash] Raw input arguments
-      # @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
+      # Uses type.try(value) which returns a Result instead of raising, allowing
+      # us to collect all errors in one pass rather than failing on the first one.
+      # Works for both Dry::Types (scalars) and Dry::Struct (InputObjects).
+      #
+      # @param raw_args [Hash] Raw input arguments (string keys from JSON)
+      # @return [Hash] Validated and coerced arguments (symbol keys, may contain InputObject instances)
+      # @raise [ZeroRuby::ValidationError] If any validation fails
       def coerce_and_validate!(raw_args)
+        # Result hash: symbol keys → coerced values (strings, integers, InputObject instances, etc.)
+        # eg:
+        # raw_args:  {"name" => "test", "count" => "5"}  # string keys, raw values
+        # validated: {name: "test", count: 5}            # symbol keys, coerced values
         validated = {}
         errors = []
 
@@ -110,47 +115,38 @@ module ZeroRuby
           str_key = name.to_s
           key_present = raw_args.key?(str_key)
           value = raw_args[str_key]
+          is_input_object = input_object_type?(type)
 
-          # 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
-
-          # Handle missing key
-          if !key_present
+          # Missing key: use default if available, otherwise error if required
+          unless key_present
             if has_default?(type)
               validated[name] = get_default(type)
             elsif required_type?(type)
               errors << "#{name} is required"
             end
+            # Optional fields without defaults are simply omitted from result
             next
           end
 
-          # Handle explicit null
+          # Explicit null: InputObjects always allow nil (they handle optionality internally),
+          # scalars only allow nil if the type is optional
           if value.nil?
-            if required_type?(type)
-              errors << "#{name} is required"
-            else
+            if is_input_object || !required_type?(type)
               validated[name] = nil
+            else
+              errors << "#{name} is required"
             end
             next
           end
 
-          # Coerce and validate value - let Dry exceptions bubble up
-          validated[name] = type[value]
+          # Coerce value: type.try returns Result instead of raising, so we can
+          # collect all errors. Works for both Dry::Types and Dry::Struct.
+          result = type.try(value)
+          if result.failure?
+            errors << format_type_error(name, result.error, is_input_object)
+          else
+            validated[name] = result.input
+          end
         end
 
         raise ValidationError.new(errors) if errors.any?
@@ -180,6 +176,28 @@ module ZeroRuby
         return true unless type.respond_to?(:optional?)
         !type.optional? && !has_default?(type)
       end
+
+      # Format a type error (coercion or constraint failure)
+      # @param name [Symbol] The field name
+      # @param error [Exception] The error from try.failure
+      # @param is_input_object [Boolean] Whether this is an InputObject type
+      # @return [String] Formatted error message
+      def format_type_error(name, error, is_input_object = false)
+        if is_input_object && error.is_a?(Dry::Struct::Error)
+          # InputObject errors get prefixed with field name
+          ErrorFormatter.format_struct_error(error).map { |m| "#{name}.#{m}" }.first
+        else
+          message = case error
+          when Dry::Types::CoercionError
+            ErrorFormatter.format_coercion_error(error)
+          when Dry::Types::ConstraintError
+            ErrorFormatter.format_constraint_error(error)
+          else
+            error.message
+          end
+          "#{name}: #{message}"
+        end
+      end
     end
 
     # Initialize a mutation with raw arguments and context
@@ -194,9 +212,20 @@ module ZeroRuby
     # @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)
+    # @raise [ZeroRuby::TransactNotCalledError] If skip_auto_transaction and transact not called
     def call(&transact_proc)
       @transact_proc = transact_proc
-      data = execute(**@args)
+      @transact_called = false
+
+      if self.class.skip_auto_transaction?
+        # Manual mode: Use defined mutation calls transact {}
+        data = execute(**@args)
+        raise TransactNotCalledError.new unless @transact_called
+      else
+        # Auto mode: wrap entire execute in transaction
+        data = transact_proc.call { execute(**@args) }
+      end
+
       result = {}
       result[:data] = data if data.is_a?(Hash) && !data.empty?
       result
@@ -205,6 +234,7 @@ module ZeroRuby
     private
 
     # Wrap database operations in a transaction with LMID tracking.
+    # Used by user defined mutation.
     #
     # Behavior depends on skip_auto_transaction:
     # - Default (no skip) - Just executes the block (already in transaction)
@@ -217,12 +247,13 @@ module ZeroRuby
     # @return [Object] Result of the block
     def transact(&block)
       raise "transact requires a block" unless block_given?
+      @transact_called = true
 
-      if @transact_proc
-        # Manual transact mode (auto_transact: false) - use the provided proc
+      if self.class.skip_auto_transaction?
+        # Manual mode - actually call the transact_proc to start transaction
         @transact_proc.call(&block)
       else
-        # Auto transact mode - already in transaction, just execute the block
+        # Auto mode - already in transaction, just execute the block
         block.call
       end
     end

data/lib/zero_ruby/push_processor.rb

@@ -37,10 +37,6 @@ 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"]} }
@@ -51,7 +47,7 @@ module ZeroRuby
           message: e.message,
           mutationIDs: unprocessed_ids
         }
-      rescue DatabaseTransactionError => e
+      rescue TransactionError => e
         # Database errors trigger top-level PushFailed per Zero protocol
         unprocessed_ids = mutations[index..].map { |m| {id: m["id"], clientID: m["clientID"]} }
         return {
@@ -70,21 +66,10 @@ module ZeroRuby
 
     # Process a single mutation with LMID validation, transaction support, and phase tracking.
     #
-    # Supports two execution modes:
+    # The Mutation#call method decides whether to auto-wrap execute in a transaction
+    # (default behavior) or pass control to user code (skip_auto_transaction mode).
     #
-    # **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:
+    # Phase tracking enables correct LMID semantics:
     # - 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
@@ -97,46 +82,9 @@ module ZeroRuby
       handler_class = schema.handler_for(mutation_name)
       raise MutationNotFoundError.new(mutation_name) unless handler_class
 
-      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)
-        schema.execute_mutation(mutation_data, context)
-      end
-      {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
-      # 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)
@@ -148,27 +96,24 @@ module ZeroRuby
       }
 
       result = schema.execute_mutation(mutation_data, context, &transact_proc)
-      raise TransactNotCalledError.new unless transact_called
       {id: mutation_id_obj, result: result}
-    rescue MutationAlreadyProcessedError => e
+    rescue MutationNotFoundError, MutationAlreadyProcessedError => e
+      # Known skip conditions - return error response, batch continues
       {id: mutation_id_obj, result: format_error_response(e)}
-    rescue OutOfOrderMutationError, DatabaseTransactionError
+    rescue OutOfOrderMutationError, TransactionError
+      # Batch-terminating errors - bubble up to process() for PushFailed response
       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
+    rescue ZeroRuby::Error => e
+      # Application errors - advance LMID based on phase, return error response
+      # Pre-transaction/transaction: 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)}
+      {id: mutation_id_obj, result: format_error_response(e)}
     rescue => e
-      raise DatabaseTransactionError.new("Transaction failed: #{e.message}")
+      # Unexpected errors - wrap and bubble up as batch-terminating
+      raise TransactionError.new("Transaction failed: #{e.message}")
     end
 
     # Persist LMID advancement after an application error.

data/lib/zero_ruby/type_names.rb

@@ -1,29 +1,16 @@
 # 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.
+  # Provides access to ZeroRuby::Types via the Types constant.
+  # Automatically included in Mutation and InputObject classes.
   #
-  # @example Including in your own classes
+  # @example Usage in mutations
   #   class PostCreate < ZeroRuby::Mutation
-  #     include ZeroRuby::TypeNames
-  #
-  #     argument :id, ID
+  #     argument :id, Types::ID
   #     argument :title, Types::String
-  #     argument :active, Boolean
+  #     argument :active, Types::Boolean
   #   end
-  #
-  # 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
-    ISO8601Date = ZeroRuby::Types::ISO8601Date
-    ISO8601DateTime = ZeroRuby::Types::ISO8601DateTime
-
-    # Provide Types module access without prefix
     Types = ZeroRuby::Types
   end
 end

data/lib/zero_ruby/types.rb

@@ -6,16 +6,14 @@ module ZeroRuby
   # Type definitions using dry-types.
   #
   # When inheriting from ZeroRuby::Mutation or ZeroRuby::InputObject, types are
-  # available via ZeroRuby::TypeNames which is automatically included:
-  #   - Direct: ID, Boolean, ISO8601Date, ISO8601DateTime
-  #   - Via Types: Types::String, Types::Integer, Types::Float
+  # available via the Types module (e.g., Types::String, Types::ID).
   #
   # @example Basic usage
   #   class MyMutation < ZeroRuby::Mutation
-  #     argument :id, ID
+  #     argument :id, Types::ID
   #     argument :name, Types::String
   #     argument :count, Types::Integer.optional
-  #     argument :active, Boolean.default(false)
+  #     argument :active, Types::Boolean.default(false)
   #   end
   #
   # @example With constraints

data/lib/zero_ruby/typescript_generator.rb

@@ -58,6 +58,18 @@ module ZeroRuby
     def collect_input_objects_from_arguments(arguments)
       arguments.each do |_name, config|
         type = config[:type]
+
+        # Unwrap optional types first (Sum type: NilClass | actual_type)
+        if sum_type?(type)
+          inner = extract_non_nil_type(type)
+          type = inner if inner
+        end
+
+        # Then unwrap array types to check element type for InputObjects
+        if array_type?(type)
+          type = type.member
+        end
+
         if input_object_type?(type)
           type_name = extract_type_name(type)
           unless @input_objects.key?(type_name)
@@ -65,7 +77,7 @@ module ZeroRuby
             # Recursively collect nested InputObjects from Dry::Struct schema
             if type.respond_to?(:schema)
               nested_args = type.schema.keys.each_with_object({}) do |key, hash|
-                hash[key.name] = { type: key.type, name: key.name }
+                hash[key.name] = {type: key.type, name: key.name}
               end
               collect_input_objects_from_arguments(nested_args)
             end
@@ -169,6 +181,19 @@ module ZeroRuby
         return extract_type_name(type)
       end
 
+      # Handle Array types
+      if array_type?(type)
+        element_type = type.member
+        return "#{resolve_type(element_type)}[]"
+      end
+
+      # Handle optional types (Sum of NilClass and another type)
+      # This must come before unwrap_primitive to handle optional arrays
+      if sum_type?(type)
+        inner = extract_non_nil_type(type)
+        return resolve_type(inner) if inner
+      end
+
       # Unwrap the dry-type to get the primitive
       primitive = unwrap_primitive(type)
 
@@ -181,7 +206,7 @@ module ZeroRuby
       PRIMITIVE_MAP[primitive] || raise(
         ArgumentError,
         "Cannot map type #{type.inspect} (primitive: #{primitive.inspect}) to TypeScript. " \
-        "Supported primitives: #{PRIMITIVE_MAP.keys.map(&:name).join(', ')}"
+        "Supported primitives: #{PRIMITIVE_MAP.keys.map(&:name).join(", ")}"
       )
     end
 
@@ -231,6 +256,23 @@ module ZeroRuby
       type.is_a?(Class) && type < ZeroRuby::InputObject
     end
 
+    def array_type?(type)
+      type.respond_to?(:primitive) && type.primitive == Array
+    end
+
+    def sum_type?(type)
+      type.respond_to?(:left) && type.respond_to?(:right)
+    end
+
+    def extract_non_nil_type(type)
+      return nil unless sum_type?(type)
+      if type.left.respond_to?(:primitive) && type.left.primitive == NilClass
+        type.right
+      elsif type.right.respond_to?(:primitive) && type.right.primitive == NilClass
+        type.left
+      end
+    end
+
     def extract_type_name(type)
       # Get just the class name without module prefixes
       type.name.split("::").last

data/lib/zero_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZeroRuby
-  VERSION = "0.1.0.alpha4"
+  VERSION = "0.1.0.alpha5"
 end

data/lib/zero_ruby.rb

@@ -7,7 +7,7 @@ require_relative "zero_ruby/errors"
 # Types module (dry-types based)
 require_relative "zero_ruby/types"
 
-# Type name shortcuts (ID, Boolean, etc. without ZeroRuby::Types:: prefix)
+# Provides Types constant for accessing ZeroRuby::Types
 require_relative "zero_ruby/type_names"
 
 # Core classes

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zero_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha4
+  version: 0.1.0.alpha5
 platform: ruby
 authors:
 - Alex Serban
 bindir: bin
 cert_chain: []
-date: 2025-12-22 00:00:00.000000000 Z
+date: 2026-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct