kaal 0.5.0 → 0.6.0

data/lib/kaal/config/file_loader.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'erb'
+require 'yaml'
+
+module Kaal
+  module Config
+    # Loads Kaal runtime configuration from config/kaal.yml and KAAL_* env vars.
+    class FileLoader
+      # Normalizes a single environment variable value into the requested config type.
+      class EnvValue
+        def initialize(value)
+          @value = value.to_s.strip
+        end
+
+        def coerce(key:, env_name:)
+          case key
+          when :tick_interval, :window_lookback, :window_lookahead, :lease_ttl, :recovery_window, :recovery_startup_jitter
+            coerce_integer(env_name)
+          when :enable_log_dispatch_registry, :enable_dispatch_recovery
+            coerce_boolean(env_name)
+          when :scheduler_conflict_policy, :scheduler_missing_file_policy
+            @value.to_sym
+          when :delayed_job_allowed_class_prefixes
+            @value.split(',').map(&:strip).reject(&:empty?)
+          else
+            @value
+          end
+        end
+
+        private
+
+        def coerce_boolean(env_name)
+          normalized_value = @value.downcase
+          return true if %w[1 true yes on].include?(normalized_value)
+          return false if %w[0 false no off].include?(normalized_value)
+
+          raise Kaal::ConfigurationError, "ENV #{env_name} must be a boolean"
+        end
+
+        def coerce_integer(env_name)
+          raise Kaal::ConfigurationError, "ENV #{env_name} must be an integer" unless @value.match?(/\A-?\d+\z/)
+
+          @value.to_i
+        end
+      end
+
+      ENV_KEY_MAP = {
+        'KAAL_BACKEND' => :backend,
+        'KAAL_NAMESPACE' => :namespace,
+        'KAAL_TICK_INTERVAL' => :tick_interval,
+        'KAAL_WINDOW_LOOKBACK' => :window_lookback,
+        'KAAL_WINDOW_LOOKAHEAD' => :window_lookahead,
+        'KAAL_LEASE_TTL' => :lease_ttl,
+        'KAAL_SCHEDULER_CONFIG_PATH' => :scheduler_config_path,
+        'KAAL_ENABLE_LOG_DISPATCH_REGISTRY' => :enable_log_dispatch_registry,
+        'KAAL_ENABLE_DISPATCH_RECOVERY' => :enable_dispatch_recovery,
+        'KAAL_RECOVERY_WINDOW' => :recovery_window,
+        'KAAL_RECOVERY_STARTUP_JITTER' => :recovery_startup_jitter,
+        'KAAL_TIME_ZONE' => :time_zone,
+        'KAAL_SCHEDULER_CONFLICT_POLICY' => :scheduler_conflict_policy,
+        'KAAL_SCHEDULER_MISSING_FILE_POLICY' => :scheduler_missing_file_policy,
+        'KAAL_DELAYED_JOB_ALLOWED_CLASS_PREFIXES' => :delayed_job_allowed_class_prefixes
+      }.freeze
+      CONFIG_KEY_TO_ENV_KEY = ENV_KEY_MAP.invert.freeze
+      CONFIGURATION_ASSIGNERS = {
+        namespace: ->(config, value) { config.namespace = value },
+        tick_interval: ->(config, value) { config.tick_interval = value },
+        window_lookback: ->(config, value) { config.window_lookback = value },
+        window_lookahead: ->(config, value) { config.window_lookahead = value },
+        lease_ttl: ->(config, value) { config.lease_ttl = value },
+        scheduler_config_path: ->(config, value) { config.scheduler_config_path = value },
+        enable_log_dispatch_registry: ->(config, value) { config.enable_log_dispatch_registry = value },
+        enable_dispatch_recovery: ->(config, value) { config.enable_dispatch_recovery = value },
+        recovery_window: ->(config, value) { config.recovery_window = value },
+        recovery_startup_jitter: ->(config, value) { config.recovery_startup_jitter = value },
+        time_zone: ->(config, value) { config.time_zone = value },
+        scheduler_conflict_policy: ->(config, value) { config.scheduler_conflict_policy = value },
+        scheduler_missing_file_policy: ->(config, value) { config.scheduler_missing_file_policy = value },
+        delayed_job_allowed_class_prefixes: ->(config, value) { config.delayed_job_allowed_class_prefixes = value },
+        logger: ->(config, value) { config.logger = value }
+      }.freeze
+
+      def initialize(configuration:, runtime_context:, env: ENV)
+        @configuration = configuration
+        @runtime_context = runtime_context
+        @env = env
+        @config_key_to_env_key = CONFIG_KEY_TO_ENV_KEY
+      end
+
+      def load(path: 'config/kaal.yml')
+        absolute_path = @runtime_context.resolve_path(path)
+        payload = File.exist?(absolute_path) ? parse_yaml(absolute_path) : {}
+        merged = merge_environment_config(payload)
+        merged = apply_env_overrides(merged)
+        apply_configuration(merged)
+        @configuration.validate!
+        @configuration
+      end
+
+      private
+
+      def parse_yaml(path)
+        rendered = render_yaml(path)
+        parsed = YAML.safe_load(rendered, aliases: true) || {}
+        raise Kaal::ConfigurationError, "Expected Kaal config YAML root to be a mapping in #{path}" unless parsed.is_a?(Hash)
+
+        Kaal::Support::HashTools.stringify_keys(parsed)
+      rescue Psych::Exception => e
+        raise Kaal::ConfigurationError, "Failed to parse Kaal config YAML at #{path}: #{e.message}"
+      end
+
+      def render_yaml(path)
+        ERB.new(File.read(path), trim_mode: '-').result
+      rescue StandardError, SyntaxError => e
+        raise Kaal::ConfigurationError, "Failed to evaluate Kaal config ERB at #{path}: #{e.message}"
+      end
+
+      def merge_environment_config(payload)
+        defaults = hash_section(payload['defaults'])
+        environment = hash_section(payload[@runtime_context.environment_name])
+
+        Kaal::Support::HashTools.deep_merge(defaults, environment)
+      end
+
+      def hash_section(value)
+        case value
+        in Hash
+          Kaal::Support::HashTools.stringify_keys(Kaal::Support::HashTools.deep_dup(value))
+        in nil
+          {}
+        else
+          raise Kaal::ConfigurationError, 'Kaal config sections must be mappings'
+        end
+      end
+
+      def apply_env_overrides(config)
+        merged = Kaal::Support::HashTools.deep_dup(config)
+
+        ENV_KEY_MAP.each do |env_key, config_key|
+          next unless @env.key?(env_key)
+
+          merged[config_key.to_s] = coerce_env_value(config_key, @env.fetch(env_key))
+        end
+
+        backend_url = @env['KAAL_BACKEND_URL']&.to_s&.strip
+        if @env.key?('KAAL_BACKEND_URL')
+          backend_config = hash_section(merged['backend_config'])
+          if backend_config.key?('connection')
+            backend_config['connection'] = backend_url
+          else
+            backend_config['url'] = backend_url
+          end
+          merged['backend_config'] = backend_config
+        end
+
+        merged
+      end
+
+      def coerce_env_value(key, value)
+        EnvValue.new(value).coerce(key:, env_name: @config_key_to_env_key.fetch(key))
+      end
+
+      def apply_configuration(config)
+        normalized = Kaal::Support::HashTools.symbolize_keys(config)
+        backend_config = normalized.delete(:backend_config) || {}
+        backend_name = normalized.delete(:backend)
+        @configuration.apply_backend_runtime_context(@runtime_context)
+
+        normalized.each do |key, value|
+          apply_configuration_value(key, value)
+        end
+
+        @configuration.backend_config = backend_config
+        @configuration.backend = backend_name if backend_name
+      end
+
+      def apply_configuration_value(key, value)
+        CONFIGURATION_ASSIGNERS[key]&.call(@configuration, value)
+      end
+    end
+  end
+end

