lutaml-store 0.1.1

data/lib/lutaml/store/cache_store.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Store
+    # TTL-aware cache store with LRU eviction. Wraps a storage adapter directly.
+    class CacheStore
+      class CacheEntry
+        attr_reader :value, :created_at, :ttl, :metadata
+
+        def initialize(value, ttl: nil, metadata: {}, created_at: nil)
+          @value = value
+          @created_at = created_at || Time.now
+          @ttl = ttl
+          @metadata = metadata
+        end
+
+        def expired?
+          return false unless @ttl
+
+          Time.now - @created_at > @ttl
+        end
+
+        def expires_at
+          return nil unless @ttl
+
+          @created_at + @ttl
+        end
+
+        def to_h
+          {
+            value: @value,
+            created_at: @created_at.iso8601,
+            ttl: @ttl,
+            expires_at: expires_at&.iso8601,
+            metadata: @metadata
+          }
+        end
+
+        def self.from_h(hash)
+          new(
+            hash[:value],
+            ttl: hash[:ttl],
+            metadata: hash[:metadata] || {},
+            created_at: Time.parse(hash[:created_at])
+          )
+        end
+      end
+
+      attr_reader :adapter
+
+      def initialize(config = {})
+        @adapter = create_adapter(config)
+        @default_ttl = config[:default_ttl]
+        @max_size = config[:max_size]
+        @cleanup_interval = config[:cleanup_interval] || 300
+        @last_cleanup = Time.now
+        @access_times = {}
+      end
+
+      def get(key)
+        cleanup_expired if should_cleanup?
+
+        entry_data = @adapter.get(key)
+        return nil unless entry_data
+
+        begin
+          entry = deserialize_entry(entry_data)
+
+          if entry.expired?
+            delete(key)
+            return nil
+          end
+
+          @access_times[key] = Time.now
+          entry.value
+        rescue StandardError
+          delete(key)
+          nil
+        end
+      end
+
+      def set(key, value, ttl: :default, metadata: {})
+        cleanup_expired if should_cleanup?
+        evict_if_needed
+
+        effective_ttl = ttl == :default ? @default_ttl : ttl
+        entry = CacheEntry.new(value, ttl: effective_ttl, metadata: metadata)
+
+        serialized_entry = serialize_entry(entry)
+        @adapter.set(key, serialized_entry)
+
+        @access_times[key] = Time.now
+        value
+      end
+
+      def delete(key)
+        value = nil
+        entry_data = @adapter.get(key)
+        if entry_data
+          begin
+            entry = deserialize_entry(entry_data)
+            value = entry.value unless entry.expired?
+          rescue StandardError
+            # If we can't deserialize, treat as nil
+          end
+        end
+
+        @access_times.delete(key)
+
+        deleted = @adapter.delete(key)
+
+        deleted ? value : nil
+      end
+
+      def clear
+        @access_times.clear
+        @adapter.clear
+      end
+
+      def exists?(key)
+        return false unless @adapter.exists?(key)
+
+        entry_data = @adapter.get(key)
+        return false unless entry_data
+
+        begin
+          entry = deserialize_entry(entry_data)
+          !entry.expired?
+        rescue StandardError
+          false
+        end
+      end
+
+      def keys
+        cleanup_expired if should_cleanup?
+        @adapter.keys.select { |key| exists?(key) }
+      end
+
+      def size
+        cleanup_expired if should_cleanup?
+        keys.size
+      end
+
+      def ttl(key)
+        entry_data = @adapter.get(key)
+        return nil unless entry_data
+
+        begin
+          entry = deserialize_entry(entry_data)
+          return nil if entry.expired?
+          return nil unless entry.ttl
+
+          remaining = entry.ttl - (Time.now - entry.created_at)
+          remaining.positive? ? remaining : nil
+        rescue StandardError
+          nil
+        end
+      end
+
+      def expire(key)
+        delete(key)
+      end
+
+      def expire_all
+        clear
+      end
+
+      def cleanup_expired
+        expired_keys = []
+
+        @adapter.keys.each do |key|
+          entry_data = @adapter.get(key)
+          next unless entry_data
+
+          entry = deserialize_entry(entry_data)
+          expired_keys << key if entry.expired?
+        rescue StandardError
+          expired_keys << key
+        end
+
+        expired_keys.each { |key| delete(key) }
+        @last_cleanup = Time.now
+
+        expired_keys.size
+      end
+
+      def cache_info
+        total_keys = @adapter.keys.size
+        valid_keys = keys.size
+        expired_keys = total_keys - valid_keys
+
+        {
+          total_entries: total_keys,
+          valid_entries: valid_keys,
+          expired_entries: expired_keys,
+          max_size: @max_size,
+          default_ttl: @default_ttl,
+          last_cleanup: @last_cleanup
+        }
+      end
+
+      def touch(key, ttl: nil)
+        entry_data = @adapter.get(key)
+        return false unless entry_data
+
+        begin
+          entry = deserialize_entry(entry_data)
+          return false if entry.expired?
+
+          new_ttl = ttl || entry.ttl
+          new_entry = CacheEntry.new(entry.value, ttl: new_ttl, metadata: entry.metadata)
+
+          serialized_entry = serialize_entry(new_entry)
+          @adapter.set(key, serialized_entry)
+
+          @access_times[key] = Time.now
+          true
+        rescue StandardError
+          false
+        end
+      end
+
+      def fetch(key, ttl: :default, metadata: {}, &block)
+        value = get(key)
+        return value unless value.nil?
+
+        return nil unless block_given?
+
+        value = block.call
+        set(key, value, ttl: ttl, metadata: metadata)
+        value
+      end
+
+      def close
+        @adapter.close
+      end
+
+      private
+
+      def create_adapter(config)
+        adapter_type = config[:adapter]&.dig(:type) || config[:adapter_type] || :memory
+        adapter_options = config[:adapter]&.dig(:options) || config[:adapter_options] || {}
+
+        case adapter_type.to_sym
+        when :memory
+          Adapter::Memory.new(adapter_options)
+        when :filesystem
+          Adapter::FileSystem.new(adapter_options)
+        when :sqlite
+          Adapter::Sqlite.new(adapter_options)
+        else
+          raise ConfigurationError, "Unknown adapter type: #{adapter_type}"
+        end
+      end
+
+      def serialize_entry(entry)
+        JSON.generate(entry.to_h)
+      end
+
+      def deserialize_entry(data)
+        hash = JSON.parse(data, symbolize_names: true)
+        CacheEntry.from_h(hash)
+      end
+
+      def should_cleanup?
+        Time.now - @last_cleanup > @cleanup_interval
+      end
+
+      def evict_if_needed
+        return unless @max_size
+        return if size < @max_size
+
+        keys_by_access = @access_times.sort_by { |_, time| time }.map(&:first)
+        keys_to_evict = keys_by_access.first(size - @max_size + 1)
+
+        keys_to_evict.each { |key| delete(key) }
+      end
+    end
+  end
+end

