durable_workflow 0.1.0

data/lib/durable_workflow/storage/active_record.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module DurableWorkflow
+  module Storage
+    class ActiveRecord < Store
+      # Assumes two tables exist:
+      #   workflow_executions: id (uuid), workflow_id, status, input (json), ctx (json),
+      #                        current_step, result (json), recover_to, halt_data (json),
+      #                        error (text), created_at, updated_at
+      #   workflow_entries:    id (uuid), execution_id, step_id, step_type, action,
+      #                        duration_ms, input (json), output (json), error, timestamp
+
+      def initialize(execution_class:, entry_class:)
+        @execution_class = execution_class
+        @entry_class = entry_class
+      end
+
+      def save(execution)
+        record = @execution_class.find_or_initialize_by(id: execution.id)
+        record.assign_attributes(
+          workflow_id: execution.workflow_id,
+          status: execution.status.to_s,
+          input: execution.input.to_json,
+          ctx: execution.ctx.to_json,
+          current_step: execution.current_step,
+          result: execution.result&.to_json,
+          recover_to: execution.recover_to,
+          halt_data: execution.halt_data&.to_json,
+          error: execution.error
+        )
+        record.save!
+        execution
+      end
+
+      def load(execution_id)
+        record = @execution_class.find_by(id: execution_id)
+        return nil unless record
+
+        Core::Execution.new(
+          id: record.id,
+          workflow_id: record.workflow_id,
+          status: record.status.to_sym,
+          input: parse_json(record.input) || {},
+          ctx: parse_json(record.ctx) || {},
+          current_step: record.current_step,
+          result: parse_json_any(record.respond_to?(:result) ? record.result : nil),
+          recover_to: record.respond_to?(:recover_to) ? record.recover_to : nil,
+          halt_data: parse_json(record.respond_to?(:halt_data) ? record.halt_data : nil),
+          error: record.respond_to?(:error) ? record.error : nil,
+          created_at: record.created_at,
+          updated_at: record.updated_at
+        )
+      end
+
+      def record(entry)
+        @entry_class.create!(
+          id: entry.id,
+          execution_id: entry.execution_id,
+          step_id: entry.step_id,
+          step_type: entry.step_type,
+          action: entry.action.to_s,
+          duration_ms: entry.duration_ms,
+          input: entry.input&.to_json,
+          output: entry.output&.to_json,
+          error: entry.error,
+          timestamp: entry.timestamp
+        )
+        entry
+      end
+
+      def entries(execution_id)
+        @entry_class.where(execution_id:).order(:timestamp).map do |r|
+          Core::Entry.new(
+            id: r.id,
+            execution_id: r.execution_id,
+            step_id: r.step_id,
+            step_type: r.step_type,
+            action: r.action.to_sym,
+            duration_ms: r.duration_ms,
+            input: parse_json(r.input),
+            output: parse_json(r.output),
+            error: r.error,
+            timestamp: r.timestamp
+          )
+        end
+      end
+
+      def find(workflow_id: nil, status: nil, limit: 100)
+        scope = @execution_class.all
+        scope = scope.where(workflow_id:) if workflow_id
+        scope = scope.where(status: status.to_s) if status
+        scope.limit(limit).order(created_at: :desc).map do |record|
+          Core::Execution.new(
+            id: record.id,
+            workflow_id: record.workflow_id,
+            status: record.status.to_sym,
+            input: parse_json(record.input) || {},
+            ctx: parse_json(record.ctx) || {},
+            current_step: record.current_step,
+            result: parse_json_any(record.respond_to?(:result) ? record.result : nil),
+            recover_to: record.respond_to?(:recover_to) ? record.recover_to : nil,
+            halt_data: parse_json(record.respond_to?(:halt_data) ? record.halt_data : nil),
+            error: record.respond_to?(:error) ? record.error : nil,
+            created_at: record.created_at,
+            updated_at: record.updated_at
+          )
+        end
+      end
+
+      def delete(execution_id)
+        record = @execution_class.find_by(id: execution_id)
+        return false unless record
+
+        @entry_class.where(execution_id:).delete_all
+        record.destroy
+        true
+      end
+
+      def execution_ids(workflow_id: nil, limit: 1000)
+        scope = @execution_class.all
+        scope = scope.where(workflow_id:) if workflow_id
+        scope.limit(limit).pluck(:id)
+      end
+
+      private
+
+      def parse_json(str)
+        return nil if str.nil? || str.empty?
+
+        result = JSON.parse(str)
+        result.is_a?(Hash) ? DurableWorkflow::Utils.deep_symbolize(result) : result
+      rescue JSON::ParserError
+        nil
+      end
+
+      def parse_json_any(str)
+        return nil if str.nil? || str.empty?
+
+        result = JSON.parse(str)
+        result.is_a?(Hash) ? DurableWorkflow::Utils.deep_symbolize(result) : result
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/durable_workflow/storage/redis.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'redis'
+
+module DurableWorkflow
+  module Storage
+    class Redis < Store
+      PREFIX = 'durable_workflow'
+
+      def initialize(redis: nil, url: nil, ttl: 86_400 * 7)
+        @redis = redis || ::Redis.new(url:)
+        @ttl = ttl
+      end
+
+      def save(execution)
+        key = exec_key(execution.id)
+        data = serialize_execution(execution)
+        @redis.setex(key, @ttl, data)
+        index_add(execution)
+        execution
+      end
+
+      def load(execution_id)
+        data = @redis.get(exec_key(execution_id))
+        data ? deserialize_execution(data) : nil
+      end
+
+      def record(entry)
+        key = entries_key(entry.execution_id)
+        data = serialize_entry(entry)
+        @redis.rpush(key, data)
+        @redis.expire(key, @ttl)
+        entry
+      end
+
+      def entries(execution_id)
+        key = entries_key(execution_id)
+        @redis.lrange(key, 0, -1).map { deserialize_entry(_1) }
+      end
+
+      def find(workflow_id: nil, status: nil, limit: 100)
+        ids = if workflow_id
+                @redis.smembers(index_key(workflow_id)).first(limit)
+              else
+                scan_execution_ids(limit)
+              end
+
+        results = ids.filter_map { load(_1) }
+        results = results.select { _1.status == status } if status
+        results.first(limit)
+      end
+
+      def delete(execution_id)
+        execution = load(execution_id)
+        return false unless execution
+
+        @redis.del(exec_key(execution_id))
+        @redis.del(entries_key(execution_id))
+        index_remove(execution)
+        true
+      end
+
+      def execution_ids(workflow_id: nil, limit: 1000)
+        if workflow_id
+          @redis.smembers(index_key(workflow_id)).first(limit)
+        else
+          scan_execution_ids(limit)
+        end
+      end
+
+      private
+
+      def exec_key(id)
+        "#{PREFIX}:exec:#{id}"
+      end
+
+      def entries_key(id)
+        "#{PREFIX}:entries:#{id}"
+      end
+
+      def index_key(wf_id)
+        "#{PREFIX}:idx:#{wf_id}"
+      end
+
+      def index_add(execution)
+        @redis.sadd(index_key(execution.workflow_id), execution.id)
+      end
+
+      def index_remove(execution)
+        @redis.srem(index_key(execution.workflow_id), execution.id)
+      end
+
+      def scan_execution_ids(limit)
+        ids = []
+        cursor = '0'
+        pattern = "#{PREFIX}:exec:*"
+
+        loop do
+          cursor, keys = @redis.scan(cursor, match: pattern, count: 100)
+          ids.concat(keys.map { _1.split(':').last })
+          break if cursor == '0' || ids.size >= limit
+        end
+
+        ids.first(limit)
+      end
+
+      def serialize_execution(execution)
+        JSON.generate(execution.to_h)
+      end
+
+      def deserialize_execution(json)
+        Core::Execution.from_h(symbolize(JSON.parse(json)))
+      end
+
+      def serialize_entry(entry)
+        JSON.generate(entry.to_h)
+      end
+
+      def deserialize_entry(json)
+        Core::Entry.from_h(symbolize(JSON.parse(json)))
+      end
+
+      def symbolize(obj)
+        case obj
+        when Hash then obj.transform_keys(&:to_sym).transform_values { symbolize(_1) }
+        when Array then obj.map { symbolize(_1) }
+        else obj
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/storage/sequel.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'sequel'
+
+module DurableWorkflow
+  module Storage
+    class Sequel < Store
+      # Tables:
+      #   workflow_executions: id (uuid pk), workflow_id, status, input (jsonb), ctx (jsonb),
+      #                        current_step, result (jsonb), recover_to, halt_data (jsonb),
+      #                        error (text), created_at, updated_at
+      #   workflow_entries:    id (uuid pk), execution_id (fk), step_id, step_type, action,
+      #                        duration_ms, input (jsonb), output (jsonb), error, timestamp
+
+      def initialize(db:, executions_table: :workflow_executions, entries_table: :workflow_entries)
+        @db = db
+        @executions = db[executions_table]
+        @entries = db[entries_table]
+      end
+
+      def save(execution)
+        now = Time.now
+        data = {
+          workflow_id: execution.workflow_id,
+          status: execution.status.to_s,
+          input: ::Sequel.pg_jsonb(execution.input),
+          ctx: ::Sequel.pg_jsonb(execution.ctx),
+          current_step: execution.current_step,
+          result: execution.result ? ::Sequel.pg_jsonb(execution.result) : nil,
+          recover_to: execution.recover_to,
+          halt_data: execution.halt_data ? ::Sequel.pg_jsonb(execution.halt_data) : nil,
+          error: execution.error,
+          updated_at: now
+        }
+
+        if @executions.where(id: execution.id).any?
+          @executions.where(id: execution.id).update(data)
+        else
+          @executions.insert(data.merge(id: execution.id, created_at: now))
+        end
+
+        execution
+      end
+
+      def load(execution_id)
+        row = @executions.where(id: execution_id).first
+        return nil unless row
+
+        Core::Execution.new(
+          id: row[:id],
+          workflow_id: row[:workflow_id],
+          status: row[:status].to_sym,
+          input: symbolize(row[:input] || {}),
+          ctx: symbolize(row[:ctx] || {}),
+          current_step: row[:current_step],
+          result: symbolize(row[:result]),
+          recover_to: row[:recover_to],
+          halt_data: symbolize(row[:halt_data]),
+          error: row[:error],
+          created_at: row[:created_at],
+          updated_at: row[:updated_at]
+        )
+      end
+
+      def record(entry)
+        @entries.insert(
+          id: entry.id,
+          execution_id: entry.execution_id,
+          step_id: entry.step_id,
+          step_type: entry.step_type,
+          action: entry.action.to_s,
+          duration_ms: entry.duration_ms,
+          input: entry.input ? ::Sequel.pg_jsonb(entry.input) : nil,
+          output: entry.output ? ::Sequel.pg_jsonb(entry.output) : nil,
+          error: entry.error,
+          timestamp: entry.timestamp
+        )
+        entry
+      end
+
+      def entries(execution_id)
+        @entries.where(execution_id:).order(:timestamp).map do |row|
+          Core::Entry.new(
+            id: row[:id],
+            execution_id: row[:execution_id],
+            step_id: row[:step_id],
+            step_type: row[:step_type],
+            action: row[:action].to_sym,
+            duration_ms: row[:duration_ms],
+            input: symbolize(row[:input]),
+            output: symbolize(row[:output]),
+            error: row[:error],
+            timestamp: row[:timestamp]
+          )
+        end
+      end
+
+      def find(workflow_id: nil, status: nil, limit: 100)
+        scope = @executions
+        scope = scope.where(workflow_id:) if workflow_id
+        scope = scope.where(status: status.to_s) if status
+        scope.order(::Sequel.desc(:created_at)).limit(limit).map do |row|
+          Core::Execution.new(
+            id: row[:id],
+            workflow_id: row[:workflow_id],
+            status: row[:status].to_sym,
+            input: symbolize(row[:input] || {}),
+            ctx: symbolize(row[:ctx] || {}),
+            current_step: row[:current_step],
+            result: symbolize(row[:result]),
+            recover_to: row[:recover_to],
+            halt_data: symbolize(row[:halt_data]),
+            error: row[:error],
+            created_at: row[:created_at],
+            updated_at: row[:updated_at]
+          )
+        end
+      end
+
+      def delete(execution_id)
+        count = @executions.where(id: execution_id).delete
+        @entries.where(execution_id:).delete
+        count.positive?
+      end
+
+      def execution_ids(workflow_id: nil, limit: 1000)
+        scope = @executions
+        scope = scope.where(workflow_id:) if workflow_id
+        scope.limit(limit).select_map(:id)
+      end
+
+      private
+
+      def symbolize(obj)
+        case obj
+        when Hash then obj.transform_keys(&:to_sym).transform_values { symbolize(_1) }
+        when Array then obj.map { symbolize(_1) }
+        else obj
+        end
+      end
+    end
+  end
+end

