familia 2.0.0.pre14 → 2.0.0.pre16

data/examples/autoloader/mega_customer/features/deprecated_fields.rb

@@ -0,0 +1,7 @@
+# examples/autoloader/mega_customer/features/deprecated_fields.rb
+
+# Extend the MegaCustomer class to organize all of the deprecated fields into one place
+class MegaCustomer < Familia::Horreum
+  field :favourite_colour
+  field :nickname
+end

data/examples/autoloader/mega_customer/safe_dump_fields.rb

@@ -1,6 +1,6 @@
 # examples/autoloader/mega_customer/safe_dump_fields.rb
 
 # Extend the MegaCustomer class to add safe dump fields
-class MegaCustomer
+class MegaCustomer < Familia::Horreum
   safe_dump_fields :custid, :username, :created_at, :updated_at
 end

data/examples/autoloader/mega_customer.rb

@@ -3,6 +3,8 @@
 require_relative '../../lib/familia'
 
 class MegaCustomer < Familia::Horreum
+  include Familia::Features::Autoloader
+
   field :custid
   field :username
   field :email
@@ -13,5 +15,5 @@ class MegaCustomer < Familia::Horreum
   field :updated_at
 
   feature :safe_dump
-  # feature :deprecated_fields
+  feature :deprecated_fields
 end

data/examples/encrypted_fields.rb

