Fix/directives not applied to type args

lib/createSchemaMapperForVisitor.ts

@@ -2,6 +2,7 @@ import type { SchemaMapper } from '@graphql-tools/utils';
 import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils';
 import type {
   DirectiveLocation,
+  GraphQLArgument,
   GraphQLFieldConfig,
   GraphQLObjectType,
   GraphQLSchema,
@@ -26,6 +27,17 @@ export const createMapper = <T extends DirectiveLocation>(
     return mutation;
   },
   [MapperKind.OBJECT_TYPE](type, schema): GraphQLObjectType {
+    Object.values(type.getFields()).forEach(field => {
+      field.args.forEach(arg => {
+        const [directive] = getDirective(schema, arg, directiveName) ?? [];
+        if (!directive) return;
+        // eslint-disable-next-line no-param-reassign
+        visitor.args = directive;
+        visitor.visitArgumentDefinition(arg as GraphQLArgument, {
+          field,
+        });
+      });
+    });
     const [directive] = getDirective(schema, type, directiveName) ?? [];
     if (!directive) return type;
     // eslint-disable-next-line no-param-reassign

lib/foreignNodeId.test.ts

@@ -256,6 +256,71 @@ ${validationDirectionEnumTypeDefs(capitalizedName)}
     expect(result).toEqual({ data: rootValue });
   });
 
+  it('should decode arguments in type field argument', async (): Promise<void> => {
+    const schema = new ForeignNodeId().applyToSchema(
+      makeExecutableSchema({
+        resolvers: {
+          Query: {},
+          TestType: {
+            typeIds: (_, { ids }) => {
+              return ids;
+            },
+          },
+        },
+        typeDefs: [
+          ...directiveTypeDefs,
+          gql`
+            type TestType {
+              typeIds(
+                ids: [ID!]! @foreignNodeId(typename: "TypeID")
+                otherArgs: String
+              ): [String!]!
+            }
+            type Query {
+              testType: TestType!
+              unusedQuery: TestType!
+            }
+          `,
+        ],
+      }),
+    );
+    const source = print(gql`
+      query MyQuery($typeIds: [ID!]!) {
+        testType {
+          typeIds(ids: $typeIds)
+        }
+      }
+    `);
+    const decodedIds = ['123', '345', '678', '910'];
+    const encodedIds = decodedIds.map(id => toNodeId('TypeID', id));
+    const variableValues = {
+      typeIds: encodedIds,
+    };
+    const rootValue = {
+      testType: {},
+    };
+
+    const contextValue = ForeignNodeId.createDirectiveContext({
+      fromNodeId,
+    });
+    const spy = jest.spyOn(contextValue, 'fromNodeId');
+    const result = await graphql({
+      contextValue,
+      rootValue,
+      schema,
+      source,
+      variableValues,
+    });
+    expect(spy).toHaveBeenCalledTimes(encodedIds.length);
+    expect(result).toEqual({
+      data: {
+        testType: {
+          typeIds: decodedIds,
+        },
+      },
+    });
+  });
+
   it('should work when used on mutation inputs', async (): Promise<void> => {
     const mockResolver = jest.fn().mockReturnValue('return value');
     const typeName = 'MyType';

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profusion/apollo-validation-directives",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "description": "GraphQL directives to implement field validations in Apollo Server",
   "author": "Gustavo Sverzut Barbieri <[email protected]>",
   "license": "MIT",