unitsdb 2.2.1 → 2.2.4

data/lib/unitsdb/database.rb

@@ -2,7 +2,15 @@
 
 module Unitsdb
   class Database < Lutaml::Model::Serializable
-    # model Config.model_for(:units)
+    autoload :ReferenceValidator, "unitsdb/database/reference_validator"
+    autoload :UniquenessValidator, "unitsdb/database/uniqueness_validator"
+    autoload :Loader, "unitsdb/database/loader"
+
+    COLLECTIONS = Loader::DATABASE_FILES.keys.map(&:to_sym).freeze
+
+    # Collections whose entities carry a `symbols` attribute.
+    # Used by symbol-based search/match to narrow iteration.
+    SYMBOL_COLLECTIONS = %i[units prefixes].freeze
 
     attribute :schema_version, :string
     attribute :version, :string
@@ -12,16 +20,47 @@ module Unitsdb
     attribute :dimensions, Dimension, collection: true
     attribute :unit_systems, UnitSystem, collection: true
 
+    # Resolve a collection name (String or Symbol) to its typed Array.
+    # Validates against COLLECTIONS so caller-supplied names can never
+    # dispatch to arbitrary methods (e.g. `schema_version`, `to_yaml`).
+    def collection(name)
+      sym = name.to_sym
+      unless COLLECTIONS.include?(sym)
+        raise ArgumentError, "unknown collection: #{name.inspect}"
+      end
+
+      public_send(sym)
+    end
+
+    # Build an empty Database with `entities` partitioned into their
+    # typed collections. Used by CLI commands that need to serialize
+    # a subset of search results.
+    def self.empty_for_results(entities)
+      Database.new.tap do |db|
+        COLLECTIONS.each do |name|
+          klass = collection_element_class(name)
+          db.public_send("#{name}=", entities.grep(klass))
+        end
+      end
+    end
+
+    class << self
+      private
+
+      # Map a collection symbol to the entity class it holds.
+      # Derived from the Lutaml attribute declaration.
+      def collection_element_class(name)
+        attributes.fetch(name.to_s).type
+      end
+    end
+
     # Find an entity by its specific identifier and type
     # @param id [String] the identifier value to search for
     # @param type [String, Symbol] the entity type (units, prefixes, quantities, etc.)
     # @return [Object, nil] the first entity with matching identifier or nil if not found
     def find_by_type(id:, type:)
-      collection = send(type.to_s)
-      collection.find do |entity|
-        entity.identifiers&.any? do |identifier|
-          identifier.id == id
-        end
+      collection(type).find do |entity|
+        entity.identifiers.any? { |identifier| identifier.id == id }
       end
     end
 
@@ -30,82 +69,36 @@ module Unitsdb
     # @param type [String, nil] optional identifier type to match
     # @return [Object, nil] the first entity with matching identifier or nil if not found
     def get_by_id(id:, type: nil)
-      %w[units prefixes quantities dimensions
-         unit_systems].each do |collection_name|
-        next unless respond_to?(collection_name)
-
-        collection = send(collection_name)
-        entity = collection.find do |e|
-          e.identifiers&.any? do |identifier|
+      COLLECTIONS.each do |name|
+        entity = collection(name).find do |e|
+          e.identifiers.any? do |identifier|
             identifier.id == id && (type.nil? || identifier.type == type)
           end
         end
-
         return entity if entity
       end
 
       nil
     end
 
-    # Search for entities containing the given text in identifiers, names, or short description
+    # Search for entities containing the given text in identifiers,
+    # names, or short description.
     # @param params [Hash] search parameters
     # @option params [String] :text The text to search for
     # @option params [String, Symbol, nil] :type Optional entity type to limit search scope
     # @return [Array] all entities matching the search criteria
     def search(params = {})
       text = params[:text]
-      type = params[:type]
-
       return [] unless text
 
-      results = []
+      needle = text.downcase
+      scope = scope_for(params[:type], COLLECTIONS)
 
