errors.osl

def pruneSiteErrors() (
  array stored = errorDocs.sort("created", db.desc).limit(1100).all()
  for i stored.len (
    if i >= 1000 (
      object entry = stored[i].assert(object)
      errorDocs.deleteOne({_id: entry["_id"]})
    )
  )
)

def shouldIgnoreSiteError(string message) boolean (
  string normalized = message.toLower().strip()
  return normalized == "unsandboxed is not defined" or normalized == "referenceerror: unsandboxed is not defined" or normalized == "can't find variable: unsandboxed"
)

def handleRecordSiteError(*serve.Context c) (
  object body = c.bodyJSON()
  string message = body.message.toStr().strip()
  if message == "" (
    c.badRequest("error message is required")
    return
  )
  if message.len > 2000 (
    message = message.trim(1, 2000)
  )
  if shouldIgnoreSiteError(message) (
    c.json(200, {ok: true, ignored: true})
    return
  )
  string stack = ""
  if body.contains("stack") and body.stack != null (
    stack = body.stack.toStr().trim(1, 20000)
  )
  if stack == "" and body.contains("trace") and body.trace != null (
    stack = body.trace.toStr().trim(1, 20000)
  )
  string url = ""
  if body.contains("url") and body.url != null (
    url = body.url.toStr().strip().trim(1, 2000)
  )
  string projectId = ""
  if body.contains("projectId") and body.projectId != null (
    projectId = body.projectId.toStr().strip().trim(1, 120)
  )
  string kind = "uncaught"
  if body.contains("kind") and body.kind != null (
    kind = body.kind.toStr().toLower().strip().trim(1, 40)
  )
  if kind != "uncaught" and kind != "rejection" and kind != "react" and kind != "manual" (
    kind = "uncaught"
  )
  string viewport = ""
  if body.contains("viewport") and body.viewport != null (
    viewport = body.viewport.toStr().strip().trim(1, 40)
  )
  string appVersion = ""
  if body.contains("version") and body.version != null (
    appVersion = body.version.toStr().strip().trim(1, 120)
  )
  if appVersion == "" and body.contains("appVersion") and body.appVersion != null (
    appVersion = body.appVersion.toStr().strip().trim(1, 120)
  )
  string componentStack = ""
  if body.contains("componentStack") and body.componentStack != null (
    componentStack = body.componentStack.toStr().trim(1, 10000)
  )
  string userAgent = c.header("User-Agent").strip().trim(1, 500)
  string username = c.getString("username")
  object entry = {
    _id: "e" ++ randomString(16),
    message: message,
    stack: stack,
    url: url,
    projectId: projectId,
    kind: kind,
    username: username,
    userAgent: userAgent,
    viewport: viewport,
    appVersion: appVersion,
    componentStack: componentStack,
    created: timestamp,
    resolved: false
  }
  sync.lock("site-errors")
  errorDocs.insertOne(entry)
  pruneSiteErrors()
  sync.unlock("site-errors")
  c.json(201, {ok: true})
)

def handleAdminGetErrors(*serve.Context c) (
  string show = c.query("show").toLower().strip()
  array items = errorDocs.sort("created", db.desc).limit(200).all()
  if show != "all" and show != "resolved" (
    array open = []
    for i items.len (
      object item = items[i].assert(object)
      if item.resolved != true (
        open.append(item)
      )
    )
    items = open
  ) else if show == "resolved" (
    array resolved = []
    for i items.len (
      object item = items[i].assert(object)
      if item.resolved == true (
        resolved.append(item)
      )
    )
    items = resolved
  )
  number openCount = errorDocs.where("resolved", db.equal, false).count()
  c.json(200, {ok: true, errors: items, openCount: openCount})
)

def handleAdminResolveSiteError(*serve.Context c) (
  object body = c.bodyJSON()
  string id = body.id.toStr()
  if id == "" (
    c.badRequest("error id is required")
    return
  )
  boolean resolved = true
  if body.contains("resolved") (
    resolved = body.resolved == true
  )
  object entry = errorDocs.findById(id)
  if entry.len == 0 (
    c.notFound("error not found")
    return
  )
  entry.resolved = resolved
  entry.resolvedBy = c.getString("username")
  entry.resolvedAt = timestamp
  if putDocument(errorDocs, id, entry) (
    c.json(200, {ok: true})
    return
  )
  c.internalError("could not update error")
)

def deleteAllSiteErrors() number (
  sync.lock("site-errors")
  array entries = errorDocs.all()
  for i entries.len (
    object entry = entries[i].assert(object)
    errorDocs.deleteOne({_id: entry["_id"]})
  )
  sync.unlock("site-errors")
  return entries.len
)

def handleAdminDeleteAllSiteErrors(*serve.Context c) (
  number deleted = deleteAllSiteErrors()
  c.json(200, {ok: true, deleted: deleted})
)

def handleAdminDeleteSiteError(*serve.Context c) (
  object body = c.bodyJSON()
  string id = body.id.toStr()
  if id == "" (
    c.badRequest("error id is required")
    return
  )
  if errorDocs.findById(id).len == 0 (
    c.notFound("error not found")
    return
  )
  errorDocs.deleteOne({_id: id})
  c.json(200, {ok: true})
)