@@ -0,0 +1,378 @@
+#!/usr/bin/env ruby
+
+# examples/encrypted_fields.rb
+#
+# Demonstrates the EncryptedFields feature for protecting sensitive data.
+# This feature provides transparent encryption/decryption of sensitive fields
+# using strong cryptographic algorithms with field-specific key derivation.
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'familia'
+
+# Configure connection
+Familia.uri = 'redis://localhost:6379/15'
+
+puts '=== Encrypted Fields Feature Examples ==='
+puts
+
+# Configure encryption keys for examples
+Familia.configure do |config|
+  config.encryption_keys = {
+    v1: 'dGVzdGtleWZvcmV4YW1wbGVzMTIzNDU2Nzg5MA==', # Base64 encoded 32 bytes
+    v2: 'bmV3ZXJrZXlmb3JleGFtcGxlczEyMzQ1Njc4OTA=', # Base64 encoded 32 bytes
+  }
+  config.current_key_version = :v2
+  config.encryption_personalization = 'FamiliaExamples'
+end
+
+# Validate configuration before proceeding
+begin
+  Familia::Encryption.validate_configuration!
+  puts '✓ Encryption configuration validated'
+  puts "  Algorithm: #{Familia::Encryption.status[:default_algorithm]}"
+  puts "  Available algorithms: #{Familia::Encryption.status[:available_algorithms].join(', ')}"
+  puts "  Key versions: #{Familia::Encryption.status[:key_versions].join(', ')}"
+  puts
+rescue Familia::EncryptionError => e
+  puts "✗ Encryption configuration error: #{e.message}"
+  exit 1
+end
+
+# Example 1: Basic encrypted fields
+class SecureUser < Familia::Horreum
+  feature :encrypted_fields
+
+  identifier_field :email
+  field :email                    # stored as plaintext in the database
+  field :name
+  encrypted_field :ssn            # store as an encrypted string in the database
+  encrypted_field :credit_card
+  encrypted_field :notes
+  field :created_at
+end
+
+puts 'Example 1: Basic encrypted fields'
+user = SecureUser.new(
+  email: 'alice@example.com',
+  name: 'Alice Windows',
+  ssn: '123-45-6789',
+  credit_card: '4111-1111-1111-1111',
+  notes: 'VIP customer with special handling',
+  created_at: Familia.now.to_i
+)
+
+user.save
+puts '✓ User saved with encrypted fields'
+
+# Demonstrate transparent access
+puts "Name (plaintext): #{user.name}"
+puts "SSN (encrypted): #{user.ssn.class} -> #{user.ssn.reveal}"
+puts "Credit card: #{user.credit_card.reveal}"
+puts "Notes: #{user.notes.reveal}"
+
+# Show how ConcealedString protects data in logs
+puts "SSN to_s (safe for logging): #{user.ssn}"
+puts "SSN inspect (safe for logging): #{user.ssn.inspect}"
+puts
+
+# Example 2: Encrypted fields with Additional Authenticated Data (AAD)
+class SecureDocument < Familia::Horreum
+  feature :encrypted_fields
+
+  identifier_field :doc_id
+  field :doc_id
+  field :title                    # Plaintext
+  field :owner_id                 # Plaintext
+  field :classification # Plaintext
+  encrypted_field :content, aad_fields: %i[doc_id owner_id classification]
+  encrypted_field :summary        # No AAD
+  field :created_at               # Plaintext
+end
+
+puts 'Example 2: Encrypted fields with Additional Authenticated Data'
+doc = SecureDocument.new(
+  doc_id: 'DOC-2024-001',
+  title: 'Strategic Plan',
+  owner_id: 'user123',
+  classification: 'confidential',
+  content: 'This document contains sensitive strategic information...',
+  summary: 'Strategic planning document for Q1 2024',
+  created_at: Familia.now.to_i
+)
+
+doc.save
+puts '✓ Document saved with AAD-protected content'
+
+# AAD ensures content can only be decrypted with matching metadata
+puts "Title: #{doc.title}"
+puts "Content (with AAD protection): #{doc.content.reveal}"
+puts "Summary (no AAD): #{doc.summary.reveal}"
+puts
+
+# Example 3: Performance optimization with request caching
+class VaultEntry < Familia::Horreum
+  feature :encrypted_fields
+
+  identifier_field :entry_id
+  field :entry_id
+  encrypted_field :api_key
+  encrypted_field :secret_token
+  encrypted_field :private_key
+  encrypted_field :webhook_url
+end
+
+puts 'Example 3: Performance optimization with request caching'
+entries = []
+
+# Without caching - each field derives keys independently
+start_time = Time.now
+5.times do |i|
+  private_key_pem = <<~PEM
+    -----BEGIN PRIVATE KEY-----
+    FAKE_EXAMPLE_KEY_FOR_TESTING_ONLY
+    FAKE_EXAMPLE_KEY_FOR_TESTING_ONLY
+    -----END PRIVATE KEY-----
+  PEM
+
+  entry = VaultEntry.new(
+    entry_id: "entry_#{i}",
+    api_key: "sk_test_key_#{i}",
+    secret_token: "token_#{i}_secret",
+    private_key: private_key_pem.strip,
+    webhook_url: "https://api.example.com/webhook/#{i}"
+  )
+  entry.save
+  entries << entry
+end
+no_cache_time = Time.now - start_time
+
+# With caching - reuses derived keys within the block
+start_time = Time.now
+Familia::Encryption.with_request_cache do
+  5.times do |i|
+    private_key_pem = <<~PEM
+      -----BEGIN PRIVATE KEY-----
+      FAKE_EXAMPLE_KEY_FOR_TESTING_ONLY
+      FAKE_EXAMPLE_KEY_FOR_TESTING_ONLY
+      -----END PRIVATE KEY-----
+    PEM
+
+    entry = VaultEntry.new(
+      entry_id: "cached_entry_#{i}",
+      api_key: "sk_test_key_cached_#{i}",
+      secret_token: "token_cached_#{i}_secret",
+      private_key: private_key_pem.strip,
+      webhook_url: "https://api.example.com/webhook/cached/#{i}"
+    )
+    entry.save
+    entries << entry
+  end
+end
+cached_time = Time.now - start_time
+
+puts "Encryption without caching: #{(no_cache_time * 1000).round(2)}ms"
+puts "Encryption with caching: #{(cached_time * 1000).round(2)}ms"
+puts "Performance improvement: #{((no_cache_time - cached_time) / no_cache_time * 100).round(1)}%"
+puts
+
+# Example 4: Key rotation simulation
+class RotationTest < Familia::Horreum
+  feature :encrypted_fields
+
+  identifier_field :test_id
+  field :test_id
+  encrypted_field :sensitive_data
+end
+
+puts 'Example 4: Key rotation demonstration'
+rotation_obj = RotationTest.new(
+  test_id: 'rotation_test',
+  sensitive_data: 'Original sensitive data encrypted with v2 key'
+)
+rotation_obj.save
+
+puts "Original data encrypted with key version: #{Familia.config.current_key_version}"
+puts "Data: #{rotation_obj.sensitive_data.reveal}"
+
+# Check encryption status before rotation
+status_before = rotation_obj.encrypted_fields_status
+puts "Encryption status before rotation: #{status_before}"
+
+# Simulate key rotation - switch to v1 for demonstration
+Familia.config.current_key_version = :v1
+
+# Re-encrypt with new current key
+rotation_obj.sensitive_data = 'Updated data encrypted with v1 key'
+rotation_obj.re_encrypt_fields!
+rotation_obj.save
+
+puts "After rotation to key version: #{Familia.config.current_key_version}"
+puts "Data: #{rotation_obj.sensitive_data.reveal}"
+
+# Check encryption status after rotation
+status_after = rotation_obj.encrypted_fields_status
+puts "Encryption status after rotation: #{status_after}"
+
+# Switch back to v2
+Familia.config.current_key_version = :v2
+puts
+
+# Example 5: Memory safety and cleanup
+class MemoryTest < Familia::Horreum
+  feature :encrypted_fields
+
+  identifier_field :mem_id
+  field :mem_id
+  encrypted_field :secret_one
+  encrypted_field :secret_two
+  encrypted_field :secret_three
+end
+
+puts 'Example 5: Memory safety and cleanup'
+mem_obj = MemoryTest.new(
+  mem_id: 'memory_test',
+  secret_one: 'First secret value',
+  secret_two: 'Second secret value',
+  secret_three: 'Third secret value'
+)
+
+puts "Has encrypted data: #{mem_obj.encrypted_data?}"
+puts "Fields cleared: #{mem_obj.encrypted_fields_cleared?}"
+
+# Access some fields to load them into memory
+puts "Secret one: #{mem_obj.secret_one.reveal}"
+puts "Secret two: #{mem_obj.secret_two.reveal}"
+
+# Clear specific field
+mem_obj.secret_one.clear!
+puts "Secret one cleared: #{mem_obj.secret_one.cleared?}"
+
+# Clear all encrypted fields
+mem_obj.clear_encrypted_fields!
+puts "All fields cleared: #{mem_obj.encrypted_fields_cleared?}"
+puts
+
+# Example 6: Error handling and validation
+puts 'Example 6: Error handling and validation'
+
+# Test with invalid configuration
+begin
+  old_keys = Familia.config.encryption_keys
+  Familia.config.encryption_keys = {}
+
+  invalid_obj = SecureUser.new(email: 'test@example.com', ssn: 'test')
+  invalid_obj.save
+rescue Familia::EncryptionError => e
+  puts "✓ Caught expected error with invalid config: #{e.message}"
+ensure
+  Familia.config.encryption_keys = old_keys
+end
+
+# Test with missing key version
+begin
+  test_obj = SecureUser.new(email: 'version_test@example.com', ssn: '987-65-4321')
+  test_obj.save
+
+  # Simulate missing key version in config
+  old_keys = Familia.config.encryption_keys.dup
+  Familia.config.encryption_keys = { v3: old_keys[:v2] }
+
+  # This should fail when trying to decrypt
+  test_obj.ssn.reveal
+rescue Familia::EncryptionError => e
+  puts "✓ Caught expected error with missing key version: #{e.message}"
+ensure
+  Familia.config.encryption_keys = old_keys
+end
+puts
+
+# Example 7: Benchmarking encryption performance
+puts 'Example 7: Encryption performance benchmarks'
+if defined?(Familia::Encryption) && Familia::Encryption.respond_to?(:benchmark)
+  benchmark_results = Familia::Encryption.benchmark(iterations: 100)
+
+  puts 'Encryption benchmark results (100 iterations):'
+  benchmark_results.each do |algorithm, stats|
+    puts "  #{algorithm}:"
+    puts "    Time: #{(stats[:time] * 1000).round(2)}ms total"
+    puts "    Operations/sec: #{stats[:ops_per_sec]}"
+    puts "    Priority: #{stats[:priority]}"
+  end
+else
+  puts 'Benchmarking not available in this version'
+end
+puts
+
+# Example 8: Integration with safe dump feature
+class SecureProfile < Familia::Horreum
+  feature :encrypted_fields
+  feature :safe_dump
+
+  identifier_field :profile_id
+  field :profile_id
+  field :username                 # Safe to expose
+  field :email                    # Safe to expose
+  encrypted_field :phone          # Encrypted but can be safely exposed
+  encrypted_field :ssn            # Encrypted and should NOT be exposed
+  encrypted_field :bank_account   # Encrypted and should NOT be exposed
+  field :created_at               # Safe to expose
+
+  # Define safe dump fields - encrypted fields are handled automatically
+  safe_dump_field :profile_id
+  safe_dump_field :username
+  safe_dump_field :email
+  safe_dump_field :phone_display, lambda { |profile|
+    phone = profile.phone.reveal
+    phone ? "#{phone[0..2]}-***-#{phone[-4..]}" : nil
+  }
+  safe_dump_field :created_at
+end
+
+puts 'Example 8: Integration with SafeDump feature'
+profile = SecureProfile.new(
+  profile_id: 'profile_123',
+  username: 'alice_windows',
+  email: 'alice@example.com',
+  phone: '555-123-4567',
+  ssn: '123-45-6789',
+  bank_account: '9876543210',
+  created_at: Familia.now.to_i
+)
+profile.save
+
+puts 'Profile safe dump (encrypted fields handled automatically):'
+puts JSON.pretty_generate(profile.safe_dump)
+puts 'Notice: SSN and bank account are automatically excluded'
+puts 'Phone number is included but masked for display'
+puts
+
+# Clean up examples
+puts '=== Cleaning up test data ==='
+[SecureUser, SecureDocument, VaultEntry, RotationTest, MemoryTest, SecureProfile].each do |klass|
+  keys = klass.dbclient.keys("#{klass.name.downcase.gsub('::', '_')}:*")
+  klass.dbclient.del(*keys) unless keys.empty?
+  puts "✓ Cleaned #{klass.name} (#{keys.length} keys)"
+rescue StandardError => e
+  puts "✗ Error cleaning #{klass.name}: #{e.message}"
+end
+
+# Clear any request cache
+begin
+  Familia::Encryption.clear_request_cache!
+rescue StandardError => e
+  puts "⚠ Warning: Failed to clear encryption request cache: #{e.message} (#{e.backtrace.join("\n")})"
+end
+
+puts
+puts '=== Summary ==='
+puts 'This example demonstrated:'
+puts '• Basic encrypted field usage with transparent access'
+puts '• Additional Authenticated Data (AAD) for tamper detection'
+puts '• Performance optimization with request-level caching'
+puts '• Key rotation procedures and status monitoring'
+puts '• Memory safety with ConcealedString and cleanup methods'
+puts '• Error handling for configuration and key version issues'
+puts '• Encryption performance benchmarking'
+puts '• Integration with SafeDump for API-safe serialization'
+puts
+puts 'Encrypted Fields examples completed!'

