lutaml-store 0.1.1

data/spec/lutaml/store/database_store_spec.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module DatabaseStoreTestModels
+  class TestStudio < Lutaml::Model::Serializable
+    attribute :studio_key, :string
+    attribute :name, :string
+    attribute :location, :string
+    attribute :_class, :string, default: -> { "TestStudio" }, polymorphic_class: true
+  end
+
+  class TestCeramicStudio < TestStudio
+    attribute :clay_type, :string
+    attribute :_class, :string, default: -> { "TestCeramicStudio" }
+  end
+
+  class TestPotteryClass < Lutaml::Model::Serializable
+    attribute :class_id, :string
+    attribute :description, :string
+    attribute :studio, TestStudio, polymorphic: true
+  end
+end
+
+RSpec.describe Lutaml::Store::DatabaseStore do
+  let(:config) { { adapter_type: :memory } }
+
+  let(:models) do
+    [
+      { model: DatabaseStoreTestModels::TestPotteryClass, key: :class_id },
+      { model: DatabaseStoreTestModels::TestStudio, key: :studio_key, polymorphic_class_key: :_class },
+      { model: DatabaseStoreTestModels::TestCeramicStudio, key: :studio_key, polymorphic_class_key: :_class }
+    ]
+  end
+
+  let(:store) { described_class.new(adapter: :memory, models: models) }
+
+  describe "#initialize" do
+    it "creates a database store with models" do
+      expect(store).to be_a(described_class)
+      expect(store.registry.count).to eq(3)
+    end
+
+    it "raises error when no models provided" do
+      expect do
+        described_class.new(adapter: :memory, models: [])
+      end.to raise_error(Lutaml::Store::ConfigurationError, /No models registered/)
+    end
+  end
+
+  describe "#save and #fetch" do
+    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
+    let(:pottery_class) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio
+      )
+    end
+
+    it "saves and fetches a model with composite relationships" do
+      store.save(pottery_class)
+
+      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
+      expect(fetched).to be_a(DatabaseStoreTestModels::TestPotteryClass)
+      expect(fetched.class_id).to eq("pottery_101")
+      expect(fetched.description).to eq("Basic pottery")
+      expect(fetched.studio).to be_a(DatabaseStoreTestModels::TestStudio)
+      expect(fetched.studio.studio_key).to eq("test_studio")
+      expect(fetched.studio.name).to eq("Test Studio")
+    end
+
+    it "handles polymorphic models correctly" do
+      ceramic_studio = DatabaseStoreTestModels::TestCeramicStudio.new(
+        studio_key: "ceramic_studio",
+        name: "Ceramic Studio",
+        clay_type: "Porcelain"
+      )
+
+      store.save(ceramic_studio)
+
+      fetched = store.fetch(model: DatabaseStoreTestModels::TestStudio, studio_key: "ceramic_studio")
+      expect(fetched).to be_a(DatabaseStoreTestModels::TestCeramicStudio)
+      expect(fetched.clay_type).to eq("Porcelain")
+    end
+
+    it "returns nil for non-existent models" do
+      result = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "nonexistent")
+      expect(result).to be_nil
+    end
+  end
+
+  describe "#update" do
+    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
+    let(:pottery_class) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio
+      )
+    end
+
+    before { store.save(pottery_class) }
+
+    it "updates with block" do
+      updated = store.update(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101") do |model|
+        model.description = "Advanced pottery"
+        model
+      end
+
+      expect(updated.description).to eq("Advanced pottery")
+
+      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
+      expect(fetched.description).to eq("Advanced pottery")
+    end
+
+    it "updates with hash including dot notation" do
+      updated = store.update(
+        model: DatabaseStoreTestModels::TestPotteryClass,
+        class_id: "pottery_101",
+        attributes: { "studio.location" => "Downtown" }
+      )
+
+      expect(updated.studio.location).to eq("Downtown")
+
+      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
+      expect(fetched.studio.location).to eq("Downtown")
+    end
+  end
+
+  describe "#destroy" do
+    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
+    let(:pottery_class) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio
+      )
+    end
+
+    before { store.save(pottery_class) }
+
+    it "destroys a model and its composite relationships" do
+      result = store.destroy(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
+      expect(result).to be true
+
+      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
+      expect(fetched).to be_nil
+
+      studio_fetched = store.fetch(model: DatabaseStoreTestModels::TestStudio, studio_key: "test_studio")
+      expect(studio_fetched).to be_nil
+    end
+
+    it "returns false for non-existent models" do
+      result = store.destroy(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "nonexistent")
+      expect(result).to be false
+    end
+  end
+
+  describe "#where" do
+    let(:studio1) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio1", name: "Studio One") }
+    let(:studio2) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio2", name: "Studio Two") }
+    let(:pottery1) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio1
+      )
+    end
+    let(:pottery2) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_201",
+        description: "Advanced pottery",
+        studio: studio2
+      )
+    end
+
+    before do
+      store.save([pottery1, pottery2])
+    end
+
+    it "finds models by criteria" do
+      results = store.where(model: DatabaseStoreTestModels::TestPotteryClass, description: "Basic pottery")
+      expect(results.size).to eq(1)
+      expect(results.first.class_id).to eq("pottery_101")
+    end
+  end
+
+  describe "#all" do
+    let(:studio1) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio1", name: "Studio One") }
+    let(:studio2) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio2", name: "Studio Two") }
+    let(:pottery1) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio1
+      )
+    end
+    let(:pottery2) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_201",
+        description: "Advanced pottery",
+        studio: studio2
+      )
+    end
+
+    before do
+      store.save([pottery1, pottery2])
+    end
+
+    it "returns all models of a specific type" do
+      results = store.all(model: DatabaseStoreTestModels::TestPotteryClass)
+      expect(results.size).to eq(2)
+      expect(results.map(&:class_id)).to contain_exactly("pottery_101", "pottery_201")
+    end
+  end
+
+  describe "#exists?" do
+    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
+    let(:pottery_class) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio
+      )
+    end
+
+    before { store.save(pottery_class) }
+
+    it "returns true for existing models" do
+      expect(store.exists?(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")).to be true
+    end
+
+    it "returns false for non-existent models" do
+      expect(store.exists?(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "nonexistent")).to be false
+    end
+  end
+
+  describe "#count" do
+    let(:studio1) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio1", name: "Studio One") }
+    let(:studio2) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio2", name: "Studio Two") }
+    let(:pottery1) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_101",
+        description: "Basic pottery",
+        studio: studio1
+      )
+    end
+    let(:pottery2) do
+      DatabaseStoreTestModels::TestPotteryClass.new(
+        class_id: "pottery_201",
+        description: "Advanced pottery",
+        studio: studio2
+      )
+    end
+
+    before do
+      store.save([pottery1, pottery2])
+    end
+
+    it "returns count of models" do
+      expect(store.count(model: DatabaseStoreTestModels::TestPotteryClass)).to eq(2)
+      expect(store.count(model: DatabaseStoreTestModels::TestStudio)).to eq(2)
+    end
+  end
+
+  describe "#stats" do
+    it "provides statistics" do
+      stats = store.stats
+      expect(stats).to include(:models_registered, :registered_models, :total_models)
+      expect(stats[:models_registered]).to eq(3)
+      expect(stats[:registered_models]).to include(
+        "DatabaseStoreTestModels::TestPotteryClass",
+        "DatabaseStoreTestModels::TestStudio",
+        "DatabaseStoreTestModels::TestCeramicStudio"
+      )
+    end
+  end
+end

data/spec/lutaml/store/file_io_spec.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+require "json"
+
+class FileTestItem < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :value, :string
+
+  key_value do
+    map :name, to: :name
+    map :value, to: :value
+  end
+end
+
+RSpec.describe "Lutaml::Store file I/O" do
+  let(:tmpdir) { Dir.mktmpdir }
+  after { FileUtils.rm_rf(tmpdir) }
+
+  let(:store) do
+    Lutaml::Store.new(
+      adapter: :memory,
+      models: [{ model: FileTestItem, key: :name, dir: "items" }]
+    )
+  end
+
+  let(:items) do
+    [
+      FileTestItem.new(name: "alpha", value: "first"),
+      FileTestItem.new(name: "beta", value: "second"),
+      FileTestItem.new(name: "gamma", value: "third")
+    ]
+  end
+
+  def items_dir
+    File.join(tmpdir, "items")
+  end
+
+  # ── YAML format ──
+
+  describe "YAML separate layout" do
+    it "round-trips models" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
+
+      expect(Dir.glob(File.join(items_dir, "*.{yaml,yml}")).size).to eq(3)
+
+      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :separate)
+      expect(loaded.size).to eq(3)
+      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
+      expect(loaded.map(&:value).sort).to eq(%w[first second third])
+    end
+
+    it "writes one file per model named by key" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
+
+      expect(File.exist?(File.join(items_dir, "alpha.yaml"))).to be true
+      expect(File.exist?(File.join(items_dir, "beta.yaml"))).to be true
+      expect(File.exist?(File.join(items_dir, "gamma.yaml"))).to be true
+    end
+  end
+
+  describe "YAML grouped layout" do
+    it "writes one file per key" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
+
+      files = Dir.glob(File.join(items_dir, "*.yaml")).sort
+      expect(files.size).to eq(3)
+    end
+
+    it "round-trips models" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
+
+      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :grouped)
+      expect(loaded.size).to eq(3)
+      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
+    end
+  end
+
+  # ── JSON format ──
+
+  describe "JSON separate layout" do
+    it "round-trips models" do
+      store.save_all(items, path: tmpdir, format: :json, layout: :separate)
+
+      expect(Dir.glob(File.join(items_dir, "*.json")).size).to eq(3)
+
+      loaded = store.load_all(FileTestItem, path: tmpdir, format: :json, layout: :separate)
+      expect(loaded.size).to eq(3)
+      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
+    end
+
+    it "writes valid JSON files" do
+      store.save_all(items, path: tmpdir, format: :json, layout: :separate)
+
+      Dir.glob(File.join(items_dir, "*.json")).each do |path|
+        expect { JSON.parse(File.read(path, encoding: "utf-8")) }.not_to raise_error
+      end
+    end
+  end
+
+  # ── JSONL format ──
+
+  describe "JSONL export/import" do
+    it "exports models to JSONL file" do
+      export_path = File.join(tmpdir, "data.jsonl")
+      store.export(items, path: export_path, format: :jsonl)
+
+      expect(File.exist?(export_path)).to be true
+      lines = File.read(export_path, encoding: "utf-8").lines.reject { |l| l.strip.empty? }
+      expect(lines.size).to eq(3)
+      lines.each { |line| expect { JSON.parse(line) }.not_to raise_error }
+    end
+
+    it "round-trips through JSONL file" do
+      export_path = File.join(tmpdir, "data.jsonl")
+      store.export(items, path: export_path, format: :jsonl)
+
+      fmt = Lutaml::Store::Format.resolve(:jsonl)
+      data = File.read(export_path, encoding: "utf-8")
+      loaded = fmt.deserialize_many(data, FileTestItem)
+
+      expect(loaded.size).to eq(3)
+      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
+    end
+  end
+
+  # ── Marshal format ──
+
+  describe "Marshal separate layout" do
+    it "round-trips models" do
+      store.save_all(items, path: tmpdir, format: :marshal, layout: :separate)
+
+      expect(Dir.glob(File.join(items_dir, "*.bin")).size).to eq(3)
+
+      loaded = store.load_all(FileTestItem, path: tmpdir, format: :marshal, layout: :separate)
+      expect(loaded.size).to eq(3)
+      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
+    end
+  end
+
+  # ── YAMLS format ──
+
+  describe "YAMLS grouped layout" do
+    it "writes multi-document YAML files" do
+      # Grouped YAMLS: each group file contains multiple docs
+      store.save_all(items, path: tmpdir, format: :yamls, layout: :grouped)
+
+      files = Dir.glob(File.join(items_dir, "*.{yaml,yml}")).sort
+      expect(files.size).to eq(3)
+    end
+
+    it "round-trips models" do
+      store.save_all(items, path: tmpdir, format: :yamls, layout: :grouped)
+
+      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yamls, layout: :grouped)
+      expect(loaded.size).to eq(3)
+      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
+    end
+  end
+
+  # ── Edge cases ──
+
+  describe "empty directory" do
+    it "returns empty array from load_all" do
+      FileUtils.mkdir_p(items_dir)
+
+      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :separate)
+      expect(loaded).to eq([])
+    end
+  end
+
+  describe "empty model list" do
+    it "returns empty array from save_all" do
+      result = store.save_all([], path: tmpdir, format: :yaml, layout: :separate)
+      expect(result).to eq([])
+    end
+  end
+
+  describe "missing directory" do
+    it "raises BackendError for load_all" do
+      expect do
+        store.load_all(FileTestItem, path: "/nonexistent/path", format: :yaml, layout: :separate)
+      end.to raise_error(Lutaml::Store::BackendError, /Directory not found/)
+    end
+  end
+
+  describe "no path provided" do
+    it "raises BackendError for save_all without path" do
+      items_with_no_dir = [
+        FileTestItem.new(name: "x", value: "y")
+      ]
+      # No dir in registration and no path
+      bare_store = Lutaml::Store.new(
+        adapter: :memory,
+        models: [{ model: FileTestItem, key: :name }]
+      )
+      expect do
+        bare_store.save_all(items_with_no_dir, format: :yaml, layout: :separate)
+      end.to raise_error(Lutaml::Store::BackendError, /No directory specified/)
+    end
+  end
+
+  describe "unknown layout" do
+    it "raises ConfigurationError" do
+      expect do
+        store.save_all(items, path: tmpdir, format: :yaml, layout: :unknown)
+      end.to raise_error(Lutaml::Store::ConfigurationError, /Unknown layout/)
+    end
+  end
+
+  describe "unknown format" do
+    it "raises UnsupportedFormatError" do
+      expect do
+        store.save_all(items, path: tmpdir, format: :csv, layout: :separate)
+      end.to raise_error(Lutaml::Store::Format::UnsupportedFormatError)
+    end
+  end
+end

