@luvio/graphql-parser 0.104.0 → 0.104.1

package/dist/gql.d.ts

@@ -15,7 +15,6 @@ export declare const docMap: Map<string, DocumentNode>;
  * As a user shouldn't have access to the Document
  */
 export declare const referenceMap: WeakMap<Object, DocumentNode>;
-export declare let addMetaschemaDirectives: boolean;
 /**
  * Returns document node if cached or else update the cache and return the document node
  * @param inputString - operation string
@@ -50,8 +49,3 @@ export declare const astResolver: AstResolver;
  * @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

@@ -12607,128 +12607,6 @@ 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
@@ -12910,11 +12788,133 @@ function gql(literals, ...subs) {
     return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
 }
 
+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);
+    }
+}
+
 /**
  * @deprecated In favor of gql tagged template literal
  */
 function parseAndVisit(source) {
-    const ast = parseDocument(source);
+    const ast = parse(source);
     const luvioDocumentNode = transform(ast);
     // In-place substitution of metaschema annotations
     metaschemaMapper(ast);

package/dist/luvioGraphqlParser.mjs

@@ -12603,128 +12603,6 @@ 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
@@ -12906,11 +12784,133 @@ function gql(literals, ...subs) {
     return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
 }
 
+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);
+    }
+}
+
 /**
  * @deprecated In favor of gql tagged template literal
  */
 function parseAndVisit(source) {
-    const ast = parseDocument(source);
+    const ast = parse(source);
     const luvioDocumentNode = transform(ast);
     // In-place substitution of metaschema annotations
     metaschemaMapper(ast);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/graphql-parser",
-    "version": "0.104.0",
+    "version": "0.104.1",
     "description": "GraphQL parser for Luvio GraphQL adapter support",
     "repository": {
         "type": "git",

package/src/__tests__/gql.spec.ts

@@ -1,13 +1,4 @@
-import {
-    gql,
-    docMap,
-    astResolver,
-    processSubstitutions,
-    stripLocation,
-    addMetaschemaDirectives,
-    enableAddMetaschemaDirective,
-    disableAddMetaschemaDirective,
-} from '../gql';
+import { gql, docMap, astResolver, processSubstitutions, stripLocation } from '../gql';
 import ast from './ast.json';
 import astNoLoc from './astNoLoc.json';
 
@@ -672,13 +663,3 @@ describe('stripLocation', () => {
         expect(doc).toStrictEqual(astNoLoc);
     });
 });
-
-describe('addMetaschemaDirectives', () => {
-    it('flips', () => {
-        expect(addMetaschemaDirectives).toBe(false);
-        enableAddMetaschemaDirective();
-        expect(addMetaschemaDirectives).toBe(true);
-        disableAddMetaschemaDirective();
-        expect(addMetaschemaDirectives).toBe(false);
-    });
-});

package/src/__tests__/main.spec.ts

@@ -1,5 +1,5 @@
 import * as parser from '../main';
-import { astResolver, parseDocument } from '../gql';
+import { astResolver, stripLocation } from '../gql';
 
 describe('LDS GraphQL Parser', () => {
     describe('parseAndVisit', () => {
@@ -643,7 +643,9 @@ describe('LDS GraphQL Parser', () => {
             const target = parser.parseAndVisit(source);
             const metaschemaAST = astResolver(target);
 
-            expect(metaschemaAST).toStrictEqual(parseDocument(metaschemaSource));
+            expect(stripLocation(metaschemaAST)).toStrictEqual(
+                stripLocation(parser.parse(metaschemaSource))
+            );
         });
     });
 });

package/src/gql.ts

@@ -7,7 +7,6 @@ import type { DefinitionNode, DocumentNode } from 'graphql/language';
 import { parse } from 'graphql/language';
 import { stripIgnoredCharacters } from 'graphql/utilities';
 import { ObjectCreate, ObjectKeys } from './util/language';
-import { metaschemaMapper } from './metaschema';
 
 export type AstResolver = (astReference: any) => DocumentNode | undefined;
 
@@ -22,8 +21,6 @@ export const docMap = new Map<string, DocumentNode>();
  */
 export const referenceMap = new WeakMap<Object, DocumentNode>();
 
-export let addMetaschemaDirectives: boolean = false;
-
 /**
  * Strips characters that are not significant to the validity or execution
  * of a GraphQL document:
@@ -58,11 +55,6 @@ export function parseDocument(inputString: string): DocumentNode | null {
         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);
@@ -228,14 +220,3 @@ export function gql(
 
     return updateReferenceMapAndGetKey(insertFragments(document, inputSubstitutionFragments));
 }
-
-/**
- * Enable the parser to add corresponding metaschema directives for backwards compatibility
- */
-export function enableAddMetaschemaDirective() {
-    addMetaschemaDirectives = true;
-}
-
-export function disableAddMetaschemaDirective() {
-    addMetaschemaDirectives = false;
-}

package/src/main.ts

@@ -28,7 +28,7 @@ import {
     LuvioTypeNode,
 } from './ast';
 import { transform } from './document';
-import { parseDocument, updateReferenceMapWithKnownKey } from './gql';
+import { updateReferenceMapWithKnownKey } from './gql';
 import { metaschemaMapper } from './metaschema';
 
 export type {
@@ -65,6 +65,7 @@ export type {
     InputObjectTypeDefinitionNode,
     InlineFragmentNode,
 } 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';
@@ -105,7 +106,7 @@ export {
  * @deprecated In favor of gql tagged template literal
  */
 export function parseAndVisit(source: string): LuvioDocumentNode {
-    const ast = parseDocument(source);
+    const ast = parse(source);
     const luvioDocumentNode = transform(ast!);
 
     // In-place substitution of metaschema annotations