data/lib/durable_workflow/storage/store.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Storage
+    # Abstract base class for storage backends
+    class Store
+      # Save execution state
+      def save(state)
+        raise NotImplementedError
+      end
+
+      # Load execution state by ID
+      def load(execution_id)
+        raise NotImplementedError
+      end
+
+      # Record audit entry
+      def record(entry)
+        raise NotImplementedError
+      end
+
+      # Get entries for execution
+      def entries(execution_id)
+        raise NotImplementedError
+      end
+
+      # Find executions
+      def find(workflow_id: nil, status: nil, limit: 100)
+        raise NotImplementedError
+      end
+
+      # Delete execution
+      def delete(execution_id)
+        raise NotImplementedError
+      end
+
+      # List all execution IDs (for cleanup, admin)
+      def execution_ids(workflow_id: nil, limit: 1000)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/durable_workflow/utils.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  module Utils
+    module_function
+
+    def deep_symbolize(obj)
+      case obj
+      when Hash
+        obj.transform_keys(&:to_sym).transform_values { deep_symbolize(_1) }
+      when Array
+        obj.map { deep_symbolize(_1) }
+      else
+        obj
+      end
+    end
+
+    # Indifferent access - handles both symbol and string keys
+    def fetch(hash, key, default = nil)
+      return default unless hash.is_a?(Hash)
+
+      hash[key.to_sym] || hash[key.to_s] || default
+    end
+  end
+end

