shikibu 0.1.0

data/lib/shikibu/storage/sequel_storage.rb

@@ -0,0 +1,883 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'json'
+require 'securerandom'
+
+module Shikibu
+  module Storage
+    # Sequel-based storage implementation
+    class SequelStorage
+      attr_reader :db
+      attr_accessor :notify_enabled
+
+      DEFAULT_LOCK_TIMEOUT = 300 # 5 minutes
+
+      def initialize(database_url, auto_migrate: false)
+        @database_url = database_url
+        @db = Sequel.connect(database_url)
+        @notify_enabled = false
+
+        # Enable extensions based on database type
+        configure_database
+
+        # Apply migrations if requested
+        Migrations.apply(@db) if auto_migrate
+      end
+
+      def close
+        @db.disconnect
+      end
+
+      # ============================================
+      # Transaction Management
+      # ============================================
+
+      def transaction(&)
+        @db.transaction(&)
+      end
+
+      def in_transaction?
+        @db.in_transaction?
+      end
+
+      # ============================================
+      # Workflow Definitions
+      # ============================================
+
+      def save_workflow_definition(workflow_name:, source_hash:, source_code:)
+        if mysql?
+          # MySQL: Use INSERT IGNORE + UPDATE
+          @db[:workflow_definitions].insert_ignore.insert(
+            workflow_name: workflow_name,
+            source_hash: source_hash,
+            source_code: source_code,
+            created_at: current_timestamp
+          )
+        else
+          # PostgreSQL/SQLite: Use ON CONFLICT
+          @db[:workflow_definitions].insert_conflict(
+            target: %i[workflow_name source_hash],
+            update: { source_code: source_code }
+          ).insert(
+            workflow_name: workflow_name,
+            source_hash: source_hash,
+            source_code: source_code,
+            created_at: current_timestamp
+          )
+        end
+      end
+
+      def get_workflow_definition(workflow_name:, source_hash:)
+        @db[:workflow_definitions]
+          .where(workflow_name: workflow_name, source_hash: source_hash)
+          .first
+      end
+
+      # ============================================
+      # Workflow Instances
+      # ============================================
+
+      def create_instance(
+        instance_id:,
+        workflow_name:,
+        source_hash:,
+        owner_service:,
+        input_data:,
+        status: Status::RUNNING
+      )
+        @db[:workflow_instances].insert(
+          instance_id: instance_id,
+          workflow_name: workflow_name,
+          source_hash: source_hash,
+          owner_service: owner_service,
+          framework: FRAMEWORK,
+          status: status,
+          input_data: serialize_json(input_data),
+          started_at: current_timestamp,
+          updated_at: current_timestamp
+        )
+        instance_id
+      end
+
+      def get_instance(instance_id)
+        row = @db[:workflow_instances].where(instance_id: instance_id).first
+        return nil unless row
+
+        deserialize_instance(row)
+      end
+
+      def update_instance_status(instance_id, status, output_data: nil, current_activity_id: nil)
+        updates = {
+          status: status,
+          updated_at: current_timestamp
+        }
+        updates[:output_data] = serialize_json(output_data) if output_data
+        updates[:current_activity_id] = current_activity_id if current_activity_id
+
+        @db[:workflow_instances]
+          .where(instance_id: instance_id)
+          .update(updates)
+      end
+
+      def list_instances(limit: 100, offset: 0, status_filter: nil, workflow_name: nil)
+        query = @db[:workflow_instances].order(Sequel.desc(:updated_at))
+        query = query.where(status: status_filter) if status_filter
+        query = query.where(workflow_name: workflow_name) if workflow_name
+        query = query.limit(limit).offset(offset)
+
+        query.map { |row| deserialize_instance(row) }
+      end
+
+      def find_resumable_workflows(limit: 10)
+        @db[:workflow_instances]
+          .where(status: Status::RUNNING)
+          .where(locked_by: nil)
+          .where(framework: FRAMEWORK)
+          .order(:updated_at)
+          .limit(limit)
+          .select(:instance_id, :workflow_name, :source_hash)
+          .map(&:to_h)
+      end
+
+      def find_stale_locked_workflows(stale_threshold_seconds: 300)
+        threshold = Time.now - stale_threshold_seconds
+        @db[:workflow_instances]
+          .where(status: Status::RUNNING)
+          .where { lock_expires_at < threshold }
+          .where(framework: FRAMEWORK)
+          .select(:instance_id, :workflow_name, :locked_by)
+          .map(&:to_h)
+      end
+
+      # ============================================
+      # Distributed Locking
+      # ============================================
+
+      def try_acquire_lock(instance_id, worker_id, timeout: DEFAULT_LOCK_TIMEOUT)
+        now = Time.now
+        expires_at = now + timeout
+
+        if supports_skip_locked?
+          # PostgreSQL/MySQL: Use SELECT FOR UPDATE SKIP LOCKED
+          # This prevents blocking when another worker holds the lock
+          @db.transaction do
+            row = @db[:workflow_instances]
+                  .where(instance_id: instance_id)
+                  .for_update
+                  .skip_locked
+                  .first
+
+            # Row is locked by another transaction, skip
+            return false unless row
+
+            # Check if lock is available (not locked or expired)
+            return false if row[:locked_by] && row[:lock_expires_at] && row[:lock_expires_at] > now
+
+            @db[:workflow_instances]
+              .where(instance_id: instance_id)
+              .update(
+                locked_by: worker_id,
+                locked_at: now,
+                lock_expires_at: expires_at,
+                lock_timeout_seconds: timeout
+              )
+
+            true
+          end
+        else
+          # SQLite: Use atomic UPDATE (table-level locking)
+          affected = @db[:workflow_instances]
+                     .where(instance_id: instance_id)
+                     .where(
+                       Sequel.|(
+                         { locked_by: nil },
+                         Sequel.lit('lock_expires_at < ?', now)
+                       )
+                     )
+                     .update(
+                       locked_by: worker_id,
+                       locked_at: now,
+                       lock_expires_at: expires_at,
+                       lock_timeout_seconds: timeout
+                     )
+
+          affected.positive?
+        end
+      end
+
+      def release_lock(instance_id, worker_id)
+        @db[:workflow_instances]
+          .where(instance_id: instance_id, locked_by: worker_id)
+          .update(
+            locked_by: nil,
+            locked_at: nil,
+            lock_expires_at: nil,
+            lock_timeout_seconds: nil
+          )
+      end
+
+      def refresh_lock(instance_id, worker_id, timeout: DEFAULT_LOCK_TIMEOUT)
+        now = Time.now
+        expires_at = now + timeout
+
+        affected = @db[:workflow_instances]
+                   .where(instance_id: instance_id, locked_by: worker_id)
+                   .update(
+                     locked_at: now,
+                     lock_expires_at: expires_at
+                   )
+
+        affected.positive?
+      end
+
+      def lock_held_by?(instance_id, worker_id)
+        row = @db[:workflow_instances]
+              .where(instance_id: instance_id)
+              .select(:locked_by, :lock_expires_at)
+              .first
+
+        return false unless row
+        return false if row[:locked_by] != worker_id
+        return false if row[:lock_expires_at] && row[:lock_expires_at] < Time.now
+
+        true
+      end
+
+      # ============================================
+      # Workflow History
+      # ============================================
+
+      def append_history(instance_id:, activity_id:, event_type:, event_data:, data_type: DataType::JSON)
+        if data_type == DataType::BINARY
+          @db[:workflow_history].insert(
+            instance_id: instance_id,
+            activity_id: activity_id,
+            event_type: event_type,
+            data_type: data_type,
+            event_data_binary: Sequel.blob(event_data),
+            created_at: current_timestamp
+          )
+        else
+          @db[:workflow_history].insert(
+            instance_id: instance_id,
+            activity_id: activity_id,
+            event_type: event_type,
+            data_type: data_type,
+            event_data: serialize_json(event_data),
+            created_at: current_timestamp
+          )
+        end
+      rescue Sequel::UniqueConstraintViolation
+        # Activity already recorded (idempotent)
+        nil
+      end
+
+      def get_history(instance_id)
+        @db[:workflow_history]
+          .where(instance_id: instance_id)
+          .order(:id)
+          .map { |row| deserialize_history_event(row) }
+      end
+
+      def archive_history(instance_id)
+        now = current_timestamp
+
+        # Copy to archive
+        @db[:workflow_history_archive].insert(
+          @db[:workflow_history]
+            .where(instance_id: instance_id)
+            .select(
+              :instance_id, :activity_id, :event_type, :data_type,
+              :event_data, :event_data_binary, :created_at,
+              Sequel.lit("'#{now}'").as(:archived_at)
+            )
+        )
+
+        # Delete from main history
+        @db[:workflow_history].where(instance_id: instance_id).delete
+      end
+
+      # ============================================
+      # Compensations
+      # ============================================
+
+      def push_compensation(instance_id:, activity_id:, activity_name:, args:)
+        @db[:workflow_compensations].insert(
+          instance_id: instance_id,
+          activity_id: activity_id,
+          activity_name: activity_name,
+          args: serialize_json(args),
+          created_at: current_timestamp
+        )
+      end
+
+      def get_compensations(instance_id)
+        @db[:workflow_compensations]
+          .where(instance_id: instance_id)
+          .order(Sequel.desc(:created_at))
+          .map do |row|
+            {
+              id: row[:id],
+              instance_id: row[:instance_id],
+              activity_id: row[:activity_id],
+              activity_name: row[:activity_name],
+              args: parse_json(row[:args]),
+              created_at: row[:created_at]
+            }
+          end
+      end
+
+      def clear_compensations(instance_id)
+        @db[:workflow_compensations].where(instance_id: instance_id).delete
+      end
+
+      # ============================================
+      # Timer Subscriptions
+      # ============================================
+
+      def register_timer(instance_id:, timer_id:, expires_at:, activity_id: nil)
+        if mysql?
+          # MySQL: Use INSERT ... ON DUPLICATE KEY UPDATE
+          @db[:workflow_timer_subscriptions].on_duplicate_key_update(
+            expires_at: expires_at,
+            activity_id: activity_id
+          ).insert(
+            instance_id: instance_id,
+            timer_id: timer_id,
+            expires_at: expires_at,
+            activity_id: activity_id,
+            created_at: current_timestamp
+          )
+        else
+          @db[:workflow_timer_subscriptions].insert_conflict(
+            target: %i[instance_id timer_id],
+            update: { expires_at: expires_at, activity_id: activity_id }
+          ).insert(
+            instance_id: instance_id,
+            timer_id: timer_id,
+            expires_at: expires_at,
+            activity_id: activity_id,
+            created_at: current_timestamp
+          )
+        end
+      end
+
+      def find_expired_timers(limit: 100)
+        now = Time.now
+        @db[:workflow_timer_subscriptions]
+          .where { expires_at <= now }
+          .order(:expires_at)
+          .limit(limit)
+          .map(&:to_h)
+      end
+
+      def remove_timer(instance_id:, timer_id:)
+        @db[:workflow_timer_subscriptions]
+          .where(instance_id: instance_id, timer_id: timer_id)
+          .delete
+      end
+
+      # ============================================
+      # Channel Messages
+      # ============================================
+
+      def publish_message(channel:, data:, metadata: nil, data_type: DataType::JSON)
+        message_id = SecureRandom.uuid
+
+        if data_type == DataType::BINARY
+          @db[:channel_messages].insert(
+            channel: channel,
+            message_id: message_id,
+            data_type: data_type,
+            data_binary: Sequel.blob(data),
+            metadata: metadata ? serialize_json(metadata) : nil,
+            published_at: current_timestamp
+          )
+        else
+          @db[:channel_messages].insert(
+            channel: channel,
+            message_id: message_id,
+            data_type: data_type,
+            data: serialize_json(data),
+            metadata: metadata ? serialize_json(metadata) : nil,
+            published_at: current_timestamp
+          )
+        end
+
+        # Send NOTIFY for new message
+        send_notify(Notify::Channel::CHANNEL_MESSAGE, { ch: channel, msg_id: message_id })
+
+        message_id
+      end
+
+      def subscribe_to_channel(instance_id:, channel:, mode:, activity_id: nil, timeout_at: nil)
+        if mysql?
+          @db[:channel_subscriptions].on_duplicate_key_update(
+            mode: mode,
+            activity_id: activity_id,
+            timeout_at: timeout_at
+          ).insert(
+            instance_id: instance_id,
+            channel: channel,
+            mode: mode,
+            activity_id: activity_id,
+            timeout_at: timeout_at,
+            subscribed_at: current_timestamp
+          )
+        else
+          @db[:channel_subscriptions].insert_conflict(
+            target: %i[instance_id channel],
+            update: { mode: mode, activity_id: activity_id, timeout_at: timeout_at }
+          ).insert(
+            instance_id: instance_id,
+            channel: channel,
+            mode: mode,
+            activity_id: activity_id,
+            timeout_at: timeout_at,
+            subscribed_at: current_timestamp
+          )
+        end
+      end
+
+      def unsubscribe_from_channel(instance_id:, channel:)
+        @db[:channel_subscriptions]
+          .where(instance_id: instance_id, channel: channel)
+          .delete
+      end
+
+      def get_subscription(instance_id:, channel:)
+        @db[:channel_subscriptions]
+          .where(instance_id: instance_id, channel: channel)
+          .first
+      end
+
+      # Get the mode for a channel (from first subscription)
+      # @param channel [String] Channel name
+      # @return [String, nil] The mode or nil if no subscriptions exist
+      def get_channel_mode(channel)
+        row = @db[:channel_subscriptions]
+              .where(channel: channel)
+              .select(:mode)
+              .first
+        row&.dig(:mode)
+      end
+
+      def find_waiting_subscriptions(channel:, limit: 100)
+        @db[:channel_subscriptions]
+          .where(channel: channel)
+          .where { Sequel.~(activity_id: nil) }
+          .limit(limit)
+          .map(&:to_h)
+      end
+
+      def find_timed_out_subscriptions(limit: 100)
+        now = Time.now
+        @db[:channel_subscriptions]
+          .where { timeout_at <= now }
+          .where { Sequel.~(timeout_at: nil) }
+          .limit(limit)
+          .map(&:to_h)
+      end
+
+      def claim_message(message_id:, instance_id:)
+        @db[:channel_message_claims].insert(
+          message_id: message_id,
+          instance_id: instance_id,
+          claimed_at: current_timestamp
+        )
+        true
+      rescue Sequel::UniqueConstraintViolation
+        false
+      end
+
+      def get_next_message(channel:, mode:, instance_id:, cursor_id: nil)
+        case mode
+        when ChannelMode::COMPETING
+          get_next_competing_message(channel, instance_id)
+        when ChannelMode::BROADCAST
+          get_next_broadcast_message(channel, instance_id, cursor_id)
+        end
+      end
+
+      # Deliver a channel message directly to a specific workflow instance
+      # Used for Point-to-Point delivery (e.g., shikibuinstanceid targeting)
+      # @param instance_id [String] Target workflow instance ID
+      # @param channel [String] Channel name (event type)
+      # @param message_id [String] Message ID
+      # @param data [Object] Message data
+      # @param metadata [Hash] Message metadata
+      # @param worker_id [String] Worker ID for locking
+      # @return [Hash, nil] Delivery result or nil if delivery failed
+      def deliver_channel_message(instance_id:, channel:, message_id:, data:, metadata:, worker_id:)
+        # Try to acquire lock on the workflow instance
+        return nil unless try_acquire_lock(instance_id, worker_id)
+
+        begin
+          result = @db.transaction do
+            # Find waiting subscription for this channel
+            sub = @db[:channel_subscriptions]
+                  .where(instance_id: instance_id, channel: channel)
+                  .where { Sequel.~(activity_id: nil) }
+                  .first
+
+            # No waiting subscription found
+            next nil unless sub
+
+            activity_id = sub[:activity_id]
+
+            # Record message received in history (for deterministic replay)
+            append_history(
+              instance_id: instance_id,
+              activity_id: activity_id,
+              event_type: EventType::CHANNEL_MESSAGE_RECEIVED,
+              event_data: {
+                channel: channel,
+                message_id: message_id,
+                data: data,
+                metadata: metadata,
+                published_at: Time.now.iso8601
+              }
+            )
+
+            # Clear activity_id from subscription (no longer waiting)
+            @db[:channel_subscriptions]
+              .where(instance_id: instance_id, channel: channel)
+              .update(activity_id: nil, timeout_at: nil)
+
+            # Update workflow instance status to running
+            update_instance_status(instance_id, Status::RUNNING)
+
+            { instance_id: instance_id, activity_id: activity_id }
+          end
+
+          # Send NOTIFY for workflow resumable (outside transaction for PostgreSQL)
+          send_notify(Notify::Channel::WORKFLOW_RESUMABLE, { wf_id: instance_id }) if result
+
+          result
+        ensure
+          # Always release the lock
+          release_lock(instance_id, worker_id)
+        end
+      end
+
+      # ============================================
+      # Outbox
+      # ============================================
+
+      def add_outbox_event(event_id:, event_type:, event_source:, event_data:, data_type: DataType::JSON)
+        if data_type == DataType::BINARY
+          @db[:outbox_events].insert(
+            event_id: event_id,
+            event_type: event_type,
+            event_source: event_source,
+            data_type: data_type,
+            event_data_binary: Sequel.blob(event_data),
+            status: OutboxStatus::PENDING,
+            created_at: current_timestamp
+          )
+        else
+          @db[:outbox_events].insert(
+            event_id: event_id,
+            event_type: event_type,
+            event_source: event_source,
+            data_type: data_type,
+            event_data: serialize_json(event_data),
+            status: OutboxStatus::PENDING,
+            created_at: current_timestamp
+          )
+        end
+
+        # Send NOTIFY for new outbox event
+        send_notify(Notify::Channel::OUTBOX_PENDING, { evt_id: event_id, evt_type: event_type })
+      end
+
+      def get_pending_outbox_events(limit: 100)
+        if supports_skip_locked?
+          # PostgreSQL/MySQL: Use SELECT FOR UPDATE SKIP LOCKED
+          # This allows multiple workers to fetch different events without blocking
+          @db.transaction do
+            rows = @db[:outbox_events]
+                   .where(status: [OutboxStatus::PENDING, OutboxStatus::FAILED])
+                   .order(:created_at)
+                   .limit(limit)
+                   .for_update
+                   .skip_locked
+                   .all
+
+            return [] if rows.empty?
+
+            # Mark as processing to prevent duplicate fetches
+            event_ids = rows.map { |r| r[:event_id] }
+            @db[:outbox_events]
+              .where(event_id: event_ids)
+              .update(status: OutboxStatus::PROCESSING)
+
+            rows.map { |row| deserialize_outbox_event(row) }
+          end
+        else
+          # SQLite: Simple query (table-level locking)
+          @db[:outbox_events]
+            .where(status: [OutboxStatus::PENDING, OutboxStatus::FAILED])
+            .order(:created_at)
+            .limit(limit)
+            .map { |row| deserialize_outbox_event(row) }
+        end
+      end
+
+      def mark_outbox_published(event_id)
+        @db[:outbox_events]
+          .where(event_id: event_id)
+          .update(
+            status: OutboxStatus::PUBLISHED,
+            published_at: current_timestamp
+          )
+      end
+
+      def mark_outbox_failed(event_id, error_message)
+        @db[:outbox_events]
+          .where(event_id: event_id)
+          .update(
+            status: OutboxStatus::FAILED,
+            last_error: error_message,
+            retry_count: Sequel[:retry_count] + 1
+          )
+      end
+
+      def mark_outbox_expired(event_id, error_message)
+        @db[:outbox_events]
+          .where(event_id: event_id)
+          .update(
+            status: OutboxStatus::EXPIRED,
+            last_error: error_message
+          )
+      end
+
+      def mark_outbox_invalid(event_id, error_message)
+        @db[:outbox_events]
+          .where(event_id: event_id)
+          .update(
+            status: OutboxStatus::INVALID,
+            last_error: error_message
+          )
+      end
+
+      # ============================================
+      # System Locks
+      # ============================================
+
+      def try_acquire_system_lock(lock_name, worker_id, timeout: 30)
+        now = Time.now
+        expires_at = now + timeout
+
+        # Try to insert new lock
+        begin
+          @db[:system_locks].insert(
+            lock_name: lock_name,
+            locked_by: worker_id,
+            locked_at: now,
+            lock_expires_at: expires_at
+          )
+          return true
+        rescue Sequel::UniqueConstraintViolation
+          # Lock exists, try to acquire if expired
+        end
+
+        # Try to take over expired lock
+        affected = @db[:system_locks]
+                   .where(lock_name: lock_name)
+                   .where { lock_expires_at < now }
+                   .update(
+                     locked_by: worker_id,
+                     locked_at: now,
+                     lock_expires_at: expires_at
+                   )
+
+        affected.positive?
+      end
+
+      def release_system_lock(lock_name, worker_id)
+        @db[:system_locks]
+          .where(lock_name: lock_name, locked_by: worker_id)
+          .delete
+      end
+
+      def refresh_system_lock(lock_name, worker_id, timeout: 30)
+        now = Time.now
+        expires_at = now + timeout
+
+        affected = @db[:system_locks]
+                   .where(lock_name: lock_name, locked_by: worker_id)
+                   .update(
+                     locked_at: now,
+                     lock_expires_at: expires_at
+                   )
+
+        affected.positive?
+      end
+
+      # ============================================
+      # Notifications (PostgreSQL LISTEN/NOTIFY)
+      # ============================================
+
+      # Send workflow resumable notification
+      # @param instance_id [String] Workflow instance ID
+      # @param workflow_name [String, nil] Optional workflow name
+      def notify_workflow_resumable(instance_id, workflow_name = nil)
+        send_notify(Notify::Channel::WORKFLOW_RESUMABLE, { wf_id: instance_id, wf_name: workflow_name })
+      end
+
+      # Cleanup old channel messages older than retention_days
+      # @param retention_days [Integer] Number of days to retain messages
+      # @return [Integer] Number of deleted messages
+      def cleanup_old_channel_messages(retention_days:)
+        cutoff_time = Time.now - (retention_days * 24 * 60 * 60)
+        @db[:channel_messages]
+          .where { published_at < cutoff_time }
+          .delete
+      end
+
+      private
+
+      def configure_database
+        case @db.database_type
+        when :postgres
+          @db.extension :pg_json
+        end
+      end
+
+      # Send PostgreSQL NOTIFY (PostgreSQL-only, no-op for other databases)
+      # @param channel [String] Notification channel name
+      # @param payload [Hash] Payload to send as JSON
+      def send_notify(channel, payload)
+        return unless @notify_enabled && @db.database_type == :postgres
+
+        payload_json = JSON.generate(payload, ascii_only: true)
+        @db.run(Sequel.lit('SELECT pg_notify(?, ?)', channel, payload_json))
+      rescue Sequel::DatabaseError => e
+        warn "[Shikibu::Storage] Failed to send NOTIFY on #{channel}: #{e.message}"
+      end
+
+      def current_timestamp
+        # Return Time object - Sequel handles DB-specific formatting
+        Time.now.utc
+      end
+
+      def mysql?
+        @db.database_type == :mysql
+      end
+
+      def supports_skip_locked?
+        %i[postgres mysql].include?(@db.database_type)
+      end
+
+      def serialize_json(data)
+        return nil if data.nil?
+
+        JSON.generate(data)
+      end
+
+      def parse_json(json_str)
+        return nil if json_str.nil?
+
+        JSON.parse(json_str, symbolize_names: true)
+      end
+
+      def deserialize_instance(row)
+        {
+          instance_id: row[:instance_id],
+          workflow_name: row[:workflow_name],
+          source_hash: row[:source_hash],
+          owner_service: row[:owner_service],
+          framework: row[:framework],
+          status: row[:status],
+          current_activity_id: row[:current_activity_id],
+          continued_from: row[:continued_from],
+          started_at: row[:started_at],
+          updated_at: row[:updated_at],
+          input_data: parse_json(row[:input_data]),
+          output_data: row[:output_data] ? parse_json(row[:output_data]) : nil,
+          locked_by: row[:locked_by],
+          locked_at: row[:locked_at],
+          lock_expires_at: row[:lock_expires_at]
+        }
+      end
+
+      def deserialize_history_event(row)
+        data = if row[:data_type] == DataType::BINARY
+                 row[:event_data_binary]
+               else
+                 parse_json(row[:event_data])
+               end
+
+        {
+          id: row[:id],
+          instance_id: row[:instance_id],
+          activity_id: row[:activity_id],
+          event_type: row[:event_type],
+          data_type: row[:data_type],
+          data: data,
+          created_at: row[:created_at]
+        }
+      end
+
+      def deserialize_outbox_event(row)
+        data = if row[:data_type] == DataType::BINARY
+                 row[:event_data_binary]
+               else
+                 parse_json(row[:event_data])
+               end
+
+        {
+          event_id: row[:event_id],
+          event_type: row[:event_type],
+          event_source: row[:event_source],
+          data_type: row[:data_type],
+          data: data,
+          status: row[:status],
+          retry_count: row[:retry_count],
+          created_at: row[:created_at]
+        }
+      end
+
+      def get_next_competing_message(channel, _instance_id)
+        # Find unclaimed message
+        row = @db[:channel_messages]
+              .left_join(:channel_message_claims, message_id: :message_id)
+              .where(Sequel[:channel_messages][:channel] => channel)
+              .where(Sequel[:channel_message_claims][:message_id] => nil)
+              .order(Sequel[:channel_messages][:published_at])
+              .select(Sequel[:channel_messages].*)
+              .first
+        deserialize_channel_message(row)
+      end
+
+      def get_next_broadcast_message(channel, _instance_id, cursor_id)
+        query = @db[:channel_messages].where(channel: channel)
+        query = query.where { id > cursor_id } if cursor_id
+        row = query.order(:id).first
+        deserialize_channel_message(row)
+      end
+
+      def deserialize_channel_message(row)
+        return nil unless row
+
+        data = if row[:data_type] == DataType::BINARY
+                 row[:data_binary]
+               else
+                 parse_json(row[:data])
+               end
+        metadata = parse_json(row[:metadata])
+
+        {
+          id: row[:id],
+          message_id: row[:message_id],
+          channel: row[:channel],
+          data: data,
+          metadata: metadata,
+          published_at: row[:published_at]
+        }
+      end
+    end
+  end
+end