sailfork / t3code-github / .repos/ effect/ packages/ tools/ graphql-generator/ src/ internal/ SdlReader.ts

/**
 * Builds a {@link SchemaModel.Schema} from a parsed type-system document.
 *
 * @internal
 */
import type * as Result from "effect/Result"
import type * as Ast from "./Ast.ts"
import { catchDiagnostic, type Diagnostic, make, type Source } from "./Diagnostic.ts"
import * as SchemaModel from "./SchemaModel.ts"

/**
 * Reads every definition and `extend` form in `document`, merging extensions
 * into their base definitions in document order. Root operation types come
 * from `schema { ... }` and `extend schema`, or default to the types named
 * `Query`, `Mutation` and `Subscription` when there is no schema definition.
 * Executable definitions are ignored.
 *
 * Fails with a diagnostic located in `source` when the document cannot form a
 * schema, e.g. it has no query root type or extends a type it never defines.
 * The server schema is not otherwise validated.
 */
export const read = (source: Source, document: Ast.Document): Result.Result<SchemaModel.Schema, Diagnostic> =>
  catchDiagnostic(() => build(source, document))

/** The definition each extension kind extends, and the word graphql-js uses for it. */
const extensionTargets: Record<Ast.TypeExtension["_tag"], readonly [Ast.TypeDefinition["_tag"], string]> = {
  ScalarTypeExtension: ["ScalarTypeDefinition", "scalar"],
  ObjectTypeExtension: ["ObjectTypeDefinition", "object"],
  InterfaceTypeExtension: ["InterfaceTypeDefinition", "interface"],
  UnionTypeExtension: ["UnionTypeDefinition", "union"],
  EnumTypeExtension: ["EnumTypeDefinition", "enum"],
  InputObjectTypeExtension: ["InputObjectTypeDefinition", "input object"]
}

const build = (source: Source, document: Ast.Document): SchemaModel.Schema => {
  const fail = (offset: number, message: string): never => {
    throw make(source, offset, message)
  }

  const definitions = new Map<string, Ast.TypeDefinition>()
  const extensions = new Map<string, Array<Ast.TypeExtension>>()
  let schemaDefinition: Ast.SchemaDefinition | undefined
  const schemaExtensions: Array<Ast.SchemaExtension> = []

  for (const definition of document.definitions) {
    switch (definition._tag) {
      case "OperationDefinition":
      case "FragmentDefinition":
      case "DirectiveDefinition":
        break

      case "SchemaDefinition":
        if (schemaDefinition !== undefined) fail(definition.loc.start, "Must provide only one schema definition.")
        schemaDefinition = definition
        break
      case "SchemaExtension":
        schemaExtensions.push(definition)
        break

      case "ScalarTypeExtension":
      case "ObjectTypeExtension":
      case "InterfaceTypeExtension":
      case "UnionTypeExtension":
      case "EnumTypeExtension":
      case "InputObjectTypeExtension": {
        const list = extensions.get(definition.name.value)
        if (list === undefined) extensions.set(definition.name.value, [definition])
        else list.push(definition)
        break
      }
      default: {
        const name = definition.name.value
        if (definitions.has(name)) fail(definition.name.loc.start, `There can be only one type named "${name}".`)
        definitions.set(name, definition)
      }
    }
  }

  for (const [name, list] of extensions) {
    const definition = definitions.get(name)
    for (const extension of list) {
      const [target, word] = extensionTargets[extension._tag]
      if (definition === undefined) {
        if (extension._tag === "ScalarTypeExtension" && SchemaModel.builtInScalarNames.includes(name)) continue
        fail(extension.name.loc.start, `Cannot extend type "${name}" because it is not defined.`)
      } else if (definition._tag !== target) {
        fail(extension.name.loc.start, `Cannot extend non-${word} type "${name}".`)
      }
    }
  }

  // Interface name -> implementing object types, for `possibleTypes`.
  const implementations = new Map<string, Array<string>>()
  for (const [name, definition] of definitions) {
    if (definition._tag !== "ObjectTypeDefinition") continue
    const parts = withExtensions(definition, extensions) as ReadonlyArray<
      Ast.ObjectTypeDefinition | Ast.ObjectTypeExtension
    >
    for (const part of parts) {
      for (const iface of part.interfaces) {
        const list = implementations.get(iface.name.value)
        if (list === undefined) implementations.set(iface.name.value, [name])
        else if (!list.includes(name)) list.push(name)
      }
    }
  }

  const types = new Map<string, SchemaModel.NamedType>()
  for (const name of SchemaModel.builtInScalarNames) types.set(name, SchemaModel.builtInScalar(name))
  for (const [name, definition] of definitions) {
    if (SchemaModel.builtInScalarNames.includes(name)) continue
    types.set(name, buildType(definition, extensions, implementations))
  }

  const defaultRoot = (name: string) => schemaDefinition === undefined && types.has(name) ? name : undefined
  const roots: Record<Ast.OperationType, string | undefined> = {
    query: defaultRoot("Query"),
    mutation: defaultRoot("Mutation"),
    subscription: defaultRoot("Subscription")
  }
  for (const part of schemaDefinition === undefined ? schemaExtensions : [schemaDefinition, ...schemaExtensions]) {
    for (const operationType of part.operationTypes) {
      roots[operationType.operation] = operationType.type.name.value
    }
  }
  if (roots.query === undefined) {
    return fail(schemaDefinition?.loc.start ?? 0, "Query root type must be provided.")
  }

  return {
    queryType: roots.query,
    mutationType: roots.mutation,
    subscriptionType: roots.subscription,
    types
  }
}

