praxis 2.0.pre.14 → 2.0.pre.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6af11de4fdf970e848d638ed6fd1f47db86dcd27562bca90e50805398a82b346
-  data.tar.gz: dd4b664b1b8afde291e0402eeb0bb57178214ac1d8d6a4dc691f532fff7ae29f
+  metadata.gz: 9391f2cd6fb2c5a605a4b4c9f492371ef1d7f01849e94a9d17fdc51b95c211a9
+  data.tar.gz: 70c9f00cd12c7b3e99cebd10f86a98ac913433b8b96a41b658893b63ddc4b31b
 SHA512:
-  metadata.gz: 525c64c37e1cfe27fe74c1ddbd02d3c6e45860acd0f8a79a5d9a0832274368c728dacc8096b3b37f63c302fe265161793320a64dcf44a84d99ee5074d9de9da2
-  data.tar.gz: 79a70e175f17a14d98beddd66add981c03a8c720dd45855221b5b3223cb021d056381a5fd87880e3cbe2886755445182cf6cad3427de9f38b44220a26b23955d
+  metadata.gz: edfc42021b347aea6bd7b84853ebd901f55e4963612da2a6870e00b956b3352e51efd8cd3c360123625af48f89553bff6fa0ad7766e076bc164ba8ccf770ba7b
+  data.tar.gz: da2df887a849f03be390f7218f931807670a58addc8eb3d101b293e0827a522680ca1824f47bafcff2c3f26bfb45bd13e8ad0c6f02577edad12c5c8cfca60904

data/bin/praxis

@@ -9,6 +9,12 @@ rescue Bundler::GemfileNotFound
   # no-op: we might be installed as a system gem
 end
 
+if ARGV[0] == "version"
+  require 'praxis/version'
+  puts "Praxis version #{Praxis::VERSION}"
+  exit 0
+end
+
 if ["routes","docs","console"].include? ARGV[0]
   require 'rake'
   require 'praxis'

data/lib/praxis/api_definition.rb

@@ -97,8 +97,10 @@ module Praxis
         description( description || 'Standard response for successful HTTP requests.' )
 
         media_type media_type
-        location location
-        headers headers if headers
+        location if location
+        headers&.each do |(name, value)|
+          header(name: name, value: value)
+        end
       end
 
       api.response_template :created do |media_type: nil, location: nil, headers: nil, description: nil|
@@ -106,8 +108,10 @@ module Praxis
         description( description || 'The request has been fulfilled and resulted in a new resource being created.' )
 
         media_type media_type if media_type
-        location location
-        headers headers if headers
+        location if location
+        headers&.each do |(name, value)|
+          header(name: name, value: value)
+        end
       end
     end
 

data/lib/praxis/collection.rb

@@ -32,5 +32,16 @@ module Praxis
       @member_type.domain_model
     end
 
+    def self.json_schema_type
+      :array
+    end
+
+    def self.as_json_schema(**args)
+      the_type = @attribute && @attribute.type || member_type
+      {
+        type: json_schema_type,
+        items: { '$ref': "#/components/schemas/#{the_type.id}" }
+      }
+    end
   end
 end

data/lib/praxis/docs/open_api/response_object.rb

@@ -16,12 +16,27 @@ module Praxis
 
         def dump_response_headers_object( headers )
           headers.each_with_object({}) do |(name,data),accum|
-            # data is a hash with :value and :type keys
-            # How did we say in that must match a value in json schema again??
-            accum[name] = {
-              schema: SchemaObject.new(info: data[:type])
-              # allowed values:  [ data[:value] ] ??? is this the right json schema way?
-            }
+            # each header comes from Praxis::ResponseDefinition 
+            # the keys are the header names, and value can be:
+            #  "true"  => means it only needs to exist
+            #  String => which means that it has to fully match
+            #  Regex  => which means it has to regexp match it
+
+            # Get the schema from the type (defaulting to string in case the type doesn't have the as_json_schema defined)
+            schema = data[:attribute].type.as_json_schema rescue { type: :string }
+            hash = { description: data[:description] || '', schema: schema }
+            # Note, our Headers in response definition are not full types...they're basically only 
+            # strings, which can either match anything, match the exact word or match a regex
+            # they don't even have a description...
+            data_value = data[:value]
+            if data_value.is_a? String
+              hash[:pattern] = "^#{data_value}$" # Exact String match
+            elsif data_value.is_a? Regexp
+              sanitized_pattern = data_value.inspect[1..-2] #inspect returns enclosing '/' characters
+              hash[:pattern] = sanitized_pattern
+            end
+
+            accum[name] = hash
           end
         end
 

