servus 0.7.0 → 1.0.0

data/lib/servus/schema.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'did_you_mean'
+
+module Servus
+  # Registry of reusable JSON Schema fragments, and the entry point for
+  # compiling a schema that references them.
+  #
+  # Servus services and events declare their contracts inline via the +schema+
+  # DSL. That keeps a service's inputs and outputs visible in the file that
+  # implements it. The cost of inline-only declaration is duplication: the same
+  # +amount+ or +timestamp+ shape gets copy-pasted across every service that
+  # touches it.
+  #
+  # Registered fragments close that gap without giving up explicitness. A
+  # fragment is registered under a key, and services reference into it with a
+  # standard JSON Schema +$ref+. A service that references a shared type is
+  # still explicitly declaring that type — it just names it once.
+  #
+  # @example Registering a fragment
+  #   Servus::Schema.register('core', {
+  #     '$defs' => {
+  #       'amount' => { 'type' => 'integer', 'minimum' => 0 }
+  #     }
+  #   })
+  #
+  # @example Referencing it from a service
+  #   class Treasury::TransferGold::Service < Servus::Base
+  #     schema arguments: {
+  #       type: 'object',
+  #       required: ['gold_dragons'],
+  #       properties: {
+  #         gold_dragons: { '$ref' => '#/core/$defs/amount' }
+  #       }
+  #     }
+  #   end
+  #
+  # Lookups never return nil. An unregistered key raises {UnknownKeyError} at
+  # the point of use, because the alternative — silently skipping validation for
+  # a service that appears to declare a contract — is the worst failure mode
+  # this system has.
+  #
+  # @see Servus::Schema::Compiler
+  # @see Servus::Base.schema
+  module Schema
+    @registry = {}.freeze
+    @cache = Cache.new
+    @mutex = Mutex.new
+
+    class << self
+      # Memoized ref resolutions and the generation counter derived from them.
+      #
+      # @return [Servus::Schema::Cache]
+      # @api private
+      attr_reader :cache
+
+      # Monotonic counter bumped whenever the registry changes.
+      #
+      # Consumers memoize compiled schemas alongside the generation they were
+      # compiled under, and recompile when it moves. That makes registry
+      # updates propagate without any explicit dependency tracking.
+      #
+      # @return [Integer]
+      def generation = cache.generation
+
+      # Registers a reusable schema fragment under +key+.
+      #
+      # Re-registering an equal value is a silent no-op, so calling this from a
+      # Rails +to_prepare+ block is safe. Re-registering a *different* value
+      # replaces it, logs an override, and bumps {generation} — which
+      # invalidates every compiled schema that referenced it.
+      #
+      # @param key [String, Symbol] the fragment key, referenced as +#/<key>/...+
+      # @param fragment [Hash] the schema fragment
+      # @return [ActiveSupport::HashWithIndifferentAccess] the normalized fragment
+      # @raise [InvalidKeyError] if the key is blank or contains a +/+
+      # @raise [ArgumentError] if the fragment is not a Hash
+      #
+      # @example
+      #   Servus::Schema.register('core', { '$defs' => { 'id' => { 'type' => 'integer' } } })
+      def register(key, fragment)
+        key = normalize_key(key)
+        normalized = normalize_fragment(key, fragment)
+
+        cache.invalidate! if store(key, normalized)
+
+        normalized
+      end
+
+      # Returns a registered fragment, or a definition within one.
+      #
+      # Given no path, returns the whole fragment. Given path segments, walks
+      # them as literal keys — the same addressing a +$ref+ uses, so
+      # +fetch(key, *path)+ reads exactly what +ref(key, *path)+ points at.
+      #
+      # A missing path raises rather than returning nil. Reaching for the
+      # fragment and calling +dig+ would return nil on a typo, which is the
+      # silent failure this registry exists to prevent.
+      #
+      # Fragments are returned as authored, with any +$ref+s intact. Use
+      # {compile} to resolve them.
+      #
+      # @param key [String, Symbol] the fragment key
+      # @param path [Array<String, Symbol>] segments to walk within the fragment
+      # @return [ActiveSupport::HashWithIndifferentAccess, Object] the frozen fragment or definition
+      # @raise [UnknownKeyError] if nothing is registered under +key+
+      # @raise [RefNotFoundError] if the path is not present in the fragment
+      #
+      # @example
+      #   Servus::Schema.fetch('core')
+      #   Servus::Schema.fetch('core', '$defs', 'amount')
+      def fetch(key, *path)
+        key = key.to_s
+        fragment = @registry.fetch(key) { raise UnknownKeyError.for(key, available: @registry.keys) }
+
+        Path.walk(fragment, key, path.map(&:to_s))
+      end
+
+      # Returns a fragment, or a definition within one, with all +$ref+s resolved.
+      #
+      # The compiled counterpart to {fetch}: same addressing, but the result is
+      # self-contained and ready to validate against. This is usually what
+      # application code outside a service wants — a controller validating a
+      # request body, a serializer checking a response shape.
+      #
+      # Results are memoized, so asking repeatedly for the same address is cheap.
+      #
+      # @param key [String, Symbol] the fragment key
+      # @param path [Array<String, Symbol>] segments to walk within the fragment
+      # @return [Hash, Object] the compiled fragment or definition
+      # @raise [UnknownKeyError] if nothing is registered under +key+
+      # @raise [RefNotFoundError] if the path is not present in the fragment
+      # @raise [Error] if a ref within it cannot be resolved
+      #
+      # @example
+      #   Servus::Schema.resolve('endpoints::trades::create', '$defs', 'request')
+      #   # => { "type" => "object", "properties" => { "price" => { "type" => "integer" } } }
+      def resolve(key, *path)
+        pointer = ref(key, *path)
+
+        compile(pointer, context: "schema #{pointer['$ref']}")
+      end
+
+      # Compiles every registered fragment, resolving all +$ref+s.
+      #
+      # Returns a hash of key to compiled fragment, mirroring the registry's own
+      # shape so keys stay addressable and the result serializes straight to
+      # JSON. Useful for producing a single schema asset for an API description,
+      # a docs build, client codegen, or a CI freshness check.
+      #
+      # @return [Hash{String => Hash}] every fragment, refs resolved
+      # @raise [Error] if any fragment contains a ref that cannot be resolved
+      #
+      # @example
+      #   File.write('schema.json', JSON.pretty_generate(Servus::Schema.compile_all))
+      def compile_all
+        keys.to_h { |key| [key, compile(fetch(key), context: "schema fragment #{key.inspect}")] }
+      end
+
+      # @return [Array<String>] registered keys, sorted
+      def keys
+        @registry.keys.sort
+      end
+
+      # Builds a +$ref+ pointing at a registered fragment.
+      #
+      # Prefer this over hand-writing ref strings — it is typo-proof in the
+      # separator and prefix, which are the parts people get wrong.
+      #
+      # @param key [String, Symbol] the fragment key
+      # @param path [Array<String, Symbol>] segments to walk within the fragment
+      # @return [Hash] a +$ref+ hash
+      #
+      # @example
+      #   Servus::Schema.ref('core', '$defs', 'amount')
+      #   # => { "$ref" => "#/core/$defs/amount" }
+      def ref(key, *path)
+        { '$ref' => "#/#{[key, *path].map(&:to_s).join('/')}" }
+      end
+
+      # Compiles a schema, replacing every +$ref+ with the fragment it names.
+      #
+      # @param schema [Hash, nil] the authored schema
+      # @param context [String, nil] label used in error messages, e.g.
+      #   "Treasury::TransferGold::Service arguments schema"
+      # @return [Hash, nil] the compiled schema, or nil if +schema+ was nil
+      # @raise [Error] if any ref cannot be resolved
+      def compile(schema, context: nil)
+        return nil if schema.nil?
+
+        Compiler.new(context: context).compile(schema)
+      end
+
+      # Clears the registry. Intended for test suites.
+      #
+      # @return [void]
+      def reset!
+        restore({}.freeze)
+      end
+
+      # Captures the registry state so a test can restore it afterwards.
+      #
+      # @return [Hash] an opaque snapshot for {restore}
+      # @api private
+      def snapshot
+        @registry
+      end
+
+      # Restores a snapshot taken by {snapshot}.
+      #
+      # @param snapshot [Hash]
+      # @return [void]
+      # @api private
+      def restore(snapshot)
+        @mutex.synchronize { @registry = snapshot }
+        cache.invalidate!
+      end
+
+      private
+
+      # Writes a normalized fragment into the registry.
+      #
+      # @param key [String]
+      # @param normalized [Hash] the normalized fragment
+      # @return [Boolean] whether the registry actually changed
+      # @api private
+      def store(key, normalized)
+        @mutex.synchronize do
+          existing = @registry[key]
+          return false if existing == normalized
+
+          Support::Logger.log_schema_override(key) if existing
+          @registry = @registry.merge(key => normalized).freeze
+        end
+
+        true
+      end
+
+      # @param key [String, Symbol]
+      # @return [String]
+      # @raise [InvalidKeyError]
+      # @api private
+      def normalize_key(key)
+        key = key.to_s
+
+        raise InvalidKeyError, 'schema fragment key cannot be blank' if key.strip.empty?
+
+        if key.include?('/')
+          raise InvalidKeyError, "schema fragment key #{key.inspect} cannot contain '/' — " \
+                                 'it is the separator in $ref paths, so the key would be unreferenceable'
+        end
+
+        key
+      end
+
+      # @param key [String] the key, for the error message
+      # @param fragment [Hash]
+      # @return [ActiveSupport::HashWithIndifferentAccess] deeply frozen
+      # @raise [ArgumentError] if the fragment is not a Hash
+      # @api private
+      def normalize_fragment(key, fragment)
+        unless fragment.is_a?(Hash)
+          raise ArgumentError, "schema fragment for #{key.inspect} must be a Hash, got #{fragment.class}"
+        end
+
+        deep_freeze(fragment.deep_dup.with_indifferent_access)
+      end
+
+      # @param value [Object]
+      # @return [Object] the same value, frozen through nested hashes and arrays
+      # @api private
+      def deep_freeze(value)
+        case value
+        when Hash  then value.each_value { |v| deep_freeze(v) }.freeze
+        when Array then value.each { |v| deep_freeze(v) }.freeze
+        else value.freeze
+        end
+      end
+    end
+  end
+end

