stoplight 5.8.3 → 6.0.0.rc2

data/sig/stoplight/wiring/global_state.rbs

@@ -0,0 +1,36 @@
+module Stoplight
+  module Wiring
+    class GlobalState
+      DEFAULT_SYSTEM_NAME: String
+
+      @default_config: Domain::Config
+      @default_system: Wiring::System
+      @systems: Concurrent::Map[String, Wiring::System]
+
+      attr_reader default_config: Domain::Config
+      attr_reader default_system: Wiring::System
+
+      def initialize: (default_config: Domain::Config) -> void
+      def register_system: (
+          _ToS name,
+          ?cool_off_time: optional[Domain::duration_seconds],
+          ?threshold: optional[Domain::percentage | Integer],
+          ?recovery_threshold: optional[Integer],
+          ?window_size: optional[Domain::duration_seconds?],
+          ?tracked_errors: optional[Array[Module]],
+          ?skipped_errors: optional[Array[Module]],
+          ?data_store: optional[Domain::_DataStore],
+          ?error_notifier: optional[Domain::error_notifier],
+          ?notifiers: optional[Array[Domain::_StateTransitionNotifier]],
+          ?traffic_control: optional[Wiring::traffic_control],
+          ?traffic_recovery: optional[Wiring::traffic_recovery],
+        ) -> Wiring::System
+
+      private
+
+      def register_system_with_config: (Domain::Config) -> Wiring::System
+
+      def create_registry: (Domain::Config, Wiring::System) -> Domain::_Registry
+    end
+  end
+end

data/sig/{_private/stoplight/wiring/light_factory → stoplight/wiring/light_configuration_dsl}/traffic_control_dsl.rbs

@@ -1,6 +1,6 @@
 module Stoplight
   module Wiring
-    class LightFactory
+    class LightConfigurationDsl
       TrafficControlDsl: ^(traffic_control | Domain::_TrafficControl) -> Domain::_TrafficControl
     end
   end

data/sig/{_private/stoplight/wiring/light_factory → stoplight/wiring/light_configuration_dsl}/traffic_recovery_dsl.rbs

@@ -1,6 +1,6 @@
 module Stoplight
   module Wiring
-    class LightFactory
+    class LightConfigurationDsl
       TrafficRecoveryDsl: ^(traffic_recovery | Domain::_TrafficRecovery) -> Domain::_TrafficRecovery
     end
   end

data/sig/stoplight/wiring/light_configuration_dsl.rbs

@@ -0,0 +1,38 @@
+module Stoplight
+  module Wiring
+    class LightConfigurationDsl
+      @id: String
+
+      def initialize: (
+        name: _ToS,
+        ?cool_off_time: optional[Domain::duration_seconds],
+        ?threshold: optional[Domain::percentage | Integer],
+        ?recovery_threshold: optional[Integer],
+        ?window_size: optional[Domain::duration_seconds?],
+        ?tracked_errors: optional[Array[Module] | Module],
+        ?skipped_errors: optional[Array[Module] | Module],
+        ?traffic_control: optional[traffic_control],
+        ?traffic_recovery: optional[traffic_recovery],
+      ) -> void
+
+      def configure!: (Domain::Config default_config) -> Domain::Config
+
+      attr_reader digest: Integer
+
+      private
+
+      attr_reader name: String
+      attr_reader cool_off_time: optional[Domain::duration_seconds]
+      attr_reader threshold: optional[Domain::percentage | Integer]
+      attr_reader recovery_threshold: optional[Integer]
+      attr_reader window_size: optional[Domain::duration_seconds?]
+      attr_reader tracked_errors: optional[Array[Module]]
+      attr_reader skipped_errors: optional[Array[Module]]
+      attr_reader traffic_control: optional[Domain::_TrafficControl]
+      attr_reader traffic_recovery: optional[Domain::_TrafficRecovery]
+
+      def calculate_digest: -> Integer
+      def errors_for_digest: (optional[Array[Module]]) -> optional[Array[String]]
+    end
+  end
+end

