@model-ts/graphql 0.0.0-stage → 7.0.0

package/src/Fields.ts

@@ -0,0 +1,117 @@
+import { Schema } from "effect"
+import { connectionField } from "./Connections.ts"
+import { type ErrorPolicy } from "./Errors.ts"
+import { wrap, normalize } from "./FieldRuntime.ts"
+import {
+  type ConnectionRef,
+  type RuntimeRef,
+  type Field,
+  type Fields,
+} from "./FieldTypes.ts"
+import {
+  type AnyResolve,
+  type AnyConfig,
+  config,
+  resolverField,
+} from "./Resolver.ts"
+import { id, invalid } from "./SchemaTypes.ts"
+import { eventField } from "./Subscription.ts"
+
+export function makeFields<Types, G, C>(
+  policy: ErrorPolicy,
+  maxPageSize: number,
+  defaultPageSize: number,
+) {
+  const field = (
+    ref: RuntimeRef,
+    input: AnyResolve | AnyConfig = {},
+  ): Field<unknown> => {
+    const options = config(input)
+    if (options.subscribe) return eventField(policy, ref, options)
+    const members = options.errors ?? []
+    if (members.some((member) => policy.internal.includes(member)))
+      invalid("Internal errors cannot be exposed as result union members")
+    const resolve = options.resolve
+    return resolverField(policy, options, {
+      type: (context, name) =>
+        members.length > 0 || options.result !== undefined
+          ? context.result(
+              typeof ref === "string"
+                ? ref
+                : ref.kind === "nullable" && typeof ref.of === "string"
+                  ? ref.of
+                  : invalid(
+                      "Result unions require an object type or object union",
+                    ),
+              members,
+              name,
+              options.result,
+              typeof ref !== "string" && ref.kind === "nullable",
+            )
+          : context.output(ref, name),
+      args: options.args ?? {},
+      members,
+      call: (source, _raw, decoded, coordinate, context) =>
+        resolve
+          ? resolve(source, decoded, context)
+          : Reflect.get(
+              Object(source),
+              coordinate.slice(coordinate.lastIndexOf(".") + 1),
+            ),
+      finish: (value) => normalize(ref, value),
+    })
+  }
+  const wrapped =
+    (kind: "list" | "nullable") =>
+    (of: RuntimeRef, input?: AnyResolve | AnyConfig) =>
+      input === undefined
+        ? Object.assign(field(wrap(kind, of)), wrap(kind, of))
+        : field(wrap(kind, of), input)
+  const scalarHelpers = (nullable: boolean) =>
+    Object.fromEntries(
+      Object.entries({
+        id: "ID",
+        string: "String",
+        int: "Int",
+        float: "Float",
+        boolean: "Boolean",
+        dateTime: "DateTime",
+        json: "JSON",
+      }).map(([method, ref]) => [
+        method,
+        (options?: AnyConfig) =>
+          field(nullable ? { kind: "nullable", of: ref } : ref, options),
+      ]),
+    )
+  const connection = (node: string, input?: AnyResolve | AnyConfig) =>
+    input === undefined
+      ? Object.assign(
+          connectionField(policy, maxPageSize, defaultPageSize, node),
+          { kind: "connection" as const, node },
+        )
+      : connectionField(policy, maxPageSize, defaultPageSize, node, input)
+  // Public overloads describe these functions before the graphql-js runtime boundary.
+  const fields = {
+    ...scalarHelpers(false),
+    // A schema can never be field options, so the argument alone selects the
+    // position; the public overload admits only string schemas.
+    id: (input?: AnyConfig | Schema.Top) =>
+      Schema.isSchema(input)
+        ? id(input as Schema.Top & Schema.Schema<string>)
+        : field("ID", input),
+    field,
+    connection,
+    list: wrapped("list"),
+    nullable: Object.assign(wrapped("nullable"), scalarHelpers(true)),
+  } as unknown as Fields<Types, G, C>
+  return {
+    fields,
+    rootField: (
+      ref: RuntimeRef | ConnectionRef<string>,
+      input: AnyResolve | AnyConfig,
+    ) =>
+      typeof ref !== "string" && ref.kind === "connection"
+        ? connection(ref.node, input)
+        : field(ref, input),
+  }
+}

