mammoth 0.5.1 → 0.7.0

data/lib/mammoth/operational_state/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module OperationalState
+    # Registry for operational state adapters.
+    module Registry
+      class << self
+        # Register an operational state adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param adapter [Object] adapter class
+        # @return [Object] registered adapter
+        def register(name, adapter)
+          registry.register(name, adapter)
+        end
+
+        # Fetch an operational state adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @return [Object] adapter class
+        def fetch(name)
+          registry.fetch(name)
+        end
+
+        # Build an operational state adapter from config.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param config [Mammoth::Configuration] loaded configuration
+        # @return [Mammoth::OperationalState::Adapter] adapter instance
+        def build(name, config)
+          fetch(name).from_config(config)
+        end
+
+        # @return [Array<String>] registered operational state adapter names
+        def names
+          registry.names
+        end
+
+        # @return [Mammoth::Registry] underlying registry
+        def registry
+          @registry ||= Mammoth::Registry.new("operational_state")
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/operational_state/sqlite_adapter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module OperationalState
+    # SQLite-backed operational state adapter used by Mammoth OSS.
+    class SQLiteAdapter < Adapter
+      attr_reader :sqlite_store
+
+      # @param sqlite_store [Mammoth::SQLiteStore] bootstrapped SQLite store
+      def initialize(sqlite_store)
+        super()
+        @sqlite_store = sqlite_store.bootstrap!
+      end
+
+      # Build a SQLite state adapter from Mammoth configuration.
+      #
+      # @param config [Mammoth::Configuration] loaded configuration
+      # @return [Mammoth::OperationalState::SQLiteAdapter]
+      def self.from_config(config)
+        new(SQLiteStore.connect(config.dig("sqlite", "path")))
+      end
+
+      # @return [Mammoth::CheckpointStore]
+      def checkpoint_store
+        @checkpoint_store ||= CheckpointStore.new(sqlite_store)
+      end
+
+      # @return [Mammoth::DeadLetterStore]
+      def dead_letter_store
+        @dead_letter_store ||= DeadLetterStore.new(sqlite_store)
+      end
+
+      # @return [Mammoth::DeliveredEnvelopeStore]
+      def delivered_envelope_store
+        @delivered_envelope_store ||= DeliveredEnvelopeStore.new(sqlite_store)
+      end
+
+      # @return [Hash] JSON-friendly SQLite state summary
+      def summary
+        super.merge(adapter: "sqlite", path: sqlite_store.path, tables: sqlite_store.tables)
+      end
+    end
+  end
+end

data/lib/mammoth/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Small explicit registry for built-in and extension-provided adapters.
+  class Registry
+    attr_reader :namespace, :entries
+
+    # @param namespace [String] human-readable registry name for errors
+    def initialize(namespace)
+      @namespace = namespace
+      @entries = {}
+    end
+
+    # Register an adapter under a stable name.
+    #
+    # @param name [String, Symbol] adapter name
+    # @param adapter [Object] adapter object or class
+    # @return [Object] registered adapter
+    def register(name, adapter)
+      key = normalize_name(name)
+      raise ConfigurationError, "#{namespace} adapter already registered: #{key}" if entries.key?(key)
+
+      entries[key] = adapter
+    end
+
+    # Fetch a registered adapter.
+    #
+    # @param name [String, Symbol] adapter name
+    # @return [Object] registered adapter
+    def fetch(name)
+      key = normalize_name(name)
+      entries.fetch(key) { raise ConfigurationError, "unknown #{namespace} adapter: #{key}" }
+    end
+
+    # @return [Array<String>] registered adapter names
+    def names
+      entries.keys.sort
+    end
+
+    private
+
+    def normalize_name(name)
+      name.to_s
+    end
+  end
+end