data/sig/stoplight/wiring/light_factory.rbs

@@ -0,0 +1,78 @@
+module Stoplight
+  module Wiring
+    # Factory protocol for building +Stoplight::Light+ instances.
+    #
+    # This defines the interface that any Light factory must implement,
+    # regardless of the underlying implementation details.
+    #
+    # This uses the Abstract Factory pattern to decouple the domain (Light)
+    # from the application layer (concrete factory implementation). Light
+    # doesn't know HOW it's built, only that it needs something that can
+    # build variants of itself.
+    #
+    # By defining this interface in the domain layer:
+    # - Light can request reconfiguration without knowing about containers
+    # - Different factory implementations can be swapped (code, database-configured, etc.)
+    # - Dependency direction is preserved (Application → Domain, not Domain → Application)
+    #
+    class LightFactory
+      attr_reader data_store_config: Domain::_DataStore
+      attr_reader error_notifier: Domain::error_notifier
+      attr_reader clock: Domain::_Clock
+
+      attr_reader traffic_recovery: Domain::_TrafficRecovery
+      attr_reader traffic_control: Domain::_TrafficControl
+      attr_reader config: Domain::Config
+      attr_reader system_name: String
+
+      @system_id: String
+      @name: String
+      @cool_off_time: Domain::duration_seconds
+      @error_tracking_policy: Domain::ErrorTrackingPolicy
+      @emitter: Domain::Telemetry::Emitter
+      @failover_system: _System?
+      @storage_set: StorageSet
+      @key_space: Infrastructure::Redis::Key
+
+      def initialize: (
+          system_id: String,
+          config: Domain::Config,
+          system_name: String,
+          failover_system: _System?,
+          telemetry: Domain::_TelemetryPublisher
+        ) -> void
+
+      def lock_control: -> Domain::LockControl
+      def storage_set: -> StorageSet
+      def key_space: -> Infrastructure::Redis::Key
+      def state_store: -> Domain::_StateStore
+
+      def metrics_store: -> Domain::_MetricsStore
+      def recovery_lock_store: -> Domain::_RecoveryLockStore
+      def request_tracker: -> Domain::Tracker::Request
+      def recovery_probe_tracker: -> Domain::Tracker::RecoveryProbe
+      def recovery_metrics_store: -> Domain::_MetricsStore
+
+      def green_run_strategy: -> Domain::Strategies::GreenRunStrategy
+      def yellow_run_strategy: -> Domain::Strategies::YellowRunStrategy
+      def red_run_strategy: -> Domain::Strategies::RedRunStrategy
+      def run_recorder: (Domain::color) -> Domain::Telemetry::RunRecorder
+      def telemetry_settings: -> Domain::Telemetry::Settings
+      def redis: -> Infrastructure::redis
+      def storage_scripting: -> Infrastructure::Redis::Storage::Scripting
+      def failover_system: -> _System
+      def build_backend: -> DataStoreBackend
+
+      # Builds a Light instance with the current configuration.
+      #
+      # This method must construct a fully-wired Light with all required
+      # dependencies (strategies, data store, notifiers, etc.). The Light
+      # should be ready to use immediately after construction.
+      #
+      # @raise [Stoplight::Error::ConfigurationError] If configuration is invalid
+      def build: -> Domain::Light
+
+      def create_circuit_breaker: (String) -> Domain::Light
+    end
+  end
+end

data/sig/stoplight/wiring/notifier_bridge.rbs

@@ -0,0 +1,15 @@
+module Stoplight
+  module Wiring
+    class NotifierBridge
+      @notifiers: Array[Domain::_StateTransitionNotifier]
+
+      def initialize: (notifiers: Array[Domain::_StateTransitionNotifier]) -> void
+
+      def subscribe: (Domain::_Telemetry) -> void
+
+      private
+
+      def notify: (Domain::Telemetry::Envelope[Domain::Telemetry::state_transitioned], error: StandardError?) -> void
+    end
+  end
+end

