Returning custom directives in extensions or header

[elysakohrs]

Hi, I have a schema with a custom @auth directive with a requires argument for a list of permissions required on an object or field. At certain times, I would like to be able to return either in the extensions field in the response or in an HTTP header the list of all permissions required for a particular query so that internal developers can know what permissions are required for their query.

I attempted to do this by writing a plugin, referring to the Apollo Cache Control plugin. But it seems like doing something like this targetType.astNode?.directives (like this line) only gives access to the default directives, not to my custom one. Is there a way to access custom directives from a plugin? If not, is there an alternate way to accomplish what I'm trying to, such as by modifying how I extend SchemaDirectiveVisitor to implement the auth directive?

I appreciate any ideas, thank you!

[glasser]

I don't think there's anything special about cache control directives vs other directives here. Showing a complete reproduction might make it easier to delve into this issue.

[elysakohrs]

Thanks for the response. I tried to create a minimal ApolloServer to recreate what I'm seeing. Here's the code I have:

const { ApolloServer, gql, SchemaDirectiveVisitor } = require("apollo-server");
const { defaultFieldResolver, getNamedType } = require('graphql');

const typeDefs = gql`
  type Book {
    title: String
    author: String
  }

  type Query {
    books: [Book] @auth(requires: [READ_BOOKS])
  }

  enum Permission {
    READ_BOOKS
  }

  directive @auth(requires: [Permission!]! = []) on OBJECT | FIELD_DEFINITION
`;

const books = [
  {
    title: 'The Awakening',
    author: 'Kate Chopin',
  },
];

const resolvers = {
  Query: {
    books: () => books,
  },
};

class AuthDirective extends SchemaDirectiveVisitor {
  visitObject(type) {
    this.ensureFieldsWrapped(type);
    type._requiredAuthRole = this.args.requires;
  }

  visitFieldDefinition(field, details) {
    this.ensureFieldsWrapped(details.objectType);
    field._requiredAuthRole = this.args.requires;
  }

  ensureFieldsWrapped(objectType) {
    if (objectType._authFieldsWrapped) return;
    objectType._authFieldsWrapped = true;

    const fields = objectType.getFields();

    Object.keys(fields).forEach(fieldName => {
      const field = fields[fieldName];
      const { resolve = defaultFieldResolver } = field;
      field.resolve = async function (...args) {
        const requiredRoles =
          field._requiredAuthRole ||
          objectType._requiredAuthRole;

        if (!requiredRoles) {
          return resolve.apply(this, args);
        }

        const context = args[2];
        const roles = (context.headers.roles).split(',');
        if (!requiredRoles.every(requiredRole => roles.includes(requiredRole))) {
          throw new Error("not authorized");
        }

        return resolve.apply(this, args);
      };
    });
  }
}

const plugin = {
  requestDidStart() {
    return {
      executionDidStart: () => ({
        willResolveField({ info }) {
          const targetType = getNamedType(info.returnType);

          console.log('DIRECTIVES', targetType.astNode?.directives);
        },
      }),
    };
  },
};

const server = new ApolloServer({
  typeDefs,
  schemaDirectives: {
    auth: AuthDirective,
  },
  context: ({ req }) => ({ headers: req.headers }),
  resolvers,
  plugins: [plugin]
});


server.listen().then(({ url }) => {
  console.log(`🚀  Server ready at ${url}`);
});

I'm running this query and also passing in an HTTP header of "roles": "READ_BOOKS":

query Books {
  books {
    title
    author
  }
}

I would expect to see the auth directive logged, but I don't:

DIRECTIVES []
DIRECTIVES undefined
DIRECTIVES undefined

[glasser]

Just as a quick note, you've placed a directive on a field, but you're logging directives from the type's AST node.

[elysakohrs]

Ah thank you for catching that, I was able to figure it out based on that comment (did refer here some). I changed willResolveField to this and it works:

        willResolveField({ info }) {
          const parentTypeFields = info.parentType.getFields();
          const fieldDef = parentTypeFields[info.fieldName];

          const directive = info.schema.getDirective('auth');
          const fieldAstNode = fieldDef.astNode;
          if (!directive || !fieldAstNode) return;

          const directiveValue = getDirectiveValues(directive, fieldAstNode);
          if (!directiveValue) return;

          console.log('Directive Value', directiveValue);
        },

Thank you for the help @glasser!