data/examples/json_usage_patterns.rb

@@ -0,0 +1,144 @@
+# examples/json_usage_patterns.rb
+#
+# This file demonstrates the JSON serialization patterns available in Familia,
+# showing both the secure defaults and optional developer convenience features.
+
+require_relative '../lib/familia'
+
+# Example model setup
+class User < Familia::Horreum
+  feature :encrypted_fields
+  identifier_field :user_id
+  field :user_id
+  field :name
+  field :email
+  encrypted_field :password_hash  # This will be concealed in JSON
+  listkey :tags                   # Associates a separate ListKey field
+  set :permissions
+end
+
+# Configure encryption (required for encrypted_fields)
+Familia.config.encryption_keys = { v1: Base64.strict_encode64('a' * 32) }
+Familia.config.current_key_version = :v1
+
+# Create and save a user
+user = User.new(
+  user_id: 'user123',
+  name: 'Alice Johnson',
+  email: 'alice@example.com',
+  password_hash: 'hashed_password_secret'
+)
+user.save
+
+user.tags << 'admin' << 'developer'
+user.permissions << 'read' << 'write'
+
+puts "=== Familia JSON Serialization Patterns ==="
+puts
+
+# Pattern 1: Direct object serialization (always available)
+puts "1. Direct Familia Object Serialization:"
+puts "   user.as_json  # Secure - only public fields"
+p user.as_json
+puts "   user.to_json  # Uses Familia::JsonSerializer (OJ strict mode)"
+puts user.to_json
+puts
+
+puts "   user.tags.as_json  # DataType objects work too"
+p user.tags.as_json
+puts "   user.tags.to_json"
+puts user.tags.to_json
+puts
+
+# Pattern 2: Manual mixed serialization (current secure pattern)
+puts "2. Manual Mixed Serialization (Current Pattern):"
+mixed_data = {
+  user: user.as_json,
+  tags: user.tags.as_json,
+  permissions: user.permissions.as_json,
+  meta: { timestamp: Time.now.to_i }
+}
+puts "   Manual preparation + JsonSerializer.dump:"
+puts Familia::JsonSerializer.dump(mixed_data)
+puts
+
+# Pattern 3: Opt-in refinement for Hash/Array (new convenience feature)
+puts "3. Opt-in Refinement Pattern (Developer Convenience):"
+puts "   # Add this line to enable refinements in your file:"
+puts "   using Familia::Refinements::DearJson"
+puts
+
+# Demonstrate the refinement
+require_relative '../lib/familia/refinements/dear_json'
+using Familia::Refinements::DearJson
+
+mixed_hash = {
+  user: user,                    # Familia object (will call as_json)
+  tags: user.tags,              # Familia DataType (will call as_json)
+  meta: { timestamp: Time.now.to_i }  # Plain hash (passes through)
+}
+
+mixed_array = [
+  user,                         # Familia object
+  user.tags,                   # Familia DataType
+  { type: 'example' },         # Plain hash
+  'metadata'                   # Plain string
+]
+
+puts "   # Now Hash and Array have secure to_json using Familia::JsonSerializer"
+puts "   mixed_hash.to_json:"
+puts mixed_hash.to_json
+puts
+
+puts "   mixed_array.to_json:"
+puts mixed_array.to_json
+puts
+
+# Pattern 4: Security demonstration
+puts "4. Security Features (Always Active):"
+puts "   # Encrypted fields are automatically concealed"
+puts "   # This is what user.password_hash looks like:"
+puts "   user.password_hash.class # => #{user.password_hash.class}"
+puts "   user.password_hash.to_s  # => #{user.password_hash.to_s}"
+puts
+
+begin
+  user.password_hash.to_json
+rescue Familia::SerializerError => e
+  puts "   user.password_hash.to_json # => #{e.class}: #{e.message}"
+end
+puts
+
+puts "   # Only public fields appear in JSON (password_hash is excluded):"
+puts "   user.as_json.keys # => #{user.as_json.keys}"
+puts
+
+puts "5. Framework Integration Examples:"
+puts "   # Rails controller"
+puts "   def show"
+puts "     render json: user  # Works with as_json/to_json"
+puts "   end"
+puts
+puts "   # Sinatra/Roda response"
+puts "   get '/user/:id' do"
+puts "     content_type :json"
+puts "     user.to_json  # Direct serialization"
+puts "   end"
+puts
+puts "   # API response with refinement"
+puts "   using Familia::Refinements::DearJson"
+puts "   response = {"
+puts "     user: user,"
+puts "     meta: { version: '1.0' }"
+puts "   }"
+puts "   response.to_json  # Handles mixed Familia/core objects"
+puts
+
+puts "=== Summary ==="
+puts "✅ Security: All JSON serialization uses OJ strict mode"
+puts "✅ Encrypted fields: Automatically concealed (ConcealedString protection)"
+puts "✅ Public fields only: Horreum objects expose only defined fields"
+puts "✅ DataType support: Lists, sets, etc. serialize their contents"
+puts "✅ Developer experience: Standard Ruby JSON interface (as_json/to_json)"
+puts "✅ Opt-in convenience: Refinements for Hash/Array when desired"
+puts "✅ Framework compatible: Works with Rails, Sinatra, Roda, etc."