data/lib/servus/support/logger.rb

@@ -94,6 +94,16 @@ module Servus
         logger.error("#{service_class.name} uncaught exception: #{exception.class} - #{exception.message}")
       end
 
+      # Logs that a registered schema fragment was replaced with a different value.
+      #
+      # Expected during development reloads. Outside of that it usually means
+      # two libraries are claiming the same fragment key.
+      #
+      # @param key [String] The schema fragment key being overridden
+      def self.log_schema_override(key)
+        logger.warn("Schema fragment #{key.inspect} was already registered with a different value; replacing it.")
+      end
+
       # Filters parameters for logging based on the configured filter list.
       #
       # @param params [Hash] The parameters to filter

data/lib/servus/support/validator.rb

@@ -2,42 +2,46 @@
 
 module Servus
   module Support
-    # Handles JSON Schema validation for service arguments and results.
+    # Validates service arguments and results, and event payloads, against the
+    # JSON schemas declared with the +schema+ DSL.
     #
-    # The Validator class provides automatic validation of service inputs and outputs
-    # against JSON Schema definitions. Schemas can be defined as inline constants
-    # (ARGUMENTS_SCHEMA, RESULT_SCHEMA) or as external JSON files.
+    # Arguments are validated before +call+ runs, so a service body can trust
+    # the shape of its inputs. Result data is validated after it returns, so a
+    # service that stops honouring its own contract fails loudly rather than
+    # passing the wrong shape to its callers. Both raise
+    # {Servus::Support::Errors::ValidationError}, which signals a bug — in the
+    # caller for arguments, in the service itself for results — and is not
+    # meant to be rescued.
     #
