Cannot set "hidden" attributes at the record creation

[xdmx]

I have the following resouce:

class CommentResource < Api::V2::BaseResource
  attributes :body

  def self.creatable_fields(context)
    [:privacy, :body]
  end
end

The Comment table has a privacy column which I allow in the creatable_fields, but I don't return in the response. When I try to create a Comment I get no implicit conversion of nil into Hash as response. It seems that I cannot set attributes if they're not set in the attributes array, but I don't want some of them being returned, so it should be accepted since it's present in the creatable_fields array.

[barelyknown]

You need to set the context argument to {} by default.

def self.creatable_fields(context = {})
  [:privacy, :body]
end

[xdmx]

I've tried with both context={} and context=nil but it still returns that error

[lgebhardt]

I think the problem is you need the attribute declared in the resource. You should be able to then remove it from the fields with:

def self.fields
  super - [:privacy]
end

def updatable_fields(_context = nil)
  super - [:privacy]
end

def sortable_fields(_context = nil)
  super - [:privacy]
end

FYI I deleted my previous comment as I don't think it addressed the underlying issue.

[radar]

I am also seeing this issue with a resource defined as this:

module API
  module V2
    module Client
      class AdvertResource < JSONAPI::Resource
        attributes :title, :description, :code, :sale_price, :price, :sale_type, :published

        def self.createable_fields(context)
          [:check_isnew, :title, :price, :sale_price, 
           :description, :taxon_slug, :brand_slug, :features]
        end
      end
    end
  end
end

The check_isnew parameter is listed in creatable_fields, but is not listed in attributes. I think it should not show such a vague error message here.

[thewatts]

I'm having this same issue.

The use case is for a password and password_confirmation field.

I have a sample app setup here with specs: https://github.com/thewatts/testing-jsonapi-resources.

After some digging - it looks like things are blowing up here: https://github.com/cerebris/jsonapi-resources/blob/master/lib/jsonapi/resource.rb#L573

It looks like it's looping through the attributes and creating a hash by merging, but @_attributes doesn't actually have the keys from the defined .creatable_fields (which, when asking a hash for key that doesn't exist - returns nil, and this causes the no implicit conversion of nil into Hash through the attempt to merge nil into that attributes hash)

[thewatts]

@_attributes is defined by the attributes method on the Resource, example here.

Which, if I add both password and password_confirmation to the other attributes, the specs in the sample app pass (but this defeats the purpose of having creatable_fields.

I think ultimately - if creatable_fields are defined, they would then also have to be added to the @_attributes hash (or change how that check is happening).

( the @_attributes hash is built here)

[thewatts]

@lgebhardt --- I just now realized what you were saying -> so long as you define the field as an attribute, it'll work.

The clincher is that you have to specifically define what the public fields are via self.fields.

I was viewing the attributes: declaration as the method of defining the public fields for the resource.

In order to do what I'm needing, I'd have to create a resource as so:

class Api::UserResource < JSONAPI::Resource
  attributes :first, :last, :email, :password, :password_confirmation

  def self.fields
    super - [:password, :password_confirmation]
  end

  def self.creatable_fields(context)
    super - [:id]
  end
end

As opposed to my previous attempt (here)

Thanks!

[thewalkingtoast]

I just racked my head against this for an hour. We should add this to the README as an example. Thank you very much @thewatts. 👍

[iirving]

Question: is there a difference between using the self.fields method (used above) and fetchable_fields method (described in the README)? (doesn't seem to be...)

[elentras]

Hi, I didn't know this gem, but I have a proposition about this issue.

Why not using a class_attribute to store this hidden fields ? like following :

 # to define in class eval somewhere in JSONAPI::Resource class or ancestors
class_attribute :hidden_fields
self.hidden_fields ||= []

# with methods like following :
def self.has_hidden_fields(*fields) 
  self.hidden_fields = self.hidden_fields | fields
end

# and defining the `fields` method  :
def self.fields
  self.attributes - self.hidden_fields
end

Allowing this, in the definition of the resource classe :

class Api::UserResource < JSONAPI::Resource
  attributes :first, :last, :email, :password, :password_confirmation
  has_hidden_fields :password, :password_confirmation
end

[jsmestad]

@elentras this is a great function! thanks! 🎉

---

I did change it up a little bit to allow has_hidden_fields to also add the attribute definition.

  class_attribute :hidden_fields

  def self.has_hidden_fields(*fields)
    attributes(*fields)
    self.hidden_fields = [] | fields
  end

  def self.fields
    super - (hidden_fields || [])
  end

Taking the concept one step further, I used the same pattern for read-only attributes:

  class_attribute :read_only_fields

  def self.has_read_only_fields(*fields)
    attributes(*fields)
    self.read_only_fields = [] | fields
  end

  def self.creatable_fields(context)
    super - (read_only_fields || [])
  end

  def self.updatable_fields(context)
    super - (read_only_fields || [])
  end