whoosh 1.0.1

data/lib/whoosh/dependency_injection.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Whoosh
+  class DependencyInjection
+    def initialize
+      @providers = {}
+      @singletons = {}
+      @mutex = Mutex.new
+    end
+
+    def provide(name, scope: :singleton, &block)
+      @providers[name] = { block: block, scope: scope }
+      @singletons.delete(name) # Clear cached value on re-register
+    end
+
+    def resolve(name, request: nil, resolving: [])
+      provider = @providers[name]
+      raise Errors::DependencyError, "Unknown dependency: #{name}" unless provider
+
+      if resolving.include?(name)
+        raise Errors::DependencyError, "Circular dependency detected: #{(resolving + [name]).join(' -> ')}"
+      end
+
+      case provider[:scope]
+      when :singleton
+        # Check cache without lock first (double-checked locking pattern)
+        return @singletons[name] if @singletons.key?(name)
+
+        # Compute outside the lock to allow recursive singleton resolution
+        value = call_provider(provider[:block], request: request, resolving: resolving + [name])
+        @mutex.synchronize { @singletons[name] ||= value }
+        @singletons[name]
+      when :request
+        call_provider(provider[:block], request: request, resolving: resolving + [name])
+      end
+    end
+
+    def inject_for(names, request: nil)
+      names.each_with_object({}) do |name, hash|
+        hash[name] = resolve(name, request: request)
+      end
+    end
+
+    def validate!
+      # Topological sort to detect circular deps and unknown refs at boot
+      visited = {}
+      sorted = []
+
+      visit = ->(name, path) do
+        return if visited[name] == :done
+        raise Errors::DependencyError, "Circular dependency detected: #{(path + [name]).join(' -> ')}" if visited[name] == :visiting
+
+        provider = @providers[name]
+        raise Errors::DependencyError, "Unknown dependency: #{name} (referenced by #{path.last})" unless provider
+
+        visited[name] = :visiting
+        deps = extract_deps(provider[:block])
+        deps.each { |dep| visit.call(dep, path + [name]) }
+        visited[name] = :done
+        sorted << name
+      end
+
+      @providers.each_key { |name| visit.call(name, []) unless visited[name] }
+      sorted
+    end
+
+    def registered?(name)
+      @providers.key?(name)
+    end
+
+    def close_all
+      @singletons.each_value do |instance|
+        instance.close if instance.respond_to?(:close)
+      end
+      @singletons.clear
+    end
+
+    private
+
+    def extract_deps(block)
+      block.parameters
+        .select { |type, _| type == :keyreq || type == :key }
+        .map(&:last)
+    end
+
+    def call_provider(block, request: nil, resolving: [])
+      # Inspect block parameters to determine what to inject
+      params = block.parameters
+      kwargs = params.select { |type, _| type == :keyreq || type == :key }.map(&:last)
+
+      if kwargs.any?
+        deps = kwargs.each_with_object({}) do |dep_name, hash|
+          hash[dep_name] = resolve(dep_name, request: request, resolving: resolving)
+        end
+        block.call(**deps)
+      elsif params.any? { |type, _| type == :req || type == :opt }
+        block.call(request)
+      else
+        block.call
+      end
+    end
+  end
+end

data/lib/whoosh/endpoint.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Whoosh
+  class Endpoint
+    class Context
+      attr_reader :request
+
+      def initialize(app, request)
+        @app = app
+        @request = request
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @app.respond_to?(method_name, include_private) || super
+      end
+
+      private
+
+      def method_missing(method_name, ...)
+        if @app.respond_to?(method_name)
+          @app.send(method_name, ...)
+        else
+          super
+        end
+      end
+    end
+
+    class << self
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@declared_routes, [])
+      end
+
+      def declared_routes
+        @declared_routes
+      end
+
+      def get(path, **opts)
+        declare_route("GET", path, **opts)
+      end
+
+      def post(path, **opts)
+        declare_route("POST", path, **opts)
+      end
+
+      def put(path, **opts)
+        declare_route("PUT", path, **opts)
+      end
+
+      def patch(path, **opts)
+        declare_route("PATCH", path, **opts)
+      end
+
+      def delete(path, **opts)
+        declare_route("DELETE", path, **opts)
+      end
+
+      def options(path, **opts)
+        declare_route("OPTIONS", path, **opts)
+      end
+
+      private
+
+      def declare_route(method, path, request: nil, response: nil, **metadata)
+        @declared_routes << {
+          method: method,
+          path: path,
+          request_schema: request,
+          response_schema: response,
+          metadata: metadata
+        }
+      end
+    end
+
+    def call(req)
+      raise NotImplementedError, "#{self.class}#call must be implemented"
+    end
+  end
+end

data/lib/whoosh/env_loader.rb

@@ -0,0 +1,46 @@
+# lib/whoosh/env_loader.rb
+# frozen_string_literal: true
+
+module Whoosh
+  module EnvLoader
+    def self.load(root)
+      path = File.join(root, ".env")
+      return unless File.exist?(path)
+
+      if dotenv_available?
+        require "dotenv"
+        Dotenv.load(path)
+        return
+      end
+
+      parse(File.read(path)).each do |key, value|
+        ENV[key] ||= value
+      end
+    end
+
+    def self.parse(content)
+      pairs = {}
+      content.each_line do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+        key, value = line.split("=", 2)
+        next unless key && value
+        key = key.strip
+        value = value.strip
+        if (value.start_with?('"') && value.end_with?('"')) ||
+           (value.start_with?("'") && value.end_with?("'"))
+          value = value[1..-2]
+        end
+        pairs[key] = value
+      end
+      pairs
+    end
+
+    def self.dotenv_available?
+      require "dotenv"
+      true
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/whoosh/errors.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Whoosh
+  module Errors
+    class WhooshError < StandardError; end
+
+    class HttpError < WhooshError
+      attr_reader :status, :error_type
+
+      def initialize(message = nil, status: 500, error_type: "internal_error")
+        @status = status
+        @error_type = error_type
+        super(message || error_type)
+      end
+
+      def to_h
+        { error: error_type }
+      end
+    end
+
+    class ValidationError < HttpError
+      attr_reader :details
+
+      def initialize(details = [])
+        @details = details
+        super("Validation failed", status: 422, error_type: "validation_failed")
+      end
+
+      def to_h
+        { error: error_type, details: details }
+      end
+    end
+
+    class NotFoundError < HttpError
+      def initialize(message = "Not found")
+        super(message, status: 404, error_type: "not_found")
+      end
+    end
+
+    class UnauthorizedError < HttpError
+      def initialize(message = "Unauthorized")
+        super(message, status: 401, error_type: "unauthorized")
+      end
+    end
+
+    class ForbiddenError < HttpError
+      def initialize(message = "Forbidden")
+        super(message, status: 403, error_type: "forbidden")
+      end
+    end
+
+    class RateLimitExceeded < HttpError
+      attr_reader :retry_after
+
+      def initialize(message = "Rate limit exceeded", retry_after: 60)
+        @retry_after = retry_after
+        super(message, status: 429, error_type: "rate_limited")
+      end
+
+      def to_h
+        super.merge(retry_after: retry_after)
+      end
+    end
+
+    class DependencyError < WhooshError; end
+    class GuardrailsViolation < WhooshError; end
+  end
+end

data/lib/whoosh/http/response.rb

@@ -0,0 +1,26 @@
+# lib/whoosh/http/response.rb
+# frozen_string_literal: true
+
+require "json"
+
+module Whoosh
+  module HTTP
+    class Response
+      attr_reader :status, :body, :headers
+
+      def initialize(status:, body:, headers: {})
+        @status = status
+        @body = body
+        @headers = headers
+      end
+
+      def json
+        @json ||= JSON.parse(@body)
+      end
+
+      def ok?
+        @status >= 200 && @status < 300
+      end
+    end
+  end
+end

data/lib/whoosh/http.rb

