lutaml-store 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c26211ca36caae48ef419c2feb670e6d35ddfb958b97b27eb04173c16eaa804
-  data.tar.gz: '06953ee0ec088797069476ccd0a2595aaae24b71fc295b3882ac628464b53da0'
+  metadata.gz: 4917f68f56456a19670424157dd5001d243b9bd6d97618f445d306a7998e2a9f
+  data.tar.gz: 7076d765cf18cc91bfa9cf252bb0117ea8870c915bf1e7421648d9490de7e6a5
 SHA512:
-  metadata.gz: ac429b0436457ac91e52d18290c407598529d041294911c652a33fda075b4f24373965aea422568e85bcfa68e978a64fb4dc45b642fb9034555869a597ccb161
-  data.tar.gz: fefac8e5929d619716a9cf890601928fb52738b3ecb5d6a861a90d7d28db7902624108a8d2054a230ea4810291001690455777e0cbcebaa912fd9c8f67f11591
+  metadata.gz: 897f40bf4972373587528a80afcc44ab2b0c159f2bba63a97f39cb997eff97d3633d7e34cabeb0dac37e1b337781f0aef60b9ffaae2b3a3426d5624b35fb7950
+  data.tar.gz: 1b79b56672ace97f0b6e57715b1b56b7f4638b1d426db57b8f57c5ed21eb461a7fd2ff4181f57afaa094d85c9b7da37f9e3d4771c04afecfcef0c268e86ddcd7

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-06-05 04:23:39 UTC using RuboCop version 1.87.0.
+# on 2026-06-05 09:38:49 UTC using RuboCop version 1.87.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -16,7 +16,7 @@ Gemspec/RequiredRubyVersion:
 Metrics/AbcSize:
   Max: 112
 
-# Offense count: 50
+# Offense count: 57
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 # AllowedMethods: refine
 Metrics/BlockLength:
@@ -30,9 +30,9 @@ Metrics/ClassLength:
 # Offense count: 9
 # Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/CyclomaticComplexity:
-  Max: 11
+  Max: 12
 
-# Offense count: 80
+# Offense count: 79
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 84
@@ -42,10 +42,10 @@ Metrics/MethodLength:
 Metrics/ParameterLists:
   Max: 8
 
-# Offense count: 5
+# Offense count: 4
 # Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/PerceivedComplexity:
-  Max: 11
+  Max: 12
 
 # Offense count: 1
 Naming/AccessorMethodName:
@@ -84,7 +84,7 @@ Security/MarshalLoad:
   Exclude:
     - 'lib/lutaml/store/format/marshal_format.rb'
 
-# Offense count: 35
+# Offense count: 36
 # Configuration parameters: AllowedConstants.
 Style/Documentation:
   Enabled: false

data/CLAUDE.md

@@ -28,30 +28,43 @@ This is a Ruby gem (`lutaml-store`) providing a store-centric database-style API
 
 | Class | Role |
 |---|---|
-| `DatabaseStore` | High-level CRUD with model registry, composite models, polymorphism |
+| `DatabaseStore` | High-level CRUD with model registry, composite models, polymorphism, file I/O |
 | `BasicStore` | Low-level key-value store with optional cache/monitor/events |
 | `CacheStore` | TTL-aware cache store extending `BasicStore` |
+| `PackageStore` | Structured multi-model packages with directory/ZIP transport |
+| `PackageDefinition` | Declarative schema for package structure (models, assets, metadata) |
 | `ModelRegistry` / `ModelRegistration` | Register models with their key fields and polymorphic config |
 | `CompositeModelHandler` | Stores nested registered models independently, restores references |
 | `AttributeUpdater` | Processes updates including dot-notation paths and block-based updates |
-| `ModelSerializer` | Single point of serialization/deserialization for Lutaml::Model objects |
-| `Config` | Parses and validates store configuration (adapter, cache, monitoring, compression) |
+| `ModelSerializer` | Hash-based serialization/deserialization for key-value storage |
+| `FormatSerializer` | Bridges any Format handler to ModelSerializer interface for DatabaseStore |
+| `Format` | Multi-format file I/O (YAML, YAMLS, JSON, JSONL, Marshal, XML) |
+| `Adapter` | Storage adapter registry and factory (Memory, FileSystem, SQLite) |
+
+### Format handlers (`lib/lutaml/store/format/`)
+
+All inherit from `Format::Base`. Six formats: `Yaml`, `Yamls`, `Json`, `Jsonl`, `MarshalFormat`, `Xml`. Each implements `serialize`/`deserialize`, optional `serialize_many`/`deserialize_many`, `extension`, `glob_pattern`, and `binary?`. Registered in `Format::FORMATS` hash and resolved via `Format.resolve(:symbol)`.
 
 ### Storage adapters (`lib/lutaml/store/adapter/`)
 
