kirei 0.2.1 → 0.4.0

data/lib/kirei/model.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Model
+    extend T::Sig
+    extend T::Helpers
+
+    sig { returns(Kirei::Model::BaseClassInterface) }
+    def class; super; end # rubocop:disable all
+
+    # An update keeps the original object intact, and returns a new object with the updated values.
+    sig do
+      params(
+        hash: T::Hash[Symbol, T.untyped],
+      ).returns(T.self_type)
+    end
+    def update(hash)
+      hash[:updated_at] = Time.now.utc if respond_to?(:updated_at) && hash[:updated_at].nil?
+      self.class.wrap_jsonb_non_primivitives!(hash)
+      self.class.query.where({ id: id }).update(hash)
+      self.class.find_by({ id: id })
+    end
+
+    # Delete keeps the original object intact. Returns true if the record was deleted.
+    # Calling delete multiple times will return false after the first (successful) call.
+    sig { returns(T::Boolean) }
+    def delete
+      count = self.class.query.where({ id: id }).delete
+      count == 1
+    end
+
+    # warning: this is not concurrency-safe
+    # save keeps the original object intact, and returns a new object with the updated values.
+    sig { returns(T.self_type) }
+    def save
+      previous_record = self.class.find_by({ id: id })
+
+      hash = serialize
+      Helpers.deep_symbolize_keys!(hash)
+      hash = T.cast(hash, T::Hash[Symbol, T.untyped])
+
+      if previous_record.nil?
+        self.class.create(hash)
+      else
+        update(hash)
+      end
+    end
+
+    mixes_in_class_methods(Kirei::Model::ClassMethods)
+  end
+end

data/lib/kirei/routing/base.rb

