@model-ts/graphql 0.0.0-stage → 7.0.0

package/src/Resolver.ts

@@ -0,0 +1,176 @@
+import type { Stream } from "effect"
+import { Effect, Schema, SchemaIssue } from "effect"
+import {
+  type GraphQLFieldConfigArgumentMap,
+  type GraphQLOutputType,
+} from "graphql"
+import {
+  type ErrorPolicy,
+  fieldError,
+  protect,
+  forbidden,
+  resultSource,
+} from "./Errors.ts"
+import { describe } from "./FieldRuntime.ts"
+import {
+  type ArgFields,
+  type Description,
+  type BuildContext,
+  fieldRequirements,
+  type Field,
+} from "./FieldTypes.ts"
+import { argumentDecoder, optionalNullMessage } from "./InputTypes.ts"
+import { type ErrorSchema, type ResultOptions, errorName } from "./Results.ts"
+
+export interface Resolver {
+  readonly type: (context: BuildContext, name: string) => GraphQLOutputType
+  readonly args: ArgFields
+  readonly extraArgs?: GraphQLFieldConfigArgumentMap
+  readonly members: readonly ErrorSchema[]
+  readonly call: (
+    source: unknown,
+    args: Readonly<Record<string, unknown>>,
+    decoded: unknown,
+    coordinate: string,
+    context: unknown,
+  ) => unknown
+  readonly finish: (
+    value: unknown,
+    args: Readonly<Record<string, unknown>>,
+  ) => unknown
+}
+
+export type AnyResolve = (
+  source: unknown,
+  args: unknown,
+  context: unknown,
+) => unknown
+/** The runtime view of every field input, before type parameters are fixed. */
+
+export interface AnyConfig extends Description {
+  readonly edgeName?: string
+  readonly name?: string
+  readonly args?: ArgFields
+  readonly result?: ResultOptions
+  readonly errors?: readonly ErrorSchema[]
+  readonly resolve?: AnyResolve
+  readonly nodes?: AnyResolve
+  readonly authorize?: AnyResolve
+  readonly totalCount?: AnyResolve
+  readonly subscribe?: (
+    source: unknown,
+    args: unknown,
+    context: unknown,
+  ) => Stream.Stream<unknown, unknown, unknown>
+}
+
+export const config = (input: AnyResolve | AnyConfig): AnyConfig =>
+  typeof input === "function" ? { resolve: input } : input
+
+export const resolverField = <R>(
+  policy: ErrorPolicy,
+  options: AnyConfig,
+  resolver: Resolver,
+): Field<R> => ({
+  kind: "field",
+  [fieldRequirements]: undefined,
+  build(context, name, coordinate = name) {
+    const decode = argumentDecoder(resolver.args)
+    return {
+      type: resolver.type(context, coordinate),
+      ...describe(options),
+      args: {
+        ...resolver.extraArgs,
+        ...Object.fromEntries(
+          Object.entries(resolver.args).map(([key, schema]) => [
+            key,
+            context.input.argument(schema, `${name}(${key})`),
+          ]),
+        ),
+      },
+      resolve(source, raw: Readonly<Record<string, unknown>>, request, info) {
+        const coordinate = `${info.parentType.name}.${info.fieldName}`
+        return request.run(
+          protect(
+            () => {
+              source = resultSource(source)
+              let decoded: unknown
+              try {
+                decoded = decode(raw)
+              } catch (error) {
+                if (Schema.isSchemaError(error)) {
+                  const member = resolver.members.find(
+                    (member) => errorName(member) === "UserInputError",
+                  )
+                  if (member) {
+                    const issue = SchemaIssue.makeFormatterStandardSchemaV1()(
+                      error.issue,
+                    ).issues[0]
+                    const path =
+                      issue?.path?.map((key) =>
+                        typeof key === "object" ? String(key.key) : String(key),
+                      ) ?? []
+                    const field =
+                      (path[0] === "input" ? path.slice(1) : path).join(".") ||
+                      name
+                    return Effect.fail(
+                      Schema.decodeUnknownSync(member)({
+                        _tag: "UserInputError",
+                        message:
+                          optionalNullMessage(resolver.args, raw) ??
+                          issue?.message ??
+                          "Invalid arguments",
+                        field,
+                      }),
+                    )
+                  }
+                }
+                throw fieldError(
+                  optionalNullMessage(resolver.args, raw) ??
+                    "Invalid arguments",
+                  {
+                    code: "BAD_USER_INPUT",
+                  },
+                )
+              }
+              return Effect.gen(function* () {
+                const allowed = yield* protect(
+                  () =>
+                    options.authorize
+                      ? options.authorize(source, decoded, request.context)
+                      : true,
+                  [],
+                  policy,
+                  { coordinate, phase: "authorize" },
+                )
+                if (allowed instanceof Error) return allowed
+                if (allowed !== true) return forbidden(info.fieldName)
+                return yield* Effect.suspend(() => {
+                  const output = resolver.call(
+                    source,
+                    raw,
+                    decoded,
+                    coordinate,
+                    request.context,
+                  )
+                  return Effect.isEffect(output)
+                    ? output
+                    : Effect.succeed(output)
+                }).pipe(
+                  Effect.map((value) =>
+                    value instanceof Error
+                      ? value
+                      : resolver.finish(value, raw),
+                  ),
+                )
+              })
+            },
+            resolver.members,
+            policy,
+            { coordinate, phase: "resolve" },
+          ),
+        )
+      },
+    }
+  },
+})