-    # @example Inline schema validation
+    # Schemas come from the +schema+ DSL and nowhere else. The class-level
+    # readers resolve any +$ref+s against {Servus::Schema}, so what arrives
+    # here is always a self-contained schema.
+    #
+    # @example
     #   class MyService < Servus::Base
-    #     ARGUMENTS_SCHEMA = {
-    #       type: "object",
-    #       required: ["user_id"],
-    #       properties: {
-    #         user_id: { type: "integer" }
-    #       }
-    #     }
+    #     schema arguments: { type: 'object', required: ['user_id'] }
     #   end
     #
-    # @example File-based schema validation
-    #   # app/schemas/services/my_service/arguments.json
-    #   # { "type": "object", "required": ["user_id"], ... }
-    #
+    # @see Servus::Base.schema
+    # @see Servus::Schema
     # @see https://json-schema.org/specification.html
     class Validator
+      # Schema kinds that may be requested from {.load_schema}.
+      #
+      # @api private
+      SCHEMA_TYPES = %w[arguments result failure payload].freeze
+
       # @api private
       @schema_cache = {}
 
-      # Validates service arguments against the ARGUMENTS_SCHEMA.
-      #
-      # Checks arguments against either an inline ARGUMENTS_SCHEMA constant or
-      # a file-based schema at app/schemas/services/namespace/arguments.json.
-      # Validation is skipped if no schema is defined.
+      # Validates service arguments against the service's arguments schema.
       #
       # @param service_class [Class] the service class being validated
       # @param args [Hash] keyword arguments passed to the service
       # @return [Boolean] true if validation passes
       # @raise [Servus::Support::Errors::ValidationError] if arguments fail validation