@@ -0,0 +1,187 @@
+# typed: strict
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/all
+
+module Kirei
+  module Routing
+    class Base
+      extend T::Sig
+
+      sig { params(params: T::Hash[String, T.untyped]).void }
+      def initialize(params: {})
+        @router = T.let(Router.instance, Router)
+        @params = T.let(params, T::Hash[String, T.untyped])
+      end
+
+      sig { returns(T::Hash[String, T.untyped]) }
+      attr_reader :params
+
+      sig { returns(Router) }
+      attr_reader :router; private :router
+
+      sig { params(env: RackEnvType).returns(RackResponseType) }
+      def call(env)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+
+        http_verb = Verb.deserialize(env.fetch("REQUEST_METHOD"))
+        req_path = T.cast(env.fetch("REQUEST_PATH"), String)
+        #
+        # TODO: reject requests from unexpected hosts -> allow configuring allowed hosts in a `cors.rb` file
+        #   ( offer a scaffold for this file )
+        # -> use https://github.com/cyu/rack-cors ?
+        #
+
+        route = router.get(http_verb, req_path)
+        return [404, {}, ["Not Found"]] if route.nil?
+
+        params = case route.verb
+                 when Verb::GET
+                   query = T.cast(env.fetch("QUERY_STRING"), String)
+                   query.split("&").to_h do |p|
+                     k, v = p.split("=")
+                     k = T.cast(k, String)
+                     [k, v]
+                   end
+                 when Verb::POST, Verb::PUT, Verb::PATCH
+                   # TODO: based on content-type, parse the body differently
+                   #       build-in support for JSON & XML
+                   body = T.cast(env.fetch("rack.input"), T.any(IO, StringIO))
+                   res = Oj.load(body.read, Kirei::OJ_OPTIONS)
+                   body.rewind # TODO: maybe don't rewind if we don't need to?
+                   T.cast(res, T::Hash[String, T.untyped])
+                 else
+                   Logging::Logger.logger.warn("Unsupported HTTP verb: #{http_verb.serialize} send to #{req_path}")
+                   {}
+        end
+
+        req_id = T.cast(env["HTTP_X_REQUEST_ID"], T.nilable(String))
+        req_id ||= "req_#{App.environment}_#{SecureRandom.uuid}"
+        Thread.current[:request_id] = req_id
+
+        controller = route.controller
+        before_hooks = collect_hooks(controller, :before_hooks)
+        run_hooks(before_hooks)
+
+        Kirei::Logging::Logger.call(
+          level: Kirei::Logging::Level::INFO,
+          label: "Request Started",
+          meta: params,
+        )
+
+        statsd_timing_tags = {
+          "controller" => controller.name,
+          "route" => route.action,
+        }
+        Logging::Metric.inject_defaults(statsd_timing_tags)
+
+        status, headers, response_body = T.cast(
+          controller.new(params: params).public_send(route.action),
+          RackResponseType,
+        )
+
+        after_hooks = collect_hooks(controller, :after_hooks)
+        run_hooks(after_hooks)
+
+        headers["X-Request-Id"] ||= req_id
+
+        default_headers.each do |header_name, default_value|
+          headers[header_name] ||= default_value
+        end
+
+        [
+          status,
+          headers,
+          response_body,
+        ]
+      ensure
+        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        if start # early return for 404
+          latency_in_ms = stop - start
+          ::StatsD.measure("request", latency_in_ms, tags: statsd_timing_tags)
+
+          Kirei::Logging::Logger.call(
+            level: Kirei::Logging::Level::INFO,
+            label: "Request Finished",
+            meta: { "response.body" => response_body, "response.latency_in_ms" => latency_in_ms },
+          )
+        end
+
+        # reset global variables after the request has been served
+        # and after all "after" hooks have run to avoid leaking
+        Thread.current[:enduser_id] = nil
+        Thread.current[:request_id] = nil
+      end
+
+      #
+      # * "status": defaults to 200
+      # * "headers": Kirei adds some default headers for security, but the user can override them
+      #
+      sig do
+        params(
+          body: String,
+          status: Integer,
+          headers: T::Hash[String, String],
+        ).returns(RackResponseType)
+      end
+      def render(body, status: 200, headers: {})
+        [
+          status,
+          headers,
+          [body],
+        ]
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def default_headers
+        # "Access-Control-Allow-Origin": the user should set that, see comment about "cors" above
+        {
+          # security relevant headers
+          "X-Frame-Options" => "DENY",
+          "X-Content-Type-Options" => "nosniff",
+          "X-XSS-Protection" => "1; mode=block", # for legacy clients/browsers
+          "Strict-Transport-Security" => "max-age=31536000; includeSubDomains", # for HTTPS
+          "Cache-Control" => "no-store", # the user should set that if caching is needed
+          "Referrer-Policy" => "strict-origin-when-cross-origin",
+          "Content-Security-Policy" => "default-src 'none'; frame-ancestors 'none'",
+
+          # other headers
+          "Content-Type" => "application/json; charset=utf-8",
+        }
+      end
+
+      sig { params(hooks: NilableHooksType).void }
+      private def run_hooks(hooks)
+        return if hooks.nil? || hooks.empty?
+
+        hooks.each(&:call)
+      end
+
+      sig do
+        params(
+          controller: T.class_of(Controller),
+          hooks_type: Symbol,
+        ).returns(NilableHooksType)
+      end
+      private def collect_hooks(controller, hooks_type)
+        result = T.let(Set.new, T::Set[T.proc.void])
+
+        controller.ancestors.reverse.each do |ancestor|
+          next unless ancestor < Controller
+
+          supported_hooks = %i[before_hooks after_hooks]
+          unless supported_hooks.include?(hooks_type)
+            raise "Unexpected hook type, got #{hooks_type}, expected one of: #{supported_hooks.join(",")}"
+          end
+
+          hooks = T.let(ancestor.public_send(hooks_type), NilableHooksType)
+          result.merge(hooks) if hooks&.any?
+        end
+
+        result
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/all

data/lib/kirei/routing/nilable_hooks_type.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Routing
+    NilableHooksType = T.type_alias do
+      T.nilable(T::Set[T.proc.void])
+    end
+  end
+end

data/lib/kirei/{middleware.rb → routing/rack_env_type.rb}

@@ -2,16 +2,7 @@
 # frozen_string_literal: true
 
 module Kirei