data/examples/relationships.rb

@@ -27,7 +27,7 @@ class Customer < Familia::Horreum
 
   # Define collections for tracking relationships
   set :domains           # Simple set of domain IDs
-  list :projects         # Ordered list of project IDs
+  listkey :projects      # Ordered list of project IDs
   sorted_set :activity   # Activity feed with timestamps
 
   # Create indexes for fast lookups (using class_ prefix for class-level)
@@ -35,7 +35,7 @@ class Customer < Familia::Horreum
   class_indexed_by :plan, :plan_lookup # i.e. Customer.plan_lookup
 
   # Track in class-level collections (using class_ prefix for class-level)
-  class_tracked_in :all_customers, score: :created_at # i.e. Customer.all_customers
+  class_participates_in :all_customers, score: :created_at # i.e. Customer.all_customers
 end
 
 class Domain < Familia::Horreum
@@ -49,11 +49,11 @@ class Domain < Familia::Horreum
   field :status
 
   # Declare membership in customer collections
-  member_of Customer, :domains # , type: :set
+  participates_in Customer, :domains # , type: :set
 
   # Track domains by status (using class_ prefix for class-level)
-  class_tracked_in :active_domains,
-                   score: -> { status == 'active' ? Time.now.to_i : 0 }
+  class_participates_in :active_domains,
+                        score: -> { status == 'active' ? Familia.now.to_i : 0 }
 end
 
 class Project < Familia::Horreum
