kirei 0.3.0 → 0.4.0

data/lib/kirei/model/class_methods.rb

@@ -0,0 +1,157 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Model
+    module ClassMethods
+      extend T::Sig
+      extend T::Generic
+
+      # the attached class is the class that extends this module
+      # e.g. "User", "Airport", ..
+      has_attached_class!
+
+      include Kirei::Model::BaseClassInterface
+
+      # defaults to a pluralized, underscored version of the class name
+      sig { override.returns(String) }
+      def table_name
+        @table_name ||= T.let("#{model_name}s", T.nilable(String))
+      end
+
+      sig { returns(String) }
+      def model_name
+        Kirei::Helpers.underscore(T.must(name.split("::").last))
+      end
+
+      sig { override.returns(Sequel::Dataset) }
+      def query
+        db[table_name.to_sym]
+      end
+
+      sig { override.returns(Sequel::Database) }
+      def db
+        App.raw_db_connection
+      end
+
+      sig do
+        override.params(
+          hash: T::Hash[Symbol, T.untyped],
+        ).returns(T::Array[T.attached_class])
+      end
+      def where(hash)
+        resolve(query.where(hash))
+      end
+
+      sig { override.returns(T::Array[T.attached_class]) }
+      def all
+        resolve(query.all)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # default values defined in the model are used, if omitted in the hash
+      sig do
+        override.params(
+          hash: T::Hash[Symbol, T.untyped],
+        ).returns(T.attached_class)
+      end
+      def create(hash)
+        # instantiate a new object to ensure we use default values defined in the model
+        without_id = !hash.key?(:id)
+        hash[:id] = "kirei-fake-id" if without_id
+        new_record = from_hash(Helpers.deep_stringify_keys(hash))
+        all_attributes = T.let(new_record.serialize, T::Hash[String, T.untyped])
+        all_attributes.delete("id") if without_id && all_attributes["id"] == "kirei-fake-id"
+
+        wrap_jsonb_non_primivitives!(all_attributes)
+
+        if new_record.respond_to?(:created_at) && all_attributes["created_at"].nil?
+          all_attributes["created_at"] = Time.now.utc
+        end
+        if new_record.respond_to?(:updated_at) && all_attributes["updated_at"].nil?
+          all_attributes["updated_at"] = Time.now.utc
+        end
+
+        pkey = T.let(query.insert(all_attributes), String)
+
+        T.must(find_by({ id: pkey }))
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      sig { override.params(attributes: T::Hash[T.any(Symbol, String), T.untyped]).void }
+      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 App.config.db_extensions.include?(:pg_json)
+
+        attributes.each_pair do |key, value|
+          next unless value.is_a?(Hash) || value.is_a?(Array)
+
+          attributes[key] = T.unsafe(Sequel).pg_jsonb_wrap(value)
+        end
+      end
+
+      sig do
+        override.params(
+          hash: T::Hash[Symbol, T.untyped],
+        ).returns(T.nilable(T.attached_class))
+      end
+      def find_by(hash)
+        resolve_first(query.where(hash))
+      end
+
+      # Extra or unknown properties present in the Hash do not raise exceptions at
+      # runtime unless the optional strict argument to from_hash is passed
+      #
+      # Source: https://sorbet.org/docs/tstruct#from_hash-gotchas
+      # "strict" defaults to "false".
+      sig do
+        override.params(
+          query: T.any(Sequel::Dataset, T::Array[T::Hash[Symbol, T.untyped]]),
+          strict: T.nilable(T::Boolean),
+        ).returns(T::Array[T.attached_class])
+      end
+      def resolve(query, strict = nil)
+        strict_loading = strict.nil? ? App.config.db_strict_type_resolving : strict
+
+        query.map do |row|
+          row = T.cast(row, T::Hash[Symbol, T.untyped])
+          row.transform_keys!(&:to_s) # sequel returns symbolized keys
+          from_hash(row, strict_loading)
+        end
+      end
+
+      sig do
+        override.params(
+          query: Sequel::Dataset,
+          strict: T.nilable(T::Boolean),
+        ).returns(T.nilable(T.attached_class))
+      end
+      def resolve_first(query, strict = nil)
+        strict_loading = strict.nil? ? App.config.db_strict_type_resolving : strict
+
+        resolve(query.limit(1), strict_loading).first
+      end
+
+      # defaults to 6
+      sig { override.returns(Integer) }
+      def human_id_length = 6
+
+      # defaults to "model_name" (table_name without the trailing "s")
+      sig { override.returns(String) }
+      def human_id_prefix = model_name
+
+      #
+      # Generates a human-readable ID for the record.
+      # The ID is prefixed with the table name and an underscore.
+      #
+      sig { override.returns(String) }
+      def generate_human_id
+        Kirei::Model::HumanIdGenerator.call(
+          length: human_id_length,
+          prefix: human_id_prefix,
+        )
+      end
+    end
+  end
+end