data/lib/praxis/extensions/attribute_filtering/active_record_filter_query_builder.rb

@@ -23,7 +23,8 @@ module Praxis
       end
 
       class ActiveRecordFilterQueryBuilder
-      attr_reader :model, :filters_map
+        REFERENCES_STRING_SEPARATOR = '/'
+        attr_reader :model, :filters_map
 
         # Base query to build upon
         def initialize(query: , model:, filters_map:, debug: false)
@@ -65,8 +66,13 @@ module Praxis
           apply_single_condition = Proc.new do |condition, associated_query|
             colo = condition[:model].columns_hash[condition[:name].to_s]
             column_prefix = condition[:column_prefix]
-            #Mark where clause referencing the appropriate alias
-            associated_query = associated_query.references(build_reference_value(column_prefix, query: associated_query))
+            
+            # Mark where clause referencing the appropriate alias IF it's not the root table, as there is no association to reference
+            # If we added root table as a reference, we better make sure it is not quoted, as it actually makes AR to see it as an 
+            # unmatched reference and eager loads the whole association (it means eager load ALL the things). Not good.
+            unless for_model.table_name == column_prefix
+              associated_query = associated_query.references(build_reference_value(column_prefix, query: associated_query))
+            end
             self.class.add_clause(
               query: associated_query, 
               column_prefix: column_prefix, 
@@ -185,8 +191,7 @@ module Praxis
             h[name] = result[:associations_hash] 
             conditions += result[:conditions]
           end
-          column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? model.table_name : nodetree.path.join('/')
-          #column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? nil : nodetree.path.join('/')
+          column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? model.table_name : nodetree.path.join(REFERENCES_STRING_SEPARATOR)
           nodetree.conditions.each do |condition|
             conditions += [condition.merge(column_prefix: column_prefix, model: model)]
           end

data/lib/praxis/media_type_identifier.rb

@@ -198,10 +198,20 @@ module Praxis
       obj = self.class.new
       obj.type = self.type
       obj.subtype = self.subtype
-      obj.suffix = suffix || self.suffix || ''
+      target_suffix = suffix || self.suffix
+      obj.suffix = redundant_suffix(target_suffix) ? '' : target_suffix
       obj.parameters = self.parameters.merge(parameters)
 
       obj
     end
+
+    def redundant_suffix(suffix)
+      # application/json does not need to be suffixed with +json (same for application/xml)
+      # we're supporting text/json and text/xml for older formats as well
+      if (self.type == 'application' || self.type == 'text') && self.subtype == suffix
+        return true
+      end
+      false
+    end
   end
 end

data/lib/praxis/response_definition.rb

@@ -55,52 +55,36 @@ module Praxis
       end
     end
 
-    def location(loc=nil)
-      return @spec[:location] if loc.nil?
-      unless ( loc.is_a?(Regexp) || loc.is_a?(String) )
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid location specification. Location in response must be either a regular expression or a string."
-        )
-      end
-      @spec[:location] = loc
-    end
+    def location(loc=nil, description: nil)
+      return  headers.dig('Location',:value) if loc.nil?
 
-    def headers(hdrs = nil)
-      return @spec[:headers] if hdrs.nil?
+      header('Location', loc, description: description)
+    end
 
-      case hdrs
-      when Array
-        hdrs.each {|header_name| header(header_name) }
-      when Hash
-        header(hdrs)
-      when String
-        header(hdrs)
-      else
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid headers specification: Arrays, Hash, or String must be used. Received: #{hdrs.inspect}"
-        )
-      end
+    def headers
+      @spec[:headers]
     end
 