-      # Define which collections to search based on type parameter
-      collections = if type
-                      [type.to_s]
-                    else
-                      %w[units prefixes quantities
-                         dimensions unit_systems]
-                    end
-
-      collections.each do |collection_name|
-        next unless respond_to?(collection_name)
-
-        collection = send(collection_name)
-        collection.each do |entity|
-          # Search in identifiers
-          if entity.identifiers&.any? do |identifier|
-            identifier.id.to_s.downcase.include?(text.downcase)
-          end
-            results << entity
-            next
-          end
-
-          # Search in names (if the entity has names)
-          if entity.respond_to?(:names) && entity.names && entity.names.any? do |name|
-            name.value.to_s.downcase.include?(text.downcase)
-          end
-            results << entity
-            next
-          end
-
-          # Search in short description
-          if entity.respond_to?(:short) && entity.short &&
-              entity.short.to_s.downcase.include?(text.downcase)
-            results << entity
-            next
-          end
-
-          # Special case for prefix name (prefixes don't have names array)
-          next unless collection_name == "prefixes" && entity.respond_to?(:name) &&
-            entity.name.to_s.downcase.include?(text.downcase)
-
-          results << entity
-          next
+      scope.each_with_object([]) do |name, results|
+        collection(name).each do |entity|
+          results << entity if matches_text?(entity, needle)
         end
       end
-
-      results
     end
 
     # Find entities by symbol
@@ -115,38 +108,16 @@ module Unitsdb
     def find_by_symbol(symbol, entity_type = nil)
       return [] unless symbol
 
-      results = []
-
-      # Symbol search only applies to units and prefixes
-      collections = entity_type ? [entity_type.to_s] : %w[units prefixes]
-
-      collections.each do |collection_name|
-        next unless respond_to?(collection_name) && %w[units
-                                                       prefixes].include?(collection_name)
-
-        collection = send(collection_name)
-        collection.each do |entity|
-          if collection_name == "units" && entity.respond_to?(:symbols) && entity.symbols
-            # Units can have multiple symbols
-            matches = entity.symbols.any? do |sym|
-              sym.respond_to?(:ascii) && sym.ascii &&
-                sym.ascii.downcase == symbol.downcase
-            end
-
-            results << entity if matches
-          elsif collection_name == "prefixes" && entity.respond_to?(:symbols) && entity.symbols
-            # Prefixes have multiple symbols in 2.0.0
-            matches = entity.symbols.any? do |sym|
-              sym.respond_to?(:ascii) && sym.ascii &&
-                sym.ascii.downcase == symbol.downcase
-            end
-
-            results << entity if matches
+      needle = symbol.downcase
+      scope = scope_for(entity_type, SYMBOL_COLLECTIONS)
+
+      scope.each_with_object([]) do |name, results|
+        collection(name).each do |entity|
+          results << entity if entity.symbols.any? do |sym|
+            sym.ascii.to_s.downcase == needle
           end
         end
       end
-
-      results
     end
 
     # Match entities by name, short, or symbol with different match types
@@ -157,544 +128,112 @@ module Unitsdb
     # @return [Hash] matches grouped by match type (exact, symbol_match) with match details
     def match_entities(params = {})
       value = params[:value]
-      match_type = params[:match_type]&.to_s || "exact"
-      entity_type = params[:entity_type]
-
       return {} unless value
 
-      result = {
-        exact: [],
-        symbol_match: [],
-      }
-
-      # Define collections to search based on entity_type parameter
-      collections = if entity_type
-                      [entity_type.to_s]
-                    else
-                      %w[units prefixes
-                         quantities dimensions unit_systems]
-                    end
-
-      collections.each do |collection_name|
-        next unless respond_to?(collection_name)
-
-        collection = send(collection_name)
+      match_type = params[:match_type]&.to_s || "exact"
+      result = { exact: [], symbol_match: [] }
 
-        collection.each do |entity|
-          # For exact matches - look at short and names
+      scope_for(params[:entity_type], COLLECTIONS).each do |name|
+        collection(name).each do |entity|
           if %w[exact all].include?(match_type)
-            # Match by short
-            if entity.respond_to?(:short) && entity.short &&
-                entity.short.downcase == value.downcase
-              result[:exact] << {
-                entity: entity,
-                match_desc: "short_to_name",
-                details: "UnitsDB short '#{entity.short}' matches '#{value}'",
-              }
-              next
-            end
-
-            # Match by names
-            if entity.respond_to?(:names) && entity.names
-              matching_name = entity.names.find do |name|
-                name.value.to_s.downcase == value.downcase
-              end
-              if matching_name
-                result[:exact] << {
-                  entity: entity,
-                  match_desc: "name_to_name",
-                  details: "UnitsDB name '#{matching_name.value}' (#{matching_name.lang}) matches '#{value}'",
-                }
-                next
-              end
-            end
+            match_exact(entity, value, result)
           end
+          next unless %w[symbol all].include?(match_type) && SYMBOL_COLLECTIONS.include?(name)
 
-          # For symbol matches - only applicable to units and prefixes
-          if %w[symbol all].include?(match_type) &&
-              %w[units prefixes].include?(collection_name)
-            if collection_name == "units" && entity.respond_to?(:symbols) && entity.symbols
-              # Units can have multiple symbols
-              matching_symbol = entity.symbols.find do |sym|
-                sym.respond_to?(:ascii) && sym.ascii &&
-                  sym.ascii.downcase == value.downcase
-              end
-
-              if matching_symbol
-                result[:symbol_match] << {
-                  entity: entity,
-                  match_desc: "symbol_match",
-                  details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'",
-                }
-              end
-            elsif collection_name == "prefixes" && entity.respond_to?(:symbols) && entity.symbols
-              # Prefixes have multiple symbols in 2.0.0
-              matching_symbol = entity.symbols.find do |sym|
-                sym.respond_to?(:ascii) && sym.ascii &&
-                  sym.ascii.downcase == value.downcase
-              end
-
-              if matching_symbol
-                result[:symbol_match] << {
-                  entity: entity,
-                  match_desc: "symbol_match",
-                  details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'",
-                }
-              end
-            end
-          end
+          match_symbol(entity, value, result)
         end
       end
 
-      # Remove empty categories
       result.delete_if { |_, v| v.empty? }
-
       result
     end
 
-    # Checks for uniqueness of identifiers and short names
+    # Checks for uniqueness of identifiers and short names.
+    # Delegates to UniquenessValidator.
     def validate_uniqueness
-      results = {
-        short: {},
-        id: {},
-      }
-
-      # Validate short names for applicable collections
-      validate_shorts(units, "units", results)
-      validate_shorts(dimensions, "dimensions", results)
-      validate_shorts(unit_systems, "unit_systems", results)
-
-      # Validate identifiers for all collections
-      validate_identifiers(units, "units", results)
-      validate_identifiers(prefixes, "prefixes", results)
-      validate_identifiers(quantities, "quantities", results)
-      validate_identifiers(dimensions, "dimensions", results)
-      validate_identifiers(unit_systems, "unit_systems", results)
-
-      results
+      UniquenessValidator.validate(self)
     end
 
-    # Validates references between entities
+    # Validates references between entities. Delegates to ReferenceValidator.
     def validate_references
-      invalid_refs = {}
-
-      # Build registry of all valid IDs first
-      registry = build_id_registry
-
-      # Check various reference types
-      check_dimension_references(registry, invalid_refs)
-      check_unit_system_references(registry, invalid_refs)
-      check_quantity_references(registry, invalid_refs)
-      check_root_unit_references(registry, invalid_refs)
-
-      invalid_refs
-    end
-
-    def self.from_db(dir_path)
-      # If dir_path is a relative path, make it relative to the current working directory
-      db_path = dir_path
-      puts "Database directory path: #{db_path}"
-
-      # Check if the directory exists
-      unless Dir.exist?(db_path)
-        raise Errors::DatabaseNotFoundError,
-              "Database directory not found: #{db_path}"
-      end
-
-      # Define required files
-      required_files = %w[prefixes.yaml dimensions.yaml units.yaml
-                          quantities.yaml unit_systems.yaml]
-      yaml_files = required_files.map { |file| File.join(dir_path, file) }
-
-      # Check if all required files exist
-      missing_files = required_files.reject do |file|
-        File.exist?(File.join(dir_path, file))
-      end
-
-      if missing_files.any?
-        raise Errors::DatabaseFileNotFoundError,
-              "Missing required database files: #{missing_files.join(', ')}"
-      end
-
-      # Ensure we have path properly joined with filenames
-      prefixes_yaml = yaml_files[0]
-      dimensions_yaml = yaml_files[1]
-      units_yaml = yaml_files[2]
-      quantities_yaml = yaml_files[3]
-      unit_systems_yaml = yaml_files[4]
-
-      # Debug paths
-      if ENV["DEBUG"]
-        puts "[UnitsDB] Loading YAML files from directory: #{dir_path}"
-        puts "  - #{prefixes_yaml}"
-        puts "  - #{dimensions_yaml}"
-        puts "  - #{units_yaml}"
-        puts "  - #{quantities_yaml}"
-        puts "  - #{unit_systems_yaml}"
-      end
-
-      # Load YAML files with better error handling
-      begin
-        prefixes_hash = YAML.safe_load_file(prefixes_yaml)
-        dimensions_hash = YAML.safe_load_file(dimensions_yaml)
-        units_hash = YAML.safe_load_file(units_yaml)
-        quantities_hash = YAML.safe_load_file(quantities_yaml)
-        unit_systems_hash = YAML.safe_load_file(unit_systems_yaml)
-      rescue Errno::ENOENT => e
-        raise Errors::DatabaseFileNotFoundError,
-              "Failed to read database file: #{e.message}"
-      rescue Psych::SyntaxError => e
-        raise Errors::DatabaseFileInvalidError,
-              "Invalid YAML in database file: #{e.message}"
-      rescue StandardError => e
-        raise Errors::DatabaseLoadError, "Error loading database: #{e.message}"
-      end
-
-      # Verify all files have schema_version field
-      missing_schema = []
-      missing_schema << "prefixes.yaml" unless prefixes_hash.key?("schema_version")
-      missing_schema << "dimensions.yaml" unless dimensions_hash.key?("schema_version")
-      missing_schema << "units.yaml" unless units_hash.key?("schema_version")
-      missing_schema << "quantities.yaml" unless quantities_hash.key?("schema_version")
-      missing_schema << "unit_systems.yaml" unless unit_systems_hash.key?("schema_version")
-
-      if missing_schema.any?
-        raise Errors::DatabaseFileInvalidError,
-              "Missing schema_version in files: #{missing_schema.join(', ')}"
-      end
-
-      # Extract versions from each file
-      prefixes_version = prefixes_hash["schema_version"]
-      dimensions_version = dimensions_hash["schema_version"]
-      units_version = units_hash["schema_version"]
-      quantities_version = quantities_hash["schema_version"]
-      unit_systems_version = unit_systems_hash["schema_version"]
-
-      # Check if all versions match
-      versions = [
-        prefixes_version,
-        dimensions_version,
-        units_version,
-        quantities_version,
-        unit_systems_version,
-      ]
-
-      unless versions.uniq.size == 1
-        version_info = {
-          "prefixes.yaml" => prefixes_version,
-          "dimensions.yaml" => dimensions_version,
-          "units.yaml" => units_version,
-          "quantities.yaml" => quantities_version,
-          "unit_systems.yaml" => unit_systems_version,
-        }
-        raise Errors::VersionMismatchError,
-              "Version mismatch in database files: #{version_info.inspect}"
-      end
-
-      # Check if the version is supported
-      version = versions.first
-      unless version == "2.0.0"
-        raise Errors::UnsupportedVersionError,
-              "Unsupported database version: #{version}. Only version 2.0.0 is supported."
-      end
-
-      combined_yaml = {
-        "schema_version" => prefixes_version,
-        "prefixes" => prefixes_hash["prefixes"],
-        "dimensions" => dimensions_hash["dimensions"],
-        "units" => units_hash["units"],
-        "quantities" => quantities_hash["quantities"],
-        "unit_systems" => unit_systems_hash["unit_systems"],
-      }.to_yaml
-
-      from_yaml(combined_yaml)
+      ReferenceValidator.validate(self)
     end
 
     private
 
-    # Helper methods for uniqueness validation
-    def validate_shorts(collection, type, results)
-      shorts = {}
-
-      collection.each_with_index do |item, index|
-        next unless item.respond_to?(:short) && item.short
+    # Resolve a caller-supplied type to a list of collection symbols,
+    # validating against `allowed`. Nil means "all allowed".
+    def scope_for(type, allowed)
+      return allowed.dup unless type
 
-        (shorts[item.short] ||= []) << "index:#{index}"
-      end
-
-      # Add to results if duplicates found
-      shorts.each do |short, paths|
-        next unless paths.size > 1
+      sym = type.to_sym
+      raise ArgumentError, "unknown collection: #{type.inspect}" unless allowed.include?(sym)
 
-        (results[:short][type] ||= {})[short] = paths
-      end
+      [sym]
     end
 
-    def validate_identifiers(collection, type, results)
-      ids = {}
-
-      collection.each_with_index do |item, index|
-        next unless item.respond_to?(:identifiers)
-
-        # Process identifiers array for this item
-        item.identifiers.each_with_index do |identifier, id_index|
-          next unless identifier.respond_to?(:id) && identifier.id
-
-          id_key = identifier.id
-          loc = "index:#{index}:identifiers[#{id_index}]"
-          (ids[id_key] ||= []) << loc
-        end
-      end
-
-      # Add duplicates to results
-      ids.each do |id, paths|
-        unique_paths = paths.uniq
-        next unless unique_paths.size > 1
-
-        (results[:id][type] ||= {})[id] = unique_paths
-      end
+    def matches_text?(entity, needle)
+      entity.identifiers.any? { |i| i.id.to_s.downcase.include?(needle) } ||
+        entity.names.any? { |n| n.value.to_s.downcase.include?(needle) } ||
+        entity.short.to_s.downcase.include?(needle)
     end
 
-    # Helper methods for reference validation
-    def build_id_registry
-      registry = {}
-
-      # Add unit identifiers
-      registry["units"] = {}
-      units.each_with_index do |unit, index|
-        next unless unit.respond_to?(:identifiers)
-
-        unit.identifiers.each do |identifier|
-          next unless identifier.id && identifier.type
-
-          # Add composite key (type:id)
-          composite_key = "#{identifier.type}:#{identifier.id}"
-          registry["units"][composite_key] = "index:#{index}"
-
-          # Also add just the ID for backward compatibility
-          registry["units"][identifier.id] = "index:#{index}"
-        end
-      end
-
-      # Add dimension identifiers
-      registry["dimensions"] = {}
-      dimensions.each_with_index do |dimension, index|
-        next unless dimension.respond_to?(:identifiers)
-
-        dimension.identifiers.each do |identifier|
-          next unless identifier.id && identifier.type
-
-          composite_key = "#{identifier.type}:#{identifier.id}"
-          registry["dimensions"][composite_key] = "index:#{index}"
-          registry["dimensions"][identifier.id] = "index:#{index}"
-        end
-
-        # Also track dimensions by short name
-        if dimension.respond_to?(:short) && dimension.short
-          registry["dimensions_short"] ||= {}
-          registry["dimensions_short"][dimension.short] = "index:#{index}"
-        end
-      end
-
-      # Add quantity identifiers
-      registry["quantities"] = {}
-      quantities.each_with_index do |quantity, index|
-        next unless quantity.respond_to?(:identifiers)
-
-        quantity.identifiers.each do |identifier|
-          next unless identifier.id && identifier.type
-
-          composite_key = "#{identifier.type}:#{identifier.id}"
-          registry["quantities"][composite_key] = "index:#{index}"
-          registry["quantities"][identifier.id] = "index:#{index}"
-        end
-      end
-
-      # Add prefix identifiers
-      registry["prefixes"] = {}
-      prefixes.each_with_index do |prefix, index|
-        next unless prefix.respond_to?(:identifiers)
-
-        prefix.identifiers.each do |identifier|
-          next unless identifier.id && identifier.type
-
-          composite_key = "#{identifier.type}:#{identifier.id}"
-          registry["prefixes"][composite_key] = "index:#{index}"
-          registry["prefixes"][identifier.id] = "index:#{index}"
-        end
-      end
-
-      # Add unit system identifiers
-      registry["unit_systems"] = {}
-      unit_systems.each_with_index do |unit_system, index|
-        next unless unit_system.respond_to?(:identifiers)
-
-        unit_system.identifiers.each do |identifier|
-          next unless identifier.id && identifier.type
-
-          composite_key = "#{identifier.type}:#{identifier.id}"
-          registry["unit_systems"][composite_key] = "index:#{index}"
-          registry["unit_systems"][identifier.id] = "index:#{index}"
-        end
-
-        # Also track unit systems by short name
-        if unit_system.respond_to?(:short) && unit_system.short
-          registry["unit_systems_short"] ||= {}
-          registry["unit_systems_short"][unit_system.short] = "index:#{index}"
-        end
+    def match_exact(entity, value, result)
+      if entity.short && entity.short.downcase == value.downcase
+        result[:exact] << {
+          entity: entity,
+          match_desc: "short_to_name",
+          details: "UnitsDB short '#{entity.short}' matches '#{value}'",
+        }
+        return
       end
 
