zero_ruby 0.1.0.alpha2 → 0.1.0.alpha5

data/lib/zero_ruby/types.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "dry-types"
+
+module ZeroRuby
+  # Type definitions using dry-types.
+  #
+  # When inheriting from ZeroRuby::Mutation or ZeroRuby::InputObject, types are
+  # available via the Types module (e.g., Types::String, Types::ID).
+  #
+  # @example Basic usage
+  #   class MyMutation < ZeroRuby::Mutation
+  #     argument :id, Types::ID
+  #     argument :name, Types::String
+  #     argument :count, Types::Integer.optional
+  #     argument :active, Types::Boolean.default(false)
+  #   end
+  #
+  # @example With constraints
+  #   class MyMutation < ZeroRuby::Mutation
+  #     argument :title, Types::String.constrained(min_size: 1, max_size: 200)
+  #     argument :count, Types::Integer.constrained(gt: 0)
+  #     argument :status, Types::String.constrained(included_in: %w[draft published])
+  #   end
+  module Types
+    include Dry.Types()
+
+    # Params types for JSON input
+    # These handle string coercions common in form/JSON data
+
+    # String type (passes through strings, coerces nil)
+    String = Params::String
+
+    # Coerces string numbers to integers (e.g., "42" -> 42)
+    Integer = Params::Integer
+
+    # Coerces string numbers to floats (e.g., "3.14" -> 3.14)
+    Float = Params::Float
+
+    # Coerces string booleans (e.g., "true" -> true, "false" -> false)
+    Boolean = Params::Bool
+
+    # Non-empty string ID type
+    ID = Params::String.constrained(filled: true)
+
+    # ISO8601 date string -> Date object
+    ISO8601Date = Params::Date
+
+    # ISO8601 datetime string -> DateTime object
+    ISO8601DateTime = Params::DateTime
+  end
+end

data/lib/zero_ruby/typescript_generator.rb

@@ -9,15 +9,16 @@ module ZeroRuby
   #   TypeScriptGenerator.new(ZeroSchema).generate
   #   # => "// Auto-generated by zero-ruby - do not edit\n\nexport interface ..."
   class TypeScriptGenerator
-    TYPE_MAP = {
-      "ZeroRuby::Types::String" => "string",
-      "ZeroRuby::Types::Integer" => "number",
-      "ZeroRuby::Types::Float" => "number",
-      "ZeroRuby::Types::Boolean" => "boolean",
-      "ZeroRuby::Types::ID" => "string",
-      "ZeroRuby::Types::BigInt" => "number",
-      "ZeroRuby::Types::ISO8601Date" => "string",
-      "ZeroRuby::Types::ISO8601DateTime" => "string"
+    # Map Ruby primitives to TypeScript types
+    PRIMITIVE_MAP = {
+      String => "string",
+      Integer => "number",
+      Float => "number",
+      TrueClass => "boolean",
+      FalseClass => "boolean",
+      Date => "string",
+      DateTime => "string",
+      Time => "string"
     }.freeze
 
     def initialize(schema)
@@ -32,7 +33,6 @@ module ZeroRuby
 
       parts = [
         generate_header,
-        generate_scalars,
         generate_input_objects,
         generate_mutation_args,
         generate_mutation_map
@@ -46,20 +46,6 @@ module ZeroRuby
     def generate_header
       <<~TS
         // Auto-generated by zero-ruby - do not edit
-        // Generated at: #{Time.now.utc.iso8601}
-      TS
-    end
-
-    def generate_scalars
-      <<~TS
-
-        /** Scalar type mappings */
-        export type Scalars = {
-          String: string;
-          Integer: number;
-          Float: number;
-          Boolean: boolean;
-        };
       TS
     end
 
@@ -70,13 +56,31 @@ module ZeroRuby
     end
 
     def collect_input_objects_from_arguments(arguments)
-      arguments.each do |_name, arg|
-        if input_object_type?(arg.type)
-          type_name = extract_type_name(arg.type)
+      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)
-            @input_objects[type_name] = arg.type
-            # Recursively collect nested InputObjects
-            collect_input_objects_from_arguments(arg.type.arguments)
+            @input_objects[type_name] = type
+            # 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}
+              end
+              collect_input_objects_from_arguments(nested_args)
+            end
           end
         end
       end
@@ -86,36 +90,57 @@ module ZeroRuby
       return nil if @input_objects.empty?
 
       interfaces = @input_objects.map do |name, klass|
-        generate_interface(name, klass.arguments)
+        generate_input_object_interface(name, klass)
       end
 
       "\n" + interfaces.join("\n\n")
     end
 
+    def generate_input_object_interface(name, klass)
+      return empty_interface(name) unless klass.respond_to?(:schema)
+
+      keys = klass.schema.keys
+      return empty_interface(name) if keys.empty?
+
+      fields = keys.map do |key|
+        # Check if the type itself is optional (not just the key)
+        optional = optional_type?(key.type)
+        optional_mark = optional ? "?" : ""
+        ts_type = resolve_type(key.type)
+        ts_type = "#{ts_type} | null" if optional
+        "  #{to_camel_case(key.name)}#{optional_mark}: #{ts_type};"
+      end
+
+      <<~TS.strip
+        /** #{name} */
+        export interface #{name} {
+        #{fields.join("\n")}
+        }
+      TS
+    end
+
     def generate_mutation_args
       return nil if @schema.mutations.empty?
 
       interfaces = @schema.mutations.map do |name, handler_class|
         interface_name = to_interface_name(name)