data/lib/kaal/config.rb

@@ -5,7 +5,9 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 require 'kaal/config/configuration'
+require 'kaal/config/backend_factory'
 require 'kaal/config/delayed_job_security_policy'
+require 'kaal/config/file_loader'
 require 'kaal/config/scheduler_config_error'
 require 'kaal/config/scheduler_time_zone_resolver'
 

data/lib/kaal/runtime/scheduler_boot_loader.rb

@@ -5,7 +5,7 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 module Kaal
-  # Loads scheduler.yml at framework boot time while respecting missing-file policy.
+  # Loads kaal-scheduler.yml at framework boot time while respecting missing-file policy.
   class SchedulerBootLoader
     def initialize(configuration_provider:, logger:, runtime_context:, load_scheduler_file:)
       @configuration_provider = configuration_provider

data/lib/kaal/scheduler_file/loader.rb

@@ -14,7 +14,7 @@ require_relative 'job_normalizer'
 require_relative 'job_applier'
 
 module Kaal
-  # Loads scheduler definitions from config/scheduler.yml and registers them.
+  # Loads scheduler definitions from config/kaal-scheduler.yml and registers them.
   class SchedulerFileLoader
     include SchedulerHashTransform
     include SchedulerPlaceholderSupport

data/lib/kaal/version.rb

