dry_params 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5f02a2f9332d5329954419d09bfe9c65016fcbc48b1e533ba536308fc5b37b85
+  data.tar.gz: d5fcd3abfaf86f12f284f4d89e0b85edd9fcd152a9f6b3ec078ce0ef6cb8fb94
+SHA512:
+  metadata.gz: ff4c1cb65e04e0e3156f39beddf9662acb28c4e1958501cf3a97eb0c9252d56ae806fb9a44fb2081ac9a7744cc5b00ed8087c57073a5b4728d1f79264ba74bf9
+  data.tar.gz: 044d23e3fc8c00e5931bd739f6285258513594c9799957b61ff1788bc914c5dbeed4409b3fe1839108e96ea1597fb1b5c8949655cbed2e1153b313c738a31b8e

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2024-02-16
+
+### Added
+- Initial release
+- Grape adapter for generating API params from Dry::Validation contracts
+- Rails adapter for generating strong params from Dry::Validation contracts
+- Support for all common types: string, integer, float, decimal, date, time, boolean, array, hash
+- Custom param_type option for Grape (body, query, path)
+- Type annotations support

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rodrigo Barreto
+
+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,90 @@
+# DryParams
+
+> **Work in Progress** - This gem is under active development and currently used in production with Grape only.
+
+If you use `dry-validation` extensively, you know the pain of duplicating field definitions between your contracts and your API params. This gem eliminates that repetition by automatically generating Grape params (or Rails strong params) directly from your Dry::Validation contracts.
+
+## Installation
+
+```ruby
+gem 'dry_params'
+```
+
+## Grape
+
+```ruby
+class UserContract < Dry::Validation::Contract
+  params do
+    required(:name).filled(:string)
+    required(:age).filled(:integer)
+    optional(:email).maybe(:string)
+  end
+end
+
+DryParams.from(UserContract)
+# => {
+#   name: { type: String, desc: "Name", required: true, documentation: { param_type: "body" } },
+#   age: { type: Integer, desc: "Age", required: true, documentation: { param_type: "body" } },
+#   email: { type: String, desc: "Email", required: false, documentation: { param_type: "body" } }
+# }
+```
+
+Usage:
+
+```ruby
+desc "Create user", { params: DryParams.from(UserContract) }
+```
+
+For query params:
+
+```ruby
+desc "List users", { params: DryParams.from(UserFilterContract, param_type: 'query') }
+```
+
+## Rails
+
+```ruby
+DryParams.from(UserContract, adapter: :rails)
+# => [:name, :age, :email]
+```
+
+With arrays and hashes:
+
+```ruby
+class PostContract < Dry::Validation::Contract
+  params do
+    required(:title).filled(:string)
+    optional(:tags).filled(:array)
+    optional(:metadata).filled(:hash)
+  end
+end
+
+DryParams.from(PostContract, adapter: :rails)
+# => [:title, { tags: [], metadata: {} }]
+```
+
+Usage:
+
+```ruby
+def post_params
+  params.permit(DryParams.from(PostContract, adapter: :rails))
+end
+```
+
+## Development
+
+```bash
+bundle exec bin/console  # interactive console
+bundle exec rspec        # run tests
+```
+
+## Status
+
+- [x] Grape adapter (production ready)
+- [ ] Rails adapter (experimental)
+- [ ] Nested contracts support
+- [ ] Custom type mappings
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/dry_params/adapters/grape.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DryParams
+  module Adapters
+    class Grape
+      TYPE_MAPPING = {
+        string: String,
+        integer: Integer,
+        float: Float,
+        decimal: Float,
+        boolean: "Grape::API::Boolean",
+        date: Date,
+        time: Time,
+        array: Array,
+        hash: Hash,
+        array_of_hashes: [Hash]
+      }.freeze
+
+      DEFAULT_TYPE = String
+
+      def initialize(schema, options = {})
+        @schema = schema
+        @param_type = options[:param_type] || "body"
+      end
+
+      def to_params
+        @schema.fields.each_with_object({}) do |field, params|
+          params[field.name] = build_param(field)
+        end
+      end
+
+      private
+
+      def build_param(field)
+        {
+          type: map_type(field.type),
+          desc: field.description || field.name.to_s.tr("_", " ").capitalize,
+          required: field.required?,
+          documentation: { param_type: @param_type }
+        }
+      end
+
+      def map_type(type)
+        TYPE_MAPPING.fetch(type, DEFAULT_TYPE)
+      end
+    end
+  end
+end