-        generate_interface(interface_name, handler_class.arguments)
+        generate_mutation_interface(interface_name, handler_class.arguments)
       end
 
       "\n" + interfaces.join("\n\n")
     end
 
-    def generate_interface(name, arguments)
-      if arguments.empty?
-        return <<~TS.strip
-          /** #{name} */
-          export interface #{name} {}
-        TS
-      end
-
-      fields = arguments.map do |arg_name, arg|
-        optional = arg.optional? ? "?" : ""
-        ts_type = resolve_type(arg.type)
-        description = arg.description ? "  /** #{arg.description} */\n" : ""
-        "#{description}  #{to_camel_case(arg_name)}#{optional}: #{ts_type};"
+    def generate_mutation_interface(name, arguments)
+      return empty_interface(name) if arguments.empty?
+
+      fields = arguments.map do |arg_name, config|
+        type = config[:type]
+        optional = optional_type?(type)
+        optional_mark = optional ? "?" : ""
+        ts_type = resolve_type(type)
+        ts_type = "#{ts_type} | null" if optional
+        description = config[:description] ? "  /** #{config[:description]} */\n" : ""
+        "#{description}  #{to_camel_case(arg_name)}#{optional_mark}: #{ts_type};"
       end
 
       <<~TS.strip
@@ -126,6 +151,13 @@ module ZeroRuby
       TS
     end
 
+    def empty_interface(name)
+      <<~TS.strip
+        /** #{name} */
+        export interface #{name} {}
+      TS
+    end
+
     def generate_mutation_map
       return nil if @schema.mutations.empty?
 
@@ -140,27 +172,105 @@ module ZeroRuby
         export interface MutationArgs {
         #{entries.join("\n")}
         }
-
-        export type MutationName = keyof MutationArgs;
-        export type ArgsFor<T extends MutationName> = MutationArgs[T];
       TS
     end
 
     def resolve_type(type)
-      type_key = type.to_s
+      # Handle InputObject classes
+      if input_object_type?(type)
+        return extract_type_name(type)
+      end
+
+      # Handle Array types
+      if array_type?(type)
+        element_type = type.member
+        return "#{resolve_type(element_type)}[]"
+      end
 