@@ -5,5 +5,5 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 module Kaal
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/kaal.rb

@@ -88,6 +88,13 @@ module Kaal
       yield(configuration) if block_given?
     end
 
+    def load_config_file!(path: 'config/kaal.yml', runtime_context: RuntimeContext.default)
+      Config::FileLoader.new(
+        configuration: configuration,
+        runtime_context:
+      ).load(path:)
+    end
+
     def register(key:, cron:, enqueue:)
       registration_service.call(key:, cron:, enqueue:)
     end

data/sig/00_types.rbs

@@ -0,0 +1,12 @@
+module Kaal
+  interface _RBSOpaque
+  end
+
+  interface _RBSCallable
+    def call: (*rbs_any args, **rbs_any kwargs) -> rbs_any
+  end
+
+  type rbs_scalar = nil | bool | Integer | Float | Rational | String | Symbol | Time
+  type rbs_hash_key = String | Symbol | Integer
+  type rbs_any = rbs_scalar | _RBSOpaque | _RBSCallable | Array[rbs_any] | Hash[rbs_hash_key, rbs_any]
+end

data/sig/dependencies.rbs

@@ -0,0 +1,49 @@
+class Thor
+  class Error < StandardError
+  end
+
+  class Base
+    module Shell
+      def self.new: () -> Kaal::_RBSOpaque
+    end
+
+    def self.shell: () -> singleton(Shell)
+  end
+
+  def self.package_name: (String name) -> void
+  def self.class_option: (*Kaal::rbs_any args, **Kaal::rbs_any kwargs) -> void
+  def self.desc: (String usage, String description) -> void
+  def self.option: (*Kaal::rbs_any args, **Kaal::rbs_any kwargs) -> void
+  def self.no_commands: () { () -> Kaal::rbs_any } -> void
+end
+
+class Redis
+  def initialize: (*Kaal::rbs_any args, **Kaal::rbs_any kwargs) -> void
+end
+
+module Sequel
+  class Database
+    def connection: () -> Kaal::_RBSOpaque
+    def database_type: () -> String
+    def adapter_scheme: () -> String
+  end
+
+  def self.connect: (*Kaal::rbs_any args, **Kaal::rbs_any kwargs) -> Database
+end
+
+module ActiveSupport
+  module Inflector
+    def self.underscore: (String value) -> String
+  end
+end
+
+module ActiveRecord
+  class ConnectionNotEstablished < StandardError
+  end
+
+  class RecordNotUnique < StandardError
+  end
+
+  class Base
+  end
+end

data/sig/kaal/active_record_support.rbs

@@ -0,0 +1,23 @@
+module Kaal
+  module ActiveRecord
+    def self.install_postgres_migration: (target_dir: Kaal::rbs_any, ?migration_name: ::String) -> Kaal::rbs_any
+
+    def self.install_mysql_migration: (target_dir: Kaal::rbs_any, ?migration_name: ::String) -> Kaal::rbs_any
+
+    def self.install_sqlite_migration: (target_dir: Kaal::rbs_any, ?migration_name: ::String) -> Kaal::rbs_any
+
+    def self.install_migrations: (target_dir: Kaal::rbs_any, backend: Kaal::rbs_any, ?migration_name: Kaal::rbs_any?, ?time_source: Kaal::rbs_any) -> Kaal::rbs_any
+
+    def self.require_activerecord!: () -> Kaal::rbs_any
+
+    def self.normalize_migration_name: (Kaal::rbs_any name, fallback: Kaal::rbs_any) -> Kaal::rbs_any
+
+    def self.underscore: (Kaal::rbs_any value) -> Kaal::rbs_any
+
+    def self.default_migration_class_for: (Kaal::rbs_any backend) -> ::String
+
+    def self.migration_suffixes_for: (Kaal::rbs_any backend) -> (::Array["dispatches" | "locks" | "definitions" | "delayed_jobs"] | ::Array["dispatches" | "definitions" | "delayed_jobs"])
+
+    def self.alphanumeric?: (Kaal::rbs_any char) -> Kaal::rbs_any
+  end
+end

