odin-foundation 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a42b39245e4ab2f8821e0e12100d16418316b22758071d7acf28db0b7a754f20
-  data.tar.gz: 99f7bc6624af35e90864f3ccc1239eb2c3c8ab1cd1a50bcd5daffdca36655e98
+  metadata.gz: fd44363f49452d2888d4c6adee66875fc13d6cd77e0dac6650028aabbcace2af
+  data.tar.gz: fa3f640fe709656ffa5f3436ca7f79d287c2d7a2cf5d9470c4fb7d8d89659b4e
 SHA512:
-  metadata.gz: 00027a7160bb7e6605bdbb3e77e2ea54232147902027cdc98d3dccc6b6ce06635563d4ca84698a12a3325d29b1310e88355911dcd0c75099ad13ba35eef84a64
-  data.tar.gz: 4ad5366860defb9e19affa8f666eccd4d3d6bd3a9cba539131bb189987c9b878a6217cb60260bb58ff03660e71d4bb3865eb77fed4bb4ff47a3e01124f4621fb
+  metadata.gz: d8d134498b241ad33fa0936e95b4f5cefcb3642e97ec099509e23d75fcdb2e11df55c8d072e8989557944c0e7ae2ae38abf64e8cff85a76d8be311406fd22dfc
+  data.tar.gz: dfc5f7a283b5b8714bbb8a9ba09535a49a368dc178dfc8a7b678fee2a8a88d70e7ff8e3347d41ce310f14bccfb083c25e4ca8e3277be7abe20681932d3abbcec

data/lib/odin/types/schema.rb

@@ -154,11 +154,12 @@ module Odin
     # Schema type definition (named object structure)
     class SchemaType
       attr_reader :name, :fields, :namespace, :composition,
-                  :base_type, :constraints, :intersection_types, :parent_types
+                  :base_type, :constraints, :intersection_types, :parent_types,
+                  :arrays
 
       def initialize(name:, fields: {}, namespace: nil, composition: nil,
                      base_type: nil, constraints: nil, intersection_types: nil,
-                     parent_types: nil)
+                     parent_types: nil, arrays: {})
         @name = name.freeze
         @fields = fields.freeze
         @namespace = namespace&.freeze
@@ -167,22 +168,27 @@ module Odin
         @constraints = (constraints || {}).freeze
         @intersection_types = intersection_types&.freeze
         @parent_types = parent_types&.freeze
+        # Array-of-object entries declared inside the type, keyed by array name.
+        @arrays = (arrays || {}).freeze
         freeze
       end
     end
 
     # Schema array definition
     class SchemaArray
-      attr_reader :path, :item_fields, :min_items, :max_items, :unique, :columns
+      attr_reader :path, :item_fields, :min_items, :max_items, :unique, :columns,
+                  :item_type_ref
 
       def initialize(path:, item_fields: {}, min_items: nil, max_items: nil,
-                     unique: false, columns: nil)
+                     unique: false, columns: nil, item_type_ref: nil)
         @path = path.freeze
         @item_fields = item_fields.freeze
         @min_items = min_items
         @max_items = max_items
         @unique = unique
         @columns = columns&.freeze
+        # For an `arr[] = @type` declaration, the entry fields come from this type.
+        @item_type_ref = item_type_ref&.freeze
         freeze
       end
     end

data/lib/odin/validation/schema_parser.rb

@@ -73,6 +73,8 @@ module Odin
           end
         end
 
+        extract_type_arrays
+
         Types::OdinSchema.new(
           metadata: @metadata,
           types: @types,
@@ -83,6 +85,62 @@ module Odin
         )
       end
 
+      # Pull array-of-object entry fields out of each type's flat field map. A key
+      # `arr[]` (whose value is a type reference) becomes an array with an entry
+      # type ref; keys `arr[].field` become an array whose item fields are those
+      # fields. Matching keys are removed from the type's fields.
+      def extract_type_arrays
+        @types.each do |type_name, type|
+          builders = {}
+          remaining_fields = {}
+
+          type.fields.each do |key, field|
+            m = key.match(/\A([^\[\]]+)\[\](?:\.(.+))?\z/)
+            unless m
+              remaining_fields[key] = field
+              next
+            end
+
+            arr_name = m[1]
+            item_path = m[2]
+            b = builders[arr_name] ||= { item_fields: {}, item_type_ref: nil }
+
+            if item_path.nil?
+              # arr[] = @type  -> entry fields come from the referenced type
+              ref = field.type_ref
+              b[:item_type_ref] = ref if ref && ref != "array"
+            else
+              # arr[].item_path = field
+              b[:item_fields][item_path] = field
+            end
+          end
+
+          next if builders.empty?
+
+          arrays = {}
+          builders.each do |arr_name, b|
+            arrays[arr_name] = Types::SchemaArray.new(
+              path: arr_name,
+              item_fields: b[:item_fields],
+              unique: false,
+              item_type_ref: b[:item_type_ref]
+            )
+          end
+
+          @types[type_name] = Types::SchemaType.new(
+            name: type.name,
+            fields: remaining_fields,
+            namespace: type.namespace,
+            composition: type.composition,
+            base_type: type.base_type,
+            constraints: type.constraints,
+            intersection_types: type.intersection_types,
+            parent_types: type.parent_types,
+            arrays: arrays
+          )
+        end
+      end
+
       private
 
       def parse_import(line)
