@0no-co/graphql.web 0.1.0 → 0.1.1

package/src/parser.ts

@@ -1,480 +0,0 @@
-/**
- * This is a spec-compliant implementation of a GraphQL query language parser,
- * up-to-date with the October 2021 Edition. Unlike the reference implementation
- * in graphql.js it will only parse the query language, but not the schema
- * language.
- */
-import { Kind } from './kind';
-import { GraphQLError } from './error';
-import type * as ast from './ast';
-
-let input: string;
-let idx: number;
-
-function error(kind: Kind) {
-  return new GraphQLError(`Syntax Error: Unexpected token at ${idx} in ${kind}`);
-}
-
-function advance(pattern: RegExp) {
-  pattern.lastIndex = idx;
-  if (pattern.test(input)) {
-    const match = input.slice(idx, idx = pattern.lastIndex);
-    return match;
-  }
-}
-
-const leadingRe = / +(?=[^\s])/y;
-export function blockString(string: string) {
-  let out = '';
-  let commonIndent = 0;
-  let firstNonEmptyLine = 0;
-  let lastNonEmptyLine = -1;
-  const lines = string.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    leadingRe.lastIndex = 0;
-    if (leadingRe.test(lines[i])) {
-      if (i && (!commonIndent || leadingRe.lastIndex < commonIndent))
-        commonIndent = leadingRe.lastIndex;
-      firstNonEmptyLine = firstNonEmptyLine || i;
-      lastNonEmptyLine = i;
-    }
-  }
-  for (let i = firstNonEmptyLine; i <= lastNonEmptyLine; i++) {
-    if (i !== firstNonEmptyLine) out += '\n';
-    out += lines[i].slice(commonIndent);
-  }
-  return out;
-}
-
-const ignoredRe = /(?:[\s,]*|#[^\n\r]*)*/y;
-function ignored() {
-  ignoredRe.lastIndex = idx;
-  ignoredRe.test(input);
-  idx = ignoredRe.lastIndex;
-}
-
-const nameRe = /[_\w][_\d\w]*/y;
-function name(): ast.NameNode | undefined {
-  let match: string | undefined;
-  if (match = advance(nameRe)) {
-    return {
-      kind: Kind.NAME,
-      value: match,
-    };
-  }
-}
-
-const nullRe = /null/y;
-const boolRe = /true|false/y;
-const variableRe = /\$[_\w][_\d\w]*/y;
-const intRe = /[-]?\d+/y;
-const floatRe = /[-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
-const complexStringRe = /\\/g;
-const blockStringRe = /"""(?:[\s\S]+(?="""))?"""/y;
-const stringRe = /"(?:[^"\r\n]+)?"/y;
-
-function value(constant: true): ast.ConstValueNode;
-function value(constant: boolean): ast.ValueNode;
-
-function value(constant: boolean): ast.ValueNode | undefined {
-  let out: ast.ValueNode | undefined;
-  let match: string | undefined;
-  if (advance(nullRe)) {
-    out = { kind: Kind.NULL };
-  } else if (match = advance(boolRe)) {
-    out = {
-      kind: Kind.BOOLEAN,
-      value: match === 'true',
-    };
-  } else if (!constant && (match = advance(variableRe))) {
-    out = {
-      kind: Kind.VARIABLE,
-      name: {
-        kind: Kind.NAME,
-        value: match.slice(1),
-      },
-    };
-  } else if (match = advance(floatRe)) {
-    out = {
-      kind: Kind.FLOAT,
-      value: match,
-    };
-  } else if (match = advance(intRe)) {
-    out = {
-      kind: Kind.INT,
-      value: match,
-    };
-  } else if (match = advance(nameRe)) {
-    out = {
-      kind: Kind.ENUM,
-      value: match,
-    };
-  } else if (match = advance(blockStringRe)) {
-    out = {
-      kind: Kind.STRING,
-      value: blockString(match.slice(3, -3)),
-      block: true,
-    };
-  } else if (match = advance(stringRe)) {
-    out = {
-      kind: Kind.STRING,
-      value: complexStringRe.test(match)
-        ? JSON.parse(match) as string
-        : match.slice(1, -1),
-      block: false,
-    };
-  } else if (out = list(constant) || object(constant)) {
-    return out;
-  }
-
-  ignored();
-  return out;
-}
-
-function list(constant: boolean): ast.ListValueNode | undefined {
-  let match: ast.ValueNode | undefined;
-  if (input.charCodeAt(idx) === 91 /*'['*/) {
-    idx++;
-    ignored();
-    const values: ast.ValueNode[] = [];
-    while (match = value(constant))
-      values.push(match);
-    if (input.charCodeAt(idx++) !== 93 /*']'*/)
-      throw error(Kind.LIST);
-    ignored();
-    return {
-      kind: Kind.LIST,
-      values,
-    };
-  }
-}
-
-function object(constant: boolean): ast.ObjectValueNode | undefined {
-  if (input.charCodeAt(idx) === 123 /*'{'*/) {
-    idx++;
-    ignored();
-    const fields: ast.ObjectFieldNode[] = [];
-    let _name: ast.NameNode | undefined;
-    while (_name = name()) {
-      ignored();
-      if (input.charCodeAt(idx++) !== 58 /*':'*/)
-        throw error(Kind.OBJECT_FIELD);
-      ignored();
-      const _value = value(constant);
-      if (!_value)
-        throw error(Kind.OBJECT_FIELD);
-      fields.push({
-        kind: Kind.OBJECT_FIELD,
-        name: _name,
-        value: _value,
-      });
-    }
-    if (input.charCodeAt(idx++) !== 125 /*'}'*/)
-      throw error(Kind.OBJECT);
-    ignored();
-    return {
-      kind: Kind.OBJECT,
-      fields,
-    };
-  }
-}
-
-function arguments_(constant: boolean): ast.ArgumentNode[] {
-  const args: ast.ArgumentNode[] = [];
-  ignored();
-  if (input.charCodeAt(idx) === 40 /*'('*/) {
-    idx++;
-    ignored();
-    let _name: ast.NameNode | undefined;
-    while (_name = name()) {
-      ignored();
-      if (input.charCodeAt(idx++) !== 58 /*':'*/)
-        throw error(Kind.ARGUMENT);
-      ignored();
-      const _value = value(constant);
-      if (!_value)
-        throw error(Kind.ARGUMENT);
-      args.push({
-        kind: Kind.ARGUMENT,
-        name: _name,
-        value: _value,
-      });
-    }
-    if (!args.length || input.charCodeAt(idx++) !== 41 /*')'*/)
-      throw error(Kind.ARGUMENT);
-    ignored();
-  }
-  return args;
-}
-
-function directives(constant: true): ast.ConstDirectiveNode[];
-function directives(constant: boolean): ast.DirectiveNode[];
-
-function directives(constant: boolean): ast.DirectiveNode[] {
-  const directives: ast.DirectiveNode[] = [];
-  ignored();
-  while (input.charCodeAt(idx) === 64 /*'@'*/) {
-    idx++;
-    const _name = name();
-    if (!_name)
-      throw error(Kind.DIRECTIVE);
-    ignored();
-    directives.push({
-      kind: Kind.DIRECTIVE,
-      name: _name,
-      arguments: arguments_(constant),
-    });
-  }
-  return directives;
-}
-
-function field(): ast.FieldNode | undefined {
-  ignored();
-  let _name = name();
-  if (_name) {
-    ignored();
-    let _alias: ast.NameNode | undefined;
-    if (input.charCodeAt(idx) === 58 /*':'*/) {
-      idx++;
-      ignored();
-      _alias = _name;
-      _name = name();
-      if (!_name)
-        throw error(Kind.FIELD);
-      ignored();
-    }
-    return {
-      kind: Kind.FIELD,
-      alias: _alias,
-      name: _name,
-      arguments: arguments_(false),
-      directives: directives(false),
-      selectionSet: selectionSet(),
-    };
-  }
-}
-
-function type(): ast.TypeNode | undefined {
-  let match: ast.NameNode | ast.TypeNode | undefined;
-  ignored();
-  if (input.charCodeAt(idx) === 91 /*'['*/) {
-    idx++;
-    ignored();
-    const _type = type();
-    if (!_type || input.charCodeAt(idx++) !== 93 /*']'*/)
-      throw error(Kind.LIST_TYPE);
-    match = {
-      kind: Kind.LIST_TYPE,
-      type: _type,
-    };
-  } else if (match = name()) {
-    match = {
-      kind: Kind.NAMED_TYPE,
-      name: match,
-    };
-  } else {
-    throw error(Kind.NAMED_TYPE);
-  }
-
-  ignored();
-  if (input.charCodeAt(idx) === 33 /*'!'*/) {
-    idx++;
-    ignored();
-    return {
-      kind: Kind.NON_NULL_TYPE,
-      type: match,
-    };
-  } else {
-    return match;
-  }
-}
-
-const typeConditionRe = /on/y;
-function typeCondition(): ast.NamedTypeNode | undefined {
-  if (advance(typeConditionRe)) {
-    ignored();
-    const _name = name();
-    if (!_name)
-      throw error(Kind.NAMED_TYPE);
-    ignored();
-    return {
-      kind: Kind.NAMED_TYPE,
-      name: _name,
-    };
-  }
-}
-
-const fragmentSpreadRe = /\.\.\./y;
-
-function fragmentSpread(): ast.FragmentSpreadNode | ast.InlineFragmentNode | undefined {
-  ignored();
-  if (advance(fragmentSpreadRe)) {
-    ignored();
-    let _name: ast.NameNode | undefined;
-    if (_name = name()) {
-      return {
-        kind: Kind.FRAGMENT_SPREAD,
-        name: _name,
-        directives: directives(false),
-      };
-    } else {
-      const _typeCondition = typeCondition();
-      const _directives = directives(false);
-      const _selectionSet = selectionSet();
-      if (!_selectionSet)
-        throw error(Kind.INLINE_FRAGMENT);
-      return {
-        kind: Kind.INLINE_FRAGMENT,
-        typeCondition: _typeCondition,
-        directives: _directives,
-        selectionSet: _selectionSet,
-      };
-    }
-  }
-}
-
-function selectionSet(): ast.SelectionSetNode | undefined {
-  let match: ast.SelectionNode | undefined;
-  ignored();
-  if (input.charCodeAt(idx) === 123 /*'{'*/) {
-    idx++;
-    ignored();
-    const selections: ast.SelectionNode[] = [];
-    while (match = fragmentSpread() || field())
-      selections.push(match);
-    if (!selections.length || input.charCodeAt(idx++) !== 125 /*'}'*/)
-      throw error(Kind.SELECTION_SET);
-    ignored();
-    return {
-      kind: Kind.SELECTION_SET,
-      selections,
-    };
-  }
-}
-
-function variableDefinitions(): ast.VariableDefinitionNode[] {
-  let match: string | undefined;
-  const vars: ast.VariableDefinitionNode[] = [];
-  ignored();
-  if (input.charCodeAt(idx) === 40 /*'('*/) {
-    idx++;
-    ignored();
-    while (match = advance(variableRe)) {
-      ignored();
-      if (input.charCodeAt(idx++) !== 58 /*':'*/)
-        throw error(Kind.VARIABLE_DEFINITION);
-      const _type = type();
-      if (!_type)
-        throw error(Kind.VARIABLE_DEFINITION);
-      let _defaultValue: ast.ValueNode | undefined;
-      if (input.charCodeAt(idx) === 61 /*'='*/) {
-        idx++;
-        ignored();
-        _defaultValue = value(true);
-        if (!_defaultValue)
-          throw error(Kind.VARIABLE_DEFINITION);
-      }
-      ignored();
-      vars.push({
-        kind: Kind.VARIABLE_DEFINITION,
-        variable: {
-          kind: Kind.VARIABLE,
-          name: {
-            kind: Kind.NAME,
-            value: match.slice(1),
-          },
-        },
-        type: _type,
-        defaultValue: _defaultValue as ast.ConstValueNode,
-        directives: directives(true),
-      });
-    }
-    if (input.charCodeAt(idx++) !== 41 /*')'*/)
-      throw error(Kind.VARIABLE_DEFINITION);
-    ignored();
-  }
-  return vars;
-}
-
-const fragmentDefinitionRe = /fragment/y;
-function fragmentDefinition(): ast.FragmentDefinitionNode | undefined {
-  if (advance(fragmentDefinitionRe)) {
-    ignored();
-    const _name = name();
-    if (!_name)
-      throw error(Kind.FRAGMENT_DEFINITION);
-    ignored();
-    const _typeCondition = typeCondition();
-    if (!_typeCondition)
-      throw error(Kind.FRAGMENT_DEFINITION);
-    const _directives = directives(false);
-    const _selectionSet = selectionSet();
-    if (!_selectionSet)
-      throw error(Kind.FRAGMENT_DEFINITION);
-    return {
-      kind: Kind.FRAGMENT_DEFINITION,
-      name: _name,
-      typeCondition: _typeCondition,
-      directives: _directives,
-      selectionSet: _selectionSet,
-    };
-  }
-}
-
-const operationDefinitionRe = /query|mutation|subscription/y;
-function operationDefinition(): ast.OperationDefinitionNode | undefined {
-  let _operation: string | undefined;
-  let _name: ast.NameNode | undefined;
-  let _variableDefinitions: ast.VariableDefinitionNode[] = [];
-  let _directives: ast.DirectiveNode[] = [];
-  if (_operation = advance(operationDefinitionRe)) {
-    ignored();
-    _name = name();
-    _variableDefinitions = variableDefinitions();
-    _directives = directives(false);
-  }
-  const _selectionSet = selectionSet();
-  if (_selectionSet) {
-    return {
-      kind: Kind.OPERATION_DEFINITION,
-      operation: (_operation || 'query') as ast.OperationTypeNode,
-      name: _name,
-      variableDefinitions: _variableDefinitions,
-      directives: _directives,
-      selectionSet: _selectionSet,
-    };
-  }
-}
-
-function document(): ast.DocumentNode {
-  let match: ast.DefinitionNode | void;
-  ignored();
-  const definitions: ast.DefinitionNode[] = [];
-  while (match = fragmentDefinition() || operationDefinition())
-    definitions.push(match);
-  if (idx !== input.length)
-    throw error(Kind.DOCUMENT);
-  return {
-    kind: Kind.DOCUMENT,
-    definitions,
-  };
-}
-
-export function parse(string: string): ast.DocumentNode {
-  input = string;
-  idx = 0;
-  return document();
-}
-
-export function parseValue(string: string): ast.ValueNode | undefined {
-  input = string;
-  idx = 0;
-  ignored();
-  return value(false);
-}
-
-export function parseType(string: string): ast.TypeNode | undefined {
-  input = string;
-  idx = 0;
-  return type();
-}

package/src/printer.ts

@@ -1,132 +0,0 @@
-import { Kind } from './kind';
-import { ASTNode } from './ast';
-
-export function printString(string: string) {
-  return JSON.stringify(string);
-}
-
-export function printBlockString(string: string) {
-  return '"""\n' + string.replace(/"""/g, '\\"""') + '\n"""';
-}
-
-const hasItems = <T>(
-  array: ReadonlyArray<T> | undefined | null
-): array is ReadonlyArray<T> => !!(array && array.length);
-
-export function print(node: ASTNode): string {
-  let out: string;
-  switch (node.kind) {
-    case Kind.OPERATION_DEFINITION:
-      if (node.operation === 'query' && !node.name && !hasItems(node.variableDefinitions) && !hasItems(node.directives)) {
-        return print(node.selectionSet);
-      }
-      out = node.operation;
-      if (node.name)
-        out += ' ' + node.name.value;
-      if (hasItems(node.variableDefinitions)) {
-        if (!node.name) out += ' ';
-        out += '(' + node.variableDefinitions.map(print).join(', ') + ')';
-      }
-      if (hasItems(node.directives))
-        out += ' ' + node.directives.map(print).join(' ');
-      return out + ' ' + print(node.selectionSet);
-
-    case Kind.VARIABLE_DEFINITION:
-      out = print(node.variable) +
-        ': ' +
-        print(node.type);
-      if (node.defaultValue)
-        out += ' = ' + print(node.defaultValue);
-      if (hasItems(node.directives))
-        out += ' ' + node.directives.map(print).join(' ');
-      return out;
-
-    case Kind.FIELD:
-      out = (node.alias ? print(node.alias) + ': ' : '') + node.name.value
-      if (hasItems(node.arguments))
-        out += '(' + node.arguments.map(print).join(', ') + ')';
-      if (hasItems(node.directives))
-        out += ' ' + node.directives.map(print).join(' ');
-      return node.selectionSet
-        ? out + ' ' + print(node.selectionSet)
-        : out;
-
-    case Kind.STRING:
-      return node.block
-        ? printBlockString(node.value)
-        : printString(node.value);
-
-    case Kind.BOOLEAN:
-      return '' + node.value;
-
-    case Kind.NULL:
-      return 'null';
-
-    case Kind.INT:
-    case Kind.FLOAT:
-    case Kind.ENUM:
-    case Kind.NAME:
-      return node.value;
-
-    case Kind.LIST:
-      return '[' + node.values.map(print).join(', ') + ']';
-
-    case Kind.OBJECT:
-      return '{' + node.fields.map(print).join(', ') + '}';
-
-    case Kind.OBJECT_FIELD:
-      return node.name.value + ': ' + print(node.value);
-
-    case Kind.VARIABLE:
-      return '$' + node.name.value;
-
-    case Kind.DOCUMENT:
-      return hasItems(node.definitions)
-        ? node.definitions.map(print).join('\n\n')
-        : '';
-
-    case Kind.SELECTION_SET:
-      return '{\n  ' +
-        node.selections.map(print).join('\n').replace(/\n/g, '\n  ') +
-        '\n}';
-
-    case Kind.ARGUMENT:
-      return node.name.value + ': ' + print(node.value);
-
-    case Kind.FRAGMENT_SPREAD:
-      out = '...' + node.name.value;
-      if (hasItems(node.directives))
-        out += ' ' + node.directives.map(print).join(' ');
-      return out;
-
-    case Kind.INLINE_FRAGMENT:
-      out = '...';
-      if (node.typeCondition)
-        out += ' on ' + node.typeCondition.name.value;
-      if (hasItems(node.directives))
-        out += ' ' + node.directives.map(print).join(' ');
-      return out + ' ' + print(node.selectionSet);
-
-    case Kind.FRAGMENT_DEFINITION:
-      out = 'fragment ' + node.name.value;
-      out += ' on ' + node.typeCondition.name.value;
-      if (hasItems(node.directives))
-        out += ' ' + node.directives.map(print).join(' ');
-      return out + ' ' + print(node.selectionSet);
-      
-    case Kind.DIRECTIVE:
-      out = '@' + node.name.value;
-      if (hasItems(node.arguments))
-        out += '(' + node.arguments.map(print).join(', ') + ')';
-      return out;
-
-    case Kind.NAMED_TYPE:
-      return node.name.value;
-
-    case Kind.LIST_TYPE:
-      return '[' + print(node.type) + ']';
-
-    case Kind.NON_NULL_TYPE:
-      return print(node.type) + '!';
-  }
-}

package/src/types.ts

@@ -1,5 +0,0 @@
-export type Maybe<T> = T | undefined | null;
-
-export interface Extensions {
-  [extension: string]: unknown;
-}