package/src/Results.ts

@@ -0,0 +1,128 @@
+import type { Schema } from "effect"
+import {
+  GraphQLObjectType,
+  GraphQLNonNull,
+  GraphQLUnionType,
+  isOutputType,
+  type GraphQLNamedType,
+  type GraphQLAbstractType,
+} from "graphql"
+import type { BuildContext } from "./FieldTypes.ts"
+import type { InputTypes } from "./InputTypes.ts"
+import { metadata, invalid } from "./SchemaTypes.ts"
+
+export interface ErrorSchema extends Schema.ConstraintDecoder<unknown, never> {
+  readonly Type: Error & { readonly _tag: string }
+  readonly fields: Schema.Struct.Fields
+}
+
+export type ErrorsOf<E extends readonly ErrorSchema[]> = E[number]["Type"]
+
+export interface ResultOptions {
+  /** Override the generated result name to preserve an existing schema contract. */
+  readonly name?: string
+  readonly description?: string
+}
+
+export const errorMember = Symbol("GraphQL error member")
+
+export function errorName(error: ErrorSchema): string {
+  const tag = error.fields._tag?.ast
+  if (tag?._tag !== "Literal" || typeof tag.literal !== "string")
+    return invalid("Expected a Schema.TaggedError with a literal string _tag")
+  return tag.literal
+}
+
+export function makeResultTypes(
+  inputs: InputTypes,
+  add: <T extends GraphQLNamedType>(type: T) => T,
+  objectType: (name: string, coordinate: string) => GraphQLObjectType,
+  named: ReadonlyMap<string, GraphQLNamedType>,
+): BuildContext["result"] {
+  const errorTypes = new Map<ErrorSchema, GraphQLObjectType>()
+  const errorType = (error: ErrorSchema) => {
+    const existing = errorTypes.get(error)
+    if (existing) return existing
+    const name = errorName(error)
+    const registered = named.get(name)
+    if (registered) {
+      if (!(registered instanceof GraphQLObjectType))
+        return invalid(
+          `Result error ${name} must be an object; register its error boundary as an object`,
+        )
+      errorTypes.set(error, registered)
+      return registered
+    }
+    const type = add(
+      new GraphQLObjectType({
+        name,
+        fields: Object.fromEntries(
+          Object.entries(error.fields)
+            .filter(([key]) => key !== "_tag")
+            .map(([key, field]) => [
+              key,
+              (() => {
+                const type = inputs.type(field.ast, `${name}.${key}`)
+                if (!isOutputType(type))
+                  return invalid(
+                    `Error fields need an output scalar at ${name}.${key}`,
+                  )
+                return { type, ...metadata(field.ast) }
+              })(),
+            ]),
+        ),
+      }),
+    )
+    errorTypes.set(error, type)
+    return type
+  }
+  return (ref, errors, coordinate, options = {}, nullable = false) => {
+    const success = named.get(ref)
+    const successMembers =
+      success instanceof GraphQLUnionType
+        ? success.getTypes()
+        : [objectType(ref, coordinate)]
+    const [parent, field = parent!] = coordinate.split(".")
+    // Mutation results keep the conventional <field>Result name; other parents
+    // are prefixed to avoid collisions across roots.
+    const prefix = parent === "Mutation" ? "" : parent
+    const name =
+      options.name ??
+      `${prefix}${field[0]!.toUpperCase()}${field.slice(1)}Result`
+    const members = [...successMembers, ...errors.map(errorType)]
+    if (new Set(members).size !== members.length)
+      invalid(`Duplicate union member: ${name}`)
+    const type = add(
+      new GraphQLUnionType({
+        name,
+        ...(options.description === undefined
+          ? {}
+          : { description: options.description }),
+        types: members,
+        resolveType: (
+          value,
+          context,
+          info,
+          abstractType: GraphQLAbstractType,
+        ) => {
+          if (
+            typeof value === "object" &&
+            value !== null &&
+            errorMember in value
+          )
+            return Reflect.get(value, errorMember)
+          if (success instanceof GraphQLUnionType) {
+            if (success.resolveType)
+              return success.resolveType(value, context, info, abstractType)
+            const tag: unknown =
+              Reflect.get(Object(value), "__typename") ??
+              Reflect.get(Object(value), "_tag")
+            return typeof tag === "string" ? tag : undefined
+          }
+          return ref
+        },
+      }),
+    )
+    return nullable ? type : new GraphQLNonNull(type)
+  }
+}