@@ -0,0 +1,73 @@
+# lib/whoosh/http.rb
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Whoosh
+  module HTTP
+    autoload :Response, "whoosh/http/response"
+
+    class TimeoutError < Errors::WhooshError; end
+    class ConnectionError < Errors::WhooshError; end
+
+    class << self
+      def get(url, headers: {}, timeout: 30)
+        request(:get, url, headers: headers, timeout: timeout)
+      end
+
+      def post(url, json: nil, body: nil, headers: {}, timeout: 30)
+        request(:post, url, json: json, body: body, headers: headers, timeout: timeout)
+      end
+
+      def put(url, json: nil, body: nil, headers: {}, timeout: 30)
+        request(:put, url, json: json, body: body, headers: headers, timeout: timeout)
+      end
+
+      def patch(url, json: nil, body: nil, headers: {}, timeout: 30)
+        request(:patch, url, json: json, body: body, headers: headers, timeout: timeout)
+      end
+
+      def delete(url, headers: {}, timeout: 30)
+        request(:delete, url, headers: headers, timeout: timeout)
+      end
+
+      private
+
+      def request(method, url, json: nil, body: nil, headers: {}, timeout: 30)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+
+        request_body = json ? JSON.generate(json) : body
+        headers = { "Content-Type" => "application/json" }.merge(headers) if json
+
+        req = build_net_request(method, uri, headers)
+        req.body = request_body if request_body
+
+        response = http.request(req)
+        Response.new(status: response.code.to_i, body: response.body || "", headers: response.each_header.to_h)
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise TimeoutError, e.message
+      rescue Errno::ECONNREFUSED, SocketError, Errno::EHOSTUNREACH => e
+        raise ConnectionError, e.message
+      end
+
+      def build_net_request(method, uri, headers)
+        path = uri.request_uri
+        req = case method
+        when :get then Net::HTTP::Get.new(path)
+        when :post then Net::HTTP::Post.new(path)
+        when :put then Net::HTTP::Put.new(path)
+        when :patch then Net::HTTP::Patch.new(path)
+        when :delete then Net::HTTP::Delete.new(path)
+        end
+        headers.each { |k, v| req[k] = v }
+        req
+      end
+    end
+  end
+end

data/lib/whoosh/instrumentation.rb

@@ -0,0 +1,22 @@
+# lib/whoosh/instrumentation.rb
+# frozen_string_literal: true
+
+module Whoosh
+  class Instrumentation
+    def initialize
+      @subscribers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def on(event, &block)
+      @subscribers[event] << block
+    end
+
+    def emit(event, data = {})
+      @subscribers[event].each do |subscriber|
+        subscriber.call(data)
+      rescue => e
+        # Don't let subscriber errors crash the app
+      end
+    end
+  end
+end

data/lib/whoosh/job.rb

@@ -0,0 +1,24 @@
+# lib/whoosh/job.rb
+# frozen_string_literal: true
+
+module Whoosh
+  class Job
+    class << self
+      def inject(*names)
+        @dependencies = names
+      end
+
+      def dependencies
+        @dependencies || []
+      end
+
+      def perform_async(**args)
+        Jobs.enqueue(self, **args)
+      end
+    end
+
+    def perform(**args)
+      raise NotImplementedError, "#{self.class}#perform must be implemented"
+    end
+  end
+end

data/lib/whoosh/jobs/memory_backend.rb

@@ -0,0 +1,45 @@
+# lib/whoosh/jobs/memory_backend.rb
+# frozen_string_literal: true
+
+module Whoosh
+  module Jobs
+    class MemoryBackend
+      def initialize
+        @queue = []
+        @records = {}
+        @mutex = Mutex.new
+        @cv = ConditionVariable.new
+      end
+
+      def push(job_data)
+        @mutex.synchronize do
+          @queue << job_data
+          @cv.signal
+        end
+      end
+
+      def pop(timeout: 5)
+        @mutex.synchronize do
+          @cv.wait(@mutex, timeout) if @queue.empty?
+          @queue.shift
+        end
+      end
+
+      def save(record)
+        @mutex.synchronize { @records[record[:id]] = record }
+      end
+
+      def find(id)
+        @mutex.synchronize { @records[id]&.dup }
+      end
+
+      def size
+        @mutex.synchronize { @queue.size }
+      end
+
+      def shutdown
+        @mutex.synchronize { @cv.broadcast }
+      end
+    end
+  end
+end

data/lib/whoosh/jobs/worker.rb