@@ -453,6 +511,8 @@ module Odin
         end
 
         field_name = left
+        # Keep the raw left side so a type can retain its `[]` array markers.
+        raw_field_name = left
         # Strip array indicator from field names
         is_array_field = field_name.end_with?("[]")
         field_name = field_name[0...-2] if is_array_field
@@ -481,15 +541,20 @@ module Odin
         # Parse the field spec from the right side
         schema_field = parse_field_spec(full_path, right)
 
-        # Override type_ref for array fields
+        # Override type_ref for array fields. Inside a type, keep an entry type
+        # ref (arr[] = @entry) so it can be extracted into the type's arrays map.
         if is_array_field
+          array_type_ref = "array"
+          if @current_header_kind == :type && schema_field.type_ref
+            array_type_ref = schema_field.type_ref
+          end
           schema_field = Types::SchemaField.new(
             name: schema_field.name, field_type: schema_field.field_type,
             required: schema_field.required, nullable: schema_field.nullable,
             redacted: schema_field.redacted, deprecated: schema_field.deprecated,
             constraints: schema_field.constraints, conditionals: schema_field.conditionals,
             computed: schema_field.computed, immutable: schema_field.immutable,
-            type_ref: "array"
+            type_ref: array_type_ref
           )
         end
 
@@ -499,8 +564,10 @@ module Odin
           if @current_type_name && @types[@current_type_name]
             old_type = @types[@current_type_name]
             new_fields = old_type.fields.dup
+            # Keep `[]` markers so array-of-object entries can be extracted later.
+            key_name = raw_field_name
             # Relative sub-section ({.term}) prefixes the field key (e.g. term.effective)
-            type_key = @current_type_sub_path.empty? ? field_name : "#{@current_type_sub_path}.#{field_name}"
+            type_key = @current_type_sub_path.empty? ? key_name : "#{@current_type_sub_path}.#{key_name}"
             new_fields[type_key] = schema_field
             @types[@current_type_name] = Types::SchemaType.new(
               name: old_type.name,

data/lib/odin/validation/validator.rb

@@ -201,10 +201,14 @@ module Odin
       # A field typed @SomeType enforces that type's required fields under the field
       # path, but only when the sub-object is present (or the field itself required).
       def check_field_typeref_required_fields
-        @schema.fields.each do |path, field|
-          next if path.end_with?("._composition")
+        @schema.fields.each do |raw_path, field|
+          next if raw_path.end_with?("._composition")
           next unless field.type_ref
 
+          # A field under the root {} header keys as ".field"; the document path
+          # has no leading dot.
+          path = raw_path.sub(/\A\./, "")
+
           member_names(field.type_ref).each do |member|
             type = lookup_type(member)
             next unless type
@@ -226,8 +230,66 @@ module Odin
                 expected: "present"
               )
             end
+
+            check_type_array_required_fields(path, type) if present
+          end
+        end
+      end
+
+      # Expand a referenced type's array-of-object entries under each present
+      # index so entry-level required markers fire only when the entry is present.
+      def check_type_array_required_fields(path, type)
+        return if type.arrays.nil? || type.arrays.empty?
+
+        type.arrays.each do |arr_name, schema_array|
+          item_fields = resolve_array_item_fields(schema_array)
+          next if item_fields.empty?
+
+          array_path = "#{path}.#{arr_name}"
+          present_array_indices(array_path).each do |idx|
+            item_fields.each do |fname, tfield|
+              next if fname == "_composition"
+              next unless tfield.required
+              next if tfield.computed
+
+              full = "#{array_path}[#{idx}].#{fname}"
+              next if doc_has_value?(full)
+
+              add_error(
+                code: Errors::ValidationErrorCode::REQUIRED_FIELD_MISSING,
+                path: full,
+                message: "Required field '#{full}' is missing",
+                expected: "present"
+              )
+            end
+          end
+        end
+      end
+
+      # Entry fields for an array: inline item fields, or the fields of the type
+      # named by item_type_ref (for the arr[] = @type form).
+      def resolve_array_item_fields(schema_array)
+        return schema_array.item_fields unless schema_array.item_fields.empty?
+
+        if schema_array.item_type_ref
+          member_names(schema_array.item_type_ref).each do |member|
+            type = lookup_type(member)
+            return type.fields if type
           end
         end
+        schema_array.item_fields
+      end
+
+      # Distinct indices present in the document under the given array path.
+      def present_array_indices(array_path)
+        seen = {}
+        prefix = "#{array_path}["
+        @doc.paths.each do |p|
+          next unless p.start_with?(prefix)
+          m = p[array_path.length..].match(/\A\[(\d+)\]/)
+          seen[m[1].to_i] = true if m
+        end
+        seen.keys.sort
       end
 
       # Split an &-joined type_ref (e.g. "@hasName&hasAge") into bare member names.

data/lib/odin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Odin
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: odin-foundation
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - ODIN Foundation
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal