unitsdb 2.1.1 → 2.2.2

data/lib/unitsdb/database.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "unit"
-require_relative "prefix"
-require_relative "quantity"
-require_relative "dimension"
-require_relative "unit_system"
-require_relative "errors"
-
 module Unitsdb
   class Database < Lutaml::Model::Serializable
     # model Config.model_for(:units)
 
+    DATABASE_FILES = {
+      "prefixes" => "prefixes.yaml",
+      "dimensions" => "dimensions.yaml",
+      "units" => "units.yaml",
+      "quantities" => "quantities.yaml",
+      "unit_systems" => "unit_systems.yaml",
+    }.freeze
+    SUPPORTED_SCHEMA_VERSION = "2.0.0"
+
     attribute :schema_version, :string
     attribute :version, :string
     attribute :units, Unit, collection: true
@@ -25,7 +27,11 @@ module Unitsdb
     # @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 { |entity| entity.identifiers&.any? { |identifier| identifier.id == id } }
+      collection.find do |entity|
+        entity.identifiers&.any? do |identifier|
+          identifier.id == id
+        end
+      end
     end
 
     # Find an entity by its identifier id across all entity types
@@ -33,7 +39,8 @@ 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|
+      %w[units prefixes quantities dimensions
+         unit_systems].each do |collection_name|
         next unless respond_to?(collection_name)
 
         collection = send(collection_name)
@@ -63,7 +70,12 @@ module Unitsdb
       results = []
 
       # Define which collections to search based on type parameter
-      collections = type ? [type.to_s] : %w[units prefixes quantities dimensions unit_systems]
+      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)
@@ -71,7 +83,9 @@ module Unitsdb
         collection = send(collection_name)
         collection.each do |entity|
           # Search in identifiers
-          if entity.identifiers&.any? { |identifier| identifier.id.to_s.downcase.include?(text.downcase) }
+          if entity.identifiers&.any? do |identifier|
+            identifier.id.to_s.downcase.include?(text.downcase)
+          end
             results << entity
             next
           end
@@ -86,14 +100,14 @@ module Unitsdb
 
           # Search in short description
           if entity.respond_to?(:short) && entity.short &&
-             entity.short.to_s.downcase.include?(text.downcase)
+              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)
+            entity.name.to_s.downcase.include?(text.downcase)
 
           results << entity
           next
@@ -116,7 +130,8 @@ module Unitsdb
       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)
+        next unless respond_to?(collection_name) && %w[units
+                                                       prefixes].include?(collection_name)
 
         collection = send(collection_name)
         collection.each do |entity|
@@ -158,11 +173,16 @@ module Unitsdb
 
       result = {
         exact: [],
-        symbol_match: []
+        symbol_match: [],
       }
 
       # Define collections to search based on entity_type parameter
-      collections = entity_type ? [entity_type.to_s] : %w[units prefixes quantities dimensions unit_systems]
+      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)
@@ -174,23 +194,25 @@ module Unitsdb
           if %w[exact all].include?(match_type)
             # Match by short
             if entity.respond_to?(:short) && entity.short &&
-               entity.short.downcase == value.downcase
+                entity.short.downcase == value.downcase
               result[:exact] << {
                 entity: entity,
                 match_desc: "short_to_name",
-                details: "UnitsDB short '#{entity.short}' matches '#{value}'"
+                details: "UnitsDB short '#{entity.short}' matches '#{value}'",
               }
               next
             end
 
             # Match by names
             if entity.respond_to?(:names) && entity.names
-              matching_name = entity.names.find { |name| name.value.to_s.downcase == value.downcase }
+              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}'"
+                  details: "UnitsDB name '#{matching_name.value}' (#{matching_name.lang}) matches '#{value}'",
                 }
                 next
               end
@@ -199,7 +221,7 @@ module Unitsdb
 
           # For symbol matches - only applicable to units and prefixes
           if %w[symbol all].include?(match_type) &&
-             %w[units prefixes].include?(collection_name)
+              %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|
@@ -211,7 +233,7 @@ module Unitsdb
                 result[:symbol_match] << {
                   entity: entity,
                   match_desc: "symbol_match",
-                  details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'"
+                  details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'",
                 }
               end
             elsif collection_name == "prefixes" && entity.respond_to?(:symbols) && entity.symbols
