zero_ruby 0.1.0.alpha1

data/lib/zero_ruby/types/iso8601_date.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "base_type"
+
+module ZeroRuby
+  module Types
+    # ISO8601Date type for date values.
+    # Accepts ISO8601 formatted date strings, Date, Time, and DateTime objects.
+    # Coerces to Date.
+    class ISO8601Date < BaseType
+      class << self
+        def name
+          "ISO8601Date"
+        end
+
+        def coerce_input(value, _ctx = nil)
+          return nil if value.nil?
+
+          case value
+          when ::Date
+            value
+          when ::Time, ::DateTime
+            value.to_date
+          when ::String
+            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
+            parse_iso8601_date(value)
+          else
+            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
+          end
+        end
+
+        private
+
+        def parse_iso8601_date(value)
+          Date.iso8601(value)
+        rescue ArgumentError
+          coercion_error!(value, "#{format_value_for_error(value)} is not a valid ISO8601 date")
+        end
+      end
+    end
+  end
+end

data/lib/zero_ruby/types/iso8601_date_time.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "base_type"
+
+module ZeroRuby
+  module Types
+    # ISO8601DateTime type for datetime values.
+    # Accepts ISO8601 formatted strings, Time, and DateTime objects.
+    # Coerces to Time.
+    class ISO8601DateTime < BaseType
+      class << self
+        def name
+          "ISO8601DateTime"
+        end
+
+        def coerce_input(value, _ctx = nil)
+          return nil if value.nil?
+
+          case value
+          when ::Time
+            value
+          when ::DateTime
+            value.to_time
+          when ::String
+            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
+            parse_iso8601(value)
+          else
+            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
+          end
+        end
+
+        private
+
+        def parse_iso8601(value)
+          Time.iso8601(value)
+        rescue ArgumentError
+          coercion_error!(value, "#{format_value_for_error(value)} is not a valid ISO8601 datetime")
+        end
+      end
+    end
+  end
+end

data/lib/zero_ruby/types/string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base_type"
+
+module ZeroRuby
+  module Types
+    class String < BaseType
+      class << self
+        def name
+          "String"
+        end
+
+        def coerce_input(value, _ctx = nil)
+          return nil if value.nil?
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/zero_ruby/typescript_generator.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module ZeroRuby
+  # Generates TypeScript type definitions from registered mutations.
+  # Similar to graphql-codegen, this introspects mutation argument definitions
+  # and generates corresponding TypeScript interfaces.
+  #
+  # @example
+  #   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"
+    }.freeze
+
+    def initialize(schema)
+      @schema = schema
+      @input_objects = {}
+    end
+
+    # Generate TypeScript definitions
+    # @return [String] Complete TypeScript type definitions
+    def generate
+      collect_input_objects
+
+      parts = [
+        generate_header,
+        generate_scalars,
+        generate_input_objects,
+        generate_mutation_args,
+        generate_mutation_map
+      ]
+
+      parts.compact.join("\n")
+    end
+
+    private
+
+    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
+
+    def collect_input_objects
+      @schema.mutations.each do |_name, handler_class|
+        collect_input_objects_from_arguments(handler_class.arguments)
+      end
+    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)
+          unless @input_objects.key?(type_name)
+            @input_objects[type_name] = arg.type
+            # Recursively collect nested InputObjects
+            collect_input_objects_from_arguments(arg.type.arguments)
+          end
+        end
+      end
+    end
+
+    def generate_input_objects
+      return nil if @input_objects.empty?
+
+      interfaces = @input_objects.map do |name, klass|
+        generate_interface(name, klass.arguments)
+      end
+
+      "\n" + interfaces.join("\n\n")
+    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)
+      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};"
+      end
+
+      <<~TS.strip
+        /** #{name} */
+        export interface #{name} {
+        #{fields.join("\n")}
+        }
+      TS
+    end
+
+    def generate_mutation_map
+      return nil if @schema.mutations.empty?
+
+      entries = @schema.mutations.map do |name, _handler_class|
+        interface_name = to_interface_name(name)
+        "  \"#{name}\": #{interface_name};"
+      end
+
+      <<~TS
+
+        /** All mutations mapped by name */
+        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
+
+      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"
+      end
+    end
+
+    def input_object_type?(type)
+      defined?(ZeroRuby::InputObject) && type.is_a?(Class) && type < ZeroRuby::InputObject
+    end
+
+    def extract_type_name(type)
+      # Get just the class name without module prefixes
+      type.name.split("::").last
+    end
+
+    # Convert mutation name to interface name
+    # "todo.create" -> "TodoCreateArgs"
+    # "posts.bulk_update" -> "PostsBulkUpdateArgs"
+    def to_interface_name(mutation_name)
+      parts = mutation_name.to_s.split(".")
+      pascal = parts.map { |part| to_pascal_case(part) }.join
+      "#{pascal}Args"
+    end
+
+    # Convert snake_case to PascalCase
+    def to_pascal_case(str)
+      str.to_s.split("_").map(&:capitalize).join
+    end
+
+    # Convert snake_case to camelCase
+    def to_camel_case(name)
+      parts = name.to_s.split("_")
+      return parts.first if parts.length == 1
+      parts.first + parts[1..].map(&:capitalize).join
+    end
+  end
+end

