rapitapir 0.1.0

data/lib/rapitapir/types/string.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RapiTapir
+  module Types
+    # String type with length and format validation
+    #
+    # Validates string values with optional constraints for length, pattern matching,
+    # and format validation (email, URI, etc.).
+    #
+    # @example Basic string
+    #   RapiTapir::Types.string
+    #
+    # @example String with constraints
+    #   RapiTapir::Types.string(min_length: 1, max_length: 255, format: :email)
+    class String < Base
+      def initialize(min_length: nil, max_length: nil, pattern: nil, format: nil, **options)
+        super
+      end
+
+      protected
+
+      def validate_type(value)
+        return ["Expected string, got #{value.class}"] unless value.is_a?(::String)
+
+        []
+      end
+
+      def validate_constraints(value)
+        errors = []
+
+        errors.concat(validate_length_constraints(value))
+        errors.concat(validate_pattern_constraint(value))
+        errors.concat(validate_format_constraint(value))
+
+        errors
+      end
+
+      def validate_length_constraints(value)
+        errors = []
+
+        errors.concat(validate_min_length_constraint(value))
+        errors.concat(validate_max_length_constraint(value))
+
+        errors
+      end
+
+      def validate_min_length_constraint(value)
+        return [] unless constraints[:min_length] && value.length < constraints[:min_length]
+
+        ["String length #{value.length} is below minimum #{constraints[:min_length]}"]
+      end
+
+      def validate_max_length_constraint(value)
+        return [] unless constraints[:max_length] && value.length > constraints[:max_length]
+
+        ["String length #{value.length} exceeds maximum #{constraints[:max_length]}"]
+      end
+
+      def validate_pattern_constraint(value)
+        return [] unless constraints[:pattern] && !constraints[:pattern].match?(value)
+
+        ["String '#{value}' does not match pattern #{constraints[:pattern].inspect}"]
+      end
+
+      def validate_format_constraint(value)
+        return [] unless constraints[:format]
+
+        validate_format(value, constraints[:format])
+      end
+
+      def coerce_value(value)
+        case value
+        when ::String then value
+        when Symbol, Numeric then value.to_s
+        else
+          raise CoercionError.new(value, 'String', 'Value does not respond to to_s') unless value.respond_to?(:to_s)
+
+          value.to_s
+
+        end
+      end
+
+      def json_type
+        'string'
+      end
+
+      def apply_constraints_to_schema(schema)
+        super
+        apply_length_constraints_to_schema(schema)
+        apply_pattern_and_format_constraints_to_schema(schema)
+      end
+
+      def apply_length_constraints_to_schema(schema)
+        schema[:minLength] = constraints[:min_length] if constraints[:min_length]
+        schema[:maxLength] = constraints[:max_length] if constraints[:max_length]
+      end
+
+      def apply_pattern_and_format_constraints_to_schema(schema)
+        schema[:pattern] = constraints[:pattern].source if constraints[:pattern]
+        schema[:format] = constraints[:format].to_s if constraints[:format]
+      end
+
+      private
+
+      def validate_format(value, format)
+        case format
+        when :email
+          validate_email_format(value)
+        when :uri, :url
+          validate_uri_format(value)
+        when :uuid
+          validate_uuid_format(value)
+        else
+          validate_datetime_and_ip_formats(value, format)
+        end
+      end
+
+      def validate_datetime_and_ip_formats(value, format)
+        case format
+        when :date
+          validate_date_format(value)
+        when :datetime, :'date-time'
+          validate_datetime_format(value)
+        when :ipv4
+          validate_ipv4_format(value)
+        when :ipv6
+          validate_ipv6_format(value)
+        else
+          []
+        end
+      end
+
+      def validate_email_format(value)
+        # Basic email validation - in production, consider using a more robust library
+        email_pattern = /\A[\w+\-.]+@[a-z\d-]+(\.[a-z\d-]+)*\.[a-z]+\z/i
+        email_pattern.match?(value) ? [] : ['Invalid email format']
+      end
+
+      def validate_uri_format(value)
+        require 'uri'
+        URI.parse(value)
+        []
+      rescue URI::InvalidURIError
+        ['Invalid URI format']
+      end
+
+      def validate_uuid_format(value)
+        uuid_pattern = /\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i
+        uuid_pattern.match?(value) ? [] : ['Invalid UUID format']
+      end
+
+      def validate_date_format(value)
+        require 'date'
+        ::Date.parse(value)
+        []
+      rescue ArgumentError
+        ['Invalid date format']
+      end
+
+      def validate_datetime_format(value)
+        require 'date'
+        ::DateTime.parse(value)
+        []
+      rescue ArgumentError
+        ['Invalid datetime format']
+      end
+
+      def validate_ipv4_format(value)
+        ipv4_pattern = /\A(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\z/
+        ipv4_pattern.match?(value) ? [] : ['Invalid IPv4 format']
+      end
+
+      def validate_ipv6_format(value)
+        # Simplified IPv6 validation - in production, consider using a more robust library
+        require 'ipaddr'
+        IPAddr.new(value, Socket::AF_INET6)
+        []
+      rescue IPAddr::InvalidAddressError
+        ['Invalid IPv6 format']
+      end
+    end
+  end
+end

data/lib/rapitapir/types/uuid.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'string'
+
+module RapiTapir
+  module Types
+    # UUID type for validating UUID (Universally Unique Identifier) strings
+    # Extends String type with UUID format validation
+    class UUID < String
+      UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i
+
+      def initialize(**options)
+        super(pattern: UUID_PATTERN, **options)
+      end
+
+      protected
+
+      def validate_type(value)
+        return ["Expected string, got #{value.class}"] unless value.is_a?(::String)
+        return ['Invalid UUID format'] unless UUID_PATTERN.match?(value)
+
+        []
+      end
+
+      def apply_constraints_to_schema(schema)
+        super
+        schema[:format] = 'uuid'
+        schema[:pattern] = UUID_PATTERN.source
+      end
+    end
+  end
+end

data/lib/rapitapir/types.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative 'types/base'
+require_relative 'types/string'
+require_relative 'types/integer'
+require_relative 'types/float'
+require_relative 'types/boolean'
+require_relative 'types/date'
+require_relative 'types/datetime'
+require_relative 'types/uuid'
+require_relative 'types/email'
+require_relative 'types/array'
+require_relative 'types/hash'
+require_relative 'types/optional'
+require_relative 'types/object'
+
+module RapiTapir
+  # Type system for RapiTapir providing validation, coercion, and schema generation
+  #
+  # Provides a comprehensive type system with built-in types for strings, integers,
+  # floats, booleans, dates, arrays, hashes, and objects. Supports validation,
+  # type coercion, constraint checking, and OpenAPI schema generation.
+  #
+  # @example Basic types
+  #   RapiTapir::Types.string(min_length: 1, max_length: 255)
+  #   RapiTapir::Types.integer(minimum: 0, maximum: 100)
+  #   RapiTapir::Types.array(RapiTapir::Types.string)
+  #
+  # @example Custom objects
+  #   user_type = RapiTapir::Types.object do
+  #     field :id, RapiTapir::Types.integer
+  #     field :name, RapiTapir::Types.string
+  #   end
+  module Types
+    # Error raised when type validation fails
+    #
+    # Contains information about the validation failure including the
+    # invalid value, expected type, and specific error details.
+    class ValidationError < StandardError
+      attr_reader :value, :type, :errors
+
+      def initialize(value, type, errors = [])
+        @value = value
+        @type = type
+        @errors = errors
+        super(build_message)
+      end
+
+      private
+
+      def build_message
+        begin
+          type_name = type.to_s
+        rescue StandardError
+          type_name = type.class.name
+        end
+        base = "Validation failed for value #{value.inspect} against type #{type_name}"
+        return base if errors.empty?
+
+        "#{base}:\n#{errors.map { |error| "  - #{error}" }.join("\n")}"
+      end
+    end
+
+    # Error raised when type coercion fails
+    #
+    # Occurs when a value cannot be automatically converted to the expected type,
+    # such as trying to coerce a non-numeric string to an integer.
+    class CoercionError < StandardError
+      attr_reader :value, :type, :reason
+
+      def initialize(value, type, reason = nil)
+        @value = value
+        @type = type
+        @reason = reason
+        super(build_message)
+      end
+
+      private
+
+      def build_message
+        base = "Cannot coerce #{value.inspect} to #{type}"
+        reason ? "#{base}: #{reason}" : base
+      end
+    end
+
+    # Convenience methods for creating types
+    def self.string(**options)
+      String.new(**options)
+    end
+
+    def self.integer(**options)
+      Integer.new(**options)
+    end
+
+    def self.float(**options)
+      Float.new(**options)
+    end
+
+    def self.boolean
+      Boolean.new
+    end
+
+    def self.date(**options)
+      Date.new(**options)
+    end
+
+    def self.datetime(**options)
+      DateTime.new(**options)
+    end
+
+    def self.uuid
+      UUID.new
+    end
+
+    def self.email
+      Email.new
+    end
+
+    def self.array(item_type, **options)
+      Array.new(item_type, **options)
+    end
+
+    def self.hash(field_types = {}, **options)
+      Hash.new(field_types, **options)
+    end
+
+    def self.optional(type)
+      Optional.new(type)
+    end
+
+    def self.object(&block)
+      Object.new(&block)
+    end
+
+    # Auto-derivation convenience methods
+    def self.from_hash(hash, **options)
+      Types::AutoDerivation.from_hash(hash, **options)
+    end
+
+    def self.from_protobuf(proto_class, **options)
+      Types::AutoDerivation.from_protobuf(proto_class, **options)
+    end
+
+    def self.from_json_schema(json_schema, **options)
+      Types::AutoDerivation.from_json_schema(json_schema, **options)
+    end
+
+    def self.from_open_struct(open_struct, **options)
+      Types::AutoDerivation.from_open_struct(open_struct, **options)
+    end
+  end
+end
+
+# Load auto-derivation after Types module is fully defined
+require_relative 'types/auto_derivation'

data/lib/rapitapir/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RapiTapir
+  VERSION = '0.1.0'
+end

data/lib/rapitapir.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative 'rapitapir/version'
+require_relative 'rapitapir/types'
+require_relative 'rapitapir/schema'
+require_relative 'rapitapir/core/endpoint'
+require_relative 'rapitapir/core/input'
+require_relative 'rapitapir/core/output'
+require_relative 'rapitapir/core/request'
+require_relative 'rapitapir/core/response'
+require_relative 'rapitapir/dsl/endpoint_dsl'
+
+# Enhanced components for Phase 1
+require_relative 'rapitapir/core/enhanced_endpoint'
+require_relative 'rapitapir/dsl/enhanced_endpoint_dsl'
+require_relative 'rapitapir/server/enhanced_rack_adapter'
+require_relative 'rapitapir/server/sinatra_integration'
+require_relative 'rapitapir/dsl/fluent_dsl'
+require_relative 'rapitapir/dsl/http_verbs'
+
+# Observability components (Phase 2.1)
+require_relative 'rapitapir/observability'
+
+# Authentication & Security components (Phase 2.2)
+require_relative 'rapitapir/auth'
+
+# Server components (optional, only load if needed)
+begin
+  require_relative 'rapitapir/server/rack_adapter'
+  require_relative 'rapitapir/server/path_matcher'
+  require_relative 'rapitapir/server/middleware'
+rescue LoadError
+  # Server dependencies not available
+end
+
+# Framework adapters (optional, only load if framework is available)
+begin
+  if defined?(Sinatra)
+    require_relative 'rapitapir/server/sinatra_adapter'
+    require_relative 'rapitapir/sinatra_rapitapir'
+  end
+rescue LoadError
+  # Sinatra not available
+end
+
+begin
+  require_relative 'rapitapir/server/rails_adapter' if defined?(Rails)
+rescue LoadError
+  # Rails not available
+end
+
+# OpenAPI and client generation (optional)
+begin
+  require_relative 'rapitapir/openapi/schema_generator'
+  require_relative 'rapitapir/client/generator_base'
+  require_relative 'rapitapir/client/typescript_generator'
+rescue LoadError
+  # OpenAPI or client generation dependencies not available
+end
+
+# Documentation and CLI tools (optional)
+begin
+  require_relative 'rapitapir/docs/markdown_generator'
+  require_relative 'rapitapir/docs/html_generator'
+  require_relative 'rapitapir/cli/command'
+  require_relative 'rapitapir/cli/server'
+  require_relative 'rapitapir/cli/validator'
+rescue LoadError
+  # Documentation or CLI dependencies not available
+end
+
+# RapiTapir - A Ruby library for defining HTTP APIs declaratively
+#
+# Inspired by Scala's Tapir, this library provides type-safe input/output definitions,
+# automatic OpenAPI documentation generation, and seamless integration with multiple Ruby stacks.
+#
+# @example Basic usage
+#   endpoint = RapiTapir.get('/users/{id}')
+#     .path_param(:id, :integer)
+#     .ok(:json, { id: :integer, name: :string })
+#     .build
+#
+# @example Enhanced DSL usage
+#   include RapiTapir::DSL::HTTPVerbs
+#   endpoint = GET('/users/{id}')
+#     .path_param(:id, :integer)
+#     .ok(:json, { id: :integer, name: :string })
+#     .build
+#
+# @see https://github.com/riccardomerolla/rapitapir
+module RapiTapir
+  # Will be extended with FluentDSL later
+  @endpoints = []
+
+  # Extend the module with HTTP verbs for global access
+  extend DSL::HTTPVerbs
+
+  def self.endpoints
+    @endpoints
+  end
+
+  def self.register_endpoint(endpoint)
+    @endpoints << endpoint
+    endpoint
+  end
+
+  def self.clear_endpoints
+    @endpoints.clear
+  end
+
+  # Observability configuration
+  def self.configure
+    yield(Observability.configuration) if block_given?
+
+    # Initialize observability components after configuration
+    configure_metrics
+    configure_tracing
+    configure_logging
+    configure_health_check
+  end
+
+  private_class_method def self.configure_metrics
+    return unless Observability.config.metrics.enabled
+
+    Observability::Metrics.configure(
+      provider: Observability.config.metrics.provider,
+      namespace: Observability.config.metrics.namespace,
+      custom_labels: Observability.config.metrics.custom_labels
+    )
+  end
+
+  private_class_method def self.configure_tracing
+    return unless Observability.config.tracing.enabled
+
+    Observability::Tracing.configure(
+      service_name: Observability.config.tracing.service_name,
+      service_version: Observability.config.tracing.service_version,
+      provider: Observability.config.tracing.provider
+    )
+  end
+
+  private_class_method def self.configure_logging
+    return unless Observability.config.logging.enabled
+
+    Observability::Logging.configure(
+      level: Observability.config.logging.level,
+      format: Observability.config.logging.format,
+      structured: Observability.config.logging.structured
+    )
+  end
+
+  private_class_method def self.configure_health_check
+    return unless Observability.config.health_check.enabled
+
+    Observability::HealthCheck.configure(
+      endpoint: Observability.config.health_check.endpoint
+    )
+
+    # Register custom health checks
+    Observability.config.health_check.checks.each do |check|
+      Observability::HealthCheck.register(check[:name], &check[:check])
+    end
+  end
+
+  # Convenience methods for creating endpoints (will be replaced by FluentDSL)
+  def self.endpoint
+    Core::Endpoint.new
+  end
+end
+
+# Convenience constant for cleaner type syntax
+# Users can use T instead of RapiTapir::Types for shorter, more readable code
+T = RapiTapir::Types

data/rapitapir.gemspec

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'lib/rapitapir/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rapitapir'
+  spec.version = RapiTapir::VERSION
+  spec.authors = ['Riccardo Merolla']
+  spec.email = ['riccardo.merolla@gmail.com']
+
+  spec.summary = 'Type-safe HTTP API development for Ruby'
+  spec.description = <<~DESC
+    RapiTapir is a Ruby library inspired by Scala's Tapir for building type-safe HTTP APIs.#{' '}
+    It provides declarative endpoint definitions, automatic OpenAPI documentation generation,#{' '}
+    client code generation, and seamless integration with Sinatra, Rails, and Rack applications.
+  DESC
+
+  spec.homepage = 'https://riccardomerolla.github.io/rapitapir/'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/riccardomerolla/rapitapir'
+  spec.metadata['changelog_uri'] = 'https://github.com/riccardomerolla/rapitapir/blob/main/CHANGELOG.md'
+  spec.metadata['documentation_uri'] = 'https://riccardomerolla.github.io/rapitapir/docs'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/riccardomerolla/rapitapir/issues'
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[
+                                                           bin/ test/ spec/ features/ .git .github appveyor Gemfile
+                                                         ])
+    end
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Runtime dependencies
+  spec.add_dependency 'json', '~> 2.0'
+  spec.add_dependency 'rack', '~> 2.0', '>= 2.0'
+
+  # Optional framework dependencies
+  spec.add_dependency 'sinatra', '>= 2.0', '< 4.0'
+
+  # Development dependencies
+  spec.add_development_dependency 'rack-test', '~> 2.0'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'simplecov', '~> 0.22'
+  spec.add_development_dependency 'webrick', '~> 1.8'
+
+  # Documentation
+  spec.add_development_dependency 'redcarpet', '~> 3.6'
+  spec.add_development_dependency 'yard', '~> 0.9'
+
+  # Code quality
+  spec.add_development_dependency 'rubocop', '~> 1.50'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.18'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.20'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end