-    def header(hdr)
-      case hdr
-      when String
-        @spec[:headers][hdr] = true
-      when Hash
-        hdr.each do | k, v |
-          unless v.is_a?(Regexp) || v.is_a?(String)
-            raise Exceptions::InvalidConfiguration.new(
-              "Header definitions for #{k.inspect} can only match values of type String or Regexp. Received: #{v.inspect}"
-            )
-          end
-          @spec[:headers][k] = v
-        end
+    def header(name, value, description: nil)
+      the_type, args = case value
+      when nil,String
+        [String, {}]
+      when Regexp
+        # A regexp means it's gonna be a String typed, attached to a regexp
+        [String, { regexp: value }]
       else
         raise Exceptions::InvalidConfiguration.new(
-          "A header definition can only take a String (to match the name) or" +
-          " a Hash (to match both the name and the value). Received: #{hdr.inspect}"
+          "A header definition for a response can only take String, Regexp or nil values (to match anything)." +
+          "Received the following value for header name #{name}: #{value}"
         )
       end
+
+      info = { 
+        value: value, 
+        attribute: Attributor::Attribute.new(the_type, **args)
+      }
+      info[:description] = description if description
+      @spec[:headers][name] = info
     end
 
     def example(context=nil)
@@ -123,13 +107,14 @@ module Praxis
         :status => status,
         :headers => {}
       }
-      content[:location] = _describe_header(location) unless location == nil
 
       unless headers == nil
         headers.each do |name, value|
           content[:headers][name] = _describe_header(value)
         end
       end
+      content[:location] = content[:headers]['Location']
+
 
       if self.media_type
         payload = media_type.describe(true)
@@ -173,14 +158,14 @@ module Praxis
     end
 
     def _describe_header(data)
-      data_type = data.is_a?(Regexp) ? :regexp : :string
-      data_value = data.is_a?(Regexp) ? data.inspect : data
+
+      data_type = data[:value].is_a?(Regexp) ? :regexp : :string
+      data_value = data[:value].is_a?(Regexp) ? data[:value].inspect : data[:value]
       { :value => data_value, :type => data_type }
     end
 
     def validate(response, validate_body: false)
       validate_status!(response)
-      validate_location!(response)
       validate_headers!(response)
       validate_content_type!(response)
       validate_parts!(response)
@@ -222,23 +207,13 @@ module Praxis
       end
     end
 
-
-    # Validates 'Location' header
-    #
-    # @raise [Exceptions::Validation] When location header does not match to the defined one.
-    #
-    def validate_location!(response)
-      return if location.nil? || location === response.headers['Location']
-      raise Exceptions::Validation.new("LOCATION does not match #{location.inspect}")
-    end
-
-
     # Validates Headers
     #
     # @raise [Exceptions::Validation]  When there is a missing required header..
     #
     def validate_headers!(response)
       return unless headers
+
       headers.each do |name, value|
         if name.is_a? Symbol
           raise Exceptions::Validation.new(
@@ -252,20 +227,25 @@ module Praxis
           )
         end
 
-        case value
-        when String
-          if response.headers[name] != value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
-            )
-          end
-        when Regexp
-          if response.headers[name] !~ value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
-            )
-          end
+        errors = value[:attribute].validate(response.headers[name])
+
+        unless errors.empty? 
+          raise Exceptions::Validation.new("Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}.")
         end
+        # case value
+        # when String
+        #   if response.headers[name] != value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
+        #     )
+        #   end
+        # when Regexp
+        #   if response.headers[name] !~ value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
+        #     )
+        #   end
+        # end
       end
     end
 

data/lib/praxis/responses/http.rb

@@ -160,7 +160,9 @@ module Praxis
 
           media_type media_type if media_type
           location location if location
-          headers headers if headers
+          headers&.each do |(name, value)|
+            header(name: name, value: value)
+          end
         end
       end
 

data/lib/praxis/tasks/routes.rb