@@ -225,7 +247,7 @@ module Unitsdb
                 result[:symbol_match] << {
                   entity: entity,
                   match_desc: "symbol_match",
-                  details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'"
+                  details: "UnitsDB symbol '#{matching_symbol.ascii}' matches '#{value}'",
                 }
               end
             end
@@ -243,7 +265,7 @@ module Unitsdb
     def validate_uniqueness
       results = {
         short: {},
-        id: {}
+        id: {},
       }
 
       # Validate short names for applicable collections
@@ -277,116 +299,114 @@ module Unitsdb
       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
-      raise Errors::DatabaseNotFoundError, "Database directory not found: #{db_path}" unless Dir.exist?(db_path)
+    def self.from_db(dir_path, context: Unitsdb::Config.context_id)
+      context_id = context.to_sym
+      if context_id == Unitsdb::Config.context_id &&
+          Unitsdb::Config.find_context(context_id).nil?
+        Unitsdb::Config.context(context_id)
+      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) }
+      db_path = File.expand_path(dir_path.to_s)
+      unless Dir.exist?(db_path)
+        raise Errors::DatabaseNotFoundError,
+              "Database directory not found: #{db_path}"
+      end
 
-      # Check if all required files exist
-      missing_files = required_files.reject { |file| File.exist?(File.join(dir_path, file)) }
+      missing_files = DATABASE_FILES.values.reject do |filename|
+        File.exist?(File.join(db_path, filename))
+      end
 
       if missing_files.any?
         raise Errors::DatabaseFileNotFoundError,
-              "Missing required database files: #{missing_files.join(", ")}"
+              "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}"
+      documents = load_database_documents(db_path)
+      schema_version = validate_schema_versions!(documents)
+      combined_hash = build_database_hash(documents, schema_version)
+
+      Lutaml::Model::GlobalContext.with_context(context_id) do
+        if Unitsdb::Config.register(context_id)
+          from_hash(combined_hash, register: context_id)
+        else
+          from_hash(combined_hash)
+        end
       end
+    end
 
-      # Load YAML files with better error handling
-      begin
-        prefixes_hash = YAML.safe_load(File.read(prefixes_yaml))
-        dimensions_hash = YAML.safe_load(File.read(dimensions_yaml))
-        units_hash = YAML.safe_load(File.read(units_yaml))
-        quantities_hash = YAML.safe_load(File.read(quantities_yaml))
-        unit_systems_hash = YAML.safe_load(File.read(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}"
+    def self.load_database_documents(db_path)
+      puts "[UnitsDB] Loading YAML files from directory: #{db_path}" if ENV["UNITSDB_DEBUG"]
+      DATABASE_FILES.transform_values do |filename|
+        puts "  - #{File.join(db_path, filename)}" if ENV["UNITSDB_DEBUG"]
+        load_database_yaml(File.join(db_path, filename), filename)
+      end
+    end
+
+    def self.load_database_yaml(path, filename)
+      document = YAML.safe_load_file(path)
+
+      unless document.is_a?(Hash)
+        raise Errors::DatabaseFileInvalidError,
+              "Invalid YAML structure in #{filename}: expected a mapping"
       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")
+      document
+    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 Errors::DatabaseError
+      raise
+    rescue StandardError => e
+      raise Errors::DatabaseLoadError,
+            "Error loading database file #{filename}: #{e.message}"
+    end
+    private_class_method :load_database_documents, :load_database_yaml
 
-      if missing_schema.any?
+    def self.validate_schema_versions!(documents)
+      versions = DATABASE_FILES.each_with_object({}) do |(collection_key, filename), result|
+        document = documents.fetch(collection_key)
+        result[filename] = document.fetch("schema_version")
+      rescue KeyError
         raise Errors::DatabaseFileInvalidError,
-              "Missing schema_version in files: #{missing_schema.join(", ")}"
+              "Missing schema_version in #{filename}"
       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}"
+      unless versions.values.uniq.size == 1
+        raise Errors::VersionMismatchError,
+              "Version mismatch in database files: #{versions.inspect}"
       end
 
-      # Check if the version is supported
-      version = versions.first
-      unless version == "2.0.0"
+      version = versions.values.first
+      unless version == SUPPORTED_SCHEMA_VERSION
         raise Errors::UnsupportedVersionError,