data/lib/mammoth/route_filter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Matches CDC events and transaction envelopes against destination route rules.
+  class RouteFilter
+    attr_reader :schemas, :tables, :operations
+
+    def initialize(config = nil)
+      route = config || {}
+      @schemas = normalized_set(route["schemas"])
+      @tables = normalized_set(route["tables"])
+      @operations = normalized_set(route["operations"])
+    end
+
+    def match?(work, serializer:)
+      match_payload?(serializer.call(work))
+    end
+
+    def match_payload?(payload)
+      if transaction_payload?(payload)
+        payload.fetch("events").any? { |event| event_match?(event) }
+      else
+        event_match?(payload)
+      end
+    end
+
+    private
+
+    def normalized_set(values)
+      return [] unless values
+
+      values.map { |value| value.to_s.downcase }.freeze
+    end
+
+    def transaction_payload?(payload)
+      payload.fetch("type", nil) == TransactionEnvelopeSerializer::PAYLOAD_TYPE
+    end
+
+    def event_match?(payload)
+      matches?(schemas, payload["namespace"]) &&
+        matches?(tables, payload["entity"]) &&
+        matches?(operations, payload["operation"])
+    end
+
+    def matches?(allowed_values, actual_value)
+      allowed_values.empty? || allowed_values.include?(actual_value.to_s.downcase)
+    end
+  end
+end

data/lib/mammoth/runtimes/adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Delivery runtime adapter contracts and registry.
+  module Runtimes
+    # Base contract for delivery runtime adapters.
+    class Adapter
+      # @return [void]
+      def initialize; end
+
+      # @return [Hash] JSON-friendly adapter capabilities
+      def self.capabilities
+        { type: adapter_type }
+      end
+
+      # @return [String] adapter type name
+      def self.adapter_type
+        type = name.split("::").last.to_s.delete_suffix("Adapter").downcase
+        type.empty? ? "adapter" : type
+      end
+    end
+  end
+end

