@envelop/extended-validation 1.7.0-alpha-aca44e1.0 → 1.7.0-alpha-385b86b.0

package/cjs/common.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirectiveFromAstNode = void 0;
+function getDirectiveFromAstNode(astNode, names) {
+    const directives = astNode.directives || [];
+    const namesArr = Array.isArray(names) ? names : [names];
+    const authDirective = directives.find(d => namesArr.includes(d.name.value));
+    return authDirective || null;
+}
+exports.getDirectiveFromAstNode = getDirectiveFromAstNode;

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./plugin.js"), exports);
+tslib_1.__exportStar(require("./common.js"), exports);
+tslib_1.__exportStar(require("./rules/one-of.js"), exports);

package/cjs/package.json

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

package/cjs/plugin.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExtendedValidation = void 0;
+const graphql_1 = require("graphql");
+const symbolExtendedValidationRules = Symbol('extendedValidationContext');
+const useExtendedValidation = (options) => {
+    let schemaTypeInfo;
+    function getTypeInfo() {
+        return schemaTypeInfo;
+    }
+    return {
+        onSchemaChange({ schema }) {
+            schemaTypeInfo = new graphql_1.TypeInfo(schema);
+        },
+        onContextBuilding({ context, extendContext }) {
+            // We initialize the validationRules context in onContextBuilding as onExecute is already too late!
+            let validationRulesContext = context[symbolExtendedValidationRules];
+            if (validationRulesContext === undefined) {
+                validationRulesContext = {
+                    rules: [],
+                    didRun: false,
+                };
+                extendContext({
+                    [symbolExtendedValidationRules]: validationRulesContext,
+                });
+            }
+            validationRulesContext.rules.push(...options.rules);
+        },
+        onSubscribe: buildHandler('subscribe', getTypeInfo, options.onValidationFailed),
+        onExecute: buildHandler('execute', getTypeInfo, options.onValidationFailed),
+    };
+};
+exports.useExtendedValidation = useExtendedValidation;
+function buildHandler(name, getTypeInfo, onValidationFailed) {
+    return function handler({ args, setResultAndStopExecution, }) {
+        var _a;
+        // We hook into onExecute/onSubscribe even though this is a validation pattern. The reasoning behind
+        // it is that hooking right after validation and before execution has started is the
+        // same as hooking into the validation step. The benefit of this approach is that
+        // we may use execution context in the validation rules.
+        const validationRulesContext = args.contextValue[symbolExtendedValidationRules];
+        if (validationRulesContext === undefined) {
+            throw new Error('Plugin has not been properly set up. ' +
+                `The 'contextFactory' function is not invoked and the result has not been passed to '${name}'.`);
+        }
+        // we only want to run the extended execution once.
+        if (validationRulesContext.didRun === false) {
+            validationRulesContext.didRun = true;
+            if (validationRulesContext.rules.length !== 0) {
+                const errors = [];
+                // We replicate the default validation step manually before execution starts.
+                const typeInfo = (_a = getTypeInfo()) !== null && _a !== void 0 ? _a : new graphql_1.TypeInfo(args.schema);
+                const validationContext = new graphql_1.ValidationContext(args.schema, args.document, typeInfo, e => {
+                    errors.push(e);
+                });
+                const visitor = (0, graphql_1.visitInParallel)(validationRulesContext.rules.map(rule => rule(validationContext, args)));
+                (0, graphql_1.visit)(args.document, (0, graphql_1.visitWithTypeInfo)(typeInfo, visitor));
+                if (errors.length > 0) {
+                    let result = {
+                        data: null,
+                        errors,
+                    };
+                    if (onValidationFailed) {
+                        onValidationFailed({ args, result, setResult: newResult => (result = newResult) });
+                    }
+                    setResultAndStopExecution(result);
+                }
+            }
+        }
+    };
+}