data/lib/dry_params/adapters/rails.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DryParams
+  module Adapters
+    class Rails
+      TYPE_MAPPING = {
+        string: :scalar,
+        integer: :scalar,
+        float: :scalar,
+        decimal: :scalar,
+        boolean: :scalar,
+        date: :scalar,
+        time: :scalar,
+        array: :array,
+        hash: :hash,
+        array_of_hashes: :array_of_hashes
+      }.freeze
+
+      def initialize(schema, options = {})
+        @schema = schema
+        @options = options
+      end
+
+      # Returns an array suitable for Rails permit
+      # @return [Array] permit-compatible array
+      def to_params
+        scalars = []
+        complex = {}
+
+        @schema.fields.each do |field|
+          case map_type(field.type)
+          when :scalar
+            scalars << field.name
+          when :array
+            complex[field.name] = []
+          when :hash
+            complex[field.name] = {}
+          when :array_of_hashes
+            # For array of hashes, we permit all keys inside
+            complex[field.name] = {}
+          end
+        end
+
+        # Rails permit format: [:name, :email, { tags: [], settings: {} }]
+        complex.empty? ? scalars : scalars + [complex]
+      end
+
+      private
+
+      def map_type(type)
+        TYPE_MAPPING.fetch(type, :scalar)
+      end
+    end
+  end
+end

data/lib/dry_params/extractors/annotation_extractor.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module DryParams
+  module Extractors
+    class AnnotationExtractor
+      FIELD_PATTERN = /\s*(optional|required)\(:([\w_]+)\)/.freeze
+      ANNOTATION_PATTERN = /^\s*#\s*@(\w+)\s*=\s*(.+)/.freeze
+
+      def self.call(contract_class)
+        new(contract_class).extract
+      end
+
+      def initialize(contract_class)
+        @contract_class = contract_class
+      end
+
+      def extract
+        source_path = find_source_file
+        return {} unless source_path
+
+        parse_annotations(File.readlines(source_path))
+      end
+
+      private
+
+      def find_source_file
+        return nil unless defined?(Rails)
+
+        file_path = underscore(@contract_class.name)
+        possible_paths.find { |path| File.exist?(path % file_path) }
+                     &.then { |path| path % file_path }
+      end
+
+      def underscore(class_name)
+        class_name
+          .gsub("::", "/")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+      end
+
+      def possible_paths
+        return [] unless defined?(Rails)
+
+        [
+          Rails.root.join("app/contracts/%s.rb").to_s,
+          Rails.root.join("app/api/contracts/%s.rb").to_s,
+          Rails.root.join("app/models/%s.rb").to_s
+        ]
+      end
+
+      def parse_annotations(lines)
+        annotations = {}
+
+        lines.each_with_index do |line, index|
+          next unless line.match?(FIELD_PATTERN)
+
+          field_name = line.match(FIELD_PATTERN)[2].to_sym
+          previous_line = lines[index - 1]
+
+          if (match = previous_line&.match(ANNOTATION_PATTERN))
+            annotations[field_name] = match[2].strip if match[1] == field_name.to_s
+          end
+        end
+
+        annotations
+      end
+    end
+  end
+end