+      # @raise [Servus::Support::Errors::SchemaRequiredError] if no schema is
+      #   declared and +require_service_arguments_schema+ is enabled
       #
       # @example
       #   Validator.validate_arguments!(MyService, { user_id: 123 })
@@ -48,11 +52,7 @@ module Servus
         enforce_schema_presence!(schema, service_class, :require_service_arguments_schema)
         return true unless schema
 
-        validate_data_against_schema!(
-          args,
-          schema,
-          "Invalid arguments for #{service_class.name}"
-        )
+        validate_data_against_schema!(args, schema, "Invalid arguments for #{service_class.name}")
 
         true
       end
@@ -102,7 +102,7 @@ module Servus
         end
       end
 
-      # Validates event payload against the Event class's payload schema.
+      # Validates an event payload against the event's payload schema.
       #
       # @param event_class [Class] the Event subclass
       # @param payload [Hash] the event payload to validate
@@ -114,7 +114,7 @@ module Servus
       #
       # @api private
       def self.validate_event_payload!(event_class, payload)
-        schema = event_class.payload_schema
+        schema = load_schema(event_class, 'payload')
         enforce_schema_presence!(schema, event_class, :require_event_payload_schema)
         return true unless schema
 
@@ -127,50 +127,36 @@ module Servus
         true
       end
 
-      # Loads and caches a schema for a service.
-      #
-      # Implements a three-tier lookup strategy:
-      # 1. Check for schema defined via DSL method (service_class.arguments_schema/result_schema)
-      # 2. Check for inline constant (ARGUMENTS_SCHEMA or RESULT_SCHEMA)
-      # 3. Fall back to JSON file in app/schemas/services/namespace/type.json
+      # Returns a class's compiled schema of the given kind.
       #
-      # Schemas are cached after first load for performance.
+      # Cached per class and kind. The underlying compilation is also memoized
+      # on the class itself and rebuilds when {Servus::Schema} changes, so this
+      # cache exists to skip the lookup, not to hold compilation results.
       #
-      # @param service_class [Class] the service class
-      # @param type [String] schema type ("arguments", "result", or "failure")
-      # @return [Hash, nil] the schema hash, or nil if no schema found
+      # @param klass [Class] a {Servus::Base} or {Servus::Event} subclass
+      # @param type [String, Symbol] one of {SCHEMA_TYPES}
+      # @return [Hash, nil] the compiled schema, or nil if none is declared
+      # @raise [ArgumentError] if +type+ is not a known schema kind
       #
       # @api private
-      # rubocop:disable Metrics/MethodLength
-      def self.load_schema(service_class, type)
-        # Get service path based on class name (e.g., "process_payment" from "Servus::ProcessPayment::Service")
-        service_namespace = parse_service_namespace(service_class)
-        schema_path = Servus.config.schema_path_for(service_namespace, type)
-
-        # Return from cache if available
-        return @schema_cache[schema_path] if @schema_cache.key?(schema_path)
+      def self.load_schema(klass, type)
+        type = type.to_s
 
