@01-edu/shared 1.0.2 → 1.0.4

package/attrs-defs.js

@@ -0,0 +1,3604 @@
+import {
+  DAY,
+  HOUR,
+  MIN,
+  WEEK,
+  getQuestExtraEndAt,
+  getQuestStartAt,
+  numTime,
+} from './event-utils.js'
+import { onboardingTypes } from './onboarding.js'
+import { getObjectFromRelativePath } from './path.js'
+import { supportedLang } from './programming-languages.js'
+import { gamesScoring } from './score.js'
+import { hasRequiredSkills, skillsSet } from './skill-definitions.js'
+import {
+  arrayOf,
+  breath,
+  formatedMS,
+  getChildByType,
+  isNotCamel,
+  mapValues,
+  toCamelCase,
+} from './toolbox.js'
+
+export const MAX_LEVEL = 128
+export const LEVELS = Array(MAX_LEVEL + 1)
+
+let i = -1
+let xpIndex = 0
+let cumul = 0
+while (++i < MAX_LEVEL + 1) {
+  const req = i * 0.66 + 1
+  const base = (i + 2) * 150 + 50
+  const total = Math.round(req * base)
+  cumul += total
+  xpIndex += req
+  LEVELS[i] = { level: i, base, cumul, total, xpIndex: Math.floor(xpIndex) }
+}
+
+const _children = obj => (obj?.children && Object.values(obj.children)) || []
+const find = (object, by, key) =>
+  object && (by(object) ? object : find(object[key], by, key))
+const findParent = (object, by) => find(object, by, 'parent')
+const findPrev = (object, by) => find(object, by, 'prev')
+const hasEvent = ({ event }) => event
+const isQuest = object => object.type === 'quest'
+const isRequired = object => object.attrs.category === 'required'
+const numOrOne = x => (typeof x === 'number' && !Number.isNaN(x) ? x : 1)
+const _difficultyXpCoef = o =>
+  o.attrs.difficulty * numOrOne(o.attrs.difficultyMod)
+const add = (a, b) => a + b
+const byValueIdx = ([ak, av], [bk, bv]) => av.index - bv.index
+
+const translate = (object, user, key) =>
+  object.attrs[`${key}-${user?.attrs?.language}`] ||
+  object.attrs[`${key}-en`] ||
+  key
+
+const firstOfGroup = (a, i, children) => {
+  const { group } = a.attrs
+  if (!group) return true
+  return children.find(b => b.attrs.group === group) === a
+}
+
+const getCoreName = object => {
+  const corePath = object.attrs.requirements?.core
+  const core = _children(object.parent).find(
+    child => child.id === getObjectFromRelativePath(corePath, object)?.id,
+  )
+  return core?.name || ''
+}
+
+const getObjectPath = object => {
+  const { attrs, name } = object
+  if (!attrs.requirements?.core) return name
+  // special case only for projects with a core requirement set
+  const coreName = getCoreName(object)
+  const path = `${coreName}/${getProjectName(object)}`
+  return path
+}
+
+// Generate default value from the first function and the map of fn.name -> fn
+const Functions = functions => ({
+  value: Object.values(functions)[0],
+  functions,
+  functionsByName: Object.fromEntries(
+    Object.values(functions).map(fn => [fn.name, fn]),
+  ),
+})
+
+const translatable = {
+  functions: { translate },
+  functionsByName: { translate },
+}
+
+// generate attribute type according to its value
+const Literal = (value, options) => ({
+  type: typeof value,
+  value,
+  ...options,
+})
+
+// used to generate default value for object
+const getDefaultValue = (typeDef, ...args) => {
+  if (!typeDef.required) return
+  return typeof typeDef.value === 'function'
+    ? typeDef.value(...args)
+    : typeDef.value
+}
+// generate default value of objects according to the type described
+const TypeObject = def => ({
+  value: (...args) =>
+    mapValues(def.type, subDef => getDefaultValue(subDef, ...args)),
+  ...def,
+})
+
+// ✱ how to declare a new attribute:
+// NB: by front end here, we mean the front end of the admin side of the app
+// attrs.myAttribute = {
+//  objectType: {
+//    type*: // string, number, boolean, etc. Complex types (objects, array) are described after
+//    value*: // defaultValue ONLY IF the attribute is required, or when it is added,
+//    functions: // if the attribute is associated to function(s) (if just one - it's this by default; if several, by default the user can choose in between them),
+//    label: // text displayed in front end, instead of attribute name (client friendly),
+//    instruction: // mention displayed under the label in the front end - to give precision that need to be seen,
+//    description: complete explanation of what the attributes does - description is displayed only when the used hover the ℹ️ icon in the front end,
+//    required: // if the attribute is always there by default,
+//    editable: // if it can be override by schools in the db (=/= choice in between several functions),
+//    private: // if the attribute should not be seen in front end,
+//    primary: // only used objects in arrays, allow to indicate what key must have a unique value
+//    options: // array containing literal possible values
+//    acceptDuplicates: // when array type can have duplicates
+//    maxElements: // when array has a maximum elements accepted (indicative - has to be handled in the code)
+//    check: // function to check if the value of the attribute is valid - used to check refs but also to validate value in the front end when saving
+//  },
+// }
+// * properties with the * are absolutely needed
+// By default, required, editable, and private are set to false
+// So it should be added only to set it to true
+
+// ✱ Literal(defaultValue, properties) use
+// Can be used to describe simple types. It will generate the type
+// of the attribute from defaultValue (added as value)
+// The argument defaultValue is the default value of the attribute
+// Example: Literal('available', { required: true, ...restOfProperties })
+// will add {type: 'string'} and {value: 'available'} to the properties
+
+// ✱ ...Functions({}) use
+// Describe the associated functions of the attribute
+// it generate the `value` (to use only if the default value is a function)
+// and a `functionsByName` property to find matching functions from DB
+// example: {...Functions({'friendly name of the function': myFunction})}
+
+// ✱ ...TypeObject({}) use
+// Can be use to describe the type of the attribute if it's a complicated object
+// it will generate the default `value`. It resolves values of each key,
+// only if the key is defined as required
+
+// ✱ array and object complex types
+// Complex types can be described directly in `type` property
+// instead of writing 'object' or 'array', the type can be defined in the {} or []
+// For arrays, each item of type object MUST have one of its property
+// tagged with a `primary` key, which value must be unique.
+// That helps the system identify each item when rendering them
+// If several object types of items are defined, then each one of them
+// also needs to have a `type` property of type string with a unique value
+
+// ✱ new option: types
+// It is used to define types inside complicated attributes. types are not attributes
+// but can be defined as attributes
+// example: if an attribute is an array of strings, it can be described like this:
+// types.myStringType = { type: 'string', ...restOfTypeProperties }
+// attrs.myArrayOfStrings = { type: [types.myStringType], ...restOfAttrProperties }
+
+// list of available attributes and function to validate them
+export const attrs = {}
+export const relationAttrs = {}
+// not exported because all types will be accessed from attributes
+export const types = {}
+
+// TODO: add a placeholder to default? propose an address
+// how can we propose an address?
+attrs.address = {
+  'contact-validation-step': Literal('', {
+    editable: true,
+    required: true,
+    label: 'Phone validation URL',
+  }),
+}
+
+types.allowedFunctions = {
+  value: '', // we cannot have an exhaustive list of the fn, as we can restrict from functions to regex
+  type: 'string',
+  editable: true,
+  label: 'Function',
+}
+// not required - we handle the undefined status in the code
+const sharedAllowedFunctions = {
+  type: [types.allowedFunctions],
+  value: [],
+  label: 'Allowed functions',
+  instruction: 'Functions authorized to the student',
+  editable: true,
+  restrictive: true, // could also be constraining or exclusive
+}
+// allowedFunctions unit: array of string
+attrs.allowedFunctions = {
+  exercise: sharedAllowedFunctions,
+  raid: sharedAllowedFunctions,
+}
+
+const autoValidateLabel = 'Automatic success'
+const autoValidateWhereLabel = `${autoValidateLabel} if`
+const autoRejectWhereLabel = `Automatic reject if`
+const sharedAutoValidationOperator = (action, autoValidationLabel) => ({
+  type: 'string',
+  restrictive: true,
+  label: `${action} - number of conditions to fulfil`,
+  ...Functions({ all: () => 'and', one: () => 'or' }),
+})
+attrs.autoRejectOperator = {
+  games: sharedAutoValidationOperator('Reject', autoRejectWhereLabel),
+}
+
+const games = Object.entries(gamesScoring)
+const gamesParameters = games.flatMap(([game, params]) => [
+  [
+    `${game}Score`,
+    {
+      shouldFailUnder: params.shouldFailUnderScore,
+      shouldSucceedFrom: params.shouldSucceedFromScore,
+    },
+  ],
+  [
+    `${game}Level`,
+    {
+      shouldFailUnder: params.shouldFailUnderLevel,
+      shouldSucceedFrom: params.shouldSucceedFromLevel,
+    },
+  ],
+])
+const allParameters = [
+  ['score', { shouldFailUnder: 25, shouldSucceedFrom: 50 }],
+  ['level', { shouldFailUnder: 10, shouldSucceedFrom: 25 }],
+  ...gamesParameters,
+]
+const allParametersStr = allParameters
+  .map(([parameter, _]) => breath(parameter))
+  .join(', ')
+  .slice(0, -2)
+
+// TODO: mv to a attrs-utils file
+const isntObjectOrIsEmpty = elem =>
+  Array.isArray(elem) || typeof elem !== 'object' || !Object.keys(elem).length
+const checkNotEmpty = (value, _, key) => {
+  if (!value.length) {
+    const err = Error('Must be a non empty value')
+    err.label = key
+    throw err
+  }
+}
+const checkNumberInBetween = (value, min, max) => {
+  if (value < min || value > max) {
+    throw Error(`Expected to be a number range ${min} to ${max}`)
+  }
+}
+const checkIntegerInBetween = (value, min, max) => {
+  if (value < min || value > max || !Number.isInteger(value)) {
+    throw Error(`Expected to be an integer range ${min} to ${max}`)
+  }
+}
+const checkDurationInBetween = (value, min, max) => {
+  if (value < min || value > max) {
+    throw Error(
+      `Expected to be a duration between ${formatedMS(min)} and ${formatedMS(
+        max,
+      )}`,
+    )
+  }
+}
+const checkTextLength = (str, length) => {
+  if (str.length > length) {
+    throw Error(`Max ${length} characters (spaces included).`)
+  }
+}
+const checkValidURL = value => {
+  try {
+    return Boolean(new URL(value))
+  } catch (err) {
+    throw Error('Invalid URL.')
+  }
+}
+const sharedComparisonIntegerTypes = {
+  editable: true,
+  options: arrayOf(100, 1),
+  check: limit => checkIntegerInBetween(limit, 1, 100),
+}
+// none of these conditions are required
+types.autoRejectWhereConditions = Object.fromEntries(
+  allParameters.map(([parameter, { shouldFailUnder }]) => [
+    parameter,
+    {
+      value: {},
+      editable: true,
+      description: `Condition relative to ${breath(
+        parameter,
+      )} of the candidate.`,
+      check: condition => {
+        if (isntObjectOrIsEmpty(condition)) {
+          throw Error('expect to contain a comparison.')
+        }
+      },
+      type: {
+        '<': Literal(shouldFailUnder, {
+          label: 'is lower than',
+          description: 'Under this number, condition is fulfilled.',
+          ...sharedComparisonIntegerTypes,
+        }),
+        '<=': Literal(shouldFailUnder, {
+          label: 'is lower than or equal',
+          description: 'Until this number, condition is fulfilled.',
+          ...sharedComparisonIntegerTypes,
+        }),
+      },
+    },
+  ]),
+)
+attrs.autoRejectWhere = {
+  games: {
+    value: {},
+    editable: true,
+    restrictive: true,
+    label: autoRejectWhereLabel,
+    instruction: 'List of conditions to automatically reject an application',
+    type: types.autoRejectWhereConditions,
+    check: autoRejectWhere => {
+      if (isntObjectOrIsEmpty(autoRejectWhere)) {
+        throw Error('expect to contain at least one condition.')
+      }
+    },
+  },
+}
+
+attrs.autoValidate = {
+  administration: Literal(false, {
+    label: autoValidateLabel,
+    instruction: 'Validate all applications when they are submitted',
+    restrictive: true,
+    editable: true,
+  }),
+}
+
+attrs.autoValidateOperator = {
+  games: sharedAutoValidationOperator('Success', autoValidateWhereLabel),
+}
+
+// none of these conditions are required
+types.autoValidateWhereConditions = Object.fromEntries(
+  allParameters.map(([parameter, { shouldSucceedFrom }]) => [
+    parameter,
+    {
+      value: {},
+      editable: true,
+      description: `Condition relative to ${breath(
+        parameter,
+      )} of the candidate.`,
+      check: condition => {
+        if (isntObjectOrIsEmpty(condition)) {
+          throw Error('expect to contain at least one condition.')
+        }
+      },
+      type: {
+        '>': Literal(shouldSucceedFrom, {
+          label: 'is bigger than',
+          description: 'Above this number, condition is fulfilled.',
+          ...sharedComparisonIntegerTypes,
+        }),
+        '>=': Literal(shouldSucceedFrom, {
+          label: 'is bigger than or equal',
+          description: 'From this number, condition is fulfilled.',
+          ...sharedComparisonIntegerTypes,
+        }),
+      },
+    },
+  ]),
+)
+attrs.autoValidateWhere = {
+  games: {
+    value: {},
+    editable: true,
+    restrictive: true,
+    label: autoValidateWhereLabel,
+    instruction: 'List of conditions to automatically accept an application',
+    type: types.autoValidateWhereConditions,
+    check: autoValidateWhere => {
+      if (isntObjectOrIsEmpty(autoValidateWhere)) {
+        throw Error('expect to contain at least one condition.')
+      }
+    },
+  },
+}
+
+const skillsList = {
+  value: {},
+  editable: true,
+  label: 'Skills',
+  type: mapValues(skillsSet, ({ name, type: instruction, description }) => ({
+    label: name,
+    instruction,
+    description,
+    editable: true,
+    type: 'number',
+    value: 1,
+    options: arrayOf(100, 1),
+    check: amount => checkIntegerInBetween(amount, 1, 100),
+  })),
+}
+const sharedBasedSkills = {
+  ...skillsList,
+  instruction: 'Expertise(s) that this content is worth.',
+}
+relationAttrs.baseSkills = {
+  // only if result associated directly to the object
+  exam: { exercise: sharedBasedSkills },
+  quest: { exercise: sharedBasedSkills },
+  module: { piscine: sharedBasedSkills, project: sharedBasedSkills },
+  campus: { piscine: sharedBasedSkills },
+  piscine: { raid: sharedBasedSkills, project: sharedBasedSkills },
+}
+
+const getBaseXpByLevelAndDifficulty = object => {
+  if (Object.keys(object.children || {}).length && object.type !== 'raid') {
+    return 0 // rm type 'raid' condition after clean alem db
+  }
+  const level = LEVELS[object.attrs.level] || LEVELS[0]
+  return Math.round(level.base * numOrOne(_difficultyXpCoef(object)))
+}
+const sharedBaseXp = {
+  type: 'number',
+  required: true,
+  // TODO: we should not manually set base-xp but play with level and difficulty attribute
+  // then this attribute should not be editable
+  editable: true,
+  label: 'XP',
+  instruction: 'Expertise(s) that this content is worth.',
+  ...Functions({ 'by level and difficulty': getBaseXpByLevelAndDifficulty }),
+  check: amount => {
+    if (!Number.isInteger(amount)) throw Error('Must be a whole number')
+    if (amount < 0) throw Error('Must not be negative')
+  },
+}
+relationAttrs.baseXp = {
+  // only if result associated directly to the object
+  exam: { exercise: sharedBaseXp },
+  quest: { exercise: sharedBaseXp },
+  module: { piscine: sharedBaseXp, project: sharedBaseXp },
+  piscine: { raid: sharedBaseXp, project: sharedBaseXp },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  campus: { piscine: sharedBaseXp },
+}
+
+attrs.blockStartDelay = {
+  exam: Literal(15 * MIN, {
+    label: 'Time to join the exam',
+    editable: true,
+  }),
+}
+
+const sharedButtonText = Literal('Save', {
+  label: 'Submit button text',
+  editable: true,
+  ...translatable,
+})
+attrs.buttonText = {
+  'sign-step': sharedButtonText,
+  'form-step': sharedButtonText,
+}
+
+// const getGamesObjectsAndCampaigns = graphql(`
+//   query toad_campaign_ids($id: Int!) {
+//     object(
+//       where: {
+//         _and: [
+//           { attrs: { _has_key: "campaignId" } }
+//           { _not: { id: { _eq: $id } } }
+//         ]
+//       }
+//     ) { attrs }
+//     toad_campaigns { id }
+//   }
+// `)
+attrs.campaignId = {
+  games: Literal('', {
+    label: 'Games campaign related',
+    instruction: 'Id required',
+    required: true,
+    editable: true,
+    restrictive: true,
+    // TODO: check if we use the check here to add some security on the campaignId
+    // but we would need to do some query (which is not something we planned to do)
+    // check: (value, { id }) => {
+    // // get all toad campaigns + all campaignIds used in campus
+    // const { object, toad_campaigns } = await getGamesObjectsAndCampaigns({
+    //   id,
+    // })
+    // // compare with toad_campaigns and check if it's one of them
+    // if (!toad_campaigns.some(({ id }) => id === value)) {
+    //   throw Error('Campaign not found.')
+    // }
+    // // compare with campaignIds already used and check it's not used in another object
+    // if (object.map(({ attrs }) => attrs.campaignId).includes(value)) {
+    //   throw Error('Must be unique')
+    // }
+    // },
+  }),
+}
+
+const getCampus = object => object.path.split('/')[1]
+const sharedCampus = {
+  label: 'Campus',
+  type: 'string',
+  required: true,
+  private: true,
+  ...Functions({ 'from campus name': getCampus }),
+}
+attrs.campus = {
+  exercise: sharedCampus,
+  module: sharedCampus,
+  piscine: sharedCampus,
+  project: sharedCampus,
+  raid: sharedCampus,
+  exam: sharedCampus,
+  quest: sharedCampus,
+  ...Object.fromEntries([...onboardingTypes].map(type => [type, sharedCampus])),
+}
+
+const sharedCapacity = Literal(400, {
+  label: 'Event capacity',
+  instruction: 'From 1 to 1000.',
+  editable: true,
+  required: true,
+  check: amount => {
+    if (!Number.isInteger(amount)) throw Error('Must be a whole number')
+    if (amount > 1000) throw Error('Cannot be more than 1000.')
+    if (amount < 1) throw Error('Must be one or more')
+  },
+})
+attrs.capacity = {
+  exam: sharedCapacity,
+  module: sharedCapacity,
+  piscine: sharedCapacity,
+  raid: sharedCapacity,
+  interview: sharedCapacity,
+}
+
+const exerciseCategories = new Set(['required', 'optional', 'bonus'])
+const projectCategories = new Set(['synchronous', 'enrichment', 'asynchronous'])
+// to check: should we set dynamically the enrichment project category relying
+// on the fact that the object has a valid core project set in its requirements?
+// if so, in the admin interface we have to enforce to select a core project for the enrichment category to be applied
+const projectCategory = Literal('synchronous', {
+  label: 'Category of the project',
+  required: true,
+  options: ['synchronous', 'asynchronous', 'enrichment'],
+  check: value => {
+    if (!projectCategories.has(value)) {
+      throw Error('Must be "synchronous", "asynchronous" or "enrichment"')
+    }
+  },
+})
+relationAttrs.category = {
+  // exercises in exams need the category for expected xp calculation
+  exam: {
+    exercise: Literal('required', {
+      label: 'Category of the exercise',
+      required: true,
+      private: true,
+      check: value => {
+        const exerciseCategoriesInExam = new Set(['required', 'optional'])
+        if (!exerciseCategoriesInExam.has(value)) {
+          throw Error('Must be "required" or "optional"')
+        }
+      },
+    }),
+  },
+  quest: {
+    exercise: Literal('required', {
+      label: 'Category of the exercise',
+      required: true,
+      editable: true,
+      options: ['required', 'optional', 'bonus'],
+      check: value => {
+        if (!exerciseCategories.has(value)) {
+          throw Error('Must be "required", "optional" or "bonus"')
+        }
+      },
+    }),
+  },
+  module: { project: { ...projectCategory, editable: true } },
+  piscine: {
+    project: { ...projectCategory, private: true },
+    raid: Literal('required', { required: true, private: true }),
+  },
+}
+
+// checkbox is not required - sign step can be used without, just to display a text
+// for example: a text to ask if a user authorize to share personal info to partners
+attrs.checkbox = {
+  'sign-step': {
+    label: 'Display a checkbox',
+    instruction: 'Minimum options: "label" and "required"',
+    value: {},
+    editable: true,
+    type: 'object',
+    check: value => {
+      if (!value.label || typeof value.label !== 'string') {
+        throw Error(
+          '"label" must be defined as a text to be displayed on the right of the checkbox.',
+        )
+      }
+      // NB: required has to be defined, even if false
+      // (to help admins not forget to put it if it is mandatory)
+      if (typeof value.required !== 'boolean') {
+        throw Error(
+          '"required" must be defined as true or false (if the checkbox is mandatory or not).',
+        )
+      }
+    },
+    ...translatable,
+  },
+}
+
+types.codeEditorFile = TypeObject({
+  label: 'File',
+  editable: true,
+  type: {
+    giteaPath: Literal('root/public/README.md', {
+      label: 'Gitea file path',
+      instruction: 'Example: "{user}/{repo}/{path-to-file}"',
+      editable: true,
+      check: value => {
+        checkTextLength(value, 200)
+        checkNotEmpty(value)
+      },
+    }),
+    editorPath: Literal('provided/README.md', {
+      label: 'Path in Code editor',
+      required: true,
+      editable: true,
+      check: value => {
+        checkTextLength(value, 200)
+        checkNotEmpty(value)
+      },
+    }),
+  },
+})
+
+types.providedFiles = {
+  editable: true,
+  label: 'Provided files',
+  type: [types.codeEditorFile],
+}
+types.enableCodeEditor = (enabled, options) => {
+  return Literal(enabled, {
+    editable: true,
+    required: true,
+    label: 'Enable',
+    ...options,
+  })
+}
+
+const sharedCodeEditor = {
+  label: 'Code editor settings',
+  editable: true,
+  // code editor will not be available for shell exercises
+  // shell exercises need to commit files that are not supported, for example ".tar"
+  check: (_, { attrs }) => {
+    if (attrs.language === 'sh') {
+      throw Error('The code editor does not support shell exercises')
+    }
+  },
+  type: {
+    // If checked, will enable the code editor in the platform for the exercise.
+    enabled: types.enableCodeEditor(false),
+    providedFiles: types.providedFiles,
+  },
+}
+
+relationAttrs.codeEditor = {
+  quest: {
+    exercise: TypeObject({ ...sharedCodeEditor }),
+  },
+  exam: {
+    exercise: TypeObject({
+      ...sharedCodeEditor,
+      required: true,
+      type: {
+        enabled: types.enableCodeEditor(true, { editable: false }),
+        providedFiles: types.providedFiles,
+      },
+    }),
+  },
+}
+
+const checkCRMvalues = value => {
+  const reg = /^[^a-z](\d+)|[^a-z0-9_]/g
+  const i = value.search(reg)
+  if (i !== -1) {
+    const wrongCharacter = value[i]
+    const suggestion = value.normalize('NFD').toLowerCase().replace(reg, '')
+    const suffix = suggestion ? `Did you mean ${suggestion}?` : ''
+    throw Error(
+      `Property names should start with a letter, only contain lowercase letters, numbers, and underscores (${i}:"${wrongCharacter}"). ${suffix}`,
+    )
+  }
+}
+
+const ENABLE_CRM = process.env.ENABLE_CRM
+const CRM_NAME = process.env.CRM_NAME
+const CRM_ENDPOINT = process.env.CRM_ENDPOINT
+const CRM_PRIVATE_KEY = process.env.CRM_PRIVATE_KEY
+
+// types.crmOnRegistration = Literal('event_registration', {
+//   editable: true,
+//   check: value => {
+//     checkNotEmpty(value)
+//     checkCRMvalues(value)
+//   },
+//   label: 'Notify on registration',
+// })
+
+types.crmOnValidation = Literal('event_status', {
+  editable: true,
+  label: 'Validation status',
+
+  check: value => {
+    checkNotEmpty(value)
+    checkCRMvalues(value)
+  },
+})
+
+const sharedCRM = TypeObject({
+  label: 'Customer Relationship Management (CRM)',
+  editable: true,
+  restrictive: true,
+  private: !(
+    ENABLE_CRM &&
+    JSON.parse(ENABLE_CRM) &&
+    CRM_NAME &&
+    CRM_ENDPOINT &&
+    CRM_PRIVATE_KEY
+  ),
+  type: {
+    // TODO : add type for registration process "onRegistration"
+    // onRegistration: types.crmOnRegistration,
+    onValidation: types.crmOnValidation,
+  },
+})
+
+types.crmGamesOnAttempts = Literal('number_of_attempts_remaining', {
+  label: 'Remaining attempts',
+  editable: true,
+
+  check: value => {
+    checkNotEmpty(value)
+    checkCRMvalues(value)
+  },
+})
+
+// RootEvents
+types.crmOnProgress = Literal('last_progress', {
+  label: 'Currently in progress',
+  editable: true,
+
+  check: value => {
+    checkNotEmpty(value)
+    checkCRMvalues(value)
+  },
+})
+
+types.gamesCRM = {
+  // how many attempts remain
+  onAttempts: types.crmGamesOnAttempts,
+}
+
+types.crmDueDate = Literal('audit_due_date', {
+  label: 'Due date',
+  editable: true,
+
+  check: value => {
+    checkNotEmpty(value)
+    checkCRMvalues(value)
+  },
+})
+
+const crmRootEvents = {
+  ...sharedCRM,
+  type: { ...sharedCRM.type, onProgress: types.crmOnProgress },
+}
+
+attrs.crm = {
+  games: {
+    ...sharedCRM,
+    type: { ...types.gamesCRM, onValidation: sharedCRM.type.onValidation },
+  },
+  interview: sharedCRM,
+  piscine: crmRootEvents,
+  module: crmRootEvents,
+  exam: sharedCRM,
+  raid: sharedCRM,
+  project: {
+    ...sharedCRM,
+    type: { dueDate: types.crmDueDate },
+  },
+}
+
+const getDelay = ({ type, parent, index, attrs }) => {
+  if (parent && type === 'exercise' && attrs.special) {
+    // duration is expressed in days
+    const prevExercisesDuration = Object.values(parent.children)
+      .filter(ex => ex.index < index)
+      .map(({ attrs }) => attrs.duration)
+      .reduce(add, 0)
+    // now return in millisecond
+    return prevExercisesDuration * DAY
+  }
+  return attrs.startDay ? (attrs.startDay - 1) * DAY : 0
+}
+const sharedDelay = {
+  type: 'number',
+  required: true,
+  private: true,
+}
+relationAttrs.delay = {
+  piscine: {
+    quest: {
+      ...sharedDelay,
+      label: 'Time before the quest starts',
+      // NB: 'startDay' should be rename if one day it becomes a public attribute
+      ...Functions({ 'based on previous content temporal-windows': getDelay }),
+    },
+    // needed for project to calculate hasStarted, and then status
+    // TODO: figure out how tron is handled
+    project: {
+      ...sharedDelay,
+      label: 'Time before the project starts',
+      ...Functions({ 'based on previous content temporal-windows': getDelay }),
+    },
+  },
+  // for the hackathon
+  quest: {
+    exercise: {
+      ...sharedDelay,
+      label: 'Time before the exercise starts',
+      ...Functions({
+        'based on previous exercises temporal-windows': getDelay,
+      }),
+    },
+  },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  exam: {
+    exercise: {
+      ...sharedDelay,
+      label: 'Time before the exercise starts',
+      ...Functions({
+        'based on previous exercises temporal-windows': getDelay,
+      }),
+    },
+  },
+  module: { project: Literal(0, sharedDelay) },
+}
+
+const exerciseDifficulty = ({ attrs, prev }) => {
+  if (attrs.parentType !== 'exam') return 1
+  if (attrs.group) return Math.round(attrs.group * 2)
+  return Math.round(((prev?.attrs.group || 0) + 1) * 2)
+}
+
+const sumOfChildrenDifficulty = object =>
+  _children(object)
+    .filter(firstOfGroup)
+    .filter(isRequired)
+    .map(_difficultyXpCoef)
+    .reduce(add, 0)
+
+// TODO: update with level - still in progress
+const sharedDifficulty = Literal(1, {
+  required: true,
+  label: 'Difficulty',
+  // options: [0.75, 1, 1.25, 1.5, 1.75, 2], // TODO: uncomment when content had fixed the difficulties
+  instruction: 'From 0.75 to 2 (in increments of 0.25)',
+  // TODO: uncomment when refs are fixed
+  // check: value => checkNumberInBetween(value, 0.75, 2),
+})
+const privateDifficulty = {
+  ...sharedDifficulty,
+  private: true,
+  ...Functions({
+    'Sum of required children exercises difficulties': sumOfChildrenDifficulty,
+  }),
+}
+relationAttrs.difficulty = {
+  module: {
+    project: { ...sharedDifficulty, editable: true },
+    exam: privateDifficulty,
+  },
+  piscine: {
+    project: { ...sharedDifficulty, editable: true },
+    raid: { ...sharedDifficulty, editable: true },
+    exam: privateDifficulty,
+    quest: privateDifficulty,
+  },
+  quest: { exercise: Literal(1, { ...sharedDifficulty, editable: true }) },
+  exam: {
+    exercise: {
+      ...sharedDifficulty,
+      editable: true,
+      editableDefaultValue: 1,
+      ...Functions({ 'Based on exercise group or 1': exerciseDifficulty }),
+    },
+  },
+}
+
+// TODO: rename this attribute by 'xpCoefficient' for example
+// but it is in db so it would need to do a migration
+const getDifficultyMod = ({ parent }) => parent?.attrs.difficultyMod
+const sharedDifficultyMod = Literal(1, {
+  label: 'XP Coefficient',
+  required: true,
+  editable: true,
+  editableDefaultValue: 1,
+  ...Functions({ 'from parent': getDifficultyMod }),
+  check: value => checkNumberInBetween(value, 0, 64),
+})
+relationAttrs.difficultyMod = {
+  campus: { piscine: sharedDifficultyMod }, // ??
+  module: {
+    project: sharedDifficultyMod,
+    piscine: sharedDifficultyMod,
+    exam: sharedDifficultyMod, // ??
+  },
+  piscine: {
+    raid: sharedDifficultyMod,
+    exam: sharedDifficultyMod,
+    quest: sharedDifficultyMod,
+    project: sharedDifficultyMod,
+  },
+  quest: { exercise: sharedDifficultyMod },
+  exam: { exercise: sharedDifficultyMod },
+}
+
+const getName = ({ name }) => name
+const getProjectName = object => {
+  const { name, attrs } = object
+  if (!attrs.requirements?.core) return name
+  // only for projects with a core requirement set, and which name starts by the core name:
+  // remove the core name from the name to avoid repetition
+  const coreName = getCoreName(object)
+  return name.startsWith(coreName) ? name.slice(coreName.length + 1) : name
+}
+const sharedDisplayedName = Literal('', {
+  editable: true,
+  label: 'Displayed name',
+  check: title => checkTextLength(title, 60),
+})
+// TODO: mv onboarding name attribute to displayedName
+attrs.displayedName = {
+  raid: {
+    ...sharedDisplayedName,
+    ...Functions({ 'from name': getName }),
+  },
+  project: {
+    ...sharedDisplayedName,
+    ...Functions({ 'from name (or light version)': getProjectName }),
+    required: true,
+  },
+  // TODO: maybe rm it here and simply use name
+  piscine: sharedDisplayedName,
+  exercise: sharedDisplayedName,
+  quest: sharedDisplayedName, // not required
+}
+
+const isHackathon = object => object.attrs.special
+const getExerciseDuration = ({ parent, attrs }) =>
+  isHackathon(parent)
+    ? parent.attrs.duration / Object.keys(parent.children).length
+    : 0
+const oneDayDuration = () => 1
+const twoDaysDuration = () => 2
+const sharedDuration = Literal(1, {
+  label: 'Temporal-window duration in the event',
+  required: true,
+  editable: true,
+  check: duration => checkDurationInBetween(duration * DAY, 0, 50 * DAY), // TODO: maybe max should be another int
+  editableDefaultValue: 1,
+  ...Functions({ 'one day': oneDayDuration }),
+})
+// duration unit: positive integer
+relationAttrs.duration = {
+  // TODO: rm, here just for campus comparison
+  module: {
+    exam: sharedDuration,
+  },
+  piscine: {
+    quest: sharedDuration,
+    // exam and raid duration are used to calculate start day of the next quests
+    // it is useful only for the temporal-window - it has no impact on their scope/start/end
+    exam: sharedDuration, // used anyway to calculate the temporal-window - 1 by default
+    raid: {
+      ...sharedDuration,
+      ...Functions({ 'two days': twoDaysDuration }),
+    }, // used anyway to calculate the temporal-window - override of 2 in db
+    project: sharedDuration,
+  },
+  quest: {
+    exercise: {
+      ...sharedDuration,
+      ...Functions({
+        // TODO: maybe find a better fn name (too long) -
+        // 'handled if special' could work but is not descriptive
+        'proportional to the others (in hackathon mode)': getExerciseDuration,
+      }),
+    },
+  },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  exam: {
+    exercise: {
+      ...sharedDuration,
+      ...Functions({
+        // TODO: maybe find a better fn name (too long) -
+        // 'handled if special' could work but is not descriptive
+        'proportional to the others (in hackathon mode)': getExerciseDuration,
+      }),
+    },
+  },
+}
+
+const sharedEventDuration = {
+  label: 'Event duration',
+  required: true,
+  editable: true,
+  check: duration =>
+    checkDurationInBetween(duration * MIN, 1 * MIN, 365 * DAY * 3), // 1min to 3 years (+1 extra day)
+}
+attrs.eventDuration = {
+  exam: Literal((4 * HOUR) / MIN, sharedEventDuration),
+  module: Literal((365 * DAY * 2) / MIN, sharedEventDuration),
+  interview: Literal((DAY * 1) / MIN, sharedEventDuration),
+  piscine: Literal((4 * WEEK) / MIN, sharedEventDuration),
+  raid: Literal((DAY * 2) / MIN, sharedEventDuration),
+}
+
+const getParentEventId = ({ parent }) => parent?.attrs.eventId
+const getEventId = ({ event }) => event?.id
+const sharedEventId = {
+  type: 'number',
+  label: 'Event id',
+  required: true,
+  private: true,
+  ...Functions({ 'own event': getEventId }),
+}
+const parentEventId = {
+  ...sharedEventId,
+  ...Functions({ 'parent event': getParentEventId }),
+}
+// eventId unit: positive integer
+relationAttrs.eventId = {
+  campus: { module: sharedEventId, piscine: sharedEventId },
+  piscine: {
+    quest: parentEventId,
+    project: parentEventId,
+    exam: sharedEventId,
+    raid: sharedEventId,
+  },
+  quest: { exercise: parentEventId },
+  exam: { exercise: parentEventId },
+  module: {
+    piscine: sharedEventId,
+    project: parentEventId,
+    exam: sharedEventId,
+  },
+}
+
+const sharedEventStartDelay = Literal(0, {
+  label: 'Time between registration and event',
+  editable: true,
+})
+attrs.eventStartDelay = {
+  exam: sharedEventStartDelay,
+  module: sharedEventStartDelay,
+  interview: sharedEventStartDelay,
+  piscine: sharedEventStartDelay,
+  raid: sharedEventStartDelay,
+}
+
+// TODO: add a fake name by default or rm check not empty
+// because when the value is added in front end, it saves the default value,
+// which is '' but the save is blocked by check
+// or create a state in array type
+types.filesName = Literal('', {
+  label: 'Expected file name',
+  instruction: 'Examples: "main.go", or "exerciseName/main.go"',
+  editable: true,
+  check: value => {
+    // checkNotEmpty(value)
+    checkTextLength(value, 65)
+    // TODO: check that there is a .extension
+  },
+})
+const sharedExpectedFiles = {
+  type: [types.filesName],
+  value: [],
+  editable: true,
+  restrictive: true,
+  label: 'Expected files',
+  check: checkNotEmpty,
+}
+// expectedFiles unit: array of strings
+attrs.expectedFiles = {
+  exercise: sharedExpectedFiles,
+  raid: sharedExpectedFiles,
+}
+
+const totalRequiredXp = (acc, c) => acc + (isRequired(c) ? c.attrs.baseXp : 0)
+const getRequiredExpectedXp = object =>
+  _children(object).filter(firstOfGroup).reduce(totalRequiredXp, 0)
+const totalExpectedXp = (acc, c) => acc + (c.attrs.expectedXp || 0)
+const getTotalExpectedXp = object =>
+  _children(object).reduce(totalExpectedXp, 0)
+const sharedExpectedXp = {
+  type: 'number',
+  label: 'XP',
+  instruction: 'Expertise(s) that this content is worth.',
+  required: true,
+  check: amount => {
+    if (!Number.isInteger(amount)) throw Error('Must be a whole number')
+    if (amount < 0) throw Error('Must not be negative')
+  },
+}
+// expectedXp unit: integer
+attrs.expectedXp = {
+  piscine: {
+    ...sharedExpectedXp,
+    private: true,
+    label: 'XP (for stats)', // expected from quests and exams & for module
+    ...Functions({ 'Sum of children expected XP': getTotalExpectedXp }),
+  }, // used in event service and for stats
+  module: {
+    ...sharedExpectedXp,
+    ...Functions({ 'Sum of children expected XP': getTotalExpectedXp }),
+  }, // TODO: check if really used??
+  quest: {
+    ...sharedExpectedXp,
+    ...Functions({ 'Sum of required children XP': getRequiredExpectedXp }),
+  },
+  exam: {
+    ...sharedExpectedXp,
+    ...Functions({ 'Sum of required children XP': getRequiredExpectedXp }),
+  },
+}
+
+const primaryKeyDef = Literal('', {
+  primary: true,
+  editable: true,
+  required: true,
+})
+
+const inputKeyAndRequiredProps = {
+  key: {
+    ...primaryKeyDef,
+    label: 'Key (must be unique)',
+    instruction: 'Associated keyword in the database and data exports',
+    check: (value, object) => {
+      checkNotEmpty(value.trim())
+
+      const isNotFormatted = isNotCamel(value)
+      if (isNotFormatted) {
+        const camelKey = toCamelCase(value)
+        throw Error(`Must be written in camelCase. Suggestion: "${camelKey}"`)
+      }
+
+      // TODO: as key is defined like `primary`, this check should be done
+      // by check-refs/object service/expand attrs (to be confirmed)
+      const sameInputKeys = (
+        object.attrs['form-en'] ||
+        object.attrs.form ||
+        // TODO: rm when add object is fixed with required attrs saved in db
+        []
+      )
+        .flatMap(section => section.inputs.map(input => input.key))
+        .filter(inputKey => inputKey === value)
+      if (sameInputKeys?.length > 1) {
+        throw Error(
+          `${value} is already used for another input. Please choose a unique key.`,
+        )
+      }
+    },
+  },
+  required: Literal(true, { label: 'Must be fulfilled', editable: true }),
+}
+
+// few flags in generatedFlags from ../design/createCssClass.js
+const generatedFlags = new Set(['w100p', 'w18p'])
+const keyStyleAndRequiredProps = {
+  ...inputKeyAndRequiredProps,
+  styleProps: TypeObject({
+    // TODO: change to array, and define instruction for each selected available design flags
+    label: 'Input style',
+    type: {
+      w100p: Literal(false, {
+        label: 'Large input style',
+        editable: true,
+      }),
+      w18p: Literal(false, {
+        label: 'Small input style',
+        editable: true,
+      }),
+    },
+    editable: true,
+    check: value => {
+      const invalidProp = Object.keys(value).find(
+        prop => !generatedFlags.has(prop),
+      )
+      if (invalidProp) throw Error(`${invalidProp} is not a valid css property`)
+    },
+  }),
+}
+const nameAndIdProps = {
+  name: Literal('', {
+    label: 'Input HTML name',
+    editable: true,
+    check: checkNotEmpty,
+  }),
+  id: Literal('', {
+    label: 'Input HTML id',
+    editable: true,
+    check: checkNotEmpty,
+  }), // id could be key by default?
+}
+const labelAndPLaceholder = (defaultLabel, defaultPlaceholder) => ({
+  placeholder: Literal(defaultPlaceholder || 'Your answer...', {
+    label: 'Placeholder',
+    editable: true,
+  }),
+  label: Literal(defaultLabel || '', {
+    label: 'Label / title',
+    instruction: 'Displayed on top of the input',
+    editable: true,
+    // TODO: add this!!
+    // required: true
+  }),
+})
+const sharedTextProps = {
+  ...labelAndPLaceholder(),
+  ...nameAndIdProps,
+  minLength: Literal(1, { label: 'Minimum length', editable: true }),
+  maxLength: Literal(60, { label: 'Maximum length', editable: true }),
+}
+
+types.textInput = TypeObject({
+  label: 'Text input',
+  type: {
+    type: Literal('text', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps,
+    ...sharedTextProps,
+    size: Literal(20, { label: 'Size', editable: true }),
+  },
+})
+types.textareaInput = TypeObject({
+  label: 'Textarea input',
+  type: {
+    type: Literal('textarea', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps,
+    ...sharedTextProps,
+    rows: Literal(5, { label: 'Rows', editable: true }),
+    cols: Literal(20, { label: 'Columns', editable: true }),
+  },
+})
+
+types.telInputPattern = Literal(`/^\\s?\\+?[0-9 ()_-]+$/`, {
+  label: 'Pattern to match',
+  instruction:
+    "Regular expression (in javascript) that the input's value must match.",
+  editable: true,
+})
+
+types.telInput = TypeObject({
+  label: 'Tel input',
+  type: {
+    type: Literal('tel', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps,
+    ...nameAndIdProps,
+    ...labelAndPLaceholder('Telephone number', '+333 33 33 33 33'),
+    pattern: types.telInputPattern,
+    format: Literal('Format: +7 777 123 00 00', {
+      label: 'Format to respect',
+      editable: true,
+    }),
+  },
+})
+types.checkboxInput = TypeObject({
+  label: 'Checkbox input',
+  type: {
+    type: Literal('checkbox', { label: 'Input type', required: true }), // private: true?
+    ...inputKeyAndRequiredProps,
+    ...nameAndIdProps,
+    label: Literal('I agree', {
+      label: 'Text associated to the checkbox',
+      instruction: 'Displayed on the right of the checkbox',
+      editable: true,
+      required: true,
+      check: checkNotEmpty,
+    }),
+    value: Literal(false, {
+      label: 'Is initially checked',
+      editable: true,
+      required: true,
+    }),
+    // TODO: add items??
+  },
+})
+
+types.switchInput = TypeObject({
+  label: 'Switch input',
+  type: {
+    type: Literal('switch', { label: 'Input type', required: true }), // private: true?
+    ...inputKeyAndRequiredProps,
+    ...nameAndIdProps,
+    label: Literal('I choose...', {
+      label: 'Text associated to the switch input',
+      instruction: 'Displayed on the left of the checkbox',
+      editable: true,
+      required: true,
+      check: checkNotEmpty,
+    }),
+    value: Literal(false, {
+      label: 'Is initially set to true',
+      editable: true,
+      required: true,
+    }),
+  },
+})
+
+types.numberInputsSteps = Literal(10, {
+  label: 'Step value up and down by',
+  editable: true,
+})
+
+types.numberInput = TypeObject({
+  label: 'Number input',
+  type: {
+    type: Literal('number', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps,
+    ...nameAndIdProps,
+    ...labelAndPLaceholder('How many/much...', 'Multiple of...'),
+    min: Literal(1, { label: 'Minimum', editable: true }),
+    max: Literal(100, { label: 'Maximum', editable: true }),
+    step: types.numberInputsSteps,
+  },
+})
+
+types.dateInput = TypeObject({
+  label: 'Date input',
+  type: {
+    type: Literal('date', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps,
+    ...nameAndIdProps,
+    ...labelAndPLaceholder('Date', '2000-01-01'),
+    value: Literal('2000-01-01', {
+      label: 'Default date value',
+      editable: true,
+    }),
+    min: Literal('2000-01-01', {
+      label: 'Lowest date allowed',
+      editable: true,
+    }),
+    max: Literal('2000-01-01', {
+      label: 'Highest date allowed',
+      editable: true,
+    }),
+  },
+})
+types.datetimeLocalInput = TypeObject({
+  label: 'Date with time input',
+  type: {
+    type: Literal('datetime-local', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps,
+    ...nameAndIdProps,
+    ...labelAndPLaceholder('Date and time', '2000-01-01T00:00'),
+    value: Literal('2000-01-01T00:00', {
+      label: 'Default date and time value',
+      editable: true,
+    }),
+    min: Literal('2000-01-01T00:00', {
+      label: 'Lowest date and time allowed',
+      editable: true,
+    }),
+    max: Literal('2000-01-01T00:00', {
+      label: 'Highest date and time allowed',
+      editable: true,
+    }),
+  },
+})
+
+types.countriesInput = TypeObject({
+  label: 'Countries input',
+  type: {
+    type: Literal('countries', { label: 'Input type', required: true }), // private: true?
+    ...inputKeyAndRequiredProps,
+    ...nameAndIdProps,
+    label: Literal('Country', {
+      label: 'Label / title',
+      instruction: 'Displayed on top of the input',
+      editable: true,
+      // required: true,
+    }),
+    emptyItem: TypeObject({
+      label: 'Empty selection text',
+      editable: true,
+      instruction: 'Displayed as a placeholder before selection',
+      type: {
+        label: Literal('Choose your country...', {
+          label: 'Label',
+          editable: true,
+        }),
+      },
+    }),
+  },
+})
+types.languagesInput = TypeObject({
+  label: 'Languages input',
+  type: {
+    type: Literal('languages', { label: 'Input type', required: true }), // private: true?
+    ...inputKeyAndRequiredProps,
+    ...nameAndIdProps,
+    label: Literal('Language', {
+      label: 'Label / title',
+      instruction: 'Displayed on top of the input',
+      editable: true,
+      // required: true,
+    }),
+    emptyItem: TypeObject({
+      label: 'Empty selection text',
+      editable: true,
+      instruction: 'Displayed as a placeholder before selection',
+      type: {
+        label: Literal('Choose your language...', {
+          label: 'Label',
+          editable: true,
+        }),
+      },
+    }),
+  },
+})
+
+// TODO: handle input type file? until now, handled by upload step
+// accept, capture, and multiple properties to add
+// types.fileInput = TypeObject({})
+
+// radio must have data property
+types.radioItems = TypeObject({
+  label: 'Radio item',
+  type: {
+    label: Literal('', {
+      label: 'Label (text displayed)',
+      editable: true,
+    }),
+    data: Literal('', {
+      label: 'Data (value saved in database)',
+      editable: true,
+      required: true,
+      primary: true,
+      check: checkNotEmpty, // TODO: rm?
+    }),
+  },
+})
+types.radioInput = TypeObject({
+  label: 'Radio input',
+  type: {
+    type: Literal('radio', { label: 'Input type', required: true }), // private: true?
+    ...inputKeyAndRequiredProps,
+    ...nameAndIdProps,
+    label: Literal('Select one...', {
+      label: 'Label / title',
+      instruction: 'Displayed on top of the input',
+      editable: true,
+      required: true,
+    }),
+    inlineBlock: Literal(true, {
+      label: 'Displays options under the label',
+      instruction: 'If set to false, options are right to the label',
+      editable: true,
+    }),
+    items: {
+      value: [],
+      type: [types.radioItems],
+      label: 'Items',
+      required: true,
+      editable: true,
+    },
+  },
+})
+
+// select must have label property
+types.selectItems = TypeObject({
+  label: 'Select item',
+  type: {
+    label: Literal('', {
+      label: 'Label',
+      instruction: 'Text displayed and saved in database', // rm?
+      editable: true,
+      required: true,
+      primary: true,
+      check: checkNotEmpty, // TODO: rm?
+    }),
+    data: Literal('', { label: 'Data', editable: true }),
+  },
+})
+types.selectInput = TypeObject({
+  label: 'Select input',
+  type: {
+    type: Literal('select', { label: 'Input type', required: true }), // private: true?
+    ...keyStyleAndRequiredProps, // style???
+    ...nameAndIdProps,
+    label: Literal('Select one...', {
+      label: 'Label / title',
+      instruction: 'Displayed on top of the input',
+      editable: true,
+      // required: true, // TODO: add this?
+    }),
+    searchable: Literal(true, {
+      label: 'Searchable',
+      instruction: 'Allow search, and sort the input options',
+      editable: true,
+    }),
+    emptyItem: TypeObject({
+      label: 'Empty selection text',
+      editable: true,
+      instruction: 'Displayed as a placeholder before selection',
+      type: {
+        label: Literal('Choose...', {
+          label: 'Label',
+          editable: true,
+        }),
+      },
+    }),
+    items: {
+      type: [types.selectItems],
+      value: [],
+      label: 'Items',
+      required: true,
+      editable: true,
+    },
+  },
+})
+
+types.formSectionResume = Literal('', {
+  label: 'Resume',
+  editable: true,
+})
+
+types.formSection = TypeObject({
+  type: {
+    key: {
+      ...primaryKeyDef,
+      label: 'Section id',
+      instruction: 'Private info (for admins)',
+      check: (value, object) => {
+        checkNotEmpty(value.trim())
+        const isNotFormatted = isNotCamel(value)
+        if (isNotFormatted) {
+          const camelKey = toCamelCase(value)
+          throw Error(`Must be written in camelCase. Suggestion: "${camelKey}"`)
+        }
+
+        // TODO: as key is defined like `primary`, this check should be done
+        // by check-refs/object service/expand attrs
+        const sameSectionKeys = (
+          object.attrs['form-en'] ||
+          object.attrs.form ||
+          // TODO: rm when add object is fixed with required attrs saved in db
+          []
+        )
+          .map(section => section.key)
+          .filter(sectionKey => sectionKey === value)
+        if (sameSectionKeys?.length > 1) {
+          throw Error(
+            `${value} is already used for another section. Please choose a unique key.`,
+          )
+        }
+      },
+    },
+    title: Literal('', { label: 'Section title', editable: true }),
+    resume: types.formSectionResume,
+    inputs: {
+      label: 'Inputs',
+      instruction: 'Questions or instruction to answer to',
+      required: true,
+      editable: true,
+      // check: checkNotEmpty, // TODO: add modal to force putting first item?
+      value: [],
+      // TODO: handle one or any in the arrays
+      type: [
+        types.textInput,
+        types.textareaInput,
+        types.telInput,
+        types.checkboxInput,
+        types.switchInput,
+        types.dateInput,
+        types.datetimeLocalInput,
+        types.numberInput,
+        // types.fileInput, - supposed to be in upload step, not form
+        types.countriesInput,
+        types.languagesInput,
+        types.radioInput,
+        types.selectInput,
+      ],
+    },
+  },
+})
+
+attrs.form = {
+  'form-step': {
+    label: 'Form to fill',
+    required: true,
+    editable: true,
+    value: [{ key: 'firstSection', inputs: [] }],
+    type: [types.formSection],
+    ...translatable,
+  },
+}
+
+const questGrade = object => {
+  if (!object.children) return
+  const children = _children(object)
+  const requiredCount = children.filter(isRequired).length
+  const count = children.filter(
+    child => child.attrs.status === 'succeeded',
+  ).length
+
+  return count && count / requiredCount
+}
+attrs.grade = {
+  quest: Literal(0, {
+    required: true,
+    private: true,
+    label: 'Quest grade',
+    ...Functions({ 'succeeded exercises / required': questGrade }),
+  }),
+}
+
+types.moduleGraphViews = {
+  type: 'string',
+  options: ['Circular', 'Linear'],
+  editable: true,
+  value: '',
+}
+attrs.graphView = {
+  module: {
+    value: [],
+    editable: true,
+    label: 'Graph views',
+    type: [types.moduleGraphViews],
+    check: value => {
+      if (value.length === 0) throw Error('Must contain at least one view')
+      if (new Set(value).size !== value.length)
+        throw Error('Should not contain duplicates')
+    },
+  },
+}
+
+// about to be refactored to define group base on exercise level?
+relationAttrs.group = {
+  exam: {
+    exercise: Literal(1, {
+      label: 'Exercise group',
+      editable: true,
+      options: arrayOf(100, 1),
+      check: value => checkIntegerInBetween(value, 1, 100),
+    }),
+  },
+}
+
+const getGroupId = ({ group }) => group?.id
+const sharedGroupId = {
+  label: 'Group id of the user',
+  type: 'number',
+  required: true,
+  private: true,
+  ...Functions({ 'last confirmed group for this project': getGroupId }),
+}
+attrs.groupId = {
+  project: sharedGroupId,
+  raid: sharedGroupId,
+}
+
+attrs.groupMax = {
+  project: Literal(1, {
+    label: 'Max. group number',
+    required: true,
+    editable: true,
+    options: arrayOf(20, 1),
+    check: (number, object) => {
+      checkIntegerInBetween(number, 1, 20) // TODO: validate the max allowed
+      if (object.attrs.groupMin > number) {
+        throw Error('Must be bigger or equal to "Min. group number"')
+      }
+    },
+  }),
+}
+
+attrs.groupMin = {
+  project: Literal(1, {
+    label: 'Min. group number',
+    required: true,
+    editable: true,
+    options: arrayOf(20, 1),
+    check: (number, object) => {
+      checkIntegerInBetween(number, 1, 20) // TODO: validate the max allowed
+      if (object.attrs.groupMax < number) {
+        throw Error('Must be smaller or equal to "Max. group number"')
+      }
+    },
+  }),
+}
+
+// TODO: write a doc on the group system? not sure it's needed
+attrs.groupSize = {
+  raid: Literal(3, {
+    label: 'Average group size',
+    required: true,
+    editable: true,
+    // put literal value first, as in admin front end the first value of options
+    // is considered as default value. This is for dynamic options to be handled
+    options: [3, 1, 2, ...arrayOf(17, 4)],
+    check: number => checkIntegerInBetween(number, 1, 20), // TODO: validate the max allowed
+  }),
+}
+
+const getHasStarted = ({ attrs }) => Date.now() > attrs.start
+const always = () => true
+const never = () => false
+const sharedPrivateHasStarted = {
+  type: 'boolean',
+  required: true,
+  private: true,
+  ...Functions({ 'from beginning of event': getHasStarted }),
+}
+const sharedPublicHasStared = {
+  label: 'Starts when',
+  type: 'boolean',
+  required: true,
+  ...Functions({
+    'temporal-window has started (in hackathon mode)': getHasStarted,
+    'always started': always,
+    'never starts': never,
+  }),
+}
+// NB: it's a boolean but it is more understandable if it's described as a moment
+// to do so, we just add 2 fn: always and never instead of add editable: true
+relationAttrs.hasStarted = {
+  campus: { module: sharedPrivateHasStarted, piscine: sharedPrivateHasStarted },
+  module: {
+    piscine: sharedPrivateHasStarted,
+    exam: sharedPrivateHasStarted,
+    // TODO: rm this for project? it is now at true as soon as the module started
+    // (except for tron)
+    // depends if we want to keep the option of using the temporal-window
+    // then if we define a delay for projects, start and hasStarted would change
+    // NB: this attribute is actually used right now to define inScope attr for projects
+    project: sharedPublicHasStared,
+  },
+  piscine: {
+    exam: sharedPrivateHasStarted,
+    raid: sharedPrivateHasStarted,
+    quest: sharedPublicHasStared,
+    project: sharedPublicHasStared,
+  },
+  quest: {
+    exercise: sharedPublicHasStared,
+  },
+  exam: {
+    exercise: sharedPublicHasStared,
+  },
+}
+
+// TODO: rm? used only in the Calendar (that is not used anymore)
+// and only for mention of `Group 1,2 or 3` for raids...
+attrs.info = {
+  raid: Literal('Group 1', {
+    editable: true,
+    label: 'Calendar information tag',
+    check: value => checkTextLength(value, 50),
+  }),
+}
+
+const sharedInput = {
+  label: 'Upload input',
+  required: true,
+  editable: true,
+  type: 'object',
+  value: {},
+  ...translatable,
+  instruction: 'Required option: "type"',
+}
+attrs.input = {
+  'upload-step': {
+    ...sharedInput,
+    check: value => {
+      const [inputValues] = Object.values(value)
+      isntObjectOrIsEmpty(inputValues)
+      if (!inputValues.type || inputValues.type !== 'file') {
+        throw Error(
+          '"type":"file" property must be defined in the upload input.',
+        )
+      }
+      if (
+        inputValues.accept !== undefined &&
+        typeof inputValues.accept !== 'string'
+      ) {
+        throw Error(
+          '"accept" property (if added) must be a text. Example: "image/png, image/jpeg"',
+        )
+      }
+      if (
+        inputValues.required !== undefined &&
+        typeof inputValues.required !== 'boolean'
+      ) {
+        throw Error('"required" property (if added) must be a true or false.')
+      }
+    },
+  },
+  'contact-validation-step': {
+    ...sharedInput,
+    check: value => {
+      const [inputValues] = Object.values(value)
+      isntObjectOrIsEmpty(inputValues)
+      if (!inputValues.type || inputValues.type !== 'tel') {
+        throw Error(
+          '"type":"tel" property must be defined in the contact validation input.',
+        )
+      }
+      if (
+        inputValues.required !== undefined &&
+        typeof inputValues.required !== 'boolean'
+      ) {
+        throw Error('"required" property (if added) must be a true or false.')
+      }
+      if (
+        inputValues.label !== undefined &&
+        typeof inputValues.label !== 'string'
+      ) {
+        throw Error(
+          '"label" property (if added) must be a text. Example: "Phone contact"',
+        )
+      }
+      if (
+        inputValues.placeholder !== undefined &&
+        typeof inputValues.placeholder !== 'string'
+      ) {
+        throw Error(
+          '"placeholder" property (if added) must be a text. Example: "+333 33 33 33 33"',
+        )
+      }
+      if (
+        inputValues.format !== undefined &&
+        typeof inputValues.format !== 'string'
+      ) {
+        throw Error(
+          '"format" property (if added) must be a text. Example: "Required format: +33 7 17 17 17 17"',
+        )
+      }
+      if (inputValues.pattern !== undefined) {
+        if (typeof inputValues.pattern !== 'string') {
+          throw Error(
+            '"pattern" property (if added) must be a text and a valid regex. Example: "[+][0-9]{3}[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{2}"',
+          )
+        }
+        try {
+          return new RegExp(value)
+        } catch (err) {
+          throw Error('Invalid Regular expression.')
+        }
+      }
+    },
+  },
+}
+
+const getInScope = ({ attrs }) => {
+  const now = Date.now()
+  return now > attrs.scopeStart && now < attrs.scopeEnd
+}
+const getProjectInScope = ({ attrs }) => attrs.hasStarted
+const getExamExerciseInScope = ({ parent }) => parent.attrs.inScope
+const getExerciseInScope = ({ parent, attrs, index }) => {
+  if (parent.attrs.inScope) {
+    if (isHackathon(parent)) {
+      const now = Date.now()
+      return now > attrs.start && now < attrs.duration * DAY + attrs.start
+    }
+    return true
+  }
+  // when is it that bonus is always inScope? should be open if prev ex are done no?
+  return parent.attrs.hasStarted && attrs.category === 'bonus'
+}
+// this should never be editable!
+const sharedInScope = {
+  label: 'Reward scope',
+  required: true,
+  type: 'boolean',
+}
+const eventInScope = {
+  ...sharedInScope,
+  private: true,
+  label: 'Active scope (distinct from temporal-window)',
+  ...Functions({ 'from start date to end date': getInScope }), // TODO: check it is not an issue for raids - reward after end of event
+}
+// NB: it's a boolean but it is more understandable if it's described as a duration
+// if we decide it is editable one day, we should just add 2 fn: always and never
+// instead of add editable: true
+// 'always open': () => true,
+// 'never open': () => false,
+relationAttrs.inScope = {
+  // TODO: should it be defined for modules items also?
+  piscine: {
+    quest: {
+      ...sharedInScope,
+      label: 'Reward scope (temporal-window with extra duration)',
+      instruction:
+        'Defines whether the content keeps giving the rewards or not.',
+      ...Functions({ 'from start day to end of extra duration': getInScope }),
+    },
+    raid: eventInScope,
+    exam: eventInScope,
+    project: {
+      ...sharedInScope,
+      ...Functions({ 'parent temporal-window': getProjectInScope }),
+    },
+  },
+  // TODO: find a way to make it clear for hackathon exercise scope
+  quest: {
+    exercise: {
+      ...sharedInScope,
+      ...Functions({
+        'parent temporal-window (or one by one in hackathon)':
+          getExerciseInScope,
+      }),
+      instruction:
+        'Defines whether the content keeps giving the rewards or not.',
+    },
+  },
+  // needed?
+  exam: {
+    exercise: {
+      ...sharedInScope,
+      private: true,
+      ...Functions({ 'parent scope': getExamExerciseInScope }),
+    },
+  },
+  module: {
+    project: {
+      ...sharedInScope,
+      ...Functions({ 'parent scope': getProjectInScope }),
+    },
+    exam: eventInScope,
+  },
+}
+
+const sharedLanguage = Literal('', {
+  label: 'Programming language',
+  instruction: 'Example: "js", "go", "rust"',
+  editable: true,
+  restrictive: true,
+})
+attrs.language = {
+  exam: sharedLanguage,
+  exercise: sharedLanguage,
+  raid: sharedLanguage,
+  project: sharedLanguage,
+}
+
+const getLevel = ({ parent, attrs }) => {
+  if (parent && parent.type === 'exam') return parent.attrs.level
+
+  const totalScore = attrs.difficulty + attrs.xpIndex
+  const match = LEVELS.find(lvl => lvl.xpIndex > totalScore)
+  return match ? match.level : 0
+}
+const sharedLevel = Literal(1, {
+  label: 'Level',
+  required: true,
+  editable: true,
+  editableDefaultValue: 1,
+  ...Functions({ 'minimum required': getLevel }),
+  options: arrayOf(MAX_LEVEL, 1),
+  check: value => checkIntegerInBetween(value, 1, MAX_LEVEL),
+})
+relationAttrs.level = {
+  module: { piscine: sharedLevel, exam: sharedLevel, project: sharedLevel },
+  piscine: {
+    quest: sharedLevel,
+    raid: sharedLevel,
+    exam: sharedLevel,
+    project: sharedLevel,
+  },
+  quest: { exercise: sharedLevel },
+  exam: { exercise: sharedLevel },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  campus: { piscine: sharedLevel },
+}
+
+types.objectChildRelativePath = Literal('./', {
+  label: 'Content relative path',
+  instruction: 'As a child of this content',
+  editable: true,
+  check: getObjectFromRelativePath,
+  options: object =>
+    Object.entries(object.children || {})
+      .sort(byValueIdx)
+      .map(([key, _]) => `./${key}`),
+})
+
+types.objectRootRelativePath = Literal('../', {
+  label: 'Content relative path',
+  instruction: 'In same parent',
+  editable: true,
+  check: getObjectFromRelativePath,
+  options: object => {
+    if (!object?.parent?.children) return []
+    const sorted = Object.entries(object.parent.children).sort(byValueIdx)
+    const index = sorted.findIndex(([k, v]) => k === object.key)
+    if (index < 1) return sorted.map(([key, _]) => `../${key}`)
+    const before = sorted.slice(0, index)
+    // TODO: add a filter on category and let possibility to select the async after?
+    // const after = sorted.slice(index + 1)
+    // .filter(([k, v]) => v.attrs?.category === 'asynchronous')
+    // return [...before, ...after].map(([key, _]) => `../${key}`)
+    return before.map(([key, _]) => `../${key}`).reverse()
+  },
+})
+types.sharedObjectList = {
+  label: 'Contents', // synonyms: item, material
+  editable: true,
+  check: objects => {
+    if (!Array.isArray(objects) || !objects.length) {
+      throw Error('Must be a non empty array')
+    }
+    const uniques = [...new Set(objects)]
+    if (objects.length !== uniques.length) {
+      throw Error('Duplicates are not allowed.')
+    }
+  },
+}
+
+const sharedRequirements = { editable: true, label: 'Access conditions' }
+
+const contentRequirements = {
+  ...sharedRequirements,
+  instruction: 'Conditions to access this content',
+  description:
+    'Sets the requirements that have to be met for a content to be accessible to a student.',
+  check: (requirements, object) => {
+    const { skills, objects, core, ...rest } = requirements
+    if (Object.keys(rest).length) {
+      throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
+    }
+    if (!skills && !objects && !core) {
+      throw Error('Empty requirements, should be removed')
+    }
+  },
+}
+
+const levelRequirements = {
+  ...sharedRequirements,
+  instruction: 'Conditions to unlock and earn this level',
+  description:
+    'Sets the requirements that have to be met for a level to be unlocked and earned by a student.',
+  check: (requirements, object) => {
+    const { skills, objects, ...rest } = requirements
+    if (Object.keys(rest).length) {
+      throw Error(`Unsupported attribute "${Object.keys(rest)[0]}"`)
+    }
+    if (!skills && !objects) {
+      throw Error('Empty requirements, should be removed')
+    }
+  },
+}
+
+types.levelDefinition = TypeObject({
+  label: 'Level definition',
+  type: {
+    level: Literal(MAX_LEVEL, {
+      label: 'Level',
+      editable: true,
+      required: true,
+      primary: true,
+      // to put max level first in options - could also be [MAX_LEVEL, ...arrayOf(MAX_LEVEL -1, 1)]
+      options: arrayOf(MAX_LEVEL, 1).reverse(),
+      check: (level, object) => {
+        checkIntegerInBetween(level, 1, MAX_LEVEL)
+
+        const definitionsWithSameLevel = object.attrs.levelsDefinitions.filter(
+          levelDefinition => levelDefinition.level === level,
+        )
+        if (definitionsWithSameLevel?.length > 1) {
+          throw Error(
+            `Level ${level} is set for different levels definitions! A given level can only be defined once.`,
+          )
+        }
+      },
+    }),
+    requirements: TypeObject({
+      ...levelRequirements,
+      type: {
+        skills: {
+          ...skillsList,
+          instruction: 'Expertises required',
+        },
+        objects: {
+          ...types.sharedObjectList,
+          value: (...args) => {
+            const option = types.objectChildRelativePath.options(...args)?.[0]
+            return option ? [option] : []
+          },
+          type: [types.objectChildRelativePath],
+          instruction: 'Items to be succeeded',
+        },
+      },
+      required: true,
+      instruction: 'Conditions to access this level',
+    }),
+  },
+})
+const sharedLevelsDefinitions = {
+  label: 'Levels definitions',
+  instruction: 'List of levels access conditions',
+  value: (...args) => [
+    mapValues(types.levelDefinition.type, subDef =>
+      getDefaultValue(subDef, ...args),
+    ),
+  ],
+  editable: true,
+  restrictive: true,
+  type: [types.levelDefinition],
+  check: levelsDefinitions => {
+    if (!levelsDefinitions?.length || !Array.isArray(levelsDefinitions)) {
+      throw Error('Must be a non empty array')
+    }
+  },
+}
+attrs.levelsDefinitions = {
+  module: sharedLevelsDefinitions,
+  // TODO: solve bug on piscine: required objects that already started
+  // (quests, exams, etc.) always have the status as `succeeded`
+  // in the reward service when getting the object with `getObject`
+  // piscine: sharedLevelsDefinitions,
+}
+
+// TODO: define the type when html attributes handled/our css handled
+// as all other attributes wanted for the link can be added (e.g. target="_blank")
+attrs.link = {
+  'sign-step': TypeObject({
+    label: 'Associated link to the document',
+    editable: true,
+    type: {
+      href: Literal('', {
+        required: true,
+        editable: true,
+        label: 'URL',
+        instruction: 'Href HTML attribute',
+        check: value => {
+          if (value.length) {
+            checkValidURL(value)
+          }
+        },
+      }),
+      label: Literal('> Link to the document', {
+        editable: true,
+        label: 'Label / text displayed',
+      }),
+      target: Literal('_blank', {
+        label: 'Target HTML attribute',
+        instruction: 'Open the link in a new browser tab',
+      }),
+    },
+    ...translatable, // in case there are different versions of the doc to dl
+  }),
+}
+
+// TODO: should be required for exam exercises.
+// But it is about to be refactored to define group base on exercise level?
+const maxGroupReducer = (t, c) => Math.max(c.attrs.group || 1, t) // added '|| 1' as group is not required and could be undefined
+const getMaxExamGroup = object => _children(object).reduce(maxGroupReducer, 1)
+attrs.maxGroup = {
+  exam: {
+    type: 'number',
+    label: 'Max exercise group',
+    private: true, // interesting only in a context of an event
+    required: true,
+    ...Functions({ 'biggest exercise group of the exam': getMaxExamGroup }),
+  },
+}
+
+// TODO: mv handling of name in displayedName attribute
+const sharedName = Literal('', {
+  label: 'Name',
+  editable: true,
+  ...translatable,
+})
+const attrsNameObj = {}
+for (const type of onboardingTypes) {
+  attrsNameObj[type] = sharedName
+}
+attrs.name = {
+  signup: sharedName,
+  ...attrsNameObj,
+}
+
+const getParentType = ({ parent }) => parent?.type
+const sharedParentType = {
+  type: 'string',
+  private: true,
+  required: true,
+  label: 'Upper content type',
+  ...Functions({ 'from parent': getParentType }),
+}
+// TODO: define the one we need to keep?
+relationAttrs.parentType = {
+  campus: {
+    // module: sharedParentType,
+    piscine: sharedParentType,
+  },
+  module: {
+    piscine: sharedParentType,
+    exam: sharedParentType,
+    project: sharedParentType,
+  },
+  piscine: {
+    quest: sharedParentType,
+    exam: sharedParentType,
+    raid: sharedParentType,
+    project: sharedParentType,
+  },
+  quest: { exercise: sharedParentType },
+  exam: { exercise: sharedParentType },
+}
+
+types.rankDefinitionName = Literal('', {
+  label: 'Name',
+  editable: true,
+  required: true,
+  primary: true,
+  check: (name, object) => {
+    // checkNotEmpty(name): have to be commented or it's impossible
+    // to add a new rank to the ranks definition, as default value is ''
+    // and check is done before add
+    const definitionsWithSameName = object.attrs.ranksDefinitions.filter(
+      rankDefinition => rankDefinition.name === name,
+    )
+    if (definitionsWithSameName?.length > 1) {
+      throw Error(
+        `Name "${name}" is already set for a rank definition! A given name can only be attributed once to a rank.`,
+      )
+    }
+  },
+})
+
+types.rankDefinition = TypeObject({
+  label: 'Rank definition',
+  type: {
+    name: types.rankDefinitionName,
+    level: Literal(MAX_LEVEL, {
+      label: 'Level required',
+      editable: true,
+      required: true,
+      // to put max level first in options - could also be [MAX_LEVEL, ...arrayOf(MAX_LEVEL -1, 0)]
+      options: arrayOf(MAX_LEVEL, 0).reverse(),
+      check: (level, object) => {
+        checkIntegerInBetween(level, 0, MAX_LEVEL)
+
+        const definitionsWithSameLevel = object.attrs.ranksDefinitions.filter(
+          rankDefinition => rankDefinition.level === level,
+        )
+        if (definitionsWithSameLevel?.length > 1) {
+          throw Error(
+            `Level ${level} is already set for a rank definition! A given level can only be attributed once to a rank.`,
+          )
+        }
+      },
+    }),
+    milestone: Literal('', {
+      label: 'Milestone description',
+      editable: true,
+    }),
+  },
+})
+const sharedRanksDefinitions = {
+  label: 'Ranks definitions',
+  instruction: 'List of ranks access conditions',
+  editable: true,
+  restrictive: true,
+  value: (...args) => [
+    mapValues(types.rankDefinition.type, subDef =>
+      getDefaultValue(subDef, ...args),
+    ),
+  ],
+  type: [types.rankDefinition],
+  check: ranksDefinitions => {
+    if (!ranksDefinitions?.length || !Array.isArray(ranksDefinitions)) {
+      throw Error('Must be a non empty array')
+    }
+  },
+}
+attrs.ranksDefinitions = {
+  module: sharedRanksDefinitions,
+  piscine: sharedRanksDefinitions,
+}
+
+const sharedRegistrationDuration = {
+  label: 'Registration duration (to an event)',
+  required: true,
+  editable: true,
+  check: duration => checkDurationInBetween(duration * MIN, 1 * MIN, 365 * DAY), // 1 min to 1 years (+1 extra day)
+}
+attrs.registrationDuration = {
+  exam: Literal((1.5 * DAY) / MIN, sharedRegistrationDuration),
+  module: Literal((30 * DAY) / MIN, sharedRegistrationDuration),
+  interview: Literal((2 * WEEK) / MIN, sharedRegistrationDuration),
+  piscine: Literal((30 * DAY) / MIN, sharedRegistrationDuration),
+  raid: Literal((1.5 * DAY) / MIN, sharedRegistrationDuration),
+}
+
+const GIT_URL = `https://${process.env.DOMAIN}/git/`
+const getRepositoryURL = ({ attrs }) => `${GIT_URL}${attrs.repositoryPath}`
+const sharedRepository = {
+  label: 'Repository URL',
+  type: 'string',
+  required: true,
+  private: true,
+  ...Functions({ 'from gitea user account': getRepositoryURL }),
+}
+attrs.repository = {
+  exercise: sharedRepository,
+  project: sharedRepository,
+  raid: sharedRepository,
+}
+
+const getCaptainLogin = ({ group, parent }) => {
+  group || (group = parent?.group)
+  return group && (group.captainLogin || group.captain?.login)
+}
+const getRepositoryPath = ({ name, group, parent }, user) =>
+  `${getCaptainLogin({ group, parent }) || user.login}/${name}`
+const getExerciseRepositoryPath = ({ attrs, parent, path, group }, user) => {
+  const captainLogin = getCaptainLogin({ parent, group })
+  return captainLogin
+    ? `${captainLogin}/${parent.path.replace(/\/+/g, '-')}`
+    : `${user.login}/${attrs.rootName}`
+}
+const sharedRepositoryPath = {
+  label: 'Repository path',
+  type: 'string',
+  required: true,
+  private: true, // ??
+  ...Functions({ 'from captain': getRepositoryPath }),
+}
+attrs.repositoryPath = {
+  exercise: {
+    ...sharedRepositoryPath,
+    ...Functions({ 'from captain': getExerciseRepositoryPath }),
+  },
+  project: sharedRepositoryPath,
+  raid: sharedRepositoryPath,
+}
+
+attrs.requiredAuditRatio = {
+  project: Literal(0.5, {
+    label: 'Audit ratio required to begin the project',
+    instruction: 'From 0 to 2 (1 being the perfect balance of audits)',
+    required: true,
+    editable: true,
+    options: [...Array(21)].map((_, i) => Math.round(i * 0.1 * 10) / 10),
+    check: value => checkNumberInBetween(value, 0, 2),
+  }),
+}
+
+const sharedContentRequirementsForMainAttr = TypeObject({
+  ...contentRequirements,
+  type: {
+    skills: { ...skillsList, instruction: 'Expertises required' },
+    core: {
+      ...types.objectRootRelativePath,
+      label: 'Core content',
+      instruction: 'Relative path of the core content to be succeeded',
+    },
+    objects: {
+      ...types.sharedObjectList,
+      value: (...args) => {
+        const option = types.objectRootRelativePath.options(...args)?.[0]
+        return option ? [option] : []
+      },
+      type: [types.objectRootRelativePath],
+      instruction: 'Items to be succeeded',
+    },
+  },
+})
+relationAttrs.requirements = {
+  module: {
+    project: sharedContentRequirementsForMainAttr,
+    piscine: sharedContentRequirementsForMainAttr,
+  },
+  campus: { piscine: sharedContentRequirementsForMainAttr },
+  // should be open to any content: implementation to be checked when needed
+  // TODO: add exercise, raid, exam, quest
+}
+
+const sharedResume = Literal('', {
+  label: 'Resume',
+  editable: true,
+  ...translatable,
+})
+attrs.resume = {
+  'module-registration': sharedResume,
+  'piscine-registration': sharedResume,
+  'form-step': sharedResume,
+  interview: sharedResume,
+}
+
+const getBaseSkills = ({ attrs }) => attrs.baseSkills
+const getBaseXp = ({ attrs }) => attrs.baseXp
+const getScopedBaseXp = ({ attrs }) => (attrs.inScope ? attrs.baseXp : 0)
+types.skills = {
+  ...Functions({ 'collect skills': getBaseSkills }),
+  label: 'Skills',
+  required: true,
+}
+const sharedRewards = {
+  required: true,
+  label: 'Reward conditions',
+  instruction: 'Conditions to collect xp and skills when succeeded',
+}
+const rewardsOfSkillsAndXpInScope = TypeObject({
+  type: {
+    skills: types.skills,
+    xp: {
+      ...Functions({ 'collect xp in scope': getScopedBaseXp }),
+      label: 'XP',
+      required: true,
+    },
+  },
+  ...sharedRewards,
+})
+relationAttrs.rewards = {
+  piscine: {
+    raid: TypeObject({
+      type: {
+        skills: types.skills,
+        xp: {
+          ...Functions({ 'collect xp': getBaseXp }),
+          label: 'XP',
+          required: true,
+        },
+      },
+      ...sharedRewards,
+    }),
+    project: rewardsOfSkillsAndXpInScope,
+  },
+  module: {
+    piscine: TypeObject({
+      type: {
+        skills: types.skills,
+        xp: {
+          ...Functions({ 'collect xp': getBaseXp }),
+          label: 'XP',
+          required: true,
+        },
+      },
+      ...sharedRewards,
+    }),
+    project: rewardsOfSkillsAndXpInScope,
+  },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  campus: {
+    piscine: TypeObject({
+      type: {
+        skills: types.skills,
+        xp: {
+          ...Functions({ 'collect xp': getBaseXp }),
+          label: 'XP',
+          required: true,
+        },
+      },
+      ...sharedRewards,
+    }),
+  },
+  quest: { exercise: rewardsOfSkillsAndXpInScope },
+  exam: { exercise: rewardsOfSkillsAndXpInScope },
+}
+const rewardParent = ({ parent }) => {
+  // cannot keep all parent or get an infinite loop
+  const { attrs, name, type, id, path } = parent
+  // keep a classical object structure (as we would retrieve it with path feature)
+  return type !== 'campus'
+    ? { attrs: { eventId: attrs.eventId }, name, type, id, path }
+    : undefined
+}
+relationAttrs.rewardsTarget = {
+  module: {
+    piscine: {
+      type: 'object',
+      label: 'Target of the rewards',
+      instruction: 'Content to which rewards are attributed',
+      required: true,
+      ...Functions({ 'parent event if exists': rewardParent }),
+    },
+  },
+}
+
+const getRootName = ({ parent }) => {
+  while (parent) {
+    if (parent.type === 'module' || parent.type === 'piscine') return parent.key
+    parent = parent.parent
+  }
+  return ''
+}
+const sharedRootName = {
+  type: 'string',
+  // TODO: verify if ok: useless to be seen by admin in object edit,
+  // but is needed in front end; can be private?
+  private: true,
+  ...Functions({ 'root content key': getRootName }),
+  required: true,
+  label: 'Root key',
+}
+relationAttrs.rootName = {
+  quest: { exercise: sharedRootName },
+  exam: { exercise: sharedRootName },
+  module: { project: sharedRootName },
+  piscine: { project: sharedRootName, raid: sharedRootName },
+}
+
+const getRootPath = ({ parent }) => {
+  while (parent) {
+    if (parent.type === 'module' || parent.type === 'piscine') {
+      return parent.path
+    }
+    parent = parent.parent
+  }
+}
+const sharedRootPath = {
+  type: 'string',
+  required: true,
+  private: true,
+  ...Functions({ 'root content path': getRootPath }),
+  label: 'Root path',
+}
+relationAttrs.rootPath = {
+  module: {
+    project: sharedRootPath,
+    piscine: sharedRootPath, // module rootPath needed
+    exam: sharedRootPath,
+  },
+  piscine: {
+    project: sharedRootPath,
+    raid: sharedRootPath,
+    exam: sharedRootPath,
+    quest: sharedRootPath,
+  },
+  quest: { exercise: sharedRootPath },
+  exam: { exercise: sharedRootPath },
+}
+
+const questScopeEnd = object =>
+  getQuestExtraEndAt(object.attrs.scopeStart, object)
+const getEventScopeEnd = ({ event }) => event && numTime(event.endAt)
+// NB: Used for the timer in the front
+const sharedScopeEnd = {
+  type: 'number',
+  required: true,
+  private: true, // not necessary: admins already see temporal-window and reward scope
+}
+const eventScopeEnd = {
+  ...sharedScopeEnd,
+  label: 'Active scope end',
+  ...Functions({ 'when event ends': getEventScopeEnd }),
+}
+const extraDurationScopeEnd = {
+  ...sharedScopeEnd,
+  label: 'Reward scope end',
+  ...Functions({ 'when extra duration ends': questScopeEnd }),
+}
+relationAttrs.scopeEnd = {
+  piscine: {
+    raid: eventScopeEnd,
+    // rm? (for exam) questScopeEnd was applied (which makes no sense)
+    // so I don't think we use it. Maybe we don't need inScope/startScope either then
+    // also it seems that timer is used only in ProjectView and QuestView
+    exam: eventScopeEnd,
+    quest: extraDurationScopeEnd,
+    project: extraDurationScopeEnd,
+  },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  module: { project: extraDurationScopeEnd, exam: eventScopeEnd },
+}
+
+const sharedScopeExtraDuration = Literal(0, {
+  label: 'Extra duration (for reward scope)',
+  editable: true,
+  check: duration => checkDurationInBetween(duration * DAY, 0, 50 * DAY), // TODO: maybe max should be another int
+})
+
+relationAttrs.scopeExtraDuration = {
+  piscine: {
+    quest: sharedScopeExtraDuration,
+    project: sharedScopeExtraDuration,
+  },
+}
+
+// TODO: this attribute only get the start attribute. Maybe we could rm it
+const getScopeStart = ({ attrs }) => attrs.start
+const sharedScopeStart = {
+  type: 'number',
+  required: true,
+  private: true, // not necessary - admin already see temporal-window and reward scope
+  ...Functions({ 'from start date': getScopeStart }),
+}
+const sharedEventScopeStart = {
+  ...sharedScopeStart,
+  label: 'Active scope start',
+}
+const temporalWindowScopeStart = {
+  ...sharedScopeStart,
+  label: 'Temporal-window & reward scope start',
+}
+relationAttrs.scopeStart = {
+  piscine: {
+    quest: temporalWindowScopeStart,
+    project: temporalWindowScopeStart,
+    raid: sharedEventScopeStart,
+    exam: sharedEventScopeStart,
+  },
+  module: { exam: sharedEventScopeStart, project: temporalWindowScopeStart },
+}
+
+const getSpecial = ({ parent }) => parent?.attrs.special
+attrs.special = {
+  quest: Literal(false, {
+    label: 'Activate hackathon mode',
+    editable: true,
+    restrictive: true,
+  }),
+  exercise: {
+    // not private because it helps the admin to identify the exercise as special/in hackathon mode
+    label: 'In hackathon mode',
+    type: 'boolean',
+    required: true, // To be sure it will always be there if the quest is special
+    ...Functions({ 'activated with the quest': getSpecial }),
+  },
+}
+
+// getStart returns date in milliseconds
+const getStart = object => {
+  const match = findParent(object, hasEvent)
+  const event = match?.event
+
+  if (event) {
+    const time = numTime(event.startAt)
+    return match === object ? time : getQuestStartAt(time, object)
+  }
+  if (!object.parent) return
+  // TODO: rm this part? should always find a match no? what is the no case?
+  return getQuestStartAt(object.parent.attrs.start, object)
+}
+const sharedStart = {
+  label: 'Start date',
+  type: 'number',
+  required: true,
+  private: true, // all infos are defined in duration and inScope attributes
+  ...Functions({ 'from start date of event': getStart }),
+}
+const projectStart = {
+  // stay private - not really useful now, as access is defined by requirements & type (could be confusing otherwise)
+  ...sharedStart,
+  ...Functions({ 'starts with module': getStart }),
+}
+const getExerciseStart = ({ parent, attrs }) =>
+  parent?.attrs.start + attrs.delay
+const exerciseStart = {
+  ...sharedStart,
+  ...Functions({
+    'from temporal-window (if in hackathon mode)': getExerciseStart,
+  }),
+}
+relationAttrs.start = {
+  campus: {
+    module: sharedStart,
+    piscine: sharedStart,
+  },
+  module: {
+    exam: sharedStart,
+    piscine: sharedStart,
+    // TODO: rm? or could be used with temporal-window, if we define a delay (could be an option)
+    // NB: this attribute is used to calculate hasStarted and inScope attributes
+    project: projectStart,
+  },
+  piscine: {
+    raid: sharedStart,
+    exam: sharedStart,
+    // non event ones
+    quest: {
+      ...sharedStart,
+      ...Functions({ 'from temporal-window': getStart }),
+    },
+    project: projectStart,
+  },
+  quest: { exercise: exerciseStart },
+  // exam: { exercise: exerciseStart }, // needed?
+}
+
+// TODO: should also be handled differently in the event service
+// if no startAfter is defined, children events should not be pre-created.
+const sharedStartAfter = Literal(0, {
+  label: 'Starts after a delay of (within the event)',
+  editable: true,
+  required: true,
+  // check: () => {
+  // check that if there is a prev event with startAfter, it is bigger number here
+  // },
+})
+
+relationAttrs.startAfter = {
+  module: { piscine: sharedStartAfter, exam: sharedStartAfter },
+  piscine: { exam: sharedStartAfter, raid: sharedStartAfter },
+  // TODO: TO RM - HERE ONLY TO COMPARE CAMPUS BEFORE AND AFTER REL ATTRS IMPLEM
+  campus: { piscine: sharedStartAfter },
+}
+
+// TODO: this should be defined in the relation
+// this attribute is not editable!
+// to change the startDay, admins should update the duration of the elements
+const getStartDay = ({ prev }) =>
+  prev ? prev.attrs.duration + prev.attrs.startDay : 1
+const getExamStartDay = ({ parent, prev }) =>
+  parent.type === 'piscine' ? getStartDay({ prev }) : undefined
+const sharedStartDay = Literal(1, {
+  label: 'Start day n°',
+  // TODO: find a smaller name for the fn
+  ...Functions({ 'from end of previous content temporal-window': getStartDay }),
+  required: true,
+  private: true, // would be interesting to show only in an event context
+  // some more infos internally:
+  // This attribute is used for :
+  // → selection piscine's graph UI: startDay is not used directly in the graph but to calculate the week attribute, to display each object - quest, raid or exam - on the corresponding branch/week it's happening
+  // → calendar view UI: display the duration of each object over the week (but currently the component is not in use)
+  // → stats: check if the object has begun inside the event to extract its stats\n→ object's attributes: calculation of the attributes scopeEnd, delay & week",
+})
+relationAttrs.startDay = {
+  piscine: {
+    exam: {
+      ...sharedStartDay,
+      ...Functions({
+        'from end of previous content temporal-window': getExamStartDay,
+      }),
+    },
+    quest: sharedStartDay,
+    raid: sharedStartDay,
+    project: sharedStartDay,
+  },
+}
+
+const getProgressStatus = progress => {
+  if (progress?.isDone) {
+    return progress.grade >= 1 ? 'succeeded' : 'failed'
+  }
+}
+
+const examExerciseStatus = object => {
+  const { prev, attrs, progress, parent, index, event } = object
+  const progressStatus = getProgressStatus(progress)
+  if (progressStatus) return progressStatus
+  if (!parent) return 'available'
+  if (parent.attrs.status === 'blocked') return 'blocked'
+
+  const { group } = attrs
+  if (group <= 1) return parent.attrs.status
+  // check for previous exercises in the exam
+  // groups could be skipped due to potential misconfiguration,
+  // so we search for the closest previous group relative to the current group
+  const previousGroups = _children(parent).filter(c => c.attrs.group < group)
+  const maxGroup = Math.max(...previousGroups.map(c => c.attrs.group))
+  const prevValidated = previousGroups
+    .filter(c => c.attrs.group === maxGroup)
+    .some(c => c.attrs.status === 'succeeded')
+
+  return prevValidated ? 'available' : 'blocked'
+}
+const questExerciseStatus = object => {
+  const { prev, attrs, progress, parent, index, event } = object
+  const progressStatus = getProgressStatus(progress)
+  if (progressStatus) return progressStatus
+  if (!parent) return 'available'
+  if (parent.attrs.status === 'blocked') return 'blocked'
+
+  const now = Date.now()
+  if (attrs.special) {
+    if (now < attrs.start) return 'blocked'
+    if (now > attrs.duration + attrs.start) return 'failed'
+    return 'available'
+  }
+
+  if (prev && prev.attrs.status !== 'succeeded') return 'blocked'
+  const tomorrow = Date.now() + DAY
+  if (
+    parent.prev?.type === 'project' &&
+    parent.prev?.attrs.status !== 'succeeded' &&
+    parent.prev?.attrs.scopeEnd > tomorrow
+  ) {
+    return 'blocked'
+  }
+
+  const prevQuest = findPrev(parent.prev, isQuest)
+  if (
+    prevQuest &&
+    prevQuest.attrs.status !== 'succeeded' &&
+    prevQuest.attrs.scopeEnd > tomorrow
+  ) {
+    return 'blocked'
+  }
+
+  return 'available'
+}
+
+/**
+ * @throws This function throws an error if any of the required objects is invalid
+ * @returns {bool} true if all the required objects are succeeded, false otherwise
+ * @params {any} A 01-object
+ */
+const hasSucceededRequiredObjects = (requirements, object) => {
+  if (!requirements) return true
+  const { core, objects } = requirements
+  if ((!objects || !objects.length) && !core) return true
+
+  // aggregate core object and regular required objects in the list of objects to check
+  const requiredObjects = [...(objects || []), core].filter(Boolean) // only keep values that are not undefined
+  let objectFromPath
+  return requiredObjects.every(relativePath => {
+    try {
+      objectFromPath = getObjectFromRelativePath(relativePath, object)
+    } catch {
+      // consider the requirement locked if an error is thrown by getObjectFromRelativePath
+      return false
+    }
+    return objectFromPath?.attrs.status === 'succeeded'
+  })
+}
+
+// check if the requirements are met for a given object
+const meetsRequirements = ({ requirements, object, user, progress }) => {
+  // check if there's already a progress, to not block students who began the project before implementing the requirements feature
+  if ((progress && Object.keys(progress).length) || !requirements) return true
+
+  // check if the required skills have been earned & the required objects have been succeeded
+  const hasSkills = hasRequiredSkills(requirements.skills, user.skills)
+  const hasSucceededObjects = hasSucceededRequiredObjects(requirements, object)
+
+  return hasSucceededObjects && hasSkills
+}
+
+const projectInPiscineStatus = object => {
+  const { prev, parent, attrs } = object
+  if (!parent.progress) return 'blocked'
+  if (!attrs.hasStarted) return 'blocked'
+  if (Date.now() < attrs.scopeEnd && notSucceeded(prev)) return 'blocked'
+
+  return 'available'
+}
+
+const projectStatus = (object, user) => {
+  const { attrs, progress } = object
+  const { requirements, parentType } = attrs
+
+  // check first for existing progress
+  const progressStatus = getProgressStatus(progress)
+  if (progressStatus) return progressStatus
+
+  // check if the object requirements are met
+  if (!meetsRequirements({ object, requirements, user, progress })) {
+    return 'blocked'
+  }
+
+  // handle special case for project in piscine
+  if (parentType === 'piscine') return projectInPiscineStatus(object)
+  return 'available'
+}
+
+const notSucceeded = quest =>
+  quest?.attrs.inScope && quest?.attrs.status !== 'succeeded'
+const successStatus = children => {
+  for (const child of children) {
+    if (!isRequired(child)) continue
+    if (!child.progress) return 'failed'
+    const status = getProgressStatus(child.progress)
+    if (status && status !== 'succeeded') return status
+  }
+  return 'succeeded'
+}
+
+const questStatus = object => {
+  const { prev, parent, attrs, progress } = object
+  if (!parent) return 'blocked'
+  if (!parent.progress) return 'blocked'
+  if (!attrs.hasStarted) return 'blocked'
+  if (
+    !attrs.special &&
+    Date.now() > attrs.scopeEnd &&
+    notSucceeded(findPrev(prev, isQuest))
+  ) {
+    return 'blocked'
+  }
+
+  const children = Object.values(object.children || {})
+  return children.length
+    ? successStatus(children)
+    : getProgressStatus(progress) || 'available'
+}
+
+const getPiscineStatus = (object, user) => {
+  const { progress, event, attrs } = object
+  const { requirements } = attrs
+  const progressStatus = getProgressStatus(progress)
+  if (progressStatus) return progressStatus
+
+  if (!event) return 'blocked'
+  const registrationNotStarted = Date.now() < event.registrationStartAt
+  if (
+    !meetsRequirements({ object, requirements, user, progress }) ||
+    registrationNotStarted
+  ) {
+    return 'blocked'
+  }
+
+  return 'available'
+}
+
+const raidStatus = object => {
+  const { progress, event, attrs } = object
+  const progressStatus = getProgressStatus(progress)
+  if (progressStatus) return progressStatus
+
+  if (!event) return 'blocked'
+  const now = Date.now()
+  if (now < attrs.start) return 'blocked'
+  // ! for some reason we are having problems setting the raid status blocked or failed
+  // ! when a user does not register to the raid it should render a view saying that he did not register in time
+  // ! but this is not the case here
+  // TODO : ^ fix the issue with the non registered users and the raid view
+  return 'available'
+}
+
+const alwaysOpen = () => 'available'
+const isWaitingEndOfEvent = (type, progress) =>
+  progress?.event &&
+  (type === 'interview' || type === 'piscine-registration') &&
+  new Date(progress.event.endAt) > Date.now()
+
+const onboardingStatus = object => {
+  const hasRelatedObject = object.type.endsWith('-registration')
+  const relatedObjectName = object.type.split('-')[0]
+  const relatedObject = hasRelatedObject
+    ? getChildByType(object.parent.parent.children, relatedObjectName)
+    : object
+
+  if (!relatedObject) return 'blocked'
+  const progress = relatedObject.lastProgress
+  const progressStatus = getProgressStatus(progress)
+  if (
+    progressStatus === 'succeeded' &&
+    isWaitingEndOfEvent(object.type, relatedObject.lastProgress)
+  ) {
+    return 'available'
+  }
+  if (progressStatus) return progressStatus
+  if (
+    !object.prev ||
+    (object.prev && object.prev.attrs.status === 'succeeded')
+  ) {
+    return 'available'
+  }
+  return 'blocked'
+}
+const sharedOnboardingStepStatus = {
+  type: 'string',
+  label: 'Unlock system',
+  ...Functions({ 'previous step validated': onboardingStatus }), // old version on onboarding: step by step selection
+  options: ['blocked', 'available', 'succeeded', 'failed'],
+  required: true,
+}
+const sharedStatus = {
+  type: 'string',
+  label: 'Unlock system and result status',
+  required: true,
+  options: ['blocked', 'available', 'succeeded', 'failed'],
+}
+relationAttrs.status = {
+  campus: {
+    // TODO: could be rm for onboarding?
+    onboarding: {
+      type: 'string',
+      private: true,
+      required: true,
+      ...Functions({ 'always open': alwaysOpen }),
+    },
+    piscine: {
+      ...sharedStatus,
+      ...Functions({ 'by requirements and event': getPiscineStatus }),
+    },
+  },
+  onboarding: {
+    administration: sharedOnboardingStepStatus,
+    games: sharedOnboardingStepStatus,
+    'piscine-registration': sharedOnboardingStepStatus,
+    'module-registration': sharedOnboardingStepStatus,
+    interview: sharedOnboardingStepStatus,
+  },
+  piscine: {
+    exam: {
+      ...sharedStatus,
+      ...Functions({ 'by event': questStatus }),
+    },
+    quest: {
+      ...sharedStatus,
+      ...Functions({ 'by scope': questStatus }),
+    },
+    raid: {
+      ...sharedStatus,
+      ...Functions({ 'by event': raidStatus }),
+    },
+    project: {
+      ...sharedStatus,
+      editable: true,
+      editableDefaultValue: 'available',
+      ...Functions({ 'by requirements': projectStatus }),
+    },
+  },
+  quest: {
+    exercise: {
+      ...sharedStatus,
+      editable: true,
+      editableDefaultValue: 'available',
+      ...Functions({ 'one by one': questExerciseStatus }),
+    },
+  },
+  exam: {
+    exercise: {
+      ...sharedStatus,
+      editable: true,
+      editableDefaultValue: 'available',
+      ...Functions({
+        'one by one (grouped by difficulty)': examExerciseStatus,
+      }),
+    },
+  },
+  module: {
+    project: {
+      ...sharedStatus,
+      editable: true,
+      editableDefaultValue: 'available',
+      ...Functions({ 'by requirements': projectStatus }),
+    },
+    piscine: {
+      ...sharedStatus,
+      ...Functions({ 'by requirements and event': getPiscineStatus }),
+    },
+    exam: {
+      ...sharedStatus,
+      ...Functions({ 'by event': questStatus }),
+    },
+  },
+}
+
+const getSubject = object => {
+  const path = `subjects/${getObjectPath(object)}/README.md`
+  return `/markdown/root/public/${path}`
+}
+const sharedSubject = Literal('', {
+  label: 'Subject URL',
+  editable: true,
+  required: true,
+  ...Functions({ 'README.md in subject folder': getSubject }),
+  // TODO: add a check? can return a relative path so it's complicated
+})
+attrs.subject = {
+  exercise: sharedSubject,
+  project: sharedSubject,
+  raid: sharedSubject,
+}
+
+const sharedText = Literal('', {
+  editable: true,
+  ...translatable,
+})
+// TODO: rename it documentToSign, or something more specific than 'text'
+attrs.text = {
+  'upload-step': {
+    ...sharedText,
+    label: 'Resume', // TODO: mv it to attrs.resume
+  },
+  'sign-step': {
+    ...sharedText,
+    label: 'Text to agree to',
+    required: true,
+  },
+  'contact-validation-step': {
+    ...sharedText,
+    label: 'Resume', // TODO: mv it to attrs.resume
+  },
+}
+
+types.timelineChunk = TypeObject({
+  label: 'Month guideline',
+  type: {
+    month: Literal(120, {
+      label: 'Month',
+      editable: true,
+      required: true,
+      primary: true,
+      // to put 120 first in options - could also be [120, ...arrayOf(119, 1)]
+      options: arrayOf(120, 1).reverse(),
+      check: (month, object) => {
+        checkIntegerInBetween(month, 1, 120)
+
+        const definitionsWithSameMonth = object.attrs.timeline.filter(
+          guideline => guideline.month === month,
+        )
+        if (definitionsWithSameMonth?.length > 1) {
+          throw Error(
+            `Month ${month} is set for different timeline guidelines! A given month can only be defined once.`,
+          )
+        }
+      },
+    }),
+    minLevel: Literal(0, {
+      label: 'Minimum level to be considered on track',
+      editable: true,
+      required: true,
+      options: arrayOf(MAX_LEVEL, 0),
+      check: level => checkIntegerInBetween(level, 0, MAX_LEVEL),
+    }),
+    expectedLevel: Literal(0, {
+      label: 'Expected level',
+      editable: true,
+      required: true,
+      options: arrayOf(MAX_LEVEL, 0),
+      check: level => checkIntegerInBetween(level, 0, MAX_LEVEL),
+    }),
+    checkpointLevel: Literal(0, {
+      label: 'Expected checkpoint level',
+      editable: true,
+      required: true,
+      options: arrayOf(100, 0),
+      check: level => checkIntegerInBetween(level, 0, 100),
+    }),
+    rank: Literal('', {
+      label: 'Expected rank',
+      editable: true,
+      check: (rank, object) => {
+        if (!object.attrs.ranksDefinitions?.length) {
+          throw Error(
+            `Must match an existing rank name, but ranks definitions are not set.`,
+          )
+        }
+
+        const ranksNames = object.attrs.ranksDefinitions.map(({ name }) => name)
+        if (!ranksNames.includes(rank)) {
+          throw Error(
+            `Must match one of the following existing rank names: ${ranksNames.join(
+              ', ',
+            )}.`,
+          )
+        }
+      },
+    }),
+    developpedSkills: TypeObject({
+      label: 'Developed skills on a specific months duration',
+      editable: true,
+      type: {
+        monthsSpan: Literal(1, {
+          label: 'Months duration',
+          editable: true,
+          options: arrayOf(120, 1),
+          check: month => checkIntegerInBetween(month, 1, 120),
+        }),
+        list: {
+          label: 'List of developed skills', // shouldn't it be skillsList?
+          editable: true,
+          required: true,
+          value: [''],
+          type: [
+            Literal('', {
+              label: 'Skill developed',
+              editable: true,
+              required: true,
+              // check: value => checkNotEmpty(value), // cannot check not empty if def value is empty
+            }),
+          ],
+          check: list => {
+            if (!list?.length || !Array.isArray(list)) {
+              throw Error('Must be a non empty array')
+            }
+          },
+        },
+      },
+    }),
+  },
+})
+const sharedTimeline = {
+  label: 'Timeline per month for a curriculum',
+  value: (...args) => [
+    mapValues(types.timelineChunk.type, subDef =>
+      getDefaultValue(subDef, ...args),
+    ),
+  ],
+  editable: true,
+  restrictive: true,
+  type: [types.timelineChunk],
+  check: timeline => {
+    if (!timeline?.length || !Array.isArray(timeline)) {
+      throw Error('Must be a non empty array')
+    }
+  },
+}
+attrs.timeline = {
+  module: sharedTimeline,
+  piscine: sharedTimeline,
+}
+
+// TODO: resolve how to show this in front: as the only key is private, object is empty
+types.adminSelectionValidation = TypeObject({
+  type: {
+    type: Literal('admin_selection', {
+      required: true,
+      private: true,
+      primary: true,
+      label: 'Type',
+    }),
+  },
+  label: 'Admin selection evaluation',
+})
+
+const getTesterImage = ({ attrs }) =>
+  attrs.language && `ghcr.io/01-edu/test-${attrs.language}`
+types.testerValidation = TypeObject({
+  label: 'Tester evaluation',
+  type: {
+    type: Literal('tester', { required: true, private: true, label: 'Type' }),
+    testImage: {
+      type: 'string',
+      label: 'Docker image',
+      required: true,
+      editable: true,
+      primary: true,
+      instruction: 'used to run the tests',
+      // description currently in progress of writing
+      ...Functions({ 'from language': getTesterImage }),
+    },
+    // TODO: mv to relation attribute? Used in the attributes of an exercise or in the children attrs of a quest.
+    cooldown: Literal(3 * MIN, {
+      required: true,
+      editable: true,
+      label: 'Delay between two submit',
+    }),
+  },
+})
+
+// should not be editable because it could break the audits query system
+const sharedMatchWhere = {
+  type: 'object',
+  required: true,
+  label: 'Audited by',
+  instruction: 'Match groups with auditors',
+}
+// matchWhere for user_audit validations
+// NB: user 1 should always be excluded because he has admin role that can't be removed
+const userInCampus = ({ attrs }) => ({
+  campus: { _eq: attrs.campus },
+  _not: { roles: { slug: { _in: ['admin', `campus_admin_${attrs.campus}`] } } },
+})
+const userInEvent = ({ attrs }) => ({
+  ...userInCampus({ attrs }),
+  events: { eventId: { _eq: attrs.eventId } },
+})
+
+// fallback on user 01 when no campus admin/dedicated auditor defined
+const isUser01 = { id: { _eq: 1 } }
+const userAuditorForEvent = ({ event }) => {
+  const labelName = `auditorFor${event?.id}`
+  const hasEventLabel = { labels: { label: { name: { _eq: labelName } } } }
+
+  return { _or: [hasEventLabel, isUser01] }
+}
+
+// matchWhere for admin_audit validations
+const isCampusAdmin = ({ attrs }) => ({
+  _or: [
+    { private: { roles: { slug: { _eq: `campus_admin_${attrs.campus}` } } } },
+    isUser01,
+  ],
+})
+// if school don't want any specific attribution,
+// we attribute audits by default to user 01-edu, that cannot be removed,
+// cannot loose his admin role, or have any record associated (sql fn triggers)
+const noAttribution = () => isUser01
+
+export const getAuditPath = object => {
+  const path = `subjects/${getObjectPath(object)}/audit/README.md`
+  return `/markdown/root/public/${path}`
+}
+const sharedTypesForm = {
+  required: true,
+  editable: true,
+  type: 'string',
+  label: 'Audit form url',
+  instruction: 'List of questions asked by the auditor during the audit.',
+  ...Functions({ 'README in audit folder': getAuditPath }),
+}
+types.adminAuditValidationDelay = Literal(0, {
+  label: 'Delay',
+  editable: true,
+  required: true,
+  instruction:
+    'Time allowed to complete the audit before it expires. "0s" equals no delay.', // TODO: convert to MS'
+})
+types.adminAuditValidationRequired = Literal(1, {
+  label: 'Number required',
+  required: true,
+  instruction: 'Minimum of audits required',
+  check: value => {
+    if (value < 1) throw Error('must be at least one')
+  },
+})
+types.adminAuditValidationRatio = Literal(1, {
+  label: 'Ratio',
+  required: true,
+  instruction: 'Proportion of extra audits generated',
+  check: value => {
+    if (value < 1) throw Error('must be at least one')
+  },
+})
+
+types.adminAuditValidation = TypeObject({
+  label: 'Admin audit evaluation',
+  type: {
+    type: Literal('admin_audit', {
+      required: true,
+      private: true,
+      primary: true,
+      label: 'Type',
+    }),
+    delay: types.adminAuditValidationDelay,
+    required: types.adminAuditValidationRequired,
+    ratio: types.adminAuditValidationRatio,
+    matchWhere: {
+      ...sharedMatchWhere,
+      ...Functions({
+        'an admin of same campus': isCampusAdmin,
+        'manual attribution': noAttribution,
+      }),
+    },
+    form: sharedTypesForm,
+  },
+})
+
+types.userAuditValidationDelay = Literal((2 * WEEK) / MIN, {
+  label: 'Delay',
+  required: true,
+  editable: true,
+  instruction: 'Time allowed to complete the audit before it expires', // TODO: convert to MS
+})
+types.userAuditValidationRequired = Literal(5, {
+  label: 'Number required',
+  required: true,
+  editable: true,
+  instruction: 'Minimum of audits required',
+  check: value => {
+    if (value < 1) throw Error('must be at least one')
+  },
+})
+types.userAuditValidationRatio = Literal(2, {
+  label: 'Ratio',
+  required: true,
+  editable: true,
+  instruction: 'Proportion of extra audits generated',
+  check: value => {
+    if (value < 1) throw Error('must be at least one')
+  },
+})
+
+types.userAuditValidation = TypeObject({
+  label: 'User audit evaluation',
+  type: {
+    type: Literal('user_audit', {
+      required: true,
+      private: true,
+      primary: true,
+      label: 'Type',
+    }),
+    delay: types.userAuditValidationDelay,
+    required: types.userAuditValidationRequired,
+    ratio: types.userAuditValidationRatio,
+    matchWhere: {
+      ...sharedMatchWhere,
+      ...Functions({
+        'any user in same campus': userInCampus,
+        'any user in same event': userInEvent,
+      }),
+    },
+    form: sharedTypesForm,
+    preQuestions: {
+      editable: true,
+      type: 'array',
+      label: 'Pre questions',
+      instruction: 'List of questions that appears before the main audit',
+    },
+    postQuestions: {
+      editable: true,
+      type: 'array',
+      label: 'Post questions',
+      instruction: 'List of questions that appears after the main audit',
+    },
+  },
+})
+
+types.raidAuditorValidation = TypeObject({
+  label: 'User audit evaluation (dedicated for event)',
+  type: {
+    type: Literal('dedicated_auditors_for_event', {
+      required: true,
+      private: true,
+      primary: true,
+      label: 'Type',
+    }),
+    delay: types.adminAuditValidationDelay, // no limit to audit?
+    required: types.adminAuditValidationRequired,
+    ratio: types.adminAuditValidationRatio,
+    matchWhere: {
+      ...sharedMatchWhere,
+      ...Functions({
+        "any user labelled as event's auditor ": userAuditorForEvent,
+      }),
+    },
+    form: sharedTypesForm,
+  },
+})
+
+const sharedValidations = {
+  label: 'Evaluated by',
+  instruction: 'List of evaluations to complete in order',
+  check: value => {
+    if (!value.length) throw Error('must have at least one element')
+  },
+  required: true,
+  editable: true,
+}
+attrs.validations = {
+  project: {
+    ...sharedValidations,
+    type: [types.userAuditValidation], // TODO: add types.adminAuditValidation? test if would work
+    value: (...args) => [
+      mapValues(types.userAuditValidation.type, subDef =>
+        getDefaultValue(subDef, ...args),
+      ),
+    ],
+  },
+  raid: {
+    ...sharedValidations,
+    type: [types.adminAuditValidation, types.raidAuditorValidation],
+    maxElements: 1,
+    value: (...args) => [
+      mapValues(types.adminAuditValidation.type, subDef =>
+        getDefaultValue(subDef, ...args),
+      ),
+    ],
+  },
+  exercise: {
+    ...sharedValidations,
+    type: [types.testerValidation],
+    value: (...args) => [
+      mapValues(types.testerValidation.type, subDef =>
+        getDefaultValue(subDef, ...args),
+      ),
+    ],
+  },
+  piscine: {
+    ...sharedValidations,
+    type: [types.adminSelectionValidation],
+    value: (...args) => [
+      mapValues(types.adminSelectionValidation.type, subDef =>
+        getDefaultValue(subDef, ...args),
+      ),
+    ],
+  },
+  interview: {
+    ...sharedValidations,
+    type: [types.adminSelectionValidation],
+    value: (...args) => [
+      mapValues(types.adminSelectionValidation.type, subDef =>
+        getDefaultValue(subDef, ...args),
+      ),
+    ],
+  },
+}
+
+attrs.videos = {
+  quest: Literal('https://www.youtube.com/', {
+    type: 'string',
+    label: 'Videos URL',
+    editable: true,
+    check: checkValidURL,
+  }),
+}
+
+const getWeek = ({ attrs }) => {
+  if (!attrs.startDay) return undefined // for exams in module for example
+  const diff = attrs.startDay / 7
+  return Math.ceil(diff)
+}
+// TODO: this should be defined in the relation
+const sharedWeek = Literal(1, {
+  label: 'Week n°',
+  required: true,
+  private: true, // would be interesting to show only in an event context
+  // UI only, represents the number of the week inside an event.
+  // This attribute is used for :
+  // → selection piscine's graph UI : position each object on the corresponding branch (one branch represents one week)
+  // → calendar view UI: position each object on the calendar's weeks (but currently the component is not in use)
+  ...Functions({ 'from day n°': getWeek }),
+})
+relationAttrs.week = {
+  piscine: {
+    exam: sharedWeek,
+    quest: sharedWeek,
+    raid: sharedWeek,
+    project: {
+      ...sharedWeek,
+      value: 1,
+      functions: undefined,
+      required: false,
+      private: false,
+      editable: true,
+    },
+  },
+}
+
+const sharedZeroXpIndex = Literal(0, {
+  required: true,
+  private: true,
+})
+const parentXpIndex = ({ parent }) => parent.attrs.xpIndex
+const getXpIndex = ({ id, name, prev, parent, attrs, type }) => {
+  if (prev) return (prev.attrs.xpIndex || 0) + (_difficultyXpCoef(prev) || 1)
+  return parent?.attrs.xpIndex || 0
+}
+const sharedXpIndex = {
+  required: true,
+  private: true,
+  type: 'number',
+  ...Functions({
+    'from previous xpIndex and XP coefficient (or parent if exam or no prev)':
+      getXpIndex,
+  }),
+}
+relationAttrs.xpIndex = {
+  campus: {
+    module: sharedZeroXpIndex,
+    piscine: sharedZeroXpIndex,
+  },
+  module: {
+    piscine: sharedZeroXpIndex,
+    project: sharedXpIndex,
+    exam: sharedXpIndex,
+  },
+  piscine: {
+    exam: sharedXpIndex,
+    project: sharedXpIndex,
+    quest: sharedXpIndex,
+    raid: sharedXpIndex,
+  },
+  quest: { exercise: sharedXpIndex },
+  exam: {
+    exercise: {
+      required: true,
+      private: true,
+      type: 'number',
+      ...Functions({ 'from parent xpIndex': parentXpIndex }),
+    },
+  },
+}
+
+export const internal = {
+  hasSucceededRequiredObjects,
+  projectStatus,
+  getPiscineStatus,
+  meetsRequirements,
+}