data/sig/kaal/backend/adapter.rbs

@@ -0,0 +1,26 @@
+module Kaal
+  module Backend
+    class Adapter
+      def acquire: (Kaal::rbs_any _key, Kaal::rbs_any _ttl) -> Kaal::rbs_any
+
+      def release: (Kaal::rbs_any _key) -> Kaal::rbs_any
+
+      def with_lock: (Kaal::rbs_any key, ttl: Kaal::rbs_any) { () -> Kaal::rbs_any } -> (nil | Kaal::rbs_any)
+
+      def definition_registry: () -> nil
+
+      def delayed_store: () -> nil
+    end
+
+    class NullAdapter < Adapter
+      def acquire: (Kaal::rbs_any _key, Kaal::rbs_any _ttl) -> true
+
+      def release: (Kaal::rbs_any _key) -> true
+
+      def with_lock: (Kaal::rbs_any _key, **Kaal::rbs_any) { () -> Kaal::rbs_any } -> Kaal::rbs_any
+    end
+
+    class LockAdapterError < StandardError
+    end
+  end
+end

data/sig/kaal/backend/dispatch_attempt_logger.rbs

@@ -0,0 +1,17 @@
+module Kaal
+  module Backend
+    class DispatchAttemptLogger
+      @configuration: Kaal::rbs_any
+
+      @dispatch_registry_provider: Kaal::rbs_any
+
+      @logger: Kaal::rbs_any
+
+      @node_id_provider: Kaal::rbs_any
+
+      def initialize: (configuration: Kaal::rbs_any, dispatch_registry_provider: Kaal::rbs_any, ?logger: Kaal::rbs_any?, ?node_id_provider: Kaal::rbs_any) -> void
+
+      def call: (Kaal::rbs_any lock_key) -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/backend/dispatch_logging.rbs

@@ -0,0 +1,23 @@
+module Kaal
+  module Backend
+    module DispatchLogging
+      @dispatch_attempt_logger: Kaal::rbs_any
+
+      def dispatch_registry: () -> nil
+
+      def log_dispatch_attempt: (Kaal::rbs_any key) -> Kaal::rbs_any
+
+      def parse_lock_key: (Kaal::rbs_any key) -> Kaal::rbs_any
+
+      def self.parse_lock_key: (Kaal::rbs_any key) -> ::Array[Kaal::rbs_any]
+
+      def self.validate_lock_key!: (Kaal::rbs_any valid, Kaal::rbs_any message) -> (Kaal::rbs_any | nil)
+
+      def self.invalid_dispatch_lock_key!: (Kaal::rbs_any message) -> Kaal::rbs_any
+
+      private
+
+      def dispatch_attempt_logger: () -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/backend/dispatch_registry_accessor.rbs

@@ -0,0 +1,17 @@
+module Kaal
+  module Backend
+    class DispatchRegistryAccessor
+      @configuration: Kaal::rbs_any
+
+      def initialize: (configuration: Kaal::rbs_any) -> void
+
+      def dispatched?: (Kaal::rbs_any key, Kaal::rbs_any fire_time) -> Kaal::rbs_any
+
+      def registry: () -> Kaal::rbs_any
+
+      private
+
+      def fetch_registry: () -> (nil | Kaal::rbs_any)
+    end
+  end
+end

data/sig/kaal/backend/memory_adapter.rbs

@@ -0,0 +1,33 @@
+module Kaal
+  module Backend
+    class MemoryAdapter < Adapter
+      @locks: Kaal::rbs_any
+
+      @mutex: Kaal::rbs_any
+
+      @dispatch_registry: Kaal::rbs_any
+
+      @definition_registry: Kaal::rbs_any
+
+      @delayed_store: Kaal::rbs_any
+
+      include DispatchLogging
+
+      def initialize: () -> void
+
+      def dispatch_registry: () -> Kaal::rbs_any
+
+      def definition_registry: () -> Kaal::rbs_any
+
+      def delayed_store: () -> Kaal::rbs_any
+
+      def acquire: (Kaal::rbs_any key, Kaal::rbs_any ttl) -> Kaal::rbs_any
+
+      def release: (Kaal::rbs_any key) -> Kaal::rbs_any
+
+      private
+
+      def prune_expired_locks: () -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/backend/mysql.rbs