/** A definition followed by its extensions, which share the members being merged. */
const withExtensions = <D extends Ast.TypeDefinition>(
  definition: D,
  extensions: ReadonlyMap<string, ReadonlyArray<Ast.TypeExtension>>
): ReadonlyArray<D | Ast.TypeExtension> => [definition, ...(extensions.get(definition.name.value) ?? [])]

const buildType = (
  definition: Ast.TypeDefinition,
  extensions: ReadonlyMap<string, ReadonlyArray<Ast.TypeExtension>>,
  implementations: ReadonlyMap<string, ReadonlyArray<string>>
): SchemaModel.NamedType => {
  const name = definition.name.value
  const description = definition.description?.value
  // Each extension has already been checked to match its definition's kind.
  const parts = withExtensions(definition, extensions)
  switch (definition._tag) {
    case "ScalarTypeDefinition":
      return { _tag: "ScalarType", name, description }
    case "ObjectTypeDefinition":
    case "InterfaceTypeDefinition": {
      const objectParts = parts as ReadonlyArray<
        Ast.ObjectTypeDefinition | Ast.ObjectTypeExtension | Ast.InterfaceTypeDefinition | Ast.InterfaceTypeExtension
      >
      const interfaces = objectParts.flatMap((part) => part.interfaces.map((iface) => iface.name.value))
      const fields = objectParts.flatMap((part) => part.fields.map(buildField))
      return definition._tag === "ObjectTypeDefinition"
        ? { _tag: "ObjectType", name, description, interfaces, fields }
        : {
          _tag: "InterfaceType",
          name,
          description,
          interfaces,
          fields,
          possibleTypes: [...(implementations.get(name) ?? [])].sort()
        }
    }

    case "UnionTypeDefinition":
      return {
        _tag: "UnionType",
        name,
        description,
        possibleTypes: (parts as ReadonlyArray<Ast.UnionTypeDefinition | Ast.UnionTypeExtension>).flatMap((part) =>
          part.types.map((member) => member.name.value)
        )
      }
    case "EnumTypeDefinition":
      return {
        _tag: "EnumType",
        name,
        description,
        values: (parts as ReadonlyArray<Ast.EnumTypeDefinition | Ast.EnumTypeExtension>).flatMap((part) =>
          part.values.map((value) => ({
            name: value.name.value,
            description: value.description?.value,
            deprecationReason: deprecationReason(value.directives)
          }))
        )
      }
    case "InputObjectTypeDefinition":
      return {
        _tag: "InputObjectType",
        name,
        description,
        oneOf: parts.some((part) => findDirective(part.directives, "oneOf") !== undefined),

        fields: (parts as ReadonlyArray<Ast.InputObjectTypeDefinition | Ast.InputObjectTypeExtension>).flatMap((
          part
        ) => part.fields.map(buildInputValue))
      }
  }
}

const buildField = (field: Ast.FieldDefinition): SchemaModel.Field => ({
  name: field.name.value,
  description: field.description?.value,
  arguments: field.arguments.map(buildInputValue),
  type: SchemaModel.fromAstType(field.type),
  deprecationReason: deprecationReason(field.directives)
})

const buildInputValue = (value: Ast.InputValueDefinition): SchemaModel.InputValue => ({
  name: value.name.value,
  description: value.description?.value,
  type: SchemaModel.fromAstType(value.type),
  defaultValue: value.defaultValue === undefined ? undefined : SchemaModel.fromAstConstValue(value.defaultValue),
  deprecationReason: deprecationReason(value.directives)
})

const findDirective = (
  directives: ReadonlyArray<Ast.ConstDirective>,
  name: string
): Ast.ConstDirective | undefined => directives.find((directive) => directive.name.value === name)

const deprecationReason = (directives: ReadonlyArray<Ast.ConstDirective>): string | undefined => {
  const directive = findDirective(directives, "deprecated")
  if (directive === undefined) return undefined
  const reason = directive.arguments.find((argument) => argument.name.value === "reason")?.value
  return reason?._tag === "StringValue" ? reason.value : SchemaModel.defaultDeprecationReason
}