gemstack-db 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21dec8b41b0440c61fedf33b9d516672a31000feede8bb3a51c04bf6b635df69
-  data.tar.gz: 837a7cb9b46567af652473bbcf6370e72a0497d9b86152eab4bc7a58f7895acb
+  metadata.gz: 47396d58ea87b22d25ad2fd79a425224b1f2bd6709bbc9186fd58e7e6e0f8a49
+  data.tar.gz: 0c62733861805c0f951033fa2ce5e256874793d3129edddaf53ced3cb1cc12fb
 SHA512:
-  metadata.gz: 6f67b3804ec3a0e0d8866b834f98f823770b49cfd1ba24a73d2e39036116ae07eab309e3151f7d5232fc76472115357a1a4222e8633f6a68f4100760813841c1
-  data.tar.gz: 9e13d2708d4467477cf2e189f86d355fa1d2dafab6fb7b431a6d1c86b8c746fcf98c2db01e3459f9cfcd4ba0a1adf7e65be720ba8643ba777c875f644c5ccde6
+  metadata.gz: b99bd922ddc122d9b7cb74e0bb73b0874711ae53d63f589c4d5598f81e2c6a2631624f4773211f42ca8ccfa0c7aba6a4e2f20bd254604c085e3bd6658a09d3e1
+  data.tar.gz: 6be0513b6cbf84eb30fd80c2f61e6dda3a7cff5f1bcfed84fe37b7d45d7f9ae1e024cbb5094ab8e7642b1bd36ca72e1507ec04b823c4221aa8da833334c03463

data/CHANGELOG.md

@@ -1,29 +1,5 @@
 # Changelog
 
-## 0.2.5
+## 0.3.0
 
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.4
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.3
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.2
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.1
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.2.0
-
-See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
-
-## 0.1.0
-
-First release. See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).
+Merged into the gemstack gem; this version is a transition shim. See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).

data/README.md

@@ -1,27 +1,13 @@
 # gemstack-db
 