data/spec/lutaml/store/format_round_trip_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "json"
+
+class FormatTestItem < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :value, :string
+  attribute :count, :integer
+
+  key_value do
+    map :name, to: :name
+    map :value, to: :value
+    map :count, to: :count
+  end
+end
+
+RSpec.describe "Format handler round-trips" do
+  let(:item) { FormatTestItem.new(name: "alpha", value: "first", count: 42) }
+  let(:items) do
+    [
+      FormatTestItem.new(name: "alpha", value: "first", count: 1),
+      FormatTestItem.new(name: "beta", value: "second", count: 2)
+    ]
+  end
+
+  shared_examples "single-model round-trip" do |format_sym|
+    it "round-trips a single model through #{format_sym}" do
+      fmt = Lutaml::Store::Format.resolve(format_sym)
+      serialized = fmt.serialize(item)
+      restored = fmt.deserialize(serialized, FormatTestItem)
+
+      expect(restored.name).to eq("alpha")
+      expect(restored.value).to eq("first")
+      expect(restored.count).to eq(42)
+    end
+  end
+
+  shared_examples "multi-model round-trip" do |format_sym|
+    it "round-trips multiple models through #{format_sym}" do
+      fmt = Lutaml::Store::Format.resolve(format_sym)
+      serialized = fmt.serialize_many(items)
+      restored = fmt.deserialize_many(serialized, FormatTestItem)
+
+      expect(restored.size).to eq(2)
+      expect(restored.map(&:name).sort).to eq(%w[alpha beta])
+      expect(restored.map(&:count).sort).to eq([1, 2])
+    end
+  end
+
+  describe Lutaml::Store::Format::Yaml do
+    it_behaves_like "single-model round-trip", :yaml
+    it_behaves_like "multi-model round-trip", :yaml
+
+    it "produces valid YAML" do
+      fmt = described_class.new
+      output = fmt.serialize(item)
+      expect(output).to include("name:")
+      expect(output).to include("value:")
+    end
+  end
+
+  describe Lutaml::Store::Format::Yamls do
+    it_behaves_like "single-model round-trip", :yamls
+    it_behaves_like "multi-model round-trip", :yamls
+
+    it "produces multi-document YAML stream" do
+      fmt = described_class.new
+      output = fmt.serialize_many(items)
+      expect(output.scan(/^---/).size).to be >= 2
+    end
+  end
+
+  describe Lutaml::Store::Format::Json do
+    it_behaves_like "single-model round-trip", :json
+
+    it "produces valid JSON" do
+      fmt = described_class.new
+      output = fmt.serialize(item)
+      parsed = JSON.parse(output)
+      expect(parsed["name"]).to eq("alpha")
+      expect(parsed["count"]).to eq(42)
+    end
+  end
+
+  describe Lutaml::Store::Format::Jsonl do
+    it_behaves_like "single-model round-trip", :jsonl
+    it_behaves_like "multi-model round-trip", :jsonl
+
+    it "produces line-delimited JSON" do
+      fmt = described_class.new
+      output = fmt.serialize_many(items)
+      lines = output.lines.reject { |l| l.strip.empty? }
+      expect(lines.size).to eq(2)
+      lines.each { |line| expect { JSON.parse(line) }.not_to raise_error }
+    end
+  end
+
+  describe Lutaml::Store::Format::MarshalFormat do
+    it_behaves_like "single-model round-trip", :marshal
+    it_behaves_like "multi-model round-trip", :marshal
+
+    it "produces binary data" do
+      fmt = described_class.new
+      output = fmt.serialize(item)
+      expect(output).to be_a(String)
+      expect(output.encoding).to eq(Encoding::ASCII_8BIT)
+    end
+  end
+end

