Use config collections object to populate select field's options (circular dependency)

[revnelson]

Is there any way I can use a dynamic list of collections in to create a select field's options?

In my user collection, I want to have a field called editableCollections that I check against in my access functions. The idea being that we have an event coordinator that can edit the Events collection but not the Products collection, for example.

Here is what I have for the field so far:

{
name: "editableCollections",
type: "select",
hasMany: true,
options: collections.map((collection) => ({
	label: collection.label || startCase(collection.slug),
	value: collection.slug
})),
admin: {
	condition: (_, siblingData) => siblingData.roles.includes("editor")
    }
}

However, when I use the same collections object used in the payload config, the Users collection is included and I'm guessing there's a circular dependency issue because I get an error that isn't really an error:

export { default } from "./UsersCollection"
              ^
TypeError: Cannot read properties of undefined (reading 'default')

Is there some better way to get a list of all collections that doesn't need to be updated if a new collection is added?

[tsemachh]

We used plugin to handle that:
`import { hasAccessToAction } from '@/access/general'
import { Config, Plugin } from 'payload/config'
import { Access, ArrayField, CollectionConfig, Field, GlobalConfig } from 'payload/types'

const addAccess: Plugin = (incomingConfig: Config): Config => {
if (!incomingConfig || !incomingConfig.collections) {
throw new Error('Invalid incoming configuration or collections are missing')
}
const entities: {label:string, value:string}[] = [];
const createAccess = (slugName: string, labelName?:string) => {
const baseAccess: { read: Access; update: Access; } = {
read: hasAccessToAction(slugName, 'read'),
update: hasAccessToAction(slugName, 'write'),
};
const label = labelName?labelName:slugName.charAt(0).toUpperCase() + slugName.slice(1)
entities.push({label, value:slugName})
return baseAccess;
};
const createAccessCollection = (slugName: string, labelName?:string) => {
const baseAccess: { read: Access; update: Access; create?: Access; delete?: Access; } = createAccess(slugName, labelName)
const access = {
...baseAccess,
create: hasAccessToAction(slugName, 'write'),
delete: hasAccessToAction(slugName, 'write'),
};
return access;
};

const addEntityOptions= (obj:Field[]) =>{
const permissionIndex = 1//obj.findIndex((field: any) => field.name && field.name === 'permissions');
const premissionsObj = (obj[permissionIndex]as ArrayField)
const subPremissionsObj = (premissionsObj.fields[0] as ArrayField).fields
const entityIndex = 0; //subPremissionsObj.findIndex((field: any) => field?.name === 'entity');
(subPremissionsObj[entityIndex]as {options:{label:string, value:string}[] }).options = entities
return obj
}

let config: Config = {
...incomingConfig,
collections: incomingConfig.collections?.map((collection) => ({
...collection,
...(collection.slug !== 'users' && collection.slug !== 'roles' && {
access: collection.labels?createAccessCollection(collection.slug, String(collection.labels)):createAccessCollection(collection.slug),
}),
})) as CollectionConfig[],
globals: incomingConfig.globals?.map((global) => ({
...global,
access: global.label?createAccess(global.slug, String(global.label)):createAccess(global.slug),
})) as GlobalConfig[],
}

config = {
...config,
collections: incomingConfig.collections?.map((collection) => ({
...collection,
...(collection.slug == 'roles' && {
fields: addEntityOptions(collection.fields)
}),
})) as CollectionConfig[],
}
return config
}
export default addAccess
`
Where Roles are defined as:

`import type { CollectionConfig } from 'payload/types'
import { isAdmin, isAdminFieldLevel } from '../access/isAdmin'
import { isAdminOrSelf } from '../access/isAdminOrSelf'

export const Roles: CollectionConfig = {
slug: 'roles',
access: {
// Only admins can create users
create: isAdmin,
// Admins can read all, but any other logged in user can only read themselves
read: isAdminOrSelf,
// Admins can update all, but any other logged in user can only update themselves
update: isAdminOrSelf,
// Only admins can delete
delete: isAdmin,
},
admin: {
useAsTitle: 'name',
},
fields: [
{
name: 'name',
type: 'text',
unique: true,
},
{
name: 'permissions',
// Save this field to JWT so we can use from req.user
saveToJWT: true,
type: 'array',
access: {
// Only admins can create or update a value for this field
create: isAdminFieldLevel,
update: isAdminFieldLevel,
},
fields: [
{
type: 'row',
fields: [
{
name: 'entity',
label: 'Collection or Global',
type: 'select',
hasMany: true,
options: [ ],
required: true,
admin: {
width: '70%',
},
},
{
name: 'type',
label: 'Type',
type: 'select',
hasMany: true,
options: [
{
label: 'Write',
value: 'write',
},
{
label: 'Read',
value: 'read',
},
],
required: true,
admin: {
width: '30%',
},
},
],
},
],
},
],
}
`

[revnelson]

Would you mind sharing the hasAccessToAction util? Also, wouldn't the roles -> permissions -> entity array need to be populated in the same way of my code snippet above?

[tsemachh]

import { Access } from 'payload';
import { RolePermissions, User } from '@/payload-types'
import { Role } from '@/payload-types';

export const canUserAccessAction = (user: User | null | undefined, slugName: string, action: string) => {
  if (user) {
    if (user.isAdmin) return true;

    if (!user.userRoles || user.userRoles.length == 0) return false;

    const userRoles: Role[] = user.userRoles as Role[];
    // if (! userRoles[0].permissions) return false;
    const permissions: (RolePermissions | undefined) = userRoles[0].permissions
    if (!permissions) return false
    for (const permission of permissions)
      if (((permission.entity as string[]).includes(slugName)) && ((permission.type as string[]).includes(action))) return true;

  }
  return false
}

export const hasAccessToAction =
  (slugName: string, action: string): Access =>
    ({ req: { user } }) => {
      if (user && ('userRoles' in user || 'isAdmin' in user)) {
        const cmuser = user as unknown
        return canUserAccessAction(cmuser as User, slugName, action);
      }else{
        return false
      }
    }
    ```
    and the usage:
    ```
      const createAccess = (slugName: string, labelName?: string) => {
    const baseAccess: { read: Access; update: Access; } = {
      read: hasAccessToAction(slugName, 'read'),
      update: hasAccessToAction(slugName, 'write'),
    }
    const label = labelName ? labelName : slugName.charAt(0).toUpperCase() + slugName.slice(1)
    entities.push({ label, value: slugName })
    return baseAccess
  }
  //For Collections create and delete exists
  const createAccessCollection = (slugName: string, labelName?: string) => {
    const baseAccess: { read: Access; update: Access; create?: Access; delete?: Access; } = createAccess(slugName, labelName)
    const access = {
      ...baseAccess,
      create: hasAccessToAction(slugName, 'write'),
      delete: hasAccessToAction(slugName, 'write'),
    }
    return access
  }