kirei 0.2.1 → 0.3.0

data/lib/kirei/{base_model.rb → model.rb}

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module Kirei
-  module BaseModel
+  module Model
     extend T::Sig
     extend T::Helpers
 
@@ -115,7 +115,7 @@ module Kirei
 
       sig { override.returns(Sequel::Dataset) }
       def db
-        AppBase.raw_db_connection[table_name.to_sym]
+        App.raw_db_connection[table_name.to_sym]
       end
 
       sig do
@@ -166,7 +166,7 @@ module Kirei
       def wrap_jsonb_non_primivitives!(attributes)
         # setting `@raw_db_connection.wrap_json_primitives = true`
         # only works on JSON primitives, but not on blank hashes/arrays
-        return unless AppBase.config.db_extensions.include?(:pg_json)
+        return unless App.config.db_extensions.include?(:pg_json)
 
         attributes.each_pair do |key, value|
           next unless value.is_a?(Hash) || value.is_a?(Array)
@@ -196,7 +196,7 @@ module Kirei
         ).returns(T::Array[T.attached_class])
       end
       def resolve(query, strict = nil)
-        strict_loading = strict.nil? ? AppBase.config.db_strict_type_resolving : strict
+        strict_loading = strict.nil? ? App.config.db_strict_type_resolving : strict
 
         query.map do |row|
           row = T.cast(row, T::Hash[Symbol, T.untyped])
@@ -212,7 +212,7 @@ module Kirei
         ).returns(T.nilable(T.attached_class))
       end
       def resolve_first(query, strict = nil)
-        strict_loading = strict.nil? ? AppBase.config.db_strict_type_resolving : strict
+        strict_loading = strict.nil? ? App.config.db_strict_type_resolving : strict
 
         resolve(query.limit(1), strict_loading).first
       end

data/lib/kirei/routing/base.rb

