Lutaml::Store

store = Lutaml::Store.new(
  adapter: :memory,
  models: [
    { model: User, key: :user_id },
    { model: Post, key: :post_id }
  ]
)

class Studio < Lutaml::Model::Serializable
  attribute :studio_key, :string
  attribute :name, :string
  attribute :_class, :string, default: -> { "Studio" }, polymorphic_class: true
end

class CeramicStudio < Studio
  attribute :clay_type, :string
  attribute :_class, :string, default: -> { "CeramicStudio" }
end

store = Lutaml::Store.new(
  adapter: :memory,
  models: [
    { model: Studio, key: :studio_key, polymorphic_class_key: :_class }
  ]
)

store.save(CeramicStudio.new(studio_key: "cs1", name: "Clay Haus", clay_type: "Porcelain"))
retrieved = store.fetch(model: Studio, studio_key: "cs1")
puts retrieved.class.name # => "CeramicStudio"

store = Lutaml::Store.new(
  adapter: :memory,
  models: [
    { model: PotteryClass, key: :class_id },
    { model: Studio, key: :studio_key }
  ]
)

pottery = PotteryClass.new(
  class_id: "p101",
  studio: Studio.new(studio_key: "s1", name: "Main Studio")
)
store.save(pottery)

# Both accessible independently
store.fetch(model: Studio, studio_key: "s1").name  # => "Main Studio"
store.fetch(model: PotteryClass, class_id: "p101").studio.name  # => "Main Studio"

store.save(User.new(user_id: "u1", name: "Ada"))
store.save([user1, user2, user3])  # bulk save

user = store.fetch(model: User, user_id: "u1")

# Hash-based attributes
store.update(
  model: User, user_id: "u1",
  attributes: [
    { key: :name, value: "Grace" },
    { key: "studio.location", value: "Building A" }  # dot notation for nesting
  ]
)

# Block-based
store.update(model: User, user_id: "u1") do |user|
  user.name = "Grace"
end

store.destroy(model: User, user_id: "u1")

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)

  # Binary assets bundled in the package
  pkg.asset("logo.png", type: :file)
  pkg.asset("attachments", type: :directory)
end

# Load from directory
store = Lutaml::Store::PackageStore.load(glossary, "./my_glossary")

# 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)   # => 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 }

# 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

# Global format for all models
store.save("./out", format: :json)

# Per-model format
store.save("./out", formats: { Concept => :yaml, Author => :jsonl })

# Default: each model uses its default_format from the definition
store.save("./out")

# Write models to directory
store.save_all(concepts, path: "./data", format: :yaml, layout: :separate)

# Read models (returns array, does NOT store in backend)
models = store.load_all(Concept, path: "./data", format: :yaml, layout: :separate)

# Read AND store in backend (makes them queryable)
store.import_all(Concept, path: "./data", format: :yaml, layout: :separate)
store.fetch(model: Concept, term: "API")  # now available

# Export to a single file
store.export(all_concepts, path: "output.yaml", format: :yaml)

store = Lutaml::Store.new(adapter: :memory, models: [...])

store = Lutaml::Store.new(
  adapter: { type: :filesystem, path: "./data", extension: ".json" },
  models: [...]
)

store = Lutaml::Store.new(
  adapter: { type: :sqlite, path: "./store.db" },
  models: [...]
)