Checks if an object should be accessible based on user roles

// Object with unrestricted access
check({ roles: { '*': true }, data: 'content' }, ['user']) // returns object

// Object with role restriction
check({ roles: { admin: true }, data: 'content' }, ['user']) // returns false
check({ roles: { admin: true }, data: 'content' }, ['admin']) // returns object

// Object with negated roles
check({ roles: { '!guest': true }, data: 'content' }, ['guest']) // returns false
check({ roles: { '!guest': true }, data: 'content' }, ['user']) // returns object

The check is also passed if the obj does not have a roles property.

Combines roles from a parent object into a child object. Handles two use cases:

1. Template role assignment (when parent has localeRole, templateRole, or objRole properties)
2. Simple parent-child role combination (for nested locales)

Combines roles for nested locales. Creates parent.child role combinations.

Combines roles for templates. This replicates the old roleAssign behavior.

Templates may have an access role restriction. The template.role string property requires a user to have that role in order to access the template.

The role string will be added as boolean:true property to the template.roles object property if the property key is undefined.

template.role = 'bar' -> template.roles = {'bar':true}

A dot notation role key will be created if the obj has a role string property.

obj.role = 'foo' && template.role = 'bar' -> template.roles = {'foo.bar':true}

Recursively merges role-specific object properties based on user roles. The function handles several special cases:

• Recursively processes nested objects
• Handles arrays by mapping over their elements
• Processes negated roles (prefixed with '!')
• Preserves the original object if conditions aren't met
• Skip null or undefined values

const obj = {
  name: 'layer',
  roles: {
    admin: { secretField: 'sensitive' },
    user: { publicField: 'visible' }
  }
};

// With admin role
objMerge(obj, ['admin']);
// Returns: { name: 'layer', secretField: 'sensitive', roles: {...} }

// With user role
objMerge(obj, ['user']);
// Returns: { name: 'layer', publicField: 'visible', roles: {...} }

The setInObj receives a set of roles and an object as params.

The method iterates through the object keys and will call itself for every object type property in the object param.

Any roles defined in the roles property of the object param will be added to the rolesSet param.

The method does not return anything but will modify the rolesSet param which is passed recursively.

Access roles defined as the role string property will also be added to the rolesSet.