package/cjs/rules/one-of.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneOfInputObjectsRule = exports.ONE_OF_DIRECTIVE_SDL = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const common_js_1 = require("../common.js");
+exports.ONE_OF_DIRECTIVE_SDL = `
+  directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
+`;
+const OneOfInputObjectsRule = (validationContext, executionArgs) => {
+    return {
+        Field: node => {
+            var _a, _b;
+            if ((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.length) {
+                const fieldType = validationContext.getFieldDef();
+                if (!fieldType) {
+                    return;
+                }
+                const values = (0, utils_1.getArgumentValues)(fieldType, node, executionArgs.variableValues || undefined);
+                const isOneOfFieldType = ((_b = fieldType.extensions) === null || _b === void 0 ? void 0 : _b.oneOf) || (fieldType.astNode && (0, common_js_1.getDirectiveFromAstNode)(fieldType.astNode, 'oneOf'));
+                if (isOneOfFieldType) {
+                    if (Object.keys(values).length !== 1) {
+                        validationContext.reportError(new graphql_1.GraphQLError(`Exactly one key must be specified for input for field "${fieldType.type.toString()}.${node.name.value}"`, [node]));
+                    }
+                }
+                for (const arg of node.arguments) {
+                    const argType = fieldType.args.find(typeArg => typeArg.name === arg.name.value);
+                    if (argType) {
+                        traverseVariables(validationContext, arg, argType.type, values[arg.name.value]);
+                    }
+                }
+            }
+        },
+    };
+};
+exports.OneOfInputObjectsRule = OneOfInputObjectsRule;
+function getNonNullType(ttype) {
+    if (ttype instanceof graphql_1.GraphQLNonNull) {
+        return ttype.ofType;
+    }
+    return ttype;
+}
+function traverseVariables(validationContext, arg, graphqlType, currentValue) {
+    var _a;
+    // if the current value is empty we don't need to traverse deeper
+    // if it shouldn't be empty, the "original" validation phase should complain.
+    if (currentValue == null) {
+        return;
+    }
+    const unwrappedType = getNonNullType(graphqlType);
+    if ((0, graphql_1.isListType)(unwrappedType)) {
+        if (!Array.isArray(currentValue)) {
+            // because of graphql type coercion a single object should be treated as an array of one object
+            currentValue = [currentValue];
+        }
+        currentValue.forEach(value => {
+            traverseVariables(validationContext, arg, unwrappedType.ofType, value);
+        });
+        return;
+    }
+    if (typeof currentValue !== 'object' || currentValue == null) {
+        // in case the value is not an object, the "original" validation phase should complain.
+        return;
+    }
+    const inputType = (0, graphql_1.getNamedType)(graphqlType);
+    const isOneOfInputType = ((_a = inputType.extensions) === null || _a === void 0 ? void 0 : _a.oneOf) || (inputType.astNode && (0, common_js_1.getDirectiveFromAstNode)(inputType.astNode, 'oneOf'));
+    if (isOneOfInputType) {
+        if (Object.keys(currentValue).length !== 1) {
+            validationContext.reportError(new graphql_1.GraphQLError(`Exactly one key must be specified for input type "${inputType.name}"`, [arg]));
+        }
+    }
+    if (inputType instanceof graphql_1.GraphQLInputObjectType) {
+        for (const [name, fieldConfig] of Object.entries(inputType.getFields())) {
+            traverseVariables(validationContext, arg, fieldConfig.type, currentValue[name]);
+        }
+    }
+}

package/esm/common.js

@@ -0,0 +1,6 @@
+export function getDirectiveFromAstNode(astNode, names) {
+    const directives = astNode.directives || [];
+    const namesArr = Array.isArray(names) ? names : [names];
+    const authDirective = directives.find(d => namesArr.includes(d.name.value));
+    return authDirective || null;
+}

package/esm/index.js

@@ -0,0 +1,3 @@
+export * from './plugin.js';
+export * from './common.js';
+export * from './rules/one-of.js';

package/esm/plugin.js

@@ -0,0 +1,67 @@
+import { TypeInfo, ValidationContext, visit, visitInParallel, visitWithTypeInfo, } from 'graphql';
+const symbolExtendedValidationRules = Symbol('extendedValidationContext');
+export const useExtendedValidation = (options) => {
+    let schemaTypeInfo;
+    function getTypeInfo() {
+        return schemaTypeInfo;
+    }
+    return {
+        onSchemaChange({ schema }) {
+            schemaTypeInfo = new TypeInfo(schema);
+        },
+        onContextBuilding({ context, extendContext }) {
+            // We initialize the validationRules context in onContextBuilding as onExecute is already too late!
+            let validationRulesContext = context[symbolExtendedValidationRules];
+            if (validationRulesContext === undefined) {
+                validationRulesContext = {
+                    rules: [],
+                    didRun: false,
+                };
+                extendContext({
+                    [symbolExtendedValidationRules]: validationRulesContext,
+                });
+            }
+            validationRulesContext.rules.push(...options.rules);
+        },
+        onSubscribe: buildHandler('subscribe', getTypeInfo, options.onValidationFailed),
+        onExecute: buildHandler('execute', getTypeInfo, options.onValidationFailed),
+    };
+};
+function buildHandler(name, getTypeInfo, onValidationFailed) {
+    return function handler({ args, setResultAndStopExecution, }) {
+        var _a;
+        // We hook into onExecute/onSubscribe even though this is a validation pattern. The reasoning behind
+        // it is that hooking right after validation and before execution has started is the
+        // same as hooking into the validation step. The benefit of this approach is that
+        // we may use execution context in the validation rules.
+        const validationRulesContext = args.contextValue[symbolExtendedValidationRules];
+        if (validationRulesContext === undefined) {
+            throw new Error('Plugin has not been properly set up. ' +
+                `The 'contextFactory' function is not invoked and the result has not been passed to '${name}'.`);
+        }
+        // we only want to run the extended execution once.
+        if (validationRulesContext.didRun === false) {
+            validationRulesContext.didRun = true;
+            if (validationRulesContext.rules.length !== 0) {
+                const errors = [];
+                // We replicate the default validation step manually before execution starts.
+                const typeInfo = (_a = getTypeInfo()) !== null && _a !== void 0 ? _a : new TypeInfo(args.schema);
+                const validationContext = new ValidationContext(args.schema, args.document, typeInfo, e => {
+                    errors.push(e);
+                });
+                const visitor = visitInParallel(validationRulesContext.rules.map(rule => rule(validationContext, args)));
+                visit(args.document, visitWithTypeInfo(typeInfo, visitor));
+                if (errors.length > 0) {
+                    let result = {
+                        data: null,
+                        errors,
+                    };
+                    if (onValidationFailed) {
+                        onValidationFailed({ args, result, setResult: newResult => (result = newResult) });
+                    }
+                    setResultAndStopExecution(result);
+                }
+            }
+        }
+    };
+}

package/esm/rules/one-of.js

@@ -0,0 +1,73 @@
+import { GraphQLError, GraphQLInputObjectType, GraphQLNonNull, isListType, getNamedType, } from 'graphql';
+import { getArgumentValues } from '@graphql-tools/utils';
+import { getDirectiveFromAstNode } from '../common.js';
+export const ONE_OF_DIRECTIVE_SDL = /* GraphQL */ `
+  directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
+`;
+export const OneOfInputObjectsRule = (validationContext, executionArgs) => {
+    return {
+        Field: node => {
+            var _a, _b;
+            if ((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.length) {
+                const fieldType = validationContext.getFieldDef();
+                if (!fieldType) {
+                    return;
+                }
+                const values = getArgumentValues(fieldType, node, executionArgs.variableValues || undefined);
+                const isOneOfFieldType = ((_b = fieldType.extensions) === null || _b === void 0 ? void 0 : _b.oneOf) || (fieldType.astNode && getDirectiveFromAstNode(fieldType.astNode, 'oneOf'));
+                if (isOneOfFieldType) {
+                    if (Object.keys(values).length !== 1) {
+                        validationContext.reportError(new GraphQLError(`Exactly one key must be specified for input for field "${fieldType.type.toString()}.${node.name.value}"`, [node]));
+                    }
+                }
+                for (const arg of node.arguments) {
+                    const argType = fieldType.args.find(typeArg => typeArg.name === arg.name.value);
+                    if (argType) {
+                        traverseVariables(validationContext, arg, argType.type, values[arg.name.value]);
+                    }
+                }
+            }
+        },
+    };
+};
+function getNonNullType(ttype) {
+    if (ttype instanceof GraphQLNonNull) {
+        return ttype.ofType;
+    }
+    return ttype;
+}
+function traverseVariables(validationContext, arg, graphqlType, currentValue) {
+    var _a;
+    // if the current value is empty we don't need to traverse deeper
+    // if it shouldn't be empty, the "original" validation phase should complain.
+    if (currentValue == null) {
+        return;
+    }
+    const unwrappedType = getNonNullType(graphqlType);
+    if (isListType(unwrappedType)) {
+        if (!Array.isArray(currentValue)) {
+            // because of graphql type coercion a single object should be treated as an array of one object
+            currentValue = [currentValue];
+        }
+        currentValue.forEach(value => {
+            traverseVariables(validationContext, arg, unwrappedType.ofType, value);
+        });
+        return;
+    }
+    if (typeof currentValue !== 'object' || currentValue == null) {
+        // in case the value is not an object, the "original" validation phase should complain.
+        return;
+    }
+    const inputType = getNamedType(graphqlType);
+    const isOneOfInputType = ((_a = inputType.extensions) === null || _a === void 0 ? void 0 : _a.oneOf) || (inputType.astNode && getDirectiveFromAstNode(inputType.astNode, 'oneOf'));
+    if (isOneOfInputType) {
+        if (Object.keys(currentValue).length !== 1) {
+            validationContext.reportError(new GraphQLError(`Exactly one key must be specified for input type "${inputType.name}"`, [arg]));
+        }
+    }
+    if (inputType instanceof GraphQLInputObjectType) {
+        for (const [name, fieldConfig] of Object.entries(inputType.getFields())) {
+            traverseVariables(validationContext, arg, fieldConfig.type, currentValue[name]);
+        }
+    }
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@envelop/extended-validation",
-  "version": "1.7.0-alpha-aca44e1.0",
+  "version": "1.7.0-alpha-385b86b.0",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "2.4.0-alpha-aca44e1.0",
+    "@envelop/core": "2.4.0-alpha-385b86b.0",
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
@@ -11,26 +11,47 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dotansimha/envelop.git",
+    "url": "https://github.com/n1ru4l/envelop.git",
     "directory": "packages/plugins/extended-validation"
   },
   "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": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin.js';
+export * from './common.js';
+export * from './rules/one-of.js';

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

@@ -1,6 +1,6 @@
 import { Plugin } from '@envelop/core';
 import { ExecutionArgs, ExecutionResult } from 'graphql';
-import { ExtendedValidationRule } from './common';
+import { ExtendedValidationRule } from './common.js';
 declare type OnValidationFailedCallback = (params: {
     args: ExecutionArgs;
     result: ExecutionResult;

package/{rules → typings/rules}/one-of.d.ts

@@ -1,3 +1,3 @@
-import { ExtendedValidationRule } from '../common';
+import { ExtendedValidationRule } from '../common.js';
 export declare const ONE_OF_DIRECTIVE_SDL = "\n  directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION\n";
 export declare const OneOfInputObjectsRule: ExtendedValidationRule;

package/README.md

@@ -1,135 +0,0 @@
-## `@envelop/extended-validation`
-
-Extended validation plugin adds support for writing GraphQL validation rules, that has access to all `execute` parameters, including variables.
-
-While GraphQL supports fair amount of built-in validations, and validations could be extended, it's doesn't expose `variables` to the validation rules, since operation variables are not available during `validate` flow (it's only available through execution of the operation, after input/variables coercion is done).
-
-This plugin runs before `validate` but allow developers to write their validation rules in the same way GraphQL `ValidationRule` is defined (based on a GraphQL visitor).
-
-## Getting Started
-
-Start by installing the plugin:
-
-```
-yarn add @envelop/extended-validation
-```
-
-Then, use the plugin with your validation rules:
-
-```ts
-import { useExtendedValidation } from '@envelop/extended-validation';
-
-const getEnveloped = evelop({
-  plugins: [
-    useExtendedValidation({
-      rules: [ ... ] // your rules here
-    })
-  ]
-})
-```
-
-To create your custom rules, implement the `ExtendedValidationRule` interface and return your GraphQL AST visitor.
-
-For example:
-
-```ts
-import { ExtendedValidationRule } from '@envelop/extended-validation';
-
-export const MyRule: ExtendedValidationRule = (validationContext, executionArgs) => {
-  return {
-    OperationDefinition: node => {
-      // This will run for every executed Query/Mutation/Subscription
-      // And now you also have access to the execution params like variables, context and so on.
-      // If you wish to report an error, use validationContext.reportError or throw an exception.
-    },
-  };
-};
-```
-
-## Built-in Rules
-
-### Union Inputs: `@oneOf`
-
-This directive provides validation for input types and implements the concept of union inputs. You can find the [complete spec RFC here](https://github.com/graphql/graphql-spec/pull/825).
-
-You can use union inputs either via a the SDL flow, by annotating types and fields with `@oneOf` or via the `extensions` field.
-
-First, make sure to add that rule to your plugin usage:
-
-```ts
-import { useExtendedValidation, OneOfInputObjectsRule } from '@envelop/extended-validation';
-
-const getEnveloped = evelop({
-  plugins: [
-    useExtendedValidation({
-      rules: [OneOfInputObjectsRule],
-    }),
-  ],
-});
-```
-
-#### Schema Directive Flow
-
-Make sure to include the following directive in your schema:
-
-```graphql
-directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
-```
-
-Then, apply it to field definitions, or to a complete `input` type:
-
-```graphql
-## Apply to entire input type
-input FindUserInput @oneOf {
-  id: ID
-  organizationAndRegistrationNumber: GraphQLInt
-}
-
-## Or, apply to a set of input arguments
-
-type Query {
-  foo(id: ID, str1: String, str2: String): String @oneOf
-}
-```
-
-#### Programmatic extensions flow
-
-```tsx
-const GraphQLFindUserInput = new GraphQLInputObjectType({
-  name: 'FindUserInput',
-  fields: {
-    id: {
-      type: GraphQLID,
-    },
-    organizationAndRegistrationNumber: {
-      type: GraphQLInt,
-    },
-  },
-  extensions: {
-    oneOf: true,
-  },
-});
-
-const Query = new GraphQLObjectType({
-  name: 'Query',
-  fields: {
-    foo: {
-      type: GraphQLString,
-      args: {
-        id: {
-          type: GraphQLID,
-        },
-        str1: {
-          type: GraphQLString,
-        },
-        str2: {
-          type: GraphQLString,
-        },
-      },
-      extensions: {
-        oneOf: true,
-      },
-    },
-  },
-});
-```

package/index.d.ts

@@ -1,3 +0,0 @@
-export * from './plugin';
-export * from './common';
-export * from './rules/one-of';

package/index.js

@@ -1,156 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const graphql = require('graphql');
-const utils = require('@graphql-tools/utils');
-
-const symbolExtendedValidationRules = Symbol('extendedValidationContext');
-const useExtendedValidation = (options) => {
-    let schemaTypeInfo;
-    function getTypeInfo() {
-        return schemaTypeInfo;
-    }
-    return {
-        onSchemaChange({ schema }) {
-            schemaTypeInfo = new graphql.TypeInfo(schema);
-        },
-        onContextBuilding({ context, extendContext }) {
-            // We initialize the validationRules context in onContextBuilding as onExecute is already too late!
-            let validationRulesContext = context[symbolExtendedValidationRules];
-            if (validationRulesContext === undefined) {
-                validationRulesContext = {
-                    rules: [],
-                    didRun: false,
-                };
-                extendContext({
-                    [symbolExtendedValidationRules]: validationRulesContext,
-                });
-            }
-            validationRulesContext.rules.push(...options.rules);
-        },
-        onSubscribe: buildHandler('subscribe', getTypeInfo, options.onValidationFailed),
-        onExecute: buildHandler('execute', getTypeInfo, options.onValidationFailed),
-    };
-};
-function buildHandler(name, getTypeInfo, onValidationFailed) {
-    return function handler({ args, setResultAndStopExecution, }) {
-        var _a;
-        // We hook into onExecute/onSubscribe even though this is a validation pattern. The reasoning behind
-        // it is that hooking right after validation and before execution has started is the
-        // same as hooking into the validation step. The benefit of this approach is that
-        // we may use execution context in the validation rules.
-        const validationRulesContext = args.contextValue[symbolExtendedValidationRules];
-        if (validationRulesContext === undefined) {
-            throw new Error('Plugin has not been properly set up. ' +
-                `The 'contextFactory' function is not invoked and the result has not been passed to '${name}'.`);
-        }
-        // we only want to run the extended execution once.
-        if (validationRulesContext.didRun === false) {
-            validationRulesContext.didRun = true;
-            if (validationRulesContext.rules.length !== 0) {
-                const errors = [];
-                // We replicate the default validation step manually before execution starts.
-                const typeInfo = (_a = getTypeInfo()) !== null && _a !== void 0 ? _a : new graphql.TypeInfo(args.schema);
-                const validationContext = new graphql.ValidationContext(args.schema, args.document, typeInfo, e => {
-                    errors.push(e);
-                });
-                const visitor = graphql.visitInParallel(validationRulesContext.rules.map(rule => rule(validationContext, args)));
-                graphql.visit(args.document, graphql.visitWithTypeInfo(typeInfo, visitor));
-                if (errors.length > 0) {
-                    let result = {
-                        data: null,
-                        errors,
-                    };
-                    if (onValidationFailed) {
-                        onValidationFailed({ args, result, setResult: newResult => (result = newResult) });
-                    }
-                    setResultAndStopExecution(result);
-                }
-            }
-        }
-    };
-}
-
-function getDirectiveFromAstNode(astNode, names) {
-    const directives = astNode.directives || [];
-    const namesArr = Array.isArray(names) ? names : [names];
-    const authDirective = directives.find(d => namesArr.includes(d.name.value));
-    return authDirective || null;
-}
-
-const ONE_OF_DIRECTIVE_SDL = /* GraphQL */ `
-  directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
-`;
-const OneOfInputObjectsRule = (validationContext, executionArgs) => {
-    return {
-        Field: node => {
-            var _a, _b;
-            if ((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.length) {
-                const fieldType = validationContext.getFieldDef();
-                if (!fieldType) {
-                    return;
-                }
-                const values = utils.getArgumentValues(fieldType, node, executionArgs.variableValues || undefined);
-                const isOneOfFieldType = ((_b = fieldType.extensions) === null || _b === void 0 ? void 0 : _b.oneOf) || (fieldType.astNode && getDirectiveFromAstNode(fieldType.astNode, 'oneOf'));
-                if (isOneOfFieldType) {
-                    if (Object.keys(values).length !== 1) {
-                        validationContext.reportError(new graphql.GraphQLError(`Exactly one key must be specified for input for field "${fieldType.type.toString()}.${node.name.value}"`, [node]));
-                    }
-                }
-                for (const arg of node.arguments) {
-                    const argType = fieldType.args.find(typeArg => typeArg.name === arg.name.value);
-                    if (argType) {
-                        traverseVariables(validationContext, arg, argType.type, values[arg.name.value]);
-                    }
-                }
-            }
-        },
-    };
-};
-function getNonNullType(ttype) {
-    if (ttype instanceof graphql.GraphQLNonNull) {
-        return ttype.ofType;
-    }
-    return ttype;
-}
-function traverseVariables(validationContext, arg, graphqlType, currentValue) {
-    var _a;
-    // if the current value is empty we don't need to traverse deeper
-    // if it shouldn't be empty, the "original" validation phase should complain.
-    if (currentValue == null) {
-        return;
-    }
-    const unwrappedType = getNonNullType(graphqlType);
-    if (graphql.isListType(unwrappedType)) {
-        if (!Array.isArray(currentValue)) {
-            // because of graphql type coercion a single object should be treated as an array of one object
-            currentValue = [currentValue];
-        }
-        currentValue.forEach(value => {
-            traverseVariables(validationContext, arg, unwrappedType.ofType, value);
-        });
-        return;
-    }
-    if (typeof currentValue !== 'object' || currentValue == null) {
-        // in case the value is not an object, the "original" validation phase should complain.
-        return;
-    }
-    const inputType = graphql.getNamedType(graphqlType);
-    const isOneOfInputType = ((_a = inputType.extensions) === null || _a === void 0 ? void 0 : _a.oneOf) || (inputType.astNode && getDirectiveFromAstNode(inputType.astNode, 'oneOf'));
-    if (isOneOfInputType) {
-        if (Object.keys(currentValue).length !== 1) {
-            validationContext.reportError(new graphql.GraphQLError(`Exactly one key must be specified for input type "${inputType.name}"`, [arg]));
-        }
-    }
-    if (inputType instanceof graphql.GraphQLInputObjectType) {
-        for (const [name, fieldConfig] of Object.entries(inputType.getFields())) {
-            traverseVariables(validationContext, arg, fieldConfig.type, currentValue[name]);
-        }
-    }
-}
-
-exports.ONE_OF_DIRECTIVE_SDL = ONE_OF_DIRECTIVE_SDL;
-exports.OneOfInputObjectsRule = OneOfInputObjectsRule;
-exports.getDirectiveFromAstNode = getDirectiveFromAstNode;
-exports.useExtendedValidation = useExtendedValidation;

package/index.mjs

@@ -1,149 +0,0 @@
-import { TypeInfo, ValidationContext, visitInParallel, visit, visitWithTypeInfo, GraphQLError, isListType, getNamedType, GraphQLInputObjectType, GraphQLNonNull } from 'graphql';
-import { getArgumentValues } from '@graphql-tools/utils';
-
-const symbolExtendedValidationRules = Symbol('extendedValidationContext');
-const useExtendedValidation = (options) => {
-    let schemaTypeInfo;
-    function getTypeInfo() {
-        return schemaTypeInfo;
-    }
-    return {
-        onSchemaChange({ schema }) {
-            schemaTypeInfo = new TypeInfo(schema);
-        },
-        onContextBuilding({ context, extendContext }) {
-            // We initialize the validationRules context in onContextBuilding as onExecute is already too late!
-            let validationRulesContext = context[symbolExtendedValidationRules];
-            if (validationRulesContext === undefined) {
-                validationRulesContext = {
-                    rules: [],
-                    didRun: false,
-                };
-                extendContext({
-                    [symbolExtendedValidationRules]: validationRulesContext,
-                });
-            }
-            validationRulesContext.rules.push(...options.rules);
-        },
-        onSubscribe: buildHandler('subscribe', getTypeInfo, options.onValidationFailed),
-        onExecute: buildHandler('execute', getTypeInfo, options.onValidationFailed),
-    };
-};
-function buildHandler(name, getTypeInfo, onValidationFailed) {
-    return function handler({ args, setResultAndStopExecution, }) {
-        var _a;
-        // We hook into onExecute/onSubscribe even though this is a validation pattern. The reasoning behind
-        // it is that hooking right after validation and before execution has started is the
-        // same as hooking into the validation step. The benefit of this approach is that
-        // we may use execution context in the validation rules.
-        const validationRulesContext = args.contextValue[symbolExtendedValidationRules];
-        if (validationRulesContext === undefined) {
-            throw new Error('Plugin has not been properly set up. ' +
-                `The 'contextFactory' function is not invoked and the result has not been passed to '${name}'.`);
-        }
-        // we only want to run the extended execution once.
-        if (validationRulesContext.didRun === false) {
-            validationRulesContext.didRun = true;
-            if (validationRulesContext.rules.length !== 0) {
-                const errors = [];
-                // We replicate the default validation step manually before execution starts.
-                const typeInfo = (_a = getTypeInfo()) !== null && _a !== void 0 ? _a : new TypeInfo(args.schema);
-                const validationContext = new ValidationContext(args.schema, args.document, typeInfo, e => {
-                    errors.push(e);
-                });
-                const visitor = visitInParallel(validationRulesContext.rules.map(rule => rule(validationContext, args)));
-                visit(args.document, visitWithTypeInfo(typeInfo, visitor));
-                if (errors.length > 0) {
-                    let result = {
-                        data: null,
-                        errors,
-                    };
-                    if (onValidationFailed) {
-                        onValidationFailed({ args, result, setResult: newResult => (result = newResult) });
-                    }
-                    setResultAndStopExecution(result);
-                }
-            }
-        }
-    };
-}
-
-function getDirectiveFromAstNode(astNode, names) {
-    const directives = astNode.directives || [];
-    const namesArr = Array.isArray(names) ? names : [names];
-    const authDirective = directives.find(d => namesArr.includes(d.name.value));
-    return authDirective || null;
-}
-
-const ONE_OF_DIRECTIVE_SDL = /* GraphQL */ `
-  directive @oneOf on INPUT_OBJECT | FIELD_DEFINITION
-`;
-const OneOfInputObjectsRule = (validationContext, executionArgs) => {
-    return {
-        Field: node => {
-            var _a, _b;
-            if ((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.length) {
-                const fieldType = validationContext.getFieldDef();
-                if (!fieldType) {
-                    return;
-                }
-                const values = getArgumentValues(fieldType, node, executionArgs.variableValues || undefined);
-                const isOneOfFieldType = ((_b = fieldType.extensions) === null || _b === void 0 ? void 0 : _b.oneOf) || (fieldType.astNode && getDirectiveFromAstNode(fieldType.astNode, 'oneOf'));
-                if (isOneOfFieldType) {
-                    if (Object.keys(values).length !== 1) {
-                        validationContext.reportError(new GraphQLError(`Exactly one key must be specified for input for field "${fieldType.type.toString()}.${node.name.value}"`, [node]));
-                    }
-                }
-                for (const arg of node.arguments) {
-                    const argType = fieldType.args.find(typeArg => typeArg.name === arg.name.value);
-                    if (argType) {
-                        traverseVariables(validationContext, arg, argType.type, values[arg.name.value]);
-                    }
-                }
-            }
-        },
-    };
-};
-function getNonNullType(ttype) {
-    if (ttype instanceof GraphQLNonNull) {
-        return ttype.ofType;
-    }
-    return ttype;
-}
-function traverseVariables(validationContext, arg, graphqlType, currentValue) {
-    var _a;
-    // if the current value is empty we don't need to traverse deeper
-    // if it shouldn't be empty, the "original" validation phase should complain.
-    if (currentValue == null) {
-        return;
-    }
-    const unwrappedType = getNonNullType(graphqlType);
-    if (isListType(unwrappedType)) {
-        if (!Array.isArray(currentValue)) {
-            // because of graphql type coercion a single object should be treated as an array of one object
-            currentValue = [currentValue];
-        }
-        currentValue.forEach(value => {
-            traverseVariables(validationContext, arg, unwrappedType.ofType, value);
-        });
-        return;
-    }
-    if (typeof currentValue !== 'object' || currentValue == null) {
-        // in case the value is not an object, the "original" validation phase should complain.
-        return;
-    }
-    const inputType = getNamedType(graphqlType);
-    const isOneOfInputType = ((_a = inputType.extensions) === null || _a === void 0 ? void 0 : _a.oneOf) || (inputType.astNode && getDirectiveFromAstNode(inputType.astNode, 'oneOf'));
-    if (isOneOfInputType) {
-        if (Object.keys(currentValue).length !== 1) {
-            validationContext.reportError(new GraphQLError(`Exactly one key must be specified for input type "${inputType.name}"`, [arg]));
-        }
-    }
-    if (inputType instanceof GraphQLInputObjectType) {
-        for (const [name, fieldConfig] of Object.entries(inputType.getFields())) {
-            traverseVariables(validationContext, arg, fieldConfig.type, currentValue[name]);
-        }
-    }
-}
-
-export { ONE_OF_DIRECTIVE_SDL, OneOfInputObjectsRule, getDirectiveFromAstNode, useExtendedValidation };