@@ -7,14 +7,14 @@ namespace :praxis do
     table = Terminal::Table.new title: "Routes",
     headings:  [
       "Version", "Path", "Verb",
-      "Resource", "Action", "Implementation", "Options"
+      "Endpoint", "Action", "Implementation", "Options"
     ]
 
     rows = []
-    Praxis::Application.instance.endpoint_definitions.each do |resource_definition|
-      resource_definition.actions.each do |name, action|
+    Praxis::Application.instance.endpoint_definitions.each do |endpoint_definition|
+      endpoint_definition.actions.each do |name, action|
         method = begin
-          m = resource_definition.controller.instance_method(name)
+          m = endpoint_definition.controller.instance_method(name)
         rescue
           nil
         end
@@ -22,13 +22,13 @@ namespace :praxis do
         method_name = method ? "#{method.owner.name}##{method.name}" : 'n/a'
 
         row = {
-          resource: resource_definition.name,
+          resource: endpoint_definition.name,
           action: name,
           implementation: method_name,
         }
 
         unless action.route
-          warn "Warning: No routes defined for #{resource_definition.name}##{name}."
+          warn "Warning: No routes defined for #{endpoint_definition.name}##{name}."
           rows << row
         else
           route = action.route

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.14'
+  VERSION = '2.0.pre.15'
 end

data/spec/praxis/action_definition_spec.rb

@@ -40,7 +40,9 @@ describe Praxis::ActionDefinition do
 
         media_type media_type
         location location
-        headers headers if headers
+        headers&.each do |(name, value)|
+          header(name, value)
+        end
       end
     end
     Praxis::ActionDefinition.new(:foo, endpoint_definition) do

data/spec/praxis/media_type_identifier_spec.rb

@@ -218,7 +218,21 @@ describe Praxis::MediaTypeIdentifier do
 
     it 'replaces suffix and parameters and adds new ones' do
       expect(complex_subject + 'json; nuts=false; cherry=true').to \
-      eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+        eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+    end
+
+    context 'does not add json for an already json identifier' do
+      it 'non-parameterized mediatypes simply ignore adding the suffix' do
+        plain_application_json = described_class.new('application/json')
+
+        expect(plain_application_json + 'json').to \
+          eq(plain_application_json)
+      end
+      it 'parameterized mediatypes still keeps them' do
+        parameterized_application_json = described_class.new('application/json; cherry=true; nuts=false')
+        expect(parameterized_application_json + 'json').to \
+          eq(parameterized_application_json)
+      end
     end
   end
 end

data/spec/praxis/response_definition_spec.rb

@@ -8,7 +8,8 @@ describe Praxis::ResponseDefinition do
     Proc.new do
       status 200
       description 'test description'
-      headers({ "X-Header" => "value", "Content-Type" => "application/some-type" })
+      header( "X-Header", "value", description: 'Very nais header')
+      header( "Content-Type", "application/some-type" )
     end
   end
 
@@ -17,7 +18,7 @@ describe Praxis::ResponseDefinition do
   its(:parts) { should be(nil) }
   let(:response_status) { 200 }
   let(:response_content_type) { "application/some-type" }
-  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type} }
+  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type, "Location" => '/somewhere/over/the/rainbow'} }
 
   let(:response) { instance_double("Praxis::Response", status: response_status , headers: response_headers, content_type: response_content_type ) }
 
@@ -105,29 +106,6 @@ describe Praxis::ResponseDefinition do
     end
   end
 
-  context '#headers' do
-    it 'accepts a Hash' do
-      response_definition.headers Hash["X-Header" => "value", "Content-Type" => "application/some-type"]
-      expect(response_definition.headers).to be_a(Hash)
-    end
-
-    it 'accepts an Array' do
-      response_definition.headers ["X-Header: value", "Content-Type: application/some-type"]
-      expect(response_definition.headers).to be_a(Hash)
-      expect(response_definition.headers.keys).to include("X-Header: value", "Content-Type: application/some-type")
-    end
-
-    it 'accepts a String' do
-      response_definition.headers "X-Header: value"
-      expect(response_definition.headers).to be_a(Hash)
-      expect(response_definition.headers.keys).to include("X-Header: value")
-    end
-
-    it 'should return an error when headers are not a Hash, Array or String object' do
-      expect{ response_definition.headers Object.new }. to raise_error(Praxis::Exceptions::InvalidConfiguration)
-    end
-  end
-
   context '#parts' do
     context 'with a :like argument (and no block)' do
       before do