data/sig/stoplight/wiring/notifier_factory.rbs

@@ -0,0 +1,10 @@
+module Stoplight
+  module Wiring
+    class NotifierFactory
+      def self.create: (
+        notifier: Domain::_StateTransitionNotifier,
+        error_notifier: Domain::error_notifier,
+      ) -> Domain::_StateTransitionNotifier
+    end
+  end
+end

data/sig/{_private/stoplight → stoplight}/wiring/redis/backend.rbs

@@ -2,11 +2,11 @@ module Stoplight
   module Wiring
     module Redis
       class Backend < DataStoreBackend
-        @redis: redis
+        @redis: Infrastructure::redis
         @scripting: Infrastructure::Redis::Storage::Scripting
-        @key_space: Infrastructure::Redis::Storage::KeySpace
+        @key_space: Infrastructure::Redis::Key
         @config: Domain::Config
-        @error_notifier: error_notifier
+        @error_notifier: Domain::error_notifier
         @failover_light: Domain::Light
         @clock: Domain::_Clock
 
@@ -18,11 +18,11 @@ module Stoplight
         @unbounded_metrics_store: Infrastructure::FailSafe::Storage::Metrics
 
         def initialize: (
-          redis: redis,
+          redis: Infrastructure::redis,
           scripting: Infrastructure::Redis::Storage::Scripting,
-          key_space: Infrastructure::Redis::Storage::KeySpace,
+          key_space: Infrastructure::Redis::Key,
           config: Domain::Config,
-          error_notifier: error_notifier,
+          error_notifier: Domain::error_notifier,
           failover_light: Domain::Light,
           clock: Domain::_Clock,
           ) -> void

data/sig/stoplight/wiring/system/storage.rbs

@@ -0,0 +1,35 @@
+module Stoplight
+  module Wiring
+    class System
+      class Storage
+        @system_id: String
+        @system_name: String
+        @failover_system: _System
+        @factories: Hash[Domain::Config, LightFactory]
+        @telemetry: Domain::_TelemetryPublisher
+
+        def initialize: (
+            system_id: String,
+            system_name: String,
+            failover_system: _System,
+            telemetry: Domain::_TelemetryPublisher
+          ) -> void
+
+        def state_snapshot: (Domain::Config) -> Domain::StateSnapshot
+        def recovery_metrics_snapshot: (Domain::Config) -> Domain::MetricsSnapshot
+        def metrics_snapshot: (Domain::Config) -> Domain::MetricsSnapshot
+        def delete: (Domain::Config) -> void
+        def lock: (Domain::Config, Domain::color) -> void
+        def unlock: (Domain::Config) -> void
+
+        private
+
+        def state_store: (Domain::Config) -> Domain::_StateStore
+        def recovery_metrics_store: (Domain::Config) -> Domain::_MetricsStore
+        def metrics_store: (Domain::Config) -> Domain::_MetricsStore
+        def lock_control: (Domain::Config) -> Domain::LockControl
+        def light_factory: (Domain::Config) -> LightFactory
+      end
+    end
+  end
+end

data/sig/stoplight/wiring/system.rbs

@@ -0,0 +1,30 @@
+module Stoplight
+  module Wiring
+    class System
+      include _System
+
+      @name: String
+      REGISTRATION_FRAME_LIMIT: Integer
+
+      @lights: Concurrent::Map[String, [Domain::Light, Integer, Array[String]]]
+      @failover_system: _System?
+      @registry: Domain::_Registry
+      @telemetry: Domain::Telemetry::Bus
+      @config: Domain::Config
+
+      def initialize: (
+          config: Domain::Config,
+          failover_system: _System?,
+          registry: Domain::_Registry,
+        ) -> void
+
+      def persistent?: -> bool
+      def __stoplight__storage: -> Storage
+      def __stoplight__registry: -> Domain::_Registry
+
+      private
+
+      def wrapped_notifiers: -> Array[Domain::_StateTransitionNotifier]
+    end
+  end
+end