@@ -0,0 +1,25 @@
+module Kaal
+  module Backend
+    class MySQL < Adapter
+      @engine: Kaal::rbs_any
+
+      UNSET_SKIP_LOCKED_SUPPORT: Kaal::rbs_any
+
+      def initialize: (?database: Kaal::rbs_any?, ?connection: Kaal::rbs_any?, ?namespace: Kaal::rbs_any?, ?use_skip_locked: Kaal::rbs_any) -> void
+
+      def dispatch_registry: () -> Kaal::rbs_any
+
+      def definition_registry: () -> Kaal::rbs_any
+
+      def delayed_store: () -> Kaal::rbs_any
+
+      def acquire: (Kaal::rbs_any key, Kaal::rbs_any ttl) -> Kaal::rbs_any
+
+      def release: (Kaal::rbs_any key) -> Kaal::rbs_any
+
+      def self.build_sequel_backend: (Kaal::rbs_any database, Kaal::rbs_any namespace, Kaal::rbs_any use_skip_locked) -> Kaal::rbs_any
+
+      def self.build_active_record_backend: (Kaal::rbs_any connection, Kaal::rbs_any namespace, Kaal::rbs_any use_skip_locked) -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/backend/postgres.rbs

@@ -0,0 +1,19 @@
+module Kaal
+  module Backend
+    class Postgres < Adapter
+      @engine: Kaal::rbs_any
+
+      def initialize: (?database: Kaal::rbs_any?, ?connection: Kaal::rbs_any?, ?namespace: Kaal::rbs_any?) -> void
+
+      def dispatch_registry: () -> Kaal::rbs_any
+
+      def definition_registry: () -> Kaal::rbs_any
+
+      def delayed_store: () -> Kaal::rbs_any
+
+      def acquire: (Kaal::rbs_any key, Kaal::rbs_any ttl) -> Kaal::rbs_any
+
+      def release: (Kaal::rbs_any key) -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/backend/redis_adapter.rbs

@@ -0,0 +1,41 @@
+module Kaal
+  module Backend
+    class RedisAdapter < Adapter
+      @redis: Kaal::rbs_any
+
+      @namespace: Kaal::rbs_any
+
+      @lock_value_generator: Kaal::rbs_any
+
+      @lock_values: Kaal::rbs_any
+
+      @mutex: Kaal::rbs_any
+
+      @dispatch_registry: Kaal::rbs_any
+
+      @definition_registry: Kaal::rbs_any
+
+      @delayed_store: Kaal::rbs_any
+
+      include DispatchLogging
+
+      def initialize: (Kaal::rbs_any redis, ?namespace: ::String) -> void
+
+      def dispatch_registry: () -> Kaal::rbs_any
+
+      def definition_registry: () -> Kaal::rbs_any
+
+      def delayed_store: () -> Kaal::rbs_any
+
+      def acquire: (Kaal::rbs_any key, Kaal::rbs_any ttl) -> Kaal::rbs_any
+
+      def release: (Kaal::rbs_any key) -> Kaal::rbs_any
+
+      private
+
+      def generate_lock_value: () -> Kaal::rbs_any
+
+      def prune_expired_lock_values: () -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/backend/sqlite.rbs

@@ -0,0 +1,19 @@
+module Kaal
+  module Backend
+    class SQLite < Adapter
+      @engine: Kaal::rbs_any
+
+      def initialize: (?database: Kaal::rbs_any?, ?connection: Kaal::rbs_any?, ?namespace: Kaal::rbs_any?, **Kaal::rbs_any) -> void
+
+      def dispatch_registry: () -> Kaal::rbs_any
+
+      def definition_registry: () -> Kaal::rbs_any
+
+      def delayed_store: () -> Kaal::rbs_any
+
+      def acquire: (Kaal::rbs_any key, Kaal::rbs_any ttl) -> Kaal::rbs_any
+
+      def release: (Kaal::rbs_any key) -> Kaal::rbs_any
+    end
+  end
+end

data/sig/kaal/cli.rbs

