kraftwerk 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 297caa3f44b655c645d35c4a8334eaac79b1c0c2908a7efe961307ce9a48eae2
+  data.tar.gz: 2dee1765d8923066f6f4ee18f14d056dc49b7f30527fe3da044a0d0d76817510
+SHA512:
+  metadata.gz: 9c5587a92d8288571cd30c7e00b8f26e8bcf04e4862ac40b1576c5dd888a87f819a867edb7bf47a0440084b3c85ac58fb6d89ce3000f76ffeffcbb89d24c5250
+  data.tar.gz: 86cdc0ff303e3dec5e9b69419603d274aafe840f0eb6098e33c8f1fd6a7ff49f6ec8c0564d8564cdc3314d902289e4bc87e8eb7bd67a6a3570a826407b7e77b2

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/test/tmp/
+/tmp/

data/.gitlab-ci.yml

@@ -0,0 +1,20 @@
+
+default:
+  before_script:
+    - ruby -v
+    - gem install bundler --no-document
+    - bundle install --jobs $(nproc)  "${FLAGS[@]}"
+
+test2.7:
+  image: "ruby:2.7"
+  script:
+    - bundle exec rake test
+test3.0:
+  image: "ruby:3.0"
+  script:
+    - bundle exec rake test
+
+lint:
+  image: "ruby:2.7"
+  script:
+    - bundle exec rubycritic -f lint -s 85

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in kraftwerk.gemspec
+gemspec
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Paweł Świątkowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# Kraftwerk
+
+This gem is WIP as for now. Move along.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/kraftwerk.gemspec

@@ -0,0 +1,41 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kraftwerk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kraftwerk'
+  spec.version       = Kraftwerk::VERSION
+  spec.authors       = ['Paweł Świątkowski']
+  spec.email         = ['katafrakt@vivaldi.net']
+
+  spec.summary       = 'Framework for crafting JSON APIs with style'
+  spec.homepage      = 'https://gitlab.com/katafrakt/kraftwerk'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|example)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'hanami-controller', '~> 2.0.0.alpha'
+  spec.add_dependency 'hanami-router', '~> 2.0.0.alpha4'
+  spec.add_dependency 'hanami-utils', '~> 2.0.0.alpha'
+  spec.add_dependency 'dry-validation', '~> 1.5'
+  spec.add_dependency 'dry-auto_inject'
+  spec.add_dependency 'dry-container', '~> 0.7'
+  spec.add_dependency 'dry-core', '~> 0.5'
+  spec.add_dependency 'zeitwerk'
+
+  spec.add_development_dependency 'bundler', '>= 1.16'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rack-test', '~> 1.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubycritic'
+  spec.add_development_dependency 'sequel'
+  spec.add_development_dependency 'sqlite3'
+end

data/lib/kraftwerk.rb

@@ -0,0 +1,6 @@
+require 'kraftwerk/version'
+require 'kraftwerk/app'
+require 'kraftwerk/endpoint'
+
+module Kraftwerk
+end

data/lib/kraftwerk/app.rb

@@ -0,0 +1,66 @@
+require 'kraftwerk/router'
+require 'kraftwerk/app/configuration'
+require 'kraftwerk/app/components'
+require 'kraftwerk/app/dependencies'
+require 'hanami/middleware/body_parser'
+require 'kraftwerk/middleware/reloader'
+require 'hanami/utils/class_attribute'
+require 'dry/container'
+require 'dry/auto_inject'
+
+module Kraftwerk
+  class App
+    RoutingAlreadyDefined = Class.new(StandardError)
+    DependenciesAlreadyDefined = Class.new(StandardError)
+    AlreadyConfigured = Class.new(StandardError)
+
+    include Hanami::Utils::ClassAttribute
+    class_attribute :_dependencies, :_routing, :_zeitwerk_loader
+
+    # configuration
+    class_attribute :autoload_paths, :reloading_enabled, :configuration
+
+    def self.inherited(base)
+      create_configuration!(base)
+    end
+
+    # Initializes all the machinery
+    # Should only be called once
+    def self.initialize!
+      self::Configuration.freeze
+      create_components!
+
+      require 'kraftwerk/logger/dev_logger'
+      logger = Kraftwerk::Logger::DevLogger.new($stdout)
+
+      self::Components['telemetry'].attach(
+        'kraftwerk-request-start-log',
+        [:kraftwerk, :request, :start],
+        &logger.method(:handle_request_start)
+      )
+      self::Components['telemetry'].attach(
+        'kraftwerk-request-finish-log',
+        [:kraftwerk, :request, :finish],
+        &logger.method(:handle_request_finish)
+      )
+    end
+
+    class << self
+      def routing(&block)
+        raise RoutingAlreadyDefined unless self::Configuration.routing.nil?
+        self::Configuration.routing Kraftwerk::Router.new(&Proc.new(&block))
+      end
+
+      def dependencies(&block)
+        return self.create_dependencies!(&Proc.new(&block)) unless defined?(self::Dependencies)
+        
+        raise DependenciesAlreadyDefined if block_given?
+        self::Dependencies
+      end
+
+      def rack_app
+        self::Components[:rack_app]
+      end
+    end
+  end
+end