-      if TYPE_MAP.key?(type_key)
-        TYPE_MAP[type_key]
-      elsif input_object_type?(type)
-        extract_type_name(type)
-      else
-        # Unknown type, default to unknown
-        "unknown"
+      # 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)
+
+      # Check if it's a nested InputObject after unwrapping
+      if input_object_type?(primitive)
+        return extract_type_name(primitive)
+      end
+
+      # Map primitive to TypeScript
+      PRIMITIVE_MAP[primitive] || raise(
+        ArgumentError,
+        "Cannot map type #{type.inspect} (primitive: #{primitive.inspect}) to TypeScript. " \
+        "Supported primitives: #{PRIMITIVE_MAP.keys.map(&:name).join(", ")}"
+      )
+    end
+
+    # Unwrap dry-types wrappers to get the underlying primitive
+    def unwrap_primitive(type)
+      # Check for Sum type (optional = NilClass | type)
+      # For optional types, left is NilClass, right is the actual type
+      if type.respond_to?(:left) && type.respond_to?(:right)
+        left_primitive = unwrap_primitive(type.left)
+        right_primitive = unwrap_primitive(type.right)
+        # Return the non-NilClass side
+        return right_primitive if left_primitive == NilClass
+        return left_primitive if right_primitive == NilClass
+        # If neither is NilClass, return left (shouldn't happen for optional)
+        return left_primitive
+      end
+
+      # Try to get the primitive directly
+      if type.respond_to?(:primitive)
+        return type.primitive
+      end
+
+      # Check for Constrained type
+      if type.respond_to?(:type) && type.class.name&.include?("Constrained")
+        return unwrap_primitive(type.type)
+      end
+
+      # Check for Default type
+      if type.respond_to?(:type) && type.class.name&.include?("Default")
+        return unwrap_primitive(type.type)
+      end
+
+      # Check for other wrappers with .type method
+      if type.respond_to?(:type)
+        return unwrap_primitive(type.type)
+      end
+
+      type
+    end
+
+    def optional_type?(type)
+      return false unless type.respond_to?(:optional?)
+      type.optional? || (type.respond_to?(:default?) && type.default?)
     end
 
     def input_object_type?(type)
-      defined?(ZeroRuby::InputObject) && type.is_a?(Class) && type < ZeroRuby::InputObject
+      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)

data/lib/zero_ruby/version.rb

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

data/lib/zero_ruby.rb

@@ -4,33 +4,13 @@ require_relative "zero_ruby/version"
 require_relative "zero_ruby/configuration"
 require_relative "zero_ruby/errors"
 
-# Types (must be loaded before InputObject/Mutation which use them)
-require_relative "zero_ruby/types/base_type"
-require_relative "zero_ruby/types/string"
-require_relative "zero_ruby/types/integer"
-require_relative "zero_ruby/types/float"
-require_relative "zero_ruby/types/boolean"
-require_relative "zero_ruby/types/id"
-require_relative "zero_ruby/types/big_int"
-require_relative "zero_ruby/types/iso8601_date"
-require_relative "zero_ruby/types/iso8601_date_time"
+# Types module (dry-types based)
+require_relative "zero_ruby/types"
 
-# Type name shortcuts (ID, Boolean, etc. without ZeroRuby::Types:: prefix)
-# Must be loaded before InputObject/Mutation which include this module
+# Provides Types constant for accessing ZeroRuby::Types
 require_relative "zero_ruby/type_names"
 
-# Validators
-require_relative "zero_ruby/validators/length_validator"
-require_relative "zero_ruby/validators/numericality_validator"
-require_relative "zero_ruby/validators/format_validator"
-require_relative "zero_ruby/validators/inclusion_validator"
-require_relative "zero_ruby/validators/exclusion_validator"
-require_relative "zero_ruby/validators/allow_blank_validator"
-require_relative "zero_ruby/validators/allow_null_validator"
-
 # Core classes
-require_relative "zero_ruby/argument"
-require_relative "zero_ruby/validator"
 require_relative "zero_ruby/input_object"
 require_relative "zero_ruby/mutation"
 require_relative "zero_ruby/schema"
@@ -39,6 +19,7 @@ require_relative "zero_ruby/typescript_generator"
 # LMID (Last Mutation ID) Tracking
 require_relative "zero_ruby/lmid_store"
 require_relative "zero_ruby/lmid_stores/active_record_store"