-      registry
-    end
-
-    def check_dimension_references(registry, invalid_refs)
-      dimensions.each_with_index do |dimension, index|
-        next unless dimension.respond_to?(:dimension_reference) && dimension.dimension_reference
-
-        ref_id = dimension.dimension_reference
-        ref_type = "dimensions"
-        ref_path = "dimensions:index:#{index}:dimension_reference"
-
-        validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs,
-                           "dimensions")
+      matching_name = entity.names.find do |name|
+        name.value.to_s.downcase == value.downcase
       end
-    end
-
-    def check_unit_system_references(registry, invalid_refs)
-      units.each_with_index do |unit, index|
-        next unless unit.respond_to?(:unit_system_reference) && unit.unit_system_reference
-
-        unit.unit_system_reference.each_with_index do |ref_id, idx|
-          ref_type = "unit_systems"
-          ref_path = "units:index:#{index}:unit_system_reference[#{idx}]"
+      return unless matching_name
 
-          validate_reference(ref_id, ref_type, ref_path, registry,
-                             invalid_refs, "units")
-        end
-      end
+      result[:exact] << {
+        entity: entity,
+        match_desc: "name_to_name",
+        details: "UnitsDB name '#{matching_name.value}' (#{matching_name.lang}) matches '#{value}'",
+      }
     end
 
-    def check_quantity_references(registry, invalid_refs)
-      units.each_with_index do |unit, index|
-        next unless unit.respond_to?(:quantity_references) && unit.quantity_references
-
-        unit.quantity_references.each_with_index do |ref_id, idx|
-          ref_type = "quantities"
-          ref_path = "units:index:#{index}:quantity_references[#{idx}]"
-
-          validate_reference(ref_id, ref_type, ref_path, registry,
-                             invalid_refs, "units")
-        end
+    def match_symbol(entity, value, result)
+      matching_symbol = entity.symbols.find do |sym|
+        sym.ascii.to_s.downcase == value.downcase
       end
-    end
-
-    def check_root_unit_references(registry, invalid_refs)
-      units.each_with_index do |unit, index|
-        next unless unit.respond_to?(:root_units) && unit.root_units
-
-        unit.root_units.each_with_index do |root_unit, idx|
-          next unless root_unit.respond_to?(:unit_reference) && root_unit.unit_reference
-
-          # Check unit reference
-          ref_id = root_unit.unit_reference
-          ref_type = "units"
-          ref_path = "units:index:#{index}:root_units.#{idx}.unit_reference"
-
-          validate_reference(ref_id, ref_type, ref_path, registry,
-                             invalid_refs, "units")
+      return unless matching_symbol
 
-          # Check prefix reference if present
-          next unless root_unit.respond_to?(:prefix_reference) && root_unit.prefix_reference
-
-          ref_id = root_unit.prefix_reference
-          ref_type = "prefixes"
-          ref_path = "units:index:#{index}:root_units.#{idx}.prefix_reference"
-
-          validate_reference(ref_id, ref_type, ref_path, registry,
-                             invalid_refs, "units")
-        end
-      end
+      result[:symbol_match] << {
+        entity: entity,
+        match_desc: "symbol_match",
+        details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'",
+      }
     end
 
