@luvio/graphql-parser 0.99.0 → 0.100.0

package/dist/luvioGraphqlParser.mjs

@@ -10498,7 +10498,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);
 }
@@ -10519,7 +10519,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));
@@ -10796,6 +10796,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.
 */
@@ -10804,4 +11120,4 @@ function parseAndVisit(source) {
     return transform(ast);
 }
 
-export { GraphQLScalarType, GraphQLSchema, Kind, buildASTSchema, isScalarType, parse, parseAndVisit, print, stripIgnoredCharacters, visit };
+export { GraphQLScalarType, GraphQLSchema, Kind, astResolver, buildASTSchema, disableAddMetaschemaDirective, enableAddMetaschemaDirective, gql, isScalarType, parse, parseAndVisit, print, stripIgnoredCharacters, visit };

package/dist/main.d.ts

@@ -7,6 +7,8 @@ export type { ListTypeNode, BooleanValueNode, EnumTypeDefinitionNode, FieldDefin
 export { ASTVisitor, parse, Kind, print, visit } from 'graphql/language';
 export { isScalarType } from 'graphql/type';
 export { stripIgnoredCharacters } from 'graphql/utilities';
+export { gql, enableAddMetaschemaDirective, disableAddMetaschemaDirective, astResolver, } from './gql';
+export type { AstResolver } from './gql';
 /**
  * @deprecated - Schema-backed adapters will use standard graphql types re-exported from @luvio/graphql
  */

package/dist/metaschema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Add metaschema annotations to their corresponding custom notation counterparts
+ * @module metaschemaMapper
+ */
+import type { DocumentNode } from 'graphql/language';
+/**
+ * Accepts a document node and replaces the legacy custom directives with metaschema directives "in-place"
+ * @param doc
+ */
+export declare function metaschemaMapper(doc: DocumentNode): void;

package/dist/util/language.d.ts

@@ -0,0 +1,9 @@
+declare const isArray: (arg: any) => arg is any[];
+declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export { isArray as ArrayIsArray, keys as ObjectKeys, create as ObjectCreate, };

package/package.json

@@ -1,32 +1,28 @@
 {
     "name": "@luvio/graphql-parser",
-    "version": "0.99.0",
+    "version": "0.100.0",
     "description": "GraphQL parser for Luvio GraphQL adapter support",
-    "main": "./dist/luvioGraphqlParser.js",
-    "module": "./dist/luvioGraphqlParser.mjs",
-    "types": "dist/main.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce/luvio.git",
+        "directory": "packages/@luvio/graphql-parser"
+    },
     "license": "MIT",
     "exports": {
         "require": "./dist/luvioGraphqlParser.js",
         "import": "./dist/luvioGraphqlParser.mjs"
     },
+    "main": "./dist/luvioGraphqlParser.js",
+    "module": "./dist/luvioGraphqlParser.mjs",
+    "types": "dist/main.d.ts",
     "scripts": {
-        "clean": "rm -rf dist",
         "build": "rollup --config rollup.config.js",
+        "clean": "rm -rf dist",
         "parse": "node ./scripts/cli.mjs",
-        "test:unit": "jest",
-        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "test": "jest",
+        "test:debug": "node --inspect-brk ../../../node_modules/.bin/jest --runInBand",
         "test:size": "bundlesize"
     },
-    "nx": {
-        "targets": {
-            "build": {
-                "outputs": [
-                    "packages/@luvio/graphql-parser/dist"
-                ]
-            }
-        }
-    },
     "dependencies": {
         "graphql": "^15.0.0"
     },
@@ -39,5 +35,14 @@
             "maxSize": "58 kB",
             "compression": "brotli"
         }
-    ]
+    ],
+    "nx": {
+        "targets": {
+            "build": {
+                "outputs": [
+                    "packages/@luvio/graphql-parser/dist"
+                ]
+            }
+        }
+    }
 }