kirei 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8beff5327a463020ae69872995aa9a5101e492f23fa886f6a29e45cfb173728c
+  data.tar.gz: a2ec68b1e7e7f182d42587d4e73b3736636d883b7d5f93a804956366368467d2
+SHA512:
+  metadata.gz: 7bc7eef26e4ed940d91a425c69a447a585a76c2512132b1986b927652bc5331dddd6e77fc279ee65d7739e9d991bd1881c8c421023e1b4b25f70d5ae0224bd79
+  data.tar.gz: 4f1db54baab633700669e6f7d8f153e73a1f5383ebd9b4c593acd95956699c8bc6b8bafa2d4194aa9a00e13a74bea9bf106a631d48c147d9b60f3f912d75f58d

data/.irbrc

@@ -0,0 +1 @@
+require_relative "./lib/kirei" # rubocop:disable all

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-09-02
+
+- Initial release

data/README.md

@@ -0,0 +1,103 @@
+# Kirei
+
+Kirei is a strictly typed Ruby micro/REST-framework for building scalable and performant APIs. It is built from the ground up to be clean and easy to use. Kirei is based on [Sequel](https://github.com/jeremyevans/sequel) as an ORM, [Sorbet](https://github.com/sorbet/sorbet) for typing, and [Sinatra](https://github.com/sinatra/sinatra) for routing. It strives to have zero magic and to be as explicit as possible.
+
+Kirei's main advantages over other frameworks are its strict typing, low memory footprint, and build-in high-performance logging and metric-tracking toolkits. It is opiniated in terms of tooling, allowing you to focus on your core-business. It is a great choice for building APIs that need to scale.
+
+> Kirei (きれい) is a Japanese adjective that primarily means "beautiful" or "pretty." It can also be used to describe something that is "clean" or "neat."
+
+## Why another Ruby framework?
+
+TL;DR:
+
+* **zero magic**
+* **strict typing**
+* **very few low level dependencies**
+* ultra low memory footprint
+* high performance
+* simple to understand
+
+## Versioning
+
+This gem follows SemVer, however only after a stable release 1.0.0 is made.
+
+A changelog is maintained in the [CHANGELOG.md](CHANGELOG.md) file and/or the GitHub Releases page.
+
+## Installation
+
+Via rubygems:
+
+```ruby
+gem 'kirei'
+```
+
+Test the latest version via git:
+
+```ruby
+gem 'kirei', git: 'git@github.com:swiknaba/kirei', branch: :main
+```
+
+## Usage
+
+### Initial Set Up
+
+Scaffold a new project:
+
+```shell
+bundle exec kirei new "MyApp"
+```
+
+### Quick Start
+
+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
+class User < T::Struct
+  extend T::Sig
+  include Kirei::BaseModel
+
+  const :id, T.any(String, Integer)
+  const :name, String
+end
+
+user = User.find_by({ name: 'John' }) # T.nilable(User)
+users = User.where({ name: 'John' })  # T::Array[User]
+```
+
+Updating a record returns a new instance. The original instance is not mutated:
+
+```ruby
+updated_user = user.update({ name: 'Johnny' })
+user.name         # => 'John'
+updated_user.name # => 'Johnny'
+```
+
+To build more complex queries, Sequel can be used directly:
+
+```ruby
+query = User.db.where({ name: 'John' })
+query = query.where('...')
+query = query.limit(10) # query is a Sequel::Dataset, chain as you like
+
+users = User.resolve(query)            # T::Array[User]
+first_user = User.resolve_first(query) # T.nilable(User)
+
+# you can also cast the raw result manually
+first_user = User.from_hash(query.first.stringify_keys)
+```
+
+## 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.
+
+Please commit small and focused PRs with descriptive commit messages. If you are unsure about a PR, please open a draft PR to get early feedback. A PR must have a short description ("what"), a motiviation ("why"), and, if applicable, instructions how to test the changes, measure performance improvements, etc.
+
+## Publishing a new version
+
+run
+
+```shell
+bin/release
+```
+
+which will guide you through the release process.

data/bin/kirei

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../lib/cli'
+
+Cli::Commands::Start.call(ARGV)

data/kirei.gemspec

@@ -0,0 +1,62 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "kirei/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "kirei"
+  spec.version = Kirei::VERSION
+  spec.authors = [
+    "Ludwig Reinmiedl",
+  ]
+  spec.email = [
+    "lud@reinmiedl.com",
+    "oss@dbl.works",
+  ]
+
+  spec.summary = "Kirei is a strictly typed Ruby micro/REST-framework for building scaleable and performant APIs."
+  spec.description = <<~TXT
+    Kirei's structure und developer experience is inspired by Rails, but it's not a Rails clone.
+    It's a framework that's built from the ground up to be strictly typed, performant and scaleable.
+  TXT
+  spec.homepage = "https://github.com/swiknaba/kirei"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  spec.files = Dir[
+    "kirei.gemspec",
+    ".irbrc",
+    "lib/**/*",
+    "sorbet/rbi/dsl/**/*.rbi",
+    "sorbet/rbi/shims/**/*.rbi",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+  ]
+
+  spec.bindir = "bin"
+  spec.executables = [File.basename("bin/kirei")]
+  spec.require_paths = ["lib"]
+
+  # Utilities
+  spec.add_dependency "activesupport", "~> 6.0"
+  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"
+
+  # Database (Postgres)
+  spec.add_dependency "pg", "~> 1.0"
+  spec.add_dependency "sequel", "~> 5.0"
+  spec.add_dependency "sequel_pg", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/boot.rb

@@ -0,0 +1,31 @@
+# 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 "sorbet-runtime"
+require "oj"
+require "active_support/all"
+require "puma"
+require "sinatra"
+require "sinatra/namespace" # from sinatra-contrib
+require "pg"
+require "sequel"
+# "sequel_pg" should be 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

@@ -0,0 +1,42 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      class BaseDirectories
+        def self.call
+          directories.each do |dir|
+            FileUtils.mkdir_p(dir)
+          end
+        end
+
+        def self.directories
+          [
+            "app",
+            "app/controllers",
+            "app/models",
+            "app/services",
+
+            "bin",
+            "config",
+            "config/initializers",
+
+            "db",
+            "db/migrate",
+            "db/seeds",
+
+            "sorbet",
+            "sorbet/rbi",
+            "sorbet/rbi/shims",
+            "sorbet/tapioca",
+
+            "spec",
+            "spec/factories",
+            "spec/fixtures",
+            "spec/support",
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: false
+
+require "fileutils"
+require "active_support/all"
+
+module Cli
+  module Commands
+    module NewApp
+      class Execute
+        def self.call(app_name:)
+          BaseDirectories.call
+          Files::App.call(app_name)
+          Files::Irbrc.call
+
+          puts "Kirei app '#{app_name}' scaffolded successfully!" # rubocop:disable all
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class App
+          def self.call(app_name)
+            File.write("app.rb", content(app_name))
+          end
+
+          def self.content(app_name)
+            <<~RUBY
+              # typed: true
+              # frozen_string_literal: true
+
+              class #{app_name} < Kirei::Base
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# typed: false
+
+module Cli
+  module Commands
+    module NewApp
+      module Files
+        class Irbrc
+          def self.call
+            File.write(".irbrc", content)
+          end
+
+          def self.content
+            <<~RUBY
+              # frozen_string_literal: true
+
+              # 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')
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/commands/start.rb

@@ -0,0 +1,21 @@
+# typed: false
+
+require "fileutils"
+require "active_support/all"
+
+module Cli
+  module Commands
+    class Start
+      def self.call(args)
+        case args[0]
+        when "new"
+          app_name = args[1] || "MyApp"
+          app_name = app_name.gsub(/[-\s]/, "_").classify
+          NewApp::Execute.call(app_name: app_name)
+        else
+          puts "Unknown command" # rubocop:disable all
+        end
+      end
+    end
+  end
+end

data/lib/cli.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "kirei"
+
+Dir[File.join(__dir__, "cli/**/*.rb")].each { require(_1) }
+
+module Cli
+end

data/lib/kirei/app_base.rb

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  class AppBase < ::Sinatra::Base
+    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 env
+        ENV.fetch("RACK_ENV", "development")
+      end
+
+      sig { returns(String) }
+      def default_db_name
+        @default_db_name ||= T.let("#{config.app_name}_#{env}".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|
+          @raw_db_connection.extension(ext)
+        end
+
+        @raw_db_connection
+      end
+    end
+  end
+end

data/lib/kirei/base.rb

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

data/lib/kirei/base_controller.rb

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

data/lib/kirei/base_model.rb

@@ -0,0 +1,127 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module BaseModel
+    extend T::Sig
+    extend T::Helpers
+
+    sig { returns(BaseClassInterface) }
+    def class; super; end # rubocop:disable all
+
+    # An update keeps the original object intact, and returns a new object with the updated values.
+    sig do
+      params(
+        hash: T::Hash[Symbol, T.untyped],
+      ).returns(T.self_type)
+    end
+    def update(hash)
+      self.class.db.where({ id: id }).update(hash)
+      self.class.find_by({ id: id })
+    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.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
+
+      sig { override.returns(String) }
+      def table_name
+        T.must(name.split("::").last).pluralize.underscore
+      end
+
+      sig { override.returns(Sequel::Dataset) }
+      def db
+        AppBase.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 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: Sequel::Dataset,
+          strict: T.nilable(T::Boolean),
+        ).returns(T::Array[T.attached_class])
+      end
+      def resolve(query, strict = nil)
+        strict_loading = strict.nil? ? AppBase.config.db_strict_type_resolving : strict
+
+        query.map do |row|
+          row = T.cast(row, T::Hash[Symbol, T.untyped])
+          row.stringify_keys! # 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)
+        resolve(query.limit(1), strict).first
+      end
+    end
+
+    mixes_in_class_methods(ClassMethods)
+  end
+end

data/lib/kirei/config.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  class Config < T::Struct
+    extend T::Sig
+
+    SENSITIVE_KEYS = T.let(
+      [
+        # address data
+        /email|first_name|last_name|full_name|city|country_alpha2|country_name|country|zip_code/,
+        # auth data
+        /password|password_confirmation|access_token|client_secret|client_secret_ciphertext|client_key|token/,
+      ].freeze,
+      T::Array[Regexp],
+    )
+
+    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]))
+    # 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]
+
+    # 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
+    prop :db_strict_type_resolving, T.nilable(T::Boolean), default: nil
+  end
+end

data/lib/kirei/logger.rb

@@ -0,0 +1,175 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  # rubocop:disable Metrics
+
+  #
+  # Example Usage:
+  #
+  #    Kirei::Logger.call(
+  #      level: :info,
+  #      label: "Request started",
+  #      meta: {
+  #        key: "value",
+  #      },
+  #    )
+  #
+  # You can define a custom log transformer to transform the logline:
+  #
+  #    Kirei.config.log_transformer = Proc.new { _1 }
+  #
+  # By default, "meta" is flattened, and sensitive values are masked using see `Kirei.config.sensitive_keys`.
+  # You can also build on top of the provided log transformer:
+  #
+  #   Kirei.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 }
+  #   end
+  #
+  # NOTE: The log transformer must return an array of strings to allow emitting multiple lines per log event.
+  #
+  class Logger < Kirei::Base
+    FILTERED = "[FILTERED]"
+
+    @instance = T.let(nil, T.nilable(Kirei::Logger))
+
+    sig { void }
+    def initialize
+      super
+      @queue = T.let(Thread::Queue.new, Thread::Queue)
+      @thread = T.let(start_logging_thread, Thread)
+    end
+
+    sig { returns(Kirei::Logger) }
+    def self.instance
+      @instance ||= new
+    end
+
+    sig { returns(::Logger) }
+    def self.logger
+      return @logger unless @logger.nil?
+
+      @logger = T.let(nil, T.nilable(::Logger))
+      @logger ||= ::Logger.new($stdout)
+
+      # we want the logline to be parseable to JSON
+      @logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{msg}\n"
+      end
+
+      @logger
+    end
+
+    sig do
+      params(
+        level: T.any(String, Symbol),
+        label: String,
+        meta: T::Hash[Symbol, T.untyped],
+      ).void
+    end
+    def self.call(level:, label:, meta: {})
+      return if ENV["LOGGER"] == "disabled"
+
+      instance.call(level: level, label: label, meta: meta)
+    end
+
+    sig do
+      params(
+        level: T.any(String, Symbol),
+        label: String,
+        meta: T::Hash[Symbol, T.untyped],
+      ).void
+    end
+    def call(level:, label:, meta: {})
+      meta[:"service.instance.id"] ||= Thread.current[:request_id]
+
+      # The Ruby logger only accepts one string as the only argument
+      @queue << { level: level, label: label, meta: meta }
+    end
+
+    sig { returns(Thread) }
+    def start_logging_thread
+      Thread.new do
+        Kernel.loop do
+          log_data = T.let(@queue.pop, T::Hash[Symbol, T.untyped])
+          level = log_data.fetch(:level)
+          label = log_data.fetch(:label)
+          meta = T.let(log_data.fetch(:meta), T::Hash[Symbol, T.untyped])
+          meta[:"service.version"] ||= Kirei::AppBase.version
+          meta[:timestamp] ||= Time.current.utc.iso8601
+          meta[:level] ||= level.to_s.upcase
+          meta[:label] ||= label
+
+          log_transformer = AppBase.config.log_transformer
+
+          loglines = if log_transformer
+            log_transformer.call(meta)
+          else
+            [Oj.dump(Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta))]
+          end
+
+          loglines.each { Kirei::Logger.logger.error(_1) }
+        end
+      end
+    end
+
+    # rubocop:disable Naming/MethodParameterName
+    sig do
+      params(
+        k: Symbol,
+        v: String,
+      ).returns(String)
+    end
+    def self.mask(k, v)
+      return Kirei::Logger::FILTERED if AppBase.config.sensitive_keys.any? { k.match?(_1) }
+
+      v
+    end
+    # rubocop:enable Naming/MethodParameterName
+
+    sig do
+      params(
+        hash: T::Hash[Symbol, 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])
+      hash.deep_symbolize_keys!
+
+      hash.each do |key, value|
+        new_prefix = prefix.blank? ? key : :"#{prefix}.#{key}"
+
+        case value
+        when Hash then result.merge!(flatten_hash_and_mask_sensitive_values(value.symbolize_keys, new_prefix))
+        when Array
+          value.each_with_index do |element, index|
+            if element.is_a?(Hash) || element.is_a?(Array)
+              result.merge!(flatten_hash_and_mask_sensitive_values({ index => element }, new_prefix))
+            else
+              result[:"#{new_prefix}.#{index}"] = element.is_a?(String) ? mask(key, element) : element
+            end
+          end
+        when String then result[new_prefix] = mask(key, value)
+        when Numeric, FalseClass, TrueClass, NilClass then result[new_prefix] = value
+        else
+          if value.respond_to?(:serialize)
+            serialized_value = value.serialize
+            if serialized_value.is_a?(Hash)
+              result.merge!(flatten_hash_and_mask_sensitive_values(serialized_value.symbolize_keys, new_prefix))
+            else
+              result[new_prefix] = serialized_value&.to_s
+            end
+          else
+            result[new_prefix] = value&.to_s
+          end
+        end
+      end
+
+      result
+    end
+  end
+  # rubocop:enable Metrics
+end

data/lib/kirei/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  VERSION = "0.0.1"
+end

data/lib/kirei.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+puts "Booting Kirei..." # rubocop:disable all
+
+require "boot"
+
+module Kirei
+  extend T::Sig
+
+  GEM_ROOT = T.let(
+    Gem::Specification.find_by_name("kirei").gem_dir,
+    String,
+  )
+
+  class << self
+    extend T::Sig
+
+    sig { returns(T.nilable(Kirei::Config)) }
+    attr_accessor :configuration
+
+    sig do
+      params(
+        _: T.proc.params(configuration: Kirei::Config).void,
+      ).void
+    end
+    def configure(&_)
+      self.configuration ||= Kirei::Config.new
+      yield(T.must(configuration))
+    end
+  end
+end
+
+Kirei.configure(&:itself)
+
+puts "Kirei (#{Kirei::VERSION}) booted!" # rubocop:disable all

data/sorbet/rbi/dsl/active_support/callbacks.rbi

@@ -0,0 +1,22 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ActiveSupport::Callbacks`.
+# Please instead update this file by running `bin/tapioca dsl ActiveSupport::Callbacks`.
+
+module ActiveSupport::Callbacks
+  include GeneratedInstanceMethods
+
+  mixes_in_class_methods GeneratedClassMethods
+
+  module GeneratedClassMethods
+    def __callbacks; end
+    def __callbacks=(value); end
+    def __callbacks?; end
+  end
+
+  module GeneratedInstanceMethods
+    def __callbacks; end
+    def __callbacks?; end
+  end
+end

data/sorbet/rbi/shims/base_model.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+# rubocop:disable Style/EmptyMethod
+module Kirei
+  module BaseModel
+    sig { returns(T.any(String, Integer)) }
+    def id; end
+
+    module ClassMethods
+      include T::Props::Serializable::ClassMethods
+
+      sig { returns(String) }
+      def name; end
+    end
+  end
+end
+# rubocop:enable Style/EmptyMethod

metadata

@@ -0,0 +1,226 @@
+--- !ruby/object:Gem::Specification
+name: kirei
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ludwig Reinmiedl
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  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: 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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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
+  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: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sequel_pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |
+  Kirei's structure und developer experience is inspired by Rails, but it's not a Rails clone.
+  It's a framework that's built from the ground up to be strictly typed, performant and scaleable.
+email:
+- lud@reinmiedl.com
+- oss@dbl.works
+executables:
+- kirei
+extensions: []
+extra_rdoc_files: []
+files:
+- ".irbrc"
+- CHANGELOG.md
+- 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
+- lib/cli/commands/new_app/files/app.rb
+- lib/cli/commands/new_app/files/irbrc.rb
+- lib/cli/commands/start.rb
+- lib/kirei.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/logger.rb
+- lib/kirei/version.rb
+- sorbet/rbi/dsl/active_support/callbacks.rbi
+- sorbet/rbi/shims/base_model.rbi
+homepage: https://github.com/swiknaba/kirei
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/swiknaba/kirei
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Kirei is a strictly typed Ruby micro/REST-framework for building scaleable
+  and performant APIs.
+test_files: []