lutaml-store 0.1.1

data/TODO.impl/3-lutaml-jsonschema-migration.md

@@ -0,0 +1,273 @@
+# TODO.impl/3-lutaml-jsonschema-migration.md
+
+# Migration Plan: lutaml-jsonschema → lutaml-store
+
+## Current state analysis
+
+### How lutaml-jsonschema stores LutaML model objects
+
+lutaml-jsonschema is a JSON Schema parser/generator/SPA builder. It has the
+simplest storage profile of the three repos — it does **no persistent storage
+at all**. Its "storage" is purely in-memory:
+
+1. **`SchemaSet`** — holds `@schemas` (Hash of name → `Schema`), `@file_paths`
+   (Hash), `@source_jsons` (Hash). Loaded from JSON files on disk.
+
+2. **`ReferenceResolver`** — navigates `Schema` object graphs to resolve `$ref`
+   pointers. No storage, pure computation.
+
+3. **`Configuration`** — loads from YAML file. Simple config object, not a
+   storage concern.
+
+4. **`Combiner`** — merges multiple schemas. Pure computation.
+
+5. **SPA generation** — `Spa::SpaBuilder`, `Spa::Generator` produce HTML/Vue
+   output. Write-only, no storage.
+
+### Architecture (current)
+
+```
+Lutaml::Jsonschema
+├── SchemaSet (in-memory schema collection)
+│     ├── @schemas (Hash name → Schema)
+│     ├── load_from_files → File.read → Schema.from_json
+│     ├── load_from_directory → Dir.glob → load_from_files
+│     ├── resolve_ref → ReferenceResolver
+│     └── validate! → walks schema tree collecting errors
+│
+├── Schema (Lutaml::Model::Serializable)
+│     └── Recursive JSON Schema model with composition, conditionals, etc.
+│
+├── PropertyEntry (Lutaml::Model::Serializable)
+│     └── name + Schema pair
+│
+├── Link (Lutaml::Model::Serializable)
+│     └── JSON Hyper-Schema link
+│
+├── ReferenceResolver — navigates Schema graphs
+├── Combiner — merges schemas
+├── Configuration — YAML config loading
+└── SPA generator — static site generation
+```
+
+### Key observation
+
+lutaml-jsonschema is **not a storage application**. It's a **parsing and
+transformation pipeline**. The storage it does (loading JSON files into memory)
+is trivial — `File.read` → `Schema.from_json`.
+
+However, there are storage-adjacent concerns where lutaml-store could help:
+
+1. **Schema caching** — If the same schemas are loaded repeatedly (e.g., in a
+   dev server), caching parsed `Schema` objects avoids re-parsing.
+
+2. **Reference resolution caching** — `$ref` resolution is recursive and could
+   benefit from memoization via a store.
+
+3. **SPA incremental builds** — The SPA generator could use lutaml-store to
+   cache intermediate build artifacts.
+
+### Problems identified
+
+| Category | Issue | Location |
+|---|---|---|
+| **No caching** | `SchemaSet.load_from_files` re-parses every time | `schema_set.rb:14-21` |
+| **In-memory state** | `@source_jsons` and `@file_paths` are informal caches stored alongside `@schemas` | `schema_set.rb:36-38` |
+| **No lazy loading** | All schemas loaded eagerly; no on-demand loading | `schema_set.rb` |
+| **Duplicated index logic** | `ReferenceResolver`, `SchemaSet#find_schema_by_filename`, and `SchemaSet#resolve_file_ref` all do similar lookup work | Multiple |
+
+## Migration strategy
+
+### Phase 1: Use lutaml-store as a schema cache
+
+The primary value of lutaml-store for this repo is **caching parsed schemas**
+to avoid re-reading and re-parsing JSON files.
+
+```ruby
+module Lutaml
+  module Jsonschema
+    class SchemaStore
+      def initialize(cache_config: {})
+        @store = Lutaml::Store.new(
+          adapter: cache_config[:adapter] || :memory,
+          models: [
+            { model: Schema, key: :dollar_id }
+          ],
+          cache: {
+            enabled: true,
+            ttl: cache_config[:ttl] || 3600,
+            max_size: cache_config[:max_size] || 100
+          }
+        )
+      end
+
+      def load_schema(path, name: nil)
+        name ||= File.basename(path, ".*")
+        cached = @store.fetch(model: Schema, dollar_id: name)
+        return cached if cached
+
+        data = File.read(path)
+        schema = Schema.from_json(data)
+        @store.save(schema)
+        schema
+      end
+
+      def fetch(name)
+        @store.fetch(model: Schema, dollar_id: name)
+      end
+
+      def preload_directory(dir)
+        Dir.glob(File.join(dir, "*.json")).each do |path|
+          load_schema(path)
+        end
+      end
+    end
+  end
+end
+```
+
+### Phase 2: Integrate `SchemaStore` into `SchemaSet`
+
+`SchemaSet` currently loads all schemas eagerly. With `SchemaStore`:
+
+```ruby
+class SchemaSet
+  def initialize(base_dir: nil, schema_store: nil)
+    @schemas = {}
+    @base_dir = base_dir
+    @store = schema_store || SchemaStore.new
+    @resolver = ReferenceResolver.new(@schemas)
+  end
+
+  def self.load_from_files(*paths, base_dir: nil)
+    set = new(base_dir: base_dir)
+    paths.each do |path|
+      name = File.basename(path, ".*")
+      schema = set.instance_variable_get(:@store).load_schema(path, name: name)
+      set.add(name, schema, path)
+    end
+    set
+  end
+end
+```
+
+Schemas loaded through `SchemaStore` are automatically cached. Subsequent loads
+hit the cache instead of re-parsing JSON.
+
+### Phase 3: Cache reference resolution results
+
+`ReferenceResolver` does recursive graph navigation. Add memoization via
+lutaml-store:
+
+```ruby
+class ReferenceResolver
+  def initialize(schemas = {}, resolution_cache: nil)
+    @schemas = schemas
+    @cache = resolution_cache  # Lutaml::Store instance or nil
+  end
+
+  def resolve(ref, root_schema = nil)
+    cache_key = "#{root_schema&.dollar_id}:#{ref}"
+    cached = @cache&.get(cache_key)
+    return cached if cached
+
+    result = perform_resolve(ref, root_schema)
+    @cache&.set(cache_key, result)
+    result
+  end
+end
+```
+
+### Phase 4: SPA incremental build cache
+
+The SPA generator can use lutaml-store to cache generated artifacts:
+
+```ruby
+class Spa::Generator
+  def initialize(schema_set, output_dir, cache_adapter: :filesystem)
+    @schema_set = schema_set
+    @output_dir = output_dir
+    @artifact_cache = Lutaml::Store.new(
+      adapter: { type: cache_adapter, path: File.join(output_dir, ".cache") }
+    )
+  end
+end
+```
+
+This enables incremental SPA builds — only regenerate schemas that changed.
+
+### Phase 5: Remove `@source_jsons` and `@file_paths`
+
+These informal caches in `SchemaSet` become unnecessary once `SchemaStore`
+handles caching. The raw JSON can be re-fetched from the store if needed, or
+the schema's `to_json` can regenerate it.
+
+## Completed
+
+### Phase 1: SchemaStore with schema caching (done)
+
+Created `Lutaml::Jsonschema::SchemaStore` backed by `Lutaml::Store` for schema
+caching. Schemas loaded from JSON files are automatically cached — subsequent
+loads hit the store instead of re-parsing.
+
+Also fixed a composite model handler edge case: nested registered model
+instances with nil keys are now skipped (they're part of the parent model,
+not independently stored).
+
+| File | Change |
+|---|---|
+| `lutaml-store/lib/lutaml/store/model_registry.rb` | `find_composite_models` skips nested models with nil keys |
+| `lutaml-jsonschema/lib/lutaml/jsonschema/schema_store.rb` | Schema caching via `Lutaml::Store` |
+| `lutaml-jsonschema/lib/lutaml/jsonschema.rb` | Require for schema_store |
+| `lutaml-jsonschema/lutaml-jsonschema.gemspec` | Added `lutaml-store ~> 0.1.0` dependency |
+| `lutaml-jsonschema/Gemfile` | Added lutaml-store path gem |
+| `lutaml-jsonschema/spec/lutaml/jsonschema/schema_store_spec.rb` | 6 specs for SchemaStore CRUD + caching |
+| `lutaml-jsonschema/spec/spec_helper.rb` | Added `fixture_path` helper |
+
+### Test results
+
+- **lutaml-store:** 19 core specs pass
+- **lutaml-jsonschema:** 167 examples, 0 failures (no regressions)
+- **lutaml-hal:** 210 examples, 0 failures
+- **glossarist:** 1154 examples, 0 failures
+
+## Remaining (future work)
+
+| File | Purpose |
+|---|---|
+| `lib/lutaml/jsonschema/schema_store.rb` | Schema caching via `Lutaml::Store` |
+
+## Files to modify
+
+| File | Change |
+|---|---|
+| `schema_set.rb` | Accept optional `SchemaStore`; delegate loading to it; remove `@source_jsons`/`@file_paths` |
+| `reference_resolver.rb` | Accept optional resolution cache |
+| `spa/generator.rb` | Use `Lutaml::Store` for artifact caching |
+
+## Spec coverage needed
+
+1. **SchemaStore** — load, fetch, cache hit, cache miss, preload_directory
+2. **SchemaSet with SchemaStore** — schemas loaded from cache on second call
+3. **Reference resolution caching** — resolved refs cached, cache invalidated on schema change
+4. **SPA incremental builds** — only changed schemas regenerated
+
+## Risk assessment
+
+- **Low risk overall** — this repo has the simplest integration. No persistent
+  storage is being replaced, only caching is being added.
+- **No backward compatibility risk** — `SchemaStore` is additive; existing
+  `SchemaSet` API remains the same.
+- **Cleanest migration path** — other repos can reference this as the simplest
+  example of lutaml-store integration.
+
+## Priority
+
+This is the **lowest priority** migration because:
+1. No broken encapsulation to fix (no `send`, `instance_variable_get/set`, `respond_to?`)
+2. No storage layer to replace — only caching to add
+3. The repo is clean and well-structured already
+
+Recommended order: Fix lutaml-store self-quality first, then migrate
+lutaml-hal (most urgent encapsulation issues), then glossarist (most complex),
+then lutaml-jsonschema (polish/caching).

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "lutaml/store"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/demo/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Core dependencies
+gem "lutaml-store", path: ".."
+
+# Demo enhancement gems
+gem "paint", "~> 2.3" # For colored terminal output
+gem "sqlite3", "~> 1.4" # For SQLite database support
+gem "table_tennis", "~> 0.0.6" # For table formatting
+
+# Development dependencies
+gem "bundler", "~> 2.0"
+gem "rake", "~> 13.0"

