ask-state-providers 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18cfafbe7783b55543313b0708ed885275c8bd954a63cf152251dbfb465fde49
-  data.tar.gz: 60c56b1e649b86c893e8af07b446c3a022afb4d4b56d0419d74465b402ca36be
+  metadata.gz: 550bf5d05277f2107b94f57c09ec2189184af18ceb820a1538b07a1ed5b3981f
+  data.tar.gz: 3bb373e4312de695a6e71d76b3557e5933cc97edeae170cf3ff38c1247010c47
 SHA512:
-  metadata.gz: 38f53d279574b58eddf256975467c8bb30047060e5e994093f38ced15feb61c7e02e34c9023b7ec02a669e1b94142ca9a26cdd9d27938c5f5d51aee5d61e0715
-  data.tar.gz: be37ac572c9081ab10bf85f878a6285fd04b3522c731ae0bc28d472c855584e567d791b21953f6e013df1cbf5ebe3c48146ba91aded39c4aa08e2e2c80456f1e
+  metadata.gz: 9641c185a5128f8129e28094b8b7c605a5abc458f32685abdb7f121b18991c2eed62e61e37ce29d254e03310c0628f6bb3e98575877887e55e0cd8f0ea55843a
+  data.tar.gz: 823cd11970169cf011575f498f1c182a6ed1c76053ccf6cc00f28e840f68ab2dd80b84af9ae19dba474c6a250c284ea97ada092ed2d816979ad242c1457499f3

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.0] — 2026-07-28
+
+### Added
+
+- **`Ask::State::Memory`** — in-memory state backend, moved from `ask-core`. Same class name, same API. Requires `require "ask-state-providers"` instead of `require "ask"`.
+
+  ```ruby
+  require "ask-state-providers"
+  store = Ask::State::Memory.new
+  ```
+
 ## [0.2.0] — 2026-07-23
 
 ### Changed

data/lib/ask/state/memory.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Ask
+  module State
+    # In-process state backend backed by a Hash.
+    # All operations are thread-safe via a Mutex.
+    # Data is not persisted — lost on process exit.
+    #
+    # Available automatically when using +ask-state-providers+.
+    # For lightweight use without the full providers gem, see
+    # {Ask::State::Adapter} for the abstract contract.
+    class Memory < Adapter
+      def initialize
+        @data = {}
+        @locks = {}
+        @queues = {}
+        @lists = {}
+        @mutex = Mutex.new
+      end
+
+      # -- key-value --
+
+      def get(key)
+        @mutex.synchronize do
+          expiry = @data[key]&.dig(:expires_at)
+          return nil if expiry && Time.now >= expiry
+
+          @data[key]&.dig(:value)
+        end
+      end
+
+      def set(key, value, ttl: nil)
+        @mutex.synchronize do
+          @data[key] = {
+            value: value,
+            expires_at: ttl ? Time.now + ttl : nil
+          }
+        end
+      end
+
+      def delete(key)
+        @mutex.synchronize { @data.delete(key) }
+      end
+
+      def set_if_not_exists(key, value, ttl: nil)
+        @mutex.synchronize do
+          if @data.key?(key)
+            expiry = @data[key][:expires_at]
+            return false if expiry.nil? || Time.now < expiry
+            @data.delete(key)
+          end
+
+          @data[key] = {
+            value: value,
+            expires_at: ttl ? Time.now + ttl : nil
+          }
+          true
+        end
+      end
+
+      def clear
+        @mutex.synchronize do
+          @data.clear
+          @locks.clear
+          @queues.clear
+          @lists.clear
+        end
+      end
+
+      def exists?(key)
+        @mutex.synchronize do
+          expiry = @data[key]&.dig(:expires_at)
+          return false if expiry && Time.now >= expiry
+          @data.key?(key)
+        end
+      end
+
+      def keys(pattern: nil)
+        @mutex.synchronize do
+          active = @data.select do |_k, v|
+            expiry = v[:expires_at]
+            expiry.nil? || Time.now < expiry
+          end
+
+          keys = active.keys.map(&:to_s)
+          return keys unless pattern
+
+          regex = self.class.glob_to_regex(pattern)
+          keys.select { |k| k.match?(regex) }
+        end
+      end
+
+      # -- locking --
+
+      def acquire_lock(key, ttl: 10)
+        @mutex.synchronize do
+          existing = @locks[key]
+          if existing.nil? || existing.expired?
+            lock = Lock.new(
+              id: key,
+              token: SecureRandom.hex(16),
+              expires_at: Time.now + ttl
+            )
+            @locks[key] = lock
+            lock
+          end
+        end
+      end
+
+      def release_lock(key, lock)
+        @mutex.synchronize do
+          current = @locks[key]
+          if current && current.token == lock.token && !current.expired?
+            @locks.delete(key)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # -- queues --
+
+      def enqueue(queue, value)
+        @mutex.synchronize do
+          @queues[queue] ||= []
+          entry = QueueEntry.new(
+            id: SecureRandom.uuid,
+            value: value,
+            enqueued_at: Time.now
+          )
+          @queues[queue] << entry
+          entry
+        end
+      end
+
+      def dequeue(queue)
+        @mutex.synchronize do
+          q = @queues[queue]
+          return nil unless q&.any?
+          q.shift
+        end
+      end
+
+      def queue_depth(queue)
+        @mutex.synchronize do
+          (@queues[queue] || []).length
+        end
+      end
+
+      # -- lists --
+
+      def list_append(key, value, max_length: nil)
+        @mutex.synchronize do
+          @lists[key] ||= []
+          @lists[key] << value
+          @lists[key].shift if max_length && @lists[key].length > max_length
+        end
+      end
+
+      def list_range(key, start = 0, stop = -1)
+        @mutex.synchronize do
+          list = @lists[key] || []
+          return list if start == 0 && stop == -1
+          stop = list.length - 1 if stop == -1 || stop >= list.length
+          return [] if start > stop
+          list[start..stop] || []
+        end
+      end
+
+      def list_remove(key, value)
+        @mutex.synchronize do
+          list = @lists[key]
+          return 0 unless list
+          before = list.length
+          list.delete(value)
+          before - list.length
+        end
+      end
+
+      # -- lifecycle --
+
+      def close
+        @mutex.synchronize do
+          @data.clear
+          @locks.clear
+          @queues.clear
+          @lists.clear
+        end
+      end
+
+      private
+
+      def glob_to_regex(pattern)
+        self.class.glob_to_regex(pattern)
+      end
+    end
+  end
+end

