dryer_routes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a0daf5be57e9f83be3336908b4c91e317c379125dfe7ebf169d871069cbbc191
+  data.tar.gz: d7993a1caac99edfd196e4bfa9ed46b3e0c3f790d78e57759b4645939d6b07f2
+SHA512:
+  metadata.gz: 01035ae9c9ac7ddd871d4f255222af12ffcda7f6b8559669ab33ef442110afdff4683ff722507c43606c57047170500fc8e8410279a8e984a0afd091b2db977f
+  data.tar.gz: 8629dc965328f7e627e8436e34cb4b20ef7ac00b291eed061d9959c43ec3df07a6d366b2f360bc615c4b9e33b8369ff1fa49e74f4363c984f4b686ba520bd6ca

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+Copyright (c) 2023 John Bernier
+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,156 @@
+# Dryer Routes
+Dryer Routes is a gem allows for request and response types to be added to a
+Rails routes file via [dry-validation](https://dry-rb.org/gems/dry-validation/1.8/) contracts
+
+## Installation
+add the following to you gemfile
+```
+gem "dryer_routes"
+```
+
+## Usage
+Add this code to `config/initializers/dry_routes.rb`
+```
+RouteRegistry = Dryer::Routes::Registry.new
+```
+
+And then in `config/routes.rb` you can register your app's routes, eg.
+```
+Rails.application.routes.draw do
+  RouteRegistry.register(
+    {
+      controller: UsersController,
+      url: "/users",
+      actions: {
+        create: {
+          method: :post,
+          request_contract: Contracts::Users::Post::Request,
+          response_contracts: {
+            200 => Contracts::Users::Post::Response,
+          }
+        }
+      }
+    },
+    {
+      controller: SessionsController,
+      url: "/sessions",
+      actions: {
+        create: {
+          method: :post,
+          request_contract: Contracts::Sessions::Post::Request,
+          response_contracts: {
+            200 => Contracts::Sessions::Post::Response,
+          }
+        }
+      }
+    }
+  )
+  RouteRegistry.to_rails_routes(self)
+end
+```
+
+## Features
+This gem helps organize and enforce typing for your routes, all relevant data
+can be accessed through the gem keeping your code *dry*
+
+### Easy to find route metadata
+request contracts: `RouteRegistry.users.create.request_contract`
+
+route url: `RouteRegistry.users.create.url`
+
+response contracts: `RouteRegistry.users.create.response_contracts._200`
+
+### Generating types in controller tests
+```
+class UsersControllerIntegreationTest < ActionDispatch::IntegrationTest
+  test "POST 200 - successfully creating a user" do
+    request = Dryer::Factories::BuildFromContract.call(
+      RouteRegistry.users.create.request_contract
+    )
+    post RouteRegistry.users.create.url, params: request.as_json
+
+    assert_response :success
+
+    assert_empty RouteRegistry.users.create.response_contracts._200.new.call(
+      JSON.parse(response.body)
+    ).errors
+  end
+end
+```
+Shameless plug for my other gem [dryer_factories](https://github.com/jbernie2/dryer-factories)
+
+### Enforcing types in Controllers
+By adding an `around_action` to `ApplicationController`, a controller's requests
+and responses can be validated automatically eg:
+```
+class ApplicationController < ActionController::Base
+  include Dry::Monads[:result]
+
+  around_action :validate_request_and_response
+
+  def validate_request
+    request_errors = RouteRegistry.validate_request(request)
+    if request_errors.empty?
+      @validated_request_body = Dry::Monads::Success(request.params)
+    else
+      @validated_request_body = Dry::Monads::Failure(request_errors)
+    end
+  end
+  attr_reader :validated_request_body
+
+  def validate_response
+    response_errors = RouteRegistry.validate_response(
+      controller: request.controller_class,
+      method: request.request_method_symbol,
+      status: response.status,
+      body: JSON.parse(response.body)
+    )
+    if !response_errors.empty?
+      Rails.logger.error("
+        #{request.controller_class}##{request.request_method_symbol}
+        response errors: #{response_errors}
+      ")
+    end
+    response
+  end
+
+  def validate_request_and_response
+    validate_request
+    if validated_request_body.success?
+      yield
+      validate_response
+    else
+      render json: {errors: validated_request_body.failure.to_h}, status: :bad_request
+    end
+  end
+end
+```
+
+Allowing the controller to look like
+```
+class UsersController < ApplicationController
+  def create
+    validated_request_body.bind do |body|
+      # Do stuff
+    end
+  end
+end
+```
+
+## Development
+This gem is set up to be developed using [Nix](https://nixos.org/)
+Once you have nix installed you can run
+`make bundle`
+to install all dependencies and
+`make dev-shell`
+to enter the development environment.
+
+## Contributing
+Please create a github issue to report any problems using the Gem.
+Thanks for your help in making testing easier for everyone!
+
+## Versioning
+Dryer Routes follows Semantic Versioning 2.0 as defined at https://semver.org.
+
+## License
+This code is free to use under the terms of the MIT license.

data/dryer_routes.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |spec|
+  spec.name                  = 'dryer_routes'
+  spec.version               = "0.0.1"
+  spec.authors               = ['John Bernier']
+  spec.email                 = ['john.b.bernier@gmail.com']
+  spec.summary               = 'Typed routing for rails leveraging dry-validation contracts'
+  spec.description           = <<~DOC
+    An extension of the Dry family of gems (dry-rb.org).
+    This gem allows for rails routes to specify contracts for requests 
+    and responses
+  DOC
+  spec.homepage              = 'https://github.com/jbernie2/dryer-routes'
+  spec.license               = 'MIT'
+  spec.platform              = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 3.0.0'
+  spec.files = Dir[
+    'README.md',
+    'LICENSE',
+    'CHANGELOG.md',
+    'lib/**/*.rb',
+    'dryer_routes.gemspec',
+    '.github/*.md',
+    'Gemfile'
+  ]
+  spec.add_dependency "dry-validation", "~> 1.10"
+  spec.add_dependency "dry-types", "~> 1.7"
+  spec.add_development_dependency "rspec", "~> 3.10"
+  spec.add_development_dependency "debug", "~> 1.8"
+end

data/lib/dryer/routes/build_from_resource.rb

@@ -0,0 +1,27 @@
+require_relative "./simple_service"
+require_relative "./route"
+
+module Dryer
+  module Routes
+    class BuildFromResource < SimpleService
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def call
+        resource[:actions].map do |action, config|
+          Route.new(
+            controller: resource[:controller],
+            url: config[:url] || resource[:url],
+            method: config[:method],
+            controller_action: action,
+            request_contract: config[:request_contract],
+            response_contracts: config[:response_contracts]
+          )
+        end
+      end
+
+      attr_reader :resource
+    end
+  end
+end

data/lib/dryer/routes/hash_object.rb

@@ -0,0 +1,18 @@
+module Dryer
+  module Routes
+    class HashObject
+     def initialize(hash)
+        hash.each do |k,v|
+          key = k.is_a?(Numeric) ? "_#{k}" : k
+
+          self.instance_variable_set(
+            "@#{key}", v.is_a?(Hash) ? HashObject.new(v) : v
+          )
+          self.class.send(
+            :define_method, key, proc{self.instance_variable_get("@#{key}")}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dryer/routes/registries/create.rb

@@ -0,0 +1,11 @@
+module Dryer
+  module Routes
+    module Registries
+      class Create < SimpleService
+        def call
+
+        end
+      end
+    end
+  end
+end

data/lib/dryer/routes/registry.rb

@@ -0,0 +1,103 @@
+require_relative "./build_from_resource.rb"
+require_relative "./hash_object.rb"
+require_relative "./resource_schema.rb"
+
+module Dryer
+  module Routes
+    class Registry
+
+      def initialize
+        @resources = []
+        @routes = []
+      end
+
+      def register(*resources)
+        validate_resources!(resources)
+        @resources = resources
+        @routes = resources.map do |r|
+          BuildFromResource.call(r)
+        end.flatten
+        add_accessors_for_resources(resources)
+        @routes
+      end
+
+      def to_rails_routes(router)
+        @routes.map { |r| r.to_rails_route(router) }
+      end
+
+      def validate_request(request)
+        route_for(
+          controller: request.controller_class,
+          method: request.request_method_symbol
+        ).then do |route|
+          if route && route.request_contract
+            route.request_contract.new.call(request.params).errors
+          else
+            []
+          end
+        end
+      end
+
+      def validate_response(controller:, method:, status:, body:)
+        route_for(
+          controller: controller.class,
+          method: method.to_sym
+        ).then do |route|
+          if route && route.response_contract_for(status)
+            route.response_contract_for(status).new.call(body).errors
+          else
+            []
+          end
+        end
+      end
+
+      def route_for(controller:, method:)
+        @routes.filter do |r|
+          r.controller == controller
+          r.method == method
+        end.first
+      end
+
+      attr_reader :routes, :resources
+
+      private
+      attr_writer :routes, :resources
+
+      def add_accessors_for_resources(resources)
+        denormalize_resources(resources).inject(self) do |obj, (key, value)|
+          obj.define_singleton_method(key) { HashObject.new(value) }
+          obj
+        end
+      end
+
+      def denormalize_resources(resources)
+        resources.inject({}) do | h, resource |
+          h[
+            resource[:controller].controller_name.to_sym
+          ] = denormalize_resource(resource)
+          h
+        end
+      end
+
+      def denormalize_resource(resource)
+        resource[:actions].each do |key, value|
+          resource[:actions][key][:url] =
+            resource[:actions][key][:url] || resource[:url]
+        end
+        resource.merge(resource[:actions])
+      end
+
+      def validate_resources!(resources)
+        errors = resources.map do |r|
+          ResourceSchema.new.call(r)
+        end.select { |r| !r.errors.empty? }
+        if !errors.empty?
+          messages = errors.inject({}) do |messages, e|
+            messages.merge(e.errors.to_h)
+          end
+          raise "Invalid arguments: #{messages}"
+        end
+      end
+    end
+  end
+end

data/lib/dryer/routes/resource_schema.rb

@@ -0,0 +1,50 @@
+require 'dry-validation'
+
+module Dryer
+  module Routes
+    class ResourceSchema < Dry::Validation::Contract
+      params do
+        required(:controller).filled(:class)
+        required(:url).filled(:string)
+        required(:actions).filled(:hash)
+      end
+
+      class ActionSchema < Dry::Validation::Contract
+        params do
+          required(:method).filled(:symbol)
+          optional(:request_contract)
+          optional(:response_contracts).hash()
+        end
+
+        rule(:request_contract) do
+          if value && !value.ancestors.include?(Dry::Validation::Contract)
+            key.failure('must be a dry-validation contract')
+          end
+        end
+
+        rule(:response_contracts) do
+          values[:response_contracts].each do |key, value|
+            if !value.ancestors.include?(Dry::Validation::Contract)
+              key(:response_contracts).failure(
+                'must be a dry-validation contract'
+              )
+            end
+          end if values[:response_contracts]
+        end
+      end
+
+      rule(:actions) do
+        values[:actions].each do |key, value|
+          res = ActionSchema.new.call(value)
+          if !res.success?
+            res.errors.to_h.each do |name, messages|
+              messages.each do |msg|
+                key([key_name, name]).failure(msg)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dryer/routes/route.rb

@@ -0,0 +1,45 @@
+module Dryer
+  module Routes
+    class Route
+      def initialize(route_config)
+        @route_config = route_config
+      end
+
+      def to_rails_route(router)
+        router.send(
+          route_config[:method],
+          route_config[:url],
+          to: "#{
+            route_config[:controller].controller_path
+            }##{
+            route_config[:controller_action]
+          }"
+        )
+      end
+
+      def controller
+        route_config[:controller]
+      end
+
+      def method
+        route_config[:method]
+      end
+
+      def request_contract
+        route_config[:request_contract]
+      end
+
+      def response_contract_for(status)
+        route_config[:response_contracts][status]
+      end
+
+      def url
+        route_config[:url]
+      end
+
+      private
+      attr_reader :route_config
+    end
+  end
+end
+

data/lib/dryer/routes/simple_service.rb

@@ -0,0 +1,13 @@
+module Dryer
+  module Routes
+    class SimpleService
+      def self.call(*args)
+        if args.length == 1 && args[0].is_a?(Hash)
+          new(**args[0]).call
+        else
+          new(*args).call
+        end
+      end
+    end
+  end
+end

data/lib/dryer/routes/version.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+
+module Dryer
+  module Routes
+    VERSION = Gem::Specification::load(
+      "./dryer_routes.gemspec"
+    ).version
+  end
+end

data/lib/dryer_routes.rb

@@ -0,0 +1 @@
+require_relative "./dryer/routes/registry.rb"

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: dryer_routes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Bernier
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: "An extension of the Dry family of gems (dry-rb.org).\nThis gem allows
+  for rails routes to specify contracts for requests \nand responses\n"
+email:
+- john.b.bernier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- dryer_routes.gemspec
+- lib/dryer/routes/build_from_resource.rb
+- lib/dryer/routes/hash_object.rb
+- lib/dryer/routes/registries/create.rb
+- lib/dryer/routes/registry.rb
+- lib/dryer/routes/resource_schema.rb
+- lib/dryer/routes/route.rb
+- lib/dryer/routes/simple_service.rb
+- lib/dryer/routes/version.rb
+- lib/dryer_routes.rb
+homepage: https://github.com/jbernie2/dryer-routes
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.13
+signing_key:
+specification_version: 4
+summary: Typed routing for rails leveraging dry-validation contracts
+test_files: []