@01-edu/shared 2.0.5 → 2.0.7

package/attrs.js

@@ -1,423 +0,0 @@
-import { attrs, relationAttrs } from './attrs-defs.js'
-import { languages } from './languages.js'
-import { mapEntries, mapValues } from './toolbox.js'
-
-// ⚡ description placeholder
-
-const typeCheckers = {
-  boolean: b => typeof b === 'boolean',
-  number: n => typeof n === 'number',
-  string: s => typeof s === 'string',
-  object: o => typeof o === 'object' && o !== null,
-  array: Array.isArray,
-}
-
-const determinType = value => {
-  if (Array.isArray(value)) return 'array'
-  if (typeof value === 'object' && value !== null) return value.type || 'object'
-  return typeof value
-}
-const typeChecker = (defs, value, object, key) => {
-  const { type, check, options } = defs
-
-  if (value == null) {
-    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}`)
-  }
-
-  if (!type) throw Error(`attribute type definition is missing for ${key}`)
-
-  if (value?.type === 'function') {
-    if (defs.functionsByName[value.name]) return true
-    throw Error(`function associated not allowed for ${key}`)
-  }
-
-  // if a check is defined and don't pass, reject
-  check?.(value, object, key)
-
-  if (options) {
-    const opts =
-      typeof options === 'function' ? options(object, value) : options
-    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(', ')}`,
-        )
-      }
-    }
-  }
-
-  // basic case
-  if (typeCheckers[type]) {
-    if (!typeCheckers[type](value)) throw Error(`Expect ${type} for ${key}`)
-    return true
-  }
-
-  // complex cases: array
-  if (Array.isArray(type)) {
-    if (!Array.isArray(value)) {
-      throw Error(`invalid attribute value: expects an array for ${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 => [
-          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 || types[determinType(v)]
-
-      if (!subdefs) {
-        err.details = {
-          label: 'Unknown structure',
-          err: Error('no type matches the value'),
-        }
-        throw err
-      }
-      try {
-        typeChecker(subdefs, v, object, key)
-      } catch (error) {
-        err.details = error.details || {
-          label: subdefs.label || error.label,
-          err: error,
-        }
-        throw err
-      }
-    }
-
-    // TODO: check "one of" also one day - meaning there is no duplicate
-
-    return true
-  }
-
-  if (typeof type !== 'object') throw Error('invalid attribute type definition')
-
-  if (typeof value !== 'object' || value === null) {
-    throw Error('invalid attribute value: expects an object')
-  }
-
-  // then is necessarily an object. Let's check!
-  const typeEntries = Object.entries(type)
-
-  // check that every key fulfilled is defined in the type definitions
-  const invalidKey = Object.keys(value).find(key => !type[key])
-  if (invalidKey) throw Error(`${invalidKey} is invalid.`)
-
-  for (const [key, defs] of typeEntries) {
-    typeChecker(defs, value[key], object, key)
-  }
-  return true
-}
-
-// 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 */) => ({
-    ...defs,
-    check: (value, object) => typeChecker(defs, value, object, attrKey),
-  })),
-])
-
-export const relationAttributes = mapEntries(
-  relationAttrs,
-  ([attrKey, byParent]) => [
-    attrKey,
-    mapValues(byParent, (matches /* parentType */) =>
-      mapValues(matches, (defs /* childType */) => ({
-        ...defs,
-        check: (value, object) => typeChecker(defs, value, object, attrKey),
-      })),
-    ),
-  ],
-)
-
-// 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 = {}
-
-const languagesEntries = Object.entries(languages)
-for (const [name, matches] of Object.entries(attributes)) {
-  for (const [type, defs] of Object.entries(matches)) {
-    const ofType = attrsByType[type] || (attrsByType[type] = {})
-    ofType[name] = defs
-    // handle translations: generate translation attrs and required status
-    const { label, ...restDefs } = defs
-    if (defs.functionsByName?.translate) {
-      // 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}`
-        ofType[`${name}-${code}`] = {
-          ...restDefs,
-          label: newLabel,
-          lgCode: code,
-          required: false,
-        }
-      }
-    }
-  }
-}
-
-// map from attrs[name][parentType][childType]
-// to attrs[parentType][childType][name]
-export const relationAttrsByParentType = {}
-for (const [name, byParent] of Object.entries(relationAttributes)) {
-  for (const [parentType, byChild] of Object.entries(byParent)) {
-    for (const [childType, defs] of Object.entries(byChild)) {
-      const ofParentType =
-        relationAttrsByParentType[parentType] ||
-        (relationAttrsByParentType[parentType] = {})
-      const ofParentChildType =
-        ofParentType[childType] || (ofParentType[childType] = {})
-      ofParentChildType[name] = defs
-      // for now, there is no relation attr that is translatable
-      // if it is created one day, add handling of translations here
-    }
-  }
-}
-const attrsEntriesByType = mapValues(attrsByType, Object.entries)
-const relAttrsEntriesByParentType = mapValues(
-  relationAttrsByParentType,
-  byParent => mapValues(byParent, Object.entries),
-)
-export const getDefaultAttrsEntries = object =>
-  attrsEntriesByType[object.type] || []
-export const getDefaultRelAttrsEntries = (parentType, childType) =>
-  relAttrsEntriesByParentType[parentType]?.[childType] || []
-
-export const getDefaultAttrs = object => attrsByType[object.type]
-export const getDefaultRelAttrs = (parentType, childType) =>
-  relationAttrsByParentType[parentType]?.[childType]
-
-const findDefaultOrNamedFunction = (value, defs) => {
-  // Should be true only for required impure default value functions
-  if (value === undefined || value === null) return defs.required && defs.value
-  if (value.type !== 'function') return
-  // Otherwise we only care about when the default function was overridden
-  // by another impure function
-
-  return defs.functionsByName?.[value.name]
-}
-
-const applyDefs = (key, value, defs, object, getUser) => {
-  // xp, child.attrs.rewards, defs.type.xp, object
-  // reward, child.attrs, defs, object
-  if (value === undefined || value === null) return
-  const fn = findDefaultOrNamedFunction(value[key], defs)
-  if (typeof fn === 'function') {
-    if (getUser) {
-      Object.defineProperty(value, key, {
-        get: () => fn(object, getUser(), key),
-        enumerable: true,
-      })
-    } else if (fn.name === 'translate') {
-      // if we don't have a user, assume english language
-      value[key] = value[`${key}-en`]
-    }
-  }
-}
-
-const expandAttr = (key, value, defs, object, getUser) => {
-  const isFunction = value[key]?.type === 'function'
-  if (Array.isArray(defs.type) && value[key] && !isFunction) {
-    // handle multiple sub-types defs for array items
-    // there can be different subtypes defs of type object,
-    // as long as they all have a type property (mandatory - to distinguish def to check)
-    // and one subtype def for each primary data type
-    const types =
-      defs.type.length > 1 &&
-      Object.fromEntries(defs.type.map(t => [t.type.type?.value || t.type, t]))
-
-    for (let i = 0; i < value[key].length; i++) {
-      let def
-      if (types) {
-        const isObject = typeof value[key][i] === 'object'
-
-        // when type is set to "object" for items that cannot be defined in attrs because
-        // the key cannot be known (like types.graphArcContentWithSubContents)
-        const typeCouldNotBeDefined = isObject && Boolean(types.object)
-
-        const invalidType =
-          !value[key][i].type || typeof value[key][i].type !== 'string'
-        const allowedTypes = Object.keys(types).join(',').slice(0, -1)
-
-        if (isObject && invalidType && !typeCouldNotBeDefined) {
-          console.warn(
-            `Type not allowed. Object item for ${key} array (#${i} item) must have one of these "type" property: ${allowedTypes}.`,
-          )
-        }
-
-        def = isObject ? types[value[key][i].type] : types[typeof value[key][i]]
-
-        if (!def && !typeCouldNotBeDefined) {
-          console.warn(
-            `Missing type definition. Object item for ${key} array (#${i} item) must have one of these "type" property: ${allowedTypes}.`,
-          )
-        }
-      }
-
-      expandAttr(i, value[key], def || defs.type[0], object, getUser)
-    }
-  } else if (typeof defs.type === 'object' && value[key] && !isFunction) {
-    for (const [childKey, subDefs] of Object.entries(defs.type)) {
-      expandAttr(childKey, value[key], subDefs, object, getUser)
-    }
-  } else {
-    applyDefs(key, value, defs, object, getUser)
-  }
-}
-
-// same as the `expandDynamicAttrs` this function would resolve dynamic attributes
-// the special use of this function is that we can resolve certain attributes
-// by providing a filter function
-export const partialExpandDynamicAttrs = (object, getUser, filterFn) => {
-  if (!object.children) return (object.children = {})
-  if (!Object.keys(object.children).length) return
-
-  const defautlAttrs = getDefaultAttrsEntries(object)
-  const filteredDefaultAttrs = defautlAttrs.filter(filterFn)
-
-  processAttributes(filteredDefaultAttrs, object, getUser)
-  let prev
-  for (const child of Object.values(object.children)) {
-    // we only add the parent if it does not exist
-    if (!child.parent) child.parent = object
-    prev && (prev.next = child) && (child.prev = prev)
-    prev = child
-
-    const childDefaultAttrs = getDefaultAttrsEntries(child)
-    const childRelAttrs = getDefaultRelAttrsEntries(object.type, child.type)
-    const [filteredChildAttrs, filteredRelAttrs] = [
-      childDefaultAttrs.filter(filterFn),
-      childRelAttrs.filter(filterFn),
-    ]
-
-    // apply missing default functions
-    // a function can only be missing if it require the user,
-    // the event or current time
-    processAttributes(filteredChildAttrs, child, getUser)
-    processAttributes(filteredRelAttrs, child, getUser)
-    partialExpandDynamicAttrs(child, getUser, filterFn)
-  }
-}
-
-// this function allows us to resolve dynamic attributes
-// by converting them into functions that can be re-evaluated
-// this enables attributes to return updated values when re-checked
-// without requiring additional api queries
-// so the result can be recalculated as needed
-export const expandDynamicAttrs = (object, getUser) => {
-  if (!object.children) return (object.children = {})
-  if (!Object.keys(object.children).length) return
-
-  const defautlAttrs = getDefaultAttrsEntries(object)
-
-  processAttributes(defautlAttrs, object, getUser)
-  let prev
-  for (const child of Object.values(object.children)) {
-    child.parent = object
-    prev && (prev.next = child) && (child.prev = prev)
-    prev = child
-
-    const childDefaultAttrs = getDefaultAttrsEntries(child)
-    const childRelAttrs = getDefaultRelAttrsEntries(object.type, child.type)
-
-    // apply missing default functions
-    // a function can only be missing if it require the user,
-    // the event or current time
-    processAttributes(childDefaultAttrs, child, getUser)
-    processAttributes(childRelAttrs, child, getUser)
-    expandDynamicAttrs(child, getUser)
-  }
-}
-
-const processAttributes = (attrEntries, targetObject, getUser) => {
-  for (const [key, defs] of attrEntries) {
-    if (targetObject.attrs[key] === null) {
-      console.warn(
-        `value is null for ${targetObject.name} - ${key} - ${targetObject.id}`,
-      )
-    }
-    expandAttr(key, targetObject.attrs, defs, targetObject, getUser)
-  }
-}
-
-export { attrs, relationAttrs }