@@ -242,7 +220,6 @@ describe Praxis::ResponseDefinition do
 
       it "calls all the validation sub-functions" do
         expect(response_definition).to receive(:validate_status!).once
-        expect(response_definition).to receive(:validate_location!).once
         expect(response_definition).to receive(:validate_headers!).once
         expect(response_definition).to receive(:validate_content_type!).once
         response_definition.validate(response)
@@ -272,112 +249,39 @@ describe Praxis::ResponseDefinition do
 
       end
 
-      describe "#validate_location!" do
-        let(:block) { proc { status 200 } }
-
-        context 'checking location mismatches' do
-          before { response_definition.location(location) }
-
-          context 'for Regexp' do
-            let(:location) { /no_match/ }
-
-            it 'should raise an error' do
-              expect {
-                response_definition.validate_location!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
-          end
-
-          context 'for String' do
-            let(:location) { "no_match" }
-            it 'should raise error' do
-              expect {
-                response_definition.validate_location!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
+      describe "#validate_headers!" do
+        context 'when there are missing headers' do
+          it 'should raise error' do
+            response_definition.header('X-Unknown', 'test')
+            expect {
+              response_definition.validate_headers!(response)
+            }.to raise_error(Praxis::Exceptions::Validation)
           end
-
         end
-      end
-
-      describe "#validate_headers!" do
-        before { response_definition.headers(headers) }
-        context 'checking headers are set' do
-          context 'when there are missing headers' do
-            let (:headers) { { 'X-some' => 'test' } }
-            it 'should raise error' do
-              expect {
-                response_definition.validate_headers!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
+        context 'when headers with same names are returned' do
+          it 'a simply required header should not raise error just by being there' do
+            response_definition.header('X-Header', nil)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when headers specs are name strings" do
-            context "and is missing" do
-              let (:headers) { [ "X-Just-Key" ] }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) { [ "X-Header" ] }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'an exact string header should not raise error if it fully matches' do
+            response_definition.header('X-Header', 'value')
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when header specs are hashes" do
-            context "and is missing" do
-              let (:headers) {
-                [ { "X-Just-Key" => "notfoodbar" } ]
-              }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" } ]
-              }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'a regexp header should not raise error if it matches the regexp' do
+            response_definition.header('X-Header', /value/)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to_not raise_error
           end
-
-          context "when header specs are of mixed type " do
-            context "and is missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" }, "not-gonna-find-me" ]
-              }
-              it 'should raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.to raise_error(Praxis::Exceptions::Validation)
-              end
-            end
-
-            context "and is not missing" do
-              let (:headers) {
-                [ { "X-Header" => "value" }, "Content-Type" ]
-              }
-              it 'should not raise error' do
-                expect {
-                  response_definition.validate_headers!(response)
-                }.not_to raise_error
-              end
-            end
+          it 'a regexp header should raise error if it does not match the regexp' do
+            response_definition.header('X-Header', /anotherthing/)
+            expect {
+              response_definition.validate_headers!(response)
+            }.to raise_error(Praxis::Exceptions::Validation)
           end
         end
       end
@@ -478,7 +382,10 @@ describe Praxis::ResponseDefinition do
       if parts || parts_block
         parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block) 
       end
-      response.headers(headers) if headers
+
+      headers&.each do |(name, value)|
+        response.header(name, value)
+      end
     end
 
     context 'for a definition with a media type' do
@@ -520,8 +427,9 @@ describe Praxis::ResponseDefinition do
       its([:location]){ should == {value: location.inspect ,type: :regexp} }
 
       it 'should have a header defined with value and type keys' do
-        expect( output[:headers] ).to have(1).keys
+        expect( output[:headers] ).to have(2).keys
         expect( output[:headers]['Header1'] ).to eq({value: 'Value1' ,type: :string })