data/lib/lutaml/store/composite_model_handler.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    class CompositeModelHandler
+      Reference = Struct.new(:storage_key, :model_class, :key_value, keyword_init: true)
+
+      def initialize(registry, store, model_store = nil, serializer:)
+        @registry = registry
+        @store = store
+        @model_store = model_store
+        @serializer = serializer
+      end
+
+      def process_composite_models(model)
+        composite_models = @registry.find_composite_models(model)
+        stored_composites = {}
+
+        composite_models.each do |attr_path, composite_info|
+          nested_model = composite_info[:model]
+          registration = composite_info[:registration]
+
+          storage_key = registration.generate_storage_key(nested_model)
+          serialized_data = @serializer.serialize(nested_model)
+          @store.set(storage_key, serialized_data)
+
+          stored_composites[attr_path] = Reference.new(
+            storage_key: storage_key.to_s,
+            model_class: nested_model.class.name,
+            key_value: composite_info[:key_value]
+          )
+        end
+
+        stored_composites
+      end
+
+      def restore_composite_models(model, composite_references = nil)
+        return model unless composite_references
+
+        restored_model = model.dup
+
+        composite_references.each do |attr_path, reference_info|
+          ref = if reference_info.is_a?(Hash)
+                  Reference.new(**reference_info.transform_keys(&:to_sym).slice(
+                    :storage_key, :model_class, :key_value
+                  ))
+                else
+                  reference_info
+                end
+          nested_model = restore_nested_model(ref)
+          next unless nested_model
+
+          set_nested_attribute(restored_model, attr_path, nested_model)
+        end
+
+        restored_model
+      end
+
+      def update_composite_models(model, updates)
+        composite_updates = extract_composite_updates(updates)
+        return if composite_updates.empty?
+
+        composite_updates.each do |attr_path, update_value|
+          if attr_path.include?(".")
+            update_nested_composite(model, attr_path, update_value)
+          else
+            update_direct_composite(model, attr_path, update_value)
+          end
+        end
+      end
+
+      def delete_composite_models(model)
+        composite_models = @registry.find_composite_models(model)
+
+        composite_models.each_value do |composite_info|
+          registration = composite_info[:registration]
+          storage_key = registration.generate_storage_key(composite_info[:model])
+          @store.delete(storage_key)
+        end
+      end
+
+      private
+
+      def restore_nested_model(reference)
+        storage_key = reference.storage_key
+        model_class_name = reference.model_class
+        key_value = reference.key_value
+
+        if @model_store && key_value
+          model_class = Object.const_get(model_class_name)
+          registration = @registry.find_registration(model_class)
+          if registration
+            key_field = registration.key_field
+            return @model_store.fetch(model: model_class, key_field => key_value)
+          end
+        end
+
+        serialized_data = @store.get(storage_key)
+        return nil unless serialized_data
+
+        model_class = Object.const_get(model_class_name)
+        @serializer.deserialize(serialized_data, model_class)
+      end
+
+      def set_nested_attribute(model, attr_path, value)
+        attr_path_str = attr_path.to_s
+        if attr_path_str.include?(".")
+          parts = attr_path_str.split(".")
+          current = navigate_to_parent(model, parts[0..-2])
+          set_final_attribute(current, parts.last, value)
+        else
+          model.public_send("#{attr_path}=", value)
+        end
+      end
+
+      def navigate_to_parent(model, path_parts)
+        path_parts.reduce(model) do |current, part|
+          if part.match?(/\A\d+\z/)
+            current[part.to_i]
+          else
+            current.public_send(part)
+          end
+        end
+      end
+
+      def set_final_attribute(current, attr, value)
+        if attr.match?(/\A\d+\z/)
+          current[attr.to_i] = value
+        else
+          current.public_send("#{attr}=", value)
+        end
+      end
+
+      def extract_composite_updates(updates)
+        updates.each_with_object({}) do |update, result|
+          key = update[:key].to_s
+          value = update[:value]
+          result[key] = value if key.include?(".") || registered_model?(value)
+        end
+      end
+
+      def update_nested_composite(model, attr_path, update_value)
+        root_attr = attr_path.split(".").first
+        composite_model = model.public_send(root_attr)
+        return unless composite_model && @registry.registered?(composite_model.class)
+
+        set_nested_attribute(composite_model, attr_path.split(".", 2).last, update_value)
+
+        registration = @registry.registration_for(composite_model.class)
+        storage_key = registration.generate_storage_key(composite_model)
+        @store.set(storage_key, @serializer.serialize(composite_model))
+      end
+
+      def update_direct_composite(model, attr_path, new_composite_model)
+        return unless registered_model?(new_composite_model)
+
+        registration = @registry.registration_for(new_composite_model.class)
+        storage_key = registration.generate_storage_key(new_composite_model)
+        @store.set(storage_key, @serializer.serialize(new_composite_model))
+
+        model.public_send("#{attr_path}=", new_composite_model)
+      end
+
+      def registered_model?(value)
+        value.is_a?(Object) && @registry.registered?(value.class)
+      end
+    end
+  end
+end

