lutaml-store 0.1.1

data/lib/lutaml/store/http_header_processor.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "uri"
+require "digest"
+require "time"
+
+module Lutaml
+  module Store
+    class HttpHeaderProcessor
+      # Parse Cache-Control header according to RFC 7234
+      def self.parse_cache_control(header_value)
+        return {} unless header_value
+
+        directives = {}
+        header_value.split(",").each do |directive|
+          key, value = directive.strip.split("=", 2)
+          key = key.strip.downcase
+
+          if value
+            # Handle quoted values
+            value = value.strip.gsub(/^"(.*)"$/, '\1')
+            directives[key] = value.match?(/^\d+$/) ? value.to_i : value
+          else
+            directives[key] = true
+          end
+        end
+        directives
+      end
+
+      # Calculate expiry time based on HTTP headers
+      def self.calculate_expiry(response_headers, cached_at, default_ttl)
+        cache_control = parse_cache_control(response_headers["cache-control"])
+
+        # Check for explicit expiry
+        if (expires_header = response_headers["expires"])
+          begin
+            return Time.parse(expires_header)
+          rescue StandardError
+            nil
+          end
+        end
+
+        # Check for max-age
+        if (max_age = cache_control["max-age"])
+          return cached_at + max_age
+        end
+
+        # Fall back to default TTL
+        cached_at + default_ttl
+      end
+
+      # Determine if response should be cached
+      def self.should_cache_response?(status_code, response_headers)
+        return false if status_code < 200 || status_code >= 400
+
+        cache_control = parse_cache_control(response_headers["cache-control"])
+        return false if cache_control["no-store"]
+        return false if cache_control["private"] # Unless explicitly allowing private
+
+        true
+      end
+
+      # Generate cache key from request details
+      def self.generate_cache_key(method, url, vary_headers = {}, ignore_params = [])
+        uri = URI.parse(url)
+
+        # Normalize query parameters
+        if uri.query
+          params = URI.decode_www_form(uri.query)
+          # Filter out ignored parameters
+          params = params.reject { |key, _| ignore_params.include?(key) }
+          params = params.sort
+          uri.query = params.empty? ? nil : URI.encode_www_form(params)
+        end
+
+        base_key = "#{method.upcase}:#{uri}"
+
+        # Add vary headers to key if present
+        if vary_headers.any?
+          vary_suffix = vary_headers.sort.map { |k, v| "#{k}:#{v}" }.join("|")
+          base_key += "|#{Digest::SHA256.hexdigest(vary_suffix)[0..8]}"
+        end
+
+        base_key
+      end
+
+      # Parse Vary header
+      def self.parse_vary_header(vary_header)
+        return [] unless vary_header
+
+        vary_header.split(",").map(&:strip).map(&:downcase)
+      end
+
+      # Extract vary headers from request headers
+      def self.extract_vary_headers(request_headers, vary_header_names)
+        return {} if vary_header_names.empty?
+
+        vary_headers = {}
+        vary_header_names.each do |header_name|
+          normalized_name = header_name.downcase
+          # Find header with case-insensitive matching
+          actual_header = request_headers.find { |k, _| k.downcase == normalized_name }
+          vary_headers[normalized_name] = actual_header[1] if actual_header
+        end
+        vary_headers
+      end
+
+      # Check if response is fresh based on age
+      def self.fresh?(cached_at, max_age, expires_at)
+        return false if expires_at && Time.now > expires_at
+        return false if max_age && (Time.now - cached_at) > max_age
+
+        true
+      end
+
+      # Build conditional request headers
+      def self.build_conditional_headers(cache_entry, original_headers)
+        conditional_headers = original_headers.dup
+
+        conditional_headers["If-None-Match"] = cache_entry.etag if cache_entry.etag
+
+        conditional_headers["If-Modified-Since"] = cache_entry.last_modified.httpdate if cache_entry.last_modified
+
+        conditional_headers
+      end
+
+      # Parse Last-Modified header
+      def self.parse_last_modified(header_value)
+        return nil unless header_value
+
+        begin
+          Time.parse(header_value)
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Check if cache entry matches request (considering Vary)
+      def self.cache_entry_matches?(cache_entry, request_headers, config)
+        return true if cache_entry.vary_headers.empty?
+
+        # Extract vary headers from current request
+        current_vary = extract_vary_headers(request_headers, cache_entry.vary_headers)
+
+        # Compare with cached vary headers
+        cache_entry.vary_headers.each do |header_name|
+          cached_value = cache_entry.request_headers[header_name.downcase]
+          current_value = current_vary[header_name.downcase]
+
+          # Skip comparison for ignored headers
+          next if config.should_ignore_vary_header?(header_name)
+
+          return false if cached_value != current_value
+        end
+
+        true
+      end
+
+      # Normalize header name for consistent storage
+      def self.normalize_header_name(name)
+        name.to_s.downcase.strip
+      end
+
+      # Check if response has caching directives
+      def self.has_caching_directives?(response_headers)
+        return true if response_headers["cache-control"]
+        return true if response_headers["expires"]
+        return true if response_headers["etag"]
+        return true if response_headers["last-modified"]
+
+        false
+      end
+    end
+  end
+end