data/lib/durable_workflow/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DurableWorkflow
+  VERSION = '0.1.0'
+end

data/lib/durable_workflow.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'time'
+require_relative 'durable_workflow/version'
+
+module DurableWorkflow
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class ValidationError < Error; end
+  class ExecutionError < Error; end
+
+  class << self
+    attr_accessor :config
+
+    def configure
+      self.config ||= Config.new
+      yield config if block_given?
+      config
+    end
+
+    def load(source)
+      wf = Core::Parser.parse(source)
+      Core::Validator.validate!(wf)
+      wf
+    end
+
+    def registry
+      @registry ||= {}
+    end
+
+    def register(workflow)
+      registry[workflow.id] = workflow
+    end
+
+    def log(level, msg, **data)
+      config&.logger&.send(level, "[DurableWorkflow] #{msg} #{data}")
+    end
+  end
+
+  Config = Struct.new(:store, :service_resolver, :logger, keyword_init: true)
+end
+
+# Core (always loaded)
+require_relative 'durable_workflow/utils'
+require_relative 'durable_workflow/core/types'
+require_relative 'durable_workflow/core/parser'
+require_relative 'durable_workflow/core/validator'
+require_relative 'durable_workflow/core/resolver'
+require_relative 'durable_workflow/core/condition'
+require_relative 'durable_workflow/core/schema_validator'
+require_relative 'durable_workflow/core/executors/registry'
+require_relative 'durable_workflow/core/executors/base'
+
+# Load all core executors
+Dir[File.join(__dir__, 'durable_workflow/core/executors/*.rb')].each { |f| require f }
+
+require_relative 'durable_workflow/core/engine'
+
+# Storage (no default - must be configured)
+require_relative 'durable_workflow/storage/store'
+
+# Runners
+require_relative 'durable_workflow/runners/sync'
+require_relative 'durable_workflow/runners/async'
+require_relative 'durable_workflow/runners/stream'
+require_relative 'durable_workflow/runners/adapters/inline'
+
+# Extensions (base only - specific extensions loaded separately)
+require_relative 'durable_workflow/extensions/base'

data/sig/durable_workflow.rbs

@@ -0,0 +1,4 @@
+module DurableWorkflow
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end