@@ -0,0 +1,73 @@
+# lib/whoosh/jobs/worker.rb
+# frozen_string_literal: true
+
+module Whoosh
+  module Jobs
+    class Worker
+      def initialize(backend:, di: nil, max_retries: 3, retry_delay: 5, instrumentation: nil)
+        @backend = backend
+        @di = di
+        @max_retries = max_retries
+        @retry_delay = retry_delay
+        @instrumentation = instrumentation
+        @running = true
+      end
+
+      def run_once(timeout: 5)
+        job_data = @backend.pop(timeout: timeout)
+        return unless job_data
+        execute(job_data)
+      end
+
+      def run_loop
+        while @running
+          run_once
+        end
+      end
+
+      def stop
+        @running = false
+      end
+
+      private
+
+      def execute(job_data)
+        id = job_data[:id]
+        record = @backend.find(id) || {}
+        record = record.merge(status: :running, started_at: Time.now.to_f)
+        @backend.save(record)
+
+        job_class = Object.const_get(job_data[:class_name])
+        job = job_class.new
+
+        # Inject DI deps
+        if @di && job_class.respond_to?(:dependencies)
+          job_class.dependencies.each do |dep|
+            value = @di.resolve(dep)
+            job.instance_variable_set(:"@#{dep}", value)
+            job.define_singleton_method(dep) { instance_variable_get(:"@#{dep}") }
+          end
+        end
+
+        args = job_data[:args].transform_keys(&:to_sym)
+        result = job.perform(**args)
+        serialized = Serialization::Json.decode(Serialization::Json.encode(result))
+
+        @backend.save(record.merge(status: :completed, result: serialized, completed_at: Time.now.to_f))
+      rescue => e
+        record = @backend.find(id) || {}
+        retry_count = (record[:retry_count] || 0) + 1
+
+        if retry_count <= @max_retries
+          sleep(@retry_delay) if @retry_delay > 0
+          @backend.save(record.merge(retry_count: retry_count, status: :pending))
+          @backend.push(job_data)
+        else
+          error = { message: e.message, backtrace: e.backtrace&.first(10)&.join("\n") }
+          @backend.save(record.merge(status: :failed, error: error, retry_count: retry_count, completed_at: Time.now.to_f))
+          @instrumentation&.emit(:job_failed, { job_id: id, error: error })
+        end
+      end
+    end
+  end
+end

data/lib/whoosh/jobs.rb

@@ -0,0 +1,50 @@
+# lib/whoosh/jobs.rb
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Whoosh
+  module Jobs
+    autoload :MemoryBackend, "whoosh/jobs/memory_backend"
+    autoload :Worker,        "whoosh/jobs/worker"
+
+    @backend = nil
+    @di = nil
+
+    class << self
+      attr_reader :backend, :di
+
+      def configure(backend:, di: nil)
+        @backend = backend
+        @di = di
+      end
+
+      def configured?
+        !!@backend
+      end
+
+      def enqueue(job_class, **args)
+        raise Errors::DependencyError, "Jobs not configured — boot a Whoosh::App first" unless configured?
+        id = SecureRandom.uuid
+        record = {
+          id: id, class_name: job_class.name, args: args, status: :pending,
+          result: nil, error: nil, retry_count: 0,
+          created_at: Time.now.to_f, started_at: nil, completed_at: nil
+        }
+        @backend.save(record)
+        @backend.push({ id: id, class_name: job_class.name, args: args })
+        id
+      end
+
+      def find(id)
+        raise Errors::DependencyError, "Jobs not configured" unless configured?
+        @backend.find(id)
+      end
+
+      def reset!
+        @backend = nil
+        @di = nil
+      end
+    end
+  end
+end

data/lib/whoosh/logger.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Whoosh
+  class Logger
+    LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze
+
+    def initialize(output: $stdout, format: :json, level: :info)
+      @output = output
+      @format = format
+      @level = LEVELS[level.to_sym] || 1
+    end
+
+    def debug(event, **data)
+      log(:debug, event, **data)
+    end
+
+    def info(event, **data)
+      log(:info, event, **data)
+    end
+
+    def warn(event, **data)
+      log(:warn, event, **data)
+    end
+
+    def error(event, **data)
+      log(:error, event, **data)
+    end
+
+    def with_context(**context)
+      ScopedLogger.new(self, **context)
+    end
+
+    class ScopedLogger
+      def initialize(logger, **context)
+        @logger = logger
+        @context = context
+      end
+
+      def debug(event, **data) = @logger.debug(event, **@context, **data)
+      def info(event, **data) = @logger.info(event, **@context, **data)
+      def warn(event, **data) = @logger.warn(event, **@context, **data)
+      def error(event, **data) = @logger.error(event, **@context, **data)
+    end
+
+    private
+
+    def log(level, event, **data)
+      return if LEVELS[level] < @level
+
+      entry = { ts: Time.now.utc.iso8601, level: level.to_s, event: event }.merge(data)
+
+      case @format
+      when :json
+        @output.puts(JSON.generate(entry))
+      when :text
+        @output.puts("[#{entry[:ts]}] #{level.to_s.upcase} #{event} #{data.map { |k, v| "#{k}=#{v}" }.join(' ')}")
+      end
+    end
+  end
+end