gemstack-schema 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fea92113cb4c2f1c6bd382e86fa92f6e718985b36a4c6bc75790928cc8c56afe
-  data.tar.gz: 8f16ea47ad9db40eb45f48bfdd2aeae7be4ac82a9fbfcaaccecde65e28583948
+  metadata.gz: 1070dd8a0c48cdf0e7b69610bb3c1a59d174063621f88afec56e055d2caf795b
+  data.tar.gz: 2409a30865825b9cb073e8ac647349eab6ca1ced42ee87917ce98b903388c916
 SHA512:
-  metadata.gz: 487981983da3f2ba47ec05c30366a940f0ec6d5b43c321b9d7a12ddeb73a1048a96d9416f6ccea362e733dd26b2ffd9e060d5eaa95dce3a8f776b262dab1ba5d
-  data.tar.gz: f6e9f61cec18886f213bcdbbe50e0a0d2d58ab68f6c7508150e1d0e4eaf2db5570c0009444fc9f86b74dca00be4d1d2f505bc60e1d2a31fe17f93466847ddf45
+  metadata.gz: e7e6ae60a1248d9d4a2b2fbb3db43fd149ac760f69f0d91958f3f62d4ecc2e97105cbcf31ed111218f15999225c00c6c37d276eb863f874914503ada676ccd81
+  data.tar.gz: 1961f085af76ca45e4f3cef864d62fadd4bd68f0e62ffdca3959b569f18ab262e4dfe4451f5e6a8eac11d70e6a9b3b89b70d9d8e157719658f1d89a06401aaaa

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,23 +1,13 @@
 # gemstack-schema
 
-GemStack schema: shared types, request schemas and serializers.
+**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/schema`, so
+Gemfiles that still list `gemstack-schema` keep working. To finish upgrading, remove `gem "gemstack-schema"`
+from your Gemfile (it's loaded by `require "gemstack"`).
 
-## Installation
-
-Installed with the `gemstack` gem; you rarely need to add it yourself.
-
-## Documentation
-
-- [Guide](https://github.com/gemstack-rb/gemstack/blob/main/docs/validation.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-schema`).
+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-schema.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstack-schema
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Adware Technologies
@@ -11,33 +11,28 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bigdecimal
+  name: gemstack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: gemstack-core
-  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:
-    - - '='
+        version: 0.3.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.2.5
+        version: '1.0'
+description: Since GemStack 0.3.0, gemstack-schema is part of the gemstack gem. This
+  version only depends on gemstack and loads gemstack/schema, so Gemfiles that still
+  list it keep working.
 email:
 - gemstack26@gmail.com
 executables: []