data/lib/kirei/model/human_id_generator.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Model
+    class HumanIdGenerator
+      extend T::Sig
+
+      # Removed ambiguous characters 0, 1, O, I, l, 5, S
+      ALLOWED_CHARS = "2346789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrtuvwxyz"
+      private_constant :ALLOWED_CHARS
+
+      ALLOWED_CHARS_COUNT = T.let(ALLOWED_CHARS.size, Integer)
+      private_constant :ALLOWED_CHARS_COUNT
+
+      sig do
+        params(
+          length: Integer,
+          prefix: String,
+        ).returns(String)
+      end
+      def self.call(length:, prefix:)
+        "#{prefix}_#{random_id(length)}"
+      end
+
+      sig { params(key_length: Integer).returns(String) }
+      private_class_method def self.random_id(key_length)
+        random_chars = Array.new(key_length)
+
+        key_length.times do |idx|
+          random_char_idx = SecureRandom.random_number(ALLOWED_CHARS_COUNT)
+          random_char = T.must(ALLOWED_CHARS[random_char_idx])
+          random_chars[idx] = random_char
+        end
+
+        random_chars.join
+      end
+    end
+  end
+end

data/lib/kirei/model.rb

@@ -6,7 +6,7 @@ module Kirei
     extend T::Sig
     extend T::Helpers
 
-    sig { returns(BaseClassInterface) }
+    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.
@@ -18,7 +18,7 @@ module Kirei
     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.db.where({ id: id }).update(hash)
+      self.class.query.where({ id: id }).update(hash)
       self.class.find_by({ id: id })
     end
 
@@ -26,7 +26,7 @@ module Kirei
     # Calling delete multiple times will return false after the first (successful) call.
     sig { returns(T::Boolean) }
     def delete
-      count = self.class.db.where({ id: id }).delete
+      count = self.class.query.where({ id: id }).delete
       count == 1
     end
 
@@ -47,177 +47,6 @@ module Kirei
       end
     end
 
-    module BaseClassInterface
-      extend T::Sig
-      extend T::Helpers
-      interface!
-
-      sig { abstract.params(hash: T.untyped).returns(T.untyped) }
-      def find_by(hash)
-      end
-
-      sig { abstract.params(hash: T.untyped).returns(T.untyped) }
-      def where(hash)
-      end
-
-      sig { abstract.returns(T.untyped) }
-      def all
-      end
-
-      sig { abstract.params(hash: T.untyped).returns(T.untyped) }
-      def create(hash)
-      end
-
-      sig { abstract.params(attributes: T.untyped).void }
-      def wrap_jsonb_non_primivitives!(attributes)
-      end
-
-      sig { abstract.params(hash: T.untyped).returns(T.untyped) }
-      def resolve(hash)
-      end
-
-      sig { abstract.params(hash: T.untyped).returns(T.untyped) }
-      def resolve_first(hash)
-      end
-
-      sig { abstract.returns(T.untyped) }
-      def table_name
-      end
-
-      sig { abstract.returns(T.untyped) }
-      def db
-      end
-    end
-
-    module ClassMethods
-      extend T::Sig
-      extend T::Generic
-
-      # the attached class is the class that extends this module
-      # e.g. "User"
-      # extend T::Generic
-      # has_attached_class!
-      has_attached_class!
-
-      include BaseClassInterface
-
-      # defaults to a pluralized, underscored version of the class name
-      sig { override.returns(String) }
-      def table_name
-        @table_name ||= T.let(
-          begin
-            table_name_ = Kirei::Helpers.underscore(T.must(name.split("::").last))
-            "#{table_name_}s"
-          end,
-          T.nilable(String),
-        )
-      end
-
-      sig { override.returns(Sequel::Dataset) }
-      def db
-        App.raw_db_connection[table_name.to_sym]
-      end
-
-      sig do
-        override.params(
-          hash: T::Hash[Symbol, T.untyped],
-        ).returns(T::Array[T.attached_class])
-      end
-      def where(hash)
-        resolve(db.where(hash))
-      end
-
-      sig { override.returns(T::Array[T.attached_class]) }
-      def all
-        resolve(db.all)
-      end
-
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      # default values defined in the model are used, if omitted in the hash
-      sig do
-        override.params(
-          hash: T::Hash[Symbol, T.untyped],
-        ).returns(T.attached_class)
-      end
-      def create(hash)
-        # instantiate a new object to ensure we use default values defined in the model
-        without_id = !hash.key?(:id)
-        hash[:id] = "kirei-fake-id" if without_id
-        new_record = from_hash(Helpers.deep_stringify_keys(hash))
-        all_attributes = T.let(new_record.serialize, T::Hash[String, T.untyped])
-        all_attributes.delete("id") if without_id && all_attributes["id"] == "kirei-fake-id"
-
-        wrap_jsonb_non_primivitives!(all_attributes)
-
-        if new_record.respond_to?(:created_at) && all_attributes["created_at"].nil?
-          all_attributes["created_at"] = Time.now.utc
-        end
-        if new_record.respond_to?(:updated_at) && all_attributes["updated_at"].nil?
-          all_attributes["updated_at"] = Time.now.utc
-        end
-
-        pkey = T.let(db.insert(all_attributes), String)
-
-        T.must(find_by({ id: pkey }))
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-
-      sig { override.params(attributes: T::Hash[T.any(Symbol, String), T.untyped]).void }
-      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 App.config.db_extensions.include?(:pg_json)
-
-        attributes.each_pair do |key, value|
-          next unless value.is_a?(Hash) || value.is_a?(Array)
-
-          attributes[key] = T.unsafe(Sequel).pg_jsonb_wrap(value)
-        end
-      end
-
-      sig do
-        override.params(
-          hash: T::Hash[Symbol, T.untyped],
-        ).returns(T.nilable(T.attached_class))
-      end
-      def find_by(hash)
-        resolve_first(db.where(hash))
-      end
-
-      # Extra or unknown properties present in the Hash do not raise exceptions at
-      # runtime unless the optional strict argument to from_hash is passed
-      #
-      # Source: https://sorbet.org/docs/tstruct#from_hash-gotchas
-      # "strict" defaults to "false".
-      sig do
-        override.params(
-          query: T.any(Sequel::Dataset, T::Array[T::Hash[Symbol, T.untyped]]),
-          strict: T.nilable(T::Boolean),
-        ).returns(T::Array[T.attached_class])
-      end
-      def resolve(query, strict = nil)
-        strict_loading = strict.nil? ? App.config.db_strict_type_resolving : strict
-
-        query.map do |row|
-          row = T.cast(row, T::Hash[Symbol, T.untyped])
-          row.transform_keys!(&:to_s) # sequel returns symbolized keys
-          from_hash(row, strict_loading)
-        end
-      end
-
-      sig do
-        override.params(
-          query: Sequel::Dataset,
-          strict: T.nilable(T::Boolean),
-        ).returns(T.nilable(T.attached_class))
-      end
-      def resolve_first(query, strict = nil)
-        strict_loading = strict.nil? ? App.config.db_strict_type_resolving : strict
-
-        resolve(query.limit(1), strict_loading).first
-      end
-    end
-
-    mixes_in_class_methods(ClassMethods)
+    mixes_in_class_methods(Kirei::Model::ClassMethods)
   end
 end