@@ -0,0 +1,41 @@
+module Kaal
+  class CLI < Thor
+    module Helpers
+      private
+
+      def load_project!: () -> Kaal::rbs_any
+
+      def root_path: () -> Kaal::rbs_any
+
+      def config_path: () -> Kaal::rbs_any
+
+      def scheduler_path: () -> Kaal::rbs_any
+
+      def render_config_template: (Kaal::rbs_any backend) -> Kaal::rbs_any
+
+      def scheduler_template: () -> "defaults:\n  jobs:\n    - key: \"example:heartbeat\"\n      cron: \"*/5 * * * *\"\n      job_class: \"ExampleHeartbeatJob\"\n      enabled: true\n      args:\n        - \"{{fire_time.iso8601}}\"\n      kwargs:\n        idempotency_key: \"{{idempotency_key}}\"\n      metadata:\n        owner: \"ops\"\n"
+    end
+
+    def init: () -> Kaal::rbs_any
+
+    def start: () -> Kaal::rbs_any
+
+    def status: () -> Kaal::rbs_any
+
+    def tick: () -> Kaal::rbs_any
+
+    def explain: (Kaal::rbs_any expression) -> Kaal::rbs_any
+
+    def next: (Kaal::rbs_any expression) -> Kaal::rbs_any
+
+    def self.exit_on_failure?: () -> true
+
+    def self.write_file: (Kaal::rbs_any path, Kaal::rbs_any contents) -> (nil | Kaal::rbs_any)
+
+    def self.install_foreground_signal_handlers: (Kaal::rbs_any signal_state) -> Kaal::rbs_any
+
+    def self.restore_signal_handlers: (Kaal::rbs_any previous_handlers) -> Kaal::rbs_any
+
+    def self.shutdown_scheduler: (signal: Kaal::rbs_any, signal_state: Kaal::rbs_any, ?previous_handler: Kaal::rbs_any?, ?shell: Kaal::rbs_any?) -> Kaal::rbs_any
+  end
+end

data/sig/kaal/config/backend_factory.rbs

@@ -0,0 +1,41 @@
+module Kaal
+  module Config
+    module BackendFactory
+      SUPPORTED_BACKENDS: ::Array["memory" | "redis" | "sqlite" | "postgres" | "mysql"]
+
+      def self.normalize_name: (Kaal::rbs_any name) -> (nil | Kaal::rbs_any)
+
+      def self.build: (Kaal::rbs_any name, backend_config: Kaal::rbs_any, namespace: Kaal::rbs_any, ?runtime_context: Kaal::rbs_any?) -> Kaal::rbs_any
+
+      def self.normalize_backend_config: (Kaal::rbs_any backend_config) -> Kaal::rbs_any
+
+      def self.build_redis_backend: (Kaal::rbs_any config, Kaal::rbs_any namespace) -> Kaal::rbs_any
+
+      def self.build_sqlite_backend: (Kaal::rbs_any config, Kaal::rbs_any namespace, Kaal::rbs_any runtime_context) -> Kaal::rbs_any
+
+      def self.build_postgres_backend: (Kaal::rbs_any config, Kaal::rbs_any namespace) -> Kaal::rbs_any
+
+      def self.build_mysql_backend: (Kaal::rbs_any config, Kaal::rbs_any namespace) -> Kaal::rbs_any
+
+      def self.build_sqlite_connection: (Kaal::rbs_any connection, Kaal::rbs_any runtime_context) -> Kaal::rbs_any
+
+      def self.normalize_connection_hash: (Kaal::rbs_any connection, Kaal::rbs_any default_adapter, Kaal::rbs_any runtime_context) -> Kaal::rbs_any
+
+      def self.resolve_sqlite_database_path: (Kaal::rbs_any database, Kaal::rbs_any runtime_context) -> Kaal::rbs_any
+
+      def self.sqlite_uri?: (Kaal::rbs_any value) -> Kaal::rbs_any
+
+      def self.sequel_sqlite_database: (Kaal::rbs_any target, Kaal::rbs_any runtime_context) -> Kaal::rbs_any
+
+      def self.ensure_sqlite_directory!: (Kaal::rbs_any database_path) -> Kaal::rbs_any
+
+      def self.adapter_name_for_error: (Kaal::rbs_any adapter) -> ("postgres" | "mysql")
+
+      def self.string_value: (Kaal::rbs_any value) -> Kaal::rbs_any
+
+      def self.require_redis!: () -> Kaal::rbs_any
+
+      def self.require_sequel!: () -> Kaal::rbs_any
+    end
+  end
+end