@01-edu/shared 1.0.6 → 1.0.12

package/attrs.js

@@ -12,12 +12,17 @@ const typeCheckers = {
   array: Array.isArray,
 }
 
+const determinType = value => {
+  if (Array.isArray(value)) return 'array'
+  if (typeof value === 'object' && value !== null) return value.type
+  return typeof value
+}
 const typeChecker = (defs, value, object, key) => {
   const { type, check, options } = defs
 
   if (value == null) {
-    if (!defs.required) return true
-    // if no value for required attribute, reject
+    if (!defs.required || defs.value !== undefined) return true
+    // if no value for required attribute without a default value, reject
     throw Error(`missing value for required attribute ${key}`)
   }
 
@@ -33,11 +38,17 @@ const typeChecker = (defs, value, object, key) => {
 
   if (options) {
     const opts = typeof options === 'function' ? options(object) : options
-    const isAnOption = opts.includes(value)
-    if (!isAnOption) {
-      throw Error(
-        `invalid option for ${key}: should be included in ${opts.join(', ')}`,
-      )
+    if (opts.length === 1) {
+      if (opts[0] !== value) {
+        throw Error(`${key} must be ${opts[0]} but was ${value}`)
+      }
+    } else {
+      const isAnOption = opts.includes(value)
+      if (!isAnOption) {
+        throw Error(
+          `invalid option for ${key}: should be included in ${opts.join(', ')}`,
+        )
+      }
     }
   }
 
@@ -55,16 +66,23 @@ const typeChecker = (defs, value, object, key) => {
     // every value have to match one of the type definition
 
     const uniqueDef = type.length === 1 && type[0]
+    // convert array type into object for better accessibility
     const types =
       !uniqueDef &&
-      Object.fromEntries(type.map(t => [t.type?.type?.value || t.type, t]))
+      Object.fromEntries(
+        type.map(t => [
+          Array.isArray(t.type) ? 'array' : t.type?.type?.value || t.type,
+          t,
+        ]),
+      )
+
     for (const [index, v] of value.entries()) {
       const err = Error('checks failed for all types')
       err.index = index
       err.key = key
       err.label = defs.label
-      const subdefs =
-        uniqueDef || (typeof v === 'object' ? types[v.type] : types[typeof v])
+      const subdefs = uniqueDef || types[determinType(v)]
+
       if (!subdefs) {
         err.details = {
           label: 'Unknown structure',
@@ -79,7 +97,6 @@ const typeChecker = (defs, value, object, key) => {
           label: subdefs.label || error.label,
           err: error,
         }
-
         throw err
       }
     }
@@ -111,7 +128,7 @@ const typeChecker = (defs, value, object, key) => {
 // same as attrs with the check & function by name generated and descriptions form markdown files
 export const attributes = mapEntries(attrs, ([attrKey, matches]) => [
   attrKey,
-  mapValues(matches, (defs, type) => ({
+  mapValues(matches, (defs /* type */) => ({
     ...defs,
     check: (value, object) => typeChecker(defs, value, object, attrKey),
   })),
@@ -121,8 +138,8 @@ export const relationAttributes = mapEntries(
   relationAttrs,
   ([attrKey, byParent]) => [
     attrKey,
-    mapValues(byParent, (matches, parentType) =>
-      mapValues(matches, (defs, childType) => ({
+    mapValues(byParent, (matches /* parentType */) =>
+      mapValues(matches, (defs /* childType */) => ({
         ...defs,
         check: (value, object) => typeChecker(defs, value, object, attrKey),
       })),
@@ -130,6 +147,68 @@ export const relationAttributes = mapEntries(
   ],
 )
 
+// white list of attributes that can be applied in bulk
+const allowedBulkAttrs = {
+  codeEditor: { enabled: {} },
+  validations: {
+    // this is for the different options of validation,
+    // we know that raids for now is the only one that contains multiple validations
+    // and we **don't** want admin_selection
+    type: [
+      'admin_audit',
+      'tester',
+      'dedicated_auditors_for_event',
+      'user_audit',
+    ],
+    ratio: {},
+    required: {},
+    matchInfluence: {},
+    cooldown: {},
+    preQuestions: {},
+    postQuestions: {},
+    matchWhere: {},
+  },
+}
+export const getAllBulkAttrs = (parentType, childType) => {
+  const relationAttrs = getDefaultRelAttrs(parentType, childType)
+  const attrs = getDefaultAttrs({ type: childType })
+  const allAttrs = { ...relationAttrs, ...attrs }
+  return filterBulkAttrs(allAttrs, allowedBulkAttrs)
+}
+export const filterBulkAttrs = (attrs, allowedAttrs) => {
+  if (!attrs) return {}
+  if (Array.isArray(attrs.type)) {
+    const { type, ...rest } = attrs
+    // if it is type array and from the validation attribute we need to filter the validation type
+    const types = type
+      .map(a => filterBulkAttrs(a, allowedAttrs))
+      .filter(({ type }) => allowedAttrs.type.includes(type.type.value))
+    return { ...rest, type: types }
+  }
+  if (attrs.type && typeof attrs.type === 'object') {
+    const { type, ...rest } = attrs
+    const filtered = { type: {}, ...rest }
+    const typesKeys = Object.keys(type)
+    for (const t of typesKeys) {
+      if (allowedAttrs?.[t]) {
+        filtered.type[t] = type[t]
+      }
+    }
+    return filtered
+  }
+  if (typeof attrs === 'object' && !attrs.type) {
+    const filtered = {}
+    const keys = Object.keys(attrs)
+    for (const k of keys) {
+      if (allowedAttrs[k]) {
+        filtered[k] = filterBulkAttrs(attrs[k], allowedAttrs[k])
+      }
+    }
+    return filtered
+  }
+  return null
+}
+
 // map from attrs[name][type] to attrs[type][name]
 export const attrsByType = {}
 
@@ -141,7 +220,7 @@ for (const [name, matches] of Object.entries(attributes)) {
     // handle translations: generate translation attrs and required status
     const { label, ...restDefs } = defs
     if (defs.functionsByName?.translate) {
-      // perf measures done: inscrease from 0.671ms loadtime to 13.261ms
+      // perf measures done: increase from 0.671ms loadtime to 13.261ms
       // should not impact the perfs
       for (const [code, language] of languagesEntries) {
         const newLabel = `${label} - ${language}`
@@ -259,6 +338,14 @@ const expandAttr = (key, value, defs, object, getUser) => {
 
 export const expandAttrs = (object, getUser) => {
   if (!object.children) return (object.children = {})
+
+  for (const [key, defs] of getDefaultAttrsEntries(object)) {
+    if (object.attrs[key] === null) {
+      console.warn(`value is null for ${object.name} - ${key} - ${object.id}`)
+    }
+    expandAttr(key, object.attrs, defs, object, getUser)
+  }
+
   let prev
   for (const child of Object.values(object.children)) {
     child.parent = object

package/bin/check-definitions.js

@@ -4,6 +4,7 @@ import { readFile, stat, watch } from 'node:fs/promises'
 
 import { checkAndBuildDefinitions } from '../definitions-checker.js'
 
+const rootTypes = ['module', 'piscine', 'signup', 'onboarding']
 const isAudit = validation => validation.type.endsWith('_audit')
 const readDef = async key => {
   const path = key == null ? 'content/def.json' : `content/${key}/def.json`
@@ -11,6 +12,12 @@ const readDef = async key => {
   def.attrs || (def.attrs = {})
   def.referencePath = path
 
+  if (key == null && !rootTypes.includes(def.type)) {
+    throw Error(
+      `Root definition must be one of ${rootTypes.join(', ')}, found: ${def.type}`,
+    )
+  }
+
   switch (def.type) {
     case 'project':
     // biome-ignore lint/suspicious/noFallthroughSwitchClause: We want to fallthrough
@@ -54,6 +61,7 @@ if (process.argv.includes('--watch') || process.argv.includes('-w')) {
   await runChecks()
   for await (const event of watch('.', { recursive: true })) {
     console.clear()
+    if (!event.filename.endsWith('def.json')) continue
     console.log(event.eventType, 'on', event.filename, '\n')
     await runChecks()
   }

package/definitions-checker.js

@@ -1,5 +1,5 @@
-import { childTypes, objectTypes } from './toolbox.js'
 import { attributes, relationAttributes } from './attrs.js'
+import { childTypes, objectTypes } from './toolbox.js'
 
 const normalize = str =>
   str
@@ -9,16 +9,8 @@ const normalize = str =>
     .replaceAll(' ', '-')
 
 const assertDef = def => {
-  const {
-    type,
-    name,
-    attrs,
-    children,
-    childrenAttrs,
-    refId,
-    referencePath,
-    ...rest
-  } = def
+  const { type, name, attrs, children, childrenAttrs, referencePath, ...rest } =
+    def
   const [extra] = Object.keys(rest)
   if (extra) {
     throw Error(
@@ -27,11 +19,12 @@ const assertDef = def => {
   }
   if (!objectTypes.has(type)) throw Error(`Invalid type property`)
   if (!name || typeof name !== 'string') throw Error(`Invalid name property`)
-  if (attrs && typeof attrs !== 'object') throw Error(`Invalid attrs property`)
-  if (refId && typeof refId !== 'number') throw Error(`Invalid refId property`)
+  if (!attrs || typeof attrs !== 'object' || Array.isArray(attrs)) {
+    throw Error(`Invalid attrs property`)
+  }
   if (childrenAttrs) throw Error(`childrenAttrs is no longer supported`)
 
-  for (const key of Object.keys(attrs)) {
+  for (const key of Object.keys(attrs || {})) {
     if (relationAttributes[key]) {
       throw Error(
         `Attr ${key} should be defined in the relation with its parent, not on the object itself.`,
@@ -52,16 +45,19 @@ const assertDef = def => {
   }
 }
 
-// TODO: maybe check for circularity here
-// I skipped this check for simplicity and performance
-// because since we already have check that we have a correct parent / child type
-// structure, a circular relation should not be possible
-const buildTree = ({ name, type, attrs, children, referencePath }, parent) => {
+const buildTree = (
+  { name, type, attrs, children, referencePath },
+  parent,
+  depth,
+) => {
+  // As we check for the parent / child type structure, this should never happen
+  // so we did not bother to make a more descriptive error for this case
+  if (depth > 100) throw Error('Unexpected very deep tree, maybe circular ?')
   const object = { name, type, attrs, children: {}, referencePath, parent }
   if (!children) return object
   let prev
   for (const [key, { ref, ...rest }] of Object.entries(children)) {
-    const child = buildTree(ref, object)
+    const child = buildTree(ref, object, (depth || 0) + 1)
     child.attrs = { ...child.attrs, ...rest }
     prev && (prev.next = child)
     child.prev = prev
@@ -73,7 +69,9 @@ const buildTree = ({ name, type, attrs, children, referencePath }, parent) => {
 const assertRelation = (parent, key, relation) => {
   if (!/^[a-z0-9-]*$/.test(key)) {
     throw Error(
-      `Invalid key for child ${key} Kebab-case key suggestion: ${normalize(key)}`,
+      `Invalid key for child ${key} Kebab-case key suggestion: ${normalize(
+        key,
+      )}`,
     )
   }
 
@@ -176,7 +174,10 @@ export const checkAndBuildDefinitions = async readDef => {
   const getDefs = async ([key, relation]) => {
     let def
     try {
-      def = cache[key] || (cache[key] = await readDef(key))
+      const cached = cache[key]
+      def = await (cached || (cache[key] = readDef(key)))
+      relation && (relation.ref = def)
+      if (cached) return [] // skip assert and children checks if already cached
     } catch (err) {
       err.name = key
       throw err
@@ -188,11 +189,12 @@ export const checkAndBuildDefinitions = async readDef => {
       err.referencePath = def.referencePath
       throw err
     }
-    relation && (relation.ref = def)
     const relations = Object.entries(def.children || {}).map(getDefs)
     try {
       return [def, ...(await Promise.all(relations)).flat()]
     } catch (err) {
+      // Some content may be used at multiple place (ex: exam exercises)
+      // so we may have multiple parents
       key && (err.parents || (err.parents = [])).push(key)
       throw err
     }

package/onboarding.js

@@ -9,6 +9,7 @@ export const onboardingTypes = new Set([
   'sign-step',
   'upload-step',
   'contact-validation-step',
+  'avatar-step',
 ])
 
 export const prevValidated = (key, object) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@01-edu/shared",
-  "version": "1.0.6",
+  "version": "1.0.12",
   "type": "module",
   "description": "",
   "scripts": {
@@ -21,7 +21,7 @@
     "./skill-definitions.js",
     "./toolbox.js"
   ],
-  "license": "MIT",
+  "license": "Fair",
   "bin": {
     "check-defs": "./bin/check-definitions.js"
   },

package/path.js

@@ -39,15 +39,23 @@ const walk = (object, segment) => {
 }
 
 /**
- * @returns {Object} the object in the relative path
- * @argument relativePath {string} a relative path
- * @argument currentObj {Object} the object from where the relative path starts
+ * @param {string} relativePath - a relative path
+ * @param {Object} currentObj - the object from where the relative path starts
+ * @param {Object} [opts = { throwError: true } ] - options object with boolean property `throwError` to throw an error in case the path is invalid or no object is found
+ * @returns {Object} - the object in the relative path
  */
-export const getObjectFromRelativePath = (relativePath, currentObj) => {
+export const getObjectFromRelativePath = (
+  relativePath,
+  currentObj,
+  opts = { throwError: true },
+) => {
   const currentPath = currentObj.path
   if (isAbsolutePath(relativePath)) {
-    throw Error("'relativePath' must be a relative path")
+    if (opts.throwError) throw Error("'relativePath' must be a relative path")
+    console.error("'relativePath' must be a relative path")
+    return undefined
   }
+
   // Ignore trailing `/` in the relative path
   if (relativePath[relativePath.length - 1] === '/') {
     relativePath = relativePath.slice(0, -1)
@@ -55,9 +63,11 @@ export const getObjectFromRelativePath = (relativePath, currentObj) => {
 
   const matchingObject = relativePath.split('/').reduce(walk, currentObj)
   if (matchingObject) return matchingObject
-  throw Error(
-    `Incorrect relative path '${relativePath}': no object found — current path = '${currentPath}'`,
-  )
+
+  const errorMessage = `Incorrect relative path '${relativePath}': no object found — current path = '${currentPath}'`
+  if (opts.throwError) throw Error(errorMessage)
+  console.error(errorMessage)
+  return undefined
 }
 
 const isAbsolutePath = path => path.startsWith('/')

package/toolbox.js

@@ -27,7 +27,13 @@ export const objectTypes = new Set([...contentObjects, ...onboardingTypes])
 
 export const childTypes = {
   campus: ['signup', 'onboarding', 'piscine', 'module'],
-  signup: ['form-step', 'sign-step', 'upload-step', 'contact-validation-step'],
+  signup: [
+    'form-step',
+    'sign-step',
+    'upload-step',
+    'contact-validation-step',
+    'avatar-step',
+  ],
   onboarding: [
     'games',
     'administration',
@@ -40,6 +46,7 @@ export const childTypes = {
     'sign-step',
     'upload-step',
     'contact-validation-step',
+    'avatar-step',
   ],
   piscine: ['quest', 'exam', 'raid', 'project'],
   exam: ['exercise'],
@@ -182,15 +189,17 @@ export const formatedDuration = (seconds, { noSeconds } = {}) => {
 }
 
 const toDate = date => (date instanceof Date ? date : new Date(date))
-export const toDateFormat = d => {
+export const toDateFormat = (d, isISO = true) => {
   const date = toDate(d)
   const month = (date.getMonth() + 1).toString().padStart(2, '0')
   const day = date.getDate().toString().padStart(2, '0')
 
-  return `${date.getFullYear()}-${month}-${day}`
+  return isISO
+    ? `${date.getFullYear()}-${month}-${day}`
+    : `${day}/${month}/${date.getFullYear()}`
 }
 
-export const toISOStringWithTimeZone = d => toDate(d).toISOString().slice(0, -1)
+export const toISOStringWithTimeZone = d => toDate(d).toISOString()
 
 export const toDateFormatWithTime = (d, separator = 'T') => {
   const date = toDate(d)
@@ -220,7 +229,7 @@ export const monthNames = [
   'Dec',
 ]
 
-const weekDays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+export const weekDays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
 
 const hour = hour => {
   if (hour === 0 || hour === 12) return 12
@@ -256,12 +265,12 @@ const getDateElems = date => {
   return { day, jj, mm, yyyy, hh, min }
 }
 
-export const formatedDateTime = date => {
+export const formatedDateTime = (date, splitter = 'at') => {
   if (!date) return '-'
   if (dateIsPermanent(date)) return '∞'
   const { jj, mm, yyyy, hh, min } = getDateElems(date)
 
-  return `${monthNames[mm]} ${jj}, ${yyyy} at ${hour(hh)}:${minPad(
+  return `${monthNames[mm]} ${jj}, ${yyyy} ${splitter} ${hour(hh)}:${minPad(
     min,
   )} ${suffix(hh)}`
 }
@@ -337,13 +346,12 @@ const toSnakeCase = str =>
 // id card > id-card
 // should be enough for unique usage we have of it in check-refs
 // checked the perfs and it is faster + more secure than using replace(s) + toLowerCase
-const toLowerCase = x => x.toLowerCase()
 export const toKebabCase = str =>
   str
     .match(
       /[A-Z](?=[A-Z][a-z]+[0-9]*[a-z]|\b)|[A-Z]?[a-z]+[0-9]+[a-z]?[A-Z]*|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g,
     )
-    .map(toLowerCase)
+    .map(x => x.toLowerCase())
     .join('-')
 
 const spaceJoin = (_, a, b) => `${a} ${b}`
@@ -481,3 +489,18 @@ export const base64Encode = str => {
 
 export const timePlusDelay = (time, delay) =>
   new Date(new Date(time).getTime() + delay).toISOString()
+
+export const getRecordStatus = record => {
+  if (!isFinished(record.startAt)) return 'starting soon'
+  if (record.endAt && isFinished(record.endAt)) {
+    return 'finished'
+  }
+  if (record.type.isPermanent) return 'permanent'
+  return record.endAt ? 'in progress' : 'unblock required'
+}
+
+export const createFrequencyMap = arr =>
+  arr.reduce((map, item) => {
+    map[item] = (map[item] || 0) + 1
+    return map
+  }, {})