package/src/Formatting.ts

@@ -0,0 +1,54 @@
+import { Effect, Schema } from "effect"
+import { GraphQLError } from "graphql"
+import { recoverCause, defaultErrorPolicy } from "./Errors.ts"
+import type { ExecutionResult } from "./Execution.ts"
+
+const Result = Schema.Struct({
+  data: Schema.optionalKey(Schema.NullOr(Schema.JsonObject)),
+  errors: Schema.optionalKey(
+    Schema.Array(
+      Schema.Struct({
+        message: Schema.String,
+        locations: Schema.optionalKey(
+          Schema.Array(
+            Schema.Struct({ line: Schema.Number, column: Schema.Number }),
+          ),
+        ),
+        path: Schema.optionalKey(
+          Schema.Array(Schema.Union([Schema.String, Schema.Number])),
+        ),
+        extensions: Schema.optionalKey(Schema.JsonObject),
+      }),
+    ),
+  ),
+  extensions: Schema.optionalKey(Schema.JsonObject),
+})
+export type FormattedExecutionResult = typeof Result.Type
+const decode = Schema.decodeUnknownSync(Schema.fromJsonString(Result))
+
+/** Match the JSON wire response: plain records, no Error stacks or graphql-js prototypes. */
+export const snapshot = (result: ExecutionResult): FormattedExecutionResult =>
+  decode(JSON.stringify(result))
+
+/** Formatting belongs to the executor; transports receive only JSON values.
+ * Serialization defects always become a fixed internal error, including failures
+ * in a custom toJSON method, so even the fallback is guaranteed to serialize.
+ */
+export const formatResult = (
+  result: ExecutionResult,
+): Effect.Effect<FormattedExecutionResult> =>
+  Effect.sync(() => snapshot(result)).pipe(
+    Effect.catchCause((cause) =>
+      Effect.map(
+        recoverCause(cause, [], defaultErrorPolicy, {
+          coordinate: "operation",
+          phase: "execute",
+        }),
+        (error) => {
+          if (!(error instanceof GraphQLError))
+            throw new Error("Error policy must return a GraphQL error")
+          return snapshot({ errors: [error] })
+        },
+      ),
+    ),
+  )

package/src/GraphQL.ts

@@ -0,0 +1,50 @@
+export { createBuilder, type Builder, type BuilderOptions } from "./Builder.ts"
+export type { Register, Registration, Scalars, Values } from "./Registry.ts"
+export type {
+  Field,
+  Fields,
+  OutputRef,
+  Ref,
+  Value,
+  Resolved,
+  Requirements,
+  SourceField,
+  DefaultField,
+} from "./FieldTypes.ts"
+export type {
+  ObjectDefinition,
+  InterfaceDefinition,
+  UnionDefinition,
+  ScalarDefinition,
+  NamedDefinition,
+  RootDefinition,
+  EnumDefinition,
+  EnumOptions,
+  InterfaceOptions,
+  AbstractOptions,
+} from "./Definitions.ts"
+export type {
+  Connection,
+  ConnectionArgs,
+  Edge,
+  PageInfo,
+} from "./Connections.ts"
+export type { ErrorSchema, ResultOptions } from "./Results.ts"
+export {
+  ErrorReporter,
+  type ErrorReport,
+  type ErrorPolicyOptions,
+} from "./Errors.ts"
+export { ID, JSONValue, DateTime, id, input, defaulted } from "./SchemaTypes.ts"
+export {
+  executor,
+  type Executor,
+  type Execution,
+  type Json,
+  execute,
+  subscribe,
+  type BuiltSchema,
+  type Request,
+  type ExecutionResult,
+  type FormattedExecutionResult,
+} from "./Execution.ts"