data/lib/lutaml/store/integrity.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Lutaml
+  module Store
+    class Integrity
+      class IntegrityError < StandardError; end
+      class CorruptionError < IntegrityError; end
+      class ChecksumMismatchError < IntegrityError; end
+
+      def self.calculate_checksum(data, algorithm = "sha256")
+        # Convert data to string if it's not already
+        string_data = data.is_a?(String) ? data : data.to_s
+
+        case algorithm.to_s.downcase
+        when "md5"
+          Digest::MD5.hexdigest(string_data)
+        when "sha1"
+          Digest::SHA1.hexdigest(string_data)
+        when "sha256"
+          Digest::SHA256.hexdigest(string_data)
+        when "sha512"
+          Digest::SHA512.hexdigest(string_data)
+        else
+          raise ArgumentError, "Unsupported checksum algorithm: #{algorithm}"
+        end
+      end
+
+      def self.verify_checksum(data, expected_checksum, algorithm = "sha256")
+        actual_checksum = calculate_checksum(data, algorithm)
+        unless actual_checksum == expected_checksum
+          raise ChecksumMismatchError,
+                "Checksum mismatch: expected #{expected_checksum}, got #{actual_checksum}"
+        end
+        true
+      end
+
+      def self.create_integrity_metadata(data, algorithm = "sha256")
+        string_data = data.is_a?(String) ? data : data.to_s
+        {
+          checksum: calculate_checksum(data, algorithm),
+          algorithm: algorithm,
+          size: string_data.bytesize,
+          created_at: Time.now.utc.iso8601,
+          version: "1.0"
+        }
+      end
+
+      def self.verify_integrity_metadata(data, metadata)
+        string_data = data.is_a?(String) ? data : data.to_s
+
+        # Verify size
+        if metadata[:size] && string_data.bytesize != metadata[:size]
+          raise CorruptionError,
+                "Size mismatch: expected #{metadata[:size]}, got #{string_data.bytesize}"
+        end
+
+        # Verify checksum
+        verify_checksum(data, metadata[:checksum], metadata[:algorithm]) if metadata[:checksum] && metadata[:algorithm]
+
+        true
+      end
+
+      def self.repair_data(corrupted_data, backup_data = nil)
+        # Basic repair attempt - in a real implementation, this could be more sophisticated
+        return backup_data if backup_data && valid_data?(backup_data)
+
+        # Try to clean up common corruption patterns
+        cleaned_data = corrupted_data.dup
+
+        # Remove null bytes that might have been introduced
+        cleaned_data.gsub!("\x00", "")
+
+        # Try to fix truncated JSON/YAML
+        if cleaned_data.strip.start_with?("{") && !cleaned_data.strip.end_with?("}")
+          cleaned_data += "}"
+        elsif cleaned_data.strip.start_with?("[") && !cleaned_data.strip.end_with?("]")
+          cleaned_data += "]"
+        end
+
+        cleaned_data
+      end
+
+      def self.valid_data?(data)
+        return false if data.nil? || data.empty?
+        return false if data.include?("\x00") # Contains null bytes
+
+        # Basic validation - data should be valid UTF-8 or binary
+        begin
+          data.encode("UTF-8")
+          true
+        rescue Encoding::UndefinedConversionError
+          # Might be binary data, which is also valid
+          true
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/model_registration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Represents a single model registration with its metadata
+    class ModelRegistration
+      attr_reader :model_class, :key_field, :polymorphic_class_key, :serializer, :dir
+
+      def initialize(model_class, key_field, polymorphic_class_key: nil, serializer: nil, dir: nil)
+        @model_class = model_class
+        @key_field = key_field.to_sym
+        @polymorphic_class_key = polymorphic_class_key&.to_sym
+        @serializer = serializer
+        @dir = dir
+        validate!
+      end
+
+      # Extract key value from model instance
+      def extract_key(model)
+        key_value = model.public_send(@key_field)
+        raise InvalidKeyError, "Key field '#{@key_field}' is nil for #{@model_class}" if key_value.nil?
+
+        key_value.to_s
+      end
+
+      # Check if registration supports polymorphism
+      def polymorphic?
+        !@polymorphic_class_key.nil?
+      end
+
+      # Extract polymorphic class from model instance
+      def extract_polymorphic_class(model)
+        return @model_class.name unless polymorphic?
+
+        polymorphic_value = model.public_send(@polymorphic_class_key)
+        polymorphic_value || @model_class.name
+      end
+
+      # Generate storage key for model
+      def generate_storage_key(model)
+        StorageKey.new(model.class.name, extract_key(model))
+      end
+
+      # Generate storage key from key value and optional polymorphic class
+      def generate_storage_key_from_value(key_value, polymorphic_class = nil)
+        class_name = polymorphic_class || @model_class.name
+        StorageKey.new(class_name, key_value)
+      end
+
+      # Check if model class matches this registration (including inheritance)
+      def matches_model?(model_class)
+        model_class <= @model_class
+      end
+
+      private
+
+      def validate!
+        # Check if key field exists on model
+        unless @model_class.method_defined?(@key_field) ||
+               @model_class.private_method_defined?(@key_field)
+          raise ConfigurationError,
+                "Key field '#{@key_field}' does not exist on #{@model_class}"
+        end
+
+        # Check if polymorphic class key exists when specified
+        if polymorphic? &&
+           !@model_class.method_defined?(@polymorphic_class_key) &&
+           !@model_class.private_method_defined?(@polymorphic_class_key)
+          raise ConfigurationError,
+                "Polymorphic class key '#{@polymorphic_class_key}' does not exist on #{@model_class}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/model_registry.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Manages registered models with their key fields and polymorphic configurations
+    class ModelRegistry
+      def initialize(model_configs = [])
+        @registrations = {}
+        register_models(model_configs)
+      end
+
+      # Register a single model
+      def register(model_class, key_field, **options)
+        registration = ModelRegistration.new(model_class, key_field, **options)
+        @registrations[model_class] = registration
+        registration
+      end
+
+      # Register multiple models from configuration array
+      def register_models(model_configs)
+        model_configs.each do |config|
+          raise ConfigurationError, "Invalid model configuration: #{config}" unless config.is_a?(Hash)
+
+          model_class = config[:model]
+          key_field = config[:key]
+          register(model_class, key_field, **config.except(:model, :key))
+        end
+      end
+
+      # Find registration for model class or its superclass
+      def find_registration(model_class)
+        # First try exact match
+        return @registrations[model_class] if @registrations[model_class]
+
+        # Then try inheritance chain
+        @registrations.each_value do |registration|
+          return registration if registration.matches_model?(model_class)
+        end
+
+        nil
+      end
+
+      # Check if model is registered
+      def registered?(model_class)
+        !find_registration(model_class).nil?
+      end
+
+      # Get registration for model class (raises error if not found)
+      def registration_for(model_class)
+        registration = find_registration(model_class)
+        unless registration
+          raise ModelNotRegisteredError,
+                "Model #{model_class} is not registered. " \
+                "Register it with: models: [{ model: #{model_class}, key: :key_field }]"
+        end
+        registration
+      end
+
+      # Get all registered model classes
+      def registered_models
+        @registrations.keys
+      end
+
+      # Get all registrations
+      def registrations
+        @registrations.values
+      end
+
+      # Check if any models are registered
+      def empty?
+        @registrations.empty?
+      end
+
+      # Get count of registered models
+      def count
+        @registrations.size
+      end
+
+      # Clear all registrations
+      def clear
+        @registrations.clear
+      end
+
+      # Find models that are registered and nested within other models
+      def find_composite_models(model)
+        composite_models = {}
+
+        model.class.attributes.each_key do |attr_name|
+          attr_value = model.public_send(attr_name)
+          next if attr_value.nil?
+
+          add_composite_entry(composite_models, attr_name, attr_value) if attr_value.is_a?(Object) && registered?(attr_value.class)
+
+          next unless attr_value.is_a?(Array)
+
+          attr_value.each_with_index do |item, index|
+            next unless item.is_a?(Object) && registered?(item.class)
+
+            add_composite_entry(composite_models, "#{attr_name}.#{index}", item)
+          end
+        end
+
+        composite_models
+      rescue NoMethodError
+        {}
+      end
+
+      private
+
+      def add_composite_entry(composite_models, attr_path, model_instance)
+        registration = find_registration(model_instance.class)
+        key_value = model_instance.public_send(registration.key_field)
+        return if key_value.nil?
+
+        composite_models[attr_path] = {
+          model: model_instance,
+          registration: registration,
+          key_value: key_value.to_s
+        }
+      end
+    end
+  end
+end

