Omnile-oauth2server NPM

OAuth2Server

___________           .__      ________                 .__.__          
\__    ___/___   ____ |  |__   \_____  \   _____   ____ |__|  |   ____  
  |    |_/ __ \_/ ___\|  |  \   /   |   \ /     \ /    \|  |  | _/ __ \
  |    |\  ___/\  \___|   Y  \ /    |    \  Y Y  \   |  \  |  |_\  ___/
  |____| \___  >\___  >___|  / \_______  /__|_|  /___|  /__|____/\___  >
             \/     \/     \/          \/      \/     \/             \/  
             Techflow like the Nile River®.

About this package?

OAuth2 Server for NodeJs. Only Password and Refresh Token grant types are available now. More grant types will come soon.

Installing this package

To install library, simply run

$ npm install omnile-oauth2server

Basic Usage

Generating Access Tokens (TypeScript Example)

Generating an access token using this package is in two simple steps. First, you create an authorization server and then you provide an auth payload to the server to get the access token.

Server Setup

This package makes no assumption about how your data is stored or what database you use. It achieves this by providing a set of interfaces to be implemented using the repository design pattern.

Repositories

There are 3 repositories to be implemented for the OAuth process. These are: 1. ClientRepositoryI 2. TokenRepositoryI 3. UserRepositoryI

const clients: ClientRepositoryI = new ClientRepository();
const tokens: TokenRepositoryI = new TokenRepository();
const users: UserRepositoryI = new UserRepository();

Server Options

Once the repositories are setup, the next thing is to make a set of options for the Authorization Server. This should be an implementation of ServerOptionsI

const options: ServerOptionsI = {
    clientRepository: clients,
    userRepository: users,
    tokenRepository: tokens,
    privateKey: 'path/to/private-key.key',
    tokenExpiryMins: 30,
    encryptionKey: 'some-strong-encryption-key'
};

Now we're ready to create the authorization server. We'll put all the steps together to make it clearer.

import AuthorizationServer from 'omnile-oauth2server';

// Repository Setup
const clients: ClientRepositoryI = new ClientRepository();
const tokens: TokenRepositoryI = new TokenRepository();
const users: UserRepositoryI = new UserRepository();

// Server options
const options: ServerOptionsI = {
    clientRepository: clients,
    userRepository: users,
    tokenRepository: tokens,
    privateKey: 'path/to/private-key.key',
    tokenExpiryMins: 30,
    encryptionKey: 'some-strong-encryption-key'
};
 
// Create the authorization server
const authServer = new AuthorizationServer(options);

Generating an Access Token

Once we have the auth server, we can now start issuing access tokens.

The payload for requesting access tokens from the server should implement the AuthPayloadI interface.

This is a json object that specifies the grant type, client (ClientEntityI) and a user (UserEntityI).

The payload would most likely be received through the request (req.body) object if you're using a framework like express.

// A given request payload
const payload: AuthPayloadI = {
    client: ClientEntityI,
    grant_type: 'password', // For password grant type
    user: UserEntityI
};

 
try{
    const accessToken = await authServer.getAccessToken(payload);
}catch(e){
    console.error(e);
}

The access token returned is an instance of TokenResponseEntityI.

Resource Server

Once you have successfully generated access tokens to your application clients, the next phase is to authenticate requests that present tokens. This is usually requests to protected resources.

Authenticate access token

A resource server is used to validate access tokens. The code snippet below illustrates how a request with an access token is validated. This could be a middleware (if you're using a framework such as express).

import { ResourceServer, AuthenticatedRequestI } from 'omnile-oauth2';
 
// Setup resource server
const resourceServer = new ResourceServer();
resourceServer.setPublicKey('path/to/public-key.key');
 
// Auth request payload (For instance req.body in express)
const request: AuthenticatedRequestI = {
    access_token: 'access-token-generated'   
};
 
try{
    const decoded = await resourceServer.validateAuthenticatedRequest(request);
}catch (e){
    console.error(e);
}

The decoded data is an implementation of JwtTokenI.