sailfork / t3code-github / .repos/ effect/ packages/ tools/ graphql-generator/ test/ utils/ model.ts

/**
 * Helpers for the schema model tests: reading fixtures through either reader,
 * a structural model comparison that names the first differing type, and
 * builders for expected models.
 */
import * as IntrospectionReader from "@effect/graphql-generator/internal/IntrospectionReader"
import type * as Model from "@effect/graphql-generator/internal/SchemaModel"
import * as SdlReader from "@effect/graphql-generator/internal/SdlReader"
import { assert } from "@effect/vitest"
import * as Result from "effect/Result"
import { readFileSync } from "node:fs"
import { formatDiagnostic, parseOrThrow, source } from "./ast.ts"

export const fixture = (file: string): string => readFileSync(new URL(`../fixtures/${file}`, import.meta.url), "utf8")

export const readSdl = (body: string, path = "schema.graphql"): Model.Schema => {
  const result = SdlReader.read(source(body, path), parseOrThrow(body, path))
  if (Result.isFailure(result)) {
    throw new Error(`unexpected diagnostic: ${formatDiagnostic(result.failure)}`)
  }
  return result.success
}

export const readIntrospection = (body: string, path = "schema.json"): Model.Schema => {
  const result = IntrospectionReader.read(source(body, path))
  if (Result.isFailure(result)) {
    throw new Error(`unexpected diagnostic: ${formatDiagnostic(result.failure)}`)
  }
  return result.success
}

/** Maps become plain objects (so entry order is ignored) and `undefined` members are dropped. */
const normalize = (value: unknown): unknown => {
  if (value instanceof Map) {
    const out: Record<string, unknown> = {}
    for (const [key, child] of value) out[String(key)] = normalize(child)
    return out
  }
  if (Array.isArray(value)) return value.map(normalize)
  if (value !== null && typeof value === "object") {
    const out: Record<string, unknown> = {}
    for (const [key, child] of Object.entries(value)) {
      if (child !== undefined) out[key] = normalize(child)
    }
    return out
  }
  return value
}

const sortedKeys = (a: ReadonlyMap<string, unknown>, b: ReadonlyMap<string, unknown>): ReadonlyArray<string> =>
  Array.from(new Set([...a.keys(), ...b.keys()])).sort()

/**
 * Compares two models structurally. Types are compared one at a time in name
 * order, so a failure names the first differing type instead of dumping both
 * schemas.
 */

export const assertModelsEqual = (actual: Model.Schema, expected: Model.Schema): void => {
  assert.deepStrictEqual(
    normalize({
      queryType: actual.queryType,
      mutationType: actual.mutationType,
      subscriptionType: actual.subscriptionType
    }),
    normalize({
      queryType: expected.queryType,
      mutationType: expected.mutationType,
      subscriptionType: expected.subscriptionType
    }),
    "models differ in their root operation types"
  )
  for (const name of sortedKeys(actual.types, expected.types)) {
    assert.deepStrictEqual(
      normalize(actual.types.get(name)),
      normalize(expected.types.get(name)),
      `models differ at type "${name}"`
    )
  }
}

/** Compares one named type of `model` with `expected`. */
export const assertType = (model: Model.Schema, expected: Model.NamedType): void => {
  assert.deepStrictEqual(
    normalize(model.types.get(expected.name)),
    normalize(expected),
    `type "${expected.name}" differs`
  )
}

// Expected-model builders. Optional members default to absent.

export const named = (name: string): Model.NamedTypeRef => ({ _tag: "NamedTypeRef", name })

export const list = (ofType: Model.TypeRef): Model.ListTypeRef => ({ _tag: "ListTypeRef", ofType })

export const nonNull = (ofType: Model.NamedTypeRef | Model.ListTypeRef): Model.NonNullTypeRef => ({
  _tag: "NonNullTypeRef",
  ofType
})

export const scalarType = (name: string, options: { readonly description?: string } = {}): Model.ScalarType => ({
  _tag: "ScalarType",
  name,
  description: options.description
})

const builtInScalars: ReadonlyArray<Model.ScalarType> = ["String", "Int", "Float", "Boolean", "ID"].map((
  name
) => scalarType(name))

export const objectType = (
  name: string,
  fields: ReadonlyArray<Model.Field>,
  options: { readonly description?: string; readonly interfaces?: ReadonlyArray<string> } = {}
): Model.ObjectType => ({
  _tag: "ObjectType",
  name,
  description: options.description,
  interfaces: options.interfaces ?? [],
  fields
})

export const interfaceType = (
  name: string,
  fields: ReadonlyArray<Model.Field>,
  options: {
    readonly description?: string
    readonly interfaces?: ReadonlyArray<string>
    readonly possibleTypes?: ReadonlyArray<string>
  } = {}
): Model.InterfaceType => ({
  _tag: "InterfaceType",
  name,
  description: options.description,
  interfaces: options.interfaces ?? [],
  fields,
  possibleTypes: options.possibleTypes ?? []
})

export const unionType = (
  name: string,
  possibleTypes: ReadonlyArray<string>,
  options: { readonly description?: string } = {}
): Model.UnionType => ({ _tag: "UnionType", name, description: options.description, possibleTypes })

export const enumType = (
  name: string,
  values: ReadonlyArray<Model.EnumValueDefinition>,
  options: { readonly description?: string } = {}
): Model.EnumType => ({ _tag: "EnumType", name, description: options.description, values })

export const enumValue = (
  name: string,
  options: { readonly description?: string; readonly deprecationReason?: string } = {}
): Model.EnumValueDefinition => ({
  name,
  description: options.description,
  deprecationReason: options.deprecationReason
})

export const inputObjectType = (
  name: string,
  fields: ReadonlyArray<Model.InputValue>,
  options: { readonly description?: string; readonly oneOf?: boolean } = {}
): Model.InputObjectType => ({
  _tag: "InputObjectType",
  name,
  description: options.description,
  oneOf: options.oneOf ?? false,
  fields
})

export const field = (
  name: string,
  type: Model.TypeRef,
  options: {
    readonly description?: string
    readonly arguments?: ReadonlyArray<Model.InputValue>
    readonly deprecationReason?: string
  } = {}
): Model.Field => ({
  name,
  description: options.description,
  arguments: options.arguments ?? [],
  type,
  deprecationReason: options.deprecationReason
})

export const inputValue = (
  name: string,
  type: Model.TypeRef,
  options: {
    readonly description?: string
    readonly defaultValue?: Model.ConstValue
    readonly deprecationReason?: string
  } = {}
): Model.InputValue => ({
  name,
  description: options.description,
  type,
  defaultValue: options.defaultValue,
  deprecationReason: options.deprecationReason
})

/** A complete expected schema; the built-in scalars are added for you. */
export const schema = (options: {
  readonly queryType: string
  readonly mutationType?: string
  readonly subscriptionType?: string
  readonly types: ReadonlyArray<Model.NamedType>
}): Model.Schema => ({
  queryType: options.queryType,
  mutationType: options.mutationType,
  subscriptionType: options.subscriptionType,
  types: new Map([...builtInScalars, ...options.types].map((type) => [type.name, type]))
})