@01-edu/shared 1.0.2 → 1.0.3

package/definitions-checker.js

@@ -0,0 +1,236 @@
+import { childTypes, objectTypes } from './toolbox.js'
+import { attributes, relationAttributes } from './attrs.js'
+
+const normalize = str =>
+  str
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9]+/g, ' ')
+    .trim()
+    .replaceAll(' ', '-')
+
+const assertDef = def => {
+  const {
+    type,
+    name,
+    attrs,
+    children,
+    childrenAttrs,
+    refId,
+    referencePath,
+    ...rest
+  } = def
+  const [extra] = Object.keys(rest)
+  if (extra) {
+    throw Error(
+      `Unexpected property ${extra}, did you mean to define an attribute ?`,
+    )
+  }
+  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 (childrenAttrs) throw Error(`childrenAttrs is no longer supported`)
+
+  for (const [key, value] of Object.entries(attrs)) {
+    if (relationAttributes[key]) {
+      throw Error(
+        `Attr ${key} should be defined in the relation with its parent, not on the object itself.`,
+      )
+    }
+
+    const matches = attributes[key]
+    if (!matches) throw Error(`Undefined attr ${key}`)
+    const attrDefs = matches[type]
+    if (!attrDefs) {
+      const types = Object.keys(matches).join(', ')
+      throw Error(`${type} does not match any of ${types} for attr ${key}`)
+    }
+
+    if (attrDefs.deprecated) {
+      throw Error(`attr ${key} deprecated: ${attrDefs.deprecated}`)
+    }
+  }
+}
+
+// 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 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)
+    child.attrs = { ...child.attrs, ...rest }
+    prev && (prev.next = child)
+    child.prev = prev
+    object.children[key] = child
+  }
+  return object
+}
+
+const assertRelation = (parent, key, relation) => {
+  if (!/^[a-z0-9-]*$/.test(key)) {
+    throw Error(
+      `Invalid key for child ${key} Kebab-case key suggestion: ${normalize(key)}`,
+    )
+  }
+
+  const child = relation.ref
+  const { type } = child
+  const allowedTypes = childTypes[parent.type]
+  if (!allowedTypes.includes(type)) {
+    throw Error(`Type ${type} ${key} is not a possible child`)
+  }
+
+  // Should never happen
+  if (parent.referencePath === child.referencePath) {
+    throw Error(`Self reference in child ${key}`)
+  }
+
+  for (const [key, value] of Object.entries(relation)) {
+    if (key === 'ref') continue
+    const matches = attributes[key]
+    if (matches?.[type]?.restrictive) {
+      throw Error(
+        `Attr ${key} should be defined on the object itself, not in the relation with its parent.`,
+      )
+    }
+    const relMatches = relationAttributes[key]
+    if (!matches && !relMatches) throw Error(`Undefined attr ${key}`)
+    const attrDefs = (relMatches?.[parent.type] || matches)[type]
+    if (!attrDefs) {
+      const types = Object.keys(matches).join(', ')
+      throw Error(`${type} does not match any of ${types} for attr ${key}`)
+    }
+
+    if (attrDefs.deprecated) {
+      throw Error(`attr ${key} deprecated: ${attrDefs.deprecated}`)
+    }
+  }
+}
+
+const checkAttrs = object => {
+  for (const [key, value] of Object.entries(object.attrs)) {
+    try {
+      const attrDefs =
+        relationAttributes[key]?.[object.parent?.type]?.[object.type] ||
+        attributes[key][object.type]
+
+      if (value?.type === 'function') {
+        const fn = attrDefs.functionsByName?.[value.name]
+        if (!fn) throw Error(`function ${value.name} not found for attr ${key}`)
+      } else if (!attrDefs.check(value, object)) {
+        throw Error(`wrong type for attr ${key}`)
+      }
+    } catch (err) {
+      err.parentRef = object.parent?.referencePath
+      err.childRef = object.referencePath
+      err.value = value
+      err.key = key
+      throw err
+    }
+  }
+
+  for (const child of Object.values(object.children)) {
+    checkAttrs(child)
+  }
+}
+
+// TODO: replace by Set.intersection once available in node
+const intersection = (a, b) => {
+  const result = new Set()
+  for (const element of a) {
+    b.has(element) && result.add(element)
+  }
+  return result
+}
+
+const generatePairs = arr => {
+  const result = []
+  let i = -1
+  // Only go up to the second to last element
+  while (++i < arr.length - 1) {
+    let j = i
+    // Start from the next element to avoid duplicates
+    while (++j < arr.length) {
+      result.push([arr[i], arr[j]])
+    }
+  }
+  return result
+}
+
+const isExam = def => def.type === 'exam'
+const assertExams = definitions => {
+  const groups = {}
+  for (const exam of definitions.filter(isExam)) {
+    let prevExamGroup = 0
+    for (const [key, exercise] of Object.entries(exam.children)) {
+      try {
+        const { group } = exercise
+        if (!group) throw Error('missing exam group')
+
+        const groupDiff = group - prevExamGroup
+        prevExamGroup = group
+        if (groupDiff > 1) throw Error('exam must not have gaps in groups')
+        if (groupDiff < 0) {
+          throw Error('exercise must be sorted by group from lower to greater')
+        }
+
+        // exam exercise group should stay consistent across all exams
+        const prevGroup = groups[key]
+        if (prevGroup == null) {
+          groups[key] = group
+        } else if (prevGroup !== group) {
+          throw Error('Exercise used in different exam groups')
+        }
+      } catch (err) {
+        err.exam = exam.referencePath
+        err.exercise = exercise.ref.referencePath
+        throw err
+      }
+    }
+  }
+}
+
+export const checkAndBuildDefinitions = async readDef => {
+  const cache = {}
+  const getDefs = async ([key, relation]) => {
+    const def = cache[key] || (cache[key] = await readDef(key))
+    try {
+      assertDef(def)
+    } catch (err) {
+      err.type = def.type
+      err.referencePath = def.referencePath
+      throw err
+    }
+    relation && (relation.ref = def)
+    const relations = Object.entries(def.children || {}).map(getDefs)
+    return [def, ...(await Promise.all(relations)).flat()]
+  }
+
+  const definitions = await getDefs([])
+
+  // Assert all relations looks ok, possible child / parent, allowed attributes
+  for (const def of definitions) {
+    if (!def.children) continue
+    const allowedTypes = childTypes[def.type]
+    try {
+      for (const entry of Object.entries(def.children)) {
+        assertRelation(def, entry[0], entry[1])
+      }
+    } catch (err) {
+      err.type = def.type
+      err.referencePath = def.referencePath
+      throw err
+    }
+  }
+
+  // Check all attributes in context
+  const root = buildTree(definitions[0])
+  checkAttrs(root)
+  assertExams(definitions)
+
+  return { definitions, root }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@01-edu/shared",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "description": "",
   "scripts": {
@@ -9,10 +9,9 @@
   "files": [
     "./bin/check-definitions.js",
     "./event-utils.js",
-    "./event-utils.js",
     "./lodash.deburr.js",
     "./onboarding.js",
-    "./onboarding.js",
+    "./definitions-checker.js",
     "./path.js",
     "./programming-languages.js",
     "./score.js",