-        # Check for DSL-defined schema first
-        dsl_schema = case type
-                     when 'arguments' then service_class.arguments_schema
-                     when 'result'    then service_class.result_schema
-                     when 'failure'   then service_class.failure_schema
-                     end
+        unless SCHEMA_TYPES.include?(type)
+          raise ArgumentError, "unknown schema type #{type.inspect}. Valid: #{SCHEMA_TYPES.join(', ')}."
+        end
 
-        inline_schema_constant_name = "#{service_class}::#{type.upcase}_SCHEMA"
-        inline_schema_constant = if Object.const_defined?(inline_schema_constant_name)
-                                   Object.const_get(inline_schema_constant_name)
-                                 end
+        key = [klass, type]
+        return @schema_cache[key] if @schema_cache.key?(key)
 
-        @schema_cache[schema_path] = fetch_schema_from_sources(dsl_schema, inline_schema_constant, schema_path)
-        @schema_cache[schema_path]
+        @schema_cache[key] = klass.public_send(:"#{type}_schema")
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Clears the schema cache.
       #
-      # Useful in development when schema files are modified, or in tests
-      # to ensure fresh schema loading between test cases.
+      # Useful in tests, and in development after changing a schema. Registry
+      # changes invalidate compiled schemas on their own, so this is rarely
+      # needed in application code.
       #
       # @return [Hash] empty hash
       #
@@ -184,7 +170,7 @@ module Servus
 
       # Returns the current schema cache.
       #
-      # @return [Hash] cache mapping schema paths to loaded schemas
+      # @return [Hash] cache mapping [class, type] pairs to compiled schemas
       # @api private
       def self.cache
         @schema_cache
@@ -206,12 +192,12 @@ module Servus
         raise Servus::Base::ValidationError, "#{message_prefix}: #{errors.join(', ')}"
       end
 
-      # Returns the schema if present. Raises if absent and the config flag is enabled.
+      # Raises if a schema is absent and the corresponding config flag is on.
       #
       # @param schema [Hash, nil] the loaded schema
       # @param klass [Class] the service or Event class
       # @param config_flag [Symbol] the config method to check
-      # @return [Hash, nil] the schema
+      # @return [Hash, nil] the schema, unchanged
       # @raise [Servus::Support::Errors::SchemaRequiredError] if schema is nil and enforcement is enabled
       #
       # @api private
@@ -223,49 +209,6 @@ module Servus
         raise Servus::Support::Errors::SchemaRequiredError,
               "#{klass.name} schema missing! #{config_flag} is set to true."
       end
-
-      # Fetches schema from DSL, inline constant, or file.
-      #
-      # Implements the schema resolution precedence:
-      # 1. DSL-defined schema (if provided)
-      # 2. Inline constant (if provided)
-      # 3. File at schema_path (if exists)
-      # 4. nil (no schema found)
-      #
-      # @param dsl_schema [Hash, nil] schema from DSL method (e.g., schema arguments: Hash)
-      # @param inline_schema_constant [Hash, nil] inline schema constant (e.g., ARGUMENTS_SCHEMA)
-      # @param schema_path [String] file path to external schema JSON
-      # @return [Hash, nil] schema with indifferent access, or nil if not found
-      #
-      # @api private
-      def self.fetch_schema_from_sources(dsl_schema, inline_schema_constant, schema_path)
-        if dsl_schema
-          dsl_schema.with_indifferent_access
-        elsif inline_schema_constant
-          inline_schema_constant.with_indifferent_access
-        elsif File.exist?(schema_path)
-          JSON.load_file(schema_path).with_indifferent_access
-        end
-      end
-
-      # Converts service class name to file path namespace.
-      #
-      # Transforms a class name like "Services::ProcessPayment::Service" into
-      # "services/process_payment" for locating schema files.
-      #
-      # @param service_class [Class] the service class
-      # @return [String] underscored namespace path
-      #
-      # @example
-      #   parse_service_namespace(Services::ProcessPayment::Service)
-      #   # => "services/process_payment"
-      #
-      # @api private
-      def self.parse_service_namespace(service_class)
-        service_class.name.split('::')[..-2].map do |s|
-          s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
-        end.join('/')
-      end
     end
   end
 end