data/lib/ask/state/providers/mysql.rb

@@ -114,6 +114,36 @@ module Ask
 
         def clear
           @client.query("DELETE FROM state_store")
+          @client.query("DELETE FROM locks")
+          @client.query("DELETE FROM queues")
+          @client.query("DELETE FROM lists")
+        end
+
+        def exists?(key)
+          result = @client.prepare(<<~SQL).execute(key, Time.now.utc.strftime("%Y-%m-%d %H:%M:%S.%3N"))
+            SELECT 1 FROM state_store
+            WHERE `key` = ? AND (expires_at IS NULL OR expires_at > ?)
+          SQL
+          result.count > 0
+        end
+
+        def keys(pattern: nil)
+          sql, params = if pattern
+            like = self.class.glob_to_like(pattern)
+            [<<~SQL, [like]]
+              SELECT `key` FROM state_store
+              WHERE `key` LIKE ? AND (expires_at IS NULL OR expires_at > ?)
+            SQL
+          else
+            [<<~SQL, []]
+              SELECT `key` FROM state_store
+              WHERE (expires_at IS NULL OR expires_at > ?)
+            SQL
+          end
+          now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S.%3N")
+          stmt = @client.prepare(sql)
+          rows = stmt.execute(*params, now)
+          rows.map { |r| r["key"] }
         end
 
         # -- distributed locking --

data/lib/ask/state/providers/postgres.rb

@@ -116,7 +116,40 @@ module Ask
         end
 
         def clear
-          @pool.with { |conn| conn.exec("DELETE FROM state_store") }
+          @pool.with do |conn|
+            conn.exec("DELETE FROM state_store")
+            conn.exec("DELETE FROM locks")
+            conn.exec("DELETE FROM queues")
+            conn.exec("DELETE FROM lists")
+          end
+        end
+
+        def exists?(key)
+          @pool.with do |conn|
+            result = conn.exec_params(<<~SQL, [key, Time.now.utc])
+              SELECT 1 FROM state_store
+              WHERE key = $1 AND (expires_at IS NULL OR expires_at > $2)
+            SQL
+            result.ntuples > 0
+          end
+        end
+
+        def keys(pattern: nil)
+          @pool.with do |conn|
+            sql, params = if pattern
+              like = self.class.glob_to_like(pattern)
+              [<<~SQL, [like, Time.now.utc]]
+                SELECT key FROM state_store
+                WHERE key LIKE $1 AND (expires_at IS NULL OR expires_at > $2)
+              SQL
+            else
+              [<<~SQL, [Time.now.utc]]
+                SELECT key FROM state_store
+                WHERE (expires_at IS NULL OR expires_at > $1)
+              SQL
+            end
+            conn.exec_params(sql, params).map { |r| r["key"] }
+          end
         end
 
         # -- distributed locking --