-All inherit from `Adapter::Base`. Three backends: `Memory`, `FileSystem`, `SQLite`. The `DatabaseStore` creates the adapter internally via `BasicStore`; the adapter type is passed as `adapter: :memory`, `adapter: { type: :filesystem, path: "..." }`, etc.
+All inherit from `Adapter::Base`. Three backends: `Memory`, `FileSystem`, `SQLite`. Registered in `Adapter` module and resolved via `Adapter.resolve(:type, options)`. New adapters can be added with `Adapter.register(:custom, CustomClass)` without modifying existing code (OCP).
 
-### HTTP caching
+### PackageStore and transports
 
-`HttpCache` provides HTTP-aware caching with ETags, conditional requests (304), Cache-Control, and Vary header support. Used by lutaml-hal to avoid re-fetching HAL resources.
+`PackageStore` provides structured multi-model persistence. `PackageDefinition` declares which models, assets, and metadata the package contains. Transports (`DirectoryTransport`, `ZipTransport`) handle reading/writing to disk. Format handlers determine serialization per model entry.
 
-### Serialization & integrity
+### FormatSerializer pattern
+
+`FormatSerializer` wraps a Format handler to implement the serializer interface (serialize/deserialize). This enables `DatabaseStore` to use any format (YAMLS, XML, Marshal, etc.) for key-value storage instead of the default hash serialization. Used for Glossarist-like YAMLS patterns.
+
+### HTTP caching
 
-`Compression` adds gzip support. `Integrity` provides SHA256 checksums for data verification (used by the FileSystem adapter).
+`HttpCache` provides HTTP-aware caching with ETags, conditional requests (304), Cache-Control, and Vary header support. Uses `to_json`/`from_json` for model-driven serialization.
 
 ## Conventions
 
 - Double-quoted strings (Rubocop enforced)
 - Specs use `expect` syntax (no `should`)
-- Documentation is in AsciiDoc (README.adoc, plan.adoc)
+- Documentation is in AsciiDoc (README.adoc)
+- All library code uses Ruby `autoload` (no `require_relative` or internal `require`)
 - Error hierarchy: `Lutaml::Store::Error` → `ConfigurationError`, `BackendError`, `ModelNotRegisteredError`, `InvalidKeyError`, `PolymorphicUpdateError`, `CompositeModelError`

data/README.adoc

@@ -309,40 +309,154 @@ store.destroy(model: User, user_id: "u1")
 == PackageStore
 
 `PackageStore` provides structured multi-model persistence with directory and ZIP
-transports. It is built on `PackageDefinition`, which declares the package schema
-declaratively.
+transports. Use it when you need to bundle multiple model types, binary assets,
+and metadata into a single loadable package.
+
+The workflow is: define the package schema with `PackageDefinition`, then load,
+query, modify, and save using `PackageStore`.
 
 === Define a package
 
+`PackageDefinition` declares the package structure — which models, assets, and
+metadata the package contains:
+
 [source,ruby]
 ----
-glossary = Lutaml::Store::PackageDefinition.new(name: "glossary") do |pkg|
+require "lutaml/model"
+require "lutaml/store"
+
+# Define your models
+class Concept < Lutaml::Model::Serializable
+  attribute :term, :string
+  attribute :definition, :string
+end
+
+class Author < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :email, :string
+end
+
+class GlossaryInfo < Lutaml::Model::Serializable
+  attribute :title, :string
+  attribute :version, :string
+end
+
+# Declare the package schema
+glossary = Lutaml::Store::PackageDefinition.new(
+  name: "glossary",
+  metadata_model: GlossaryInfo,
+  metadata_file: "glossary.yaml",
+  metadata_key: :title
+) do |pkg|
+  # Models stored in subdirectories, one file per instance
   pkg.model(model: Concept, key: :term, dir: "concepts", default_format: :yaml)
   pkg.model(model: Author, key: :name, dir: "authors", default_format: :json)