@@ -0,0 +1,156 @@
+# 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 { params(env: RackEnvType).returns(RackResponseType) }
+      def call(env)
+        http_verb = Router::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.instance.get(http_verb, req_path)
+        return [404, {}, ["Not Found"]] if route.nil?
+
+        params = case route.verb
+                 when Router::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 Router::Verb::POST, Router::Verb::PUT, Router::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
+                   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)
+
+        status, headers, 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,
+          body,
+        ]
+      end
+
+      #
+      # Kirei::App#render
+      # * "status": defaults to 200
+      # * "headers": defaults to an empty hash
+      #
+      sig do
+        params(
+          body: String,
+          status: Integer,
+          headers: T::Hash[String, String],
+        ).returns(RackResponseType)
+      end
+      def render(body, status: 200, headers: {})
+        # merge default headers
+        # support a "type" to set content-type header? (or default to json, and users must set the header themselves for other types?)
+        [
+          status,
+          headers,
+          [body],
+        ]
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def default_headers
+        # "Access-Control-Allow-Origin": the user should set that
+        {
+          # 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/router.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+require("singleton")
+
+module Kirei
+  module Routing
+    #
+    # Usage:
+    #
+    # Router.add_routes([
+    #   Route.new(
+    #     verb: Kirei::Router::Verb::GET,
+    #     path: "/livez",
+    #     controller: Controllers::HealthController,
+    #     action: "livez",
+    #   ),
+    # ])
+    #
+    class Router
+      extend T::Sig
+      include ::Singleton
+
+      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
+
+      class Route < T::Struct
+        const :verb, Verb
+        const :path, String
+        const :controller, T.class_of(Controller)
+        const :action, String
+      end
+
+      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/version.rb

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

data/lib/kirei.rb

@@ -1,7 +1,30 @@
 # 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 "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
@@ -40,6 +63,8 @@ module Kirei
   end
 end
 
+loader.eager_load
+
 Kirei.configure(&:itself)
 
-Kirei::Logger.logger.info("Kirei (#{Kirei::VERSION}) booted successfully!")
+Kirei::Logger.logger.info("Kirei (v#{Kirei::VERSION}) booted.")

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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kirei
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ludwig Reinmiedl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-09 00:00:00.000000000 Z
+date: 2024-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: puma
   requirement: !ruby/object:Gem::Requirement
@@ -123,9 +137,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 description: |
-  Kirei is a strictly typed Ruby micro/REST-framework for building scaleable and performant microservices.
+  Kirei is a Ruby micro/REST-framework for building scalable and performant microservices.
   It is built from the ground up to be clean and easy to use.
-  Kirei is based on Sequel as an ORM, Sorbet for typing, and Sinatra for routing.
+  It is a Rack app, and uses Sorbet for typing, Sequel as an ORM, Zeitwerk for autoloading, and Puma as a web server.
   It strives to have zero magic and to be as explicit as possible.
 email:
 - lud@reinmiedl.com
@@ -140,7 +154,6 @@ files:
 - README.md
 - bin/kirei
 - kirei.gemspec
-- lib/boot.rb
 - lib/cli.rb
 - lib/cli/commands/new_app/base_directories.rb
 - lib/cli/commands/new_app/execute.rb
@@ -154,14 +167,16 @@ files:
 - lib/cli/commands/start.rb
 - lib/kirei.rb
 - lib/kirei/app.rb
-- lib/kirei/app_base.rb
-- lib/kirei/base_controller.rb
-- lib/kirei/base_model.rb
 - lib/kirei/config.rb
+- lib/kirei/controller.rb
 - lib/kirei/helpers.rb
 - lib/kirei/logger.rb
-- lib/kirei/middleware.rb
-- lib/kirei/router.rb
+- lib/kirei/model.rb
+- lib/kirei/routing/base.rb
+- lib/kirei/routing/nilable_hooks_type.rb
+- lib/kirei/routing/rack_env_type.rb
+- lib/kirei/routing/rack_response_type.rb
+- lib/kirei/routing/router.rb
 - lib/kirei/version.rb
 - sorbet/rbi/shims/base_model.rbi
 homepage: https://github.com/swiknaba/kirei
@@ -185,9 +200,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: Kirei is a strictly typed Ruby micro/REST-framework for building scaleable
-  and performant microservices.
+summary: Kirei is a typed Ruby micro/REST-framework for building scalable and performant
+  microservices.
 test_files: []

data/lib/boot.rb

@@ -1,23 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-# 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 "sorbet-runtime"
-require "oj"
-require "rack"
-require "pg"
-require "sequel" # "sequel_pg" is auto-required by "sequel"
-
-# Third: load all application code
-Dir[File.join(__dir__, "kirei/**/*.rb")].each { require(_1) }

data/lib/kirei/app_base.rb

@@ -1,72 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative("app")
-
-module Kirei
-  class AppBase < Kirei::App
-    class << self
-      extend T::Sig
-
-      # convenience method since "Kirei.configuration" must be nilable since it is nil
-      # at the beginning of initilization of the app
-      sig { returns(Kirei::Config) }
-      def config
-        T.must(Kirei.configuration)
-      end
-
-      sig { returns(Pathname) }
-      def root
-        defined?(::APP_ROOT) ? Pathname.new(::APP_ROOT) : Pathname.new(Dir.pwd)
-      end
-
-      sig { returns(String) }
-      def version
-        @version = T.let(@version, T.nilable(String))
-        @version ||= ENV.fetch("APP_VERSION", nil)
-        @version ||= ENV.fetch("GIT_SHA", nil)
-        @version ||= T.must(
-          `command -v git && git rev-parse --short HEAD`.to_s.split("\n").last,
-        ).freeze # localhost
-      end
-
-      sig { returns(String) }
-      def environment
-        ENV.fetch("RACK_ENV", "development")
-      end
-
-      sig { returns(String) }
-      def default_db_name
-        @default_db_name ||= T.let("#{config.app_name}_#{environment}".freeze, T.nilable(String))
-      end
-
-      sig { returns(String) }
-      def default_db_url
-        @default_db_url ||= T.let(
-          ENV.fetch("DATABASE_URL", "postgresql://localhost:5432/#{default_db_name}"),
-          T.nilable(String),
-        )
-      end
-
-      sig { returns(Sequel::Database) }
-      def raw_db_connection
-        @raw_db_connection = T.let(@raw_db_connection, T.nilable(Sequel::Database))
-        return @raw_db_connection unless @raw_db_connection.nil?
-
-        # calling "Sequel.connect" creates a new connection
-        @raw_db_connection = Sequel.connect(AppBase.config.db_url || default_db_url)
-
-        config.db_extensions.each do |ext|
-          T.cast(@raw_db_connection, Sequel::Database).extension(ext)
-        end
-
-        if config.db_extensions.include?(:pg_json)
-          # https://github.com/jeremyevans/sequel/blob/5.75.0/lib/sequel/extensions/pg_json.rb#L8
-          @raw_db_connection.wrap_json_primitives = true
-        end
-
-        @raw_db_connection
-      end
-    end
-  end
-end

data/lib/kirei/base_controller.rb

@@ -1,16 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative("app")
-
-module Kirei
-  class BaseController < Kirei::App
-    extend T::Sig
-    # register(Sinatra::Namespace)
-
-    # before do
-    #   Thread.current[:request_id] = request.env["HTTP_X_REQUEST_ID"].presence ||
-    #                                 "req_#{AppBase.environment}_#{SecureRandom.uuid}"
-    # end
-  end
-end

data/lib/kirei/router.rb

@@ -1,61 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require("singleton")
-
-module Kirei
-  #
-  # Usage:
-  #
-  # Router.add_routes([
-  #   Route.new(
-  #     verb: "GET",
-  #     path: "/livez",
-  #     controller: Controllers::HealthController,
-  #     action: "livez",
-  #   ),
-  # ])
-  #
-  class Router
-    extend T::Sig
-    include ::Singleton
-
-    class Route < T::Struct
-      const :verb, String
-      const :path, String
-      const :controller, T.class_of(BaseController)
-      const :action, String
-    end
-
-    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: String,
-        path: String,
-      ).returns(T.nilable(Route))
-    end
-    def get(verb, path)
-      key = "#{verb} #{path}"
-      routes[key]
-    end
-
-    sig { params(routes: T::Array[Route]).void }
-    def self.add_routes(routes)
-      routes.each do |route|
-        key = "#{route.verb} #{route.path}"
-        instance.routes[key] = route
-      end
-    end
-  end
-end