easy_talk_two 1.1.0

data/lib/easy_talk/builders/integer_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for integer properties.
+    class IntegerBuilder < BaseBuilder
+      extend T::Sig
+      VALID_OPTIONS = {
+        minimum: { type: Integer, key: :minimum },
+        maximum: { type: Integer, key: :maximum },
+        exclusive_minimum: { type: Integer, key: :exclusiveMinimum },
+        exclusive_maximum: { type: Integer, key: :exclusiveMaximum },
+        multiple_of: { type: Integer, key: :multipleOf },
+        enum: { type: T::Array[Integer], key: :enum },
+        const: { type: Integer, key: :const },
+        default: { type: Integer, key: :default }
+      }.freeze
+
+      # Initializes a new instance of the IntegerBuilder class.
+      sig { params(name: Symbol, constraints: Hash).void }
+      def initialize(name, constraints = {})
+        super(name, { type: 'integer' }, constraints, VALID_OPTIONS)
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/null_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # builder class for Null properties.
+    class NullBuilder < BaseBuilder
+      # Initializes a new instance of the NullBuilder class.
+      sig { params(name: Symbol, _constraints: Hash).void }
+      def initialize(name, _constraints = {})
+        super(name, { type: 'null' }, {}, {})
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/number_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for number properties.
+    class NumberBuilder < BaseBuilder
+      VALID_OPTIONS = {
+        multiple_of: { type: T.any(Integer, Float), key: :multipleOf },
+        minimum: { type: T.any(Integer, Float), key: :minimum },
+        maximum: { type: T.any(Integer, Float), key: :maximum },
+        exclusive_minimum: { type: T.any(Integer, Float), key: :exclusiveMinimum },
+        exclusive_maximum: { type: T.any(Integer, Float), key: :exclusiveMaximum },
+        enum: { type: T::Array[T.any(Integer, Float)], key: :enum },
+        const: { type: T.any(Integer, Float), key: :const },
+        default: { type: T.any(Integer, Float), key: :default }
+      }.freeze
+
+      # Initializes a new instance of the NumberBuilder class.
+      sig { params(name: Symbol, constraints: Hash).void }
+      def initialize(name, constraints = {})
+        super(name, { type: 'number' }, constraints, VALID_OPTIONS)
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/object_builder.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    #
+    # ObjectBuilder is responsible for turning a SchemaDefinition of an "object" type
+    # into a validated JSON Schema hash. It:
+    #
+    # 1) Recursively processes the schema's :properties,
+    # 2) Determines which properties are required (unless optional),
+    # 3) Handles sub-schema composition (allOf, anyOf, oneOf, not),
+    # 4) Produces the final object-level schema hash.
+    #
+    class ObjectBuilder < BaseBuilder
+      extend T::Sig
+
+      # Required by BaseBuilder: recognized schema options for "object" types
+      VALID_OPTIONS = {
+        properties: { type: T::Hash[T.any(Symbol, String), T.untyped], key: :properties },
+        additional_properties: { type: T::Boolean, key: :additionalProperties },
+        subschemas: { type: T::Array[T.untyped], key: :subschemas },
+        required: { type: T::Array[T.any(Symbol, String)], key: :required },
+        defs: { type: T.untyped, key: :$defs },
+        allOf: { type: T.untyped, key: :allOf },
+        anyOf: { type: T.untyped, key: :anyOf },
+        oneOf: { type: T.untyped, key: :oneOf },
+        not: { type: T.untyped, key: :not }
+      }.freeze
+
+      sig { params(schema_definition: EasyTalk::SchemaDefinition).void }
+      def initialize(schema_definition)
+        # Keep a reference to the original schema definition
+        @schema_definition = schema_definition
+        # Duplicate the raw schema hash so we can mutate it safely
+        @original_schema = schema_definition.schema.dup
+
+        # We'll collect required property names in this Set
+        @required_properties = Set.new
+
+        # Usually the name is a string (class name). Fallback to :klass if nil.
+        name_for_builder = schema_definition.name ? schema_definition.name.to_sym : :klass
+
+        # Build the base structure: { type: 'object' } plus any top-level options
+        super(
+          name_for_builder,
+          { type: 'object' },    # minimal "object" structure
+          build_options_hash,    # method below merges & cleans final top-level keys
+          VALID_OPTIONS
+        )
+      end
+
+      private
+
+      ##
+      # Main aggregator: merges the top-level schema keys (like :properties, :subschemas)
+      # into a single hash that we'll feed to BaseBuilder.
+      def build_options_hash
+        # Start with a copy of the raw schema
+        merged = @original_schema.dup
+
+        # Extract and build sub-schemas first (handles allOf/anyOf/oneOf references, etc.)
+        process_subschemas(merged)
+
+        # Build :properties into a final form (and find "required" props)
+        merged[:properties] = build_properties(merged.delete(:properties))
+
+        # Populate the final "required" array from @required_properties
+        merged[:required] = @required_properties.to_a if @required_properties.any?
+
+        # Add additionalProperties: false by default if not explicitly set
+        merged[:additional_properties] = false unless merged.key?(:additional_properties)
+
+        # Prune empty or nil values so we don't produce stuff like "properties": {} unnecessarily
+        merged.reject! { |_k, v| v.nil? || v == {} || v == [] }
+
+        merged
+      end
+
+      ##
+      # Given the property definitions hash, produce a new hash of
+      # { property_name => [Property or nested schema builder result] }.
+      #
+      def build_properties(properties_hash)
+        return {} unless properties_hash.is_a?(Hash)
+
+        # Cache with a key based on property name and its full configuration
+        @properties_cache ||= {}
+
+        properties_hash.each_with_object({}) do |(prop_name, prop_options), result|
+          cache_key = [prop_name, prop_options].hash
+
+          # Use cache if the exact property and configuration have been processed before
+          @properties_cache[cache_key] ||= begin
+            mark_required_unless_optional(prop_name, prop_options)
+            build_property(prop_name, prop_options)
+          end
+
+          result[prop_name] = @properties_cache[cache_key]
+        end
+      end
+
+      ##
+      # Decide if a property should be required. If it's optional or nilable,
+      # we won't include it in the "required" array.
+      #
+      def mark_required_unless_optional(prop_name, prop_options)
+        return if property_optional?(prop_options)
+
+        @required_properties.add(prop_name)
+      end
+
+      ##
+      # Returns true if the property is declared optional.
+      #
+      def property_optional?(prop_options)
+        # Check constraints[:optional]
+        return true if prop_options.dig(:constraints, :optional)
+
+        # Check for nil_optional config to determine if nilable should also mean optional
+        if prop_options[:type].respond_to?(:nilable?) && prop_options[:type].nilable?
+          return EasyTalk.configuration.nilable_is_optional
+        end
+
+        false
+      end
+
+      ##
+      # Builds a single property. Could be a nested schema if it has sub-properties,
+      # or a standard scalar property (String, Integer, etc.).
+      #
+      def build_property(prop_name, prop_options)
+        @property_cache ||= {}
+
+        # Memoize so we only build each property once
+        @property_cache[prop_name] ||= begin
+          # Remove optional constraints from the property
+          constraints = prop_options[:constraints].except(:optional)
+          # Normal property: e.g. { type: String, constraints: {...} }
+          Property.new(prop_name, prop_options[:type], constraints)
+        end
+      end
+
+      ##
+      # Process top-level composition keywords (e.g. allOf, anyOf, oneOf),
+      # converting them to definitions + references if appropriate.
+      #
+      def process_subschemas(schema_hash)
+        subschemas = schema_hash.delete(:subschemas) || []
+        subschemas.each do |subschema|
+          add_defs_from_subschema(schema_hash, subschema)
+          add_refs_from_subschema(schema_hash, subschema)
+        end
+      end
+
+      ##
+      # For each item in the composer, add it to :defs so that we can reference it later.
+      #
+      def add_defs_from_subschema(schema_hash, subschema)
+        # Build up a hash of class_name => schema for each sub-item
+        definitions = subschema.items.each_with_object({}) do |item, acc|
+          acc[item.name] = item.schema
+        end
+        # Merge or create :defs
+        existing_defs = schema_hash[:defs] || {}
+        schema_hash[:defs] = existing_defs.merge(definitions)
+      end
+
+      ##
+      # Add references to the schema for each sub-item in the composer
+      # e.g. { "$ref": "#/$defs/SomeClass" }
+      #
+      def add_refs_from_subschema(schema_hash, subschema)
+        references = subschema.items.map { |item| { '$ref': item.ref_template } }
+        schema_hash[subschema.name] = references
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/string_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+require 'sorbet-runtime' # Add the import statement for the T module
+
+module EasyTalk
+  module Builders
+    # Builder class for string properties.
+    class StringBuilder < BaseBuilder
+      extend T::Sig
+      VALID_OPTIONS = {
+        format: { type: String, key: :format },
+        pattern: { type: String, key: :pattern },
+        min_length: { type: Integer, key: :minLength },
+        max_length: { type: Integer, key: :maxLength },
+        enum: { type: T::Array[String], key: :enum },
+        const: { type: String, key: :const },
+        default: { type: String, key: :default }
+      }.freeze
+
+      sig { params(name: Symbol, constraints: Hash).void }
+      def initialize(name, constraints = {})
+        super(name, { type: 'string' }, constraints, VALID_OPTIONS)
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/temporal_builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'string_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for temporal properties (date, datetime, time).
+    class TemporalBuilder < StringBuilder
+      # Initializes a new instance of the TemporalBuilder class.
+      #
+      # @param property_name [Symbol] The name of the property.
+      # @param options [Hash] The options for the builder.
+      # @param format [String] The format of the temporal property (date, date-time, time).
+      def initialize(property_name, options = {}, format = nil)
+        super(property_name, options)
+        @format = format
+      end
+
+      # Modifies the schema to include the format constraint for a temporal property.
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def schema
+        super.tap do |schema|
+          schema[:format] = @format if @format
+        end
+      end
+
+      # Builder class for date properties.
+      class DateBuilder < TemporalBuilder
+        def initialize(property_name, options = {})
+          super(property_name, options, 'date')
+        end
+      end
+
+      # Builder class for datetime properties.
+      class DatetimeBuilder < TemporalBuilder
+        def initialize(property_name, options = {})
+          super(property_name, options, 'date-time')
+        end
+      end
+
+      # Builder class for time properties.
+      class TimeBuilder < TemporalBuilder
+        def initialize(property_name, options = {})
+          super(property_name, options, 'time')
+        end
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/typed_array_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'collection_helpers'
+
+module EasyTalk
+  module Builders
+    # Builder class for array properties.
+    class TypedArrayBuilder < BaseBuilder
+      extend CollectionHelpers
+      extend T::Sig
+
+      VALID_OPTIONS = {
+        min_items: { type: Integer, key: :minItems },
+        max_items: { type: Integer, key: :maxItems },
+        unique_items: { type: T::Boolean, key: :uniqueItems },
+        enum: { type: T::Array[T.untyped], key: :enum },
+        const: { type: T::Array[T.untyped], key: :const }
+      }.freeze
+
+      attr_reader :type
+
+      sig { params(name: Symbol, type: T.untyped, constraints: Hash).void }
+      def initialize(name, type, constraints = {})
+        @name = name
+        @type = type
+        update_option_types
+        super(name, { type: 'array' }, constraints, VALID_OPTIONS)
+      end
+
+      private
+
+      # Modifies the schema to include the `items` property.
+      #
+      # @return [Hash] The built schema.
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def schema
+        super.tap do |schema|
+          schema[:items] = Property.new(@name, inner_type, {}).build
+        end
+      end
+
+      def inner_type
+        return unless type.is_a?(T::Types::TypedArray)
+
+        type.type.raw_type
+      end
+
+      sig { void }
+      # Updates the option types for the array builder.
+      def update_option_types
+        VALID_OPTIONS[:enum][:type] = T::Array[inner_type]
+        VALID_OPTIONS[:const][:type] = T::Array[inner_type]
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/union_builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'collection_helpers'
+
+module EasyTalk
+  module Builders
+    # Base builder class for array-type properties.
+    class UnionBuilder
+      extend CollectionHelpers
+      extend T::Sig
+
+      sig { params(name: Symbol, type: T.untyped, constraints: T.untyped).void }
+      def initialize(name, type, constraints)
+        @name = name
+        @type = type
+        @constraints = constraints
+        @context = {}
+      end
+
+      def build
+        @context[@name] = {
+          'anyOf' => schemas
+        }
+      end
+
+      def schemas
+        types.map do |type|
+          Property.new(@name, type, @constraints).build
+        end
+      end
+
+      def types
+        @type.types
+      end
+    end
+  end
+end