-  module Middleware
-    # https://github.com/rack/rack/blob/main/UPGRADE-GUIDE.md#rack-3-upgrade-guide
-    RackResponseType = T.type_alias do
-      [
-        Integer,
-        T::Hash[String, String], # in theory, the values are allowed to be arrays of integers for binary representations
-        T.any(T::Array[String], Proc),
-      ]
-    end
-
+  module Routing
     RackEnvType = T.type_alias do
       T::Hash[
         String,

data/lib/kirei/routing/rack_response_type.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Routing
+    # https://github.com/rack/rack/blob/main/UPGRADE-GUIDE.md#rack-3-upgrade-guide
+    RackResponseType = T.type_alias do
+      [
+        Integer,                       # status
+        T::Hash[String, String],       # headers. Values may be arrays of integers for binary representations
+        T.any(T::Array[String], Proc), # body
+      ]
+    end
+  end
+end

data/lib/kirei/routing/route.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Routing
+    class Route < T::Struct
+      const :verb, Verb
+      const :path, String
+      const :controller, T.class_of(Controller)
+      const :action, String
+    end
+  end
+end

data/lib/kirei/routing/router.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+require("singleton")
+
+module Kirei
+  module Routing
+    #
+    # Usage:
+    #
+    # Router.add_routes([
+    #   Route.new(
+    #     verb: Verb::GET,
+    #     path: "/livez",
+    #     controller: Controllers::HealthController,
+    #     action: "livez",
+    #   ),
+    # ])
+    #
+    class Router
+      extend T::Sig
+      include ::Singleton
+
+      RoutesHash = T.type_alias do
+        T::Hash[String, Route]
+      end
+
+      sig { void }
+      def initialize
+        @routes = T.let({}, RoutesHash)
+      end
+
+      sig { returns(RoutesHash) }
+      attr_reader :routes
+
+      sig do
+        params(
+          verb: Verb,
+          path: String,
+        ).returns(T.nilable(Route))
+      end
+      def get(verb, path)
+        key = "#{verb.serialize} #{path}"
+        routes[key]
+      end
+
+      sig { params(routes: T::Array[Route]).void }
+      def self.add_routes(routes)
+        routes.each do |route|
+          key = "#{route.verb.serialize} #{route.path}"
+          instance.routes[key] = route
+        end
+      end
+    end
+  end
+end

data/lib/kirei/routing/verb.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Routing
+    class Verb < T::Enum
+      enums do
+        # idempotent
+        GET     = new("GET")
+
+        # non-idempotent
+        POST    = new("POST")
+
+        # idempotent
+        PUT     = new("PUT")
+
+        # non-idempotent
+        PATCH   = new("PATCH")
+
+        # non-idempotent
+        DELETE  = new("DELETE")
+
+        # idempotent
+        HEAD    = new("HEAD")
+
+        # idempotent
+        OPTIONS = new("OPTIONS")
+
+        # idempotent
+        TRACE   = new("TRACE")
+
+        # non-idempotent
+        CONNECT = new("CONNECT")
+      end
+    end
+  end
+end

data/lib/kirei/services/result.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Services
+    class Result
+      extend T::Sig
+      extend T::Generic
+
+      ErrorType = type_member { { fixed: T::Array[Errors::JsonApiError] } }
+      ResultType = type_member { { upper: Object } }
+
+      sig do
+        params(
+          result: T.nilable(ResultType),
+          errors: ErrorType,
+        ).void
+      end
+      def initialize(result: nil, errors: [])
+        if (result && !errors.empty?) || (!result && errors.empty?)
+          raise ArgumentError, "Must provide either result or errors, got both or neither"
+        end
+
+        @result = result
+        @errors = errors
+      end
+
+      sig { returns(T::Boolean) }
+      def success?
+        @errors.empty?
+      end
+
+      sig { returns(T::Boolean) }
+      def failed?
+        !success?
+      end
+
+      sig { returns(ResultType) }
+      def result
+        raise "Cannot call 'result' when there are errors" if failed?
+
+        T.must(@result)
+      end
+
+      sig { returns(ErrorType) }
+      def errors
+        raise "Cannot call 'errors' when there is a result" if success?
+
+        @errors
+      end
+    end
+  end
+end

data/lib/kirei/services/runner.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Services
+    class Runner
+      extend T::Sig
+      extend T::Generic
+
+      sig do
+        type_parameters(:T)
+          .params(
+            class_name: String,
+            log_tags: T::Hash[String, T.untyped],
+            _: T.proc.returns(T.type_parameter(:T)),
+          ).returns(T.type_parameter(:T))
+      end
+      def self.call(class_name, log_tags: {}, &_)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        service = yield
+
+        service
+      ensure
+        stop = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+        latency_in_ms = stop - T.must(start)
+
+        result = case service
+                 when Services::Result
+                   service.success? ? "success" : "failure"
+                 else
+                   "unknown"
+        end
+
+        metric_tags = Logging::Metric.inject_defaults({ "service.result" => result })
+        ::StatsD.measure(class_name, latency_in_ms, tags: metric_tags)
+
+        logtags = {
+          "service.name" => class_name,
+          "service.latency_in_ms" => latency_in_ms,
+          "service.result" => result,
+        }
+        logtags.merge!(log_tags)
+        Logging::Logger.call(level: Logging::Level::INFO, label: "Service Finished", meta: logtags)
+      end
+    end
+  end
+end

data/lib/kirei/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Kirei
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

data/lib/kirei.rb

@@ -1,7 +1,31 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "boot"
+# This is the entrypoint into the application,
+# This file loads first, hence we don't have Sorbet loaded yet.
+
+#
+# Load Order is important!
+#
+
+# First: check if all gems are installed correctly
+require "bundler/setup"
+
+# Second: load all gems (runtime dependencies only)
+require "logger"
+require "statsd-instrument"
+require "sorbet-runtime"
+require "oj"
+require "rack"
+require "pg"
+require "sequel" # "sequel_pg" is auto-required by "sequel"
+
+# Third: load all application code
+require("zeitwerk")
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/cli")
+loader.ignore("#{__dir__}/cli.rb")
+loader.setup
 
 module Kirei
   extend T::Sig
@@ -10,7 +34,7 @@ module Kirei
   # rubocop:disable Style/MutableConstant
   OJ_OPTIONS = T.let(
     {
-      mode: :compat, # required to dump hashes with symbol-keys
+      mode: :compat, # required to dump hashes with symbol-keys. @TODO(lud, 14.05.2024): drop this, and enforce String Keys?
       symbol_keys: false, # T::Struct.new works only with string-keys
     },
     T::Hash[Symbol, T.untyped],
@@ -40,6 +64,10 @@ module Kirei
   end
 end
 
+loader.eager_load
+
 Kirei.configure(&:itself)
 
-Kirei::Logger.logger.info("Kirei (#{Kirei::VERSION}) booted successfully!")
+yjit_enabled = defined?(RubyVM::YJIT) ? RubyVM::YJIT.enabled? : false
+
+Kirei::Logging::Logger.logger.info("Kirei v#{Kirei::VERSION} booted; YJIT enabled: #{yjit_enabled}")

data/sorbet/rbi/shims/base_model.rbi

@@ -2,7 +2,7 @@
 
 # rubocop:disable Style/EmptyMethod
 module Kirei
-  module BaseModel
+  module Model
     include Kernel # "self" is a class since we include the module in a class
     include T::Props::Serializable
 

data/sorbet/rbi/shims/ruby.rbi

@@ -0,0 +1,15 @@
+# typed: true
+
+#
+# The RubyVM module only exists on MRI. RubyVM is not defined in other Ruby implementations such as JRuby and TruffleRuby.
+#
+# The RubyVM module provides some access to MRI internals. This module is for very limited purposes, such as debugging, prototyping, and research. Normal users must not use it. This module is not portable between Ruby implementations.
+#
+class RubyVM
+  module YJIT
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    def self.enabled?; end
+  end
+end