data/lib/servus/testing/example_extractor.rb

@@ -286,13 +286,11 @@ module Servus
         end
       end
 
-      # Loads schema from service class using Validator.
+      # Loads a schema from a service class using the Validator.
       #
-      # Reuses the existing Validator schema loading logic which handles:
-      # - DSL-defined schemas
-      # - Constant-defined schemas
-      # - File-based schemas
-      # - Schema caching
+      # The schema returned is compiled, so +example+ and +examples+ values
+      # inside +$ref+'d fragments are visible to extraction — a shared fragment
+      # can carry its own examples and every service referencing it gets them.
       #
       # @param service_class [Class] The service class
       # @param schema_type [Symbol] Either :arguments or :result

data/lib/servus/testing/matchers.rb

@@ -94,12 +94,7 @@ end
 # Matcher for asserting schema presence on a service or Event class
 RSpec::Matchers.define :have_schema do |schema_type|
   match do |klass|
-    if schema_type.to_s == 'payload'
-      !klass.payload_schema.nil?
-    else
-      Servus::Support::Validator.clear_cache!
-      !Servus::Support::Validator.load_schema(klass, schema_type.to_s).nil?
-    end
+    !Servus::Support::Validator.load_schema(klass, schema_type.to_s).nil?
   end
 
   failure_message do |klass|

data/lib/servus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Servus
-  VERSION = '0.7.0'
+  VERSION = '1.0.0'
 end

data/lib/servus.rb

@@ -5,6 +5,8 @@ require 'json-schema'
 require 'active_support'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/deep_dup'
+require 'active_support/core_ext/string/inflections'
 # Servus namespace
 module Servus; end
 
@@ -17,6 +19,15 @@ require_relative 'servus/railtie' if defined?(Rails::Railtie)
 # Config
 require_relative 'servus/config'
 
+# Schema
+require_relative 'servus/schema/errors'
+require_relative 'servus/schema/cache'
+require_relative 'servus/schema/path'
+require_relative 'servus/schema/ref'
+require_relative 'servus/schema/declaration'
+require_relative 'servus/schema/compiler'
+require_relative 'servus/schema'
+
 # Support
 require_relative 'servus/support/logger'
 require_relative 'servus/support/data_object'
@@ -28,6 +39,7 @@ require_relative 'servus/support/lockdown'
 require_relative 'servus/support/message_resolver'
 
 # Events
+require_relative 'servus/events/errors'
 require_relative 'servus/events/bus'
 require_relative 'servus/events/emitter'
 require_relative 'servus/event'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servus
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Sebastian Scholl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-15 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -68,8 +68,6 @@ files:
 - lib/generators/servus/guard/templates/guard.rb.erb
 - lib/generators/servus/guard/templates/guard_spec.rb.erb
 - lib/generators/servus/service/service_generator.rb
-- lib/generators/servus/service/templates/arguments.json.erb
-- lib/generators/servus/service/templates/result.json.erb
 - lib/generators/servus/service/templates/service.rb.erb
 - lib/generators/servus/service/templates/service_spec.rb.erb
 - lib/servus.rb
@@ -79,6 +77,7 @@ files:
 - lib/servus/events/bus.rb
 - lib/servus/events/class_router.rb
 - lib/servus/events/emitter.rb
+- lib/servus/events/errors.rb
 - lib/servus/events/invocation.rb
 - lib/servus/events/router.rb
 - lib/servus/extensions/async/call.rb
@@ -97,6 +96,13 @@ files:
 - lib/servus/guards/truthy_guard.rb
 - lib/servus/helpers/controller_helpers.rb
 - lib/servus/railtie.rb
+- lib/servus/schema.rb
+- lib/servus/schema/cache.rb
+- lib/servus/schema/compiler.rb
+- lib/servus/schema/declaration.rb
+- lib/servus/schema/errors.rb
+- lib/servus/schema/path.rb
+- lib/servus/schema/ref.rb
 - lib/servus/support/data_object.rb
 - lib/servus/support/errors.rb
 - lib/servus/support/lockdown.rb
@@ -127,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="