data/lib/zero_ruby/validator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ZeroRuby
+  # Base class for argument validators.
+  # Inspired by graphql-ruby's validation system.
+  class Validator
+    class << self
+      # Registry of validator classes by name
+      def validators
+        @validators ||= {}
+      end
+
+      # Register a validator class
+      def register(name, klass)
+        validators[name.to_sym] = klass
+      end
+
+      # Get a validator class by name
+      def get(name)
+        validators[name.to_sym]
+      end
+
+      # Run all validations on a value
+      # @param validators_config [Hash] Configuration hash for validators
+      # @param mutation [ZeroRuby::Mutation] The mutation instance
+      # @param ctx [Hash] The context hash
+      # @param value [Object] The value to validate
+      # @return [Array<String>] Array of error messages
+      def validate!(validators_config, mutation, ctx, value)
+        return [] if validators_config.nil? || validators_config.empty?
+
+        errors = []
+
+        validators_config.each do |validator_name, config|
+          validator_class = get(validator_name)
+          next unless validator_class
+
+          validator = validator_class.new(config)
+          result = validator.validate(mutation, ctx, value)
+          errors.concat(Array(result)) if result
+        end
+
+        errors
+      end
+    end
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Validate a value
+    # @param mutation [ZeroRuby::Mutation] The mutation instance
+    # @param ctx [Hash] The context hash
+    # @param value [Object] The value to validate
+    # @return [String, Array<String>, nil] Error message(s) or nil if valid
+    def validate(mutation, ctx, value)
+      raise NotImplementedError, "Subclasses must implement #validate"
+    end
+
+    protected
+
+    # Helper to format error messages
+    def error_message(message)
+      message
+    end
+  end
+end

data/lib/zero_ruby/validators/allow_blank_validator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates that a value is not blank when allow_blank is false.
+    #
+    # @example
+    #   validates: { allow_blank: false }
+    class AllowBlankValidator < Validator
+      def validate(mutation, ctx, value)
+        # If allow_blank is true (or truthy), blank values are allowed
+        return nil if config == true || config
+
+        # Check if value is blank (nil, empty string, or whitespace-only string)
+        is_blank = value.nil? ||
+          (value.respond_to?(:empty?) && value.empty?) ||
+          (value.is_a?(::String) && value.strip.empty?)
+
+        if is_blank
+          return "can't be blank"
+        end
+
+        nil
+      end
+    end
+
+    Validator.register(:allow_blank, AllowBlankValidator)
+  end
+end

data/lib/zero_ruby/validators/allow_null_validator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates that a value is not null when allow_null is false.
+    #
+    # @example
+    #   validates: { allow_null: false }
+    class AllowNullValidator < Validator
+      def validate(mutation, ctx, value)
+        # If allow_null is true (or truthy), null values are allowed
+        return nil if config == true || config
+
+        if value.nil?
+          return "can't be null"
+        end
+
+        nil
+      end
+    end
+
+    Validator.register(:allow_null, AllowNullValidator)
+  end
+end

data/lib/zero_ruby/validators/exclusion_validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates that a value is NOT included in a given set.
+    #
+    # @example
+    #   validates: { exclusion: { in: ["admin", "root", "system"] } }
+    class ExclusionValidator < Validator
+      def validate(mutation, ctx, value)
+        return nil if value.nil?
+
+        excluded = config[:in] || config[:within]
+        return nil unless excluded
+
+        if excluded.respond_to?(:include?) ? excluded.include?(value) : excluded.cover?(value)
+          message = config[:message] || "is reserved"
+          return message
+        end
+
+        nil
+      end
+    end
+
+    Validator.register(:exclusion, ExclusionValidator)
+  end
+end

data/lib/zero_ruby/validators/format_validator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates that a value matches a regular expression.
+    #
+    # @example
+    #   validates: { format: { with: /\A[a-z0-9_]+\z/ } }
+    #   validates: { format: { without: /[<>]/ } }
+    class FormatValidator < Validator
+      def validate(mutation, ctx, value)
+        return nil if value.nil?
+
+        str_value = value.to_s
+        errors = []
+
+        if config[:with] && !str_value.match?(config[:with])
+          message = config[:message] || "is invalid"
+          errors << message
+        end
+
+        if config[:without] && str_value.match?(config[:without])
+          message = config[:message] || "is invalid"
+          errors << message
+        end
+
+        errors.empty? ? nil : errors
+      end
+    end
+
+    Validator.register(:format, FormatValidator)
+  end
+end