data/lib/dry_params/extractors/type_extractor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DryParams
+  module Extractors
+    class TypeExtractor
+      PREDICATES = {
+        /int\?/ => :integer,
+        /date\?/ => :date,
+        /time\?/ => :time,
+        /float\?/ => :float,
+        /decimal\?/ => :decimal,
+        /bool\?/ => :boolean,
+        /array\? AND each\(hash\?/ => :array_of_hashes,
+        /array\?/ => :array,
+        /hash\?/ => :hash
+      }.freeze
+
+      DEFAULT_TYPE = :string
+
+      def self.call(rule)
+        new(rule).extract
+      end
+
+      def initialize(rule)
+        @rule_string = rule.to_s
+      end
+
+      def extract
+        PREDICATES.each do |pattern, type|
+          return type if @rule_string.match?(pattern)
+        end
+
+        DEFAULT_TYPE
+      end
+    end
+  end
+end

data/lib/dry_params/schema.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DryParams
+  class Schema
+    attr_reader :fields
+
+    def initialize(fields)
+      @fields = fields
+    end
+
+    # Factory method to create a Schema from a contract class
+    def self.from_contract(contract_class)
+      contract = contract_class.new
+      annotations = Extractors::AnnotationExtractor.call(contract_class)
+
+      fields = contract.schema.rules.map do |name, rule|
+        Field.new(
+          name: name,
+          type: Extractors::TypeExtractor.call(rule),
+          required: required_field?(rule),
+          description: annotations[name]
+        )
+      end
+
+      new(fields)
+    end
+
+    def self.required_field?(rule)
+      !optional_field?(rule)
+    end
+
+    def self.optional_field?(rule)
+      return true if rule.is_a?(Dry::Logic::Operations::Implication)
+
+      if rule.is_a?(Dry::Logic::Operations::And)
+        rule.rules.any? { |sub_rule| sub_rule.is_a?(Dry::Logic::Operations::Implication) }
+      else
+        false
+      end
+    end
+
+    private_class_method :required_field?, :optional_field?
+  end
+
+  class Field
+    attr_reader :name, :type, :required, :description
+
+    def initialize(name:, type:, required:, description: nil)
+      @name = name
+      @type = type
+      @required = required
+      @description = description
+    end
+
+    def required?
+      @required
+    end
+
+    def optional?
+      !required?
+    end
+  end
+end

data/lib/dry_params/version.rb

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

data/lib/dry_params.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "date"
+
+require_relative "dry_params/version"
+require_relative "dry_params/schema"
+require_relative "dry_params/extractors/type_extractor"
+require_relative "dry_params/extractors/annotation_extractor"
+require_relative "dry_params/adapters/grape"
+require_relative "dry_params/adapters/rails"
+
+module DryParams
+  class Error < StandardError; end
+  class UnsupportedAdapterError < Error; end
+
+  ADAPTERS = {
+    grape: Adapters::Grape,
+    rails: Adapters::Rails
+  }.freeze
+
+  class << self
+    # Global adapter configuration (default: :grape)
+    attr_writer :adapter
+
+    def adapter
+      @adapter ||= :grape
+    end
+
+    # Configure DryParams
+    #
+    # @example
+    #   DryParams.configure do |config|
+    #     config.adapter = :grape
+    #   end
+    #
+    def configure
+      yield self
+    end
+
+    # Main entry point - converts a Dry::Validation::Contract to framework params
+    #
+    # @param contract_class [Class] the Dry::Validation::Contract class
+    # @param options [Hash] additional options
+    # @option options [Symbol] :adapter Override the global adapter (:grape, :rails)
+    # @option options [String] :param_type Swagger param type (default: 'body')
+    # @return [Hash] params hash for the target framework
+    #
+    # @example Basic usage
+    #   DryParams.from(UserCreateContract)
+    #
+    # @example With options
+    #   DryParams.from(UserCreateContract, param_type: 'formData')
+    #
+    # @example Override adapter
+    #   DryParams.from(UserCreateContract, adapter: :rails)
+    #
+    def from(contract_class, options = {})
+      selected_adapter = options.delete(:adapter) || adapter
+      adapter_class = ADAPTERS[selected_adapter]
+
+      raise UnsupportedAdapterError, "Adapter '#{selected_adapter}' not supported" unless adapter_class
+
+      schema = Schema.from_contract(contract_class)
+      adapter_class.new(schema, options).to_params
+    end
+
+    # Legacy API - kept for backwards compatibility
+    # @deprecated Use {.from} instead
+    def for(adapter_name, contract_class, options = {})
+      from(contract_class, options.merge(adapter: adapter_name))
+    end
+  end
+end

data/sig/dry_params.rbs

@@ -0,0 +1,4 @@
+module DryParams
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: dry_params
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- rodrinbarreto
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-02-20 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.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: grape
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Automatically generate Grape params or Rails strong params from Dry::Validation
+  contracts
+email:
+- rodrigonbarreto@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/dry_params.rb
+- lib/dry_params/adapters/grape.rb
+- lib/dry_params/adapters/rails.rb
+- lib/dry_params/extractors/annotation_extractor.rb
+- lib/dry_params/extractors/type_extractor.rb
+- lib/dry_params/schema.rb
+- lib/dry_params/version.rb
+- sig/dry_params.rbs
+homepage: https://github.com/rodrinbarreto/dry_params
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rodrinbarreto/dry_params
+  source_code_uri: https://github.com/rodrinbarreto/dry_params
+  changelog_uri: https://github.com/rodrinbarreto/dry_params/blob/main/CHANGELOG.md
+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.5.3
+signing_key:
+specification_version: 4
+summary: Convert Dry::Validation contracts to framework params
+test_files: []