@luvio/graphql-parser 0.126.0 → 0.126.2

package/src/fragment-spread-node.ts

@@ -1,28 +0,0 @@
-import type { FragmentSpreadNode } from 'graphql/language';
-import type { LuvioFragmentSpreadNode } from './ast';
-import { transform as transformDirectiveNode } from './directive-node';
-import type { TransformState } from './operation/query';
-
-export function transform(
-    node: FragmentSpreadNode,
-    transformState: TransformState
-): LuvioFragmentSpreadNode {
-    const {
-        kind,
-        name: { value },
-        directives,
-    } = node;
-
-    const luvioNode: LuvioFragmentSpreadNode = {
-        kind,
-        name: value,
-    };
-
-    if (directives !== undefined && directives.length > 0) {
-        luvioNode.directives = directives.map((directive) =>
-            transformDirectiveNode(directive, transformState)
-        );
-    }
-
-    return luvioNode;
-}

package/src/fragment.ts

@@ -1,46 +0,0 @@
-import type { FragmentDefinitionNode } from 'graphql/language';
-import type { LuvioFieldNode, LuvioFragmentDefinitionNode, LuvioSelectionNode } from './ast';
-import { selectionSetVisitor } from './visitor';
-import { transform as transformDirectiveNode } from './directive-node';
-import { NODE_KIND_OBJECT_FIELD_SELECTION } from './constants';
-
-export function transform(node: FragmentDefinitionNode): LuvioFragmentDefinitionNode {
-    const {
-        kind: nodeKind,
-        name: { value: nodeName },
-        typeCondition: {
-            kind: typeKind,
-            name: { value: typeName },
-        },
-        directives,
-    } = node;
-
-    // dummy root node
-    const fragmentRoot: LuvioFieldNode = {
-        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
-        name: 'fragment',
-        luvioSelections: [],
-    };
-    const currentNodePath: LuvioSelectionNode[] = [fragmentRoot];
-
-    const transformState = { variablesUsed: {} };
-    selectionSetVisitor(node, currentNodePath, transformState);
-
-    const luvioNode: LuvioFragmentDefinitionNode = {
-        kind: nodeKind,
-        name: nodeName,
-        typeCondition: {
-            kind: typeKind,
-            name: typeName,
-        },
-        luvioSelections: fragmentRoot.luvioSelections!,
-    };
-
-    if (directives !== undefined && directives.length > 0) {
-        luvioNode.directives = directives.map((node) =>
-            transformDirectiveNode(node, transformState)
-        );
-    }
-
-    return luvioNode;
-}

package/src/gql.ts

