kirei 0.0.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b67435621f32def7ede1b291b5d0fe529125bda4dd34149afa5b7db6d2193ddd
-  data.tar.gz: fb6c0e91a22bdb8cf726f638c5a250c5245c9a2de4e662f853d2b436a865d2fe
+  metadata.gz: 8a37402ff7c216a16e3cc2a279d477e91d7ed8c40fd58169a8c598e47efd90d7
+  data.tar.gz: 1fd249f44b20dc1dfba0ace6ea52f6de6f67ee47e4c2a7f511438ceafba4985f
 SHA512:
-  metadata.gz: 5529b60454e2389fb5df0ff5fad1cdc5f3b1c8385396aa3f65d977db9bb6ceccbd9e93de70de7dba4f719681f8332cc30a2dfd087117589c274b7ad5f99926ef
-  data.tar.gz: 61f28174f219f9968e59183d473a4296d0fe659e3104b4ab2debe8e7cef27de077f653279a9897f7fc71af541597b8b90c3cf8ef66c0cbbadd40984f1520d1a4
+  metadata.gz: d6d29c323e8b3438a0c9775f2b92312182a709443aa04843145bfed76226d71e2d78081361b178dc6293dfefa75571d525981b5ed84fee2664c93a880eb5f6fa
+  data.tar.gz: 6b33ff256a0a199333d789c81ff70f4dca49225069f0c854fe0f4cfec4c6a68c918a6966b92c93ef76aebd14117029c5f3e7ad36d65d7d74033c5d7a0f905ab4

data/CHANGELOG.md

@@ -1,5 +1,16 @@
+# Changelog
+
 ## [Unreleased]
 
 ## [0.1.0] - 2023-09-02
 
 - Initial release
+- added base model
+- added database connection
+- WIP: basic cli to scaffold a new project
+
+## [0.2.0] - 2023-09-02
+
+- added routing
+- added base controller
+- added database tasks (create, drop, migrate, rollback, generate migration)

data/README.md

@@ -49,6 +49,10 @@ bundle exec kirei new "MyApp"
 
 ### Quick Start
 
+Find a test app in the [spec/test_app](spec/test_app) directory. It is a fully functional example of a Kirei app.
+
+#### Models
+
 All models must inherit from `T::Struct` and include `Kirei::BaseModel`. They must implement `id` which must hold the primary key of the table. The primary key must be named `id` and be of type `T.any(String, Integer)`.
 
 ```ruby
@@ -86,6 +90,93 @@ first_user = User.resolve_first(query) # T.nilable(User)
 first_user = User.from_hash(query.first.stringify_keys)
 ```
 