-              "Unsupported database version: #{version}. Only version 2.0.0 is supported."
+              "Unsupported database version: #{version}. Only version #{SUPPORTED_SCHEMA_VERSION} 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
+      version
+    end
+
+    def self.build_database_hash(documents, schema_version)
+      {
+        "schema_version" => schema_version,
+      }.merge(
+        DATABASE_FILES.keys.to_h do |collection_key|
+          document = documents.fetch(collection_key)
+          [collection_key, fetch_collection!(document, collection_key)]
+        end,
+      )
+    end
 
-      from_yaml(combined_yaml)
+    def self.fetch_collection!(document, collection_key)
+      document.fetch(collection_key)
+    rescue KeyError
+      raise Errors::DatabaseFileInvalidError,
+            "Missing #{collection_key} collection in #{DATABASE_FILES.fetch(collection_key)}"
     end
+    private_class_method :validate_schema_versions!, :build_database_hash,
+                         :fetch_collection!
 
     private
 
@@ -533,7 +553,8 @@ module Unitsdb
         ref_type = "dimensions"
         ref_path = "dimensions:index:#{index}:dimension_reference"
 
-        validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs, "dimensions")
+        validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs,
+                           "dimensions")
       end
     end
 
@@ -545,7 +566,8 @@ module Unitsdb
           ref_type = "unit_systems"
           ref_path = "units:index:#{index}:unit_system_reference[#{idx}]"
 
-          validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs, "units")
+          validate_reference(ref_id, ref_type, ref_path, registry,
+                             invalid_refs, "units")
         end
       end
     end
@@ -558,7 +580,8 @@ module Unitsdb
           ref_type = "quantities"
           ref_path = "units:index:#{index}:quantity_references[#{idx}]"
 
-          validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs, "units")
+          validate_reference(ref_id, ref_type, ref_path, registry,
+                             invalid_refs, "units")
         end
       end
     end
@@ -575,7 +598,8 @@ module Unitsdb
           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")
+          validate_reference(ref_id, ref_type, ref_path, registry,
+                             invalid_refs, "units")
 
           # Check prefix reference if present
           next unless root_unit.respond_to?(:prefix_reference) && root_unit.prefix_reference
@@ -584,7 +608,8 @@ module Unitsdb
           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")
+          validate_reference(ref_id, ref_type, ref_path, registry,
+                             invalid_refs, "units")
         end
       end
     end
@@ -608,8 +633,12 @@ module Unitsdb
         # 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? { |k| k.end_with?(":SI_#{id.sub("si-", "")}") } ||
-            registry[ref_type].keys.any? { |k| k.end_with?(":non-SI_#{id.sub("nonsi-", "")}") }
+            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
@@ -617,7 +646,8 @@ module Unitsdb
 
         unless valid
           invalid_refs[file_type] ||= {}