package/src/InputTypes.ts

@@ -0,0 +1,266 @@
+import { Schema, SchemaAST } from "effect"
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLScalarType,
+  GraphQLString,
+  type GraphQLNamedType,
+  type GraphQLInputType,
+  GraphQLInputObjectType,
+  GraphQLEnumType,
+  isInputType,
+} from "graphql"
+import { dateTime, jsonScalar } from "./Scalars.ts"
+import {
+  invalid,
+  annotations,
+  metadata,
+  representation,
+  unwrap,
+} from "./SchemaTypes.ts"
+
+export function structure(ast: SchemaAST.AST): SchemaAST.Objects | undefined {
+  if (ast._tag === "Objects") return ast
+  if (ast._tag === "Declaration" && ast.typeParameters[0]?._tag === "Objects")
+    return ast.typeParameters[0]
+  return undefined
+}
+
+/** One mapper per assembled schema: names and AST identity never leak between schemas. */
+export class InputTypes {
+  private readonly registered = new Map<SchemaAST.AST, GraphQLInputType>()
+  // optionalKey() and annotate() copy Union ASTs but retain their member array.
+  // Its identity links model enum schemas without matching unrelated literals by value.
+  private readonly enums = new Map<readonly SchemaAST.AST[], GraphQLEnumType>()
+  private readonly owners = new Map<string, SchemaAST.Objects>()
+  constructor(
+    private readonly named: Map<string, GraphQLNamedType>,
+    private readonly add: <T extends GraphQLNamedType>(type: T) => T,
+  ) {}
+  register(ast: SchemaAST.AST, type: GraphQLInputType) {
+    if (ast._tag === "Union" && type instanceof GraphQLEnumType) {
+      const existing = this.enums.get(ast.types)
+      if (existing && existing !== type)
+        invalid(
+          `Enum schema is registered as both ${existing.name} and ${type.name}; use a separate Schema.Literals instance for each enum`,
+        )
+      this.enums.set(ast.types, type)
+    }
+    this.registered.set(ast, type)
+  }
+  argument(
+    schema: Schema.ConstraintDecoder<unknown, never>,
+    coordinate: string,
+  ) {
+    const defaultValue: unknown = annotations(schema.ast).graphqlDefault
+    return {
+      type: this.type(schema.ast, coordinate),
+      ...metadata(schema.ast),
+      ...(defaultValue === undefined
+        ? {}
+        : {
+            // defaulted() accepts a codec; the argument map retains its decoder view.
+            defaultValue: Schema.encodeUnknownSync(
+              schema as Schema.Codec<unknown, unknown>,
+            )(defaultValue),
+          }),
+    }
+  }
+  type(ast: SchemaAST.AST, coordinate: string): GraphQLInputType {
+    const nonnull = !SchemaAST.isOptional(ast)
+    const wrap = (type: GraphQLInputType) =>
+      nonnull ? new GraphQLNonNull(unwrap(type)) : unwrap(type)
+    const registered = this.registered.get(ast)
+    if (registered) return wrap(registered)
+    const ref =
+      annotations(ast).graphqlType ??
+      (structure(ast) ? annotations(ast).identifier : undefined)
+    if (ref) {
+      const existing = this.named.get(ref)
+      if (existing) {
+        if (!isInputType(existing))
+          return invalid(`${coordinate}: ${ref} is not an input type`)
+        const owner = this.owners.get(ref)
+        if (
+          owner &&
+          owner.propertySignatures !== structure(ast)?.propertySignatures
+        )
+          return invalid(`Duplicate input name: ${ref}`)
+        if (structure(ast) && !(existing instanceof GraphQLInputObjectType))
+          return invalid(`Duplicate input name: ${ref}`)
+        return wrap(existing)
+      }
+      if (ref === "DateTime") return wrap(this.add(dateTime()))
+      if (ref === "JSON") return wrap(this.add(jsonScalar()))
+      const encoded = structure(ast) ?? SchemaAST.toEncoded(ast)
+      if (encoded._tag !== "Objects")
+        return invalid(`${coordinate}: unregistered scalar or enum ${ref}`)
+      if (encoded.indexSignatures.length)
+        return invalid(
+          `${coordinate}: input dictionaries require a JSON scalar`,
+        )
+      this.owners.set(ref, encoded)
+      const type = this.add(
+        new GraphQLInputObjectType({
+          name: ref,
+          ...metadata(ast),
+          fields: () =>
+            Object.fromEntries(
+              encoded.propertySignatures.map((p) => {
+                if (typeof p.name !== "string")
+                  return invalid(`${coordinate}: input keys must be strings`)
+                return [
+                  p.name,
+                  this.argument(Schema.make(p.type), `${ref}.${p.name}`),
+                ]
+              }),
+            ),
+        }),
+      )
+      return wrap(type)
+    }
+    if (ast._tag === "Union") {
+      const enumeration = this.enums.get(ast.types)
+      if (enumeration) return wrap(enumeration)
+      const members = ast.types.filter(
+        (t) => t._tag !== "Null" && t._tag !== "Undefined",
+      )
+      if (members.length !== 1 || members.length === ast.types.length)
+        return invalid(
+          `Unregistered literal or union schema at ${coordinate}; register this exact model schema with GraphQL.enum(name, schema) and export the definition in the schema barrel`,
+        )
+      return unwrap(this.type(members[0]!, coordinate))
+    }
+    if (
+      ast._tag === "Declaration" &&
+      representation(ast) === "effect/schema/Date"
+    ) {
+      const existing = this.named.get("DateTime")
+      return wrap(
+        existing instanceof GraphQLScalarType ? existing : this.add(dateTime()),
+      )
+    }
+    if (ast.encoding) return this.type(SchemaAST.toEncoded(ast), coordinate)
+    switch (ast._tag) {
+      case "String":
+        return wrap(GraphQLString)
+      case "Number":
+        return wrap(
+          ast.checks?.some((c) => representation(c) === "effect/schema/isInt")
+            ? GraphQLInt
+            : GraphQLFloat,
+        )
+      case "Boolean":
+        return wrap(GraphQLBoolean)
+      case "Literal":
+        return wrap(
+          typeof ast.literal === "string"
+            ? GraphQLString
+            : typeof ast.literal === "boolean"
+              ? GraphQLBoolean
+              : GraphQLFloat,
+        )
+      case "Arrays":
+        if (ast.elements.length || ast.rest.length !== 1)
+          return invalid(`Unsupported tuple at ${coordinate}`)
+        return wrap(new GraphQLList(this.type(ast.rest[0]!, coordinate)))
+      default:
+        return invalid(
+          `Unsupported Schema ${ast._tag} at ${coordinate}; use Schema.Class or name input objects with GraphQL.input`,
+        )
+    }
+  }
+}
+
+/** Report the schema change needed to accept an explicit clear, without echoing input data. */
+export function optionalNullMessage(
+  args: Readonly<Record<string, Schema.ConstraintDecoder<unknown, never>>>,
+  raw: Readonly<Record<string, unknown>>,
+): string | undefined {
+  const visit = (
+    ast: SchemaAST.AST,
+    value: unknown,
+    path: string,
+  ): string | undefined => {
+    if (value === null) {
+      const nullable = Schema.is(Schema.toEncoded(Schema.make(ast)))(null)
+      return SchemaAST.isOptional(ast) && !nullable
+        ? `${path}: null is not accepted by Schema.optionalKey(S); omit the field or use Schema.optionalKey(Schema.NullOr(S)) to allow clearing it`
+        : undefined
+    }
+    if (ast._tag === "Union") {
+      for (const member of ast.types) {
+        const message = visit(member, value, path)
+        if (message) return message
+      }
+    }
+    const object = structure(ast)
+    if (object && typeof value === "object" && value !== null) {
+      for (const field of object.propertySignatures) {
+        const message = visit(
+          field.type,
+          Reflect.get(value, field.name),
+          `${path}.${String(field.name)}`,
+        )
+        if (message) return message
+      }
+    }
+    if (ast._tag === "Arrays" && ast.rest[0] && Array.isArray(value)) {
+      for (const [index, item] of value.entries()) {
+        const message = visit(ast.rest[0], item, `${path}[${index}]`)
+        if (message) return message
+      }
+    }
+    return undefined
+  }
+  for (const [key, schema] of Object.entries(args)) {
+    const message = visit(schema.ast, raw[key], key)
+    if (message) return message
+  }
+  return undefined
+}
+
+/** DateTime parses to ISO strings; native Schema.Date inputs still decode to Dates. */
+export function argumentDecoder(
+  args: Readonly<Record<string, Schema.ConstraintDecoder<unknown, never>>>,
+) {
+  const schema = Schema.Struct(args)
+  const decode = Schema.decodeUnknownSync(schema)
+  // Walk the wire shape: a Schema.Class itself has an encoding to its object fields.
+  const encoded = SchemaAST.toEncoded(schema.ast)
+  const prepare = (ast: SchemaAST.AST, value: unknown): unknown => {
+    if (value == null) return value
+    if (
+      ast._tag === "Declaration" &&
+      representation(ast) === "effect/schema/Date" &&
+      typeof value === "string"
+    )
+      return new Date(value)
+    if (ast._tag === "Union") {
+      const member = ast.types.find(
+        (type) => type._tag !== "Null" && type._tag !== "Undefined",
+      )
+      return member ? prepare(member, value) : value
+    }
+    const object = structure(ast)
+    if (object && typeof value === "object") {
+      const fields = new Map(
+        object.propertySignatures.map((field) => [field.name, field.type]),
+      )
+      return Object.fromEntries(
+        Object.entries(value).map(([key, item]) => {
+          const field = fields.get(key)
+          return [key, field ? prepare(field, item) : item]
+        }),
+      )
+    }
+    if (ast._tag === "Arrays" && ast.rest[0] && Array.isArray(value))
+      return value.map((item) => prepare(ast.rest[0]!, item))
+    return value
+  }
+  return (raw: Readonly<Record<string, unknown>>) =>
+    decode(prepare(encoded, raw))
+}