data/lib/mammoth/runtimes/concurrent_adapter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Runtimes
+    # Runtime adapter backed by Mammoth's existing cdc-concurrent wrapper.
+    class ConcurrentAdapter < Adapter
+      class << self
+        # @return [String] adapter type name
+        def adapter_type
+          "concurrent"
+        end
+
+        # Build a concurrent runtime adapter.
+        #
+        # @param processor [#process] delivery processor
+        # @param concurrency [Integer] worker count
+        # @param timeout [Numeric, nil] optional timeout
+        # @param preserve_order [Boolean] preserve ordering when supported
+        # @return [Mammoth::ConcurrentDeliveryRuntime]
+        def build(processor:, concurrency:, timeout:, preserve_order:)
+          ConcurrentDeliveryRuntime.new(
+            processor: processor,
+            concurrency: concurrency,
+            timeout: timeout,
+            preserve_order: preserve_order
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/runtimes/inline_adapter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Runtimes
+    # Inline runtime adapter that processes work in the caller thread.
+    class InlineAdapter < Adapter
+      attr_reader :processor
+
+      # @param processor [#process] delivery processor
+      def initialize(processor:)
+        super()
+        @processor = processor
+      end
+
+      # Build an inline runtime.
+      #
+      # @param processor [#process] delivery processor
+      # @return [Mammoth::Runtimes::InlineAdapter]
+      def self.build(processor:, **_options)
+        new(processor: processor)
+      end
+
+      # @return [String] adapter type name
+      def self.adapter_type
+        "inline"
+      end
+
+      # @param items [Array<Object>] work units
+      # @return [Array<Object>] processor results
+      def process_many(items)
+        items.map { |item| processor.process(item) }
+      end
+
+      # @return [nil]
+      def shutdown
+        nil
+      end
+    end
+  end
+end

data/lib/mammoth/runtimes/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Runtimes
+    # Registry for delivery runtime adapters.
+    module Registry
+      class << self
+        # Register a runtime adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param adapter [Object] adapter class
+        # @return [Object] registered adapter
+        def register(name, adapter)
+          registry.register(name, adapter)
+        end
+
+        # Fetch a runtime adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @return [Object] adapter class
+        def fetch(name)
+          registry.fetch(name)
+        end
+
+        # Build a runtime adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param options [Hash] adapter-specific build options
+        # @return [Object] runtime adapter
+        def build(name, **options)
+          fetch(name).build(**options)
+        end
+
+        # @return [Array<String>] registered runtime adapter names
+        def names
+          registry.names
+        end
+
+        # @return [Mammoth::Registry] underlying registry
+        def registry
+          @registry ||= Mammoth::Registry.new("runtime")
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/status.rb

@@ -3,39 +3,73 @@
 module Mammoth
   # Builds and prints a boring operational status snapshot.
   class Status
-    attr_reader :config, :sqlite_store
+    attr_reader :config, :sqlite_store, :output
 
     # Print status for a configuration and optional SQLite store.
     #
     # @param config [Mammoth::Configuration] loaded configuration
     # @param sqlite_store [Mammoth::SQLiteStore, nil] operational store
     # @return [void]
-    def self.call(config, sqlite_store: nil)
-      new(config, sqlite_store: sqlite_store).call
+    def self.call(config, sqlite_store: nil, output: $stdout)
+      new(config, sqlite_store: sqlite_store, output: output).call
     end
 
     # @param config [Mammoth::Configuration] loaded configuration
     # @param sqlite_store [Mammoth::SQLiteStore, nil] operational store
-    def initialize(config, sqlite_store: nil)
+    # @param output [#puts] output stream
+    def initialize(config, sqlite_store: nil, output: $stdout)
       @config = config
       @sqlite_store = sqlite_store
+      @output = output
     end
 
     # Print the status snapshot.
     #
     # @return [void]
     def call
-      puts "Mammoth: #{config.dig("mammoth", "name")}"
-      puts "Replication slot: #{config.dig("replication", "slot")}"
-      puts "Replication publications: #{Array(config.dig("replication", "publications")).join(", ")}"
-      puts "Runtime: not started"
-      puts "SQLite: #{sqlite_path}"
-      puts "Destinations: #{destination_names.join(", ")}"
+      status_lines.each { |line| output.puts(line) }
       print_store_state if sqlite_store
     end
 
     private
 
+    def status_lines
+      identity_lines + replication_lines + runtime_lines + destination_lines + ["SQLite: #{sqlite_path}"]
+    end
+
+    def identity_lines
+      [
+        "Mammoth: #{config.dig("mammoth", "name")}",
+        "Node ID: #{node_identity.node_id}",
+        "Node name: #{node_identity.node_name}",
+        "Fleet: #{node_identity.fleet_id || "unassigned"}",
+        "Environment: #{node_identity.environment || "unspecified"}"
+      ]
+    end
+
+    def replication_lines
+      [
+        "Replication slot: #{config.dig("replication", "slot")}",
+        "Replication publications: #{Array(config.dig("replication", "publications")).join(", ")}"
+      ]
+    end
+
+    def runtime_lines
+      [
+        "Runtime: not started",
+        "Runtime adapter: #{capabilities.fetch(:runtime)}",
+        "Operational state: #{capabilities.fetch(:operational_state)}"
+      ]
+    end
+
+    def destination_lines
+      [
+        "Destinations: #{destination_names.join(", ")}",
+        "Destination adapters: #{capabilities.fetch(:destinations).join(", ")}",
+        "Features: #{capabilities.fetch(:features).join(", ")}"
+      ]
+    end
+
     def sqlite_path
       config.dig("sqlite", "path")
     end
@@ -47,11 +81,19 @@ module Mammoth
       [config.dig("webhook", "name")]
     end
 
+    def node_identity
+      @node_identity ||= NodeIdentity.from_config(config)
+    end
+
+    def capabilities
+      @capabilities ||= Capabilities.call(config)
+    end
+
     def print_store_state
       store = sqlite_store.bootstrap!
-      puts "Tables: #{store.tables.join(", ")}"
-      puts "Checkpoints: #{CheckpointStore.new(store).count}"
-      puts "Dead Letters: #{DeadLetterStore.new(store).count}"
+      output.puts "Tables: #{store.tables.join(", ")}"
+      output.puts "Checkpoints: #{CheckpointStore.new(store).count}"
+      output.puts "Dead Letters: #{DeadLetterStore.new(store).count}"
     end
   end
 end

data/lib/mammoth/version.rb

@@ -2,5 +2,5 @@
 
 module Mammoth
   # Current Mammoth gem version.
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

data/lib/mammoth.rb

@@ -2,8 +2,12 @@
 
 require_relative "mammoth/version"
 require_relative "mammoth/errors"
+require_relative "mammoth/registry"
 require_relative "mammoth/configuration"
+require_relative "mammoth/node_identity"
+require_relative "mammoth/capabilities"
 require_relative "mammoth/status"
+require_relative "mammoth/commands/status_command"
 require_relative "mammoth/observability_snapshot"
 require_relative "mammoth/observability_server"
 require_relative "mammoth/sqlite_store"
@@ -12,11 +16,22 @@ require_relative "mammoth/dead_letter_store"
 require_relative "mammoth/delivered_envelope_store"
 require_relative "mammoth/event_serializer"
 require_relative "mammoth/transaction_envelope_serializer"
+require_relative "mammoth/route_filter"
 require_relative "mammoth/webhook_sink"
+require_relative "mammoth/operational_state/adapter"
+require_relative "mammoth/operational_state/sqlite_adapter"
+require_relative "mammoth/operational_state/registry"
+require_relative "mammoth/destinations/adapter"
+require_relative "mammoth/destinations/webhook_adapter"
+require_relative "mammoth/destinations/registry"
 require_relative "mammoth/delivery_worker"
 require_relative "mammoth/fanout_delivery_worker"
 require_relative "mammoth/delivery_processor"
 require_relative "mammoth/concurrent_delivery_runtime"
+require_relative "mammoth/runtimes/adapter"
+require_relative "mammoth/runtimes/inline_adapter"
+require_relative "mammoth/runtimes/concurrent_adapter"
+require_relative "mammoth/runtimes/registry"
 require_relative "mammoth/sources/postgres"
 require_relative "mammoth/cdc_source"
 require_relative "mammoth/replication_consumer"
@@ -30,4 +45,8 @@ require_relative "mammoth/cli"
 # PostgreSQL change events are normalized, persisted through local operational
 # state, and delivered to webhook destinations.
 module Mammoth
+  OperationalState::Registry.register("sqlite", OperationalState::SQLiteAdapter)
+  Destinations::Registry.register("webhook", Destinations::WebhookAdapter)
+  Runtimes::Registry.register("inline", Runtimes::InlineAdapter)
+  Runtimes::Registry.register("concurrent", Runtimes::ConcurrentAdapter)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mammoth
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -145,9 +145,11 @@ files:
 - exe/mammoth
 - lib/mammoth.rb
 - lib/mammoth/application.rb
+- lib/mammoth/capabilities.rb
 - lib/mammoth/cdc_source.rb
 - lib/mammoth/checkpoint_store.rb
 - lib/mammoth/cli.rb
+- lib/mammoth/commands/status_command.rb
 - lib/mammoth/concurrent_delivery_runtime.rb
 - lib/mammoth/configuration.rb
 - lib/mammoth/dead_letter_commands.rb
@@ -155,12 +157,25 @@ files:
 - lib/mammoth/delivered_envelope_store.rb
 - lib/mammoth/delivery_processor.rb
 - lib/mammoth/delivery_worker.rb
+- lib/mammoth/destinations/adapter.rb
+- lib/mammoth/destinations/registry.rb
+- lib/mammoth/destinations/webhook_adapter.rb
 - lib/mammoth/errors.rb
 - lib/mammoth/event_serializer.rb
 - lib/mammoth/fanout_delivery_worker.rb
+- lib/mammoth/node_identity.rb
 - lib/mammoth/observability_server.rb
 - lib/mammoth/observability_snapshot.rb
+- lib/mammoth/operational_state/adapter.rb
+- lib/mammoth/operational_state/registry.rb
+- lib/mammoth/operational_state/sqlite_adapter.rb
+- lib/mammoth/registry.rb
 - lib/mammoth/replication_consumer.rb
+- lib/mammoth/route_filter.rb
+- lib/mammoth/runtimes/adapter.rb
+- lib/mammoth/runtimes/concurrent_adapter.rb
+- lib/mammoth/runtimes/inline_adapter.rb
+- lib/mammoth/runtimes/registry.rb
 - lib/mammoth/sources/postgres.rb
 - lib/mammoth/sql/__bootstrap__.sql
 - lib/mammoth/sqlite_store.rb