@envelop/fragment-arguments 4.0.0-alpha-d0d0776.0 → 4.0.0-alpha-5b6bfa8.0

package/README.md

@@ -15,13 +15,13 @@ yarn add @envelop/fragment-arguments
 ## Usage Example
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useFragmentArguments } from '@envelop/fragment-arguments';
+import { envelop } from '@envelop/core'
+import { useFragmentArguments } from '@envelop/fragment-arguments'
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
-    useFragmentArguments(),
-  ],
-});
+    useFragmentArguments()
+  ]
+})
 ```

package/cjs/extended-parser.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FragmentArgumentCompatibleParser = void 0;
+const graphql_1 = require("@graphql-tools/graphql");
+class FragmentArgumentCompatibleParser extends graphql_1.Parser {
+    // see https://github.com/graphql/graphql-js/pull/3248
+    getLexer() {
+        return this._lexer;
+    }
+    // see https://github.com/graphql/graphql-js/pull/3248
+    getOptions() {
+        return this._options;
+    }
+    // for backwards-compat with v15, this api was removed in v16 in favor of the this.node API.
+    loc(startToken) {
+        var _a;
+        if (((_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.noLocation) !== true) {
+            const lexer = this.getLexer();
+            return new graphql_1.Location(startToken, lexer.lastToken, lexer.source);
+        }
+        return undefined;
+    }
+    parseFragment() {
+        const start = this.getLexer().token;
+        this.expectToken(graphql_1.TokenKind.SPREAD);
+        const hasTypeCondition = this.expectOptionalKeyword('on');
+        if (!hasTypeCondition && this.peek(graphql_1.TokenKind.NAME)) {
+            const name = this.parseFragmentName();
+            if (this.peek(graphql_1.TokenKind.PAREN_L)) {
+                return {
+                    kind: graphql_1.Kind.FRAGMENT_SPREAD,
+                    name,
+                    arguments: this.parseArguments(),
+                    directives: this.parseDirectives(),
+                    loc: this.loc(start),
+                };
+            }
+            return {
+                kind: graphql_1.Kind.FRAGMENT_SPREAD,
+                name: this.parseFragmentName(),
+                directives: this.parseDirectives(),
+                loc: this.loc(start),
+            };
+        }
+        return {
+            kind: graphql_1.Kind.INLINE_FRAGMENT,
+            typeCondition: hasTypeCondition ? this.parseNamedType() : undefined,
+            directives: this.parseDirectives(),
+            selectionSet: this.parseSelectionSet(),
+            loc: this.loc(start),
+        };
+    }
+    parseFragmentDefinition() {
+        const start = this.getLexer().token;
+        this.expectKeyword('fragment');
+        const name = this.parseFragmentName();
+        if (this.peek(graphql_1.TokenKind.PAREN_L)) {
+            const fragmentDefinition = {
+                kind: graphql_1.Kind.FRAGMENT_DEFINITION,
+                name,
+                variableDefinitions: this.parseVariableDefinitions(),
+                typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
+                directives: this.parseDirectives(),
+                selectionSet: this.parseSelectionSet(),
+                loc: this.loc(start),
+            };
+            return fragmentDefinition;
+        }
+        const fragmentDefinition = {
+            kind: graphql_1.Kind.FRAGMENT_DEFINITION,
+            name,
+            typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
+            directives: this.parseDirectives(),
+            selectionSet: this.parseSelectionSet(),
+            loc: this.loc(start),
+        };
+        return fragmentDefinition;
+    }
+}
+exports.FragmentArgumentCompatibleParser = FragmentArgumentCompatibleParser;

package/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFragmentArguments = exports.parseWithFragmentArguments = void 0;
+const extended_parser_js_1 = require("./extended-parser.js");
+const utils_js_1 = require("./utils.js");
+function parseWithFragmentArguments(source, options) {
+    const parser = new extended_parser_js_1.FragmentArgumentCompatibleParser(source, options);
+    return parser.parseDocument();
+}
+exports.parseWithFragmentArguments = parseWithFragmentArguments;
+const useFragmentArguments = () => {
+    return {
+        onParse({ setParseFn }) {
+            setParseFn(parseWithFragmentArguments);
+            return ({ result, replaceParseResult }) => {
+                if (result && 'kind' in result) {
+                    replaceParseResult((0, utils_js_1.applySelectionSetFragmentArguments)(result));
+                }
+            };
+        },
+    };
+};
+exports.useFragmentArguments = useFragmentArguments;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySelectionSetFragmentArguments = void 0;
+const graphql_1 = require("@graphql-tools/graphql");
+function applySelectionSetFragmentArguments(document) {
+    const fragmentList = new Map();
+    for (const def of document.definitions) {
+        if (def.kind !== 'FragmentDefinition') {
+            continue;
+        }
+        fragmentList.set(def.name.value, def);
+    }
+    return (0, graphql_1.visit)(document, {
+        FragmentSpread(fragmentNode) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (fragmentNode.arguments != null && fragmentNode.arguments.length) {
+                const fragmentDef = fragmentList.get(fragmentNode.name.value);
+                if (!fragmentDef) {
+                    return;
+                }
+                const fragmentArguments = new Map();
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                for (const arg of fragmentNode.arguments) {
+                    fragmentArguments.set(arg.name.value, arg);
+                }
+                const selectionSet = (0, graphql_1.visit)(fragmentDef.selectionSet, {
+                    Variable(variableNode) {
+                        const fragArg = fragmentArguments.get(variableNode.name.value);
+                        if (fragArg) {
+                            return fragArg.value;
+                        }
+                        return variableNode;
+                    },
+                });
+                const inlineFragment = {
+                    kind: graphql_1.Kind.INLINE_FRAGMENT,
+                    typeCondition: fragmentDef.typeCondition,
+                    selectionSet,
+                };
+                return inlineFragment;
+            }
+            return fragmentNode;
+        },
+    });
+}
+exports.applySelectionSetFragmentArguments = applySelectionSetFragmentArguments;

package/{index.mjs → esm/extended-parser.js}

@@ -1,8 +1,5 @@
-import { Parser } from 'graphql/language/parser.js';
-import { Location, TokenKind, Kind, visit } from 'graphql';
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-class FragmentArgumentCompatibleParser extends Parser {
+import { TokenKind, Kind, Location, Parser, } from '@graphql-tools/graphql';
+export class FragmentArgumentCompatibleParser extends Parser {
     // see https://github.com/graphql/graphql-js/pull/3248
     getLexer() {
         return this._lexer;
@@ -13,7 +10,8 @@ class FragmentArgumentCompatibleParser extends Parser {
     }
     // for backwards-compat with v15, this api was removed in v16 in favor of the this.node API.
     loc(startToken) {
-        if (this.getOptions()?.noLocation !== true) {
+        var _a;
+        if (((_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.noLocation) !== true) {
             const lexer = this.getLexer();
             return new Location(startToken, lexer.lastToken, lexer.source);
         }
@@ -76,66 +74,3 @@ class FragmentArgumentCompatibleParser extends Parser {
         return fragmentDefinition;
     }
 }
-
-function applySelectionSetFragmentArguments(document) {
-    const fragmentList = new Map();
-    for (const def of document.definitions) {
-        if (def.kind !== 'FragmentDefinition') {
-            continue;
-        }
-        fragmentList.set(def.name.value, def);
-    }
-    return visit(document, {
-        FragmentSpread(fragmentNode) {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            if (fragmentNode.arguments != null && fragmentNode.arguments.length) {
-                const fragmentDef = fragmentList.get(fragmentNode.name.value);
-                if (!fragmentDef) {
-                    return;
-                }
-                const fragmentArguments = new Map();
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                for (const arg of fragmentNode.arguments) {
-                    fragmentArguments.set(arg.name.value, arg);
-                }
-                const selectionSet = visit(fragmentDef.selectionSet, {
-                    Variable(variableNode) {
-                        const fragArg = fragmentArguments.get(variableNode.name.value);
-                        if (fragArg) {
-                            return fragArg.value;
-                        }
-                        return variableNode;
-                    },
-                });
-                const inlineFragment = {
-                    kind: Kind.INLINE_FRAGMENT,
-                    typeCondition: fragmentDef.typeCondition,
-                    selectionSet,
-                };
-                return inlineFragment;
-            }
-            return fragmentNode;
-        },
-    });
-}
-
-function parseWithFragmentArguments(source, options) {
-    const parser = new FragmentArgumentCompatibleParser(source, options);
-    return parser.parseDocument();
-}
-const useFragmentArguments = () => {
-    return {
-        onParse({ setParseFn }) {
-            setParseFn(parseWithFragmentArguments);
-            return ({ result, replaceParseResult }) => {
-                if (result && 'kind' in result) {
-                    replaceParseResult(applySelectionSetFragmentArguments(result));
-                }
-            };
-        },
-    };
-};
-
-export { parseWithFragmentArguments, useFragmentArguments };

package/esm/index.js

@@ -0,0 +1,18 @@
+import { FragmentArgumentCompatibleParser } from './extended-parser.js';
+import { applySelectionSetFragmentArguments } from './utils.js';
+export function parseWithFragmentArguments(source, options) {
+    const parser = new FragmentArgumentCompatibleParser(source, options);
+    return parser.parseDocument();
+}
+export const useFragmentArguments = () => {
+    return {
+        onParse({ setParseFn }) {
+            setParseFn(parseWithFragmentArguments);
+            return ({ result, replaceParseResult }) => {
+                if (result && 'kind' in result) {
+                    replaceParseResult(applySelectionSetFragmentArguments(result));
+                }
+            };
+        },
+    };
+};

package/esm/utils.js

@@ -0,0 +1,44 @@
+import { visit, Kind, } from '@graphql-tools/graphql';
+export function applySelectionSetFragmentArguments(document) {
+    const fragmentList = new Map();
+    for (const def of document.definitions) {
+        if (def.kind !== 'FragmentDefinition') {
+            continue;
+        }
+        fragmentList.set(def.name.value, def);
+    }
+    return visit(document, {
+        FragmentSpread(fragmentNode) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (fragmentNode.arguments != null && fragmentNode.arguments.length) {
+                const fragmentDef = fragmentList.get(fragmentNode.name.value);
+                if (!fragmentDef) {
+                    return;
+                }
+                const fragmentArguments = new Map();
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                for (const arg of fragmentNode.arguments) {
+                    fragmentArguments.set(arg.name.value, arg);
+                }
+                const selectionSet = visit(fragmentDef.selectionSet, {
+                    Variable(variableNode) {
+                        const fragArg = fragmentArguments.get(variableNode.name.value);
+                        if (fragArg) {
+                            return fragArg.value;
+                        }
+                        return variableNode;
+                    },
+                });
+                const inlineFragment = {
+                    kind: Kind.INLINE_FRAGMENT,
+                    typeCondition: fragmentDef.typeCondition,
+                    selectionSet,
+                };
+                return inlineFragment;
+            }
+            return fragmentNode;
+        },
+    });
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@envelop/fragment-arguments",
-  "version": "4.0.0-alpha-d0d0776.0",
+  "version": "4.0.0-alpha-5b6bfa8.0",
   "peerDependencies": {
-    "@envelop/core": "3.0.0-alpha-d0d0776.0",
-    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
+    "@envelop/core": "3.0.0-alpha-5b6bfa8.0",
+    "@graphql-tools/graphql": "0.1.0-alpha-33fb2950.0"
   },
+  "dependencies": {},
   "repository": {
     "type": "git",
     "url": "https://github.com/n1ru4l/envelop.git",
@@ -12,33 +13,42 @@
   },
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
       "require": {
-        "default": "./index.js",
-        "types": "./index.d.ts"
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
       },
       "import": {
-        "default": "./index.mjs",
-        "types": "./index.d.ts"
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
       }
     },
     "./*": {
       "require": {
-        "default": "./*.js",
-        "types": "./*.d.ts"
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
       },
       "import": {
-        "default": "./*.mjs",
-        "types": "./*.d.ts"
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
       }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/{extended-parser.d.ts → typings/extended-parser.d.ts}

@@ -1,6 +1,5 @@
-import { ParseOptions, Parser } from 'graphql/language/parser.js';
-import type { Lexer } from 'graphql/language/lexer.js';
-import { Token, Location, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode } from 'graphql';
+import type { Lexer, ParseOptions } from '@graphql-tools/graphql';
+import { Token, Location, FragmentDefinitionNode, FragmentSpreadNode, InlineFragmentNode, Parser } from '@graphql-tools/graphql';
 export declare class FragmentArgumentCompatibleParser extends Parser {
     getLexer(): Lexer;
     getOptions(): ParseOptions;

package/{index.d.ts → typings/index.d.ts}

@@ -1,5 +1,5 @@
 import type { Plugin } from '@envelop/core';
 import type { ParseOptions } from 'graphql/language/parser';
-import type { Source, DocumentNode } from 'graphql';
+import type { Source, DocumentNode } from '@graphql-tools/graphql';
 export declare function parseWithFragmentArguments(source: string | Source, options?: ParseOptions): DocumentNode;
 export declare const useFragmentArguments: () => Plugin;

package/{utils.d.ts → typings/utils.d.ts}

@@ -1,2 +1,2 @@
-import { DocumentNode } from 'graphql';
+import { DocumentNode } from '@graphql-tools/graphql';
 export declare function applySelectionSetFragmentArguments(document: DocumentNode): DocumentNode | Error;

package/index.js

@@ -1,146 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const parser_js = require('graphql/language/parser.js');
-const graphql = require('graphql');
-
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-class FragmentArgumentCompatibleParser extends parser_js.Parser {
-    // see https://github.com/graphql/graphql-js/pull/3248
-    getLexer() {
-        return this._lexer;
-    }
-    // see https://github.com/graphql/graphql-js/pull/3248
-    getOptions() {
-        return this._options;
-    }
-    // for backwards-compat with v15, this api was removed in v16 in favor of the this.node API.
-    loc(startToken) {
-        if (this.getOptions()?.noLocation !== true) {
-            const lexer = this.getLexer();
-            return new graphql.Location(startToken, lexer.lastToken, lexer.source);
-        }
-        return undefined;
-    }
-    parseFragment() {
-        const start = this.getLexer().token;
-        this.expectToken(graphql.TokenKind.SPREAD);
-        const hasTypeCondition = this.expectOptionalKeyword('on');
-        if (!hasTypeCondition && this.peek(graphql.TokenKind.NAME)) {
-            const name = this.parseFragmentName();
-            if (this.peek(graphql.TokenKind.PAREN_L)) {
-                return {
-                    kind: graphql.Kind.FRAGMENT_SPREAD,
-                    name,
-                    arguments: this.parseArguments(),
-                    directives: this.parseDirectives(),
-                    loc: this.loc(start),
-                };
-            }
-            return {
-                kind: graphql.Kind.FRAGMENT_SPREAD,
-                name: this.parseFragmentName(),
-                directives: this.parseDirectives(),
-                loc: this.loc(start),
-            };
-        }
-        return {
-            kind: graphql.Kind.INLINE_FRAGMENT,
-            typeCondition: hasTypeCondition ? this.parseNamedType() : undefined,
-            directives: this.parseDirectives(),
-            selectionSet: this.parseSelectionSet(),
-            loc: this.loc(start),
-        };
-    }
-    parseFragmentDefinition() {
-        const start = this.getLexer().token;
-        this.expectKeyword('fragment');
-        const name = this.parseFragmentName();
-        if (this.peek(graphql.TokenKind.PAREN_L)) {
-            const fragmentDefinition = {
-                kind: graphql.Kind.FRAGMENT_DEFINITION,
-                name,
-                variableDefinitions: this.parseVariableDefinitions(),
-                typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
-                directives: this.parseDirectives(),
-                selectionSet: this.parseSelectionSet(),
-                loc: this.loc(start),
-            };
-            return fragmentDefinition;
-        }
-        const fragmentDefinition = {
-            kind: graphql.Kind.FRAGMENT_DEFINITION,
-            name,
-            typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
-            directives: this.parseDirectives(),
-            selectionSet: this.parseSelectionSet(),
-            loc: this.loc(start),
-        };
-        return fragmentDefinition;
-    }
-}
-
-function applySelectionSetFragmentArguments(document) {
-    const fragmentList = new Map();
-    for (const def of document.definitions) {
-        if (def.kind !== 'FragmentDefinition') {
-            continue;
-        }
-        fragmentList.set(def.name.value, def);
-    }
-    return graphql.visit(document, {
-        FragmentSpread(fragmentNode) {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            if (fragmentNode.arguments != null && fragmentNode.arguments.length) {
-                const fragmentDef = fragmentList.get(fragmentNode.name.value);
-                if (!fragmentDef) {
-                    return;
-                }
-                const fragmentArguments = new Map();
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                for (const arg of fragmentNode.arguments) {
-                    fragmentArguments.set(arg.name.value, arg);
-                }
-                const selectionSet = graphql.visit(fragmentDef.selectionSet, {
-                    Variable(variableNode) {
-                        const fragArg = fragmentArguments.get(variableNode.name.value);
-                        if (fragArg) {
-                            return fragArg.value;
-                        }
-                        return variableNode;
-                    },
-                });
-                const inlineFragment = {
-                    kind: graphql.Kind.INLINE_FRAGMENT,
-                    typeCondition: fragmentDef.typeCondition,
-                    selectionSet,
-                };
-                return inlineFragment;
-            }
-            return fragmentNode;
-        },
-    });
-}
-
-function parseWithFragmentArguments(source, options) {
-    const parser = new FragmentArgumentCompatibleParser(source, options);
-    return parser.parseDocument();
-}
-const useFragmentArguments = () => {
-    return {
-        onParse({ setParseFn }) {
-            setParseFn(parseWithFragmentArguments);
-            return ({ result, replaceParseResult }) => {
-                if (result && 'kind' in result) {
-                    replaceParseResult(applySelectionSetFragmentArguments(result));
-                }
-            };
-        },
-    };
-};
-
-exports.parseWithFragmentArguments = parseWithFragmentArguments;
-exports.useFragmentArguments = useFragmentArguments;