-GemStack database: Sequel models and migrations for SQLite, PostgreSQL and MySQL.
+**Merged into [`gemstack`](https://rubygems.org/gems/gemstack) in GemStack 0.3.0.**
 
-Part of [GemStack](https://github.com/gemstack-rb/gemstack), a modular Ruby API framework for Next.js
-applications by [Adware Technologies](https://www.adwaretech.com). All GemStack gems are developed together in that repository and released with the same
-version.
+This version is a transition shim: it depends on `gemstack` and loads `gemstack/db`, so
+Gemfiles that still list `gemstack-db` keep working. To finish upgrading, remove `gem "gemstack-db"`
+from your Gemfile and make sure `config/app.rb` has `require "gemstack/db"` (apps created with 0.3.0 do).
 
-## Installation
-
-Optional module — added by `gemstack new` (unless --skip-database):
-
-```ruby
-gem "gemstack-db", "~> 0.1"
-```
-
-## Documentation
-
-- [Guide](https://github.com/gemstack-rb/gemstack/blob/main/docs/database.md)
-- [All guides](https://github.com/gemstack-rb/gemstack/tree/main/docs) ·
-  [Architecture](https://github.com/gemstack-rb/gemstack/blob/main/ARCHITECTURE.md)
-
-Source, issues and pull requests: [gemstack-rb/gemstack](https://github.com/gemstack-rb/gemstack)
-(this gem lives in `gems/gemstack-db`).
+GemStack is a modular Ruby API framework for Next.js applications by
+[Adware Technologies](https://www.adwaretech.com) — [gemstack-rb/gemstack](https://github.com/gemstack-rb/gemstack).
 
 ## License
 

data/lib/gemstack-db.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# gemstack-db is part of the gemstack gem since 0.3.0. This shim keeps Gemfiles
+# that still list gemstack-db working; remove the line from your Gemfile.
+require "gemstack/db"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstack-db
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Adware Technologies
@@ -11,47 +11,28 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: gemstack-core
+  name: gemstack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.5
-- !ruby/object:Gem::Dependency
-  name: gemstack-schema
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
+        version: 0.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.2.5
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.5
-- !ruby/object:Gem::Dependency
-  name: sequel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.80'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: 0.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.80'
+        version: '1.0'
+description: Since GemStack 0.3.0, gemstack-db is part of the gemstack gem. This version
+  only depends on gemstack and loads gemstack/db, so Gemfiles that still list it keep
+  working.
 email:
 - gemstack26@gmail.com
 executables: []
@@ -61,24 +42,19 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- lib/gemstack/db.rb
-- lib/gemstack/db/configuration.rb
-- lib/gemstack/db/errors.rb
-- lib/gemstack/db/json_compat.rb
-- lib/gemstack/db/migrator.rb
-- lib/gemstack/db/model.rb
-- lib/gemstack/db/schema_types.rb
-- lib/gemstack/db/tasks.rb
-- lib/gemstack/db/testing.rb
+- lib/gemstack-db.rb
 homepage: https://github.com/gemstack-rb/gemstack
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  source_code_uri: https://github.com/gemstack-rb/gemstack/tree/main/gems/gemstack-db
-  changelog_uri: https://github.com/gemstack-rb/gemstack/blob/main/gems/gemstack-db/CHANGELOG.md
+  source_code_uri: https://github.com/gemstack-rb/gemstack
+  changelog_uri: https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/gemstack-rb/gemstack/issues
   documentation_uri: https://github.com/gemstack-rb/gemstack/tree/main/docs
+post_install_message: gemstack-db is now part of the gemstack gem. Remove `gem "gemstack-db"`
+  from your Gemfile and make sure `config/app.rb` has `require "gemstack/db"` (apps
+  created with 0.3.0 do).
 rdoc_options: []
 require_paths:
 - lib
@@ -95,6 +71,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: 'GemStack database: Sequel models and migrations for SQLite, PostgreSQL and
-  MySQL'
+summary: Merged into the gemstack gem — remove gemstack-db from your Gemfile
 test_files: []

data/lib/gemstack/db/configuration.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-require "uri"
-require "yaml"
-
-module GemStack
-  module DB
-    # Where the connection settings come from, first match wins:
-    #
-    #   1. config.db.url, set in config/app.rb or config/environments/*.rb
-    #   2. DATABASE_URL (TEST_DATABASE_URL in the test environment)
-    #   3. config/database.yml — the section for the current environment
-    #   4. PostgreSQL on this machine, database <app>_<env> (apps without database.yml)
-    #
-    # config/database.yml works like Rails' (ERB allowed):
-    #
-    #   default: &default
-    #     adapter: postgresql          # postgresql, mysql2, trilogy or sqlite3
-    #     pool: <%= ENV.fetch("GEMSTACK_MAX_THREADS", 5) %>
-    #   development:
-    #     <<: *default
-    #     database: shop_development
-    #   test:
-    #     <<: *default
-    #     database: shop_test
-    #   production:
-    #     <<: *default
-    #     url: <%= ENV["DATABASE_URL"] %>
-    #
-    # The result is a Hash for Sequel.connect: { adapter: "postgres", database:, host:, … }.
-    module Configuration
-      # Rails-style names (and URL schemes) → Sequel adapters.
-      ADAPTERS = {
-        "postgresql" => "postgres", "postgres" => "postgres", "postgis" => "postgres",
-        "mysql2" => "mysql2", "mysql" => "mysql2", "trilogy" => "trilogy",
-        "sqlite3" => "sqlite", "sqlite" => "sqlite"
-      }.freeze
-      # The gem each adapter needs in the application's Gemfile.
-      DRIVER_GEMS = { "postgres" => "pg", "mysql2" => "mysql2", "trilogy" => "trilogy", "sqlite" => "sqlite3" }.freeze
-      # database.yml keys with another name in Sequel.
-      RENAMED = { "username" => :user, "pool" => :max_connections }.freeze
-      # database.yml keys Rails uses that mean nothing to Sequel.
-      IGNORED = %w[schema_search_path migrations_paths reaping_frequency idle_timeout checkout_timeout].freeze
-
-      module_function
-
-      def resolve(config: DB.config, env: GemStack.env, root: GemStack.config.root)
-        return from_url(config.url, root: root).merge(source: "config.db.url") if config.url
-
-        variable = env.test? ? "TEST_DATABASE_URL" : "DATABASE_URL"
-        url = ENV.fetch(variable, "").strip
-        yaml = yaml_settings(root, env)
-        return from_url(url, root: root).merge(pool_from(yaml)).merge(source: variable) unless url.empty?
-        return yaml.merge(source: "config/database.yml (#{env})") if yaml
-
-        name = "#{GemStack.config.name.to_s.tr("-", "_")}_#{env}"
-        { adapter: "postgres", database: name, source: "default (no config/database.yml)" }
-      end
-
-      # The section of config/database.yml for this environment, normalized; nil without the file.
-      def yaml_settings(root, env)
-        path = File.join(root.to_s, "config", "database.yml")
-        return nil unless File.file?(path)
-
-        data = YAML.safe_load(ERB.new(File.read(path)).result, aliases: true, filename: path) || {}
-        section = data[env.to_s] or raise ConfigurationError, "config/database.yml has no #{env} section"
-        raise ConfigurationError, "config/database.yml: #{env} must be a mapping" unless section.is_a?(Hash)
-
-        from_hash(section, root: root)
-      rescue Psych::Exception => e
-        raise ConfigurationError, "config/database.yml: #{e.message}"
-      end
-
-      def from_hash(section, root:)
-        url = section["url"].to_s.strip
-        base = url.empty? ? {} : from_url(url, root: root)
-        settings = section.each_with_object({}) do |(key, value), out|
-          next if key == "url" || IGNORED.include?(key) || value.nil?
-
-          out[RENAMED.fetch(key, key.to_sym)] = value
-        end
-        settings = base.merge(settings) { |_, from_url, from_keys| from_keys || from_url }
-        settings[:adapter] = adapter!(settings[:adapter]) if settings[:adapter]
-        raise ConfigurationError, "config/database.yml: set adapter (or url)" unless settings[:adapter]
-
-        settings[:max_connections] = Integer(settings[:max_connections]) if settings[:max_connections]
-        settings[:port] = Integer(settings[:port]) if settings[:port]
-        sqlite_path(settings, root)
-      end
-
-      # postgres://user:pass@host:5432/name?sslmode=require, mysql2://…, trilogy://…,
-      # sqlite3:db/development.sqlite3 (relative to the app), sqlite3:///abs/path.db, sqlite3::memory:
-      def from_url(url, root:)
-        scheme = url[/\A([a-z0-9+.-]+):/i, 1].to_s.downcase
-        adapter = adapter!(scheme)
-        if adapter == "sqlite"
-          path = url.sub(/\A[^:]+:/, "").sub(%r{\A//}, "").sub(/\?.*\z/, "")
-          return sqlite_path({ adapter: adapter, database: path }, root)
-        end
-
-        uri = URI.parse(url)
-        settings = { adapter: adapter, host: uri.host, port: uri.port,
-                     database: decode(uri.path.to_s.delete_prefix("/")), user: decode(uri.user),
-                     password: decode(uri.password) }
-        URI.decode_www_form(uri.query.to_s).each { |key, value| settings[key.to_sym] = value }
-        settings.reject { |_, value| value.nil? || value == "" }
-      rescue URI::InvalidURIError => e
-        raise ConfigurationError, "invalid database URL: #{e.message}"
-      end
-
-      def adapter!(name)
-        ADAPTERS.fetch(name.to_s.downcase) do
-          raise ConfigurationError, "unsupported database adapter #{name.inspect} " \
-                                    "(use postgresql, mysql2, trilogy or sqlite3)"
-        end
-      end
-
-      def pool_from(yaml) = yaml && yaml[:max_connections] ? { max_connections: yaml[:max_connections] } : {}
-
-      def sqlite_path(settings, root)
-        return settings unless settings[:adapter] == "sqlite"
-
-        database = settings[:database].to_s
-        if database.empty?
-          raise ConfigurationError,
-                "sqlite3 needs a database file (e.g. database: db/development.sqlite3)"
-        end
-
-        settings[:database] = File.expand_path(database, root.to_s) unless database == ":memory:"
-        settings
-      end
-
-      def decode(value) = value && URI.decode_www_form_component(value)
-
-      # For logs and `gemstack doctor`: no passwords.
-      def describe(settings)
-        if settings[:adapter] == "sqlite"
-          return "sqlite3 #{settings[:database].to_s.delete_prefix("#{GemStack.config.root}/")}"
-        end
-
-        host = settings[:host] || "localhost"
-        user = settings[:user] ? "#{settings[:user]}@" : ""
-        "#{settings[:adapter]}://#{user}#{host}#{":#{settings[:port]}" if settings[:port]}/#{settings[:database]}"
-      end
-    end
-  end
-end

data/lib/gemstack/db/errors.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  module DB
-    # Gives Sequel errors their HTTP meaning via GemStack::ErrorMapping (no
-    # dependency on the HTTP layer), for PostgreSQL, MySQL and SQLite:
-    #
-    #   record not found           → 404 not_found
-    #   model validation failed    → 422 validation_failed + field errors
-    #   unique / not-null / FK     → 422 with the offending column when the database names it
-    #   row still referenced (FK)  → 409 conflict
-    #   database unreachable       → 503 service_unavailable
-    module Errors
-      KEY_DETAIL = /Key \(([^)]+)\)=/ # PostgreSQL
-      MYSQL_KEY = /Duplicate entry .* for key '(?:[^.']+\.)?([^']+)'/   # MySQL 8 names table.index
-      SQLITE_COLUMNS = /constraint failed: ((?:[\w.]+(?:, )?)+)/i       # UNIQUE / NOT NULL
-      FK_COLUMN = /FOREIGN KEY \(`?([^`)]+)`?\)/                        # MySQL
-
-      module_function
-
-      def install!
-        # Registered first: the specific classes below take precedence.
-        ErrorMapping.register(Sequel::DatabaseError) { |error| mysql_missing_value(error) }
-        install_record_errors!
-        install_constraint_errors!
-        ErrorMapping.register(Sequel::DatabaseConnectionError) { ServiceUnavailable.new("Database unavailable") }
-        ErrorMapping.register(Sequel::PoolTimeout) { ServiceUnavailable.new("Database busy, try again") }
-      end
-
-      def install_record_errors!
-        ErrorMapping.register(Sequel::NoMatchingRow) do |error|
-          model = error.respond_to?(:dataset) && error.dataset.respond_to?(:model) ? error.dataset.model : nil
-          RecordNotFound.new(model&.name ? "#{model.name} not found" : "Record not found")
-        end
-        ErrorMapping.register(Sequel::ValidationFailed) do |error|
-          ValidationError.new(errors: stringify(error.errors))
-        end
-        ErrorMapping.register(Sequel::InvalidValue) do |error|
-          ValidationError.new(error.message.sub(/\A.*?: /, "Invalid value: "), code: "invalid_value")
-        end
-        ErrorMapping.register(Sequel::MassAssignmentRestriction) do |error|
-          BadRequest.new(error.message, code: "unknown_attribute")
-        end
-      end
-
-      def install_constraint_errors!
-        ErrorMapping.register(Sequel::UniqueConstraintViolation) do |error|
-          field_error(columns(error), "is already taken") || Conflict.new("Record already exists")
-        end
-        ErrorMapping.register(Sequel::NotNullConstraintViolation) do |error|
-          field_error([column(error)].compact, "is required") || ValidationError.new("A required value is missing")
-        end
-        ErrorMapping.register(Sequel::ForeignKeyConstraintViolation) do |error|
-          if referenced_missing?(error)
-            field_error(columns(error), "does not exist") || ValidationError.new("A referenced record does not exist")
-          else
-            Conflict.new("Record is still referenced by other records", code: "still_referenced")
-          end
-        end
-        ErrorMapping.register(Sequel::CheckConstraintViolation) do
-          ValidationError.new("A value violates a database constraint", code: "constraint_violation")
-        end
-      end
-
-      # MySQL (strict mode) reports an omitted NOT NULL column without a
-      # default as a plain error: "Field 'name' doesn't have a default value".
-      def mysql_missing_value(error)
-        name = error.message[/Field '([^']+)' doesn't have a default value/, 1]
-        name && ValidationError.new(errors: { name => ["is required"] })
-      end
-
-      def stringify(errors) = errors.to_h { |key, messages| [Array(key).join(","), Array(messages)] }
-
-      def field_error(names, message)
-        return nil if names.empty?
-
-        ValidationError.new(errors: names.to_h { |name| [name, [message]] })
-      end
-
-      def pg_error(error) = error.respond_to?(:wrapped_exception) ? error.wrapped_exception : nil
-
-      # PostgreSQL: "is not present in table"; MySQL: "Cannot add or update a child row".
-      # SQLite doesn't say which side failed, so it is reported as a conflict.
-      def referenced_missing?(error)
-        message = error.message
-        message.include?("is not present") || message.include?("Cannot add or update a child row")
-      end
-
-      # The columns named by a unique or foreign-key violation, when the database says.
-      def columns(error)
-        message = error.message
-        if (detail = pg_detail(error) || message[KEY_DETAIL]) && (match = KEY_DETAIL.match(detail))
-          match[1].split(",").map(&:strip).map { |c| c.delete('"') }
-        elsif (match = SQLITE_COLUMNS.match(message))
-          match[1].split(", ").map { |name| name.split(".").last }
-        elsif (match = FK_COLUMN.match(message))
-          [match[1]]
-        elsif (match = MYSQL_KEY.match(message))
-          index_column(match[1])
-        else
-          []
-        end
-      rescue StandardError
-        []
-      end
-
-      def column(error)
-        message = error.message
-        (defined?(PG::PG_DIAG_COLUMN_NAME) && pg_error(error)&.result&.error_field(PG::PG_DIAG_COLUMN_NAME)) ||
-          message[/column "([^"]+)"/, 1] || message[/Column '([^']+)' cannot be null/, 1] ||
-          sqlite_column(message)
-      rescue StandardError
-        nil
-      end
-
-      def sqlite_column(message)
-        list = message[SQLITE_COLUMNS, 1] or return nil
-        list.split(", ").first.split(".").last
-      end
-
-      def pg_detail(error)
-        return nil unless defined?(PG::PG_DIAG_MESSAGE_DETAIL)
-
-        pg_error(error)&.result&.error_field(PG::PG_DIAG_MESSAGE_DETAIL)
-      end
-
-      # MySQL reports the index, not the column. `unique: true` on a column
-      # (what the generators write) names the index after the column; other
-      # indexes (table_column_index, composite) can't be mapped to one field.
-      def index_column(name)
-        name == "PRIMARY" || name.match?(/_(?:key|unique|uniq|index)\z/) ? [] : [name]
-      end
-    end
-  end
-end
-
-GemStack::DB::Errors.install!

data/lib/gemstack/db/json_compat.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  module DB
-    # Sequel (5.108 and earlier) parses JSON/JSONB columns with
-    # JSON.parse(json, create_additions: false), an option json 3.0 removed, so
-    # every jsonb read raises ArgumentError. JSON.parse never creates additions,
-    # so dropping the option keeps Sequel's behaviour.
-    module JSONCompat
-      def parse_json(json) = JSON.parse(json)
-
-      def self.install!
-        return unless Gem::Version.new(JSON::VERSION) >= Gem::Version.new("3.0")
-
-        Sequel.singleton_class.prepend(self)
-      end
-    end
-  end
-end
-
-GemStack::DB::JSONCompat.install!

data/lib/gemstack/db/migrator.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.extension :migration
-
-module GemStack
-  module DB
-    # Timestamped Sequel migrations in db/migrations:
-    #
-    #   # db/migrations/20260928120000_create_products.rb
-    #   Sequel.migration do
-    #     change do
-    #       create_table(:products) do
-    #         primary_key :id, type: :Bignum
-    #         String :name, null: false
-    #         timestamptz :created_at, null: false
-    #       end
-    #     end
-    #   end
-    #
-    # Migrations are plain Sequel migrations; the full Sequel schema DSL applies.
-    class Migrator
-      Entry = Struct.new(:version, :name, :file, :applied, keyword_init: true)
-
-      attr_reader :db, :path
-
-      def initialize(database = DB.connection, path = GemStack.root.join(DB.config.migrations_path).to_s)
-        @db = database
-        @path = path.to_s
-      end
-
-      def files = Dir.glob(File.join(path, "*.rb"))
-
-      # Applies pending migrations (or migrates up/down to target). Returns the
-      # file names that were applied or reverted.
-      def migrate(target: nil)
-        before = applied
-        run(target)
-        after = applied
-        (after - before) + (before - after)
-      end
-
-      # Reverts the last `steps` applied migrations.
-      def rollback(steps: 1)
-        versions = applied.map { |file| version_of(file) }.sort
-        return [] if versions.empty?
-
-        target = versions[-(steps + 1)] || 0
-        migrate(target: target)
-      end
-
-      def status
-        done = applied
-        files.map do |file|
-          base = File.basename(file)
-          Entry.new(version: version_of(base), name: base.sub(/\A\d+_/, "").delete_suffix(".rb"), file: base,
-                    applied: done.include?(base))
-        end.sort_by(&:version)
-      end
-
-      def pending = status.reject(&:applied)
-      def pending? = !pending.empty?
-
-      def applied
-        return [] if DB.table_missing?(db, :schema_migrations)
-
-        db[:schema_migrations].select_map(:filename)
-      end
-
-      private
-
-      def run(target)
-        return unless File.directory?(path)
-
-        Sequel::TimestampMigrator.new(db, path, target: target).run
-      end
-
-      def version_of(file) = File.basename(file)[/\A\d+/].to_i
-    end
-  end
-end

data/lib/gemstack/db/model.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  # Base class for models: Sequel::Model plus GemStack conventions.
-  #
-  #   class Product < GemStack::Model
-  #     field :name, :string, null: false, size: 120
-  #     field :price, :decimal, null: false, gt: 0
-  #     field :active, :boolean, null: false, default: true
-  #
-  #     validates :name, format: /\A\S/
-  #     belongs_to :category
-  #     has_many :reviews
-  #   end
-  #
-  # `field` declarations are metadata that drive validations, request
-  # schemas (Product.input_schema), serializer types and TypeScript. The
-  # database schema itself comes from migrations; everything Sequel offers
-  # (datasets, associations, hooks, plugins) is available unchanged.
-  #
-  # Created with Class.new on purpose: an *anonymous* subclass stops Sequel
-  # from binding GemStack::Model itself to a "models" table (which would need
-  # a database connection just to require this file).
-  Model = Class.new(Sequel::Model) # rubocop:disable Style/EmptyClassDefinition
-
-  class Model
-    Field = Struct.new(:name, :type, :options)
-
-    FIELD_RULES = %i[null default size gt gte lt lte in format].freeze
-
-    plugin :timestamps, update_on_create: true
-    plugin :validation_helpers
-
-    # A model may load before its migration has run (e.g. while generating the
-    # API contract right after `generate resource`); queries still fail
-    # clearly with "relation does not exist".
-    self.require_valid_table = false
-
-    class << self
-      def gemstack_fields
-        @gemstack_fields ||= superclass.respond_to?(:gemstack_fields) ? superclass.gemstack_fields.dup : {}
-      end
-
-      # Declares a field. Options: null: false (required), default:, size:
-      # (max length), gt/gte/lt/lte, in:, format:. Types are GemStack::Types.
-      def field(name, type, **options)
-        Types.fetch(type)
-        unknown = options.keys - FIELD_RULES
-        raise ArgumentError, "unknown field option(s) #{unknown.inspect} for #{name}" unless unknown.empty?
-
-        @input_schemas = nil
-        serialize_json(name) if Types::CLASS_ALIASES.fetch(type, type).to_sym == :json
-        gemstack_fields[name.to_sym] = Field.new(name.to_sym, Types::CLASS_ALIASES.fetch(type, type).to_sym,
-                                                 options.freeze)
-      end
-
-      def gemstack_validations
-        @gemstack_validations ||=
-          superclass.respond_to?(:gemstack_validations) ? superclass.gemstack_validations.dup : []
-      end
-
-      # validates :name, :sku, presence: true, length: { max: 40 }, format: /\A[A-Z]/,
-      #           inclusion: { in: %w[a b] }, numericality: { gt: 0 }, uniqueness: true
-      def validates(*names, **rules)
-        unknown = rules.keys - %i[presence length format inclusion numericality uniqueness]
-        raise ArgumentError, "unknown validation(s) #{unknown.inspect}" unless unknown.empty?
-
-        gemstack_validations << [names.map(&:to_sym), rules]
-      end
-
-      # A request schema derived from the field declarations (memoized):
-      #   accepts :create, with: Product.input_schema
-      def input_schema(only: nil, except: nil)
-        key = [only, except]
-        (@input_schemas ||= {})[key] ||= Schema.from_model(
-          self, only: only, except: except, type_name: "#{name.to_s.split("::").join}Input"
-        )
-      end
-
-      # find(42) raises GemStack::DB::RecordNotFound (404) when missing.
-      # With a Hash or block it behaves like Sequel's find (nil when missing).
-      def find(*args, &block)
-        return super if block || args.size != 1 || args.first.is_a?(Hash)
-
-        id = args.first
-        record = valid_primary_key?(id) ? with_pk(id) : nil
-        record || raise(DB::RecordNotFound, "#{name} #{id} not found")
-      end
-
-      def find_by(conditions) = first(conditions)
-      def find_by!(conditions) = first(conditions) || raise(DB::RecordNotFound, "#{name} not found")
-
-      alias create! create
-
-      # Associations with familiar names; the Sequel names work too.
-      def belongs_to(name, **) = many_to_one(name, **)
-      def has_many(name, **) = one_to_many(name, **) # rubocop:disable Naming/PredicatePrefix
-      def has_one(name, **) = one_to_one(name, **) # rubocop:disable Naming/PredicatePrefix
-      def has_and_belongs_to_many(name, **) = many_to_many(name, **) # rubocop:disable Naming/PredicatePrefix
-
-      private
-
-      # PostgreSQL's jsonb comes back as Hash/Array (pg_json); MySQL JSON and
-      # SQLite text come back as strings, so those fields are (de)serialized.
-      def serialize_json(name)
-        return if db.database_type == :postgres
-
-        plugin :serialization unless respond_to?(:serialization_map)
-        serialize_attributes :json, name unless serialization_map.key?(name.to_sym)
-      end
-
-      # For a table that doesn't exist yet, skip Sequel's schema queries: they
-      # would fail and log two errors per model (e.g. while `gemstack contract`
-      # runs before `db:migrate`). One cheap catalog lookup decides.
-      def get_db_schema(reload = reload_db_schema?)
-        return super unless missing_table?
-
-        set_columns(nil)
-        {}
-      end
-
-      def missing_table?
-        return false unless @dataset
-
-        DB.table_missing?(db, dataset.first_source_table)
-      rescue Sequel::Error
-        false
-      end
-
-      def valid_primary_key?(id)
-        return true unless integer_primary_key?
-
-        id.is_a?(Integer) || (id.is_a?(String) && id.match?(/\A\d{1,19}\z/))
-      end
-
-      def integer_primary_key?
-        return @integer_primary_key if defined?(@integer_primary_key)
-
-        @integer_primary_key = primary_key.is_a?(Symbol) && db_schema.dig(primary_key, :type) == :integer
-      end
-    end
-
-    alias update! update
-
-    # Identifies this version of the record, for ETags (Controller#stale?) and
-    # cache keys: "product/42-1759052159.123456".
-    def cache_key
-      stamp = respond_to?(:updated_at) && updated_at ? "-#{updated_at.to_f}" : ""
-      "#{Inflector.underscore(self.class.name.to_s)}/#{pk}#{stamp}"
-    end
-
-    def validate
-      super
-      validate_fields
-      self.class.gemstack_validations.each { |names, rules| apply_validations(names, rules) }
-    end
-
-    # Models are never rendered implicitly: exposing every column is how
-    # APIs leak data. Define a serializer instead.
-    def as_json(*)
-      file = "#{Inflector.underscore(self.class.name)}_serializer.rb"
-      raise Error, "#{self.class.name} has no serializer. Create #{file} " \
-                   "in app/serializers (class #{self.class.name}Serializer < GemStack::Serializer)."
-    end
-
-    def to_json(*) = as_json
-
-    private
-
-    def validate_fields
-      self.class.gemstack_fields.each_value do |field|
-        opts = field.options
-        name = field.name
-        if opts[:null] == false && !opts.key?(:default)
-          if field.type == :boolean
-            validates_includes([true, false], name, message: "must be true or false")
-          else
-            validates_presence(name, message: "is required")
-          end
-        end
-        apply_rules(name, opts)
-      end
-    end
-
-    def apply_rules(name, opts)
-      if opts[:size].is_a?(Integer)
-        validates_max_length(opts[:size], name, message: "is too long (maximum #{opts[:size]} characters)",
-                                                allow_nil: true)
-      end
-      { gt: :>, gte: :>=, lt: :<, lte: :<= }.each do |key, operator|
-        next unless opts.key?(key)
-
-        words = { gt: "greater than", gte: "greater than or equal to", lt: "less than", lte: "less than or equal to" }
-        validates_operator(operator, opts[key], name, message: "must be #{words[key]} #{opts[key]}", allow_nil: true)
-      end
-      if opts[:in]
-        validates_includes(opts[:in], name, message: "must be one of: #{opts[:in].to_a.join(", ")}",
-                                            allow_nil: true)
-      end
-      validates_format(opts[:format], name, message: "is invalid", allow_nil: true) if opts[:format]
-    end
-
-    def apply_validations(names, rules)
-      names.each do |name|
-        validates_presence(name, message: "is required") if rules[:presence]
-        length = rules[:length]
-        if length
-          apply_rules(name, size: length[:max]) if length[:max]
-          if length[:min]
-            validates_min_length(length[:min], name, message: "is too short (minimum #{length[:min]} characters)",
-                                                     allow_nil: true)
-          end
-        end
-        apply_rules(name, format: rules[:format]) if rules[:format]
-        inclusion = rules[:inclusion]
-        apply_rules(name, in: inclusion.is_a?(Hash) ? inclusion[:in] : inclusion) if inclusion
-        numeric = rules[:numericality]
-        if numeric
-          validates_numeric(name, message: "must be a number", allow_nil: true)
-          apply_rules(name, numeric.slice(:gt, :gte, :lt, :lte)) if numeric.is_a?(Hash)
-        end
-        validates_unique(name, message: "is already taken") if rules[:uniqueness]
-      end
-    end
-  end
-end

data/lib/gemstack/db/schema_types.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  module DB
-    # Migrations may use PostgreSQL's type names — the generators write
-    # `column :created_at, :timestamptz` — and still run on MySQL and SQLite,
-    # where each maps to the closest native type. Everything
-    # else in the Sequel schema DSL is untouched.
-    module SchemaTypes
-      MAPPINGS = {
-        mysql: { "timestamptz" => "datetime(6)", "timestamp" => "datetime(6)", "jsonb" => "json",
-                 "uuid" => "char(36)", "inet" => "varchar(45)", "citext" => "varchar(255)" },
-        sqlite: { "timestamptz" => "timestamp", "jsonb" => "json", "uuid" => "varchar(36)",
-                  "inet" => "varchar(45)", "citext" => "varchar(255)" }
-      }.freeze
-
-      private
-
-      def type_literal_specific(column)
-        type = column[:type]
-        mapped = MAPPINGS.dig(database_type, type.to_s.downcase) if type.is_a?(Symbol) || type.is_a?(String)
-        mapped || super
-      end
-    end
-  end
-end
-
-Sequel::Database.prepend(GemStack::DB::SchemaTypes)

data/lib/gemstack/db/tasks.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module GemStack
-  module DB
-    # Database lifecycle used by `gemstack db:*`, for every adapter:
-    # PostgreSQL and MySQL through a server connection without the database,
-    # SQLite by creating or deleting the file.
-    #
-    # Each method takes resolved settings (DB.settings, the default) or a URL.
-    module Tasks
-      module_function
-
-      def settings_for(target)
-        target.is_a?(String) ? Configuration.from_url(target, root: GemStack.config.root) : target.except(:source)
-      end
-
-      # The database name (SQLite: the file, relative to the app).
-      def database_name(target = DB.settings)
-        name = settings_for(target)[:database].to_s
-        name.delete_prefix("#{GemStack.config.root}/")
-      end
-
-      def exists?(target = DB.settings)
-        settings = settings_for(target)
-        name = settings[:database].to_s
-        case settings[:adapter]
-        when "sqlite" then name == ":memory:" || File.file?(name)
-        when "postgres" then with_server(settings) { |db| db[:pg_database].where(datname: name).any? }
-        else with_server(settings) { |db| db[Sequel[:information_schema][:schemata]].where(schema_name: name).any? }
-        end
-      end
-
-      # Returns :created or :exists.
-      def create(target = DB.settings)
-        settings = settings_for(target)
-        return :exists if exists?(settings)
-
-        name = settings[:database].to_s
-        case settings[:adapter]
-        when "sqlite"
-          FileUtils.mkdir_p(File.dirname(name))
-          Sequel.connect(**settings, test: true, keep_reference: false).disconnect # creates the file
-        when "postgres"
-          with_server(settings) { |db| db.run("CREATE DATABASE #{db.literal(Sequel.identifier(name))}") }
-        else
-          with_server(settings) do |db|
-            db.run("CREATE DATABASE #{db.literal(Sequel.identifier(name))} " \
-                   "CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci")
-          end
-        end
-        :created
-      end
-
-      # Refuses outside development/test unless GEMSTACK_ALLOW_DB_DROP=1.
-      def drop(target = DB.settings)
-        unless GemStack.env.local? || ENV["GEMSTACK_ALLOW_DB_DROP"] == "1"
-          raise Error, "refusing to drop the #{GemStack.env} database; set GEMSTACK_ALLOW_DB_DROP=1 to confirm"
-        end
-
-        settings = settings_for(target)
-        return :missing unless exists?(settings)
-
-        DB.disconnect
-        name = settings[:database].to_s
-        case settings[:adapter]
-        when "sqlite" then FileUtils.rm_f(["", "-wal", "-shm", "-journal"].map { |suffix| "#{name}#{suffix}" })
-        when "postgres"
-          with_server(settings) { |db| db.run("DROP DATABASE #{db.literal(Sequel.identifier(name))} WITH (FORCE)") }
-        else with_server(settings) { |db| db.run("DROP DATABASE #{db.literal(Sequel.identifier(name))}") }
-        end
-        :dropped
-      end
-
-      def seed(path = GemStack.root.join(DB.config.seeds_path))
-        return false unless File.file?(path)
-
-        load path.to_s
-        true
-      end
-
-      # A connection to the server itself: PostgreSQL's "postgres" maintenance
-      # database, or MySQL without a default database.
-      def with_server(settings)
-        server = settings.merge(database: settings[:adapter] == "postgres" ? "postgres" : nil).compact
-        db = Sequel.connect(**server, max_connections: 1, test: true, keep_reference: false)
-        yield db
-      ensure
-        db&.disconnect
-      end
-    end
-  end
-end

data/lib/gemstack/db/testing.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "gemstack/db"
-require "securerandom"
-
-module GemStack
-  module DB
-    # Test support, used by the generated test/test_helper.rb:
-    #
-    #   require "gemstack/db/testing"
-    #   GemStack::DB::Testing.prepare!             # create + migrate the test database
-    #   GemStack::TestCase.include GemStack::DB::Testing::Transactions
-    module Testing
-      module_function
-
-      # Creates the test database if needed and applies pending migrations,
-      # so `gemstack test` works on a fresh checkout.
-      def prepare!
-        Tasks.create
-        Migrator.new.migrate
-      end
-
-      # Valid attribute values for a model, derived from its `field`
-      # declarations (types, size, gt/gte/lt/lte, in:). Unique-looking values
-      # use a sequence; `references` fields create the referenced record.
-      # Fields with a `format:` rule may need an override.
-      #
-      #   Product.create(GemStack::DB::Testing.sample_attributes(Product, name: "Lamp"))
-      def sample_attributes(model, overrides = {})
-        @sequence = (@sequence || 0) + 1
-        model.gemstack_fields.each_value.with_object({}) do |field, attrs|
-          attrs[field.name] = sample_value(model, field, @sequence)
-        end.merge(overrides)
-      end
-
-      # sample_attributes as JSON-ready values (for request bodies).
-      def sample_payload(model, overrides = {})
-        sample_attributes(model, overrides).transform_values do |value|
-          case value
-          when BigDecimal then value.to_s("F")
-          when Time then value.utc.iso8601
-          when Date then value.iso8601
-          else value
-          end
-        end
-      end
-
-      def sample_value(model, field, sequence)
-        opts = field.options
-        return Array(opts[:in]).first if opts[:in]
-
-        case field.type
-        when :string, :text then sample_string(field, opts, sequence)
-        when :integer, :bigint then bounded(opts, 1, step: 1).to_i
-        when :float then bounded(opts, 1.5, step: 1).to_f
-        when :decimal then BigDecimal(bounded(opts, BigDecimal("9.99"), step: 1).to_s)
-        when :boolean then true
-        when :date then Date.today
-        when :datetime then Time.now.utc.round
-        when :uuid then SecureRandom.uuid
-        when :json then { "sample" => true }
-        when :references then sample_reference(model, field)
-        end
-      end
-
-      def sample_string(field, opts, sequence)
-        value = "#{Inflector.humanize(field.name)} #{sequence}"
-        opts[:size].is_a?(Integer) ? value[0, opts[:size]] : value
-      end
-
-      def bounded(opts, value, step:)
-        value = opts[:gt] + step if opts[:gt] && value <= opts[:gt]
-        value = opts[:gte] if opts[:gte] && value < opts[:gte]
-        value = opts[:lt] - step if opts[:lt] && value >= opts[:lt]
-        value = opts[:lte] if opts[:lte] && value > opts[:lte]
-        value
-      end
-
-      def sample_reference(model, field)
-        reflection = model.association_reflections.values.find { |r| r[:key] == field.name }
-        target = reflection&.associated_class ||
-                 Object.const_get(Inflector.camelize(field.name.to_s.delete_suffix("_id")))
-        target.create(sample_attributes(target)).pk
-      end
-
-      # Runs every test inside a transaction that is rolled back afterwards.
-      # Requests made through rack-test run on the same thread, so they see
-      # (and roll back) the same data. Nested GemStack.transaction calls
-      # become savepoints.
-      module Transactions
-        def run(...)
-          result = nil
-          DB.connection.transaction(rollback: :always, auto_savepoint: true) { result = super }
-          result
-        end
-      end
-    end
-  end
-end

data/lib/gemstack/db.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require "sequel"
-require "json"
-require "gemstack/core"
-require "gemstack/schema"
-
-require_relative "db/json_compat"
-require_relative "db/configuration"
-require_relative "db/schema_types"
-
-module GemStack
-  # SQL databases through Sequel: PostgreSQL, MySQL
-  # (mysql2 or trilogy) and SQLite, configured by config/database.yml or
-  # DATABASE_URL. Optional: add `gem "gemstack-db"` and the driver gem
-  # (pg, mysql2, trilogy or sqlite3) to the Gemfile — `gemstack new` does.
-  #
-  #   GemStack.db[:products].where(active: true).count     # the Sequel::Database
-  #   GemStack.transaction { order.save; payment.save }
-  module DB
-    class Config < Settings
-      # An explicit database URL; wins over DATABASE_URL and config/database.yml
-      # (see DB::Configuration). Test uses TEST_DATABASE_URL, never DATABASE_URL,
-      # so a development database from .env can't be wiped by the test suite.
-      setting :url, default: nil
-      # One connection per server thread by default (database.yml `pool:` wins).
-      setting :pool_size, default: lambda {
-        Integer(ENV.fetch("GEMSTACK_DB_POOL") { ENV.fetch("GEMSTACK_MAX_THREADS", 5) })
-      }
-      setting :pool_timeout, default: 5
-      setting :migrations_path, default: "db/migrations"
-      setting :seeds_path, default: "db/seeds.rb"
-      setting :log_queries, default: -> { GemStack.env.development? }
-      # Queries slower than this are logged at WARN in every environment.
-      setting :slow_query_ms, default: 500
-      # Server-side statement timeout in ms (nil = the database's default).
-      # PostgreSQL: statement_timeout; MySQL: max_execution_time (SELECTs); SQLite: none.
-      setting :statement_timeout, default: nil
-      # Sequel extensions to load; nil = pg_json + pg_array on PostgreSQL, none elsewhere.
-      setting :extensions, default: nil
-      # Extra options passed to Sequel.connect.
-      setting :options, default: {}
-    end
-
-    class RecordNotFound < NotFound; end
-
-    # Stored and compared in UTC on every adapter (MySQL DATETIME and SQLite
-    # text have no time zone); PostgreSQL timestamptz is unaffected.
-    Sequel.database_timezone = :utc
-
-    # Adapts Sequel's logging to the GemStack logger: SQL at DEBUG only when
-    # config.db.log_queries is on, slow queries at WARN, and failures of the
-    # existence probes Sequel runs on purpose (table_exists?, model setup
-    # before a migration) are not reported as errors.
-    class QueryLogger
-      PROBE = /: SELECT (?:NULL AS [`"']nil[`"'] FROM \S+ LIMIT 1|\* FROM \S+ LIMIT 0)\z/
-
-      def initialize(logger, queries:)
-        @logger = logger
-        @queries = queries
-      end
-
-      def debug(message) = (@logger.debug(message) if @queries)
-      def info(message) = @logger.info(message)
-      def warn(message) = @logger.warn(message)
-      def error(message) = (@logger.error(message) unless PROBE.match?(message.to_s))
-    end
-
-    @mutex = Mutex.new
-
-    class << self
-      def config = GemStack.config.db
-
-      def connection
-        @connection || @mutex.synchronize { @connection ||= connect }
-      end
-
-      def connected? = !@connection.nil?
-
-      # The resolved connection settings (a Hash; see DB::Configuration).
-      def settings = @settings ||= Configuration.resolve
-
-      # "postgres", "mysql2", "trilogy" or "sqlite".
-      def adapter = settings[:adapter]
-      def postgres?(db = nil) = type(db) == :postgres
-      def mysql?(db = nil) = type(db) == :mysql
-      def sqlite?(db = nil) = type(db) == :sqlite
-
-      # Sequel's database type (:postgres, :mysql, :sqlite) — from the
-      # connection when there is one, so no query is needed.
-      def type(db = nil)
-        db ||= @connection
-        return db.database_type if db
-
-        { "postgres" => :postgres, "mysql2" => :mysql, "trilogy" => :mysql, "sqlite" => :sqlite }.fetch(adapter)
-      end
-
-      # Builds the Sequel::Database. Connections are opened lazily, so an
-      # unavailable database doesn't prevent the application from booting.
-      def connect(target = settings)
-        target = Configuration.from_url(target, root: GemStack.config.root) if target.is_a?(String)
-        opts = target.except(:source)
-        options = { max_connections: opts.delete(:max_connections) || config.pool_size,
-                    pool_timeout: config.pool_timeout, test: false, keep_reference: false }
-        options.merge!(adapter_options(opts[:adapter], opts[:database]))
-        db = open_database(opts.merge(options).merge(config.options))
-        configure(db)
-        Sequel::Model.db = db
-        db
-      end
-
-      # Closes pooled connections (e.g. before Puma forks workers). The
-      # Database object stays in place and reconnects lazily: models hold a
-      # reference to it, so replacing it would split them from GemStack.db.
-      def disconnect
-        @connection&.disconnect
-      end
-
-      def transaction(**, &) = connection.transaction(**, &)
-
-      # Forgets the resolved settings and the connection (tests, console).
-      def reset!
-        @connection&.disconnect
-        @connection = nil
-        @settings = nil
-      end
-
-      # True when the table isn't there — one catalog query, nothing logged
-      # (Sequel's table_exists? probes with a failing SELECT).
-      def table_missing?(db, table)
-        name = table.to_s
-        case db.database_type
-        when :postgres then db.get(Sequel.function(:to_regclass, db.literal(table))).nil?
-        when :mysql
-          db[Sequel[:information_schema][:tables]].where(table_schema: Sequel.function(:database),
-                                                         table_name: name).empty?
-        when :sqlite then db[:sqlite_master].where(type: %w[table view], name: name).empty?
-        else !db.table_exists?(table)
-        end
-      end
-
-      private
-
-      def configure(db)
-        extensions = config.extensions || (postgres?(db) ? %i[pg_json pg_array] : [])
-        db.extension(*extensions) unless extensions.empty?
-        db.log_warn_duration = config.slow_query_ms / 1000.0 if config.slow_query_ms
-        db.loggers << QueryLogger.new(GemStack.logger, queries: config.log_queries)
-        db.sql_log_level = :debug
-      end
-
-      def open_database(options)
-        Sequel.connect(**options)
-      rescue Sequel::AdapterNotFound, LoadError => e
-        gem_name = Configuration::DRIVER_GEMS.fetch(options[:adapter], options[:adapter])
-        raise ConfigurationError, "#{options[:adapter]} needs gem \"#{gem_name}\" in the Gemfile (#{e.message})"
-      end
-
-      def adapter_options(adapter, database)
-        timeout = config.statement_timeout && Integer(config.statement_timeout)
-        case adapter
-        when "postgres" then timeout ? { connect_sqls: ["SET statement_timeout = #{timeout}"] } : {}
-        when "mysql2", "trilogy"
-          sqls = timeout ? ["SET SESSION max_execution_time = #{timeout}"] : []
-          { encoding: "utf8mb4", connect_sqls: sqls }
-        when "sqlite"
-          # Several Puma threads share the file: wait for the write lock instead
-          # of failing, and let readers work while one connection writes.
-          sqls = database == ":memory:" ? [] : ["PRAGMA journal_mode = WAL", "PRAGMA synchronous = NORMAL"]
-          { timeout: 5_000, connect_sqls: sqls }
-        else {}
-        end
-      end
-    end
-  end
-
-  # A model base class bound to an explicit table, like Sequel::Model(:table):
-  #   class Item < GemStack::Model(:inventory_items)
-  def self.Model(source) = Model.Model(source) # rubocop:disable Naming/MethodName
-
-  class << self
-    def db = DB.connection
-    def transaction(**, &) = DB.transaction(**, &)
-  end
-end
-
-require_relative "db/model"
-require_relative "db/errors"
-require_relative "db/migrator"
-require_relative "db/tasks"
-
-GemStack::Config.namespace(:db, GemStack::DB::Config)
-
-GemStack::Plugins.register(:db) do |app|
-  GemStack::DB.connection
-  app.on_shutdown { GemStack::DB.disconnect } if app.respond_to?(:on_shutdown)
-
-  # A friendly nudge in development; never blocks boot.
-  if GemStack.env.development?
-    begin
-      pending = GemStack::DB::Migrator.new.pending
-      unless pending.empty?
-        GemStack.logger.warn("#{pending.size} pending migration(s) — run `gemstack db:migrate`",
-                             first: pending.first.file)
-      end
-    rescue Sequel::Error
-      nil # database not reachable yet; requests will report it
-    end
-  end
-end