+require_relative "zero_ruby/zero_client"
 require_relative "zero_ruby/push_processor"
 
 # ZeroRuby - A Ruby gem for handling Zero mutations with type safety
@@ -46,19 +27,19 @@ require_relative "zero_ruby/push_processor"
 # @example Basic usage with InputObject
 #   # Define an input type
 #   class Types::PostInput < ZeroRuby::InputObject
-#     argument :id, ID, required: true
-#     argument :title, String, required: true
-#     argument :body, String, required: false
+#     argument :id, ZeroRuby::Types::ID
+#     argument :title, ZeroRuby::Types::String.constrained(min_size: 1, max_size: 200)
+#     argument :body, ZeroRuby::Types::String.optional
 #   end
 #
 #   # Define a mutation
 #   class Mutations::PostCreate < ZeroRuby::Mutation
-#     argument :post_input, Types::PostInput, required: true
-#     argument :notify, Boolean, required: false
+#     argument :post_input, Types::PostInput
+#     argument :notify, ZeroRuby::Types::Boolean.default(false)
 #
-#     def execute(post_input:, notify: false)
-#       Post.create!(**post_input)
-#       notify_subscribers if notify
+#     def execute
+#       Post.create!(**args[:post_input])
+#       notify_subscribers if args[:notify]
 #     end
 #   end
 #
@@ -80,8 +61,4 @@ require_relative "zero_ruby/push_processor"
 #     end
 #   end
 module ZeroRuby
-  # Convenience method for quick type access
-  module Types
-    # Already defined in individual type files
-  end
 end

metadata

@@ -1,14 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: zero_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha2
+  version: 0.1.0.alpha5
 platform: ruby
 authors:
 - Alex Serban
 bindir: bin
 cert_chain: []
-date: 2025-12-21 00:00:00.000000000 Z
+date: 2026-01-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -88,8 +130,8 @@ files:
 - LICENSE.txt
 - README.md
 - lib/zero_ruby.rb
-- lib/zero_ruby/argument.rb
 - lib/zero_ruby/configuration.rb
+- lib/zero_ruby/error_formatter.rb
 - lib/zero_ruby/errors.rb
 - lib/zero_ruby/input_object.rb
 - lib/zero_ruby/lmid_store.rb
@@ -98,24 +140,8 @@ files:
 - lib/zero_ruby/push_processor.rb
 - lib/zero_ruby/schema.rb
 - lib/zero_ruby/type_names.rb
-- lib/zero_ruby/types/base_type.rb
-- lib/zero_ruby/types/big_int.rb
-- lib/zero_ruby/types/boolean.rb
-- lib/zero_ruby/types/float.rb
-- lib/zero_ruby/types/id.rb
-- lib/zero_ruby/types/integer.rb
-- lib/zero_ruby/types/iso8601_date.rb
-- lib/zero_ruby/types/iso8601_date_time.rb
-- lib/zero_ruby/types/string.rb
+- lib/zero_ruby/types.rb
 - lib/zero_ruby/typescript_generator.rb
-- lib/zero_ruby/validator.rb
-- lib/zero_ruby/validators/allow_blank_validator.rb
-- lib/zero_ruby/validators/allow_null_validator.rb
-- lib/zero_ruby/validators/exclusion_validator.rb
-- lib/zero_ruby/validators/format_validator.rb
-- lib/zero_ruby/validators/inclusion_validator.rb
-- lib/zero_ruby/validators/length_validator.rb
-- lib/zero_ruby/validators/numericality_validator.rb
 - lib/zero_ruby/version.rb
 - lib/zero_ruby/zero_client.rb
 homepage: https://github.com/alse/zero-ruby