data/sig/stoplight/wiring/system_configuration_dsl.rbs

@@ -0,0 +1,39 @@
+module Stoplight
+  module Wiring
+    class SystemConfigurationDsl
+      @id: String
+
+      def initialize: (
+        _ToS name,
+        ?cool_off_time: optional[Domain::duration_seconds],
+        ?threshold: optional[Domain::percentage | Integer],
+        ?recovery_threshold: optional[Integer],
+        ?window_size: optional[Domain::duration_seconds?],
+        ?tracked_errors: optional[Array[Module] | Module],
+        ?skipped_errors: optional[Array[Module] | Module],
+        ?data_store: optional[Domain::_DataStore],
+        ?error_notifier: optional[Domain::error_notifier],
+        ?notifiers: optional[Array[Domain::_StateTransitionNotifier]],
+        ?traffic_control: optional[traffic_control],
+        ?traffic_recovery: optional[traffic_recovery],
+      ) -> void
+
+      def configure!: (Domain::Config default_config) -> Domain::Config
+
+      private
+
+      attr_reader name: String
+      attr_reader cool_off_time: optional[Domain::duration_seconds]
+      attr_reader threshold: optional[Domain::percentage | Integer]
+      attr_reader recovery_threshold: optional[Integer]
+      attr_reader window_size: optional[Domain::duration_seconds?]
+      attr_reader data_store: optional[Domain::_DataStore]
+      attr_reader error_notifier: optional[Domain::error_notifier]
+      attr_reader notifiers: optional[Array[Domain::_StateTransitionNotifier]]
+      attr_reader tracked_errors: optional[Array[Module]]
+      attr_reader skipped_errors: optional[Array[Module]]
+      attr_reader traffic_control: optional[Domain::_TrafficControl]
+      attr_reader traffic_recovery: optional[Domain::_TrafficRecovery]
+    end
+  end
+end

data/sig/stoplight/wiring/types.rbs

@@ -0,0 +1,6 @@
+module Stoplight
+  module Wiring
+    type traffic_control = :consecutive_errors | :error_rate
+    type traffic_recovery = :consecutive_successes
+  end
+end

data/sig/stoplight.rbs

@@ -1,66 +1,49 @@
 module Stoplight
-  type optional[T] = Undefined | T
-
-  type timestamp = Float | Integer
-  type redis = ::Redis | ConnectionPool[::Redis]
-
-  # Light Colors
-  type green = "green"
-  type yellow = "yellow"
-  type red = "red"
-  type color = green | yellow | red
-
-  # Light States
-  type unlocked = "unlocked"
-  type locked_green = "locked_green"
-  type locked_red = "locked_red"
-  type state = unlocked | locked_green | locked_red
-
-  # Duration in seconds (1, 23, 0.4, etc.)
-  type duration = Float | Integer
-  # Percentage as decimal (0.0 to 1.0)
-  type percentage = Float
-
-  type error_notifier = ^(StandardError) -> void
-  type traffic_control = :consecutive_errors | :error_rate | {error_rate: {min_requests: Integer}}
-  type traffic_recovery = :consecutive_successes
-  type data_store = DataStore::Redis | DataStore::Memory
-  type state_transition_notifier = _StateTransitionNotifier
-  type notification_formatter = ^(Domain::Config light, color, color, StandardError?) -> String
+  extend _System
+
+  T: singleton(Types)
+  CONFIG_MUTEX: Mutex
+
+  self.@state: Wiring::GlobalState?
+  def self.warn_if_reconfiguring: (bool) { () -> void } -> void
+  def self.configured?: -> bool
+  def self.__stoplight__reset!: -> void
+  def self.ensure_configured: -> void
+  def self.register_system: (
+      _ToS name,
+      ?cool_off_time: optional[Domain::duration_seconds],
+      ?threshold: optional[Domain::percentage | Integer],
+      ?recovery_threshold: optional[Integer],
+      ?window_size: optional[Domain::duration_seconds?],
+      ?tracked_errors: optional[Array[Module]],
+      ?skipped_errors: optional[Array[Module]],
+      ?data_store: optional[Domain::_DataStore],
+      ?error_notifier: optional[Domain::error_notifier],
+      ?notifiers: optional[Array[Domain::_StateTransitionNotifier]],
+      ?traffic_control: optional[Wiring::traffic_control],
+      ?traffic_recovery: optional[Wiring::traffic_recovery],
+    ) -> _System
+  def self.__stoplight__default_configuration: -> Domain::Config
+  def self.__stoplight__default_system: -> Wiring::System
+  def self.state: -> Wiring::GlobalState
 