data/lib/ask/state/providers/redis.rb

@@ -58,6 +58,17 @@ module Ask
           @redis.call("DEL", *keys) if keys.any?
         end
 
+        def exists?(key)
+          @redis.call("EXISTS", prefixed(key)) == 1
+        end
+
+        def keys(pattern: nil)
+          glob = pattern ? "#{NAMESPACE}:#{pattern}" : "#{NAMESPACE}:*"
+          raw = @redis.call("KEYS", glob)
+          prefix_len = NAMESPACE.length + 1
+          raw.map { |k| k[prefix_len..] }
+        end
+
         # -- distributed locking --
 
         def acquire_lock(key, ttl: 10)
@@ -117,7 +128,6 @@ module Ask
           @redis.call("RPUSH", prefixed("list:#{key}"), JSON.generate(value))
           return unless max_length
 
-          # LTRIM keeps only the specified range (negative indices, so -max_length means keep newest max_length)
           @redis.call("LTRIM", prefixed("list:#{key}"), -max_length, -1)
         end
 

data/lib/ask/state/providers/sqlite.rb

@@ -13,6 +13,8 @@ module Ask
       # key-value storage, distributed locking, message queues, and ordered
       # lists. Uses the +sqlite3+ gem.
       #
+      # Thread-safe via internal Mutex.
+      #
       # @example
       #   store = Ask::State::Providers::SQLite.new(path: "sessions.db")
       #   store.set("key", { hello: "world" })
@@ -23,6 +25,7 @@ module Ask
         def initialize(path: "sessions.db", **pragmas)
           require "sqlite3"
 
+          @mutex = Mutex.new
           @db = SQLite3::Database.new(path)
           @db.results_as_hash = true
           @db.busy_timeout = 5000
@@ -44,181 +47,235 @@ module Ask
         # -- key-value --
 
         def get(key)
-          row = @db.get_first_row(<<~SQL, [key, Time.now.to_f])
-            SELECT value FROM state_store
-            WHERE key = ? AND (expires_at IS NULL OR expires_at > ?)
-          SQL
-          row ? JSON.parse(row["value"]) : nil
+          @mutex.synchronize do
+            row = @db.get_first_row(<<~SQL, [key, Time.now.to_f])
+              SELECT value FROM state_store
+              WHERE key = ? AND (expires_at IS NULL OR expires_at > ?)
+            SQL
+            row ? JSON.parse(row["value"]) : nil
+          end
         end
 
         def set(key, value, ttl: nil)
-          @db.execute(<<~SQL, [key, JSON.generate(value), ttl ? Time.now.to_f + ttl : nil])
-            INSERT OR REPLACE INTO state_store (key, value, expires_at)
-            VALUES (?, ?, ?)
-          SQL
+          @mutex.synchronize do
+            @db.execute(<<~SQL, [key, JSON.generate(value), ttl ? Time.now.to_f + ttl : nil])
+              INSERT OR REPLACE INTO state_store (key, value, expires_at)
+              VALUES (?, ?, ?)
+            SQL
+          end
         end
 
         def delete(key)
-          @db.execute("DELETE FROM state_store WHERE key = ?", [key])
+          @mutex.synchronize do
+            @db.execute("DELETE FROM state_store WHERE key = ?", [key])
+          end
         end
 
         def set_if_not_exists(key, value, ttl: nil)
-          now = Time.now.to_f
-          expires = ttl ? now + ttl : nil
+          @mutex.synchronize do
+            now = Time.now.to_f
+            expires = ttl ? now + ttl : nil
 
-          @db.transaction do
             row = @db.get_first_row(
               "SELECT 1 FROM state_store WHERE key = ? AND (expires_at IS NULL OR expires_at > ?)",
               [key, now]
             )
-            next false if row
+            return false if row
 
+            # Key doesn't exist or is expired — delete any leftovers, then insert
             @db.execute("DELETE FROM state_store WHERE key = ?", [key])
             @db.execute(<<~SQL, [key, JSON.generate(value), expires])
               INSERT INTO state_store (key, value, expires_at)
               VALUES (?, ?, ?)
             SQL
-            next true
+            true
           end
         end
 
         def clear
