lutaml-store 0.1.1

data/lib/lutaml/store/adapter/filesystem.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+require "json"
+
+module Lutaml
+  module Store
+    module Adapter
+      class FileSystem < Base
+        DEFAULT_EXTENSION = ".data"
+        METADATA_EXTENSION = ".meta"
+
+        def initialize(config = {})
+          super
+          @root_path = @config[:path] || raise(ConfigurationError, "FileSystem adapter requires :path config")
+          @extension = @config[:extension] || DEFAULT_EXTENSION
+          @create_directories = @config.fetch(:create_directories, true)
+          @integrity_enabled = @config.fetch(:integrity_checks, true)
+          @integrity_algorithm = @config.fetch(:integrity_algorithm, "sha256")
+
+          setup_directory_structure
+        end
+
+        def get(key)
+          file_path = path_for_key(key)
+          return nil unless File.exist?(file_path)
+
+          data = file_safe_read(file_path)
+          metadata = read_metadata(key)
+
+          begin
+            verify_data_integrity(data, metadata)
+          rescue Integrity::IntegrityError => e
+            repaired_data = repair_corruption(key)
+            return repaired_data if repaired_data
+
+            raise e
+          end
+
+          data
+        end
+
+        def set(key, value)
+          file_path = path_for_key(key)
+          ensure_directory_exists(File.dirname(file_path))
+
+          full_metadata = wrap_with_integrity(value)
+          file_safe_write(file_path, value)
+          write_metadata(key, full_metadata) if full_metadata.any?
+          value
+        end
+
+        def delete(key)
+          file_path = path_for_key(key)
+          metadata_path = metadata_path_for_key(key)
+
+          return nil unless File.exist?(file_path)
+
+          value = file_safe_read(file_path)
+          File.delete(file_path)
+          File.delete(metadata_path) if File.exist?(metadata_path)
+
+          cleanup_empty_directories(File.dirname(file_path))
+
+          value
+        end
+
+        def exists?(key)
+          File.exist?(path_for_key(key))
+        end
+
+        def keys
+          return [] unless Dir.exist?(@root_path)
+
+          Dir.glob(File.join(@root_path, "**", "*#{@extension}")).filter_map do |file_path|
+            key_from_path(file_path) if File.file?(file_path)
+          end
+        end
+
+        def all
+          result = {}
+
+          Dir.glob(File.join(@root_path, "**", "*#{@extension}")).each do |file_path|
+            next unless File.file?(file_path)
+
+            key = key_from_path(file_path)
+            value = get(key)
+            result[key] = value if value
+          end
+
+          result
+        end
+
+        def clear
+          return 0 unless Dir.exist?(@root_path)
+
+          count = 0
+          Dir.glob(File.join(@root_path, "**", "*#{@extension}")).each do |file_path|
+            if File.file?(file_path)
+              File.delete(file_path)
+              count += 1
+            end
+          end
+
+          Dir.glob(File.join(@root_path, "**", "*#{METADATA_EXTENSION}")).each do |file_path|
+            File.delete(file_path) if File.file?(file_path)
+          end
+
+          cleanup_empty_directories(@root_path, preserve_root: true)
+
+          count
+        end
+
+        def size
+          return 0 unless Dir.exist?(@root_path)
+
+          Dir.glob(File.join(@root_path, "**", "*#{@extension}")).count { |path| File.file?(path) }
+        end
+
+        def close; end
+
+        def verify_integrity
+          corrupted_keys = []
+
+          keys.each do |key|
+            get(key)
+          rescue Integrity::IntegrityError
+            corrupted_keys << key
+          end
+
+          {
+            total_keys: keys.size,
+            corrupted_keys: corrupted_keys,
+            integrity_ok: corrupted_keys.empty?
+          }
+        end
+
+        def repair_corruption(key, backup_data = nil)
+          file_path = path_for_key(key)
+          return nil unless File.exist?(file_path)
+
+          corrupted_data = file_safe_read(file_path)
+          repaired_data = Integrity.repair_data(corrupted_data, backup_data)
+
+          if Integrity.valid_data?(repaired_data)
+            set(key, repaired_data)
+            return repaired_data
+          end
+
+          nil
+        end
+
+        def stats
+          super.merge(
+            root_path: @root_path,
+            extension: @extension,
+            disk_usage: calculate_disk_usage
+          )
+        end
+
+        private
+
+        def setup_directory_structure
+          return unless @create_directories
+
+          FileUtils.mkdir_p(@root_path) unless Dir.exist?(@root_path)
+        end
+
+        def path_for_key(key)
+          safe_key = sanitize_key(key)
+
+          if safe_key.length >= 2
+            subdir = safe_key[0, 2]
+            File.join(@root_path, subdir, "#{safe_key}#{@extension}")
+          else
+            File.join(@root_path, "#{safe_key}#{@extension}")
+          end
+        end
+
+        def metadata_path_for_key(key)
+          data_path = path_for_key(key)
+          data_path.sub(@extension, METADATA_EXTENSION)
+        end
+
+        def key_from_path(file_path)
+          relative_path = file_path.sub(@root_path, "").sub(%r{^/}, "")
+          File.basename(relative_path, @extension)
+        end
+
+        def sanitize_key(key)
+          key.to_s.gsub(/[^a-zA-Z0-9._-]/, "_")
+        end
+
+        def create_integrity_metadata(data)
+          return {} unless @integrity_enabled
+
+          Integrity.create_integrity_metadata(data, @integrity_algorithm)
+        end
+
+        def verify_data_integrity(data, metadata)
+          return true unless @integrity_enabled
+          return true unless metadata.is_a?(Hash) && metadata[:integrity]
+
+          Integrity.verify_integrity_metadata(data, metadata[:integrity])
+        end
+
+        def wrap_with_integrity(data, user_metadata = {})
+          metadata = user_metadata.dup
+          metadata[:integrity] = create_integrity_metadata(data) if @integrity_enabled
+          metadata
+        end
+
+        def write_metadata(key, metadata)
+          return unless metadata.any?
+
+          metadata_path = metadata_path_for_key(key)
+          ensure_directory_exists(File.dirname(metadata_path))
+
+          File.write(metadata_path, JSON.generate(metadata))
+        end
+
+        def read_metadata(key)
+          metadata_path = metadata_path_for_key(key)
+          return {} unless File.exist?(metadata_path)
+
+          begin
+            JSON.parse(File.read(metadata_path), symbolize_names: true)
+          rescue JSON::ParserError
+            {}
+          end
+        end
+
+        def ensure_directory_exists(dir_path)
+          return if Dir.exist?(dir_path)
+
+          FileUtils.mkdir_p(dir_path)
+        end
+
+        def cleanup_empty_directories(dir_path, preserve_root: false)
+          return if preserve_root && dir_path == @root_path
+          return unless Dir.exist?(dir_path)
+          return unless Dir.empty?(dir_path)
+
+          Dir.rmdir(dir_path)
+
+          parent_dir = File.dirname(dir_path)
+          cleanup_empty_directories(parent_dir, preserve_root: preserve_root) if parent_dir != dir_path
+        end
+
+        def file_safe_read(file_path)
+          File.open(file_path, "rb") do |file|
+            file.flock(File::LOCK_SH)
+            file.read
+          end
+        rescue StandardError => e
+          raise BackendError, "Failed to read file #{file_path}: #{e.message}"
+        end
+
+        def file_safe_write(file_path, content)
+          temp_path = "#{file_path}.tmp.#{Process.pid}"
+
+          File.open(temp_path, "wb") do |file|
+            file.flock(File::LOCK_EX)
+            file.write(content)
+            file.fsync
+          end
+
+          File.rename(temp_path, file_path)
+        rescue StandardError => e
+          File.delete(temp_path) if File.exist?(temp_path)
+          raise BackendError, "Failed to write file #{file_path}: #{e.message}"
+        end
+
+        def calculate_disk_usage
+          return 0 unless Dir.exist?(@root_path)
+
+          total_size = 0
+          Dir.glob(File.join(@root_path, "**", "*#{@extension}")).each do |file_path|
+            total_size += File.size(file_path) if File.file?(file_path)
+          end
+
+          total_size
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/adapter/memory.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    module Adapter
+      class Memory < Base
+        def initialize(config = {})
+          super
+          @data = {}
+          @mutex = Mutex.new
+          @ttl_enabled = @config.fetch(:ttl_enabled, false)
+          @ttl_data = {} if @ttl_enabled
+          @default_ttl = @config[:default_ttl] || 3600
+        end
+
+        def get(key)
+          @mutex.synchronize do
+            return nil unless @data.key?(key)
+
+            if @ttl_enabled && expired?(key)
+              @data.delete(key)
+              @ttl_data.delete(key)
+              return nil
+            end
+
+            @data[key]
+          end
+        end
+
+        def set(key, value, metadata = {})
+          @mutex.synchronize do
+            @data[key] = value
+
+            if @ttl_enabled
+              ttl_value = metadata[:ttl] || @default_ttl
+              @ttl_data[key] = Time.now + ttl_value if ttl_value
+            end
+
+            value
+          end
+        end
+
+        def delete(key)
+          @mutex.synchronize do
+            existed = @data.key?(key)
+            @data.delete(key)
+            @ttl_data.delete(key) if @ttl_enabled
+            existed
+          end
+        end
+
+        def exists?(key)
+          @mutex.synchronize do
+            return false unless @data.key?(key)
+
+            if @ttl_enabled && expired?(key)
+              @data.delete(key)
+              @ttl_data.delete(key)
+              return false
+            end
+
+            true
+          end
+        end
+
+        def all
+          @mutex.synchronize do
+            cleanup_expired if @ttl_enabled
+            @data.dup
+          end
+        end
+
+        def clear
+          @mutex.synchronize do
+            count = @data.size
+            @data.clear
+            @ttl_data.clear if @ttl_enabled
+            count
+          end
+        end
+
+        def size
+          @mutex.synchronize do
+            cleanup_expired if @ttl_enabled
+            @data.size
+          end
+        end
+
+        def keys
+          @mutex.synchronize do
+            cleanup_expired if @ttl_enabled
+            @data.keys
+          end
+        end
+
+        def close
+          @mutex.synchronize do
+            @data.clear
+            @ttl_data.clear if @ttl_enabled
+          end
+        end
+
+        def stats
+          @mutex.synchronize do
+            cleanup_expired if @ttl_enabled
+            super.merge(
+              size: @data.size,
+              ttl_enabled: @ttl_enabled,
+              expired_keys: @ttl_enabled ? count_expired_keys : 0
+            )
+          end
+        end
+
+        def cleanup_expired
+          return unless @ttl_enabled
+
+          @mutex.synchronize do
+            expired_keys = []
+            @ttl_data.each do |key, expiry_time|
+              expired_keys << key if Time.now > expiry_time
+            end
+
+            expired_keys.each do |key|
+              @data.delete(key)
+              @ttl_data.delete(key)
+            end
+
+            expired_keys.size
+          end
+        end
+
+        def set_ttl(key, ttl)
+          return false unless @ttl_enabled
+
+          @mutex.synchronize do
+            return false unless @data.key?(key)
+
+            if ttl
+              @ttl_data[key] = Time.now + ttl
+            else
+              @ttl_data.delete(key)
+            end
+
+            true
+          end
+        end
+
+        def get_ttl(key)
+          return nil unless @ttl_enabled
+
+          @mutex.synchronize do
+            return nil unless @ttl_data.key?(key)
+
+            expiry_time = @ttl_data[key]
+            remaining = expiry_time - Time.now
+            remaining.positive? ? remaining : nil
+          end
+        end
+
+        def bulk_set(key_value_pairs, ttl: nil)
+          @mutex.synchronize do
+            key_value_pairs.each do |key, value|
+              @data[key] = value
+
+              if @ttl_enabled
+                ttl_value = ttl || @default_ttl
+                @ttl_data[key] = Time.now + ttl_value if ttl_value
+              end
+            end
+          end
+        end
+
+        def bulk_get(keys)
+          @mutex.synchronize do
+            result = {}
+            keys.each do |key|
+              if @data.key?(key)
+                if @ttl_enabled && expired?(key)
+                  @data.delete(key)
+                  @ttl_data.delete(key)
+                  result[key] = nil
+                else
+                  result[key] = @data[key]
+                end
+              else
+                result[key] = nil
+              end
+            end
+            result
+          end
+        end
+
+        def bulk_delete(keys)
+          @mutex.synchronize do
+            result = {}
+            keys.each do |key|
+              result[key] = @data.delete(key)
+              @ttl_data.delete(key) if @ttl_enabled
+            end
+            result
+          end
+        end
+
+        private
+
+        def expired?(key)
+          return false unless @ttl_enabled
+          return false unless @ttl_data.key?(key)
+
+          Time.now > @ttl_data[key]
+        end
+
+        def count_expired_keys
+          return 0 unless @ttl_enabled
+
+          count = 0
+          @ttl_data.each_value do |expiry_time|
+            count += 1 if Time.now > expiry_time
+          end
+          count
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/adapter/sqlite.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module Store
+    module Adapter
+      class Sqlite < Base
+        DEFAULT_TABLE_NAME = "lutaml_store"
+
+        def initialize(config = {})
+          super
+          begin
+            require "sqlite3"
+          rescue LoadError
+            raise ConfigurationError,
+                  "sqlite3 gem is required for the SQLite adapter. Add it to your Gemfile."
+          end
+          @db_path = @config[:path] || raise(ConfigurationError, "SQLite adapter requires :path config")
+          @table_name = @config[:table_name] || DEFAULT_TABLE_NAME
+          @timeout = @config[:timeout] || 30_000
+
+          setup_database
+        end
+
+        def get(key)
+          result = nil
+          execute_query("SELECT value FROM #{@table_name} WHERE key = ?", [key]) do |row|
+            value = row[0]
+            begin
+              result = JSON.parse(value)
+            rescue JSON::ParserError
+              result = value
+            end
+          end
+          result
+        end
+
+        def set(key, value)
+          serialized_value = value.is_a?(String) ? value : JSON.generate(value)
+
+          execute_statement(
+            "INSERT OR REPLACE INTO #{@table_name} (key, value, updated_at) VALUES (?, ?, ?)",
+            [key, serialized_value, Time.now.to_f]
+          )
+          value
+        end
+
+        def delete(key)
+          value = get(key)
+          return nil unless value
+
+          execute_statement("DELETE FROM #{@table_name} WHERE key = ?", [key])
+          value
+        end
+
+        def exists?(key)
+          execute_query("SELECT 1 FROM #{@table_name} WHERE key = ? LIMIT 1", [key]) do |_row|
+            return true
+          end
+          false
+        end
+
+        def all
+          result = {}
+          execute_query("SELECT key, value FROM #{@table_name}") do |row|
+            result[row[0]] = row[1]
+          end
+          result
+        end
+
+        def clear
+          count = size
+          execute_statement("DELETE FROM #{@table_name}")
+          count
+        end
+
+        def size
+          execute_query("SELECT COUNT(*) FROM #{@table_name}") do |row|
+            return row[0]
+          end
+          0
+        end
+
+        def keys
+          result = []
+          execute_query("SELECT key FROM #{@table_name}") do |row|
+            result << row[0]
+          end
+          result
+        end
+
+        def close
+          @db&.close
+          @db = nil
+        end
+
+        def stats
+          super.merge(
+            db_path: @db_path,
+            table_name: @table_name,
+            database_size: calculate_database_size,
+            schema_version: get_schema_version
+          )
+        end
+
+        def bulk_set(key_value_pairs)
+          @db.transaction do
+            key_value_pairs.each do |key, value|
+              serialized_value = value.is_a?(String) ? value : JSON.generate(value)
+              execute_statement(
+                "INSERT OR REPLACE INTO #{@table_name} (key, value, updated_at) VALUES (?, ?, ?)",
+                [key, serialized_value, Time.now.to_f]
+              )
+            end
+          end
+        end
+
+        def bulk_delete(keys)
+          result = {}
+          @db.transaction do
+            keys.each do |key|
+              value = get(key)
+              if value
+                execute_statement("DELETE FROM #{@table_name} WHERE key = ?", [key])
+                result[key] = value
+              else
+                result[key] = nil
+              end
+            end
+          end
+          result
+        end
+
+        private
+
+        def setup_database
+          @db = SQLite3::Database.new(@db_path)
+          @db.busy_timeout = @timeout
+
+          @db.execute("PRAGMA journal_mode=WAL")
+          @db.execute("PRAGMA synchronous=NORMAL")
+          @db.execute("PRAGMA cache_size=10000")
+          @db.execute("PRAGMA temp_store=memory")
+
+          create_table_if_not_exists
+          create_indexes
+        end
+
+        def create_table_if_not_exists
+          @db.execute(<<~SQL)
+            CREATE TABLE IF NOT EXISTS #{@table_name} (
+              key TEXT PRIMARY KEY,
+              value BLOB NOT NULL,
+              updated_at REAL NOT NULL DEFAULT (julianday('now'))
+            )
+          SQL
+        end
+
+        def create_indexes
+          @db.execute("CREATE INDEX IF NOT EXISTS idx_#{@table_name}_updated_at ON #{@table_name} (updated_at)")
+        end
+
+        def execute_query(sql, params = [])
+          @db.execute(sql, params) do |row|
+            yield row if block_given?
+          end
+        rescue SQLite3::Exception => e
+          raise BackendError, "SQLite query failed: #{e.message}"
+        end
+
+        def execute_statement(sql, params = [])
+          @db.execute(sql, params)
+        rescue SQLite3::Exception => e
+          raise BackendError, "SQLite statement failed: #{e.message}"
+        end
+
+        def calculate_database_size
+          return 0 unless File.exist?(@db_path)
+
+          File.size(@db_path)
+        end
+
+        def get_schema_version
+          execute_query("PRAGMA user_version") do |row|
+            return row[0]
+          end
+          0
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/adapter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    module Adapter
+      autoload :Base, "lutaml/store/adapter/base"
+      autoload :Memory, "lutaml/store/adapter/memory"
+      autoload :FileSystem, "lutaml/store/adapter/filesystem"
+      autoload :Sqlite, "lutaml/store/adapter/sqlite"
+    end
+  end
+end