kirei 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cea2982351607eeafadd7e8ee3bb3ce13ba2c7e1e37eed22fa2f5a124b625022
-  data.tar.gz: 84a47be77945fa7a2faf5950441290fde74293388467729f2eb52c1c6041d29b
+  metadata.gz: 7eaf9be851bf8985a4c169c4ed79c3bc3cc067b247b0cc50e1f742447e019c3d
+  data.tar.gz: 47816fbc66608113d804e9efcbc7267cd3deea522edcdc8c5920d7ac365cd1b6
 SHA512:
-  metadata.gz: 3b420ea6cbfce60bf741bfd85cbfeb310dfd71031519a6d5fcc330bff788d24a0df1ef7268abbdbe49a2f373f4ff5df413dc6cf1b83589f96a6f8867164ffcef
-  data.tar.gz: 061a15d94de3e73dcd8d41db48601bfa5390d59aa1438c322d590ec3c33db9da4dd38d1f9258bf37a13c248ded433883a6da9ff52d41ee5873ca13b0cda414ca
+  metadata.gz: 2f66ca601807ae0f8528f59b0303812d6bf2b644a910284f4caedbe413c5865d3634c12a6a8e30c1a3ae85ff44f7f80fd8b69c48a977e4cec98260b30c09d56e
+  data.tar.gz: 8ec07fe4d0a69c0918026a966e96eb1257767e187c9bde5edc9d5be9f6796269bccc5f989c399df8e211965f1014c51a24739c638a78cee971b4dddb9abdf821

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,13 +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 "sinatra", "~> 3.0"
-  spec.add_dependency "sinatra-contrib", "~> 3.0"
+  spec.add_dependency "puma", "~> 6.0"
+  spec.add_dependency "rack", "~> 3.0"
 
   # Database (Postgres)
   spec.add_dependency "pg", "~> 1.0"

data/lib/boot.rb

@@ -15,8 +15,7 @@ require "bundler/setup"
 require "logger"
 require "sorbet-runtime"
 require "oj"
-require "sinatra"
-require "sinatra/namespace" # from sinatra-contrib
+require "rack"
 require "pg"
 require "sequel" # "sequel_pg" is auto-required by "sequel"
 

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,12 @@ 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
+          Files::SorbetConfig.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: false
+                    # 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/new_app/files/sorbet_config.rb

@@ -0,0 +1,25 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class SorbetConfig
+          def self.call
+            File.write("sorbet/config", content)
+          end
+
+          def self.content
+            <<~TXT
+              --dir
+              .
+              --ignore=vendor/
+              --ignore=spec/
+
+            TXT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/commands/start.rb

@@ -9,8 +9,8 @@ module Cli
         case args[0]
         when "new"
           app_name = args[1] || "MyApp"
-          # @TODO(lud, 31.12.2023): classify is from ActiveSupport -> remove this?
-          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
 

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

@@ -60,6 +60,10 @@ 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
@@ -123,6 +127,11 @@ 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
@@ -182,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

data/lib/kirei/logger.rb

@@ -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))

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.1.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kirei
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Ludwig Reinmiedl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-02 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
@@ -67,21 +53,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: sinatra
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: sinatra-contrib
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -159,16 +145,23 @@ 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/new_app/files/sorbet_config.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
@@ -192,7 +185,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