-  pkg.asset("glossary.yaml", type: :file)
-  pkg.metadata_model = GlossaryInfo
-  pkg.metadata_file = "glossary.yaml"
+
+  # Binary assets bundled in the package
+  pkg.asset("logo.png", type: :file)
+  pkg.asset("attachments", type: :directory)
 end
 ----
 
-=== Load and save packages
+Each `pkg.model` call registers a model type with:
+
+* `model:` — the `Lutaml::Model::Serializable` class
+* `key:` — attribute used as the unique identifier (becomes the filename)
+* `dir:` — subdirectory for this model type (use `file:` instead for a single-file model)
+* `layout:` — `:separate` (one file per instance, default) or `:grouped` (multiple instances per file)
+* `default_format:` — `:yaml`, `:json`, `:jsonl`, `:yamls`, or `:marshal`
+
+=== Directory structure
+
+When saved to disk, the glossary package produces:
+
+----
+my_glossary/
+├── glossary.yaml          # metadata (GlossaryInfo)
+├── concepts/              # Concept model instances
+│   ├── API.yaml
+│   ├── REST.yaml
+│   └── YAML.yaml
+├── authors/               # Author model instances
+│   ├── john_doe.json
+│   └── jane_smith.json
+├── logo.png               # asset file
+└── attachments/           # asset directory
+    └── spec.pdf
+----
+
+=== Load and query
 
 [source,ruby]
 ----
 # Load from directory
-store = Lutaml::Store::PackageStore.load(glossary, "./my_glossary", transport: :directory)
+store = Lutaml::Store::PackageStore.load(glossary, "./my_glossary")
 
-# Load from ZIP
+# Load from ZIP file
 store = Lutaml::Store::PackageStore.load(glossary, "./glossary.zip", transport: :zip)
 
+# Access metadata
+store.metadata  # => GlossaryInfo instance
+
 # Query models
-concepts = store.models_for(Concept)
-store.model_count(Concept)  # => 42
-store.fetch_model(Concept, "API")
+concepts = store.models_for(Concept)   # => array of Concept instances
+concept = store.fetch_model(Concept, "API")
+store.model_count(Concept)             # => 3
+store.model_exists?(Concept, "REST")   # => true
+
+# Access assets
+store.asset("logo.png")  # => binary content
+store.asset_paths        # => ["logo.png", "attachments/spec.pdf"]
+
+# Package statistics
+store.stats
+# => { package: "glossary", models: { "Concept" => 3, "Author" => 2 },
+#      assets: 2, metadata: true }
+----
+
+=== Modify and save
+
+[source,ruby]
+----
+# Add models
+store.add_model(Concept.new(term: "JSON", definition: "..."))
+store.add_models([concept1, concept2])
+
+# Remove models
+store.remove_model(Concept, "deprecated_term")
+
+# Add/remove assets
+store.add_asset("diagram.svg", svg_content)
+store.remove_asset("old_diagram.svg")
+
+# Save to directory (default format per model)
+store.save("./output")
+
+# Save to ZIP with per-model format overrides
+store.save("./glossary.zip", transport: :zip, formats: { Concept => :json })
+
+# Save with global format override
+store.save("./output", format: :yaml)
+
+# Bulk operations
+store.clear_models(Concept)  # remove all Concept instances
+store.clear_all              # remove everything
+----
+
+=== Per-model format override
+
+The `save` method accepts format overrides:
+
+[source,ruby]
+----
+# Global format for all models
+store.save("./out", format: :json)
+
+# Per-model format
+store.save("./out", formats: { Concept => :yaml, Author => :jsonl })
 
-# Modify and save
-store.add_model(Concept.new(term: "REST", definition: "..."))
-store.save("./output", transport: :zip)
+# Default: each model uses its default_format from the definition
+store.save("./out")
 ----
 
 === Package transports

data/lib/lutaml/store/adapter.rb

@@ -7,6 +7,23 @@ module Lutaml
       autoload :Memory, "lutaml/store/adapter/memory"
       autoload :FileSystem, "lutaml/store/adapter/filesystem"
       autoload :Sqlite, "lutaml/store/adapter/sqlite"
+
+      @registry = {
+        memory: "Memory",
+        filesystem: "FileSystem",
+        sqlite: "Sqlite"
+      }
+
+      def self.resolve(type, options = {})
+        entry = @registry[type.to_sym]
+        raise ConfigurationError, "Unknown adapter type: #{type}" unless entry
+
+        const_get(entry).new(options)
+      end
+
+      def self.register(type, adapter_class)
+        @registry[type.to_sym] = adapter_class.name
+      end
     end
   end
 end