package/bin/check-definitions.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-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`
-  const def = JSON.parse(await readFile(path, 'utf8'))
-  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
-    case 'raid': {
-      const audit = (def.attrs.validations || []).find(isAudit)
-      if (!audit) {
-        throw Error('project and raid must have an audit validation specified')
-      }
-      if (audit.form) {
-        throw Error(
-          'audit form attribute is automatically set to be ./audit/README.md, do not specify it',
-        )
-      }
-      audit.form = `content/${key}/audit/README.md`
-      await stat(audit.form)
-    }
-    case 'exercise': {
-      if (def.attrs.subject) {
-        throw Error(
-          'subject attribute is automatically set to be ./README.md, do not specify it',
-        )
-      }
-      def.attrs.subject = `content/${key}/README.md`
-      await stat(def.attrs.subject)
-    }
-  }
-
-  return def
-}
-
-const runChecks = async () => {
-  try {
-    return await checkAndBuildDefinitions(readDef)
-  } catch ({ message, stack, ...props }) {
-    console.error(message)
-    console.error(props)
-  }
-}
-
-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()
-  }
-} else if (!(await runChecks())) {
-  process.exit(1)
-}
-
-console.log('All checks passed, no errors')
-// Extra checks:
-// - Orphan files (defs files not referenced anywhere)