@luvio/graphql-parser 0.98.0 → 0.99.2-240.0

package/dist/gql.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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';
+export declare 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 declare const docMap: Map<string, DocumentNode>;
+/**
+ * Opaque reference map to return keys to userland
+ * As a user shouldn't have access to the Document
+ */
+export declare const referenceMap: WeakMap<Object, DocumentNode>;
+export declare let addMetaschemaDirectives: boolean;
+/**
+ * Insert string and fragment substitutions with the actual nodes
+ * @param inputString
+ * @param substitutions - string | fragment DocumentNode
+ * @returns { operation string, fragment docs [] }
+ */
+export declare function processSubstitutions(inputString: ReadonlyArray<string>, substitutions: (string | object)[]): {
+    operationString: string;
+    fragments: DefinitionNode[];
+} | null;
+/**
+ * strips Document node and nested definitions of location references
+ */
+export declare function stripLocation(node: any): any;
+/**
+ *
+ * @param astReference - ast reference passed from user land
+ */
+export declare const astResolver: AstResolver;
+/**
+ *
+ * @param literals - operation query string
+ * @param subs - all other substitutions
+ * @returns an opaque reference to the parsed document
+ */
+export declare function gql(literals: ReadonlyArray<string> | string, ...subs: (string | object)[]): object | null;
+/**
+ * Enable the parser to add corresponding metaschema directives for backwards compatibility
+ */
+export declare function enableAddMetaschemaDirective(): void;
+export declare function disableAddMetaschemaDirective(): void;

package/dist/luvioGraphqlParser.js

@@ -10502,7 +10502,7 @@ function transform$9(node, transformState) {
     }
     return ret;
 }
-function isCustomDirective(node) {
+function isCustomDirective$1(node) {
     return (node.name.value === CUSTOM_DIRECTIVE_CONNECTION ||
         node.name.value === CUSTOM_DIRECTIVE_RESOURCE);
 }
@@ -10523,7 +10523,7 @@ function transform$8(node, transformState) {
     else {
         // object or custom field node
         if (directives !== undefined && directives.length > 0) {
-            const customDirectiveNode = directives.find(isCustomDirective);
+            const customDirectiveNode = directives.find(isCustomDirective$1);
             if (customDirectiveNode === undefined) {
                 // transform non client-side directives
                 luvioNode.directives = directives.map((directive) => transform$9(directive, transformState));
@@ -10800,6 +10800,322 @@ function transform(root) {
     };
 }
 
+const { create, keys } = Object;
+
+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, index, nodeName) {
+    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) {
+    return (node.name.value === CUSTOM_DIRECTIVE_CONNECTION ||
+        node.name.value === CUSTOM_DIRECTIVE_RESOURCE);
+}
+/**
+ * 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) {
+    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;
+        let selectionName;
+        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
+ */
+function metaschemaMapper(doc) {
+    // 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 } = doc;
+    for (const def of definitions) {
+        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);
+    }
+}
+
+/**
+ * we should look into optimizing this before it turns into a memory hog
+ * weakmaps, or limiting the size of the cache, or something
+ */
+const docMap = new Map();
+/**
+ * Opaque reference map to return keys to userland
+ * As a user shouldn't have access to the Document
+ */
+const referenceMap = new WeakMap();
+let addMetaschemaDirectives = false;
+/**
+ * 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) {
+    return stripIgnoredCharacters(inputString);
+}
+/**
+ * Returns document node if cached or else update the cache and return the document node
+ * @param inputString - operation string
+ * @returns DocumentNode
+ */
+function parseDocument(inputString) {
+    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;
+    }
+    // in-place substitution for removal of legacy and adding metaschema directives
+    if (addMetaschemaDirectives) {
+        metaschemaMapper(parsedDoc);
+    }
+    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, fragments) {
+    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;
+}
+function createReference(document) {
+    const key = create(null);
+    referenceMap.set(key, document);
+    return key;
+}
+/**
+ * Insert string and fragment substitutions with the actual nodes
+ * @param inputString
+ * @param substitutions - string | fragment DocumentNode
+ * @returns { operation string, fragment docs [] }
+ */
+function processSubstitutions(inputString, substitutions) {
+    let outputString = '';
+    const fragments = [];
+    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
+ */
+function stripLocation(node) {
+    if (node.loc) {
+        delete node.loc;
+    }
+    const keys$1 = keys(node);
+    const keysLength = keys$1.length;
+    if (keysLength === 0) {
+        return node;
+    }
+    for (const key of keys$1) {
+        const subNode = node[key];
+        if (subNode && typeof subNode === 'object') {
+            stripLocation(subNode);
+        }
+    }
+    return node;
+}
+/**
+ *
+ * @param astReference - ast reference passed from user land
+ */
+const astResolver = function (astReference) {
+    return referenceMap.get(astReference);
+};
+/**
+ *
+ * @param literals - operation query string
+ * @param subs - all other substitutions
+ * @returns an opaque reference to the parsed document
+ */
+function gql(literals, ...subs) {
+    let inputString;
+    let inputSubstitutionFragments;
+    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 createReference(document);
+    }
+    return createReference(insertFragments(document, inputSubstitutionFragments));
+}
+/**
+ * Enable the parser to add corresponding metaschema directives for backwards compatibility
+ */
+function enableAddMetaschemaDirective() {
+    addMetaschemaDirectives = true;
+}
+function disableAddMetaschemaDirective() {
+    addMetaschemaDirectives = false;
+}
+
 /*
     Deprecated - Remove after existing usages are removed.
 */
@@ -10811,7 +11127,11 @@ function parseAndVisit(source) {
 exports.GraphQLScalarType = GraphQLScalarType;
 exports.GraphQLSchema = GraphQLSchema;
 exports.Kind = Kind;
+exports.astResolver = astResolver;
 exports.buildASTSchema = buildASTSchema;
+exports.disableAddMetaschemaDirective = disableAddMetaschemaDirective;
+exports.enableAddMetaschemaDirective = enableAddMetaschemaDirective;
+exports.gql = gql;
 exports.isScalarType = isScalarType;
 exports.parse = parse;
 exports.parseAndVisit = parseAndVisit;