@model-ts/graphql 0.0.0-stage → 7.0.0

package/src/Testing.ts

@@ -0,0 +1,144 @@
+/** Test operations keep their Effect requirements so @effect/vitest can supply any layer. */
+import { Effect, Stream } from "effect"
+import { GraphQLError, stripIgnoredCharacters } from "graphql"
+import {
+  type BuiltSchema,
+  type ContextArgument,
+  type Request,
+  execute as run,
+  subscribe as events,
+} from "./Execution.ts"
+import {
+  snapshot,
+  type FormattedExecutionResult as Result,
+} from "./Formatting.ts"
+export { snapshot } from "./Formatting.ts"
+export type { FormattedExecutionResult as Result } from "./Formatting.ts"
+
+export const execute = <R, C>(
+  built: BuiltSchema<R, C>,
+  request: Request,
+  ...context: ContextArgument<NoInfer<C>>
+): Effect.Effect<Result, never, R> =>
+  run(built, request, ...context).pipe(Effect.map(snapshot))
+
+export const subscribe = <R, C>(
+  built: BuiltSchema<R, C>,
+  request: Request,
+  ...context: ContextArgument<NoInfer<C>>
+): Stream.Stream<Result, never, R> =>
+  events(built, request, ...context).pipe(Stream.map(snapshot))
+
+/**
+ * Tags a GraphQL document for editor highlighting and removes ignored
+ * characters, so snapshots and error locations do not depend on indentation.
+ * String literals are kept verbatim. Like an editor, it reads backslash
+ * escapes as GraphQL escapes.
+ *
+ * @example
+ * const QUERY = graphql`
+ *   query List($id: ID!) { list(id: $id) { id name } }
+ * `
+ */
+export function graphql(
+  strings: TemplateStringsArray,
+  ...values: ReadonlyArray<string | number | boolean>
+): string {
+  const source = String.raw({ raw: strings.raw }, ...values)
+  try {
+    return stripIgnoredCharacters(source)
+  } catch (error) {
+    // Leave invalid documents to execution, which reports a located syntax error.
+    if (error instanceof GraphQLError) return source
+    throw error
+  }
+}
+
+export interface RequestOptions {
+  readonly variables?: { readonly [name: string]: unknown }
+  readonly operationName?: string
+}
+
+/** Request options are optional unless the context factory requires one. */
+export type RequestArgument<O> = {} extends O
+  ? [options?: O & RequestOptions]
+  : [options: O & RequestOptions]
+
+export interface ClientOptions<C, O, R> {
+  /** Builds each request's context from its options, as a value or an Effect. */
+  readonly context: (options: O) => C | Effect.Effect<C, never, R>
+}
+
+/** A context factory is required whenever the schema has a request context. */
+export type ClientArgument<C, O, R> = {} extends C
+  ? [options?: ClientOptions<C, O, R>]
+  : [options: ClientOptions<C, O, R>]
+
+export interface Client<O, R> {
+  readonly request: (
+    source: string,
+    ...options: RequestArgument<O>
+  ) => Effect.Effect<Result, never, R>
+  readonly subscribe: (
+    source: string,
+    ...options: RequestArgument<O>
+  ) => Stream.Stream<Result, never, R>
+}
+
+// A context is never itself an Effect, so Effect.isEffect separates the two
+// cases exactly; TypeScript cannot exclude an Effect from a generic A.
+const lift = <A, R>(
+  value: A | Effect.Effect<A, never, R>,
+): Effect.Effect<A, never, R> =>
+  Effect.isEffect(value)
+    ? (value as Effect.Effect<A, never, R>)
+    : Effect.succeed(value)
+
+/**
+ * Binds a schema to a default request context so each test only states what
+ * differs, such as the identity.
+ *
+ * @example
+ * export const { request, subscribe } = Testing.client(schema, {
+ *   context: (options: { identity?: Identity }) => ({
+ *     requestId: "test",
+ *     identity: options.identity ?? anonymous,
+ *   }),
+ * })
+ */
+export const client = <R, C, O = {}, R2 = never>(
+  built: BuiltSchema<R, C>,
+  ...[options]: ClientArgument<NoInfer<C>, O, R2>
+): Client<O, R | R2> => {
+  // RequestArgument and ClientArgument make an argument optional only when
+  // `{}` satisfies its type, and both ContextArgument branches accept [C].
+  // TypeScript cannot narrow these conditionals for generic O and C.
+  const prepare = (source: string, input?: O & RequestOptions) => {
+    const request = input ?? ({} as O & RequestOptions)
+    const context = options
+      ? lift(options.context(request))
+      : Effect.succeed({} as C)
+    return Effect.map(context, (context) => ({
+      request: {
+        source,
+        ...(request.variables ? { variableValues: request.variables } : {}),
+        ...(request.operationName === undefined
+          ? {}
+          : { operationName: request.operationName }),
+      },
+      context: [context] as ContextArgument<C>,
+    }))
+  }
+  return {
+    request: (source, ...[input]) =>
+      Effect.flatMap(prepare(source, input), ({ request, context }) =>
+        execute(built, request, ...context),
+      ),
+    subscribe: (source, ...[input]) =>
+      Stream.unwrap(
+        Effect.map(prepare(source, input), ({ request, context }) =>
+          subscribe(built, request, ...context),
+        ),
+      ),
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./GraphQL.ts"

package/src/internal/SubscriptionRule.ts

@@ -0,0 +1,90 @@
+import {
+  GraphQLError,
+  Kind,
+  isAbstractType,
+  typeFromAST,
+  type FieldNode,
+  type FragmentDefinitionNode,
+  type InlineFragmentNode,
+  type DirectiveNode,
+  type SelectionSetNode,
+  type ValidationRule,
+} from "graphql"
+
+/**
+ * Replaces graphql-js's SingleFieldSubscriptionsRule, which evaluates root
+ * skip/include without variables and throws for a variable condition. Collect
+ * root response keys through fragments and reject root conditionals instead.
+ */
+export const singleRootFieldSubscriptionsRule: ValidationRule = (context) => ({
+  OperationDefinition(operation) {
+    if (operation.operation !== "subscription") return
+    const schema = context.getSchema()
+    const root = schema.getSubscriptionType()
+    if (!root) return
+    const fields = new Map<string, FieldNode[]>()
+    const visited = new Set<string>()
+    const forbidden: DirectiveNode[] = []
+    const matches = (fragment: FragmentDefinitionNode | InlineFragmentNode) => {
+      if (!fragment.typeCondition) return true
+      const type = typeFromAST(schema, fragment.typeCondition)
+      return (
+        type === root || (isAbstractType(type) && schema.isSubType(type, root))
+      )
+    }
+    const collect = (selectionSet: SelectionSetNode): void => {
+      for (const selection of selectionSet.selections) {
+        // Validation cannot evaluate variables. Like GraphQL 17, root selections are
+        // unconditional and skip/include are forbidden; nested fields are not visited.
+        for (const directive of selection.directives ?? [])
+          if (
+            directive.name.value === "skip" ||
+            directive.name.value === "include"
+          )
+            forbidden.push(directive)
+        if (selection.kind === Kind.FIELD) {
+          const key = selection.alias?.value ?? selection.name.value
+          const group = fields.get(key)
+          if (group) group.push(selection)
+          else fields.set(key, [selection])
+        } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+          if (matches(selection)) collect(selection.selectionSet)
+        } else {
+          const name = selection.name.value
+          if (visited.has(name)) continue
+          visited.add(name)
+          const fragment = context.getFragment(name)
+          // Standard validation owns missing/cyclic fragments; this traversal must terminate.
+          if (fragment && matches(fragment)) collect(fragment.selectionSet)
+        }
+      }
+    }
+    collect(operation.selectionSet)
+    const name = operation.name
+      ? `Subscription "${operation.name.value}"`
+      : "Anonymous Subscription"
+    if (forbidden.length > 0) {
+      context.reportError(
+        new GraphQLError(
+          `${name} must not use \`@skip\` or \`@include\` directives in the top level selection.`,
+          { nodes: forbidden },
+        ),
+      )
+      return
+    }
+    if (fields.size > 1)
+      context.reportError(
+        new GraphQLError(`${name} must select only one top level field.`, {
+          nodes: [...fields.values()].slice(1).flat(),
+        }),
+      )
+    for (const nodes of fields.values())
+      if (nodes[0]!.name.value.startsWith("__"))
+        context.reportError(
+          new GraphQLError(
+            `${name} must not select an introspection top level field.`,
+            { nodes },
+          ),
+        )
+  },
+})