-          invalid_refs[file_type][ref_path] = { id: id, type: type, ref_type: ref_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")
@@ -637,8 +667,12 @@ module Unitsdb
         # 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? { |k| k.end_with?(":SI_#{id.sub("si-", "")}") } ||
-            registry[ref_type].keys.any? { |k| k.end_with?(":non-SI_#{id.sub("nonsi-", "")}") }
+            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
@@ -646,7 +680,8 @@ module Unitsdb
 
         unless valid
           invalid_refs[file_type] ||= {}
-          invalid_refs[file_type][ref_path] = { id: id, type: type, ref_type: ref_type }
+          invalid_refs[file_type][ref_path] =
+            { id: id, type: type, ref_type: ref_type }
         end
       else
         # Handle plain string references (legacy format)
@@ -659,4 +694,6 @@ module Unitsdb
       end
     end
   end
+
+  Config.register_model(Database, id: :database)
 end

data/lib/unitsdb/dimension.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "identifier"
-require_relative "dimension_details"
-require_relative "quantity"
-require_relative "localized_string"
 # NISTd1:
 #   length:
 #     power: 1
@@ -45,5 +41,8 @@ module Unitsdb
     attribute :plane_angle, DimensionDetails
     attribute :short, :string
     attribute :names, LocalizedString, collection: true
+    attribute :references, ExternalReference, collection: true
   end
+
+  Config.register_model(Dimension, id: :dimension)
 end

data/lib/unitsdb/dimension_details.rb

@@ -10,11 +10,12 @@
 #   mathml: "<mi mathvariant='sans-serif'>M</mi>"
 #   unicode: "\U0001D5AC"
 
-require_relative "symbol_presentations"
 module Unitsdb
   class DimensionDetails < Lutaml::Model::Serializable
     attribute :power, :integer
     attribute :symbol, :string
     attribute :symbols, SymbolPresentations, collection: true
   end
+
+  Config.register_model(DimensionDetails, id: :dimension_details)
 end

data/lib/unitsdb/dimension_reference.rb

@@ -5,4 +5,6 @@ module Unitsdb
     attribute :id, :string
     attribute :type, :string
   end
+
+  Config.register_model(DimensionReference, id: :dimension_reference)
 end

data/lib/unitsdb/dimensions.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "dimension"
-
 module Unitsdb
   class Dimensions < Lutaml::Model::Serializable
     # model Config.model_for(:dimensions)
@@ -10,4 +8,6 @@ module Unitsdb
     attribute :version, :string
     attribute :dimensions, Dimension, collection: true
   end
+
+  Config.register_model(Dimensions, id: :dimensions)
 end

data/lib/unitsdb/errors.rb

@@ -9,5 +9,12 @@ module Unitsdb
     class DatabaseLoadError < DatabaseError; end
     class VersionMismatchError < DatabaseError; end
     class UnsupportedVersionError < DatabaseError; end
+
+    # CLI-specific errors
+    class CLIRuntimeError < StandardError; end
+    class InvalidParameterError < CLIRuntimeError; end
+    class FileNotFoundError < CLIRuntimeError; end
+    class ValidationError < CLIRuntimeError; end
+    class InvalidFormatError < CLIRuntimeError; end
   end
 end

data/lib/unitsdb/external_reference.rb

@@ -11,4 +11,6 @@ module Unitsdb
     attribute :type, :string, values: %w[normative informative]
     attribute :authority, :string
   end
+
+  Config.register_model(ExternalReference, id: :external_reference)
 end

data/lib/unitsdb/identifier.rb

@@ -5,4 +5,6 @@ module Unitsdb
     attribute :id, :string
     attribute :type, :string
   end
+
+  Config.register_model(Identifier, id: :identifier)
 end

data/lib/unitsdb/localized_string.rb

@@ -14,4 +14,6 @@ module Unitsdb
       value&.downcase
     end
   end
+
+  Config.register_model(LocalizedString, id: :localized_string)
 end

data/lib/unitsdb/prefix.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "identifier"
-require_relative "symbol_presentations"
-require_relative "external_reference"
-require_relative "localized_string"
 # ---
 # NISTp10_30:
 #   name: quetta
@@ -27,4 +23,6 @@ module Unitsdb
     attribute :power, :integer
     attribute :references, ExternalReference, collection: true
   end
+
+  Config.register_model(Prefix, id: :prefix)
 end

data/lib/unitsdb/prefix_reference.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "identifier"
-
 module Unitsdb
   class PrefixReference < Identifier
     attribute :id, :string
     attribute :type, :string
   end
+
+  Config.register_model(PrefixReference, id: :prefix_reference)
 end

data/lib/unitsdb/prefixes.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "prefix"
 # ---
 # NISTp10_30:
 #   name: quetta
@@ -20,4 +19,6 @@ module Unitsdb
     attribute :version, :string
     attribute :prefixes, Prefix, collection: true
   end
+
+  Config.register_model(Prefixes, id: :prefixes)
 end

data/lib/unitsdb/quantities.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "quantity"
-
 module Unitsdb
   class Quantities < Lutaml::Model::Serializable
     # model Config.model_for(:quantities)
@@ -9,4 +7,6 @@ module Unitsdb
     attribute :version, :string
     attribute :quantities, Quantity, collection: true
   end
+
+  Config.register_model(Quantities, id: :quantities)
 end

data/lib/unitsdb/quantity.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "identifier"
-require_relative "unit_reference"
-require_relative "dimension_reference"
-require_relative "external_reference"
-require_relative "localized_string"
-
 module Unitsdb
   class Quantity < Lutaml::Model::Serializable
     # model Config.model_for(:quantity)
@@ -18,4 +12,6 @@ module Unitsdb
     attribute :dimension_reference, DimensionReference
     attribute :references, ExternalReference, collection: true
   end
+
+  Config.register_model(Quantity, id: :quantity)
 end