data/spec/lutaml/store/format_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+RSpec.describe Lutaml::Store::Format do
+  describe ".resolve" do
+    it "resolves :yaml format" do
+      fmt = described_class.resolve(:yaml)
+      expect(fmt).to be_a(Lutaml::Store::Format::Yaml)
+    end
+
+    it "resolves :yamls format" do
+      fmt = described_class.resolve(:yamls)
+      expect(fmt).to be_a(Lutaml::Store::Format::Yamls)
+    end
+
+    it "resolves :json format" do
+      fmt = described_class.resolve(:json)
+      expect(fmt).to be_a(Lutaml::Store::Format::Json)
+    end
+
+    it "resolves :jsonl format" do
+      fmt = described_class.resolve(:jsonl)
+      expect(fmt).to be_a(Lutaml::Store::Format::Jsonl)
+    end
+
+    it "resolves :marshal format" do
+      fmt = described_class.resolve(:marshal)
+      expect(fmt).to be_a(Lutaml::Store::Format::MarshalFormat)
+    end
+
+    it "raises for unknown format" do
+      expect { described_class.resolve(:unknown) }
+        .to raise_error(Lutaml::Store::Format::UnsupportedFormatError)
+    end
+  end
+
+  describe Lutaml::Store::Format::Yaml do
+    let(:fmt) { described_class.new }
+
+    it "returns .yaml extension" do
+      expect(fmt.extension).to eq(".yaml")
+    end
+
+    it "returns glob pattern" do
+      expect(fmt.glob_pattern).to eq("*.{yaml,yml}")
+    end
+  end
+
+  describe Lutaml::Store::Format::Json do
+    let(:fmt) { described_class.new }
+
+    it "returns .json extension" do
+      expect(fmt.extension).to eq(".json")
+    end
+
+    it "returns glob pattern" do
+      expect(fmt.glob_pattern).to eq("*.json")
+    end
+  end
+
+  describe Lutaml::Store::Format::MarshalFormat do
+    let(:fmt) { described_class.new }
+
+    it "returns .bin extension" do
+      expect(fmt.extension).to eq(".bin")
+    end
+  end
+end