@@ -1,222 +0,0 @@
-/**
- * Exposes a tagged template literal to parse graphql operation string
- * "gql" is the only publicly exposed method
- * @module gql
- */
-import type { DefinitionNode, DocumentNode } from 'graphql/language';
-import { parse } from 'graphql/language';
-import { stripIgnoredCharacters } from 'graphql/utilities';
-import { ObjectCreate, ObjectKeys } from './util/language';
-
-export type AstResolver = (astReference: any) => DocumentNode | undefined;
-
-/**
- * we should look into optimizing this before it turns into a memory hog
- * weakmaps, or limiting the size of the cache, or something
- */
-export const docMap = new Map<string, DocumentNode>();
-/**
- * Opaque reference map to return keys to userland
- * As a user shouldn't have access to the Document
- */
-export const referenceMap = new WeakMap<Object, DocumentNode>();
-
-/**
- * Strips characters that are not significant to the validity or execution
- * of a GraphQL document:
- *   - UnicodeBOM
- *   - WhiteSpace
- *   - LineTerminator
- *   - Comment
- *   - Comma
- *   - BlockString indentation
- */
-function operationKeyBuilder(inputString: string): string {
-    return stripIgnoredCharacters(inputString);
-}
-
-/**
- * Returns document node if cached or else update the cache and return the document node
- * @param inputString - operation string
- * @returns DocumentNode
- */
-export function parseDocument(inputString: string): DocumentNode | null {
-    const operationKey = operationKeyBuilder(inputString);
-    const cachedDoc = docMap.get(operationKey);
-    if (cachedDoc !== undefined) {
-        return cachedDoc;
-    }
-    // parse throws an GraphQLError in case of invalid query, should this be in try/catch?
-    const parsedDoc = parse(inputString);
-    if (!parsedDoc || parsedDoc.kind !== 'Document') {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Invalid graphql doc');
-        }
-        return null;
-    }
-
-    const parsedDocNoLoc = stripLocation(parsedDoc);
-
-    docMap.set(operationKey, parsedDocNoLoc);
-
-    return parsedDocNoLoc;
-}
-
-/**
- * If the input string has fragment substitution
- * Insert the fragments AST to the query document node
- */
-function insertFragments(doc: DocumentNode, fragments: DefinitionNode[]): DocumentNode {
-    fragments.forEach((fragment) => {
-        // @ts-ignore
-        // graphql describes definitions as "readonly"
-        // so we aren't supposed to mutate the document node
-        // but instead of parsing the fragment again, we substitute it's definition in the document node
-        doc.definitions.push(fragment);
-    });
-    return doc;
-}
-
-export function updateReferenceMapWithKnownKey(doc: DocumentNode, key: object): void {
-    referenceMap.set(key, doc);
-}
-
-export function updateReferenceMapAndGetKey(doc: DocumentNode): object {
-    const key = ObjectCreate(null);
-    updateReferenceMapWithKnownKey(doc, key);
-
-    return key;
-}
-
-/**
- * Insert string and fragment substitutions with the actual nodes
- * @param inputString
- * @param substitutions - string | fragment DocumentNode
- * @returns { operation string, fragment docs [] }
- */
-export function processSubstitutions(
-    inputString: ReadonlyArray<string>,
-    substitutions: (string | object)[]
-): { operationString: string; fragments: DefinitionNode[] } | null {
-    let outputString = '';
-    const fragments: DefinitionNode[] = [];
-    const subLength = substitutions.length;
-
-    for (let i = 0; i < subLength; i++) {
-        const substitution = substitutions[i];
-        outputString += inputString[i];
-
-        if (typeof substitution === 'string' || typeof substitution === 'number') {
-            outputString += substitution;
-        } else if (typeof substitution === 'object') {
-            const doc = referenceMap.get(substitution);
-
-            if (doc === undefined) {
-                if (process.env.NODE_ENV !== 'production') {
-                    throw new Error('Invalid substitution fragment');
-                }
-                return null;
-            }
-
-            for (const def of doc.definitions) {
-                fragments.push(def);
-            }
-        } else {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('Unsupported substitution type');
-            }
-            return null;
-        }
-    }
-
-    return {
-        operationString: outputString + inputString[subLength],
-        fragments,
-    };
-}
-
-/**
- * strips Document node and nested definitions of location references
- */
-export function stripLocation(node: any) {
-    if (node.loc) {
-        delete node.loc;
-    }
-    const keys = ObjectKeys(node);
-    const keysLength = keys.length;
-
-    if (keysLength === 0) {
-        return node;
-    }
-
-    for (const key of keys) {
-        const subNode = node[key];
-        if (subNode && typeof subNode === 'object') {
-            stripLocation(subNode);
-        }
-    }
-
-    return node;
-}
-
-/**
- *
- * @param astReference - ast reference passed from user land
- */
-export const astResolver: AstResolver = function (astReference: any) {
-    return referenceMap.get(astReference);
-};
-
-/**
- *
- * @param literals - operation query string
- * @param subs - all other substitutions
- * @returns an opaque reference to the parsed document
- */
-export function gql(
-    literals: ReadonlyArray<string> | string,
-    ...subs: (string | object)[]
-): object | null {
-    let inputString: string;
-    let inputSubstitutionFragments: DefinitionNode[];
-
-    if (!literals) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Invalid query');
-        }
-        return null;
-    } else if (typeof literals === 'string') {
-        inputString = literals.trim();
-        inputSubstitutionFragments = [];
-    } else {
-        // called as template literal
-        const sub = processSubstitutions(literals, subs);
-        // if invalid fragment references found
-        if (sub === null) {
-            return null;
-        }
-
-        const { operationString, fragments } = sub;
-        inputString = operationString.trim();
-        inputSubstitutionFragments = fragments;
-    }
-
-    if (inputString.length === 0) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Invalid query');
-        }
-        return null;
-    }
-
-    const document = parseDocument(inputString);
-
-    if (document === null) {
-        return null;
-    }
-
-    if (inputSubstitutionFragments.length === 0) {
-        return updateReferenceMapAndGetKey(document);
-    }
-
-    return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
-}