data/lib/lutaml/store/basic_store.rb

@@ -167,16 +167,7 @@ module Lutaml
       end
 
       def create_adapter
-        case @config.adapter_type
-        when :memory
-          Adapter::Memory.new(@config.adapter_options)
-        when :filesystem
-          Adapter::FileSystem.new(@config.adapter_options)
-        when :sqlite
-          Adapter::Sqlite.new(@config.adapter_options)
-        else
-          raise ConfigurationError, "Unknown adapter type: #{@config.adapter_type}"
-        end
+        Adapter.resolve(@config.adapter_type, @config.adapter_options)
       end
 
       def create_cache

data/lib/lutaml/store/cache_store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 
 module Lutaml
   module Store
@@ -246,16 +247,7 @@ module Lutaml
         adapter_type = config[:adapter]&.dig(:type) || config[:adapter_type] || :memory
         adapter_options = config[:adapter]&.dig(:options) || config[:adapter_options] || {}
 
-        case adapter_type.to_sym
-        when :memory
-          Adapter::Memory.new(adapter_options)
-        when :filesystem
-          Adapter::FileSystem.new(adapter_options)
-        when :sqlite
-          Adapter::Sqlite.new(adapter_options)
-        else
-          raise ConfigurationError, "Unknown adapter type: #{adapter_type}"
-        end
+        Adapter.resolve(adapter_type, adapter_options)
       end
 
       def serialize_entry(entry)

data/lib/lutaml/store/database_store.rb

@@ -207,7 +207,7 @@ module Lutaml
 
         content = fmt.serialize_many(models_array)
 
-        File.write(path, content, encoding: "utf-8")
+        write_file(path, content, fmt)
         @store.emit_event(:model_export, count: models_array.size, path: path)
         path
       end
@@ -331,8 +331,8 @@ module Lutaml
         Dir.glob(glob).sort.each do |file_path|
           next unless File.file?(file_path)
 
-          raw = File.read(file_path, encoding: "utf-8")
-          next if raw.strip.empty?
+          raw = read_file(file_path, fmt)
+          next if !fmt.binary? && raw.strip.empty?
 
           begin
             model = fmt.deserialize(raw, model_class)
@@ -351,8 +351,8 @@ module Lutaml
         Dir.glob(glob).sort.each do |file_path|
           next unless File.file?(file_path)
 
-          raw = File.read(file_path, encoding: "utf-8")
-          next if raw.strip.empty?
+          raw = read_file(file_path, fmt)
+          next if !fmt.binary? && raw.strip.empty?
 
           begin
             loaded = fmt.deserialize_many(raw, model_class)
@@ -375,8 +375,7 @@ module Lutaml
           key = extract_model_key(model)
           filename = key || model.class.name.to_s.gsub("::", "_")
           file_path = File.join(dir, "#{filename}#{fmt.extension}")
-          content = fmt.serialize(model)
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, fmt.serialize(model), fmt)
           model
         end
       end
@@ -391,8 +390,7 @@ module Lutaml
 
         grouped.map do |key, group|
           file_path = File.join(dir, "#{key}#{fmt.extension}")
-          content = fmt.serialize_many(group)
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, fmt.serialize_many(group), fmt)
           group
         end.flatten
       end
@@ -420,6 +418,18 @@ module Lutaml
         basename = File.basename(file_path, ".*")
         model.public_send(:"#{registration.key_field}=", basename)
       end
+
+      def read_file(file_path, fmt)
+        fmt.binary? ? File.binread(file_path) : File.read(file_path, encoding: "utf-8")
+      end
+
+      def write_file(file_path, content, fmt)
+        if fmt.binary?
+          File.binwrite(file_path, content)
+        else
+          File.write(file_path, content, encoding: "utf-8")
+        end
+      end
     end
   end
 end

data/lib/lutaml/store/format/base.rb

@@ -27,6 +27,10 @@ module Lutaml
         def deserialize_many(_data, _model_class)
           raise NotImplementedError, "#{self.class} does not support multi-document deserialization"
         end
+
+        def binary?
+          false
+        end
       end
     end
   end

data/lib/lutaml/store/format/marshal_format.rb

@@ -31,6 +31,10 @@ module Lutaml
           hash_array = ::Marshal.load(data)
           hash_array.map { |h| model_class.from_hash(h) }
         end
+
+        def binary?
+          true
+        end
       end
     end
   end