package/src/ScalarBoundary.ts

@@ -0,0 +1,30 @@
+import { GraphQLScalarType, specifiedScalarTypes } from "graphql"
+
+/** Retain callback provenance even when graphql-js forwards a thrown GraphQLError unchanged. */
+export class ScalarInputFailure extends Error {
+  constructor(readonly original: unknown) {
+    super("Scalar input failed")
+  }
+}
+
+const guarded = new WeakSet<GraphQLScalarType>()
+
+/** Clone adopted scalars so validation cannot mistake application exceptions for document diagnostics. */
+export function guardScalar(type: GraphQLScalarType): GraphQLScalarType {
+  if (specifiedScalarTypes.includes(type) || guarded.has(type)) return type
+  const input = <A>(evaluate: () => A): A => {
+    try {
+      return evaluate()
+    } catch (error) {
+      throw new ScalarInputFailure(error)
+    }
+  }
+  const result = new GraphQLScalarType({
+    ...type.toConfig(),
+    parseValue: (value) => input(() => type.parseValue(value)),
+    parseLiteral: (node, variables) =>
+      input(() => type.parseLiteral(node, variables)),
+  })
+  guarded.add(result)
+  return result
+}

package/src/Scalars.ts

@@ -0,0 +1,143 @@
+import { Schema } from "effect"
+import {
+  GraphQLScalarType,
+  GraphQLEnumType,
+  valueFromASTUntyped,
+  Kind,
+  type ValueNode,
+} from "graphql"
+import { fieldError } from "./Errors.ts"
+import { guardScalar } from "./ScalarBoundary.ts"
+import { invalid, metadata, annotations } from "./SchemaTypes.ts"
+
+export const date = (value: unknown) => {
+  if (typeof value !== "string")
+    return invalid("DateTime expects an ISO string")
+  const result = new Date(value)
+  return Number.isFinite(result.getTime())
+    ? result
+    : invalid("Invalid DateTime")
+}
+
+const invalidInput = (message: string): never => {
+  throw fieldError(message, { code: "BAD_USER_INPUT" })
+}
+
+const dateInput = (value: unknown): string => {
+  try {
+    return date(value).toISOString()
+  } catch {
+    return invalidInput("DateTime expects a valid ISO string")
+  }
+}
+
+export const dateTime = () =>
+  guardScalar(
+    new GraphQLScalarType({
+      name: "DateTime",
+      description: "A valid DateTime value",
+      serialize: (value) =>
+        value instanceof Date && Number.isFinite(value.getTime())
+          ? value.toISOString()
+          : date(value).toISOString(),
+      parseValue: dateInput,
+      parseLiteral: (node) =>
+        node.kind === Kind.STRING
+          ? dateInput(node.value)
+          : invalidInput("DateTime expects a string literal"),
+    }),
+  )
+
+export function scalar<A, I>(
+  name: string,
+  codec: Schema.Codec<A, I>,
+): GraphQLScalarType {
+  const decode = Schema.decodeUnknownSync(codec)
+  const encode = Schema.encodeUnknownSync(codec)
+  const decodeInput = (value: unknown) => {
+    try {
+      return decode(value)
+    } catch (error) {
+      if (Schema.isSchemaError(error))
+        return invalidInput(`Invalid value for ${name}`)
+      throw error
+    }
+  }
+  return guardScalar(
+    new GraphQLScalarType({
+      name,
+      ...metadata(codec.ast),
+      specifiedByURL: annotations(codec.ast).specifiedByURL,
+      serialize: encode,
+      // Keep the encoded representation until the argument Struct converts it for the resolver.
+      parseValue: (value) => {
+        decodeInput(value)
+        return value
+      },
+      parseLiteral: (node, variables) => {
+        if (node.kind === Kind.ENUM)
+          return invalidInput(
+            `${name} cannot represent an enum literal; quote the value as a string`,
+          )
+        const value: unknown = valueFromASTUntyped(node, variables)
+        decodeInput(value)
+        return value
+      },
+    }),
+  )
+}
+
+function jsonLiteral(
+  node: ValueNode,
+  variables?: Readonly<Record<string, unknown>> | null,
+): unknown {
+  switch (node.kind) {
+    case Kind.ENUM:
+      return invalidInput(
+        "JSON cannot represent an enum literal; quote the value as a string",
+      )
+    case Kind.OBJECT:
+      return Object.fromEntries(
+        node.fields.map((field) => [
+          field.name.value,
+          jsonLiteral(field.value, variables),
+        ]),
+      )
+    case Kind.LIST:
+      return node.values.map((value) => jsonLiteral(value, variables))
+    default:
+      return valueFromASTUntyped(node, variables)
+  }
+}
+
+/** Like graphql-type-json, variables and outputs are deliberately unrestricted JS values. */
+export const jsonScalar = () =>
+  guardScalar(
+    new GraphQLScalarType({
+      name: "JSON",
+      description:
+        "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
+      serialize: (value) => value,
+      parseValue: (value) => value,
+      parseLiteral: jsonLiteral,
+    }),
+  )
+
+export function enumeration(
+  name: string,
+  schema: Schema.Schema<string>,
+): GraphQLEnumType {
+  const ast = schema.ast
+  const values = ast._tag === "Union" ? ast.types : [ast]
+  return new GraphQLEnumType({
+    name,
+    ...metadata(ast),
+    values: Object.fromEntries(
+      values.map((value) => {
+        if (value._tag !== "Literal" || typeof value.literal !== "string")
+          return invalid(`${name}: enums require string Schema.Literals`)
+        return [value.literal, { value: value.literal, ...metadata(value) }]
+      }),
+    ),
+  })
+}