data/demo/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: ..
+  specs:
+    lutaml-store (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    csv (3.3.5)
+    ffi (1.17.2)
+    ffi (1.17.2-aarch64-linux-gnu)
+    ffi (1.17.2-aarch64-linux-musl)
+    ffi (1.17.2-arm-linux-gnu)
+    ffi (1.17.2-arm-linux-musl)
+    ffi (1.17.2-arm64-darwin)
+    ffi (1.17.2-x86-linux-gnu)
+    ffi (1.17.2-x86-linux-musl)
+    ffi (1.17.2-x86_64-darwin)
+    ffi (1.17.2-x86_64-linux-gnu)
+    ffi (1.17.2-x86_64-linux-musl)
+    memo_wise (1.13.0)
+    paint (2.3.0)
+    rake (13.3.0)
+    sqlite3 (1.7.3-aarch64-linux)
+    sqlite3 (1.7.3-arm-linux)
+    sqlite3 (1.7.3-arm64-darwin)
+    sqlite3 (1.7.3-x86-linux)
+    sqlite3 (1.7.3-x86_64-darwin)
+    sqlite3 (1.7.3-x86_64-linux)
+    table_tennis (0.0.6)
+      csv (~> 3.3)
+      ffi (~> 1.17)
+      memo_wise (~> 1.11)
+      paint (~> 2.3)
+      unicode-display_width (~> 3.1)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  lutaml-store!
+  paint (~> 2.3)
+  rake (~> 13.0)
+  sqlite3 (~> 1.4)
+  table_tennis (~> 0.0.6)
+
+BUNDLED WITH
+   2.6.9

data/demo/README.adoc

@@ -0,0 +1,301 @@
+= VCard Store Demo
+:toc:
+:toclevels: 3
+
+== Overview
+
+This demo showcases the capabilities of `lutaml-store` using vCard (Virtual Contact File) models. It demonstrates how to store, retrieve, and manage contact information using different storage backends and advanced features like caching, compression, and data integrity.
+
+== Features Demonstrated
+
+=== Storage Backends
+* **Memory Store** - Fast in-memory storage for temporary data
+* **Filesystem Store** - File-based persistence with organized directory structure
+* **SQLite Store** - Database storage for structured queries and relationships
+* **Cache Store** - High-performance caching with TTL and LRU eviction
+
+=== Advanced Features
+* **Data Integrity** - SHA256 checksums to ensure data hasn't been corrupted
+* **Compression** - GZIP compression to reduce storage space
+* **Search Capabilities** - Find contacts by organization, email domain, birth year
+* **Multiple Key Strategies** - UID-based, email-based, and organized naming schemes
+
+== Demo Structure
+
+----
+demo/
+├── README.adoc              # This documentation
+├── vcard_models.rb          # VCard model definitions
+├── vcard_store_demo.rb      # Main demo script
+└── data/                    # Generated during demo
+    ├── vcards/              # Filesystem store files
+    └── vcards.db            # SQLite database
+----
+
+== VCard Models
+
+The demo uses simplified vCard models based on the vCard 4.0 specification:
+
+=== Core Models
+
+==== `Vcard`
+Main contact record containing:
+* `version` - vCard format version (4.0)
+* `fn` - Formatted name (display name)
+* `n` - Structured name components
+* `tel` - Phone numbers (collection)
+* `email` - Email addresses (collection)
+* `org` - Organization
+* `bday` - Birthday
+* `uid` - Unique identifier
+
+==== `VcardName`
+Structured name with components:
+* `family` - Last name
+* `given` - First name
+* `additional` - Middle names
+* `prefix` - Title (Dr., Mr., etc.)
+* `suffix` - Suffix (Jr., PhD, etc.)
+
+==== `VcardTel`
+Phone number with metadata:
+* `value` - Phone number
+* `type` - Phone type (work, mobile, home)
+* `pref` - Preference ranking
+
+==== `VcardBday`
+Birthday with flexible date formats:
+* `value` - Date in ISO format or text
+
+== Sample Data
+
+The demo creates 10 diverse contact records representing different professions and use cases:
+
+1. **John Doe** - Tech Corp employee with multiple emails
+2. **Jane Smith** - Design Studio creative
+3. **Dr. Robert Johnson** - Medical professional
+4. **Maria Garcia** - Startup innovator
+5. **David Wilson** - Independent consultant
+6. **Sarah Brown** - University researcher
+7. **Michael Davis** - Creative agency worker
+8. **Lisa Anderson** - Financial services
+9. **James Taylor** - Music producer
+10. **Emma Thompson** - Legal professional
+
+== Running the Demo
+
+=== Prerequisites
+
+Ensure you have the lutaml-store gem and its dependencies installed:
+
+[source,bash]
+----
+bundle install
+----
+
+=== Execute the Demo
+
+[source,bash]
+----
+cd demo
+ruby vcard_store_demo.rb
+----
+
+=== Expected Output
+
+The demo will show:
+
+1. **Initialization** - Setting up different store types
+2. **Sample Data Creation** - Generating 10 vCard records
+3. **Memory Store Demo** - Fast in-memory operations
+4. **Filesystem Store Demo** - File persistence with organized naming
+5. **SQLite Store Demo** - Database storage with email-based keys
+6. **Cache Store Demo** - High-performance caching with TTL
+7. **Search Capabilities** - Finding contacts by various criteria
+8. **Data Integrity** - Demonstrating checksums and compression
+
+== Storage Strategies
+
+=== Memory Store
+* **Use Case**: Temporary data, fast access, testing
+* **Key Strategy**: UUID-based for unique identification
+* **Persistence**: None (data lost on restart)
+
+=== Filesystem Store
+* **Use Case**: Simple persistence, human-readable storage
+* **Key Strategy**: Organized naming (`contact_1_doe`)
+* **Persistence**: Individual JSON files in directory structure
+
+=== SQLite Store
+* **Use Case**: Structured queries, relationships, ACID transactions
+* **Key Strategy**: Email username for easy lookup
+* **Persistence**: Single database file with full SQL capabilities
+
+=== Cache Store
+* **Use Case**: Performance optimization, temporary storage
+* **Key Strategy**: UUID with TTL-based expiration
+* **Features**: LRU eviction, automatic cleanup, cache statistics
+
+== Search Examples
+
+The demo includes several search patterns:
+
+=== By Organization
+[source,ruby]
+----
+# Find all contacts from "Tech Corp"
+find_by_organization("Tech Corp")
+----
+
+=== By Email Domain
+[source,ruby]
+----
+# Find all contacts with "example.com" emails
+find_by_email_domain("example.com")
+----
+
+=== By Birth Year
+[source,ruby]
+----
+# Find all contacts born in 1985
+find_by_birth_year(1985)
+----
+
+== Data Integrity Features
+
+=== Checksums
+The demo shows how to enable SHA256 checksums:
+
+[source,ruby]
+----
+store = Lutaml::Store::Store.new(
+  adapter: { type: :memory },
+  integrity: { enabled: true, algorithm: :sha256 }
+)
+----
+
+=== Compression
+GZIP compression reduces storage space:
+
+[source,ruby]
+----
+store = Lutaml::Store::Store.new(
+  adapter: { type: :memory },
+  compression: { enabled: true, algorithm: :gzip }
+)
+----
+
+== Performance Considerations
+
+=== Memory Store
+* **Pros**: Fastest access, no I/O overhead
+* **Cons**: Limited by RAM, no persistence
+* **Best For**: Caching, temporary data, testing
+
+=== Filesystem Store
+* **Pros**: Simple, human-readable, version control friendly
+* **Cons**: Slower for large datasets, limited query capabilities
+* **Best For**: Configuration, small datasets, debugging
+
+=== SQLite Store
+* **Pros**: ACID transactions, complex queries, excellent performance
+* **Cons**: Single writer limitation, file locking
+* **Best For**: Structured data, relationships, production use
+
+=== Cache Store
+* **Pros**: Automatic expiration, LRU eviction, high performance
+* **Cons**: Temporary storage, memory limited
+* **Best For**: Frequently accessed data, API responses
+
+== Extending the Demo
+
+=== Adding New Fields
+To add new vCard fields:
+
+1. Update the `Vcard` model with new attributes
+2. Modify the `create_vcard` method to accept new parameters
+3. Update sample data generation
+4. Add search methods for new fields
+
+=== Custom Storage Backends
+Create custom adapters by:
+
+1. Inheriting from `Lutaml::Store::Adapter::Base`
+2. Implementing required methods (`save`, `load`, `delete`, etc.)
+3. Registering the adapter with the store
+
+=== Advanced Queries
+Implement complex search patterns:
+
+[source,ruby]
+----
+# Find contacts by age range
+def find_by_age_range(min_age, max_age)
+  # Implementation using birth date calculations
+end
+
+# Find contacts with multiple emails
+def find_multi_email_contacts
+  # Implementation checking email array length
+end
+----
+
+== Real-World Applications
+
+This demo pattern can be adapted for:
+
+* **Contact Management Systems** - CRM applications
+* **User Profile Storage** - Web applications
+* **Configuration Management** - Application settings
+* **Document Storage** - Content management
+* **API Response Caching** - Performance optimization
+* **Session Storage** - Web session management
+
+== Troubleshooting
+
+=== Common Issues
+
+==== Permission Errors
+Ensure write permissions for the `demo/data/` directory:
+[source,bash]
+----
+chmod 755 demo/data
+----
+
+==== SQLite Lock Issues
+If SQLite database is locked:
+[source,bash]
+----
+rm demo/data/vcards.db
+----
+
+==== Memory Issues
+For large datasets, consider:
+* Using filesystem or SQLite stores instead of memory
+* Implementing pagination for search results
+* Adding cleanup routines for cache stores
+
+=== Debug Mode
+Enable verbose output by modifying the demo script:
+[source,ruby]
+----
+# Add at the top of vcard_store_demo.rb
+ENV['DEBUG'] = 'true'
+----
+
+== Next Steps
+
+After running this demo, consider:
+
+1. **Exploring the Generated Data** - Examine files in `demo/data/`
+2. **Modifying Sample Data** - Add your own contact records
+3. **Implementing New Features** - Add search, sorting, or filtering
+4. **Performance Testing** - Benchmark different storage backends
+5. **Integration** - Use lutaml-store in your own applications
+
+== Resources
+
+* link:../README.md[Lutaml::Store Documentation]
+* link:../lib/lutaml/store/[Source Code]
+* link:../spec/[Test Suite]
+* https://tools.ietf.org/html/rfc6350[vCard 4.0 Specification]

data/demo/data/vcards/co/contact_10_thompson.data

@@ -0,0 +1 @@
+{:version=>"4.0", :fn=>"Emma Thompson", :n=>{:family=>"Thompson", :given=>"Emma", :additional=>nil, :prefix=>nil, :suffix=>nil}, :tel=>[{:value=>"+1-555-0110", :type=>"work", :pref=>nil}], :email=>["emma.thompson@law.com"], :org=>"Thompson & Associates", :bday=>{:value=>"1977-04-07"}, :uid=>"2361d65a-8810-49f9-bc3b-eeff2c229b5c"}

data/demo/data/vcards/co/contact_10_thompson.meta

@@ -0,0 +1 @@
+{"integrity":{"checksum":"c40eb05833b277bb6ab06bf4ae41b9ae82b13f17f607d3567da6bbf090b39b50","algorithm":"sha256","size":331,"created_at":"2025-07-11T00:01:58Z","version":"1.0"}}

data/demo/data/vcards/co/contact_1_doe.data

@@ -0,0 +1 @@
+{:version=>"4.0", :fn=>"John Doe", :n=>{:family=>"Doe", :given=>"John", :additional=>nil, :prefix=>nil, :suffix=>nil}, :tel=>[{:value=>"+1-555-0101", :type=>"work", :pref=>nil}], :email=>["john.doe@example.com", "j.doe@work.com"], :org=>"Tech Corp", :bday=>{:value=>"1985-03-15"}, :uid=>"a62ceddc-eac7-4a93-9a45-b356acbc3509"}

data/demo/data/vcards/co/contact_1_doe.meta

@@ -0,0 +1 @@
+{"integrity":{"checksum":"80e64e58e91a6362bf3b3dadbec3614863f9139f7b98a2156e1700574e6e6fe0","algorithm":"sha256","size":326,"created_at":"2025-07-11T00:01:58Z","version":"1.0"}}

data/demo/data/vcards/co/contact_2_smith.data

@@ -0,0 +1 @@
+{:version=>"4.0", :fn=>"Jane Smith", :n=>{:family=>"Smith", :given=>"Jane", :additional=>nil, :prefix=>nil, :suffix=>nil}, :tel=>[{:value=>"+1-555-0102", :type=>"mobile", :pref=>nil}], :email=>["jane.smith@example.com"], :org=>"Design Studio", :bday=>{:value=>"1990-07-22"}, :uid=>"dc604681-c04c-4faa-9112-f0b8ece1e80d"}

data/demo/data/vcards/co/contact_2_smith.meta

@@ -0,0 +1 @@
+{"integrity":{"checksum":"ff43bcd52684c7f7c29fda288ba23bf4c48b44cc4972d2d70eb02436765b34e8","algorithm":"sha256","size":320,"created_at":"2025-07-11T00:01:58Z","version":"1.0"}}

data/demo/data/vcards/co/contact_3_johnson.data

@@ -0,0 +1 @@
+{:version=>"4.0", :fn=>"Dr. Robert Johnson", :n=>{:family=>"Johnson", :given=>"Robert", :additional=>nil, :prefix=>"Dr.", :suffix=>nil}, :tel=>[{:value=>"+1-555-0103", :type=>"work", :pref=>nil}], :email=>["r.johnson@hospital.com", "robert@personal.com"], :org=>"City Hospital", :bday=>{:value=>"1975-11-08"}, :uid=>"b63bdabe-bff7-4198-94d7-6730e2a52cd4"}

data/demo/data/vcards/co/contact_3_johnson.meta

@@ -0,0 +1 @@
+{"integrity":{"checksum":"20f9f5f2ac7306f4dc77947adf411afff60309918e4fb32525b54aa37dda130e","algorithm":"sha256","size":355,"created_at":"2025-07-11T00:01:58Z","version":"1.0"}}