+        expect( output[:headers]['Location'] ).to eq({value: "/\\/my\\/url\\//" ,type: :regexp })        
       end
     end
 

data/tasks/thor/templates/generator/example_app/app/v1/concerns/href.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module V1
+  module Resources
+    module Concerns
+      module Href
+        extend ActiveSupport::Concern
+
+        # Base module where the href concern will grab constants from
+        included do
+          def self.base_module
+            ::V1
+          end
+        end
+
+        module ClassMethods
+          def endpoint_path_template
+            # memoize a templated path for an endpoint, like
+            # /im/contacts/%{id}
+            return @endpoint_path_template if @endpoint_path_template
+
+            path = self.base_module.const_get(:Endpoints).const_get(model.name.split(':').last.pluralize).canonical_path.route.path
+            @endpoint_path_template = path.names.inject(path.to_s) { |p, name| p.sub(':' + name, "%{#{name}}") }
+          end
+        end
+
+        def href
+          format(self.class.endpoint_path_template, id: id)
+        end
+      end
+    end
+  end
+end

data/tasks/thor/templates/generator/example_app/app/v1/resources/base.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative '../concerns/href'
+
 module V1
   module Resources
     class Base < Praxis::Mapper::Resource
+      include Resources::Concerns::Href
+
       # Base for all V1 resources.
       # Resources withing a single version should have resource mappings separate from other versions
       # and the Mapper::Resource will appropriately maintain different model_maps for each Base classes

data/tasks/thor/templates/generator/example_app/config/environment.rb

@@ -4,7 +4,7 @@ Praxis::Application.configure do |application|
   # Configure the Mapper plugin (if we want to use all the filtering/field_selection extensions)
   application.bootloader.use Praxis::Plugins::MapperPlugin
   # Configure the Pagination plugin (if we want to use all the pagination/ordering extensions)
-  application.bootloader.use Praxis::Plugins::PaginationPlugin, {
+  application.bootloader.use Praxis::Plugins::PaginationPlugin, **{
     # max_items: 500,  # Unlimited by default,
     # default_page_size: 100,
     # paging_default_mode: {by: :id},

data/tasks/thor/templates/generator/scaffold/implementation/resources/item.rb

@@ -18,7 +18,7 @@ module <%= version_module %>
       <%- if action_enabled?(:create) -%>
       def self.create(payload)
         # Assuming the API field names directly map the the model attributes. Massage if appropriate.
-        self.new(model.create(*payload.to_h))
+        self.new(model.create(**payload.to_h))
       end
       <%- end -%>
 
@@ -27,7 +27,7 @@ module <%= version_module %>
         record = model.find_by(id: id)
         return nil unless record
         # Assuming the API field names directly map the the model attributes. Massage if appropriate.
-        record.update(*payload.to_h)
+        record.update(**payload.to_h)
         self.new(record)
       end
       <%- end -%>

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.14
+  version: 2.0.pre.15
 platform: ruby
 authors:
 - Josep M. Blanquer
 - Dane Jensen
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-26 00:00:00.000000000 Z
+date: 2021-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -367,7 +367,7 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '4'
-description:
+description: 
 email:
 - blanquer@gmail.com
 - dane.jensen@gmail.com
@@ -647,6 +647,7 @@ files:
 - tasks/thor/templates/generator/example_app/Rakefile
 - tasks/thor/templates/generator/example_app/app/models/user.rb
 - tasks/thor/templates/generator/example_app/app/v1/concerns/controller_base.rb
+- tasks/thor/templates/generator/example_app/app/v1/concerns/href.rb
 - tasks/thor/templates/generator/example_app/app/v1/controllers/users.rb
 - tasks/thor/templates/generator/example_app/app/v1/resources/base.rb
 - tasks/thor/templates/generator/example_app/app/v1/resources/user.rb
@@ -671,7 +672,7 @@ homepage: https://github.com/praxis/praxis
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -687,7 +688,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Building APIs the way you want it.
 test_files: []