-          @db.execute("DELETE FROM state_store")
+          @mutex.synchronize do
+            @db.execute("DELETE FROM state_store")
+            @db.execute("DELETE FROM locks")
+            @db.execute("DELETE FROM queues")
+            @db.execute("DELETE FROM lists")
+          end
+        end
+
+        def exists?(key)
+          @mutex.synchronize do
+            row = @db.get_first_row(<<~SQL, [key, Time.now.to_f])
+              SELECT 1 FROM state_store
+              WHERE key = ? AND (expires_at IS NULL OR expires_at > ?)
+            SQL
+            !row.nil?
+          end
+        end
+
+        def keys(pattern: nil)
+          @mutex.synchronize do
+            now = Time.now.to_f
+            sql, params = if pattern
+              like = self.class.glob_to_like(pattern)
+              [<<~SQL, [like, now]]
+                SELECT key FROM state_store
+                WHERE key LIKE ? AND (expires_at IS NULL OR expires_at > ?)
+              SQL
+            else
+              [<<~SQL, [now]]
+                SELECT key FROM state_store
+                WHERE (expires_at IS NULL OR expires_at > ?)
+              SQL
+            end
+            @db.execute(sql, params).map { |r| r["key"] }
+          end
         end
 
         # -- distributed locking --
 
         def acquire_lock(key, ttl: 10)
-          now = Time.now.to_f
-          expires_at_time = Time.now + ttl
-          token = SecureRandom.hex(16)
+          @mutex.synchronize do
+            now = Time.now.to_f
+            expires_at_time = Time.now + ttl
+            token = SecureRandom.hex(16)
 
-          acquired = @db.transaction do
             row = @db.get_first_row(
               "SELECT 1 FROM locks WHERE key = ? AND expires_at > ?",
               [key, now]
             )
-            next false if row
+            return nil if row
 
             @db.execute("DELETE FROM locks WHERE key = ?", [key])
             @db.execute(<<~SQL, [key, expires_at_time.to_f, token])
               INSERT INTO locks (key, expires_at, token)
               VALUES (?, ?, ?)
             SQL
-            next true
-          end
 
-          acquired ? Lock.new(id: key, token: token, expires_at: expires_at_time) : nil
+            Lock.new(id: key, token: token, expires_at: expires_at_time)
+          end
         end
 
         def release_lock(key, lock)
-          @db.execute(
-            "DELETE FROM locks WHERE key = ? AND token = ?",
-            [key, lock.token]
-          )
-          @db.changes > 0
+          @mutex.synchronize do
+            @db.execute(
+              "DELETE FROM locks WHERE key = ? AND token = ?",
+              [key, lock.token]
+            )
+            @db.changes > 0
+          end
         end
 
         # -- message queues --
 
         def enqueue(queue, value)
-          @db.execute(<<~SQL, [queue, JSON.generate(value), Time.now.iso8601])
-            INSERT INTO queues (queue_name, value, enqueued_at)
-            VALUES (?, ?, ?)
-          SQL
-          id = @db.last_insert_row_id
-          QueueEntry.new(id: id.to_s, value: value, enqueued_at: Time.now)
+          @mutex.synchronize do
+            @db.execute(<<~SQL, [queue, JSON.generate(value), Time.now.iso8601])
+              INSERT INTO queues (queue_name, value, enqueued_at)
+              VALUES (?, ?, ?)
+            SQL
+            id = @db.last_insert_row_id
+            QueueEntry.new(id: id.to_s, value: value, enqueued_at: Time.now)
+          end
         end
 
         def dequeue(queue)
-          row = @db.get_first_row(<<~SQL, [queue])
-            DELETE FROM queues
-            WHERE id = (
-              SELECT id FROM queues
-              WHERE queue_name = ?
-              ORDER BY id ASC
-              LIMIT 1
-            )
-            RETURNING id, value, enqueued_at
-          SQL
-          return nil unless row
+          @mutex.synchronize do
+            row = @db.get_first_row(<<~SQL, [queue])
+              DELETE FROM queues
+              WHERE id = (
+                SELECT id FROM queues
+                WHERE queue_name = ?
+                ORDER BY id ASC
+                LIMIT 1
+              )
+              RETURNING id, value, enqueued_at
+            SQL
+            return nil unless row
 
-          QueueEntry.new(
-            id: row["id"].to_s,
-            value: JSON.parse(row["value"]),
-            enqueued_at: Time.parse(row["enqueued_at"])
-          )
+            QueueEntry.new(
+              id: row["id"].to_s,
+              value: JSON.parse(row["value"]),
+              enqueued_at: Time.parse(row["enqueued_at"])
+            )
+          end
         end
 
         def queue_depth(queue)