@@ -66,7 +66,7 @@ class Project < Familia::Horreum
   field :priority
 
   # Member of customer projects list (ordered)
-  member_of Customer, :projects, type: :list
+  participates_in Customer, :projects, type: :list
 end
 
 puts '=== 1. Basic Object Creation ==='
@@ -110,7 +110,7 @@ puts '=== 2. Establishing Relationships ==='
 customer.save # Automatically adds to email_lookup, plan_lookup, and all_customers
 puts '✓ Customer automatically added to indexes and tracking on save'
 
-# Establish member_of relationships using clean << operator syntax
+# Establish participates_in relationships using clean << operator syntax
 customer.domains << domain1   # Clean Ruby-like syntax
 customer.domains << domain2   # Same as domain1.add_to_customer_domains(customer)
 customer.projects << project  # Same as project.add_to_customer_projects(customer)
@@ -149,7 +149,7 @@ puts "  Customer has #{customer.projects.size} projects"
 puts "  Domain IDs: #{customer.domains.members}"
 puts "  Project IDs: #{customer.projects.members}"
 
-# Test tracked_in collections
+# Test participates_in collections
 all_customers_count = Customer.values.size
 puts "\nClass-level tracking:"
 puts "  Total customers in system: #{all_customers_count}"
@@ -161,7 +161,7 @@ puts
 puts '=== 4. Range Queries ==='
 
 # Get recent customers (last 24 hours)