data/lib/lutaml/store/compression.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module Lutaml
+  module Store
+    class Compression
+      SUPPORTED_ALGORITHMS = %w[gzip deflate bzip2 lz4 zstd].freeze
+
+      def self.compress(data, algorithm = "gzip", level = 6)
+        case algorithm.to_s.downcase
+        when "gzip"
+          compress_gzip(data, level)
+        when "deflate"
+          compress_deflate(data, level)
+        when "bzip2"
+          compress_bzip2(data, level)
+        when "lz4"
+          compress_lz4(data)
+        when "zstd"
+          compress_zstd(data, level)
+        else
+          raise ArgumentError,
+                "Unsupported compression algorithm: #{algorithm}. Supported: #{SUPPORTED_ALGORITHMS.join(", ")}"
+        end
+      end
+
+      def self.decompress(data, algorithm = "gzip")
+        case algorithm.to_s.downcase
+        when "gzip"
+          decompress_gzip(data)
+        when "deflate"
+          decompress_deflate(data)
+        when "bzip2"
+          decompress_bzip2(data)
+        when "lz4"
+          decompress_lz4(data)
+        when "zstd"
+          decompress_zstd(data)
+        else
+          raise ArgumentError,
+                "Unsupported compression algorithm: #{algorithm}. Supported: #{SUPPORTED_ALGORITHMS.join(", ")}"
+        end
+      end
+
+      def self.detect_algorithm(data)
+        return nil unless data.is_a?(String)
+
+        # Force binary encoding for magic number detection
+        binary_data = data.dup.force_encoding("ASCII-8BIT")
+
+        # Define magic numbers as binary strings
+        gzip_magic = "\x1f\x8b".b
+        deflate_magic = "\x78".b
+        bzip2_magic = "BZ".b
+        lz4_magic = "\x04\"M\x18".b
+        zstd_magic = "\x28\xb5\x2f\xfd".b
+
+        # Check magic numbers
+        return "gzip" if binary_data.start_with?(gzip_magic)
+        return "deflate" if binary_data.start_with?(deflate_magic)
+        return "bzip2" if binary_data.start_with?(bzip2_magic)
+        return "lz4" if binary_data.start_with?(lz4_magic)
+        return "zstd" if binary_data.start_with?(zstd_magic)
+
+        nil # No compression detected
+      end
+
+      def self.compress_gzip(data, level)
+        io = StringIO.new
+        gz = Zlib::GzipWriter.new(io, level)
+        gz.write(data)
+        gz.close
+        io.string
+      end
+
+      def self.decompress_gzip(data)
+        io = StringIO.new(data)
+        gz = Zlib::GzipReader.new(io)
+        result = gz.read
+        gz.close
+        result
+      end
+
+      def self.compress_deflate(data, level)
+        Zlib::Deflate.deflate(data, level)
+      end
+
+      def self.decompress_deflate(data)
+        Zlib::Inflate.inflate(data)
+      end
+
+      def self.compress_bzip2(data, level)
+        require "bzip2-ffi"
+        Bzip2::FFI.compress(data, level)
+      rescue LoadError
+        raise ArgumentError, "bzip2-ffi gem is required for bzip2 compression"
+      end
+
+      def self.decompress_bzip2(data)
+        require "bzip2-ffi"
+        Bzip2::FFI.decompress(data)
+      rescue LoadError
+        raise ArgumentError, "bzip2-ffi gem is required for bzip2 compression"
+      end
+
+      def self.compress_lz4(data)
+        require "lz4-ruby"
+        LZ4.compress(data)
+      rescue LoadError
+        raise ArgumentError, "lz4-ruby gem is required for LZ4 compression"
+      end
+
+      def self.decompress_lz4(data)
+        require "lz4-ruby"
+        LZ4.decompress(data)
+      rescue LoadError
+        raise ArgumentError, "lz4-ruby gem is required for LZ4 compression"
+      end
+
+      def self.compress_zstd(data, level)
+        require "zstd-ruby"
+        Zstd.compress(data, level: level)
+      rescue LoadError
+        raise ArgumentError, "zstd-ruby gem is required for Zstd compression"
+      end
+
+      def self.decompress_zstd(data)
+        require "zstd-ruby"
+        Zstd.decompress(data)
+      rescue LoadError
+        raise ArgumentError, "zstd-ruby gem is required for Zstd compression"
+      end
+    end
+  end
+end