validateSchedule.js

const TOP_LEVEL_ARRAYS = ["sessions", "speakers", "session_types", "rooms", "tags"]
const OPTIONAL_SESSION_STRINGS = ["uri", "qa", "slide", "live", "record", "language", "co_write"]

function isObject(value) {
  return value != null && typeof value === "object" && !Array.isArray(value)
}

function isNonEmptyString(value) {
  return typeof value === "string" && value.length > 0
}

function validateString(value, path, errors, { nonEmpty = false } = {}) {
  if (typeof value !== "string" || (nonEmpty && value.length === 0)) {
    errors.push(`${path}: expected ${nonEmpty ? "non-empty " : ""}string`)
  }
}

function validateOptionalString(value, path, errors, { nonEmpty = false } = {}) {
  if (value != null) {
    validateString(value, path, errors, { nonEmpty })
  }
}

function validateDateTime(value, path, errors) {
  validateString(value, path, errors)
  if (typeof value === "string" && Number.isNaN(Date.parse(value))) {
    errors.push(`${path}: expected parseable date-time string`)
  }
}

function validateStringList(value, path, errors) {
  if (!Array.isArray(value)) {
    errors.push(`${path}: expected array`)
    return
  }

  value.forEach((item, index) => validateString(item, `${path}[${index}]`, errors))
}

function validateLocalized(value, path, fields, errors) {
  if (!isObject(value)) {
    errors.push(`${path}: expected object`)
    return
  }

  for (const field of fields) {
    validateString(value[field], `${path}.${field}`, errors)
  }
}

function validateCollectionIds(items, collection, errors) {
  const ids = new Set()

  items.forEach((item, index) => {
    const path = `$.${collection}[${index}].id`
    if (!isObject(item)) {
      return
    }
    if (!isNonEmptyString(item.id)) {
      return
    }
    if (ids.has(item.id)) {
      errors.push(`${path}: duplicate id "${item.id}"`)
    }
    ids.add(item.id)
  })

  return ids
}

function validateNamedEntity(item, path, errors) {
  if (!isObject(item)) {
    errors.push(`${path}: expected object`)
    return
  }

  validateString(item.id, `${path}.id`, errors, { nonEmpty: true })
  validateLocalized(item.zh, `${path}.zh`, ["name"], errors)
  validateLocalized(item.en, `${path}.en`, ["name"], errors)
}

function validateSpeaker(speaker, path, errors) {
  if (!isObject(speaker)) {
    errors.push(`${path}: expected object`)
    return
  }

  validateString(speaker.id, `${path}.id`, errors, { nonEmpty: true })
  validateString(speaker.avatar, `${path}.avatar`, errors)
  validateLocalized(speaker.zh, `${path}.zh`, ["name", "bio"], errors)
  validateLocalized(speaker.en, `${path}.en`, ["name", "bio"], errors)
}

function validateSession(session, path, errors) {
  if (!isObject(session)) {
    errors.push(`${path}: expected object`)
    return
  }

  validateString(session.id, `${path}.id`, errors, { nonEmpty: true })
  validateString(session.room, `${path}.room`, errors, { nonEmpty: true })
  validateOptionalString(session.type, `${path}.type`, errors, { nonEmpty: true })
  validateDateTime(session.start, `${path}.start`, errors)
  validateDateTime(session.end, `${path}.end`, errors)
  validateLocalized(session.zh, `${path}.zh`, ["title", "description"], errors)
  validateLocalized(session.en, `${path}.en`, ["title", "description"], errors)
  validateStringList(session.speakers, `${path}.speakers`, errors)
  validateStringList(session.tags, `${path}.tags`, errors)

  if (session.broadcast != null) {
    validateStringList(session.broadcast, `${path}.broadcast`, errors)
  }

  for (const field of OPTIONAL_SESSION_STRINGS) {
    if (session[field] != null) {
      validateString(session[field], `${path}.${field}`, errors)
    }
  }
}

function checkReference(id, ids, path, target, diagnostics) {
  if (typeof id !== "string" || id.length === 0) {
    return
  }
  if (!ids.has(id)) {
    diagnostics.push(`${path}: unknown ${target} id "${id}"`)
  }
}

function validateReferences(schedule, ids, errors, warnings) {
  schedule.sessions.forEach((session, sessionIndex) => {
    if (!isObject(session)) {
      return
    }

    const path = `$.sessions[${sessionIndex}]`
    checkReference(session.room, ids.rooms, `${path}.room`, "room", errors)
    checkReference(session.type, ids.session_types, `${path}.type`, "session_type", warnings)

    if (Array.isArray(session.speakers)) {
      session.speakers.forEach((speakerId, index) =>
        checkReference(speakerId, ids.speakers, `${path}.speakers[${index}]`, "speaker", warnings)
      )
    }

    if (Array.isArray(session.tags)) {
      session.tags.forEach((tagId, index) => checkReference(tagId, ids.tags, `${path}.tags[${index}]`, "tag", warnings))
    }
  })
}

export function validateSchedule(schedule, { strict = false } = {}) {
  const errors = []
  const warnings = []

  if (!isObject(schedule)) {
    return { valid: false, errors: ["$: expected object"], warnings }
  }

  for (const collection of TOP_LEVEL_ARRAYS) {
    if (!Array.isArray(schedule[collection])) {
      errors.push(`$.${collection}: expected array`)
    }
  }

  const collections = Object.fromEntries(
    TOP_LEVEL_ARRAYS.map((collection) => [collection, Array.isArray(schedule[collection]) ? schedule[collection] : []])
  )

  collections.sessions.forEach((session, index) => validateSession(session, `$.sessions[${index}]`, errors))
  collections.speakers.forEach((speaker, index) => validateSpeaker(speaker, `$.speakers[${index}]`, errors))

  for (const collection of ["session_types", "rooms", "tags"]) {
    collections[collection].forEach((item, index) => validateNamedEntity(item, `$.${collection}[${index}]`, errors))
  }

  const ids = {
    sessions: validateCollectionIds(collections.sessions, "sessions", errors),
    speakers: validateCollectionIds(collections.speakers, "speakers", errors),
    session_types: validateCollectionIds(collections.session_types, "session_types", errors),
    rooms: validateCollectionIds(collections.rooms, "rooms", errors),
    tags: validateCollectionIds(collections.tags, "tags", errors),
  }

  validateReferences(collections, ids, errors, warnings)

  return { valid: errors.length === 0 && (!strict || warnings.length === 0), errors, warnings }
}

export function assertValidSchedule(schedule, options) {
  const result = validateSchedule(schedule, options)
  if (!result.valid) {
    throw new Error([...result.errors, ...result.warnings].join("\n"))
  }
  return schedule
}