data/lib/lutaml/store/format/xml.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    module Format
+      class Xml < Base
+        def extension
+          ".xml"
+        end
+
+        def glob_pattern
+          "*.xml"
+        end
+
+        def serialize(model)
+          model.to_xml
+        end
+
+        def deserialize(data, model_class)
+          model_class.from_xml(data)
+        end
+
+        def serialize_many(models)
+          inner = models.map(&:to_xml).join("\n")
+          "<items>\n#{inner}\n</items>"
+        end
+
+        def deserialize_many(data, model_class)
+          doc = Moxml.parse(data)
+          doc.root.children.select(&:element?).map do |child|
+            model_class.from_xml(child.to_xml)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/format/yamls.rb

@@ -17,7 +17,7 @@ module Lutaml
         end
 
         def serialize_many(models)
-          models.map(&:to_yamls).join
+          models.map(&:to_yamls).join("\n")
         end
 
         def deserialize(data, model_class)

data/lib/lutaml/store/format.rb

@@ -13,13 +13,15 @@ module Lutaml
       autoload :Json, "lutaml/store/format/json"
       autoload :Jsonl, "lutaml/store/format/jsonl"
       autoload :MarshalFormat, "lutaml/store/format/marshal_format"
+      autoload :Xml, "lutaml/store/format/xml"
 
       FORMATS = {
         yaml: "Yaml",
         yamls: "Yamls",
         json: "Json",
         jsonl: "Jsonl",
-        marshal: "MarshalFormat"
+        marshal: "MarshalFormat",
+        xml: "Xml"
       }.freeze
 
       def self.resolve(format)

data/lib/lutaml/store/format_serializer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Bridges a Format handler to the ModelSerializer interface.
+    # Enables DatabaseStore to use any format (yaml, json, xml, yamls, marshal)
+    # for key-value storage instead of the default hash serialization.
+    #
+    # Usage:
+    #   serializer = FormatSerializer.new(:yamls)
+    #   store = DatabaseStore.new(
+    #     adapter: :sqlite,
+    #     models: [{ model: ConceptDocument, key: :id, serializer: serializer }]
+    #   )
+    class FormatSerializer
+      DATA_KEY = "_data"
+      CLASS_KEY = "_class"
+
+      def initialize(format)
+        @format = Format.resolve(format)
+      end
+
+      def serialize(model)
+        {
+          DATA_KEY => @format.serialize(model),
+          CLASS_KEY => model.class.name
+        }
+      end
+
+      def deserialize(data, model_class)
+        model_class = resolve_class(data[CLASS_KEY]) if data[CLASS_KEY]
+        @format.deserialize(data[DATA_KEY], model_class)
+      end
+
+      private
+
+      def resolve_class(class_name)
+        Object.const_get(class_name)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/lutaml/store/package_transport/base.rb