-    def validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs,
-file_type)
-      # Handle references that are objects with id and type (could be a hash or an object)
-      if ref_id.respond_to?(:id) && ref_id.respond_to?(:type)
-        id = ref_id.id
-        type = ref_id.type
-        composite_key = "#{type}:#{id}"
-
-        # Try multiple lookup strategies
-        valid = false
-
-        # 1. Try exact composite key match
-        valid = true if registry.key?(ref_type) && registry[ref_type].key?(composite_key)
-
-        # 2. Try just ID match if composite didn't work
-        valid = true if !valid && registry.key?(ref_type) && registry[ref_type].key?(id)
-
-        # 3. Try alternate ID formats for unit systems (e.g., SI_base vs si-base)
-        if !valid && type == "unitsml" && ref_type == "unit_systems" && registry.key?(ref_type) && (
-            registry[ref_type].keys.any? { |k| k.end_with?(":#{id}") } ||
-            registry[ref_type].keys.any? do |k|
-              k.end_with?(":SI_#{id.sub('si-', '')}")
-            end ||
-            registry[ref_type].keys.any? do |k|
-              k.end_with?(":non-SI_#{id.sub('nonsi-', '')}")
-            end
-          )
-          # Special handling for unit_systems between unitsml and nist types
-          valid = true
-        end
-
-        unless valid
-          invalid_refs[file_type] ||= {}
-          invalid_refs[file_type][ref_path] =
-            { id: id, type: type, ref_type: ref_type }
-        end
-      # Handle references that are objects with id and type in a hash
-      elsif ref_id.is_a?(Hash) && ref_id.key?("id") && ref_id.key?("type")
-        id = ref_id["id"]
-        type = ref_id["type"]
-        composite_key = "#{type}:#{id}"
-
-        # Try multiple lookup strategies
-        valid = false
-
-        # 1. Try exact composite key match
-        valid = true if registry.key?(ref_type) && registry[ref_type].key?(composite_key)
-
-        # 2. Try just ID match if composite didn't work
-        valid = true if !valid && registry.key?(ref_type) && registry[ref_type].key?(id)
-
-        # 3. Try alternate ID formats for unit systems (e.g., SI_base vs si-base)
-        if !valid && type == "unitsml" && ref_type == "unit_systems" && registry.key?(ref_type) && (
-            registry[ref_type].keys.any? { |k| k.end_with?(":#{id}") } ||
-            registry[ref_type].keys.any? do |k|
-              k.end_with?(":SI_#{id.sub('si-', '')}")
-            end ||
-            registry[ref_type].keys.any? do |k|
-              k.end_with?(":non-SI_#{id.sub('nonsi-', '')}")
-            end
-          )
-          # Special handling for unit_systems between unitsml and nist types
-          valid = true
-        end
+    class << self
+      # Load every YAML file under `dir_path` and deserialize into a
+      # Database instance scoped to `context`. The default context is
+      # auto-created via `Config.ensure_default_context!`; custom
+      # contexts must be created by the caller first.
+      def from_db(dir_path, context: Unitsdb::Config.context_id)
+        context_id = context.to_sym
+        Unitsdb::Config.ensure_default_context! if context_id == Unitsdb::Config.context_id
 
-        unless valid
-          invalid_refs[file_type] ||= {}
-          invalid_refs[file_type][ref_path] =
-            { id: id, type: type, ref_type: ref_type }
-        end
-      else
-        # Handle plain string references (legacy format)
-        valid = registry.key?(ref_type) && registry[ref_type].key?(ref_id)
+        combined_hash = Loader.load(dir_path)
 
-        unless valid
-          invalid_refs[file_type] ||= {}
-          invalid_refs[file_type][ref_path] = { id: ref_id, type: ref_type }
+        Lutaml::Model::GlobalContext.with_context(context_id) do
+          if Unitsdb::Config.register_id_for(context_id)
+            from_hash(combined_hash, register: context_id)
+          else
+            from_hash(combined_hash)
+          end
         end
       end
     end
   end
+
+  Config.register_model(Database, id: :database)
 end