ask-session 0.1.0

data/lib/ask/session/store.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Ask
+  module Session
+    class Store
+      def initialize
+        @sessions = {}
+        @events = {}
+        @mutex = Mutex.new
+      end
+
+      def create(id: nil, status: :active, metadata: {}, created_at: nil)
+        record = Record.create(id: id, status: status, metadata: metadata, created_at: created_at)
+        @mutex.synchronize do
+          if @sessions.key?(record.id)
+            raise DuplicateSessionError, "Session already exists: #{record.id}"
+          end
+          @sessions[record.id] = record
+          @events[record.id] = []
+        end
+        record
+      end
+
+      def load(id)
+        @mutex.synchronize { @sessions[id] }
+      end
+
+      def load!(id)
+        load(id) || raise(NotFoundError, "Session not found: #{id}")
+      end
+
+      def list
+        @mutex.synchronize { @sessions.values.dup }
+      end
+
+      def append_event(event, expected_sequence:)
+        @mutex.synchronize do
+          session_events = @events[event.session_id]
+          raise NotFoundError, "Session not found: #{event.session_id}" unless session_events
+
+          current_seq = session_events.size
+          unless current_seq == expected_sequence
+            raise ConcurrencyError,
+              "Expected sequence #{expected_sequence} but got #{current_seq} for session #{event.session_id}"
+          end
+
+          unless event.seq == current_seq + 1
+            raise ConcurrencyError,
+              "Event seq #{event.seq} does not match expected next sequence #{current_seq + 1} for session #{event.session_id}"
+          end
+
+          session_events << event
+        end
+        event
+      end
+
+      def state(session_id)
+        State.reduce(session_id, events(session_id))
+      end
+
+      def events_after(session_id, after_seq:)
+        @mutex.synchronize do
+          session_events = @events[session_id]
+          raise NotFoundError, "Session not found: #{session_id}" unless session_events
+
+          session_events.select { |e| e.seq > after_seq }.freeze
+        end
+      end
+
+      def current_sequence(session_id)
+        @mutex.synchronize do
+          session_events = @events[session_id]
+          raise NotFoundError, "Session not found: #{session_id}" unless session_events
+
+          session_events.size
+        end
+      end
+
+      def events(session_id)
+        @mutex.synchronize do
+          session_events = @events[session_id]
+          raise NotFoundError, "Session not found: #{session_id}" unless session_events
+
+          session_events.dup.freeze
+        end
+      end
+
+      def export(session_id = nil)
+        @mutex.synchronize do
+          if session_id
+            record = @sessions[session_id]
+            raise NotFoundError, "Session not found: #{session_id}" unless record
+
+            session_events = @events[session_id] || []
+            {
+              sessions: [record.to_h],
+              events: session_events.map(&:to_h)
+            }
+          else
+            {
+              sessions: @sessions.values.map(&:to_h),
+              events: @events.values.flatten.map(&:to_h)
+            }
+          end
+        end
+      end
+
+      def import(data)
+        sessions = data[:sessions] || data["sessions"] || []
+        events = data[:events] || data["events"] || []
+
+        @mutex.synchronize do
+          pending_sessions = {}
+          pending_events = {}
+
+          sessions.each do |s|
+            id = s[:id] || s["id"]
+            raise SerializationError, "Session record missing id" unless id && !id.to_s.empty?
+            raise DuplicateSessionError, "Session already exists: #{id}" if @sessions.key?(id)
+            raise DuplicateSessionError, "Duplicate session in import data: #{id}" if pending_sessions.key?(id)
+
+            record = Record.from_h(s)
+            pending_sessions[record.id] = record
+            pending_events[record.id] = []
+          end
+
+          events.each do |e|
+            session_id = e[:session_id] || e["session_id"]
+            unless pending_events.key?(session_id) || @events.key?(session_id)
+              raise NotFoundError, "Session not found: #{session_id}"
+            end
+
+            event = Event.from_h(e)
+            target = pending_events.key?(session_id) ? pending_events : @events
+            session_events = target[session_id]
+            expected_seq = session_events.size
+
+            unless event.seq == expected_seq + 1
+              raise ConcurrencyError,
+                "Expected sequence #{expected_seq + 1} but got #{event.seq} for session #{session_id}"
+            end
+
+            session_events << event
+          end
+
+          pending_sessions.each do |id, record|
+            @sessions[id] = record
+            @events[id] = pending_events[id]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ask/session/subscription.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module Ask
+  module Session
+    class Subscription
+      SENTINEL = Object.new
+
+      attr_reader :id, :session_id
+
+      def initialize(id:, session_id:)
+        @id = id
+        @session_id = session_id
+        @queue = Queue.new
+        @closed = false
+        @mutex = Mutex.new
+      end
+
+      def closed?
+        @mutex.synchronize { @closed }
+      end
+
+      def close
+        @mutex.synchronize { @closed = true }
+        @queue.push(SENTINEL)
+      end
+
+      def next(timeout: nil)
+        return nil if closed?
+
+        if timeout
+          val = Timeout.timeout(timeout) { @queue.pop }
+          val.equal?(SENTINEL) ? nil : val
+        else
+          val = @queue.pop
+          val.equal?(SENTINEL) ? nil : val
+        end
+      rescue Timeout::Error
+        nil
+      end
+
+      alias_method :wait, :next
+
+      def each
+        while (event = self.next)
+          yield event
+        end
+      end
+
+      def enqueue(event)
+        @queue.push(event) unless closed?
+      end
+    end
+  end
+end

data/lib/ask/session/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ask
+  module Session
+    VERSION = "0.1.0"
+  end
+end

data/lib/ask/session.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "securerandom"
+
+require_relative "session/version"
+require_relative "session/record"
+require_relative "session/event"
+require_relative "session/store"
+require_relative "session/provider_store"
+require_relative "session/state"
+require_relative "session/codec"
+require_relative "session/subscription"
+require_relative "session/host"
+require_relative "session/sink"
+
+module Ask
+  module Session
+    class Error < StandardError; end
+    class ConcurrencyError < Error; end
+    class NotFoundError < Error; end
+    class DuplicateSessionError < Error; end
+    class SerializationError < Error; end
+    class InvalidTransitionError < Error; end
+    class SessionMismatchError < Error; end
+  end
+end

data/lib/ask-session.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "ask/session"

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: ask-session
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kaka Ruto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Provides immutable session records, event envelopes, an in-memory store
+  with concurrency guardrails, a durable provider-backed store for restart-safe sessions,
+  a replayable host with subscriptions, a runtime tool-lifecycle sink, and a state
+  reducer that reconstructs session snapshots from event history.
+email:
+- kaka@myrrlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/ask-session.rb
+- lib/ask/session.rb
+- lib/ask/session/codec.rb
+- lib/ask/session/event.rb
+- lib/ask/session/host.rb
+- lib/ask/session/provider_store.rb
+- lib/ask/session/record.rb
+- lib/ask/session/sink.rb
+- lib/ask/session/state.rb
+- lib/ask/session/store.rb
+- lib/ask/session/subscription.rb
+- lib/ask/session/version.rb
+homepage: https://github.com/ask-rb/ask-session
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ask-rb/ask-session
+  source_code_uri: https://github.com/ask-rb/ask-session
+  changelog_uri: https://github.com/ask-rb/ask-session/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.18
+specification_version: 4
+summary: Event-sourced session state for the ask-rb ecosystem.
+test_files: []