gemstack-schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83d696c90043ae45d43cf3c1a111ccdb4994074eefc92fa1ffee45b76a22099f
+  data.tar.gz: 3e15497f7f407e896075eee23f6b7fd571842652dfdff5fbf9ebcc69b5684a3e
+SHA512:
+  metadata.gz: de8fd8a7fc6706af6c571004b003430a83e4fb68cc6786f7045827b0eb8f03de65f079a8195d27f0b4fe77e595e1e19309b8e4c97fdf10a7815722b9ba910173
+  data.tar.gz: 80904233c21486bac7a3031a162ac245686cd1c32afd76aee93710649991ec079648f6b404ad9e24ee74fa4e743bc8a0e5180f229adc9796838455c7ac74d6c4

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+First release. See the [GemStack changelog](https://github.com/gemstack-rb/gemstack/blob/main/CHANGELOG.md).

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shoaib Malik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# gemstack-schema
+
+GemStack schema: shared types, request schemas and serializers.
+
+Part of [GemStack](https://github.com/gemstack-rb/gemstack), a modular Ruby API framework for Next.js
+applications. All GemStack gems are developed together in that repository and released with the same
+version.
+
+## 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`).
+
+## License
+
+MIT — see [LICENSE.txt](LICENSE.txt).

data/lib/gemstack/schema.rb

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

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

@@ -0,0 +1,163 @@
+# 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 (DECISIONS D-022).
+    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

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: gemstack-schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shoaib Malik
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  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.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+email:
+- gemstack26@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/gemstack/schema.rb
+- lib/gemstack/serializer.rb
+- lib/gemstack/types.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
+  bug_tracker_uri: https://github.com/gemstack-rb/gemstack/issues
+  documentation_uri: https://github.com/gemstack-rb/gemstack/tree/main/docs
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: 'GemStack schema: shared types, request schemas and serializers'
+test_files: []