data/lib/kraftwerk/app/components.rb

@@ -0,0 +1,56 @@
+require 'dry/container'
+require 'kraftwerk/telemetry'
+require 'kraftwerk/middleware/request_telemetry'
+
+module Kraftwerk
+  class App
+    # Creates components
+    # Configuration must be present and final at this point
+    def self.create_components!
+      kraftwerk_app = self
+      config = self::Configuration
+      klass = Class.new do
+        extend Dry::Container::Mixin
+
+        # Rack application for use in config.ru
+        register(:rack_app, memoize: true) do
+          router = resolve(:router)
+          reloader = resolve(:reloader)
+
+          Rack::Builder.new do
+            use Kraftwerk::Middleware::Reloader.new(reloader)
+            use Hanami::Middleware::BodyParser, :json
+            use Kraftwerk::Middleware::RequestTelemetry, kraftwerk_app
+            run router
+          end
+        end
+
+        register(:router, memoize: true) do
+          kraftwerk_app::Configuration.routing.routes
+        end
+
+        register(:reloader, memoize: true) do
+          if config.reloading_enabled
+            require 'zeitwerk'
+            loader = Zeitwerk::Loader.new
+            config.autoload_paths.each { |path| loader.push_dir(path) }
+            loader.enable_reloading
+            loader.setup
+            loader
+          else
+            # fake reloader
+            Class.new do
+              def reload; end
+            end
+          end
+        end
+
+        register(:telemetry, memoize: true) do
+          Kraftwerk::Telemetry.new
+        end
+      end
+
+      self.const_set('Components', klass)
+    end
+  end
+end

data/lib/kraftwerk/app/configuration.rb

@@ -0,0 +1,25 @@
+require 'dry/core/class_builder'
+
+module Kraftwerk
+  class App
+    # Creates class holding app configuration
+    def self.create_configuration!(namespace)
+      klass = Class.new do
+        extend Dry::Core::ClassAttributes
+
+        defines :logger
+        logger ::Logger.new($stdout)
+
+        defines :reloading_enabled
+        reloading_enabled ENV['RACK_ENV'] != 'production'
+
+        defines :autoload_paths
+        autoload_paths File.directory?('endpoints') ? ['endpoints'] : []
+
+        defines :routing
+      end
+
+      namespace.const_set('Configuration', klass)
+    end
+  end
+end

data/lib/kraftwerk/app/dependencies.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'dry/core/class_builder'
+
+module Kraftwerk
+  class App
+    def self.create_dependencies!(&block)
+      klass = Class.new do
+        extend Dry::Container::Mixin
+        instance_exec(&block)
+      end
+      
+      self.const_set('Dependencies', Dry::AutoInject(klass))
+    end
+  end
+end

data/lib/kraftwerk/endpoint.rb

@@ -0,0 +1,20 @@
+require 'hanami/controller'
+require 'kraftwerk/response_formatter'
+require 'kraftwerk/endpoint/validatable'
+require 'kraftwerk/endpoint/callable'
+require 'kraftwerk/endpoint/error_handling'
+
+module Kraftwerk
+  module Endpoint
+    def self.prepended(base_class)
+      base_class.class_eval do
+        include Hanami::Utils::ClassAttribute
+        include Hanami::Action::Rack
+        include Hanami::Action::Mime
+        prepend Validatable
+        prepend ErrorHandling
+        prepend Callable
+      end
+    end
+  end
+end

