Using directives

[valerii15298]

I am trying to imlement directives with type-graphql:

import {getDirective, MapperKind, mapSchema} from "@graphql-tools/utils";
import {GraphQLSchema} from "graphql";
// ... other imports

function directiveTransformer(schema: GraphQLSchema, directiveName: string) {
  return mapSchema(schema, {

    // Executes once for each object field definition in the schema
    [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
      const directive = getDirective(schema, fieldConfig, directiveName);
      if (directive) {
        console.log({directive})
        return fieldConfig;
      }
    }
  });
};

@Resolver()
export class CustomResolver {
  @Directive("@auth(requires: ADMIN)")
  @Query((_returns) => String, { nullable: true })
  async testQuery() {
    return 'It is query';
  }
}

const schema = buildSchemaSync({
  resolvers: [CustomResolver],
});

directiveTransformer(schema, "auth")

The problem: it does not detect directive at all...
console.log is not showing anything.
I do not know how to detect if there is directive in schema: GraphQLSchema or not, but I checked it few times, according to examples:
apollo and typegraphql

SchemaDirectiveVisitor is deprecated know so I am using as explained in apollo docs, because schema parameter is the same.
Can you tell me:
Is it a bug in type-graphql?
Do I need to use SchemaDirectiveVisitor to make it work and there is now way to use it in new way?
Or maybe I am doing something wrong?
And how to make directives work?

Will be very thankful for the answers how to use it properly.

Update: I tried: console.dir({ schema }, {depth: 10}) and it appears directives really exist in schema object.
But still, it is still not showing in directiveTransformer and not understandable how to use it properly.

[MichalLytek]

You need to create new GraphQLDirective with the definition side, not only the graphql tools implementation part.

[valerii15298]

Thanks for pointing out.

I tried this one:

@Directive("@auth(requires: USER)")
@ObjectType()
class Foo {
  @Field()
  field: string;
}

@Resolver(of => Foo)
class FooBarResolver {
  @Directive("@auth(requires: ANY)") // only this one can be found
  @Query()
  foobar(@Arg("baz") baz: string): string {
    return "foobar";
  }

  @Directive("@auth(requires: ANY)")
  @FieldResolver()
  bar(): string {
    return "foobar";
  }
}

const fn = (fieldConfig: any) => {
  const directive = getDirective(schema, fieldConfig, "auth");

  if (directive) {
    console.log({ directive});

    return fieldConfig;
  }
};

function directiveTransformer(schema: GraphQLSchema) {
  return mapSchema(schema, Object.values(MapperKind).reduce((acc, next) => { // checking all available locations
    acc[next] = fn;
    return acc
  }, {} as any));
}

const schema = buildSchemaSync({
  resolvers: [FooBarResolver],
  directives: [new GraphQLDirective({
    name: "auth",
    locations: Object.values(DirectiveLocation), // allowing all available locations
    isRepeatable: true
  })]
});

But again it found only one @auth directive as I commented in code. Others just cannot be found if I comment that one.
Though I checked all locations. I even tried to create directives as this:

const typeDefs = gql`
    directive @auth on FIELD_DEFINITION | FIELD | ARGUMENT_DEFINITION | OBJECT | QUERY | VARIABLE_DEFINITION | INPUT_FIELD_DEFINITION | INPUT_OBJECT | INTERFACE | SCHEMA | ENUM | ENUM_VALUE
`;

const directivesSchema = makeExecutableSchema({
  typeDefs
});

and pass as [...directivesSchema.getDirectives()]
but again it works the same :(
Can you tell please, Is there something I am missing again?

[valerii15298]

For now as I tested it works only with fields that have @Query or @Mutation decorators. But not with @fieldResolver or others decorators.

[valerii15298]

@MichalLytek actually directives work also for fields in object types(those with @ObjectType decorator).
This one will work and directive will be visible:

@ObjectType()
export class ObjType {
  @Directive("@auth")
  @Field()
  test: string;
}

But this one will not:

@Directive("@auth")
@ObjectType()
export class ObjType {
  @Field()
  test: string;
}

Also any directive above @Query or @Mutation decorators in resolvers will work, but directive above @FieldResolver will not, here examples:
This will work:

@Resolver()
export class SomeResolver {
  @Directive("@auth")
  @Query(_returns => String)
  test() {
    return "test";
  }

  @Directive("@auth")
  @Mutation(_returns => String)
  test2() {
    return "test";
  }
}

but this one will not:

@Resolver(_of => Recipe)
export class SomeResolverOf {
  @Directive("@auth")
  @FieldResolver()
  test() {
    return "test filed resolver";
  }
}

Luckily in this way it is possible to put directives at any field, just remember not to put it in places where it does not work. I do not know if it is a bug in implementation or docs but anyway I think it should be consistent and understandable.

So if it is not a bug in the implementation, I suggest fix docs here where directive is used above @FieldResolver. And explain in docs where directives could be used.

Should I open separate issue for it?

[MichalLytek]

Directives on field resolvers works:
https://github.com/MichalLytek/type-graphql/blob/master/tests/functional/directives.ts#L512

You need to properly implement your directive transformer. TypeGraphQL is only responsible for declaring the directive AST in SDL.
You can use printSchemaWithDirectives from graphql tools in order to see where it registers your directives.

[valerii15298]

Finally I solved it. Problem was: I was not defining @Query or @Mutation type on @FieldResolver. Needed field was not even created in schema and simply ignored without error. And directive was not visible bcs field does not exist in schema. And since I was testing it only by searching directives in schema - I did not notice that field does not even exist and if field does not exist - directive to that field is not visible of course too.
Code:

@ObjectType()
class Foo {
  @Field()
  field: string;
}

@Resolver((_of) => Foo)
class FooBarResolver {
  @Directive('@auth(requires: ANY)') // only this one can be found
  @Query()
  foobar(@Arg('baz') _baz: string): string {
    return 'foobar';
  }

  @Directive('@auth(requires: ANY)')
  // @Query() // if `@Query` is not defined here, it will not be visible and that is actually logical bcs typegraphql cannot determine
       // whether it is query or mutation type. So it just will be omitted(without error unfortunately, but maybe that is reasonable, I do not know).
      // but if you test it and open in graphql explorer or print schema, problem is visible right away.
  @FieldResolver()
  bar(): string {
    return 'bar';
  }
}

So yep, directives actually work fine. It was just a tricky for me in this particular case until I printed the schema and understand the cause.