@luvio/graphql-parser 0.138.1 → 0.138.2

package/dist/luvioGraphqlParser.js

@@ -10728,744 +10728,744 @@ function dedentBlockString(blockStr) {
   return '"""' + body + '"""';
 }
 
-/* Util Functions */
-function isOperationDefinitionNode(input) {
-    return input.kind === 'OperationDefinition';
-}
-function isFragmentDefinitionNode(input) {
-    return input.kind === 'FragmentDefinition';
-}
-function isNamedTypeNode(input) {
-    return input.kind === 'NamedType';
-}
-function isListTypeNode(input) {
-    return input.kind === 'ListType';
-}
-function isNonNullTypeNode(input) {
-    return input.kind === 'NonNullType';
-}
-
-const CUSTOM_DIRECTIVE_CONNECTION = 'connection';
-const CUSTOM_DIRECTIVE_RESOURCE = 'resource';
-const NODE_KIND_CUSTOM_FIELD_SELECTION = 'CustomFieldSelection';
-const NODE_KIND_FIELD = 'Field';
-const NODE_KIND_FRAGMENT_SPREAD = 'FragmentSpread';
-const NODE_KIND_INLINE_FRAGMENT = 'InlineFragment';
-const NODE_KIND_LIST_TYPE = 'ListType';
-const NODE_KIND_NAMED_TYPE = 'NamedType';
-const NODE_KIND_NON_NULL_TYPE = 'NonNullType';
-const NODE_KIND_OBJECT_FIELD_SELECTION = 'ObjectFieldSelection';
-const NODE_KIND_SCALAR_FIELD_SELECTION = 'ScalarFieldSelection';
+/* Util Functions */
+function isOperationDefinitionNode(input) {
+    return input.kind === 'OperationDefinition';
+}
+function isFragmentDefinitionNode(input) {
+    return input.kind === 'FragmentDefinition';
+}
+function isNamedTypeNode(input) {
+    return input.kind === 'NamedType';
+}
+function isListTypeNode(input) {
+    return input.kind === 'ListType';
+}
+function isNonNullTypeNode(input) {
+    return input.kind === 'NonNullType';
+}
+
+const CUSTOM_DIRECTIVE_CONNECTION = 'connection';
+const CUSTOM_DIRECTIVE_RESOURCE = 'resource';
+const NODE_KIND_CUSTOM_FIELD_SELECTION = 'CustomFieldSelection';
+const NODE_KIND_FIELD = 'Field';
+const NODE_KIND_FRAGMENT_SPREAD = 'FragmentSpread';
+const NODE_KIND_INLINE_FRAGMENT = 'InlineFragment';
+const NODE_KIND_LIST_TYPE = 'ListType';
+const NODE_KIND_NAMED_TYPE = 'NamedType';
+const NODE_KIND_NON_NULL_TYPE = 'NonNullType';
+const NODE_KIND_OBJECT_FIELD_SELECTION = 'ObjectFieldSelection';
+const NODE_KIND_SCALAR_FIELD_SELECTION = 'ScalarFieldSelection';
 const NODE_TYPE_CONNECTION = 'Connection';
 