package/src/Registry.ts

@@ -0,0 +1,157 @@
+import type { Schema } from "effect"
+import { type PageInfo, type Edge, type Connection } from "./Connections.ts"
+import { type FieldMap, type Contextual } from "./FieldTypes.ts"
+
+export interface Scalars {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  DateTime: Date | string
+  JSON: unknown
+}
+
+export type DefinitionKind =
+  | "object"
+  | "interface"
+  | "union"
+  | "scalar"
+  | "enum"
+
+export interface Registration<K extends DefinitionKind, A> {
+  readonly kind: K
+  readonly model: A
+}
+
+export type Model = { readonly Type: unknown }
+
+export type Tag<M extends Model> = M["Type"] extends {
+  readonly _tag: infer N extends string
+}
+  ? N
+  : never
+
+export type InferKind<M extends Model> =
+  M extends Schema.Literals<readonly string[]>
+    ? "enum"
+    : M extends Schema.Union<readonly Schema.Top[]>
+      ? "union"
+      : M["Type"] extends string | number | boolean | Date
+        ? "scalar"
+        : "object"
+/** Tagged models need no name; non-object abstract types specify their kind. */
+
+export type Register<
+  M extends Model,
+  N extends string = Tag<M>,
+  K extends DefinitionKind = InferKind<M>,
+> = {
+  readonly [Name in N]: Registration<K, M["Type"]>
+}
+
+export type NamesOfKind<Types, Kind extends DefinitionKind> = Extract<
+  {
+    [N in keyof Types]: Types[N] extends Registration<Kind, unknown> ? N : never
+  }[keyof Types],
+  string
+>
+
+export type ModelAt<Types, N> = N extends keyof Types
+  ? Types[N] extends Registration<DefinitionKind, infer A>
+    ? A
+    : never
+  : never
+
+export type Values<Types> = {
+  readonly [N in keyof Types]: ModelAt<Types, N>
+} & {
+  readonly [
+    N in NamesOfKind<
+      Types,
+      "object" | "interface" | "union"
+    > as `${N}Edge` extends keyof Types ? never : `${N}Edge`
+  ]: Edge<ModelAt<Types, N>>
+} & {
+  readonly [
+    N in NamesOfKind<
+      Types,
+      "object" | "interface" | "union"
+    > as `${N}Connection` extends keyof Types ? never : `${N}Connection`
+  ]: Connection<ModelAt<Types, N>>
+} & ("PageInfo" extends keyof Types ? {} : { readonly PageInfo: PageInfo })
+
+export type NameOf<T> = T extends {
+  readonly "~kind": DefinitionKind
+  readonly "~name": infer N extends string
+}
+  ? N
+  : never
+
+export type RegistrationIssue<
+  Types,
+  N extends string,
+  A,
+  K extends DefinitionKind,
+> = N extends keyof Types
+  ? Types[N] extends Registration<K, infer Expected>
+    ? [A] extends [Expected]
+      ? [Expected] extends [A]
+        ? unknown
+        : `Registration model mismatch for "${N}"; register the definition's model`
+      : `Registration model mismatch for "${N}"; register the definition's model`
+    : `Registration kind mismatch for "${N}"; expected ${K}`
+  : `Register "${N}": add declare module "../graphql" { interface Types extends Register<typeof ${N}${K extends "object" ? "" : `, "${N}"${K extends "enum" | "scalar" ? "" : `, "${K}"`}`}> {} }`
+
+export type RegistrationCheck<
+  Types,
+  N extends string,
+  A,
+  K extends DefinitionKind,
+> =
+  RegistrationIssue<Types, N, A, K> extends infer Issue
+    ? Issue extends string
+      ? { readonly error: Issue }
+      : unknown
+    : never
+
+export type TaggedModel = Schema.Top & {
+  readonly Type: { readonly _tag: string }
+  readonly fields: { readonly _tag: Schema.Constraint }
+}
+
+export type MemberIssue<Types, M extends Schema.Top> = M extends TaggedModel
+  ? RegistrationIssue<Types, Tag<M>, M["Type"], "object"> extends infer Issue
+    ? Issue extends string
+      ? Issue
+      : never
+    : never
+  : "Union members must be tagged object models; use registered objects and pass { members: [...] } for untagged models"
+
+export type CheckedMembers<Types, Members extends readonly Schema.Top[]> =
+  MemberIssue<Types, Members[number]> extends infer Issue
+    ? [Issue] extends [never]
+      ? unknown
+      : { readonly error: Issue }
+    : never
+
+export type Complete<Types, M> =
+  Exclude<keyof Types, NameOf<M[keyof M]>> extends infer Missing
+    ? [Missing] extends [never]
+      ? unknown
+      : `Missing definition: ${Missing & string}; export it through the schema barrel`
+    : never
+
+/** Check each definition separately so conflicting contexts cannot widen into a union. */
+export type CompatibleContexts<M, C> = {
+  readonly [K in keyof M]: M[K] extends {
+    readonly "~kind": string
+    readonly fields: infer F
+  }
+    ? M[K] extends Contextual<C>
+      ? F extends FieldMap<never, C, boolean>
+        ? unknown
+        : "Fields require a different request context; build them with the createBuilder<Types, AppContext>() builder that builds the schema"
+      : "Definition requires a different request context; use definitions from createBuilder<Types, AppContext>() with the schema context"
+    : unknown
+}