data/lib/kraftwerk/endpoint/callable.rb

@@ -0,0 +1,21 @@
+module Kraftwerk
+  module Endpoint
+    # Replacement for Hanami::Action::Callable, which does not care about return value of the call method,
+    # instead requiring us to assign response via self.body= or via view.
+    # We don't want that in Kraftwerk. Return value from #call should be interpreted and returned by the framework.
+    module Callable
+      def call(env)
+        params = Hanami::Action::BaseParams.new(env)
+        begin
+          response = super(params)
+        rescue StandardError => e
+          puts e
+          puts e.backtrace.join("\n")
+          response = Kraftwerk::Response.new(code: 500, body: { error: 'Internal server error' })
+        end
+
+        ResponseFormatter.new.call(response: response, params: params)
+      end
+    end
+  end
+end

data/lib/kraftwerk/endpoint/error_handling.rb

@@ -0,0 +1,38 @@
+module Kraftwerk
+  module Endpoint
+    module ErrorHandling
+      def call(params)
+        begin
+          super
+        rescue => exception
+          if self.class.exception_handlers.key?(exception.class)
+            handler = self.class.exception_handlers[exception.class]
+            message = handler[:message].respond_to?(:call) ? handler[:message].call(exception) : handler[:message]
+            unless message.is_a?(Kraftwerk::Response)
+              message = Kraftwerk::Response.new(code: handler[:code], body: { error: message })
+            end
+            message
+            # todo call app expection handler somehow
+          else
+            raise exception
+          end
+        end
+      end
+
+      def self.prepended(base)
+        base.class_eval do
+          class_attribute :exception_handlers
+          self.exception_handlers = {}
+          extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def handle_exception(exception_class, code: 422, message: nil)
+          body = message || Proc.new
+          self.exception_handlers[exception_class] = { code: code, message: body }
+        end
+      end
+    end
+  end
+end

data/lib/kraftwerk/endpoint/validatable.rb

@@ -0,0 +1,45 @@
+require 'dry/validation'
+require 'kraftwerk/response'
+
+module Kraftwerk
+  module Endpoint
+    module Validatable
+      # Unlike in Hanami, where we usually want to validate params manually and, if they are invalid,
+      # take a proper action, in Kraftwerk if validation is not passed, the request should not happen at all.
+      # Instead, error messages are returned.
+      def call(params)
+        validation_class = self.class.validation_class
+        return super if validation_class.nil?
+
+        result = validation_class.new.call(params.to_h)
+        if result.success?
+          # pass only whitelisted parameters down
+          super(result.to_h)
+        else
+          Response.new(code: 400, body: result.errors.to_h)
+        end
+      end
+
+      def self.prepended(base)
+        base.class_eval do
+          class_attribute :validation_class
+          extend ClassMethods
+        end
+      end
+
+      module ClassMethods
+        def contract(&block)
+          klass = Class.new(Dry::Validation::Contract) do
+            instance_exec(&Proc.new(&block))
+          end
+          self.validation_class = klass
+        end
+
+        def validate_with(klass)
+          # TODO: add check if klass is proper validation class
+          self.validation_class = klass
+        end
+      end
+    end
+  end
+end

data/lib/kraftwerk/logger/dev_logger.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'hanami/logger'
+
+module Kraftwerk
+  module Logger
+    class DevLogger < ::Logger
+      def initialize(*args)
+        super
+        self.formatter = proc do |severity, datetime, progname, message|
+          message + "\n"
+        end
+      end
+
+      def handle_request_start(data, meta)
+        msg = String.new
+        msg << "[#{meta[:time]}]\n"
+        msg << color("[#{data[:method]}] ", :magenta)
+        msg << color(data[:path], :green)
+        msg << " "
+        msg << (data[:params]&.empty? ? '' : JSON.dump(data[:params]))
+        info(msg)
+      end
+
+      def handle_request_finish(data, meta)
+        msg = String.new
+        clr = data[:code] < 400 ? :green : :red
+
+        msg << color("[#{data[:code]}] ", clr)
+        msg << "[#{data[:duration].round(3)} ms] "
+        if !data[:body].nil? && data[:body].length > 0
+          msg << json_response(data[:body])
+        else
+          msg << "[empty response]"
+        end
+
+        info(msg + "\n")
+      end
+
+      private
+
+      def color(text, color)
+        Hanami::Utils::ShellColor.call(text, color: color)
+      end
+
+      def json_response(response)
+        JSON.dump(JSON.parse(response))
+      rescue
+        "[non-JSON response: #{response}]"
+      end
+    end
+  end
+end