+#### Database Migrations
+
+Read the [Sequel Migrations](https://github.com/jeremyevans/sequel/blob/5.78.0/doc/schema_modification.rdoc) documentation for detailed information.
+
+```ruby
+Sequel.migration do
+  up do
+    create_table(:airports) do
+      primary_key :id
+      String :name, null: false
+    end
+  end
+
+  down do
+    drop_table(:airports)
+  end
+end
+```
+
+Applying migrations:
+
+```shell
+# create the database
+bundle exec rake db:create
+
+# drop the database
+bundle exec rake db:drop
+
+# apply all pending migrations
+bundle exec rake db:migrate
+
+# roll back the last n migration
+STEPS=1 bundle exec rake db:rollback
+
+# run db/seeds.rb to seed the database
+bundle exec rake db:migrate
+
+# scaffold a new migration file
+bundle exec rake 'db:migration[CreateAirports]'
+```
+
+#### Routing
+
+Define routes anywhere in your app; by convention, they are defined in `config/routes.rb`:
+
+```ruby
+# config/routes.rb
+
+Kirei::Router.add_routes([
+  Kirei::Router::Route.new(
+    verb: "GET",
+    path: "/livez",
+    controller: Controllers::Health,
+    action: "livez",
+  ),
+
+  Kirei::Router::Route.new(
+    verb: "GET",
+    path: "/airports",
+    controller: Controllers::Airports,
+    action: "index",
+  ),
+])
+```
+
+#### Controllers
+
+Controllers can be defined anywhere; by convention, they are defined in the `app/controllers` directory:
+
+```ruby
+module Controllers
+  class Airports < Kirei::BaseController
+    extend T::Sig
+
+    sig { returns(Kirei::Middleware::RackResponseType) }
+    def index
+      airports = Airport.all
+
+      # or use a serializer
+      data = Oj.dump(airports.map(&:serialize))
+
+      render(status: 200, body: data)
+    end
+  end
+end
+```
+
 ## Contributions
 
 We welcome contributions from the community. Before starting work on a major feature, please get in touch with us either via email or by opening an issue on GitHub. "Major feature" means anything that changes user-facing features or significant changes to the codebase itself.

data/kirei.gemspec

@@ -45,14 +45,12 @@ Gem::Specification.new do |spec|
 
   # Utilities
   spec.add_dependency "oj", "~> 3.0"
-  spec.add_dependency "rake", "~> 13.0"
   spec.add_dependency "sorbet-runtime", "~> 0.5"
   spec.add_dependency "tzinfo-data", "~> 1.0" # for containerized environments, e.g. on AWS ECS
 
   # Web server & routing
   spec.add_dependency "puma", "~> 6.0"
-  spec.add_dependency "sinatra", "~> 3.0"
-  spec.add_dependency "sinatra-contrib", "~> 3.0"
+  spec.add_dependency "rack", "~> 3.0"
 
   # Database (Postgres)
   spec.add_dependency "pg", "~> 1.0"

data/lib/boot.rb

@@ -15,16 +15,9 @@ require "bundler/setup"
 require "logger"
 require "sorbet-runtime"
 require "oj"
-require "puma"
-require "sinatra"
-require "sinatra/namespace" # from sinatra-contrib
+require "rack"
 require "pg"
 require "sequel" # "sequel_pg" is auto-required by "sequel"
 
-Oj.default_options = {
-  mode: :compat, # required to dump hashes with symbol-keys
-  symbol_keys: false, # T::Struct.new works only with string-keys
-}
-
 # Third: load all application code
 Dir[File.join(__dir__, "kirei/**/*.rb")].each { require(_1) }

data/lib/cli/commands/new_app/base_directories.rb

@@ -25,6 +25,9 @@ module Cli
             "db/migrate",
             "db/seeds",
 
+            "lib",
+            "lib/tasks",
+
             "sorbet",
             "sorbet/rbi",
             "sorbet/rbi/shims",

data/lib/cli/commands/new_app/execute.rb

@@ -9,7 +9,11 @@ module Cli
         def self.call(app_name:)
           BaseDirectories.call
           Files::App.call(app_name)
+          Files::ConfigRu.call(app_name)
+          Files::DbRake.call(app_name)
           Files::Irbrc.call
+          Files::Rakefile.call
+          Files::Routes.call
 
           Kirei::Logger.logger.info(
             "Kirei app '#{app_name}' scaffolded successfully!",

data/lib/cli/commands/new_app/files/app.rb

@@ -10,11 +10,33 @@ module Cli
           end
 
           def self.content(app_name)
+            snake_case_app_name = app_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+
             <<~RUBY
               # typed: true
               # frozen_string_literal: true
 
-              class #{app_name} < Kirei::Base
+              # First: check if all gems are installed correctly
+              require "bundler/setup"
+
+              # Second: load all gems
+              #         we have runtime/production ("default") and development gems ("development")
+              Bundler.require(:default)
+              Bundler.require(:development) if ENV["RACK_ENV"] == "development"
+              Bundler.require(:test) if ENV["RACK_ENV"] == "test"
+
+              # Third: load all initializers
+              Dir[File.join(__dir__, "config/initializers", "*.rb")].each { require(_1) }
+
+              # Fourth: load all application code
+              Dir[File.join(__dir__, "app/**/*", "*.rb")].each { require(_1) }
+
+              # Fifth: load configs
+              Dir[File.join(__dir__, "config", "*.rb")].each { require(_1) }
+
+              class #{app_name} < Kirei::AppBase
+                # Kirei configuration
+                config.app_name = "#{snake_case_app_name}"
               end
             RUBY
           end

data/lib/cli/commands/new_app/files/config_ru.rb

@@ -0,0 +1,34 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class ConfigRu
+          def self.call(app_name)
+            File.write("config.ru", content(app_name))
+          end
+
+          def self.content(app_name)
+            <<~RUBY
+              # typed: false
+              # frozen_string_literal: true
+
+              require_relative("app")
+
+              # Load middlewares here
+              use(Rack::Reloader, 0) if #{app_name}.environment == "development"
+
+              # Launch the app
+              run(#{app_name}.new)
+
+              # "use" all controllers
+              # store all routes in a global variable to render (localhost only)
+              # put "booted" statement
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/commands/new_app/files/db_rake.rb

@@ -0,0 +1,178 @@
+# typed: false
+
+# rubocop:disable Metrics/ClassLength
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class DbRake
+          def self.call(app_name)
+            # set db_name to snake_case version of app_name
+            db_name = app_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+            File.write("lib/tasks/db.rake", content(app_name, db_name))
+          end
+
+          def self.content(app_name, db_name)
+            <<~RUBY
+              # typed: false
+
+              # run on the database server once:
+              #
+              #   CREATE DATABASE #{db_name}_${environment};
+
+              require_relative "../../app"
+
+              namespace :db do
+                # RACK_ENV=development bundle exec rake db:create
+                desc "Create the database"
+                task :create do
+                  envs = ENV.key?("RACK_ENV") ? [ENV.fetch("RACK_ENV")] : %w[development test]
+                  envs.each do |env|
+                    ENV["RACK_ENV"] = env
+                    db_name = "#{db_name}_#{env}"
+                    puts("Creating database \#{db_name}...")
+
+                    reset_memoized_class_level_instance_vars(#{app_name})
+                    url = #{app_name}.default_db_url.dup # frozen string
+                    url.gsub!(db_name, "postgres")
+                    puts("Connecting to \#{url.gsub(%r{://.*@}, "_REDACTED_")}")
+                    db = Sequel.connect(url)
+
+                    begin
+                      db.execute("CREATE DATABASE \#{db_name}")
+                      puts("Created database \#{db_name}.")
+                    rescue Sequel::DatabaseError, PG::DuplicateDatabase
+                      puts("Database \#{db_name} already exists, skipping.")
+                    end
+                  end
+                end
+
+                desc "Drop the database"
+                task :drop do
+                  envs = ENV.key?("RACK_ENV") ? [ENV.fetch("RACK_ENV")] : %w[development test]
+                  envs.each do |env|
+                    ENV["RACK_ENV"] = env
+                    db_name = "#{db_name}_\#{env}"
+                    puts("Dropping database \#{db_name}...")
+
+                    reset_memoized_class_level_instance_vars(#{app_name})
+                    url = #{app_name}.default_db_url.dup  # frozen string
+                    url.gsub!(db_name, "postgres")
+                    puts("Connecting to \#{url.gsub(%r{://.*@}, "_REDACTED_")}")
+                    db = Sequel.connect(url)
+
+                    begin
+                      db.execute("DROP DATABASE \#{db_name} (FORCE)")
+                      puts("Dropped database \#{db_name}.")
+                    rescue Sequel::DatabaseError, PG::DuplicateDatabase
+                      puts("Database \#{db_name} does not exists, nothing to drop.")
+                    end
+                  end
+                end
+
+                desc "Run migrations"
+                task :migrate do
+                  Sequel.extension(:migration)
+                  envs = ENV.key?("RACK_ENV") ? [ENV.fetch("RACK_ENV")] : %w[development test]
+                  envs.each do |env|
+                    ENV["RACK_ENV"] = env
+                    db_name = "#{db_name}_\#{env}"
+                    reset_memoized_class_level_instance_vars(#{app_name})
+                    db = Sequel.connect(#{app_name}.default_db_url)
+                    Sequel::Migrator.run(db, File.join(#{app_name}.root, "db/migrate"))
+                    current_version = db[:schema_migrations].order(:filename).last[:filename].to_i
+                    puts "Migrated \#{db_name} to version \#{current_version}!"
+                  end
+                end
+
+                desc "Rollback the last migration"
+                task :rollback do
+                  envs = ENV.key?("RACK_ENV") ? [ENV.fetch("RACK_ENV")] : %w[development test]
+                  Sequel.extension(:migration)
+                  envs.each do |env|
+                    ENV["RACK_ENV"] = env
+                    db_name = "#{db_name}_\#{env}"
+                    reset_memoized_class_level_instance_vars(#{app_name})
+                    db = Sequel.connect(#{app_name}.default_db_url)
+
+                    steps = (ENV["STEPS"] || 1).to_i + 1
+                    versions = db[:schema_migrations].order(:filename).all
+
+                    if versions[-steps].nil?
+                      puts "No more migrations to rollback"
+                    else
+                      target_version = versions[-steps][:filename].to_i
+
+                      Sequel::Migrator.run(db, File.join(#{app_name}.root, "db/migrate"), target: target_version)
+                      puts "Rolled back \#{db_name} \#{steps} steps to version \#{target_version}"
+                    end
+                  end
+                end
+
+                desc "Seed the database"
+                task :seed do
+                  load File.join(#{app_name}.root, "db/seeds.rb")
+                end
+
+                desc "Generate a new migration file"
+                task :migration, [:name] do |_t, args|
+                  require "fileutils"
+                  require "time"
+
+                  # Ensure the migrations directory exists
+                  migrations_dir = File.join(#{app_name}.root, "db/migrate")
+                  FileUtils.mkdir_p(migrations_dir)
+
+                  # Generate the migration number
+                  migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S")
+
+                  # Sanitize and format the migration name
+                  formatted_name = args[:name].to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+
+                  # Combine them to create the filename
+                  filename = "\#{migration_number}_\#{formatted_name}.rb"
+                  file_path = File.join(migrations_dir, filename)
+
+                  # Define the content of the migration file
+                  content = <<~MIGRATION
+                    # typed: strict
+                    # frozen_string_literal: true
+
+                    Sequel.migration do
+                      up do
+                        # your code here
+                      end
+
+                      down do
+                        # your code here
+                      end
+                    end
+                  MIGRATION
+
+                  # Write the migration file
+                  File.write(file_path, content)
+
+                  puts "Generated migration: db/migrate/\#{filename}"
+                end
+              end
+
+              def reset_memoized_class_level_instance_vars(app)
+                %i[
+                  @default_db_name
+                  @default_db_url
+                  @raw_db_connection
+                ].each do |ivar|
+                  app.remove_instance_variable(ivar) if app.instance_variable_defined?(ivar)
+                end
+              end
+
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/ClassLength

data/lib/cli/commands/new_app/files/irbrc.rb

@@ -16,10 +16,10 @@ module Cli
               # Kirei needs to know where the root of the project is
               APP_ROOT = File.expand_path(__dir__)
 
-              ENV['RACK_ENV'] ||= 'development'
-              ENV['APP_VERSION'] ||= (ENV['GIT_SHA'] ||= `git rev-parse --short HEAD`.to_s.chomp.freeze)
-              require('dotenv/load') if %w[test development].include?(ENV['RACK_ENV'])
-              require_relative('app')
+              ENV["RACK_ENV"] ||= "development"
+              ENV["APP_VERSION"] ||= (ENV["GIT_SHA"] ||= `git rev-parse --short HEAD`.to_s.chomp.freeze)
+              require("dotenv/load") if %w[test development].include?(ENV["RACK_ENV"])
+              require_relative("app")
             RUBY
           end
         end

data/lib/cli/commands/new_app/files/rakefile.rb

@@ -0,0 +1,27 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class Rakefile
+          def self.call
+            File.write("Rakefile", content)
+          end
+
+          def self.content
+            <<~RUBY
+              # typed: false
+              # frozen_string_literal: true
+
+              require "rake"
+
+              Dir.glob("lib/tasks/**/*.rake").each { import(_1) }
+
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/commands/new_app/files/routes.rb

@@ -0,0 +1,31 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class Routes
+          def self.call
+            File.write("config/routes.rb", content)
+          end
+
+          def self.content
+            <<~RUBY
+              # typed: strict
+              # frozen_string_literal: true
+
+              Kirei::Router.add_routes([
+                # Kirei::Router::Route.new(
+                #   verb: "GET",
+                #   path: "/livez",
+                #   controller: Controllers::HealthController,
+                #   action: "livez",
+                # )
+              ])
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/commands/start.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: true
 
 require "fileutils"
 
@@ -9,7 +9,8 @@ module Cli
         case args[0]
         when "new"
           app_name = args[1] || "MyApp"
-          app_name = app_name.gsub(/[-\s]/, "_").classify
+          app_name = app_name.gsub(/[-\s]/, "_")
+          app_name = app_name.split("_").map(&:capitalize).join if app_name.include?("_")
           NewApp::Execute.call(app_name: app_name)
         else
           Kirei::Logger.logger.info("Unknown command")

data/lib/kirei/app.rb

@@ -0,0 +1,72 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative("middleware")
+
+# rubocop:disable Metrics/AbcSize, Layout/LineLength
+
+module Kirei
+  class App
+    include Middleware
+    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 = T.cast(env.fetch("REQUEST_METHOD"), String)
+      req_path = T.cast(env.fetch("REQUEST_PATH"), String)
+      # 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 = if route.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
+      else
+        # 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])
+      end
+
+      instance = route.controller.new(params: params)
+      instance.public_send(route.action)
+    end
+
+    sig do
+      params(
+        status: Integer,
+        body: String,
+        headers: T::Hash[String, String],
+      ).returns(RackResponseType)
+    end
+    def render(status:, body:, 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
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Layout/LineLength

data/lib/kirei/app_base.rb

@@ -1,8 +1,10 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative("app")
+
 module Kirei
-  class AppBase < ::Sinatra::Base
+  class AppBase < Kirei::App
     class << self
       extend T::Sig
 
@@ -55,7 +57,12 @@ module Kirei
         @raw_db_connection = Sequel.connect(AppBase.config.db_url || default_db_url)
 
         config.db_extensions.each do |ext|
-          @raw_db_connection.extension(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

data/lib/kirei/base_controller.rb

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

data/lib/kirei/base_model.rb

@@ -16,10 +16,37 @@ module Kirei
       ).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.db.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.db.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
+
     module BaseClassInterface
       extend T::Sig
       extend T::Helpers
@@ -33,6 +60,18 @@ module Kirei
       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
@@ -88,6 +127,54 @@ module Kirei
         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 AppBase.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],
@@ -104,7 +191,7 @@ module Kirei
       # "strict" defaults to "false".
       sig do
         override.params(
-          query: Sequel::Dataset,
+          query: T.any(Sequel::Dataset, T::Array[T::Hash[Symbol, T.untyped]]),
           strict: T.nilable(T::Boolean),
         ).returns(T::Array[T.attached_class])
       end
@@ -125,7 +212,9 @@ module Kirei
         ).returns(T.nilable(T.attached_class))
       end
       def resolve_first(query, strict = nil)
-        resolve(query.limit(1), strict).first
+        strict_loading = strict.nil? ? AppBase.config.db_strict_type_resolving : strict
+
+        resolve(query.limit(1), strict_loading).first
       end
     end
 

data/lib/kirei/config.rb

@@ -17,16 +17,18 @@ module Kirei
 
     prop :logger, ::Logger, factory: -> { ::Logger.new($stdout) }
     prop :log_transformer, T.nilable(T.proc.params(msg: T::Hash[Symbol, T.untyped]).returns(T::Array[String]))
+    prop :log_default_metadata, T::Hash[Symbol, String], default: {}
+
     # dup to allow the user to extend the existing list of sensitive keys
     prop :sensitive_keys, T::Array[Regexp], factory: -> { SENSITIVE_KEYS.dup }
+
     prop :app_name, String, default: "kirei"
-    prop :db_url, T.nilable(String)
 
     # must use "pg_json" to parse jsonb columns to hashes
     #
     # Source: https://github.com/jeremyevans/sequel/blob/5.75.0/lib/sequel/extensions/pg_json.rb
     prop :db_extensions, T::Array[Symbol], default: %i[pg_json pg_array]
-
+    prop :db_url, T.nilable(String)
     # Extra or unknown properties present in the Hash do not raise exceptions at runtime
     # unless the optional strict argument to from_hash is passed
     #

data/lib/kirei/helpers.rb

@@ -23,6 +23,26 @@ module Kirei
         string.nil? || string.to_s.empty?
       end
 
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_stringify_keys(object)
+        deep_transform_keys(object) { _1.to_s rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_stringify_keys!(object)
+        deep_transform_keys!(object) { _1.to_s rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_symbolize_keys(object)
+        deep_transform_keys(object) { _1.to_sym rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_symbolize_keys!(object)
+        deep_transform_keys!(object) { _1.to_sym rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
       # Simplified version from Rails' ActiveSupport
       sig do
         params(
@@ -30,7 +50,7 @@ module Kirei
           block: Proc,
         ).returns(T.untyped) # could be anything due to recursive calls
       end
-      def deep_transform_keys(object, &block)
+      private def deep_transform_keys(object, &block)
         case object
         when Hash
           object.each_with_object({}) do |(key, value), result|
@@ -49,7 +69,7 @@ module Kirei
           block: Proc,
         ).returns(T.untyped) # could be anything due to recursive calls
       end
-      def deep_transform_keys!(object, &block)
+      private def deep_transform_keys!(object, &block)
         case object
         when Hash
           # using `each_key` results in a `RuntimeError: can't add a new key into hash during iteration`

data/lib/kirei/logger.rb

@@ -17,12 +17,12 @@ module Kirei
   #
   # You can define a custom log transformer to transform the logline:
   #
-  #    Kirei.config.log_transformer = Proc.new { _1 }
+  #    Kirei::AppBase.config.log_transformer = Proc.new { _1 }
   #
-  # By default, "meta" is flattened, and sensitive values are masked using see `Kirei.config.sensitive_keys`.
+  # By default, "meta" is flattened, and sensitive values are masked using see `Kirei::AppBase.config.sensitive_keys`.
   # You can also build on top of the provided log transformer:
   #
-  #   Kirei.config.log_transformer = Proc.new do |meta|
+  #   Kirei::AppBase.config.log_transformer = Proc.new do |meta|
   #      flattened_meta = Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta)
   #      # Do something with the flattened meta
   #      flattened_meta.map { _1.to_json }
@@ -30,7 +30,9 @@ module Kirei
   #
   # NOTE: The log transformer must return an array of strings to allow emitting multiple lines per log event.
   #
-  class Logger < Kirei::Base
+  class Logger
+    extend T::Sig
+
     FILTERED = "[FILTERED]"
 
     @instance = T.let(nil, T.nilable(Kirei::Logger))
@@ -83,7 +85,16 @@ module Kirei
       ).void
     end
     def call(level:, label:, meta: {})
+      Kirei::AppBase.config.log_default_metadata.each_pair do |key, value|
+        meta[key] ||= value
+      end
+
+      #
+      # key names follow OpenTelemetry Semantic Conventions
+      # Source: https://opentelemetry.io/docs/concepts/semantic-conventions/
+      #
       meta[:"service.instance.id"] ||= Thread.current[:request_id]
+      meta[:"service.name"] ||= Kirei::AppBase.config.app_name
 
       # The Ruby logger only accepts one string as the only argument
       @queue << { level: level, label: label, meta: meta }
@@ -107,7 +118,10 @@ module Kirei
           loglines = if log_transformer
             log_transformer.call(meta)
           else
-            [Oj.dump(Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta))]
+            [Oj.dump(
+              Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta),
+              Kirei::OJ_OPTIONS,
+            )]
           end
 
           loglines.each { Kirei::Logger.logger.error(_1) }
@@ -131,19 +145,24 @@ module Kirei
 
     sig do
       params(
-        hash: T::Hash[Symbol, T.untyped],
+        hash: T::Hash[T.any(Symbol, String), T.untyped],
         prefix: Symbol,
       ).returns(T::Hash[Symbol, T.untyped])
     end
     def self.flatten_hash_and_mask_sensitive_values(hash, prefix = :'')
       result = T.let({}, T::Hash[Symbol, T.untyped])
-      Kirei::Helpers.deep_transform_keys!(hash) { _1.to_sym rescue _1 } # rubocop:disable Style/RescueModifier
+      Kirei::Helpers.deep_symbolize_keys!(hash)
+      hash = T.cast(hash, T::Hash[Symbol, T.untyped])
 
       hash.each do |key, value|
         new_prefix = Kirei::Helpers.blank?(prefix) ? key : :"#{prefix}.#{key}"
 
         case value
-        when Hash then result.merge!(flatten_hash_and_mask_sensitive_values(value.transform_keys(&:to_sym), new_prefix))
+        when Hash
+          # Some libraries have a custom Hash class that inhert from Hash, but act differently, e.g. OmniAuth::AuthHash.
+          # This results in `transform_keys` being available but without any effect.
+          value = value.to_h if value.class != Hash
+          result.merge!(flatten_hash_and_mask_sensitive_values(value.transform_keys(&:to_sym), new_prefix))
         when Array
           value.each_with_index do |element, index|
             if element.is_a?(Hash) || element.is_a?(Array)

data/lib/kirei/middleware.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# 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
+
+    RackEnvType = T.type_alias do
+      T::Hash[
+        String,
+        T.any(
+          T::Array[T.untyped],
+          IO,
+          T::Boolean,
+          String,
+          Numeric,
+          TCPSocket,
+          Puma::Client,
+          StringIO,
+          Puma::Configuration,
+        )
+      ]
+    end
+  end
+end

data/lib/kirei/router.rb

@@ -0,0 +1,61 @@
+# 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

data/lib/kirei/version.rb

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

data/lib/kirei.rb

@@ -6,6 +6,17 @@ require "boot"
 module Kirei
   extend T::Sig
 
+  # we don't know what Oj does under the hood with the options hash, so don't freeze it
+  # rubocop:disable Style/MutableConstant
+  OJ_OPTIONS = T.let(
+    {
+      mode: :compat, # required to dump hashes with symbol-keys
+      symbol_keys: false, # T::Struct.new works only with string-keys
+    },
+    T::Hash[Symbol, T.untyped],
+  )
+  # rubocop:enable Style/MutableConstant
+
   GEM_ROOT = T.let(
     Gem::Specification.find_by_name("kirei").gem_dir,
     String,

data/sorbet/rbi/shims/base_model.rbi

@@ -3,6 +3,9 @@
 # rubocop:disable Style/EmptyMethod
 module Kirei
   module BaseModel
+    include Kernel # "self" is a class since we include the module in a class
+    include T::Props::Serializable
+
     sig { returns(T.any(String, Integer)) }
     def id; end
 
@@ -12,6 +15,10 @@ module Kirei
       sig { returns(String) }
       def name; end
     end
+
+    module BaseClassInterface
+      # include T::Props::Serializable::ClassMethods
+    end
   end
 end
 # rubocop:enable Style/EmptyMethod

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kirei
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Ludwig Reinmiedl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-31 00:00:00.000000000 Z
+date: 2024-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -81,21 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: sinatra
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: sinatra-contrib
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -173,16 +145,22 @@ files:
 - lib/cli/commands/new_app/base_directories.rb
 - lib/cli/commands/new_app/execute.rb
 - lib/cli/commands/new_app/files/app.rb
+- lib/cli/commands/new_app/files/config_ru.rb
+- lib/cli/commands/new_app/files/db_rake.rb
 - lib/cli/commands/new_app/files/irbrc.rb
+- lib/cli/commands/new_app/files/rakefile.rb
+- lib/cli/commands/new_app/files/routes.rb
 - lib/cli/commands/start.rb
 - lib/kirei.rb
+- lib/kirei/app.rb
 - lib/kirei/app_base.rb
-- lib/kirei/base.rb
 - lib/kirei/base_controller.rb
 - lib/kirei/base_model.rb
 - lib/kirei/config.rb
 - lib/kirei/helpers.rb
 - lib/kirei/logger.rb
+- lib/kirei/middleware.rb
+- lib/kirei/router.rb
 - lib/kirei/version.rb
 - sorbet/rbi/shims/base_model.rbi
 homepage: https://github.com/swiknaba/kirei
@@ -206,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Kirei is a strictly typed Ruby micro/REST-framework for building scaleable

data/lib/kirei/base.rb

@@ -1,8 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Kirei
-  class Base
-    extend T::Sig
-  end
-end