Best way to do polymorphic or enumerated collection types?

sibergenomelast year

3

• 

  jesschow

  last year

  Hey @sibergenome, how about conditional logic?

  https://payloadcms.com/docs/fields/overview#conditional-logic
  
  

  You could have an Applications collection, a 'type' select field, then fields that get conditionally rendered based on that type, like this:

  
  
  

  export const Applications: CollectionConfig = {
    slug: 'applications',
    fields: [
      {
        name: 'type',
        type: 'select',
        options: [
          {
            label: 'Musician',
            value: 'musician',
          },
          {
            label: 'Volunteer',
            value: 'volunteer',
          },
          {
            label: 'Other',
            value: 'other',
          },
        ],
      },
      // all get this field
      {
        name: 'name',
        type: 'text',
        required: true,
      },
      // only musicians get this field
      {
        name: 'instrument',
        type: 'text',
        admin: {
          condition: (_, {type}) => type === 'musician',
        }
      },
      // only volunteers get this field
      {
        name: 'department',
        type: 'text',
        admin: {
          condition: (_, {type}) => type === 'volunteer',
        }
      }
    ],
  }

  
  
  

  If you're going to have a lot of fields, you could put them in different groups and then apply the condition at a group level.

• 

  zoul0813last year

  I use a series of functions - as the collections are just exported modules

  
  
  

  My common fields are all behind a single "baseFields()" call, so I just call

  
  
  

  fields: [baseFields(), {...}, {...}]

  
  
  

  This allows me to define common fields shared across multiple collections, in one place, and manage them from there.

  
  
  

  My collections generally have tabbed interfaces, with Content, Layout and Advanced tabs ... each having common fields within them, and then unique fields for that collection.

  
  
  

  All of my fields are functions, I rarely define a field as an object-literal inside the collection itself.

  
  
  

  fields: [
    baseFields(), // slug, and other common things
    labelField(), // row with text and select
    titleField(), // row with text and select
    contentField(), // richtext with specific definition
    contentField('customName', CUSTOM_ARGS), // richtext with custom name, and some overrides to which leafs/elements are accessible
    withCondition(labelField(), (data, siblingData) => { return siblingData.label.type == 'something'; }), // wrapper for admin: { condition: ... } }
  ]

• 

  sibergenomelast year

  Oh that's awesome, both are really good recommendations. I've noticed there's the recent form builder plugin, which could solve my problem, but having more complex field like hasMany relations seems like a bit of work.

  
  

  Seems a mix of both of your solutions will do the trick since they're both flexible and hide complexity.

  
  

  Thanks!