package/src/inline-fragment-node.ts

@@ -1,31 +0,0 @@
-import type { InlineFragmentNode } from 'graphql/language';
-import type { LuvioInlineFragmentNode } from './ast';
-import { transform as transformDirectiveNode } from './directive-node';
-import type { TransformState } from './operation/query';
-
-export function transform(
-    node: InlineFragmentNode,
-    transformState: TransformState
-): LuvioInlineFragmentNode {
-    const { kind: nodeKind, typeCondition, directives } = node;
-
-    const luvioNode: LuvioInlineFragmentNode = {
-        kind: nodeKind,
-        luvioSelections: [],
-    };
-
-    if (typeCondition !== undefined) {
-        luvioNode.typeCondition = {
-            kind: typeCondition.kind,
-            name: typeCondition.name.value,
-        };
-    }
-
-    if (directives !== undefined && directives.length > 0) {
-        luvioNode.directives = directives.map((directive) =>
-            transformDirectiveNode(directive, transformState)
-        );
-    }
-
-    return luvioNode;
-}

package/src/main.ts

@@ -1,134 +0,0 @@
-import {
-    GraphQLSchema,
-    GraphQLScalarType,
-    execute,
-    buildSchema,
-    getNamedType,
-    isObjectType,
-    validateSchema,
-    NameNode,
-    GraphQLError,
-    ObjectValueNode,
-    defaultFieldResolver,
-    type ASTNode,
-    type DefinitionNode,
-} from 'graphql';
-import { buildASTSchema } from 'graphql/utilities';
-
-import {
-    LuvioDocumentNode,
-    LuvioArgumentNode,
-    LuvioDefinitionNode,
-    LuvioObjectValueNode,
-    LuvioOperationDefinitionNode,
-    LuvioSelectionCustomFieldNode,
-    LuvioSelectionNode,
-    LuvioSelectionObjectFieldNode,
-    LuvioSelectionScalarFieldNode,
-    LuvioValueNode,
-    LuvioFieldNode,
-    LuvioVariableDefinitionNode,
-    LuvioVariableNode,
-    LuvioNamedTypeNode,
-    LuvioListTypeNode,
-    LuvioListValueNode,
-    LuvioTypeNode,
-} from './ast';
-import { transform } from './document';
-import { updateReferenceMapWithKnownKey } from './gql';
-import { metaschemaMapper } from './metaschema';
-
-export type {
-    GraphQLObjectType,
-    GraphQLInterfaceType,
-    GraphQLDirective,
-    GraphQLUnionType,
-    GraphQLNamedType,
-} from 'graphql/type';
-export type {
-    ListTypeNode,
-    BooleanValueNode,
-    EnumTypeDefinitionNode,
-    FieldDefinitionNode,
-    FloatValueNode,
-    InterfaceTypeDefinitionNode,
-    IntValueNode,
-    NamedTypeNode,
-    ObjectTypeDefinitionNode,
-    StringValueNode,
-    TypeNode,
-    UnionTypeDefinitionNode,
-    DocumentNode,
-    OperationDefinitionNode,
-    FieldNode,
-    ArgumentNode,
-    ValueNode,
-    SelectionNode,
-    SelectionSetNode,
-    FragmentDefinitionNode,
-    DirectiveNode,
-    ObjectFieldNode,
-    ScalarTypeDefinitionNode,
-    InputObjectTypeDefinitionNode,
-    InlineFragmentNode,
-    FragmentSpreadNode,
-} from 'graphql/language';
-import { parse } from 'graphql/language';
-export { ASTVisitor, parse, Kind, print, visit } from 'graphql/language';
-export { isScalarType } from 'graphql/type';
-export { stripIgnoredCharacters } from 'graphql/utilities';
-export { gql, astResolver } from './gql';
-export type { AstResolver } from './gql';
-
-/**
- * @deprecated - Schema-backed adapters will use standard graphql types re-exported from @luvio/graphql
- */
-export {
-    LuvioDocumentNode,
-    LuvioArgumentNode,
-    LuvioDefinitionNode,
-    LuvioObjectValueNode,
-    LuvioOperationDefinitionNode,
-    LuvioSelectionCustomFieldNode,
-    LuvioSelectionNode,
-    LuvioSelectionObjectFieldNode,
-    LuvioSelectionScalarFieldNode,
-    LuvioValueNode,
-    LuvioFieldNode,
-    LuvioVariableDefinitionNode,
-    LuvioVariableNode,
-    LuvioNamedTypeNode,
-    LuvioListTypeNode,
-    LuvioListValueNode,
-    LuvioTypeNode,
-    GraphQLSchema,
-    GraphQLScalarType,
-    NameNode,
-    GraphQLError,
-    ASTNode,
-    DefinitionNode,
-    ObjectValueNode,
-    buildASTSchema,
-    execute,
-    buildSchema,
-    getNamedType,
-    isObjectType,
-    validateSchema,
-    defaultFieldResolver,
-};
-
-/**
- * @deprecated In favor of gql tagged template literal
- */
-export function parseAndVisit(source: string): LuvioDocumentNode {
-    const ast = parse(source);
-    const luvioDocumentNode = transform(ast!);
-
-    // In-place substitution of metaschema annotations
-    metaschemaMapper(ast!);
-
-    // Set the AST reference map with LuvioDocumentNode as the key
-    // ASTResolver will resolve it to metaschema mapped AST
-    updateReferenceMapWithKnownKey(ast!, luvioDocumentNode);
-    return luvioDocumentNode;
-}