-  def self.configure: (?trust_me_im_an_engineer: bool) ?{ (_Configuration) -> void } -> void
+  type optional[T] = Undefined | T
 
-  def self.light: (
-      String name,
-      ?cool_off_time: optional[duration],
-      ?threshold: optional[percentage | Integer],
-      ?recovery_threshold: optional[Integer],
-      ?window_size: optional[duration?],
-      ?tracked_errors: optional[Array[_ExceptionMatcher] | _ExceptionMatcher],
-      ?skipped_errors: optional[Array[_ExceptionMatcher] | _ExceptionMatcher],
-      ?data_store: optional[data_store],
-      ?error_notifier: optional[error_notifier],
-      ?notifiers: optional[Array[state_transition_notifier]],
-      ?traffic_control: optional[traffic_control],
-      ?traffic_recovery: optional[traffic_recovery],
-    ) -> _Light
+  def self.configure: (?trust_me_im_an_engineer: bool) ?{ (Wiring::DefaultConfiguration) -> void } -> void
 end
 
 module Kernel
   # For a method usable both as Kernel.Stoplight() and just Stoplight()
   def self?.Stoplight: (
       String name,
-      ?cool_off_time: Stoplight::optional[Stoplight::duration],
-      ?threshold: Stoplight::optional[Stoplight::percentage | Integer],
+      ?cool_off_time: Stoplight::optional[Stoplight::Domain::duration_seconds],
+      ?threshold: Stoplight::optional[Stoplight::Domain::percentage | Integer],
       ?recovery_threshold: Stoplight::optional[Integer],
-      ?window_size: Stoplight::optional[Stoplight::duration?],
-      ?tracked_errors: Stoplight::optional[Array[Stoplight::_ExceptionMatcher] | Stoplight::_ExceptionMatcher],
-      ?skipped_errors: Stoplight::optional[Array[Stoplight::_ExceptionMatcher] | Stoplight::_ExceptionMatcher],
-      ?data_store: Stoplight::optional[Stoplight::data_store],
-      ?error_notifier: Stoplight::optional[Stoplight::error_notifier],
-      ?notifiers: Stoplight::optional[Array[Stoplight::state_transition_notifier]],
-      ?traffic_control: Stoplight::optional[Stoplight::traffic_control],
-      ?traffic_recovery: Stoplight::optional[Stoplight::traffic_recovery],
-  ) -> Stoplight::_Light
+      ?window_size: Stoplight::optional[Stoplight::Domain::duration_seconds?],
+      ?tracked_errors: Stoplight::optional[Array[Module] | Module],
+      ?skipped_errors: Stoplight::optional[Array[Module] | Module],
+      ?traffic_control: Stoplight::optional[Stoplight::Wiring::traffic_control],
+      ?traffic_recovery: Stoplight::optional[Stoplight::Wiring::traffic_recovery],
+  ) -> Stoplight::Domain::Light
 end