@@ -42,6 +42,18 @@ module Lutaml
         def sanitize_filename(key)
           key.gsub(%r{[/:#?]}, "_")
         end
+
+        def read_file(file_path, fmt)
+          fmt.binary? ? File.binread(file_path) : File.read(file_path, encoding: "utf-8")
+        end
+
+        def write_file(file_path, content, fmt)
+          if fmt.binary?
+            File.binwrite(file_path, content)
+          else
+            File.write(file_path, content, encoding: "utf-8")
+          end
+        end
       end
     end
   end

data/lib/lutaml/store/package_transport/directory_transport.rb

@@ -47,7 +47,7 @@ module Lutaml
           return unless File.exist?(file_path)
 
           fmt = format_for_file(definition.metadata_file)
-          raw = File.read(file_path, encoding: "utf-8")
+          raw = read_file(file_path, fmt)
           metadata = fmt.deserialize(raw, definition.metadata_model)
           package_store.metadata = metadata
         end
@@ -60,7 +60,7 @@ module Lutaml
           content = fmt.serialize(package_store.metadata)
           file_path = File.join(path, definition.metadata_file)
           FileUtils.mkdir_p(File.dirname(file_path))
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, content, fmt)
         end
 
         def read_model_entry(base_path, entry, package_store, fmt_name)
@@ -76,7 +76,7 @@ module Lutaml
           return unless File.exist?(file_path)
 
           fmt = resolve_format(fmt_name)
-          raw = File.read(file_path, encoding: "utf-8")
+          raw = read_file(file_path, fmt)
           model = fmt.deserialize(raw, entry.model)
           package_store.add_model(model)
         end
@@ -91,8 +91,8 @@ module Lutaml
           Dir.glob(glob).sort.each do |file_path|
             next unless File.file?(file_path)
 
-            raw = File.read(file_path, encoding: "utf-8")
-            next if raw.strip.empty?
+            raw = read_file(file_path, fmt)
+            next if !fmt.binary? && raw.strip.empty?
 
             begin
               case entry.layout
@@ -127,7 +127,7 @@ module Lutaml
           content = entry.layout == :grouped ? fmt.serialize_many(models) : fmt.serialize(models.first)
           file_path = File.join(base_path, entry.file)
           FileUtils.mkdir_p(File.dirname(file_path))
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, content, fmt)
         end
 
         def write_directory_models(base_path, entry, models, fmt)
@@ -138,13 +138,13 @@ module Lutaml
           when :grouped
             models.group_by { |m| extract_key(m, entry) }.each do |key, group|
               file_path = File.join(dir, "#{sanitize_filename(key)}#{fmt.extension}")
-              File.write(file_path, fmt.serialize_many(group), encoding: "utf-8")
+              write_file(file_path, fmt.serialize_many(group), fmt)
             end
           else
             models.each do |model|
               key = extract_key(model, entry)
               file_path = File.join(dir, "#{sanitize_filename(key)}#{fmt.extension}")
-              File.write(file_path, fmt.serialize(model), encoding: "utf-8")
+              write_file(file_path, fmt.serialize(model), fmt)
             end
           end
         end

data/lib/lutaml/store/package_transport/zip_transport.rb

@@ -93,14 +93,19 @@ module Lutaml
             next if zip_entry.name == prefix || zip_entry.name.end_with?("/")
 
             raw = zip_entry.get_input_stream.read
-            next if raw.strip.empty?
+            next if !fmt.binary? && raw.strip.empty?
 
             begin
-              loaded = fmt.deserialize_many(raw, entry.model)
-              loaded = [loaded] unless loaded.is_a?(Array)
-              loaded.each do |m|
-                set_key_from_zip_path(m, zip_entry.name, entry, prefix)
-                package_store.add_model(m)
+              case entry.layout
+              when :grouped
+                fmt.deserialize_many(raw, entry.model).each do |m|
+                  set_key_from_zip_path(m, zip_entry.name, entry, prefix)
+                  package_store.add_model(m)
+                end
+              else
+                model = fmt.deserialize(raw, entry.model)
+                set_key_from_zip_path(model, zip_entry.name, entry, prefix)
+                package_store.add_model(model)
               end
             rescue StandardError => e
               warn "PackageStore: failed to load #{zip_entry.name}: #{e.message}"

data/lib/lutaml/store/storage_key.rb

@@ -18,7 +18,7 @@ module Lutaml
 
       def self.parse(string)
         str = string.to_s
-        sep = str.rindex(/(?<!:):(?!:)/)
+        sep = str.index(/(?<!:):(?!:)/)
         return new("", str) unless sep
 
         new(str[0...sep], str[sep + 1..])

data/lib/lutaml/store/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Store
-    VERSION = "0.2.1"
+    VERSION = "0.2.2"
   end
 end

data/lib/lutaml/store.rb

@@ -25,6 +25,7 @@ module Lutaml
     autoload :CompositeModelHandler, "lutaml/store/composite_model_handler"
     autoload :AttributeUpdater, "lutaml/store/attribute_updater"
     autoload :DatabaseStore, "lutaml/store/database_store"
+    autoload :FormatSerializer, "lutaml/store/format_serializer"
     autoload :PackageDefinition, "lutaml/store/package_definition"
     autoload :PackageStore, "lutaml/store/package_store"
     autoload :PackageTransport, "lutaml/store/package_transport"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-store
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ronald Tse
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-05 00:00:00.000000000 Z
+date: 2026-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -75,8 +75,10 @@ files:
 - lib/lutaml/store/format/json.rb
 - lib/lutaml/store/format/jsonl.rb
 - lib/lutaml/store/format/marshal_format.rb
+- lib/lutaml/store/format/xml.rb
 - lib/lutaml/store/format/yaml.rb
 - lib/lutaml/store/format/yamls.rb
+- lib/lutaml/store/format_serializer.rb
 - lib/lutaml/store/http_cache.rb
 - lib/lutaml/store/http_cache_config.rb
 - lib/lutaml/store/http_cache_entry.rb