data/lib/easy_talk/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  class Configuration
+    attr_accessor :exclude_foreign_keys, :exclude_associations, :excluded_columns,
+                  :exclude_primary_key, :exclude_timestamps, :default_additional_properties,
+                  :nilable_is_optional
+
+    def initialize
+      @exclude_foreign_keys = true
+      @exclude_associations = true
+      @excluded_columns = []
+      @exclude_primary_key = true  # New option, defaulting to true
+      @exclude_timestamps = true   # New option, defaulting to true
+      @default_additional_properties = false
+      @nilable_is_optional = false
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/easy_talk/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  class Error < StandardError; end
+  class ConstraintError < Error; end
+  class UnknownOptionError < Error; end
+  class InvalidPropertyNameError < Error; end
+end

data/lib/easy_talk/errors_helper.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module ErrorHelper
+    def self.raise_constraint_error(property_name:, constraint_name:, expected:, got:)
+      message = "Error in property '#{property_name}': Constraint '#{constraint_name}' expects #{expected}, " \
+                "but received #{got.inspect} (#{got.class})."
+      raise ConstraintError, message
+    end
+
+    def self.raise_array_constraint_error(property_name:, constraint_name:, index:, expected:, got:)
+      message = "Error in property '#{property_name}': Constraint '#{constraint_name}' at index #{index} " \
+                "expects #{expected}, but received #{got.inspect} (#{got.class})."
+      raise ConstraintError, message
+    end
+
+    def self.raise_unknown_option_error(property_name:, option:, valid_options:)
+      option = option.keys.first if option.is_a?(Hash)
+      message = "Unknown option '#{option}' for property '#{property_name}'. " \
+                "Valid options are: #{valid_options.join(', ')}."
+      raise UnknownOptionError, message
+    end
+
+    def self.extract_inner_type(type_info)
+      # No change needed here
+      if type_info.respond_to?(:type) && type_info.type.respond_to?(:raw_type)
+        type_info.type.raw_type
+      # special boolean handling
+      elsif type_info.try(:type).try(:name) == 'T::Boolean'
+        T::Boolean
+      elsif type_info.respond_to?(:type_parameter)
+        type_info.type_parameter
+      elsif type_info.respond_to?(:raw_a) && type_info.respond_to?(:raw_b)
+        # Handle SimplePairUnion types
+        [type_info.raw_a, type_info.raw_b]
+      elsif type_info.respond_to?(:types)
+        # Handle complex union types
+        type_info.types.map { |t| t.respond_to?(:raw_type) ? t.raw_type : t }
+      else
+        # Fallback to something sensible
+        Object
+      end
+    end
+
+    def self.validate_typed_array_values(property_name:, constraint_name:, type_info:, array_value:)
+      # Skip validation if it's not actually an array
+      return unless array_value.is_a?(Array)
+
+      # Extract the inner type from the array type definition
+      inner_type = extract_inner_type(type_info)
+
+      # Check each element of the array
+      array_value.each_with_index do |element, index|
+        if inner_type.is_a?(Array)
+          # For union types, check if the element matches any of the allowed types
+          unless inner_type.any? { |t| element.is_a?(t) }
+            expected = inner_type.join(' or ')
+            raise_array_constraint_error(
+              property_name: property_name,
+              constraint_name: constraint_name,
+              index: index,
+              expected: expected,
+              got: element
+            )
+          end
+        else
+          # For single types, just check against that type
+          next if [true, false].include?(element)
+
+          unless element.is_a?(inner_type)
+            raise_array_constraint_error(
+              property_name: property_name,
+              constraint_name: constraint_name,
+              index: index,
+              expected: inner_type,
+              got: element
+            )
+          end
+        end
+      end
+    end
+
+    def self.validate_constraint_value(property_name:, constraint_name:, value_type:, value:)
+      return if value.nil?
+
+      if value_type.to_s.include?('Boolean')
+        return if value.is_a?(Array) && value.all? { |v| [true, false].include?(v) }
+
+        unless [true, false].include?(value)
+          raise_constraint_error(
+            property_name: property_name,
+            constraint_name: constraint_name,
+            expected: 'Boolean (true or false)',
+            got: value
+          )
+        end
+        return
+      end
+
+      # Handle simple scalar types (String, Integer, etc.)
+      if value_type.is_a?(Class)
+        unless value.is_a?(value_type)
+          raise_constraint_error(
+            property_name: property_name,
+            constraint_name: constraint_name,
+            expected: value_type,
+            got: value
+          )
+        end
+      # Handle array types specifically
+      elsif value_type.class.name.include?('TypedArray') ||
+            (value_type.respond_to?(:to_s) && value_type.to_s.include?('T::Array'))
+        # This is an array type, validate it
+        validate_typed_array_values(
+          property_name: property_name,
+          constraint_name: constraint_name,
+          type_info: value_type,
+          array_value: value
+        )
+      # Handle Sorbet type objects
+      elsif value_type.class.ancestors.include?(T::Types::Base)
+        # Extract the inner type
+        inner_type = extract_inner_type(value_type)
+
+        if inner_type.is_a?(Array)
+          # For union types, check if the value matches any of the allowed types
+          unless inner_type.any? { |t| value.is_a?(t) }
+            expected = inner_type.join(' or ')
+            raise_constraint_error(
+              property_name: property_name,
+              constraint_name: constraint_name,
+              expected: expected,
+              got: value
+            )
+          end
+        elsif !value.is_a?(inner_type)
+          raise_constraint_error(
+            property_name: property_name,
+            constraint_name: constraint_name,
+            expected: inner_type,
+            got: value
+          )
+        end
+      end
+    end
+  end
+end

data/lib/easy_talk/keywords.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  KEYWORDS = %i[
+    description
+    type
+    title
+    property
+    required
+    items
+    additional_items
+    pattern_properties
+    additional_properties
+    dependencies
+    dependent_required
+    format
+    content_media_type
+    content_encoding
+    enum
+    const
+    default
+    examples
+    max_length
+    min_length
+    pattern
+    maximum
+    exclusive_maximum
+    minimum
+    exclusive_minimum
+    multiple_of
+    max_items
+    min_items
+    unique_items
+    max_properties
+    min_properties
+  ].freeze
+end