data/lib/kirei/routing/base.rb

@@ -17,9 +17,14 @@ module Kirei
       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)
-        http_verb = Router::Verb.deserialize(env.fetch("REQUEST_METHOD"))
+        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
@@ -27,18 +32,18 @@ module Kirei
         # -> use https://github.com/cyu/rack-cors ?
         #
 
-        route = Router.instance.get(http_verb, req_path)
+        route = router.get(http_verb, req_path)
         return [404, {}, ["Not Found"]] if route.nil?
 
         params = case route.verb
-                 when Router::Verb::GET
+                 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 Router::Verb::POST, Router::Verb::PUT, Router::Verb::PATCH
+                 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))
@@ -46,7 +51,7 @@ module Kirei
                    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}")
+                   Logging::Logger.logger.warn("Unsupported HTTP verb: #{http_verb.serialize} send to #{req_path}")
                    {}
         end
 
@@ -58,7 +63,19 @@ module Kirei
         before_hooks = collect_hooks(controller, :before_hooks)
         run_hooks(before_hooks)
 
-        status, headers, body = T.cast(
+        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,
         )
@@ -75,14 +92,30 @@ module Kirei
         [
           status,
           headers,
-          body,
+          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
 
       #
-      # Kirei::App#render
       # * "status": defaults to 200
-      # * "headers": defaults to an empty hash
+      # * "headers": Kirei adds some default headers for security, but the user can override them
       #
       sig do
         params(
@@ -92,8 +125,6 @@ module Kirei
         ).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,
@@ -103,7 +134,7 @@ module Kirei
 
       sig { returns(T::Hash[String, String]) }
       def default_headers
-        # "Access-Control-Allow-Origin": the user should set that
+        # "Access-Control-Allow-Origin": the user should set that, see comment about "cors" above
         {
           # security relevant headers
           "X-Frame-Options" => "DENY",

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

@@ -10,7 +10,7 @@ module Kirei
     #
     # Router.add_routes([
     #   Route.new(
-    #     verb: Kirei::Router::Verb::GET,
+    #     verb: Verb::GET,
     #     path: "/livez",
     #     controller: Controllers::HealthController,
     #     action: "livez",
@@ -21,36 +21,6 @@ module Kirei
       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

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