package/src/SchemaTypes.ts

@@ -0,0 +1,90 @@
+import type { SchemaAST } from "effect"
+import { Schema } from "effect"
+import {
+  type GraphQLOutputType,
+  type GraphQLNullableType,
+  type GraphQLInputType,
+  isNonNullType,
+} from "graphql"
+
+declare module "effect/Schema" {
+  namespace Annotations {
+    interface Annotations {
+      readonly specifiedByURL?: string
+      readonly graphqlType?: string
+      readonly graphqlDefault?: unknown
+      readonly deprecationReason?: string
+    }
+  }
+}
+
+export const ID = Schema.String.annotate({ graphqlType: "ID" })
+
+export function id<S extends Schema.Top & Schema.Schema<string>>(
+  schema: S,
+): S["Rebuild"] {
+  return schema.annotate({ graphqlType: "ID" })
+}
+
+export const JSONValue = Schema.Unknown.annotate({ graphqlType: "JSON" })
+
+/** DateTime inputs decode to normalized ISO strings. */
+export const DateTime = Schema.String.annotate({ graphqlType: "DateTime" })
+
+export function input<S extends Schema.Top>(
+  name: string,
+  schema: S,
+): S["Rebuild"] {
+  // Schema annotations preserve the codec and its fields (including Schema classes).
+  return schema.annotate({ graphqlType: name })
+}
+
+export function defaulted<
+  S extends Schema.Top & Schema.Codec<unknown, unknown>,
+>(schema: S, value: NoInfer<S["Type"]>): S["Rebuild"] {
+  Schema.decodeUnknownSync(Schema.toType(schema))(value)
+  return schema.annotate({ graphqlDefault: value })
+}
+
+export const invalid = (message: string): never => {
+  throw new Error(message)
+}
+
+export const annotations = (ast: SchemaAST.AST) => ({
+  ...Schema.resolveAnnotations(Schema.make(ast)),
+  ...ast.context?.annotations,
+})
+
+export function descriptionOf(ast: SchemaAST.AST): string | undefined {
+  const own = annotations(ast).description
+  return typeof own === "string"
+    ? own
+    : ast._tag === "Union"
+      ? ast.types.map(descriptionOf).find((v) => v !== undefined)
+      : undefined
+}
+
+export function metadata(ast: SchemaAST.AST) {
+  const description = descriptionOf(ast)
+  const deprecationReason = annotations(ast).deprecationReason
+  return {
+    ...(description === undefined ? {} : { description }),
+    ...(deprecationReason === undefined ? {} : { deprecationReason }),
+  }
+}
+
+export function representation(node: {
+  readonly annotations?: Schema.Annotations.Annotations | undefined
+}): unknown {
+  return Reflect.get(Object(node.annotations?.representation), "id")
+}
+
+export function unwrap(
+  type: GraphQLOutputType,
+): GraphQLOutputType & GraphQLNullableType
+export function unwrap(
+  type: GraphQLInputType,
+): GraphQLInputType & GraphQLNullableType
+export function unwrap(type: GraphQLOutputType | GraphQLInputType) {
+  return isNonNullType(type) ? type.ofType : type
+}

