syntropy 0.41.0 → 0.43.0

data/lib/syntropy/storage/kv_store.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'syntropy/storage/store'
-
-module Syntropy
-  module Storage
-    # The KVStore class implements an SQLite-backed key-value store
-    class KVStore < Store
-      attr_reader :q_get, :q_set
-
-      def self.apply_schema(db, table_name)
-        db.execute <<~SQL
-          create table if not exists #{table_name} (key text primary key, value, expires float);
-          create index if not exists idx_#{table_name}_expires on #{table_name} (expires) where expires is not null;
-        SQL
-      end
-
-      def initialize(connection_pool, table_name)
-        super(connection_pool)
-        @table_name = table_name
-
-        setup_queries
-      end
-
-      def get(db, key)
-        db[@q_get].bind(key).next
-      end
-
-      def set(db, key, value)
-        db[@q_set].execute(key, value)
-      end
-
-      def setex(db, key, value, ttl)
-        db[@q_setex].execute(key, value, ttl ? Time.now.to_f + ttl : nil)
-      end
-
-      def sweep(db)
-        db[@q_sweep].execute(Time.now.to_f)
-      end
-
-      private
-
-      def setup_queries
-        @q_get = Storage.prepare_splat <<~SQL
-          select value from #{@table_name}
-          where key = ?
-        SQL
-
-        @q_set = Storage.prepare <<~SQL
-          insert into #{@table_name} (key, value)
-          values($1, $2)
-          on conflict (key) do update set value = $2, expires = null
-        SQL
-
-        @q_setex = Storage.prepare <<~SQL
-          insert into #{@table_name} (key, value, expires)
-          values($1, $2, $3)
-          on conflict (key) do update set value = $2, expires = $3
-        SQL
-
-        @q_sweep = Storage.prepare <<~SQL
-          delete from #{@table_name}
-          where expires < ?
-        SQL
-      end
-    end
-  end
-end

data/lib/syntropy/storage/prepared_query.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'extralite'
-
-module Syntropy
-  module Storage
-    class << self
-      def prepare(sql)
-        PreparedQuery.new(sql)
-      end
-
-      def prepare_splat(sql)
-        PreparedQuery.new(sql, :prepare_splat)
-      end
-    end
-
-    # Represents information about a prepared query
-    class PreparedQuery
-      attr_reader :sql, :mode
-
-      def initialize(sql, mode = :prepare)
-        @sql = sql
-        @mode = mode
-      end
-    end
-
-    # Extensions for Extralite::Database
-    module ExtraliteDatabaseExtensions
-      def [](pq)
-        (@prepared_queries ||= {})[pq] ||= send(pq.mode, pq.sql)
-      end
-    end
-
-    ::Extralite::Database.include(ExtraliteDatabaseExtensions)
-  end
-end

data/lib/syntropy/storage/schema.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Syntropy
-  module Storage
-    class Schema
-      def initialize(module_loader: nil, schema_root: '_schema', &)
-        @migrations = {}
-        @module_loader = module_loader
-        @schema_root = schema_root
-        load_schema_from_modules if @module_loader
-        run_schema_block(&) if block_given?
-      end
-
-      def apply(connection_pool)
-        execute_migrations(connection_pool)
-      end
-
-      def current_version(connection_pool)
-        connection_pool.with_db do |db|
-          get_schema_version(db)
-        end
-      end
-
-      private
-
-      def load_schema_from_modules
-        modules = @module_loader.list(@schema_root)
-        modules.each do |name|
-          @migrations[File.basename(name)] = @module_loader.load(name)
-        end
-      end
-
-      class SchemaBlockRunner
-        def initialize(migrations, &)
-          @migrations = migrations
-          instance_eval(&)
-        end
-
-        def initial(&block)
-          @migrations['0000'] = block
-        end
-
-        def version(key, &block)
-          @migrations[key] = block
-        end
-      end
-
-      def run_schema_block(&)
-        SchemaBlockRunner.new(@migrations, &)
-      end
-
-      def execute_migrations(connection_pool)
-        connection_pool.with_db do |db|
-          current_version = get_schema_version(db)
-          migrations_keys = @migrations.keys.sort
-          migrations_keys.select! { it > current_version } if current_version
-
-          migrations_keys.each do |key|
-            db.transaction do
-              @migrations[key].(db)
-              set_schema_version(db, key)
-              current_version = key
-            end
-          end
-
-          current_version
-        end
-      end
-
-      def get_schema_version(db)
-        db.execute <<~SQL
-          create table if not exists __syntropy_schema__(
-            k text primary key,
-            v text
-          );
-        SQL
-        db.query_single_splat <<~SQL
-          select v from __syntropy_schema__
-          where k = 'version'
-        SQL
-      end
-
-      def set_schema_version(db, version)
-        db.execute <<~SQL, version
-          insert into __syntropy_schema__ (k, v)
-          values ('version', $1)
-          on conflict(k) do update set v = $1
-        SQL
-      end
-    end
-  end
-end

data/lib/syntropy/storage/store.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Syntropy
-  module Storage
-    # The Store class represents a data store based on one or more tables, and
-    # connected to a database connection pool.
-    class Store
-      def initialize(connection_pool)
-        @connection_pool = connection_pool
-      end
-
-      def query(sql, *, **)
-        @connection_pool.with_db { it.query(sql, *, **) }
-      end
-
-      def query_single_row(sql, *, **)
-        @connection_pool.with_db { it.query_single(sql, *, **) }
-      end
-
-      def query_single_value(sql, *, **)
-        @connection_pool.with_db { it.query_single_splat(sql, *, **) }
-      end
-
-      def execute(sql, *, **)
-        @connection_pool.with_db { it.execute(sql, *, **) }
-      end
-
-      def transaction(&)
-        @connection_pool.with_db(&)
-      end
-    end
-  end
-end

data/test/test_store.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class StoreTest < Minitest::Test
-  def setup
-    @machine = UM.new
-    @fn = "/tmp/#{rand(100000)}.db"
-    FileUtils.rm(@fn) rescue nil
-    @cp = Syntropy::Storage::ConnectionPool.new(@machine, @fn, 4)
-  end
-
-  def teardown
-    @cp.close
-  end
-
-  def test_db_store
-    store = Syntropy::Storage::Store.new(@cp)
-
-    assert_equal [{a: 42}], store.query("select ? as a", 42)
-    assert_equal({a: 42}, store.query_single_row("select ? as a", 42))
-    assert_equal 42, store.query_single_value("select ?", 42)
-  end
-end