graphql-directive-auth

Introduction

The graphql-directive-auth was created to help with common authentication tasks that is faced in almost every API.

graphql-directive-auth
Introduction
Table of Contents
Installation
Usage
Directive Parameters
- Contributing
LICENSE

Installation

yarn add graphql-directive-auth

Usage

We are able to use directives in two different way:

Default

To use the default directive behaviour, you need to set APP_SECRET environment variable, and that's all.

What `default` means, and what I need to do?

@isAuthenitaced - Just after you set environment variables, you need to have a valid JWT token and send it by Authorization in the HTTP headers. That's all, the directive will be check your token and throw an error if the token is invalid or expired.
@hasRole - is for checking roles of an authenticated user. To use it correctly, inside your JWT token you should have the role property with the correct role. If the user role doesn't match with the provided role, then directive will throw an error.

@hasRole before checking role is doing authentication to get roles from JWT token.

Example:

import AuthDirective from 'graphql-directive-auth';
// or
const AuthDirective = require('graphql-directive-auth');

// set environment variable, but in better way ;)
process.env.APP_SECRET = 'your_secret_key';

const schema = makeExecutableSchema({
  typeDefs,
  resolvers,
  schemaDirectives: {
    // to use @hasRole and @isAuthenticated directives
    ...AuthDirective,
    // custom name for @isAuthenticated
    auth: AuthDirective().isAuthenticated,
    // custom name for @hasRole
    role: AuthDirective().hasRole,
  },
});

Custom behaviour of authentication functions

If you need custom Authentication you can pass your authenticated function to the main AuthDirective functions.

Authentication function signature:

context => {
  // your logic here

  // you should return an object
  // this object will be passed inside your resolver
  // it is available inside context via auth property
  return {
    user: {
      id: 'your_user_id',
    },
  };
};

usage:

import AuthDirectives from 'graphql-directive-auth';
// or
const AuthDirectives = require('graphql-directive-auth');

const customAuth = AuthDirectives({
  authenticateFunc: cusomFunc,
  checkRoleFunc: cusomFunc
});

const schema = makeExecutableSchema({
  typeDefs,
  resolvers,
  schemaDirectives: {
    // to use @hasRole and @isAuthenticated directives
    ...customAuth,
    // custom name for @isAuthenticated
    auth: customAuth().isAuthenticated,
    // custom name for @hasRole
    role: customAuth().hasRole,
  },

resolver:

export default {
  Query: {
    me() (root, args, ctx){
      const userId = ctx.auth.user.id; // your_user_id
    },
  },
};

Custom check role function

The same as authenticate function you can add your own logic to checking roles.

How to create your own function

Function accept two parameters, one is the context and the second is value from the directive use
To reject an acces to the particular field, you need to throw an Error that will be caught by the directive and returned if required.
function don't need to return enything special

Directive Parameters

'@isAuthenticated' - check if user is authenticated
'@hasRole(role: "user, admin")' - check if user is authenticated

if you use graphql-import then you need to add this definition on top of the schema:

directive @isAuthenticated on FIELD | FIELD_DEFINITION
directive @hasRole(role: String) on FIELD | FIELD_DEFINITION

Contributing

I would love to see your contribution. ❤️

For local development (and testing), all you have to do is to run yarn and then yarn dev. This will start the Apollo server and you are ready to contribute 🎉

Run yarn test (try --watch flag) for unit tests (we are using Jest)

LICENSE

The MIT License (MIT) 2018 - Luke Czyszczonik - mailto:lukasz.czyszczonik@gmail.com

lambrojos/graphql-directive-auth