graphql 16.11.0 → 16.13.0

package/language/schemaCoordinateLexer.d.ts

@@ -0,0 +1,43 @@
+import { Token } from './ast';
+import type { LexerInterface } from './lexer';
+import type { Source } from './source';
+/**
+ * Given a Source schema coordinate, creates a Lexer for that source.
+ * A SchemaCoordinateLexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+export declare class SchemaCoordinateLexer implements LexerInterface {
+  source: Source;
+  /**
+   * The previously focused non-ignored token.
+   */
+  lastToken: Token;
+  /**
+   * The currently focused non-ignored token.
+   */
+  token: Token;
+  /**
+   * The (1-indexed) line containing the current token.
+   * Since a schema coordinate may not contain newline, this value is always 1.
+   */
+  line: 1;
+  /**
+   * The character offset at which the current line begins.
+   * Since a schema coordinate may not contain newline, this value is always 0.
+   */
+  lineStart: 0;
+  constructor(source: Source);
+  get [Symbol.toStringTag](): string;
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+  advance(): Token;
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the current Lexer token.
+   */
+  lookahead(): Token;
+}

package/language/schemaCoordinateLexer.js

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.SchemaCoordinateLexer = void 0;
+
+var _syntaxError = require('../error/syntaxError.js');
+
+var _ast = require('./ast.js');
+
+var _characterClasses = require('./characterClasses.js');
+
+var _lexer = require('./lexer.js');
+
+var _tokenKind = require('./tokenKind.js');
+
+/**
+ * Given a Source schema coordinate, creates a Lexer for that source.
+ * A SchemaCoordinateLexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+class SchemaCoordinateLexer {
+  /**
+   * The previously focused non-ignored token.
+   */
+
+  /**
+   * The currently focused non-ignored token.
+   */
+
+  /**
+   * The (1-indexed) line containing the current token.
+   * Since a schema coordinate may not contain newline, this value is always 1.
+   */
+  line = 1;
+  /**
+   * The character offset at which the current line begins.
+   * Since a schema coordinate may not contain newline, this value is always 0.
+   */
+
+  lineStart = 0;
+
+  constructor(source) {
+    const startOfFileToken = new _ast.Token(
+      _tokenKind.TokenKind.SOF,
+      0,
+      0,
+      0,
+      0,
+    );
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'SchemaCoordinateLexer';
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+
+  advance() {
+    this.lastToken = this.token;
+    const token = (this.token = this.lookahead());
+    return token;
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the current Lexer token.
+   */
+
+  lookahead() {
+    let token = this.token;
+
+    if (token.kind !== _tokenKind.TokenKind.EOF) {
+      // Read the next token and form a link in the token linked-list.
+      const nextToken = readNextToken(this, token.end); // @ts-expect-error next is only mutable during parsing.
+
+      token.next = nextToken; // @ts-expect-error prev is only mutable during parsing.
+
+      nextToken.prev = token;
+      token = nextToken;
+    }
+
+    return token;
+  }
+}
+/**
+ * Gets the next token from the source starting at the given position.
+ */
+
+exports.SchemaCoordinateLexer = SchemaCoordinateLexer;
+
+function readNextToken(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  const position = start;
+
+  if (position < bodyLength) {
+    const code = body.charCodeAt(position);
+
+    switch (code) {
+      case 0x002e:
+        // .
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.DOT,
+          position,
+          position + 1,
+        );
+
+      case 0x0028:
+        // (
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.PAREN_L,
+          position,
+          position + 1,
+        );
+
+      case 0x0029:
+        // )
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.PAREN_R,
+          position,
+          position + 1,
+        );
+
+      case 0x003a:
+        // :
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.COLON,
+          position,
+          position + 1,
+        );
+
+      case 0x0040:
+        // @
+        return (0, _lexer.createToken)(
+          lexer,
+          _tokenKind.TokenKind.AT,
+          position,
+          position + 1,
+        );
+    } // Name
+
+    if ((0, _characterClasses.isNameStart)(code)) {
+      return (0, _lexer.readName)(lexer, position);
+    }
+
+    throw (0, _syntaxError.syntaxError)(
+      lexer.source,
+      position,
+      `Invalid character: ${(0, _lexer.printCodePointAt)(lexer, position)}.`,
+    );
+  }
+
+  return (0, _lexer.createToken)(
+    lexer,
+    _tokenKind.TokenKind.EOF,
+    bodyLength,
+    bodyLength,
+  );
+}

package/language/schemaCoordinateLexer.mjs