data/lib/kraftwerk/middleware/reloader.rb

@@ -0,0 +1,18 @@
+module Kraftwerk
+  module Middleware
+    module Reloader
+      def self.new(reloader)
+        Class.new do
+          define_method :initialize do |app|
+            @app = app
+          end
+
+          define_method :call do |env|
+            reloader.reload
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kraftwerk/middleware/request_telemetry.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Kraftwerk
+  module Middleware
+    class RequestTelemetry
+      ROUTER_PARAMS = 'router.params'
+      PATH = 'PATH_INFO'
+      METHOD = 'REQUEST_METHOD'
+      QUERY_STRING = 'QUERY_STRING'
+      RACK_INPUT = 'rack.input'
+
+      attr_reader :app, :kraftwerk_app, :telemetry
+
+      def initialize(app, kraftwerk_app, telemetry: nil)
+        @app = app
+        @kraftwerk_app = kraftwerk_app
+        @telemetry ||= kraftwerk_app::Components['telemetry']
+      end
+
+      def call(env)
+        metadata = { app: kraftwerk_app, time: Time.now }
+        start_data = request_start_data(env)
+        telemetry.execute([:kraftwerk, :request, :start], start_data, metadata)
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        app.call(env).tap do |response|
+          telemetry.execute(
+            [:kraftwerk, :request, :finish],
+            request_finish_data(start_data, response, start_time),
+            metadata
+          )
+        end
+      end
+
+      private
+
+      def request_start_data(env)
+        {
+          method: env[METHOD],
+          path: env[PATH],
+          params: request_params(env)
+        }
+      end
+
+      def request_finish_data(start_data, response, start_time)
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+        code, _headers, body = response
+
+        start_data.merge(
+          {
+            duration: duration,
+            code: code,
+            body: body[0]
+          }
+        )
+      end
+
+      # Combines params from query string and body into a single hash
+      def request_params(env)
+        params_from_query_string = env[QUERY_STRING] ? CGI.parse(env[QUERY_STRING]) : {}
+        rack_input = env[RACK_INPUT].dup.read
+        params_from_input = rack_input.length > 0 ? CGI.parse(rack_input) : {}
+        params_from_router = env[ROUTER_PARAMS] || {}
+        params_from_query_string.merge(params_from_input).merge(params_from_router)
+      end
+    end
+  end
+end

data/lib/kraftwerk/response.rb

@@ -0,0 +1,13 @@
+module Kraftwerk
+  class Response
+    attr_reader :code, :body, :headers, :body_raw
+
+    # TODO: support cookies nicely
+    def initialize(code: nil, body: nil, headers: {}, body_raw: false)
+      @code = code
+      @body = body
+      @headers = headers
+      @body_raw = body_raw
+    end
+  end
+end

data/lib/kraftwerk/response_formatter.rb

@@ -0,0 +1,37 @@
+require 'json'
+
+module Kraftwerk
+  class ResponseFormatter
+    def call(response:, params:)
+      case response
+      when Kraftwerk::Response
+        body = response.body_raw ? response.body : to_json(response.body)
+        code = code_or_default(response.code, params)
+        headers = response.headers
+        [code, headers, [body]]
+      else
+        body = JSON.dump(response)
+        [code_or_default(nil, params), {}, [body]]
+      end
+    end
+
+    private
+
+    def to_json(response)
+      JSON.dump(response)
+    end
+
+    def code_or_default(code, params)
+      return code unless code.nil?
+
+      method = params.env['REQUEST_METHOD']
+      case method
+      when 'GET' then 200
+      when 'POST' then 201
+      when 'PUT', 'PATCH' then 204
+      when 'DELETE' then 204
+      else 200
+      end
+    end
+  end
+end

data/lib/kraftwerk/router.rb