package/src/Subscription.ts

@@ -0,0 +1,93 @@
+import { Effect, Stream } from "effect"
+import {
+  type ErrorPolicy,
+  fieldError,
+  forbidden,
+  protect,
+  recoverCause,
+} from "./Errors.ts"
+import { describe, normalize } from "./FieldRuntime.ts"
+import { type RuntimeRef, type Field, fieldRequirements } from "./FieldTypes.ts"
+import { argumentDecoder, optionalNullMessage } from "./InputTypes.ts"
+import { type AnyConfig } from "./Resolver.ts"
+
+/** Setup and delivery share the resolver policy; authorization runs on every event. */
+export const eventField = (
+  policy: ErrorPolicy,
+  ref: RuntimeRef,
+  options: AnyConfig,
+): Field<unknown> => ({
+  kind: "field",
+  [fieldRequirements]: undefined,
+  build(context, name) {
+    const decode = argumentDecoder(options.args ?? {})
+    return {
+      type: context.output(ref, name),
+      ...describe(options),
+      args: Object.fromEntries(
+        Object.entries(options.args ?? {}).map(([key, schema]) => [
+          key,
+          context.input.argument(schema, `${name}(${key})`),
+        ]),
+      ),
+      subscribe(source, raw, request, info) {
+        const coordinate = `${info.parentType.name}.${info.fieldName}`
+        return request.stream(
+          Stream.suspend(() => {
+            let decoded: unknown
+            try {
+              decoded = decode(raw)
+            } catch {
+              throw fieldError(
+                optionalNullMessage(options.args ?? {}, raw) ??
+                  "Invalid arguments",
+                { code: "BAD_USER_INPUT" },
+              )
+            }
+            if (!options.subscribe)
+              throw new Error("Subscription needs a stream")
+            return options.subscribe(source, decoded, request.context)
+          }).pipe(
+            Stream.catchCause((cause) =>
+              Stream.fromEffect(
+                recoverCause(cause, [], policy, {
+                  coordinate,
+                  phase: "subscribe",
+                }),
+              ),
+            ),
+          ),
+        )
+      },
+      resolve(value, raw, request, info) {
+        const coordinate = `${info.parentType.name}.${info.fieldName}`
+        return request.run(
+          protect(
+            () => {
+              if (value instanceof Error) return value
+              const decoded = decode(raw)
+              return Effect.gen(function* () {
+                const allowed = yield* protect(
+                  () =>
+                    options.authorize
+                      ? options.authorize(value, decoded, request.context)
+                      : true,
+                  [],
+                  policy,
+                  { coordinate, phase: "authorize" },
+                )
+                if (allowed instanceof Error) return allowed
+                return allowed === true
+                  ? normalize(ref, value)
+                  : forbidden(info.fieldName)
+              })
+            },
+            [],
+            policy,
+            { coordinate, phase: "resolve" },
+          ),
+        )
+      },
+    }
+  },
+})