parseReferenceType() — supabase Function Reference

Source Code

apps/docs/features/docs/Reference.typeSpec.ts lines 694–783

function parseReferenceType(type: any, map: Map<number, any>, typeArguments?: any, debug = false) {
  if (type.dereferenced?.type) {
    return delegateParsing(type, type.dereferenced.type, map)
  }

  if (type.dereferenced?.kindString) {
    return delegateParsing(type, type.dereferenced, map)
  }

  if (type.refersToTypeParameter === true && typeArguments?.[0]) {
    return delegateParsing(type, typeArguments?.[0], map)
  }

  if (
    type.package === 'typescript' &&
    (type.name === 'Record' || type.qualifiedName === 'Record')
  ) {
    return parseRecordType(type, map)
  }

  if (
    type.package === 'typescript' &&
    (type.name === 'Promise' || type.qualifiedName === 'Promise')
  ) {
    return parsePromiseType(type, map)
  }

  if (
    type.package === 'typescript' &&
    (type.name === 'Extract' || type.qualifiedName === 'Extract')
  ) {
    return parseExtractType(type, map)
  }

  if (type.package === 'typescript' && (type.name === 'Pick' || type.qualifiedName === 'Pick')) {
    return parsePickType(type, map)
  }

  // If we still haven't produced a meaningful type, try looking up the reference
  const referenced = map.get(type.id ?? type.target) // became target in newer versions of tsdoc
  if (referenced) {
    const maybeType =
      typeof referenced.type === 'object' && 'type' in referenced.type
        ? /* need to go down a level */ delegateParsing(
            type,
            referenced.type,
            map,
            typeArguments ?? type.typeArguments
          )
        : delegateParsing(type, referenced, map, typeArguments ?? type.typeArguments)

    if (maybeType) {
      return maybeType
    } else if (isNewTypedoc(referenced) && referenced.kind === KIND_INTERFACE) {
      return parseInterface(referenced, map, typeArguments ?? type.typeArguments)
    } else if (isNewTypedoc(referenced) && referenced.kind === KIND_CLASS) {
      // Class is too complicated to display here, just return its name
      return {
        type: 'nameOnly',
        name: referenced.name,
      }
    }
  }

  // We produced nothing, let's just return some strings in case they're in any
  // way meaningful.
  if (type.package && type.qualifiedName) {
    return {
      type: 'nameOnly',
      name:
        type.package === 'typescript'
          ? type.qualifiedName
          : `${type.package}.${type.qualifiedName}`,
    }
  }

  if (type.name === 'default' && type.typeArguments?.[0]) {
    return parseType(type.typeArguments[0], map)
  }

  // Final fallback
  if (type.name && type.name !== 'default' /* Not particularly meaningful */) {
    return {
      type: 'nameOnly',
      name: type.name,
    }
  }

  return undefined
}