-yesterday = (Time.now - (24 * 3600)).to_i # 24 hours ago
+yesterday = (Familia.now - (24 * 3600)).to_i # 24 hours ago
 recent_customers = Customer.values.rangebyscore(yesterday, '+inf')
 puts "Recent customers (last 24h): #{recent_customers.size}"
 
@@ -178,7 +178,7 @@ puts '=== 6. Relationship Cleanup ==='
 # Remove relationships
 puts 'Cleaning up relationships...'
 
-# Remove from member_of relationships
+# Remove from participates_in relationships
 domain1.remove_from_customer_domains(customer)
 puts "✓ Removed #{domain1.name} from customer domains"
 
@@ -195,10 +195,10 @@ puts
 puts '=== Example Complete! ==='
 puts
 puts 'Key takeaways:'
-puts '• class_tracked_in: Automatic class-level collections updated on save'
+puts '• class_participates_in: Automatic class-level collections updated on save'
 puts '• class_indexed_by: Automatic class-level indexes updated on save'
-puts '• member_of: Use << operator for clean Ruby-like collection syntax'
-puts '• indexed_by with parent:: Use for relationship-scoped indexes'
+puts '• participates_in: Use << operator for clean Ruby-like collection syntax'
+puts '• indexed_by with context:: Use for relationship-scoped indexes'
 puts '• Save operations: Automatically update indexes and class-level tracking'
 puts '• << operator: Works naturally with all collection types (sets, lists, sorted sets)'
 puts

data/examples/safe_dump.rb

@@ -38,10 +38,10 @@ puts 'Example 1: Basic SafeDump'
 user = User.new(
   email: 'alice@example.com',
   first_name: 'Alice',
-  last_name: 'Smith',
+  last_name: 'Windows',
   password_hash: 'secret123',
   ssn: '123-45-6789',
-  created_at: Time.now.to_i
+  created_at: Familia.now.to_i
 )
 
 puts "Full object data: #{user.to_h}"
@@ -70,7 +70,7 @@ class Product < Familia::Horreum
 
   # Computed fields using callables
   safe_dump_field :price, ->(product) { "$#{format('%.2f', product.price_cents.to_i / 100.0)}" }
-  safe_dump_field :in_stock, ->(product) { product.inventory_count.to_i > 0 }
+  safe_dump_field :in_stock, ->(product) { product.inventory_count.to_i.positive? }
   safe_dump_field :display_name, ->(product) { "#{product.name} (#{product.sku})" }
 end
 
@@ -82,7 +82,7 @@ product = Product.new(
   cost_cents: 800,       # $8.00 - sensitive, not exposed
   inventory_count: 25,
   category: 'widgets',
-  created_at: Time.now.to_i
+  created_at: Familia.now.to_i
 )
 
 puts "Full object data: #{product.to_h}"
@@ -140,8 +140,8 @@ order = Order.new(
   payment_method: 'credit_card',
   credit_card_number: '4111-1111-1111-1111', # Never expose this!
   processing_notes: 'Rush order - expedite shipping',
-  created_at: Time.now.to_i - 86_400, # Yesterday
-  shipped_at: Time.now.to_i - 3600 # 1 hour ago
+  created_at: Familia.now.to_i - 86_400, # Yesterday
+  shipped_at: Familia.now.to_i - 3600 # 1 hour ago
 )
 
 puts "Full object data: #{order.to_h}"