package/src/metaschema.ts

@@ -1,162 +0,0 @@
-/**
- * Add metaschema annotations to their corresponding custom notation counterparts
- * @module metaschemaMapper
- */
-import type {
-    DefinitionNode,
-    DirectiveNode,
-    DocumentNode,
-    FragmentSpreadNode,
-    SelectionNode,
-    SelectionSetNode,
-    TypeSystemDefinitionNode,
-    TypeSystemExtensionNode,
-} from 'graphql/language';
-import { CUSTOM_DIRECTIVE_CONNECTION, CUSTOM_DIRECTIVE_RESOURCE } from './constants';
-
-const DIRECTIVE_RECORD_CATEGORY = {
-    kind: 'Directive',
-    name: {
-        kind: 'Name',
-        value: 'category',
-    },
-    arguments: [
-        {
-            kind: 'Argument',
-            name: {
-                kind: 'Name',
-                value: 'name',
-            },
-            value: {
-                kind: 'StringValue',
-                value: 'recordQuery',
-                block: false,
-            },
-        },
-    ],
-};
-
-const DIRECTIVE_PARENT_CATEGORY = {
-    kind: 'Directive',
-    name: {
-        kind: 'Name',
-        value: 'category',
-    },
-    arguments: [
-        {
-            kind: 'Argument',
-            name: {
-                kind: 'Name',
-                value: 'name',
-            },
-            value: {
-                kind: 'StringValue',
-                value: 'parentRelationship',
-                block: false,
-            },
-        },
-    ],
-};
-
-function substituteDirectives(
-    directives: ReadonlyArray<DirectiveNode>,
-    index: number,
-    nodeName: string | undefined
-): void {
-    if (directives[index].name.value === CUSTOM_DIRECTIVE_CONNECTION) {
-        // replace the custom directive node with the metaschema directive node
-        // @ts-ignore - Document is read only
-        directives[index] = DIRECTIVE_RECORD_CATEGORY;
-    } else if (directives[index].name.value === CUSTOM_DIRECTIVE_RESOURCE) {
-        // node gets its type from @category recordQuery
-        if (nodeName === 'node') {
-            // @ts-ignore - Document is read only
-            directives.splice(index, 1);
-        } else {
-            // @ts-ignore - Document is read only
-            directives[index] = DIRECTIVE_PARENT_CATEGORY;
-        }
-    }
-}
-
-/**
- * Returns true if the directive node is of legacy type
- * @param node : Directive node
- * @returns
- */
-function isCustomDirective(node: DirectiveNode): boolean {
-    return (
-        node.name.value === CUSTOM_DIRECTIVE_CONNECTION ||
-        node.name.value === CUSTOM_DIRECTIVE_RESOURCE
-    );
-}
-
-type TraverseSelectionSetNode = SelectionSetNode | undefined;
-
-/**
- * Traverses a selection set and it's nested selections,
- * to find any legacy custom directives and substitute them with metaschema directives
- * @param node - SelectionSetNode
- * @returns SelectionSetNode
- */
-function traverseSelectionSet(node: TraverseSelectionSetNode): TraverseSelectionSetNode {
-    if (node === undefined) {
-        return;
-    }
-
-    for (const selection of node.selections) {
-        // FragmentSpreadNode doesn't have a selection set
-        // which should be handled at this methods entry point
-        const { directives, selectionSet } = selection as Exclude<
-            SelectionNode,
-            FragmentSpreadNode
-        >;
-        let selectionName: string | undefined;
-
-        if (selection.kind !== 'InlineFragment') {
-            selectionName = selection.name.value;
-        }
-
-        if (directives !== undefined && directives.length > 0) {
-            // we follow this pattern instead of map to preserve the order of directives
-            // order of directives may be significant as per graphql spec
-            const index = directives.findIndex(isCustomDirective);
-
-            if (index !== -1) {
-                substituteDirectives(directives, index, selectionName);
-            }
-        }
-
-        traverseSelectionSet(selectionSet);
-    }
-    return node;
-}
-
-/**
- * Accepts a document node and replaces the legacy custom directives with metaschema directives "in-place"
- * @param doc
- */
-export function metaschemaMapper(doc: DocumentNode): void {
-    // this method is only callable for Executable definitions
-    // such as Operations and Fragments
-    // so we have to explicitly cast the definitions for ts
-    const { definitions }: { definitions: unknown } = doc;
-
-    for (const def of definitions as ReadonlyArray<
-        Exclude<DefinitionNode, TypeSystemDefinitionNode | TypeSystemExtensionNode>
-    >) {
-        const { directives, selectionSet } = def;
-
-        if (directives !== undefined && directives.length > 0) {
-            // we are making an assumption here that only one custom directive can be applied to a node
-            // we can revisit if this condition changes
-            const index = directives.findIndex(isCustomDirective);
-
-            if (index !== -1) {
-                substituteDirectives(directives, index, undefined);
-            }
-        }
-
-        traverseSelectionSet(selectionSet);
-    }
-}

package/src/operation/index.ts

@@ -1,12 +0,0 @@
-import type { OperationDefinitionNode } from 'graphql/language';
-import type { LuvioOperationDefinitionNode } from '../ast';
-import { transform as QueryTransform } from './query';
-
-export function transform(node: OperationDefinitionNode): LuvioOperationDefinitionNode {
-    const { operation } = node;
-    if (operation === 'query') {
-        return QueryTransform(node);
-    }
-
-    throw new Error(`Unsupported ${operation} operation. Only query operation is supported`);
-}