@01-edu/shared 2.0.5 → 2.0.6

package/definitions-checker.js

@@ -1,233 +0,0 @@
-import { attributes, relationAttributes } from './attrs.js'
-import { childTypes, objectTypes } from './object-structure.ts'
-
-const normalize = str =>
-  str
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9]+/g, ' ')
-    .trim()
-    .replaceAll(' ', '-')
-
-const assertDef = def => {
-  const {
-    type,
-    name,
-    attrs,
-    children: _children,
-    childrenAttrs,
-    referencePath: _referencePath,
-    ...rest
-  } = def
-  const [extra] = Object.keys(rest)
-  if (extra) {
-    throw Error(
-      `Unexpected property ${extra}, did you mean to define an attribute ?`,
-    )
-  }
-  if (type === 'campus') throw Error(`Campuses can't be defined in definitions`)
-  if (!objectTypes.has(type)) throw Error(`Invalid type property`)
-  if (!name || typeof name !== 'string') throw Error(`Invalid name 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 || {})) {
-    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}`)
-    }
-  }
-}
-
-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, (depth || 0) + 1)
-    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 of Object.keys(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)
-  }
-}
-
-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]) => {
-    let def
-    try {
-      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
-    }
-    try {
-      assertDef(def)
-    } catch (err) {
-      err.type = def.type
-      err.referencePath = def.referencePath
-      throw err
-    }
-    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
-    }
-  }
-
-  const definitions = await getDefs([])
-
-  // Assert all relations looks ok, possible child / parent, allowed attributes
-  for (const def of definitions) {
-    if (!def.children) continue
-    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/event-utils.js

@@ -1,58 +0,0 @@
-export const SEC = 1000
-export const MIN = 60 * SEC
-export const HOUR = 60 * MIN
-export const DAY = 24 * HOUR
-export const WEEK = 7 * DAY
-
-export const numTime = date => new Date(date).getTime()
-export const numToISOString = number =>
-  number ? new Date(number).toISOString() : Number.NaN
-export const getChildRegistrationStartAt = (parentEventStartAt, child) => {
-  const {
-    startAfter = 0,
-    eventStartDelay = 0,
-    registrationDuration,
-  } = child.attrs
-  return (
-    numTime(parentEventStartAt) +
-    (startAfter - (eventStartDelay + registrationDuration)) * MIN
-  )
-}
-export const getChildRegistrationEndAt = (parentEventStartAt, child) => {
-  const { startAfter = 0, eventStartDelay = 0 } = child.attrs
-  return numTime(parentEventStartAt) + (startAfter - eventStartDelay) * MIN
-}
-export const getChildEventStartAt = (parentEventStartAt, { attrs }) =>
-  numTime(parentEventStartAt) + (attrs.startAfter || 0) * MIN
-
-export const getChildEventEndAt = (parentEventStartAt, child) => {
-  const { startAfter = 0, eventDuration } = child.attrs
-  return numTime(parentEventStartAt) + (startAfter + eventDuration) * MIN
-}
-
-export const getChildEventInfo = (parentEventStartAt, child) => ({
-  startAt: numToISOString(
-    getChildRegistrationStartAt(parentEventStartAt, child),
-  ),
-  endAt: numToISOString(getChildRegistrationEndAt(parentEventStartAt, child)),
-  eventJoinedAt: numToISOString(
-    getChildEventStartAt(parentEventStartAt, child),
-  ),
-  eventEndAt: numToISOString(getChildEventEndAt(parentEventStartAt, child)),
-})
-
-// NB: useful when creating event for first time (add event)
-export const getEndOfEvent = ({ eventJoinedAt }, object) =>
-  numTime(eventJoinedAt) + object.attrs.eventDuration * MIN
-
-// TODO: rename this fn - also used for project
-// the best would be to find a word to label the child items that are not events
-export const getQuestStartAt = (parentEventStartAt, quest) =>
-  numTime(parentEventStartAt) + quest.attrs.delay
-export const getQuestExtraEndAt = (questStartAt, quest) => {
-  const { scopeExtraDuration, duration } = quest.attrs
-  return questStartAt + ((scopeExtraDuration || 0) + (duration || 1)) * DAY
-}
-
-// TODO: rename isPassed
-export const isFinished = date => new Date(date).getTime() < Date.now()

package/graph.js

@@ -1,96 +0,0 @@
-const isCoreObj = (contentShape, coreKey) =>
-  typeof contentShape === 'object' && Object.keys(contentShape)[0] === coreKey
-const isSatteliteObj = (contentShape, satteliteKey) =>
-  typeof contentShape === 'object' &&
-  Object.values(contentShape)[0].some(sat => sat === satteliteKey)
-
-export const getCoreSattelites = (coreObject, objectsList) => {
-  const { key, parent } = coreObject
-  const objects = objectsList || Object.values(parent.children)
-  const sattelitesSection = parent.attrs.graph.innerCircle.find(
-    s => s.type === 'slice' && s.innerArc.contents.find(c => isCoreObj(c, key)),
-  )
-  if (!sattelitesSection) return []
-  const sattelitesObject = sattelitesSection.innerArc.contents.find(c =>
-    isCoreObj(c, key),
-  )
-  const sattelitesList = new Set(...Object.values(sattelitesObject))
-
-  return objects.filter(o => sattelitesList.has(o.key))
-}
-
-export const getCoreOfSattelite = (satteliteObject, objectsList) => {
-  const { key, parent } = satteliteObject
-  const objects = objectsList || Object.values(parent.children)
-  const sattelitesSection = parent.attrs.graph?.innerCircle?.find(
-    s =>
-      s.type === 'slice' &&
-      s.innerArc?.contents.find(c => isSatteliteObj(c, key)),
-  )
-  if (!sattelitesSection) return undefined
-  const coreObject = sattelitesSection.innerArc.contents.find(c =>
-    isSatteliteObj(c, key),
-  )
-
-  return objects.filter(o => o.key === Object.keys(coreObject)[0])
-}
-
-export const flatGraphContents = graph => [
-  ...(graph.centralPoint ? [graph.centralPoint] : []),
-  ...(graph.innerCircle || []).flatMap(section =>
-    section.type === 'slice'
-      ? [
-          ...(section.entryPoint ? [section.entryPoint] : []),
-          ...(section.innerArc?.contents || []).flatMap(c =>
-            typeof c === 'string' ? c : Object.entries(c)[0].flat(),
-          ),
-          ...(section.outerArcs || []).flatMap(arc => arc.contents || []),
-        ]
-      : section.contents,
-  ),
-  ...(graph.middleCircle || []).flatMap(arc => arc.contents || []),
-  ...(graph.outerCircle || []).flatMap(arc => arc.contents || []),
-]
-
-// WARNING: without central point (for linear graph, already destructured)
-export const flatAtomeAndCoreContents = graph => [
-  ...(graph.innerCircle || []).flatMap(section =>
-    section.type === 'slice'
-      ? [
-          ...(section.entryPoint ? [section.entryPoint] : []),
-          ...(section.innerArc?.contents || []).flatMap(c =>
-            typeof c === 'string' ? c : Object.keys(c)[0],
-          ),
-          ...(section.outerArcs || []).flatMap(arc => arc.contents || []),
-        ]
-      : section.contents,
-  ),
-  ...(graph.middleCircle || []).flatMap(arc => arc.contents || []),
-  ...(graph.outerCircle || []).flatMap(arc => arc.contents || []),
-]
-
-export const limitations = {
-  LINE: {
-    maxLinesCount: 6,
-    maxContentsCount: 7, // 7 contents max split along a single line
-  },
-  SLICE: {
-    maxSlicesCount: 4,
-    innerCircle: {
-      maxSubContentsCount: 5, // 5 sub-contents max by content
-      maxContentsCount: 30, // 30 contents max spread evenly over the number of inner cirlces of slices
-    },
-    outerArc: {
-      maxArcsCount: 2,
-      maxContentsCount: 10, // 10 contents max spread evenly over the 1 or 2 outer arcs
-    },
-  },
-  MIDDLE_CIRCLE: {
-    maxArcsCount: 8,
-    maxContentsCount: 70, // 70 contents max spread evenly over the number of arcs
-  },
-  OUTER_CIRCLE: {
-    maxArcsCount: 9,
-    maxContentsCount: 90, // 90 contents max spread evenly over the number of arcs
-  },
-}

package/hasura-core.js

@@ -1,217 +0,0 @@
-export class HasuraError extends Error {
-  constructor({ extensions, message, ...props }, cause) {
-    super(message, cause)
-    Object.assign(this, props)
-    Object.assign(this, extensions)
-    Error.captureStackTrace?.(this, HasuraError)
-  }
-}
-
-export const initClient = ({ debug, address, log, ...params }) => {
-  log || (log = debug ? console.debug : () => {})
-  const handlers = new Map()
-  const subscribers = new Map()
-
-  const getId = () => {
-    const id = Math.random().toString(36).slice(2)
-    return handlers.has(id) ? getId() : id
-  }
-
-  const rejectAllPending = err => {
-    subscribers.clear() // TODO: store subscribers query and re-trigger them
-    for (const [id, { reject, noCleanup }] of handlers) {
-      noCleanup || activeQueries.delete(id)
-      handlers.delete(id)
-      reject(err)
-    }
-    return err
-  }
-
-  const end = (handler, props = {}) => {
-    props.duration = Date.now() - handler.start
-    props.size = handler.size
-    props.name = handler.query
-    props.id = handler.id
-    log('query', props)
-    handlers.delete(handler.id)
-    handler.noCleanup || activeQueries.delete(handler.id)
-  }
-
-  const messageFail = (handler, payload, id) => {
-    if (!handler) return log('missing-handler', { id, type: 'error' })
-
-    end(handler, { payload, type: 'error' })
-    handlers.delete(id)
-    return handler.reject(
-      new HasuraError(payload.errors[0], debug && { cause: handler.cause }),
-    )
-  }
-
-  const handleMessage = (data, resolve, reject) => {
-    if (data === '{"type":"ka"}') return // ignore keep alive
-
-    const { type, payload, id } = JSON.parse(data)
-    const handler = handlers.get(id)
-    handler && (handler.size += data.length)
-
-    log('raw', data)
-
-    switch (type) {
-      case 'connection_ack': {
-        return resolve(payload)
-      }
-
-      case 'connection_error': {
-        const err = rejectAllPending(new HasuraError({ errors: [payload] }))
-        return reject(err)
-      }
-
-      case 'data': {
-        if (payload.errors) return messageFail(handler, payload, id)
-
-        const sub = subscribers.get(id)
-        if (!sub) {
-          return handler
-            ? (handler.payload = payload)
-            : log('missing-handler', { id, type: 'error' })
-        }
-
-        sub(payload.data)
-        if (handler) {
-          end(handler, { type, payload })
-          handler.resolve()
-        }
-
-        return
-      }
-
-      case 'error': {
-        return messageFail(handler, payload, id)
-      }
-
-      case 'complete': {
-        if (!handler) return
-        end(handler, { type, payload })
-        return handler.resolve(handler.payload?.data)
-      }
-    }
-  }
-
-  const handleFail = (event, type) =>
-    rejectAllPending(
-      new HasuraError({ message: `WebSocket connection ${type}`, event }),
-    )
-
-  let ws = new WebSocket(address, 'graphql-ws')
-  let activeQueries = new Map()
-  const exec = async (id, payload, name, noCleanup) => {
-    await connection
-    const handler = {
-      id,
-      size: 0,
-      query: name,
-      start: Date.now(),
-      noCleanup,
-    }
-    const result = new Promise((resolve, reject) => {
-      handler.resolve = resolve
-      handler.reject = reject
-    })
-    debug && (handler.cause = Error('hasuraClient.exec'))
-    handlers.set(id, handler)
-    activeQueries.set(id, { payload, name })
-    log('start', { id, payload })
-    ws.send(`{"type":"start","id":"${id}","payload":${payload}}`)
-    return result
-  }
-  const runFromString = (payload, name) => exec(getId(), payload, name)
-
-  const subscribeFromString = (sub, payload, name) => {
-    const id = getId()
-    subscribers.set(id, sub)
-
-    return {
-      execution: exec(id, payload, name, true),
-      unsubscribe: () => {
-        subscribers.delete(id)
-        activeQueries.delete(id)
-        log('stop', { id })
-        ws.send(`{"type":"stop","id":"${id}"}`)
-      },
-    }
-  }
-
-  let connected = false
-  const getConnection = async () => {
-    connected = false
-    const { promise, resolve, reject } = Promise.withResolvers()
-    const onError = () => reject(handleFail(undefined, 'failed'))
-    const onClose = event =>
-      reject(handleFail({ code: event.code, reason: event.reason }, 'close'))
-    ws.addEventListener('error', onError, { once: true })
-    ws.addEventListener('close', onClose, { once: true })
-    ws.addEventListener('message', event =>
-      handleMessage(event.data, resolve, reject),
-    )
-    try {
-      await promise
-      return (connected = true)
-    } finally {
-      ws.removeEventListener('error', onError)
-      ws.removeEventListener('close', onClose)
-    }
-  }
-
-  let connection = getConnection()
-
-  const connect = async ({ adminSecret, token, role, headers }) => {
-    const previousActiveQueries = activeQueries
-    const reload = connected
-    if (reload) {
-      ws.close()
-      ws = new WebSocket(address, 'graphql-ws')
-      connection = getConnection()
-      activeQueries = new Map()
-    }
-
-    if (!ws.readyState) {
-      await new Promise(s => ws.addEventListener('open', s, { once: true }))
-    }
-
-    const payload = {
-      headers: adminSecret
-        ? { 'x-hasura-admin-secret': adminSecret, ...headers }
-        : { Authorization: `Bearer ${token}`, ...headers },
-    }
-
-    role && (payload.headers['x-hasura-role'] = role)
-
-    ws.send(JSON.stringify({ type: 'connection_init', payload }))
-
-    reload &&
-      connection.then(() => {
-        // re exec all previous active queries
-        for (const [id, { payload, name }] of previousActiveQueries) {
-          exec(id, payload, name)
-        }
-      })
-
-    return connection
-  }
-
-  if (params.adminSecret || params.token) {
-    connect(params)
-  }
-
-  return {
-    ws,
-    connect,
-    connection,
-    runFromString,
-    subscribeFromString,
-    run: (query, variables) =>
-      runFromString(JSON.stringify({ query, variables })),
-    subscribe: (sub, query, variables) =>
-      subscribeFromString(sub, JSON.stringify({ query, variables })),
-  }
-}