-function transform$b(node, transformState) {
-    switch (node.kind) {
-        case 'Variable':
-            transformState.variablesUsed[node.name.value] = true;
-            return {
-                kind: 'Variable',
-                name: node.name.value,
-            };
-        case 'IntValue':
-            return {
-                kind: 'IntValue',
-                value: node.value,
-            };
-        case 'FloatValue':
-            return {
-                kind: 'FloatValue',
-                value: node.value,
-            };
-        case 'StringValue':
-            return {
-                kind: 'StringValue',
-                value: node.value,
-            };
-        case 'BooleanValue':
-            return {
-                kind: 'BooleanValue',
-                value: node.value,
-            };
-        case 'EnumValue':
-            return {
-                kind: 'EnumValue',
-                value: node.value,
-            };
-        case 'NullValue':
-            return {
-                kind: 'NullValue',
-            };
-        case 'ListValue': {
-            const values = [];
-            for (var index = 0; index < node.values.length; index++) {
-                const value = transform$b(node.values[index], transformState);
-                values.push(value);
-            }
-            return {
-                kind: 'ListValue',
-                values: values,
-            };
-        }
-        case 'ObjectValue': {
-            const { fields } = node;
-            const result = {};
-            fields.forEach((field) => {
-                const name = field.name.value;
-                const value = transform$b(field.value, transformState);
-                result[name] = value;
-            });
-            return {
-                kind: 'ObjectValue',
-                fields: result,
-            };
-        }
-        default:
-            throw new Error('Unsupported ValueNode kind');
-    }
-}
-
-function transform$a(node, transformState) {
-    const { kind, name: { value: nodeName }, value: nodeValue, } = node;
-    const valueNode = transform$b(nodeValue, transformState);
-    return {
-        kind,
-        name: nodeName,
-        value: valueNode,
-    };
-}
-
-function transform$9(node, transformState) {
-    const { kind, name: { value: nodeName }, arguments: nodeArguments, } = node;
-    const ret = {
-        kind,
-        name: nodeName,
-    };
-    if (nodeArguments !== undefined && nodeArguments.length > 0) {
-        let returnArguments = [];
-        for (var index = 0; index < nodeArguments.length; index++) {
-            const argumentNode = nodeArguments[index];
-            const value = transform$a(argumentNode, transformState);
-            returnArguments.push(value);
-        }
-        ret.arguments = returnArguments;
-    }
-    return ret;
-}
-function isCustomDirective$1(node) {
-    return (node.name.value === CUSTOM_DIRECTIVE_CONNECTION ||
-        node.name.value === CUSTOM_DIRECTIVE_RESOURCE);
-}
-
-function transform$8(node, transformState) {
-    const { name, alias, arguments: fieldArgs, selectionSet, directives } = node;
-    let luvioNode = {
-        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
-        name: name.value,
-        luvioSelections: [],
-    };
-    if (selectionSet === undefined || selectionSet.selections.length === 0) {
-        luvioNode = {
-            kind: NODE_KIND_SCALAR_FIELD_SELECTION,
-            name: name.value,
-        };
-    }
-    else {
-        // object or custom field node
-        if (directives !== undefined && directives.length > 0) {
-            const customDirectiveNode = directives.find(isCustomDirective$1);
-            if (customDirectiveNode === undefined) {
-                // transform non client-side directives
-                luvioNode.directives = directives.map((directive) => transform$9(directive, transformState));
-            }
-            else {
-                if (customDirectiveNode.name.value === CUSTOM_DIRECTIVE_CONNECTION) {
-                    luvioNode = {
-                        kind: NODE_KIND_CUSTOM_FIELD_SELECTION,
-                        name: name.value,
-                        type: NODE_TYPE_CONNECTION,
-                        luvioSelections: [],
-                    };
-                }
-                else if (customDirectiveNode.name.value === CUSTOM_DIRECTIVE_RESOURCE) {
-                    luvioNode = {
-                        kind: NODE_KIND_CUSTOM_FIELD_SELECTION,
-                        name: name.value,
-                        type: customDirectiveNode.arguments[0].value.value,
-                        luvioSelections: [],
-                    };
-                }
-            }
-        }
-        if (fieldArgs !== undefined && fieldArgs.length > 0) {
-            const returnArguments = [];
-            for (var index = 0; index < fieldArgs.length; index++) {
-                const value = transform$a(fieldArgs[index], transformState);
-                returnArguments.push(value);
-            }
-            luvioNode.arguments = returnArguments;
-        }
-    }
-    if (alias !== undefined) {
-        luvioNode.alias = alias.value;
-    }
-    return luvioNode;
-}
-
-function transform$7(node, transformState) {
-    const { kind, name: { value }, directives, } = node;
-    const luvioNode = {
-        kind,
-        name: value,
-    };
-    if (directives !== undefined && directives.length > 0) {
-        luvioNode.directives = directives.map((directive) => transform$9(directive, transformState));
-    }
-    return luvioNode;
-}
-
-function transform$6(node, transformState) {
-    const { kind: nodeKind, typeCondition, directives } = node;
-    const luvioNode = {
-        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) => transform$9(directive, transformState));
-    }
-    return luvioNode;
-}
-
-function selectionSetVisitor(ast, luvioSelectionPath, transformState) {
-    const visitor = {
-        enter(node) {
-            let selectionNode;
-            switch (node.kind) {
-                case NODE_KIND_FIELD: {
-                    const fieldNode = transform$8(node, transformState);
-                    selectionNode = fieldNode;
-                    break;
-                }
-                case NODE_KIND_FRAGMENT_SPREAD:
-                    selectionNode = transform$7(node, transformState);
-                    break;
-                case NODE_KIND_INLINE_FRAGMENT:
-                    selectionNode = transform$6(node, transformState);
-                    break;
-            }
-            if (selectionNode !== undefined) {
-                const parentNode = luvioSelectionPath[luvioSelectionPath.length - 1];
-                if (parentNode.kind === NODE_KIND_OBJECT_FIELD_SELECTION ||
-                    parentNode.kind === NODE_KIND_CUSTOM_FIELD_SELECTION ||
-                    parentNode.kind === NODE_KIND_INLINE_FRAGMENT) {
-                    parentNode.luvioSelections.push(selectionNode);
-                }
-                luvioSelectionPath.push(selectionNode);
-            }
-        },
-        leave(node) {
-            switch (node.kind) {
-                case NODE_KIND_FIELD:
-                case NODE_KIND_FRAGMENT_SPREAD:
-                case NODE_KIND_INLINE_FRAGMENT:
-                    luvioSelectionPath.pop();
-                    break;
-            }
-        },
-    };
-    visit(ast, visitor);
-}
-
-function transform$5(node) {
-    if (isNamedTypeNode(node)) {
-        return {
-            kind: NODE_KIND_NAMED_TYPE,
-            name: node.name.value,
-        };
-    }
-    else if (isListTypeNode(node)) {
-        return {
-            kind: NODE_KIND_LIST_TYPE,
-            type: transform$5(node.type),
-        };
-    }
-    else if (isNonNullTypeNode(node)) {
-        if (isNamedTypeNode(node.type)) {
-            return {
-                kind: NODE_KIND_NON_NULL_TYPE,
-                type: {
-                    kind: NODE_KIND_NAMED_TYPE,
-                    name: node.type.name.value,
-                },
-            };
-        }
-        else if (isListTypeNode(node.type)) {
-            return {
-                kind: NODE_KIND_NON_NULL_TYPE,
-                type: {
-                    kind: NODE_KIND_LIST_TYPE,
-                    type: transform$5(node.type.type),
-                },
-            };
-        }
-        else {
-            throw new Error('Unsupported NonNullTypeNode');
-        }
-    }
-    else {
-        throw new Error('Unsupported TypeNode');
-    }
-}
-
-function transform$4(variableDefinitions, transformState) {
-    const { kind, variable: { kind: variableKind, name: { value: variableName }, }, type, defaultValue, } = variableDefinitions;
-    const ret = {
-        kind,
-        variable: {
-            kind: variableKind,
-            name: variableName,
-        },
-        type: transform$5(type),
-    };
-    if (defaultValue !== undefined) {
-        const value = transform$b(defaultValue, transformState);
-        ret.defaultValue = value;
-    }
-    // TODO: transform directives
-    return ret;
-}
-
-function validateVariables(variableDefinitions, transformState) {
-    if (process.env.NODE_ENV === 'production') {
-        throw new ReferenceError("Do not call this function in production becuase we don't want to break existing uses. Other environments are okay because we want to catch errors early.");
-    }
-    const variablesDefined = {};
-    if (variableDefinitions !== undefined) {
-        for (let i = 0, len = variableDefinitions.length; i < len; i++) {
-            const definedVariableName = variableDefinitions[i].variable.name.value;
-            variablesDefined[definedVariableName] = true;
-            if (transformState.variablesUsed[definedVariableName] === undefined) {
-                throw new Error(`Variable $${definedVariableName} was defined but never used.`);
-            }
-        }
-    }
-    const usedVariableKeys = Object.keys(transformState.variablesUsed);
-    for (let i = 0, len = usedVariableKeys.length; i < len; i++) {
-        if (variablesDefined[usedVariableKeys[i]] !== true) {
-            throw new Error(`Variable $${usedVariableKeys[i]} was used but never defined.`);
-        }
-    }
-}
-function transform$3(node) {
-    const queryRoot = {
-        kind: 'ObjectFieldSelection',
-        name: 'query',
-        luvioSelections: [],
-    };
-    const currentNodePath = [queryRoot];
-    const transformState = {
-        variablesUsed: {},
-    };
-    selectionSetVisitor(node, currentNodePath, transformState);
-    const operationDefinition = {
-        kind: 'OperationDefinition',
-        operation: 'query',
-        luvioSelections: queryRoot.luvioSelections,
-    };
-    if (node.name !== undefined) {
-        operationDefinition.name = node.name.value;
-    }
-    const { variableDefinitions, directives } = node;
-    if (variableDefinitions !== undefined && variableDefinitions.length > 0) {
-        operationDefinition.variableDefinitions = variableDefinitions.map((variableDefinition) => transform$4(variableDefinition, transformState));
-    }
-    if (directives !== undefined && directives.length > 0) {
-        operationDefinition.directives = directives.map((node) => transform$9(node, transformState));
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        validateVariables(variableDefinitions, transformState);
-    }
-    return operationDefinition;
-}
-
-function transform$2(node) {
-    const { operation } = node;
-    if (operation === 'query') {
-        return transform$3(node);
-    }
-    throw new Error(`Unsupported ${operation} operation. Only query operation is supported`);
-}
-
-function transform$1(node) {
-    const { kind: nodeKind, name: { value: nodeName }, typeCondition: { kind: typeKind, name: { value: typeName }, }, directives, } = node;
-    // dummy root node
-    const fragmentRoot = {
-        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
-        name: 'fragment',
-        luvioSelections: [],
-    };
-    const currentNodePath = [fragmentRoot];
-    const transformState = { variablesUsed: {} };
-    selectionSetVisitor(node, currentNodePath, transformState);
-    const luvioNode = {
-        kind: nodeKind,
-        name: nodeName,
-        typeCondition: {
-            kind: typeKind,
-            name: typeName,
-        },
-        luvioSelections: fragmentRoot.luvioSelections,
-    };
-    if (directives !== undefined && directives.length > 0) {
-        luvioNode.directives = directives.map((node) => transform$9(node, transformState));
-    }
-    return luvioNode;
-}
-
-function transform(root) {
-    const { kind, definitions } = root;
-    const luvioDefinitions = [];
-    for (let i = 0; i < definitions.length; i++) {
-        const definition = definitions[i];
-        if (isOperationDefinitionNode(definition)) {
-            luvioDefinitions.push(transform$2(definition));
-        }
-        else if (isFragmentDefinitionNode(definition)) {
-            luvioDefinitions.push(transform$1(definition));
-        }
-        else {
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error(`Unsupported ${definition.kind} definition. Only OperationDefinition and FragmentDefinition are supported in a GraphQL Document`);
-            }
-        }
-    }
-    return {
-        kind,
-        definitions: luvioDefinitions,
-    };
-}
-
-/**
- * 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();
-/**
- * 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, { noLocation: true });
-    if (!parsedDoc || parsedDoc.kind !== 'Document') {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Invalid graphql doc');
-        }
-        return null;
-    }
-    docMap.set(operationKey, parsedDoc);
-    return parsedDoc;
-}
-/**
- * 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 updateReferenceMapWithKnownKey(doc, key) {
-    referenceMap.set(key, doc);
-}
-function updateReferenceMapAndGetKey(doc) {
-    // the key is a String object so that legacy locker does not replace its identity.
-    const key = new String();
-    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 [] }
- */
-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,
-    };
-}
-/**
- *
- * @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 updateReferenceMapAndGetKey(document);
-    }
-    return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
-}
-
-const DIRECTIVE_RECORD_QUERY_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_CHILD_RELATIONSHIP_CATEGORY = {
-    kind: 'Directive',
-    name: {
-        kind: 'Name',
-        value: 'category',
-    },
-    arguments: [
-        {
-            kind: 'Argument',
-            name: {
-                kind: 'Name',
-                value: 'name',
-            },
-            value: {
-                kind: 'StringValue',
-                value: 'childRelationship',
-                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, selection, parentNode) {
-    if (directives[index].name.value === CUSTOM_DIRECTIVE_CONNECTION) {
-        if (parentNode !== undefined &&
-            parentNode.kind === 'Field' &&
-            parentNode.name.value === 'uiapi') {
-            // @ts-ignore - Document is read only
-            directives[index] = DIRECTIVE_RECORD_QUERY_CATEGORY;
-        }
-        else {
-            // @ts-ignore - Document is read only
-            directives[index] = DIRECTIVE_CHILD_RELATIONSHIP_CATEGORY;
-        }
-    }
-    else if (directives[index].name.value === CUSTOM_DIRECTIVE_RESOURCE) {
-        // node gets its type from @category recordQuery or @category childRelationship
-        if (selection.kind === 'Field' && selection.name.value === '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 and it's nested selections,
- * to find any legacy custom directives and substitute them with metaschema directives
- * @param node - SelectionNode
- * @returns void
- */
-function traverseSelection(node, parentNode) {
-    if (node === undefined || node.kind === 'FragmentSpread' || node.selectionSet === undefined) {
-        return;
-    }
-    const { selectionSet } = node;
-    for (const selection of selectionSet.selections) {
-        replaceCustomDirectives(selection, parentNode);
-        traverseSelection(selection, node);
-    }
-}
-function replaceCustomDirectives(selection, parentNode) {
-    const { directives } = selection;
-    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, selection, parentNode);
-        }
-    }
-}
-/**
- * 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 { selectionSet } = def;
-        // This is just iterating through the top level 'Query' operations. There should never be any custom
-        // directives at this level, as RecordQuery is actually a field lower in the schema. So we can skip looking for them.
-        selectionSet.selections.forEach((selection) => {
-            traverseSelection(selection);
-        });
-    }
-}
-
-/**
- * @deprecated In favor of gql tagged template literal
- */
-function parseAndVisit(source) {
-    const ast = parse(source, { noLocation: true });
-    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;
+function transform$b(node, transformState) {
+    switch (node.kind) {
+        case 'Variable':
+            transformState.variablesUsed[node.name.value] = true;
+            return {
+                kind: 'Variable',
+                name: node.name.value,
+            };
+        case 'IntValue':
+            return {
+                kind: 'IntValue',
+                value: node.value,
+            };
+        case 'FloatValue':
+            return {
+                kind: 'FloatValue',
+                value: node.value,
+            };
+        case 'StringValue':
+            return {
+                kind: 'StringValue',
+                value: node.value,
+            };
+        case 'BooleanValue':
+            return {
+                kind: 'BooleanValue',
+                value: node.value,
+            };
+        case 'EnumValue':
+            return {
+                kind: 'EnumValue',
+                value: node.value,
+            };
+        case 'NullValue':
+            return {
+                kind: 'NullValue',
+            };
+        case 'ListValue': {
+            const values = [];
+            for (var index = 0; index < node.values.length; index++) {
+                const value = transform$b(node.values[index], transformState);
+                values.push(value);
+            }
+            return {
+                kind: 'ListValue',
+                values: values,
+            };
+        }
+        case 'ObjectValue': {
+            const { fields } = node;
+            const result = {};
+            fields.forEach((field) => {
+                const name = field.name.value;
+                const value = transform$b(field.value, transformState);
+                result[name] = value;
+            });
+            return {
+                kind: 'ObjectValue',
+                fields: result,
+            };
+        }
+        default:
+            throw new Error('Unsupported ValueNode kind');
+    }
+}
+
+function transform$a(node, transformState) {
+    const { kind, name: { value: nodeName }, value: nodeValue, } = node;
+    const valueNode = transform$b(nodeValue, transformState);
+    return {
+        kind,
+        name: nodeName,
+        value: valueNode,
+    };
+}
+
+function transform$9(node, transformState) {
+    const { kind, name: { value: nodeName }, arguments: nodeArguments, } = node;
+    const ret = {
+        kind,
+        name: nodeName,
+    };
+    if (nodeArguments !== undefined && nodeArguments.length > 0) {
+        let returnArguments = [];
+        for (var index = 0; index < nodeArguments.length; index++) {
+            const argumentNode = nodeArguments[index];
+            const value = transform$a(argumentNode, transformState);
+            returnArguments.push(value);
+        }
+        ret.arguments = returnArguments;
+    }
+    return ret;
+}
+function isCustomDirective$1(node) {
+    return (node.name.value === CUSTOM_DIRECTIVE_CONNECTION ||
+        node.name.value === CUSTOM_DIRECTIVE_RESOURCE);
+}
+
+function transform$8(node, transformState) {
+    const { name, alias, arguments: fieldArgs, selectionSet, directives } = node;
+    let luvioNode = {
+        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
+        name: name.value,
+        luvioSelections: [],
+    };
+    if (selectionSet === undefined || selectionSet.selections.length === 0) {
+        luvioNode = {
+            kind: NODE_KIND_SCALAR_FIELD_SELECTION,
+            name: name.value,
+        };
+    }
+    else {
+        // object or custom field node
+        if (directives !== undefined && directives.length > 0) {
+            const customDirectiveNode = directives.find(isCustomDirective$1);
+            if (customDirectiveNode === undefined) {
+                // transform non client-side directives
+                luvioNode.directives = directives.map((directive) => transform$9(directive, transformState));
+            }
+            else {
+                if (customDirectiveNode.name.value === CUSTOM_DIRECTIVE_CONNECTION) {
+                    luvioNode = {
+                        kind: NODE_KIND_CUSTOM_FIELD_SELECTION,
+                        name: name.value,
+                        type: NODE_TYPE_CONNECTION,
+                        luvioSelections: [],
+                    };
+                }
+                else if (customDirectiveNode.name.value === CUSTOM_DIRECTIVE_RESOURCE) {
+                    luvioNode = {
+                        kind: NODE_KIND_CUSTOM_FIELD_SELECTION,
+                        name: name.value,
+                        type: customDirectiveNode.arguments[0].value.value,
+                        luvioSelections: [],
+                    };
+                }
+            }
+        }
+        if (fieldArgs !== undefined && fieldArgs.length > 0) {
+            const returnArguments = [];
+            for (var index = 0; index < fieldArgs.length; index++) {
+                const value = transform$a(fieldArgs[index], transformState);
+                returnArguments.push(value);
+            }
+            luvioNode.arguments = returnArguments;
+        }
+    }
+    if (alias !== undefined) {
+        luvioNode.alias = alias.value;
+    }
+    return luvioNode;
+}
+
+function transform$7(node, transformState) {
+    const { kind, name: { value }, directives, } = node;
+    const luvioNode = {
+        kind,
+        name: value,
+    };
+    if (directives !== undefined && directives.length > 0) {
+        luvioNode.directives = directives.map((directive) => transform$9(directive, transformState));
+    }
+    return luvioNode;
+}
+
+function transform$6(node, transformState) {
+    const { kind: nodeKind, typeCondition, directives } = node;
+    const luvioNode = {
+        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) => transform$9(directive, transformState));
+    }
+    return luvioNode;
+}
+
+function selectionSetVisitor(ast, luvioSelectionPath, transformState) {
+    const visitor = {
+        enter(node) {
+            let selectionNode;
+            switch (node.kind) {
+                case NODE_KIND_FIELD: {
+                    const fieldNode = transform$8(node, transformState);
+                    selectionNode = fieldNode;
+                    break;
+                }
+                case NODE_KIND_FRAGMENT_SPREAD:
+                    selectionNode = transform$7(node, transformState);
+                    break;
+                case NODE_KIND_INLINE_FRAGMENT:
+                    selectionNode = transform$6(node, transformState);
+                    break;
+            }
+            if (selectionNode !== undefined) {
+                const parentNode = luvioSelectionPath[luvioSelectionPath.length - 1];
+                if (parentNode.kind === NODE_KIND_OBJECT_FIELD_SELECTION ||
+                    parentNode.kind === NODE_KIND_CUSTOM_FIELD_SELECTION ||
+                    parentNode.kind === NODE_KIND_INLINE_FRAGMENT) {
+                    parentNode.luvioSelections.push(selectionNode);
+                }
+                luvioSelectionPath.push(selectionNode);
+            }
+        },
+        leave(node) {
+            switch (node.kind) {
+                case NODE_KIND_FIELD:
+                case NODE_KIND_FRAGMENT_SPREAD:
+                case NODE_KIND_INLINE_FRAGMENT:
+                    luvioSelectionPath.pop();
+                    break;
+            }
+        },
+    };
+    visit(ast, visitor);
+}
+
+function transform$5(node) {
+    if (isNamedTypeNode(node)) {
+        return {
+            kind: NODE_KIND_NAMED_TYPE,
+            name: node.name.value,
+        };
+    }
+    else if (isListTypeNode(node)) {
+        return {
+            kind: NODE_KIND_LIST_TYPE,
+            type: transform$5(node.type),
+        };
+    }
+    else if (isNonNullTypeNode(node)) {
+        if (isNamedTypeNode(node.type)) {
+            return {
+                kind: NODE_KIND_NON_NULL_TYPE,
+                type: {
+                    kind: NODE_KIND_NAMED_TYPE,
+                    name: node.type.name.value,
+                },
+            };
+        }
+        else if (isListTypeNode(node.type)) {
+            return {
+                kind: NODE_KIND_NON_NULL_TYPE,
+                type: {
+                    kind: NODE_KIND_LIST_TYPE,
+                    type: transform$5(node.type.type),
+                },
+            };
+        }
+        else {
+            throw new Error('Unsupported NonNullTypeNode');
+        }
+    }
+    else {
+        throw new Error('Unsupported TypeNode');
+    }
+}
+
+function transform$4(variableDefinitions, transformState) {
+    const { kind, variable: { kind: variableKind, name: { value: variableName }, }, type, defaultValue, } = variableDefinitions;
+    const ret = {
+        kind,
+        variable: {
+            kind: variableKind,
+            name: variableName,
+        },
+        type: transform$5(type),
+    };
+    if (defaultValue !== undefined) {
+        const value = transform$b(defaultValue, transformState);
+        ret.defaultValue = value;
+    }
+    // TODO: transform directives
+    return ret;
+}
+
+function validateVariables(variableDefinitions, transformState) {
+    if (process.env.NODE_ENV === 'production') {
+        throw new ReferenceError("Do not call this function in production becuase we don't want to break existing uses. Other environments are okay because we want to catch errors early.");
+    }
+    const variablesDefined = {};
+    if (variableDefinitions !== undefined) {
+        for (let i = 0, len = variableDefinitions.length; i < len; i++) {
+            const definedVariableName = variableDefinitions[i].variable.name.value;
+            variablesDefined[definedVariableName] = true;
+            if (transformState.variablesUsed[definedVariableName] === undefined) {
+                throw new Error(`Variable $${definedVariableName} was defined but never used.`);
+            }
+        }
+    }
+    const usedVariableKeys = Object.keys(transformState.variablesUsed);
+    for (let i = 0, len = usedVariableKeys.length; i < len; i++) {
+        if (variablesDefined[usedVariableKeys[i]] !== true) {
+            throw new Error(`Variable $${usedVariableKeys[i]} was used but never defined.`);
+        }
+    }
+}
+function transform$3(node) {
+    const queryRoot = {
+        kind: 'ObjectFieldSelection',
+        name: 'query',
+        luvioSelections: [],
+    };
+    const currentNodePath = [queryRoot];
+    const transformState = {
+        variablesUsed: {},
+    };
+    selectionSetVisitor(node, currentNodePath, transformState);
+    const operationDefinition = {
+        kind: 'OperationDefinition',
+        operation: 'query',
+        luvioSelections: queryRoot.luvioSelections,
+    };
+    if (node.name !== undefined) {
+        operationDefinition.name = node.name.value;
+    }
+    const { variableDefinitions, directives } = node;
+    if (variableDefinitions !== undefined && variableDefinitions.length > 0) {
+        operationDefinition.variableDefinitions = variableDefinitions.map((variableDefinition) => transform$4(variableDefinition, transformState));
+    }
+    if (directives !== undefined && directives.length > 0) {
+        operationDefinition.directives = directives.map((node) => transform$9(node, transformState));
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateVariables(variableDefinitions, transformState);
+    }
+    return operationDefinition;
+}
+
+function transform$2(node) {
+    const { operation } = node;
+    if (operation === 'query') {
+        return transform$3(node);
+    }
+    throw new Error(`Unsupported ${operation} operation. Only query operation is supported`);
+}
+
+function transform$1(node) {
+    const { kind: nodeKind, name: { value: nodeName }, typeCondition: { kind: typeKind, name: { value: typeName }, }, directives, } = node;
+    // dummy root node
+    const fragmentRoot = {
+        kind: NODE_KIND_OBJECT_FIELD_SELECTION,
+        name: 'fragment',
+        luvioSelections: [],
+    };
+    const currentNodePath = [fragmentRoot];
+    const transformState = { variablesUsed: {} };
+    selectionSetVisitor(node, currentNodePath, transformState);
+    const luvioNode = {
+        kind: nodeKind,
+        name: nodeName,
+        typeCondition: {
+            kind: typeKind,
+            name: typeName,
+        },
+        luvioSelections: fragmentRoot.luvioSelections,
+    };
+    if (directives !== undefined && directives.length > 0) {
+        luvioNode.directives = directives.map((node) => transform$9(node, transformState));
+    }
+    return luvioNode;
+}
+
+function transform(root) {
+    const { kind, definitions } = root;
+    const luvioDefinitions = [];
+    for (let i = 0; i < definitions.length; i++) {
+        const definition = definitions[i];
+        if (isOperationDefinitionNode(definition)) {
+            luvioDefinitions.push(transform$2(definition));
+        }
+        else if (isFragmentDefinitionNode(definition)) {
+            luvioDefinitions.push(transform$1(definition));
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error(`Unsupported ${definition.kind} definition. Only OperationDefinition and FragmentDefinition are supported in a GraphQL Document`);
+            }
+        }
+    }
+    return {
+        kind,
+        definitions: luvioDefinitions,
+    };
+}
+
+/**
+ * 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();
+/**
+ * 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, { noLocation: true });
+    if (!parsedDoc || parsedDoc.kind !== 'Document') {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('Invalid graphql doc');
+        }
+        return null;
+    }
+    docMap.set(operationKey, parsedDoc);
+    return parsedDoc;
+}
+/**
+ * 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 updateReferenceMapWithKnownKey(doc, key) {
+    referenceMap.set(key, doc);
+}
+function updateReferenceMapAndGetKey(doc) {
+    // the key is a String object so that legacy locker does not replace its identity.
+    const key = new String();
+    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 [] }
+ */
+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,
+    };
+}
+/**
+ *
+ * @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 updateReferenceMapAndGetKey(document);
+    }
+    return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
+}
+
+const DIRECTIVE_RECORD_QUERY_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_CHILD_RELATIONSHIP_CATEGORY = {
+    kind: 'Directive',
+    name: {
+        kind: 'Name',
+        value: 'category',
+    },
+    arguments: [
+        {
+            kind: 'Argument',
+            name: {
+                kind: 'Name',
+                value: 'name',
+            },
+            value: {
+                kind: 'StringValue',
+                value: 'childRelationship',
+                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, selection, parentNode) {
+    if (directives[index].name.value === CUSTOM_DIRECTIVE_CONNECTION) {
+        if (parentNode !== undefined &&
+            parentNode.kind === 'Field' &&
+            parentNode.name.value === 'uiapi') {
+            // @ts-ignore - Document is read only
+            directives[index] = DIRECTIVE_RECORD_QUERY_CATEGORY;
+        }
+        else {
+            // @ts-ignore - Document is read only
+            directives[index] = DIRECTIVE_CHILD_RELATIONSHIP_CATEGORY;
+        }
+    }
+    else if (directives[index].name.value === CUSTOM_DIRECTIVE_RESOURCE) {
+        // node gets its type from @category recordQuery or @category childRelationship
+        if (selection.kind === 'Field' && selection.name.value === '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 and it's nested selections,
+ * to find any legacy custom directives and substitute them with metaschema directives
+ * @param node - SelectionNode
+ * @returns void
+ */
+function traverseSelection(node, parentNode) {
+    if (node === undefined || node.kind === 'FragmentSpread' || node.selectionSet === undefined) {
+        return;
+    }
+    const { selectionSet } = node;
+    for (const selection of selectionSet.selections) {
+        replaceCustomDirectives(selection, parentNode);
+        traverseSelection(selection, node);
+    }
+}
+function replaceCustomDirectives(selection, parentNode) {
+    const { directives } = selection;
+    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, selection, parentNode);
+        }
+    }
+}
+/**
+ * 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 { selectionSet } = def;
+        // This is just iterating through the top level 'Query' operations. There should never be any custom
+        // directives at this level, as RecordQuery is actually a field lower in the schema. So we can skip looking for them.
+        selectionSet.selections.forEach((selection) => {
+            traverseSelection(selection);
+        });
+    }
+}
+
+/**
+ * @deprecated In favor of gql tagged template literal
+ */
+function parseAndVisit(source) {
+    const ast = parse(source, { noLocation: true });
+    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;
 }
 
 exports.GraphQLError = GraphQLError;