data/lib/lutaml/store/model_serializer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Single point of serialization/deserialization for Lutaml::Model objects.
+    # All registered models are Lutaml::Model::Serializable, so they uniformly
+    # support to_hash / from_hash. No duck-typing needed.
+    class ModelSerializer
+      METADATA_KEY = "_class"
+      COMPOSITE_KEY = "_composite_models"
+
+      def serialize(model, registration = nil)
+        hash_data = if registration&.serializer
+                      registration.serializer.serialize(model)
+                    else
+                      extract_hash(model)
+                    end
+        hash_data.merge(METADATA_KEY => model.class.name)
+      end
+
+      def deserialize(data, expected_class, registration = nil)
+        validate_data!(data, expected_class)
+
+        model_class = resolve_class(data[METADATA_KEY])
+        validate_polymorphic_compatibility!(model_class, expected_class)
+
+        model_data = data.except(METADATA_KEY, COMPOSITE_KEY)
+        if registration&.serializer
+          registration.serializer.deserialize(model_data, model_class)
+        else
+          build_model(model_class, model_data)
+        end
+      end
+
+      private
+
+      def extract_hash(model)
+        model.to_hash
+      rescue NoMethodError
+        model.to_h
+      end
+
+      def build_model(model_class, data)
+        model_class.from_hash(data)
+      rescue NoMethodError
+        model_class.from_h(data)
+      end
+
+      def validate_data!(data, expected_class)
+        return if data.is_a?(Hash) && data[METADATA_KEY]
+
+        raise CompositeModelError, "Invalid serialized data for #{expected_class}"
+      end
+
+      def resolve_class(class_name)
+        Object.const_get(class_name)
+      rescue NameError
+        raise CompositeModelError, "Cannot resolve class #{class_name}"
+      end
+
+      def validate_polymorphic_compatibility!(model_class, expected_class)
+        return if model_class <= expected_class
+
+        raise PolymorphicUpdateError,
+              "Stored #{model_class} is not compatible with #{expected_class}"
+      end
+    end
+  end
+end