@@ -0,0 +1,122 @@
+import { syntaxError } from '../error/syntaxError.mjs';
+import { Token } from './ast.mjs';
+import { isNameStart } from './characterClasses.mjs';
+import { createToken, printCodePointAt, readName } from './lexer.mjs';
+import { TokenKind } from './tokenKind.mjs';
+/**
+ * Given a Source schema coordinate, creates a Lexer for that source.
+ * A SchemaCoordinateLexer is a stateful stream generator in that every time
+ * it is advanced, it returns the next token in the Source. Assuming the
+ * source lexes, the final Token emitted by the lexer will be of kind
+ * EOF, after which the lexer will repeatedly return the same EOF token
+ * whenever called.
+ */
+
+export class SchemaCoordinateLexer {
+  /**
+   * The previously focused non-ignored token.
+   */
+
+  /**
+   * The currently focused non-ignored token.
+   */
+
+  /**
+   * The (1-indexed) line containing the current token.
+   * Since a schema coordinate may not contain newline, this value is always 1.
+   */
+  line = 1;
+  /**
+   * The character offset at which the current line begins.
+   * Since a schema coordinate may not contain newline, this value is always 0.
+   */
+
+  lineStart = 0;
+
+  constructor(source) {
+    const startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0);
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'SchemaCoordinateLexer';
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+
+  advance() {
+    this.lastToken = this.token;
+    const token = (this.token = this.lookahead());
+    return token;
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the current Lexer token.
+   */
+
+  lookahead() {
+    let token = this.token;
+
+    if (token.kind !== TokenKind.EOF) {
+      // Read the next token and form a link in the token linked-list.
+      const nextToken = readNextToken(this, token.end); // @ts-expect-error next is only mutable during parsing.
+
+      token.next = nextToken; // @ts-expect-error prev is only mutable during parsing.
+
+      nextToken.prev = token;
+      token = nextToken;
+    }
+
+    return token;
+  }
+}
+/**
+ * Gets the next token from the source starting at the given position.
+ */
+
+function readNextToken(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  const position = start;
+
+  if (position < bodyLength) {
+    const code = body.charCodeAt(position);
+
+    switch (code) {
+      case 0x002e:
+        // .
+        return createToken(lexer, TokenKind.DOT, position, position + 1);
+
+      case 0x0028:
+        // (
+        return createToken(lexer, TokenKind.PAREN_L, position, position + 1);
+
+      case 0x0029:
+        // )
+        return createToken(lexer, TokenKind.PAREN_R, position, position + 1);
+
+      case 0x003a:
+        // :
+        return createToken(lexer, TokenKind.COLON, position, position + 1);
+
+      case 0x0040:
+        // @
+        return createToken(lexer, TokenKind.AT, position, position + 1);
+    } // Name
+
+    if (isNameStart(code)) {
+      return readName(lexer, position);
+    }
+
+    throw syntaxError(
+      lexer.source,
+      position,
+      `Invalid character: ${printCodePointAt(lexer, position)}.`,
+    );
+  }
+
+  return createToken(lexer, TokenKind.EOF, bodyLength, bodyLength);
+}

package/language/tokenKind.d.ts

@@ -10,6 +10,7 @@ declare enum TokenKind {
   AMP = '&',
   PAREN_L = '(',
   PAREN_R = ')',
+  DOT = '.',
   SPREAD = '...',
   COLON = ':',
   EQUALS = '=',

package/language/tokenKind.js

@@ -20,6 +20,7 @@ exports.TokenKind = TokenKind;
   TokenKind['AMP'] = '&';
   TokenKind['PAREN_L'] = '(';
   TokenKind['PAREN_R'] = ')';
+  TokenKind['DOT'] = '.';
   TokenKind['SPREAD'] = '...';
   TokenKind['COLON'] = ':';
   TokenKind['EQUALS'] = '=';

package/language/tokenKind.mjs

@@ -12,6 +12,7 @@ var TokenKind;
   TokenKind['AMP'] = '&';
   TokenKind['PAREN_L'] = '(';
   TokenKind['PAREN_R'] = ')';
+  TokenKind['DOT'] = '.';
   TokenKind['SPREAD'] = '...';
   TokenKind['COLON'] = ':';
   TokenKind['EQUALS'] = '=';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql",
-  "version": "16.11.0",
+  "version": "16.13.0",
   "description": "A Query Language and Runtime which can target any service.",
   "license": "MIT",
   "main": "index",

package/utilities/index.d.ts

@@ -59,3 +59,8 @@ export {
 } from './findBreakingChanges';
 export type { BreakingChange, DangerousChange } from './findBreakingChanges';
 export type { TypedQueryDocumentNode } from './typedQueryDocumentNode';
+export {
+  resolveSchemaCoordinate,
+  resolveASTSchemaCoordinate,
+} from './resolveSchemaCoordinate';
+export type { ResolvedSchemaElement } from './resolveSchemaCoordinate';

package/utilities/index.js

@@ -153,6 +153,18 @@ Object.defineProperty(exports, 'printType', {
     return _printSchema.printType;
   },
 });
+Object.defineProperty(exports, 'resolveASTSchemaCoordinate', {
+  enumerable: true,
+  get: function () {
+    return _resolveSchemaCoordinate.resolveASTSchemaCoordinate;
+  },
+});
+Object.defineProperty(exports, 'resolveSchemaCoordinate', {
+  enumerable: true,
+  get: function () {
+    return _resolveSchemaCoordinate.resolveSchemaCoordinate;
+  },
+});
 Object.defineProperty(exports, 'separateOperations', {
   enumerable: true,
   get: function () {
@@ -231,3 +243,5 @@ var _typeComparators = require('./typeComparators.js');
 var _assertValidName = require('./assertValidName.js');
 
 var _findBreakingChanges = require('./findBreakingChanges.js');
+
+var _resolveSchemaCoordinate = require('./resolveSchemaCoordinate.js');

package/utilities/index.mjs

@@ -53,3 +53,8 @@ export {
   findBreakingChanges,
   findDangerousChanges,
 } from './findBreakingChanges.mjs';
+// Schema coordinates
+export {
+  resolveSchemaCoordinate,
+  resolveASTSchemaCoordinate,
+} from './resolveSchemaCoordinate.mjs';

package/utilities/resolveSchemaCoordinate.d.ts

@@ -0,0 +1,80 @@
+import type { SchemaCoordinateNode } from '../language/ast';
+import type { Source } from '../language/source';
+import type {
+  GraphQLArgument,
+  GraphQLEnumType,
+  GraphQLEnumValue,
+  GraphQLField,
+  GraphQLInputField,
+  GraphQLInputObjectType,
+  GraphQLInterfaceType,
+  GraphQLNamedType,
+  GraphQLObjectType,
+} from '../type/definition';
+import type { GraphQLDirective } from '../type/directives';
+import type { GraphQLSchema } from '../type/schema';
+/**
+ * A resolved schema element may be one of the following kinds:
+ */
+export interface ResolvedNamedType {
+  readonly kind: 'NamedType';
+  readonly type: GraphQLNamedType;
+}
+export interface ResolvedField {
+  readonly kind: 'Field';
+  readonly type: GraphQLObjectType | GraphQLInterfaceType;
+  readonly field: GraphQLField<unknown, unknown>;
+}
+export interface ResolvedInputField {
+  readonly kind: 'InputField';
+  readonly type: GraphQLInputObjectType;
+  readonly inputField: GraphQLInputField;
+}
+export interface ResolvedEnumValue {
+  readonly kind: 'EnumValue';
+  readonly type: GraphQLEnumType;
+  readonly enumValue: GraphQLEnumValue;
+}
+export interface ResolvedFieldArgument {
+  readonly kind: 'FieldArgument';
+  readonly type: GraphQLObjectType | GraphQLInterfaceType;
+  readonly field: GraphQLField<unknown, unknown>;
+  readonly fieldArgument: GraphQLArgument;
+}
+export interface ResolvedDirective {
+  readonly kind: 'Directive';
+  readonly directive: GraphQLDirective;
+}
+export interface ResolvedDirectiveArgument {
+  readonly kind: 'DirectiveArgument';
+  readonly directive: GraphQLDirective;
+  readonly directiveArgument: GraphQLArgument;
+}
+export declare type ResolvedSchemaElement =
+  | ResolvedNamedType
+  | ResolvedField
+  | ResolvedInputField
+  | ResolvedEnumValue
+  | ResolvedFieldArgument
+  | ResolvedDirective
+  | ResolvedDirectiveArgument;
+/**
+ * A schema coordinate is resolved in the context of a GraphQL schema to
+ * uniquely identify a schema element. It returns undefined if the schema
+ * coordinate does not resolve to a schema element, meta-field, or introspection
+ * schema element. It will throw if the containing schema element (if
+ * applicable) does not exist.
+ *
+ * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics
+ */
+export declare function resolveSchemaCoordinate(
+  schema: GraphQLSchema,
+  schemaCoordinate: string | Source,
+): ResolvedSchemaElement | undefined;
+/**
+ * Resolves schema coordinate from a parsed SchemaCoordinate node.
+ */
+export declare function resolveASTSchemaCoordinate(
+  schema: GraphQLSchema,
+  schemaCoordinate: SchemaCoordinateNode,
+): ResolvedSchemaElement | undefined;