@@ -0,0 +1,36 @@
+require 'hanami/router'
+require 'json'
+
+module Kraftwerk
+  class Router
+    DEFAULT_RESPONSE = [
+      404,
+      {
+        'X-Cascade' => 'pass',
+        'Content-Type' => 'application/json'
+      },
+      [JSON.dump(error: 'not found')]
+    ].freeze
+
+    attr_reader :routes
+
+    def initialize(&block)
+      @routes = create_routing(&Proc.new(&block))
+    end
+
+    private
+
+    def create_routing(&block)
+      # default_app is an undocumented feature of Hanami router coming from
+      # HttpRouter library, which it relies upon.
+      # It sets a default handler when no route can be matched.
+      # See: https://github.com/hanami/router/issues/119
+      #
+      # In hanami-router 2.0 it has been renamed to not_found
+      default_app = ->(_env) { DEFAULT_RESPONSE }
+      @routes = Hanami::Router.new(not_found: default_app) do
+        instance_exec(&Proc.new(&block))
+      end
+    end
+  end
+end

data/lib/kraftwerk/telemetry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Kraftwerk
+  # Based on
+  # * BEAM Telemetry module
+  # * Work of Tony Pitale: https://github.com/tpitale/telemetry-ruby
+  class Telemetry
+    HandlerIdAlreadyUsed = Class.new(RuntimeError)
+
+    def initialize
+      @handlers = Concurrent::Map.new
+      @used_ids = Concurrent::Map.new
+      @semaphore = Concurrent::Semaphore.new(1)
+    end
+
+    def attach(id, event_key, &handler)
+      raise HandlerIdAlreadyUsed.new(id) if @used_ids.key?(id)
+
+      @handlers[event_key] ||= Concurrent::Array.new
+      @handlers[event_key] << { id: id, handler: handler }
+      sync_used_ids_cache
+    end
+
+    def detach(id)
+      event_key = @used_ids[id]
+      @handlers[event_key].delete_if { |handler| handler[:id] == id }
+      sync_used_ids_cache
+    end
+
+    def execute(event_key, values = {}, meta = {})
+      handlers = @handlers[event_key]
+      return if handlers.nil?
+
+      handlers.each do |handler|
+        handler[:handler].call(values, {_event_key: event_key}.merge(meta))
+      end
+    end
+
+    private
+
+    def sync_used_ids_cache
+      ids = Concurrent::Map.new
+      @semaphore.acquire
+      @handlers.each do |key, handlers|
+        handlers.each do |handler|
+          id = handler[:id]
+          ids[id] = key
+        end
+      end
+
+      @used_ids = ids
+    ensure
+      @semaphore.release
+    end
+  end
+end

data/lib/kraftwerk/version.rb

@@ -0,0 +1,3 @@
+module Kraftwerk
+  VERSION = '0.1.1'.freeze
+end

metadata

@@ -0,0 +1,291 @@
+--- !ruby/object:Gem::Specification
+name: kraftwerk
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Paweł Świątkowski
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hanami-controller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.alpha
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.alpha
+- !ruby/object:Gem::Dependency
+  name: hanami-router
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.alpha4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.alpha4
+- !ruby/object:Gem::Dependency
+  name: hanami-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.alpha
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.alpha
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: dry-auto_inject
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubycritic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- katafrakt@vivaldi.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kraftwerk.gemspec
+- lib/kraftwerk.rb
+- lib/kraftwerk/app.rb
+- lib/kraftwerk/app/components.rb
+- lib/kraftwerk/app/configuration.rb
+- lib/kraftwerk/app/dependencies.rb
+- lib/kraftwerk/endpoint.rb
+- lib/kraftwerk/endpoint/callable.rb
+- lib/kraftwerk/endpoint/error_handling.rb
+- lib/kraftwerk/endpoint/validatable.rb
+- lib/kraftwerk/logger/dev_logger.rb
+- lib/kraftwerk/middleware/reloader.rb
+- lib/kraftwerk/middleware/request_telemetry.rb
+- lib/kraftwerk/response.rb
+- lib/kraftwerk/response_formatter.rb
+- lib/kraftwerk/router.rb
+- lib/kraftwerk/telemetry.rb
+- lib/kraftwerk/version.rb
+homepage: https://gitlab.com/katafrakt/kraftwerk
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Framework for crafting JSON APIs with style
+test_files: []