data/lib/zero_ruby/validators/inclusion_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates that a value is included in a given set.
+    #
+    # @example
+    #   validates: { inclusion: { in: ["draft", "published", "archived"] } }
+    #   validates: { inclusion: { in: 1..10 } }
+    class InclusionValidator < Validator
+      def validate(mutation, ctx, value)
+        return nil if value.nil?
+
+        allowed = config[:in] || config[:within]
+        return nil unless allowed
+
+        unless allowed.respond_to?(:include?) ? allowed.include?(value) : allowed.cover?(value)
+          message = config[:message] || "is not included in the list"
+          return message
+        end
+
+        nil
+      end
+    end
+
+    Validator.register(:inclusion, InclusionValidator)
+  end
+end

data/lib/zero_ruby/validators/length_validator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates the length of a string or array value.
+    #
+    # @example
+    #   validates: { length: { minimum: 1, maximum: 200 } }
+    #   validates: { length: { is: 10 } }
+    #   validates: { length: { in: 5..10 } }
+    class LengthValidator < Validator
+      def validate(mutation, ctx, value)
+        return nil if value.nil?
+
+        length = value.respond_to?(:length) ? value.length : value.to_s.length
+        errors = []
+
+        if config[:minimum] && length < config[:minimum]
+          errors << "is too short (minimum is #{config[:minimum]})"
+        end
+
+        if config[:maximum] && length > config[:maximum]
+          errors << "is too long (maximum is #{config[:maximum]})"
+        end
+
+        if config[:is] && length != config[:is]
+          errors << "is the wrong length (should be #{config[:is]})"
+        end
+
+        if config[:in] && !config[:in].cover?(length)
+          errors << "length is not in #{config[:in]}"
+        end
+
+        errors.empty? ? nil : errors
+      end
+    end
+
+    Validator.register(:length, LengthValidator)
+  end
+end

data/lib/zero_ruby/validators/numericality_validator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module ZeroRuby
+  module Validators
+    # Validates numeric constraints on a value.
+    #
+    # @example
+    #   validates: { numericality: { greater_than: 0 } }
+    #   validates: { numericality: { less_than_or_equal_to: 100 } }
+    #   validates: { numericality: { equal_to: 42 } }
+    #   validates: { numericality: { odd: true } }
+    #   validates: { numericality: { even: true } }
+    class NumericalityValidator < Validator
+      def validate(mutation, ctx, value)
+        return nil if value.nil?
+
+        unless value.is_a?(Numeric)
+          return "is not a number"
+        end
+
+        errors = []
+
+        if config[:greater_than] && value <= config[:greater_than]
+          errors << "must be greater than #{config[:greater_than]}"
+        end
+
+        if config[:greater_than_or_equal_to] && value < config[:greater_than_or_equal_to]
+          errors << "must be greater than or equal to #{config[:greater_than_or_equal_to]}"
+        end
+
+        if config[:less_than] && value >= config[:less_than]
+          errors << "must be less than #{config[:less_than]}"
+        end
+
+        if config[:less_than_or_equal_to] && value > config[:less_than_or_equal_to]
+          errors << "must be less than or equal to #{config[:less_than_or_equal_to]}"
+        end
+
+        if config[:equal_to] && value != config[:equal_to]
+          errors << "must be equal to #{config[:equal_to]}"
+        end
+
+        if config[:other_than] && value == config[:other_than]
+          errors << "must be other than #{config[:other_than]}"
+        end
+
+        if config[:odd] && value.to_i.even?
+          errors << "must be odd"
+        end
+
+        if config[:even] && value.to_i.odd?
+          errors << "must be even"
+        end
+
+        errors.empty? ? nil : errors
+      end
+    end
+
+    Validator.register(:numericality, NumericalityValidator)
+  end
+end

data/lib/zero_ruby/version.rb

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

data/lib/zero_ruby/zero_client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ZeroRuby
+  # ZeroClient model for LMID (Last Mutation ID) tracking.
+  # This model interfaces with Zero's zero_0.clients table, which is
+  # automatically created and managed by zero-cache.
+  #
+  # Table Schema (created by zero-cache):
+  #   clientGroupID  TEXT   - The client group identifier
+  #   clientID       TEXT   - The client identifier
+  #   lastMutationID INTEGER - The last processed mutation ID for this client
+  #   userID         TEXT   - The user identifier (optional)
+  #
+  # @note Do NOT run migrations for this table - zero-cache manages it.
+  # @see https://zero.rocicorp.dev/docs/mutators
+  class ZeroClient < ActiveRecord::Base
+    self.table_name = "zero_0.clients"
+    self.primary_key = nil # Composite key: clientGroupID + clientID
+
+    def readonly?
+      # Allow updates through the LMID store's direct SQL
+      false
+    end
+  end
+end