@@ -47,18 +42,18 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- lib/gemstack/schema.rb
-- lib/gemstack/serializer.rb
-- lib/gemstack/types.rb
+- lib/gemstack-schema.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-schema
-  changelog_uri: https://github.com/gemstack-rb/gemstack/blob/main/gems/gemstack-schema/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-schema is now part of the gemstack gem. Remove `gem
+  "gemstack-schema"` from your Gemfile (it's loaded by `require "gemstack"`).
 rdoc_options: []
 require_paths:
 - lib
@@ -75,5 +70,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: 'GemStack schema: shared types, request schemas and serializers'
+summary: Merged into the gemstack gem — remove gemstack-schema from your Gemfile
 test_files: []

data/lib/gemstack/schema.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-require "gemstack/core"
-require_relative "types"
-
-module GemStack
-  # Declarative input validation and coercion.
-  #
-  #   class ProductInput < GemStack::Schema
-  #     required :name, :string, max_length: 120
-  #     required :price, :decimal, gt: 0
-  #     optional :active, :boolean, default: true
-  #     optional :tags, [:string]
-  #     optional :dimensions do
-  #       required :width, :integer
-  #     end
-  #   end
-  #
-  #   ProductInput.call(params)   # => { name: "Lamp", price: 0.999e1, active: true }
-  #                               # or raises GemStack::ValidationError (422) with
-  #                               #    errors: { "price" => ["must be greater than 0"] }
-  #
-  # - Output has symbol keys and only declared fields (an allow-list).
-  # - Values are coerced to their type ("12" → 12 for :integer).
-  # - For non-string types an empty string counts as "not given" (HTML forms).
-  # - A required string that is blank is reported as "is required".
-  # - Error keys are paths: "dimensions.width", "tags.2".
-  class Schema
-    Field = Struct.new(:name, :type, :required, :nullable, :default, :rules, :schema, :array, keyword_init: true) do
-      def default? = !default.equal?(NO_DEFAULT)
-      def default_value = default.respond_to?(:call) ? default.call : default
-      def ts_optional? = !required && !default?
-    end
-
-    NO_DEFAULT = Object.new.freeze
-    RULES = %i[gt gte lt lte min_length max_length in format].freeze
-    STRING_TYPES = %i[string text].freeze
-
-    # rule => [passes?(value, arg), message(arg)]
-    RULE_CHECKS = {
-      gt: [->(v, a) { v > a }, ->(a) { "must be greater than #{a}" }],
-      gte: [->(v, a) { v >= a }, ->(a) { "must be greater than or equal to #{a}" }],
-      lt: [->(v, a) { v < a }, ->(a) { "must be less than #{a}" }],
-      lte: [->(v, a) { v <= a }, ->(a) { "must be less than or equal to #{a}" }],
-      min_length: [->(v, a) { v.to_s.length >= a }, ->(a) { "is too short (minimum #{a} characters)" }],
-      max_length: [->(v, a) { v.to_s.length <= a }, ->(a) { "is too long (maximum #{a} characters)" }],
-      in: [->(v, a) { a.include?(v) }, ->(a) { "must be one of: #{a.to_a.join(", ")}" }],
-      format: [->(v, a) { a.match?(v.to_s) }, ->(_) { "is invalid" }]
-    }.freeze
-
-    class << self
-      def fields
-        @fields ||= superclass.respond_to?(:fields) ? superclass.fields.dup : {}
-      end
-
-      # Name used for this schema's TypeScript/OpenAPI type.
-      attr_writer :type_name
-
-      def type_name
-        @type_name || name&.split("::")&.join
-      end
-
-      def required(name, type = nil, **options, &) = add_field(name, type, true, options, &)
-      def optional(name, type = nil, **options, &) = add_field(name, type, false, options, &)
-
-      # An anonymous schema from a block: Schema.define { required :q, :string }
-      def define(type_name = nil, &)
-        Class.new(self) do
-          self.type_name = type_name
-          class_exec(&)
-        end
-      end
-
-      # Every field optional and without defaults — for PATCH-style updates.
-      def partial(type_name = nil)
-        source = self
-        Class.new(Schema) do
-          self.type_name = type_name
-          source.fields.each_value do |field|
-            fields[field.name] = field.dup.tap do |copy|
-              copy.required = false
-              copy.default = NO_DEFAULT
-            end
-          end
-        end
-      end
-
-      # A schema derived from a model's field declarations (anything that
-      # responds to #gemstack_fields → { name => field with #type and #options }).
-      # Fields that are NOT NULL without a default become required.
-      def from_model(model, only: nil, except: nil, type_name: nil)
-        declared = model.gemstack_fields
-        names = only ? Array(only).map(&:to_sym) : declared.keys
-        names -= Array(except).map(&:to_sym)
-        define(type_name) do
-          names.each do |name|
-            field = declared.fetch(name) { raise ArgumentError, "#{model} has no field #{name.inspect}" }
-            opts = field.options
-            rules = opts.slice(*RULES)
-            rules[:max_length] ||= opts[:size] if opts[:size].is_a?(Integer)
-            required = opts[:null] == false && !opts.key?(:default) && field.type != :boolean
-            add_field(name, field.type, required, rules.merge(nullable: opts[:null] != false))
-          end
-        end
-      end
-
-      def call(input)
-        errors = {}
-        result = coerce_object(input, nil, errors)
-        raise ValidationError.new(errors: errors) unless errors.empty?
-
-        result
-      end
-
-      # Like #call but returns [result, errors] instead of raising.
-      def validate(input)
-        errors = {}
-        result = coerce_object(input, nil, errors)
-        [errors.empty? ? result : nil, errors]
-      end
-
-      def coerce_object(input, path, errors)
-        input = normalize_input(input)
-        unless input.is_a?(Hash)
-          errors[path || "base"] = ["must be an object"]
-          return nil
-        end
-
-        fields.each_value.with_object({}) do |field, output|
-          coerce_field(field, input, path, output, errors)
-        end
-      end
-
-      private
-
-      def add_field(name, type, required, options, &block)
-        options = options.dup
-        nullable = options.delete(:nullable) || false
-        default = options.key?(:default) ? options.delete(:default) : NO_DEFAULT
-        unknown = options.keys - RULES
-        raise ArgumentError, "unknown option(s) #{unknown.inspect} for #{name}" unless unknown.empty?
-
-        array = false
-        schema = nil
-        if type.is_a?(Array)
-          array = true
-          type = type.first
-        elsif type == :array
-          array = true
-          type = nil
-        end
-        if block
-          schema = Schema.define(&block)
-          type = nil
-        elsif type.is_a?(Class) && type <= Schema
-          schema = type
-          type = nil
-        elsif type.nil?
-          raise ArgumentError, "#{name}: give a type (e.g. :string) or a block"
-        else
-          Types.fetch(type) # validate early
-          type = Types::CLASS_ALIASES.fetch(type, type).to_sym
-        end
-
-        fields[name.to_sym] = Field.new(name: name.to_sym, type: type, required: required, nullable: nullable,
-                                        default: default, rules: options.freeze, schema: schema, array: array)
-      end
-
-      # absent → default or omitted; required + absent/nil/blank → "is required";
-      # explicit null → nil when nullable, otherwise "can't be null".
-      def coerce_field(field, input, path, output, errors)
-        key = field.name.to_s
-        field_path = path ? "#{path}.#{key}" : key
-        value = input[key]
-        present = input.key?(key) && !empty_form_value?(field, value)
-
-        if field.required && (!present || value.nil? || blank_string?(value))
-          missing_required(field, present, field_path, output, errors)
-        elsif !present
-          output[field.name] = field.default_value if field.default?
-        else
-          coerce_present(field, value, field_path, output, errors)
-        end
-      end
-
-      def coerce_present(field, value, path, output, errors)
-        if value.nil?
-          field.nullable ? output[field.name] = nil : (errors[path] ||= []) << "can't be null"
-        else
-          coerced = coerce_value(field, value, path, errors)
-          output[field.name] = coerced unless coerced.equal?(NO_DEFAULT)
-        end
-      end
-
-      def missing_required(field, present, path, output, errors)
-        return output[field.name] = field.default_value if field.default? && !present
-
-        (errors[path] ||= []) << "is required"
-      end
-
-      def coerce_value(field, value, path, errors)
-        return coerce_array(field, value, path, errors) if field.array
-
-        coerce_single(field, value, path, errors)
-      end
-
-      def coerce_array(field, value, path, errors)
-        value = value.values if value.is_a?(Hash) && value.keys.all? { |k| k.to_s.match?(/\A\d+\z/) } # form arrays
-        unless value.is_a?(Array)
-          (errors[path] ||= []) << "must be a list"
-          return NO_DEFAULT
-        end
-
-        value.each_with_index.map { |item, index| coerce_single(field, item, "#{path}.#{index}", errors) }
-      end
-
-      def coerce_single(field, value, path, errors)
-        return field.schema.coerce_object(value, path, errors) if field.schema
-
-        coerced = Types.fetch(field.type).coerce(value)
-        check_rules(field.rules, coerced, path, errors)
-        coerced
-      rescue Types::CoercionError => e
-        (errors[path] ||= []) << e.message
-        NO_DEFAULT
-      end
-
-      def check_rules(rules, value, path, errors)
-        messages = rules.filter_map { |rule, arg| rule_message(rule, arg, value) }
-        (errors[path] ||= []).concat(messages) unless messages.empty?
-      end
-
-      def rule_message(rule, arg, value)
-        check, message = RULE_CHECKS.fetch(rule)
-        check.call(value, arg) ? nil : message.call(arg)
-      end
-
-      def normalize_input(input)
-        input = input.to_unsafe_h if input.respond_to?(:to_unsafe_h) # GemStack::Params
-        input.is_a?(Hash) ? input.transform_keys(&:to_s) : input
-      end
-
-      def blank_string?(value) = value.is_a?(String) && value.strip.empty?
-
-      # An empty form input for a non-string field means "not given".
-      def empty_form_value?(field, value) = value == "" && !STRING_TYPES.include?(field.type)
-    end
-  end
-end
-
-require_relative "serializer"

data/lib/gemstack/serializer.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-module GemStack
-  # Explicit, typed JSON representations. Nothing is exposed unless listed.
-  #
-  #   class ProductSerializer < GemStack::Serializer
-  #     attributes :id, :name, :price, :active, :created_at   # types inferred from Product's fields
-  #     attribute :display_price, :string do |product|
-  #       "€#{product.price}"
-  #     end
-  #     attribute :category, CategorySerializer                 # nested
-  #     attribute :reviews, [ReviewSerializer]                  # nested list
-  #   end
-  #
-  #   ProductSerializer.serialize(product)   # => { id: 1, name: "Lamp", price: "9.99", ... }
-  #   ProductSerializer.many(products)       # => [ {...}, ... ]
-  #
-  # Values are dumped by type: decimals become strings, times ISO 8601 UTC.
-  # Types come from an explicit type argument, else from the model's field
-  # declarations (the model is found by name: ProductSerializer → Product),
-  # and drive the generated TypeScript interfaces.
-  class Serializer
-    Attribute = Struct.new(:name, :type, :block, :nullable, keyword_init: true) do
-      def serializer? = type.is_a?(Class) && type <= Serializer
-      def list? = type.is_a?(Array)
-    end
-
-    CONVENTIONAL_TYPES = { id: [:bigint, false], created_at: [:datetime, false], updated_at: [:datetime, false] }.freeze
-
-    class << self
-      def attributes_list
-        @attributes_list ||= superclass.respond_to?(:attributes_list) ? superclass.attributes_list.dup : {}
-      end
-
-      # attributes :id, :name        (types inferred)
-      # attributes name: :string     (explicit)
-      def attributes(*names, **typed)
-        names.each { |name| attribute(name) }
-        typed.each { |name, type| attribute(name, type) }
-      end
-
-      def attribute(name, type = nil, nullable: nil, &block)
-        if type && !type.is_a?(Array) && !(type.is_a?(Class) && type <= Serializer)
-          type = Types::CLASS_ALIASES.fetch(type, type).to_sym
-          Types.fetch(type)
-        end
-        attributes_list[name.to_sym] = Attribute.new(name: name.to_sym, type: type, block: block, nullable: nullable)
-        @resolved_attributes = nil
-      end
-
-      # The model used for type inference. Defaults to the class named like
-      # the serializer without "Serializer" (Admin::ProductSerializer → Admin::Product, then Product).
-      def model(klass = nil)
-        @model = klass if klass
-        return @model if defined?(@model) && @model
-
-        base = name&.delete_suffix("Serializer")
-        return nil if base.nil? || base.empty?
-
-        [base, base.split("::").last].uniq.each do |candidate|
-          constant = Object.const_get(candidate) if Object.const_defined?(candidate)
-          return constant if constant.respond_to?(:gemstack_fields)
-        rescue NameError
-          next
-        end
-        nil
-      end
-
-      attr_writer :type_name
-
-      # TypeScript/OpenAPI name: ProductSerializer → "Product", Admin::ProductSerializer → "AdminProduct".
-      def type_name
-        @type_name || (name && name.delete_suffix("Serializer").split("::").join)
-      end
-
-      # Attributes with resolved types: [{name:, type:, nullable:}], type being
-      # a type Symbol, a Serializer class, or [Serializer]/[:type] for lists.
-      def resolved_attributes
-        @resolved_attributes ||= attributes_list.values.map do |attr|
-          type, nullable = infer(attr)
-          { name: attr.name, type: type, nullable: attr.nullable.nil? ? nullable : attr.nullable }
-        end.freeze
-      end
-
-      # [[name, block_or_nil, dumper_or_nil], ...] — types resolved to
-      # dumpers once, so serializing an object does no type lookups.
-      def compiled
-        @compiled ||= resolved_attributes.map do |attr|
-          [attr[:name], attributes_list[attr[:name]].block, dumper_for(attr[:type])]
-        end.freeze
-      end
-
-      def serialize(object, context = {})
-        object.nil? ? nil : new(object, context).to_h
-      end
-
-      def many(objects, context = {})
-        objects = objects.all if objects.respond_to?(:all) && !objects.is_a?(Array) # Sequel datasets
-        objects.map { |object| new(object, context).to_h }
-      end
-
-      # Convention-based rendering, shared by controllers (`render`) and
-      # realtime (`GemStack.broadcast`): an object of class Product uses
-      # ProductSerializer, arrays and datasets of them too; plain JSON values
-      # and objects without a serializer pass through unchanged.
-      def render(value, context = {})
-        case value
-        when Hash, String, Numeric, Symbol, true, false, nil then value
-        when Array
-          serializer = value.first && self.for(value.first.class)
-          serializer ? serializer.many(value, context) : value
-        else
-          if value.respond_to?(:model) && value.respond_to?(:all) # a dataset / query
-            serializer = self.for(value.model)
-            return serializer ? serializer.many(value, context) : value.all
-          end
-          serializer = self.for(value.class)
-          serializer ? serializer.serialize(value, context) : value
-        end
-      end
-
-      # Defaults for convention-based lookup: ProductSerializer for Product.
-      def for(object_class)
-        return nil unless object_class.name
-
-        name = "#{object_class.name}Serializer"
-        Object.const_defined?(name) ? Object.const_get(name) : nil
-      rescue NameError
-        nil
-      end
-
-      private
-
-      # A lambda (value, context) -> JSON value, or nil when values pass through.
-      def dumper_for(type)
-        case type
-        when Array
-          item = dumper_for(type.first)
-          return nil unless item
-
-          ->(values, ctx) { values.map { |v| v.nil? ? nil : item.call(v, ctx) } }
-        when Symbol then scalar_dumper(Types.fetch(type))
-        else ->(value, ctx) { type.serialize(value, ctx) } # nested serializer
-        end
-      end
-
-      def scalar_dumper(type)
-        if %i[string text].include?(type.name)
-          ->(value, _) { value.is_a?(String) ? value : type.coerce(value) }
-        elsif type.dumper
-          dump = type.dumper
-          ->(value, _) { dump.call(value) }
-        end
-      end
-
-      # Explicit types are non-null unless declared nullable or the model's
-      # field allows null; inferred types follow the model's field.
-      def infer(attr)
-        field = model&.gemstack_fields&.[](attr.name)
-        return [attr.type, field ? field.options[:null] != false : false] if attr.type
-        return [field.type, field.options[:null] != false] if field
-
-        CONVENTIONAL_TYPES.fetch(attr.name) { [:json, true] }
-      end
-    end
-
-    attr_reader :object, :context
-
-    def initialize(object, context = {})
-      @object = object
-      @context = context
-    end
-
-    # Hot path: iterates the plan compiled once per serializer class
-    # (docs/performance.md — this loop dominates JSON response time).
-    def to_h
-      hash = {}
-      self.class.compiled.each do |name, block, dumper|
-        value = block ? instance_exec(object, &block) : object.public_send(name)
-        hash[name] = value.nil? || dumper.nil? ? value : dumper.call(value, context)
-      end
-      hash
-    end
-    alias as_json to_h
-  end
-end

data/lib/gemstack/types.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-require "date"
-require "time"
-
-module GemStack
-  # The type system shared by model fields, request schemas, serializers and
-  # the TypeScript/OpenAPI generators — one name per concept everywhere:
-  #
-  #   field :price, :decimal          (model)
-  #   required :price, :decimal       (request schema)
-  #   attribute :price, :decimal      (serializer)
-  #   price: string                   (generated TypeScript)
-  #
-  # Each type knows how to coerce input (strings from forms and query strings,
-  # JSON values), how to dump values into JSON, and its TypeScript / OpenAPI
-  # representation. Register your own with Types.register.
-  module Types
-    # Raised by a coercer when a value can't be converted; the message is the
-    # client-facing validation message ("must be an integer").
-    class CoercionError < StandardError; end
-
-    Type = Struct.new(:name, :ts, :openapi, :coercer, :dumper, keyword_init: true) do
-      def coerce(value) = coercer ? coercer.call(value) : value
-      def dump(value) = value.nil? || dumper.nil? ? value : dumper.call(value)
-    end
-
-    INTEGER = /\A[-+]?\d+\z/
-    NUMBER = /\A[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?\z/
-    UUID = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/i
-    TRUE_VALUES = [true, 1, "1", "true", "TRUE", "True", "on", "yes"].freeze
-    FALSE_VALUES = [false, 0, "0", "false", "FALSE", "False", "off", "no"].freeze
-
-    CLASS_ALIASES = {
-      String => :string, Integer => :integer, Float => :float, BigDecimal => :decimal,
-      TrueClass => :boolean, FalseClass => :boolean, Date => :date, Time => :datetime,
-      DateTime => :datetime, Hash => :json
-    }.freeze
-
-    @registry = {}
-
-    class << self
-      def register(name, ts:, openapi:, coerce: nil, dump: nil)
-        @registry[name.to_sym] = Type.new(name: name.to_sym, ts: ts, openapi: openapi.freeze,
-                                          coercer: coerce, dumper: dump).freeze
-      end
-
-      # Accepts a type name (:string) or a Ruby class (String, Integer, ...).
-      def fetch(name)
-        key = CLASS_ALIASES.fetch(name, name)
-        @registry.fetch(key.to_sym) do
-          raise ArgumentError, "unknown type #{name.inspect}; known types: #{@registry.keys.join(", ")}"
-        end
-      end
-
-      def type?(name)
-        CLASS_ALIASES.key?(name) || ((name.is_a?(Symbol) || name.is_a?(String)) && @registry.key?(name.to_sym))
-      end
-
-      def names = @registry.keys
-
-      def fail!(message) = raise(CoercionError, message)
-
-      def to_integer(value)
-        case value
-        when Integer then value
-        when Float then value == value.floor ? value.to_i : fail!("must be an integer")
-        when String then value.strip.match?(INTEGER) ? Integer(value.strip, 10) : fail!("must be an integer")
-        else fail!("must be an integer")
-        end
-      end
-
-      def to_float(value)
-        case value
-        when Float then value
-        when Numeric then value.to_f
-        when String then value.strip.match?(NUMBER) ? Float(value.strip) : fail!("must be a number")
-        else fail!("must be a number")
-        end
-      end
-
-      def to_decimal(value)
-        case value
-        when BigDecimal then value
-        when Integer then BigDecimal(value)
-        when Float then BigDecimal(value.to_s)
-        when String then value.strip.match?(NUMBER) ? BigDecimal(value.strip) : fail!("must be a decimal number")
-        else fail!("must be a decimal number")
-        end
-      end
-
-      def to_boolean(value)
-        return true if TRUE_VALUES.include?(value)
-        return false if FALSE_VALUES.include?(value)
-
-        fail!("must be true or false")
-      end
-
-      def to_date(value)
-        case value
-        when DateTime, Time then value.to_date
-        when Date then value
-        when String then Date.iso8601(value.strip)
-        else fail!("must be a date (YYYY-MM-DD)")
-        end
-      rescue ArgumentError # includes Date::Error
-        fail!("must be a date (YYYY-MM-DD)")
-      end
-
-      def to_datetime(value)
-        case value
-        when Time then value
-        when DateTime then value.to_time
-        when String then parse_time(value.strip)
-        else fail!("must be a date-time (ISO 8601)")
-        end
-      end
-
-      private
-
-      # ISO 8601 with a zone, or a zone-less "YYYY-MM-DDTHH:MM[:SS]" (as sent
-      # by <input type="datetime-local">), which is read as UTC.
-      def parse_time(string)
-        Time.iso8601(string)
-      rescue ArgumentError
-        match = string.match(/\A(\d{4})-(\d\d)-(\d\d)[T ](\d\d):(\d\d)(?::(\d\d))?\z/)
-        fail!("must be a date-time (ISO 8601)") unless match
-        Time.utc(*match.captures.compact.map(&:to_i))
-      end
-    end
-
-    string = lambda do |value|
-      case value
-      when String then value
-      when Symbol, Numeric then value.to_s
-      else fail!("must be a string")
-      end
-    end
-    iso_time = ->(value) { (value.respond_to?(:to_time) ? value.to_time : value).utc.iso8601(3) }
-
-    register :string, ts: "string", openapi: { type: "string" }, coerce: string
-    register :text, ts: "string", openapi: { type: "string" }, coerce: string
-    register :integer, ts: "number", openapi: { type: "integer" }, coerce: method(:to_integer)
-    register :bigint, ts: "number", openapi: { type: "integer", format: "int64" }, coerce: method(:to_integer)
-    register :references, ts: "number", openapi: { type: "integer", format: "int64" }, coerce: method(:to_integer)
-    register :float, ts: "number", openapi: { type: "number" }, coerce: method(:to_float)
-    # Decimals travel as strings so no precision is lost in JavaScript.
-    register :decimal, ts: "string", openapi: { type: "string", format: "decimal" },
-                       coerce: method(:to_decimal),
-                       dump: ->(value) { (value.is_a?(BigDecimal) ? value : BigDecimal(value.to_s)).to_s("F") }
-    register :boolean, ts: "boolean", openapi: { type: "boolean" }, coerce: method(:to_boolean)
-    register :date, ts: "string", openapi: { type: "string", format: "date" },
-                    coerce: method(:to_date), dump: lambda(&:iso8601)
-    register :datetime, ts: "string", openapi: { type: "string", format: "date-time" },
-                        coerce: method(:to_datetime), dump: iso_time
-    register :uuid, ts: "string", openapi: { type: "string", format: "uuid" },
-                    coerce: lambda { |value|
-                      value.is_a?(String) && value.match?(UUID) ? value.downcase : fail!("must be a UUID")
-                    }
-    register :json, ts: "unknown", openapi: {}
-  end
-end