data/lib/zero_ruby/argument.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module ZeroRuby
-  # Represents a declared argument for a mutation.
-  # Holds type, required status, and validation configuration.
-  class Argument
-    # Sentinel value to distinguish "no default provided" from "default is nil"
-    NOT_PROVIDED = Object.new.freeze
-
-    # Maps Ruby built-in classes to ZeroRuby types.
-    # This allows using String, Integer, Float directly in argument declarations.
-    RUBY_TYPE_MAP = {
-      ::String => -> { ZeroRuby::Types::String },
-      ::Integer => -> { ZeroRuby::Types::Integer },
-      ::Float => -> { ZeroRuby::Types::Float }
-    }.freeze
-
-    attr_reader :name, :type, :required, :validators, :default, :description
-
-    def initialize(name:, type:, required: true, validates: nil, default: NOT_PROVIDED, description: nil, **options)
-      @name = name.to_sym
-      @type = resolve_type(type)
-      @required = required
-      @validators = validates || {}
-      @has_default = default != NOT_PROVIDED
-      @default = @has_default ? default : nil
-      @description = description
-      @options = options
-    end
-
-    def required?
-      @required
-    end
-
-    def optional?
-      !@required
-    end
-
-    def has_default?
-      @has_default
-    end
-
-    # Coerce and validate a raw input value
-    # @param raw_value [Object] The raw input value
-    # @param ctx [Hash] The context hash
-    # @return [Object] The coerced value
-    def coerce(raw_value, ctx = nil)
-      value = (raw_value.nil? && has_default?) ? @default : raw_value
-
-      # Handle InputObject types (they use .coerce instead of .coerce_input)
-      if input_object_type?
-        @type.coerce(value, ctx)
-      else
-        @type.coerce_input(value, ctx)
-      end
-    end
-
-    private
-
-    # Resolve a type reference to a ZeroRuby type.
-    # Handles Ruby built-in classes (String, Integer, Float) by mapping them
-    # to the corresponding ZeroRuby::Types class.
-    def resolve_type(type)
-      if RUBY_TYPE_MAP.key?(type)
-        RUBY_TYPE_MAP[type].call
-      else
-        type
-      end
-    end
-
-    def input_object_type?
-      defined?(ZeroRuby::InputObject) && @type.is_a?(Class) && @type < ZeroRuby::InputObject
-    end
-  end
-end

data/lib/zero_ruby/types/base_type.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module ZeroRuby
-  module Types
-    # Base class for all types. Provides the interface for type coercion.
-    class BaseType
-      class << self
-        def name
-          raise NotImplementedError, "Subclasses must implement .name"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          raise NotImplementedError, "Subclasses must implement .coerce_input"
-        end
-
-        def valid?(value)
-          coerce_input(value)
-          true
-        rescue CoercionError
-          false
-        end
-
-        protected
-
-        # Helper to raise CoercionError with consistent formatting
-        # @param value [Object] The invalid value
-        # @param message [String, nil] Custom message (optional)
-        def coercion_error!(value, message = nil)
-          displayed_value = format_value_for_error(value)
-          msg = message || "#{displayed_value} is not a valid #{name}"
-          raise CoercionError.new(msg, value: value, expected_type: name)
-        end
-
-        private
-
-        # Format a value for display in error messages
-        # Truncates long strings and handles various types
-        def format_value_for_error(value)
-          case value
-          when ::String
-            truncated = (value.length > 50) ? "#{value[0, 50]}..." : value
-            "'#{truncated}'"
-          when ::Symbol
-            ":#{value}"
-          when ::NilClass
-            "nil"
-          else
-            value.inspect.then { |s| (s.length > 50) ? "#{s[0, 50]}..." : s }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/types/big_int.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    # BigInt type for large integers beyond 32-bit range.
-    # Ruby's Integer handles arbitrary precision natively.
-    # Accepts integers and numeric strings, coerces to Integer.
-    class BigInt < BaseType
-      class << self
-        def name
-          "BigInt"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-          return value if value.is_a?(::Integer)
-
-          if value.is_a?(::String)
-            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
-            result = Kernel.Integer(value, exception: false)
-            coercion_error!(value) if result.nil?
-            result
-          else
-            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
-          end
-        end
-      end
-    end
-  end
-end