-          row = @db.get_first_row(
-            "SELECT COUNT(*) AS cnt FROM queues WHERE queue_name = ?", [queue]
-          )
-          row["cnt"]
+          @mutex.synchronize do
+            row = @db.get_first_row(
+              "SELECT COUNT(*) AS cnt FROM queues WHERE queue_name = ?", [queue]
+            )
+            row["cnt"]
+          end
         end
 
         # -- ordered lists --
 
         def list_append(key, value, max_length: nil)
-          serialized = JSON.generate(value)
+          @mutex.synchronize do
+            serialized = JSON.generate(value)
 
-          @db.execute(<<~SQL, [key, serialized])
-            INSERT INTO lists (list_key, value)
-            VALUES (?, ?)
-          SQL
+            @db.execute(<<~SQL, [key, serialized])
+              INSERT INTO lists (list_key, value)
+              VALUES (?, ?)
+            SQL
 
-          return unless max_length
+            return unless max_length
 
-          # Keep only the newest max_length items by deleting those with the
-          # smallest id values beyond the threshold
-          row = @db.get_first_row(<<~SQL, [key, max_length])
-            SELECT MIN(id) AS cutoff FROM (
-              SELECT id FROM lists
-              WHERE list_key = ?
-              ORDER BY id DESC
-              LIMIT ?
-            )
-          SQL
-          return unless row && row["cutoff"]
+            row = @db.get_first_row(<<~SQL, [key, max_length])
+              SELECT MIN(id) AS cutoff FROM (
+                SELECT id FROM lists
+                WHERE list_key = ?
+                ORDER BY id DESC
+                LIMIT ?
+              )
+            SQL
+            return unless row && row["cutoff"]
 
-          @db.execute(<<~SQL, [key, row["cutoff"]])
-            DELETE FROM lists WHERE list_key = ? AND id < ?
-          SQL
+            @db.execute(<<~SQL, [key, row["cutoff"]])
+              DELETE FROM lists WHERE list_key = ? AND id < ?
+            SQL
+          end
         end
 
         def list_range(key, start = 0, stop = -1)
-          if stop == -1
-            rows = @db.execute(<<~SQL, [key, start])
-              SELECT value FROM lists
-              WHERE list_key = ?
-              ORDER BY id ASC
-              LIMIT -1 OFFSET ?
-            SQL
-          else
-            limit = stop - start + 1
-            rows = @db.execute(<<~SQL, [key, limit, start])
-              SELECT value FROM lists
-              WHERE list_key = ?
-              ORDER BY id ASC
-              LIMIT ? OFFSET ?
-            SQL
+          @mutex.synchronize do
+            rows = if stop == -1
+              @db.execute(<<~SQL, [key, start])
+                SELECT value FROM lists
+                WHERE list_key = ?
+                ORDER BY id ASC
+                LIMIT -1 OFFSET ?
+              SQL
+            else
+              limit = stop - start + 1
+              @db.execute(<<~SQL, [key, limit, start])
+                SELECT value FROM lists
+                WHERE list_key = ?
+                ORDER BY id ASC
+                LIMIT ? OFFSET ?
+              SQL
+            end
+            rows.map { |r| JSON.parse(r["value"]) }
           end
-          rows.map { |r| JSON.parse(r["value"]) }
         end
 
         def list_remove(key, value)
-          serialized = JSON.generate(value)
-          @db.execute(
-            "DELETE FROM lists WHERE list_key = ? AND value = ?",
-            [key, serialized]
-          )
-          @db.changes
+          @mutex.synchronize do
+            serialized = JSON.generate(value)
+            @db.execute(
+              "DELETE FROM lists WHERE list_key = ? AND value = ?",
+              [key, serialized]
+            )
+            @db.changes
+          end
         end
 
         # -- lifecycle --
 
         def close
-          @db.close
+          @mutex.synchronize do
+            @db.close
+          end
         end
 
         private

data/lib/ask/state/providers/version.rb

@@ -3,7 +3,7 @@
 module Ask
   module State
     module Providers
-      VERSION = "0.2.0"
+      VERSION = "0.3.0"
     end
   end
 end

data/lib/ask-state-providers.rb

@@ -3,6 +3,9 @@
 require "ask"
 require "ask/state"
 
+# Load the in-memory state backend (default adapter, previously in ask-core)
+require_relative "ask/state/memory"
+
 module Ask
   module State
     module Providers

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-state-providers
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -79,6 +79,7 @@ files:
 - LICENSE
 - README.md
 - lib/ask-state-providers.rb
+- lib/ask/state/memory.rb
 - lib/ask/state/providers/mysql.rb
 - lib/ask/state/providers/postgres.rb
 - lib/ask/state/providers/redis.rb