@feathersjs/authentication-client 5.0.0-pre.9 → 5.0.0

package/src/core.ts

@@ -1,200 +1,244 @@
-import { NotAuthenticated, FeathersError } from '@feathersjs/errors';
-import { Application, Params } from '@feathersjs/feathers';
-import { AuthenticationRequest, AuthenticationResult } from '@feathersjs/authentication';
-import { Storage, StorageWrapper } from './storage';
+import { NotAuthenticated, FeathersError } from '@feathersjs/errors'
+import { Application, Params } from '@feathersjs/feathers'
+import { AuthenticationRequest, AuthenticationResult } from '@feathersjs/authentication'
+import { Storage, StorageWrapper } from './storage'
 
 class OauthError extends FeathersError {
-  constructor (message: string, data?: any) {
-    super(message, 'OauthError', 401, 'oauth-error', data);
+  constructor(message: string, data?: any) {
+    super(message, 'OauthError', 401, 'oauth-error', data)
   }
 }
 
-const getMatch = (location: Location, key: string): [ string, RegExp ] => {
-  const regex = new RegExp(`(?:\&?)${key}=([^&]*)`);
-  const match = location.hash ? location.hash.match(regex) : null;
+const getMatch = (location: Location, key: string): [string, RegExp] => {
+  const regex = new RegExp(`(?:\&?)${key}=([^&]*)`)
+  const match = location.hash ? location.hash.match(regex) : null
 
   if (match !== null) {
-    const [ , value ] = match;
+    const [, value] = match
 
-    return [ value, regex ];
+    return [value, regex]
   }
 
-  return [ null, regex ];
-};
+  return [null, regex]
+}
 
-export type ClientConstructor = new (app: Application, options: AuthenticationClientOptions)
-  => AuthenticationClient;
+export type ClientConstructor = new (
+  app: Application,
+  options: AuthenticationClientOptions
+) => AuthenticationClient
 
 export interface AuthenticationClientOptions {
-  storage: Storage;
-  header: string;
-  scheme: string;
-  storageKey: string;
-  locationKey: string;
-  locationErrorKey: string;
-  jwtStrategy: string;
-  path: string;
-  Authentication: ClientConstructor;
+  storage: Storage
+  header: string
+  scheme: string
+  storageKey: string
+  locationKey: string
+  locationErrorKey: string
+  jwtStrategy: string
+  path: string
+  Authentication: ClientConstructor
 }
 
 export class AuthenticationClient {
-  app: Application;
-  authenticated: boolean;
-  options: AuthenticationClientOptions;
+  app: Application
+  authenticated: boolean
+  options: AuthenticationClientOptions
 
-  constructor (app: Application, options: AuthenticationClientOptions) {
-    const socket = app.io;
-    const storage = new StorageWrapper(app.get('storage') || options.storage);
+  constructor(app: Application, options: AuthenticationClientOptions) {
+    const socket = app.io
+    const storage = new StorageWrapper(app.get('storage') || options.storage)
 
-    this.app = app;
-    this.options = options;
-    this.authenticated = false;
-    this.app.set('storage', storage);
+    this.app = app
+    this.options = options
+    this.authenticated = false
+    this.app.set('storage', storage)
 
     if (socket) {
-      this.handleSocket(socket);
+      this.handleSocket(socket)
     }
   }
 
-  get service () {
-    return this.app.service(this.options.path);
+  get service() {
+    return this.app.service(this.options.path)
   }
 
-  get storage () {
-    return this.app.get('storage') as Storage;
+  get storage() {
+    return this.app.get('storage') as Storage
   }
 
-  handleSocket (socket: any) {
-    // Connection events happen on every reconnect
-    const connected = this.app.io ? 'connect' : 'open';
-    const disconnected = this.app.io ? 'disconnect' : 'disconnection';
-
-    socket.on(disconnected, () => {
-      const authPromise = new Promise(resolve =>
-        socket.once(connected, (data: any) => resolve(data))
-      )
-      // Only reconnect when `reAuthenticate()` or `authenticate()`
-      // has been called explicitly first
-      // Force reauthentication with the server
-      .then(() => this.authenticated ? this.reAuthenticate(true) : null);
-
-      this.app.set('authentication', authPromise);
-    });
+  handleSocket(socket: any) {
+    // When the socket disconnects and we are still authenticated, try to reauthenticate right away
+    // the websocket connection will handle timeouts and retries
+    socket.on('disconnect', () => {
+      if (this.authenticated) {
+        this.reAuthenticate(true)
+      }
+    })
   }
 
-  getFromLocation (location: Location) {
-    const [ accessToken, tokenRegex ] = getMatch(location, this.options.locationKey);
+  /**
+   * Parse the access token or authentication error from the window location hash. Will remove it from the hash
+   * if found.
+   *
+   * @param location The window location
+   * @returns The access token if available, will throw an error if found, otherwise null
+   */
+  getFromLocation(location: Location) {
+    const [accessToken, tokenRegex] = getMatch(location, this.options.locationKey)
 
     if (accessToken !== null) {
-      location.hash = location.hash.replace(tokenRegex, '');
+      location.hash = location.hash.replace(tokenRegex, '')
 
-      return Promise.resolve(accessToken);
+      return Promise.resolve(accessToken)
     }
 
-    const [ message, errorRegex ] = getMatch(location, this.options.locationErrorKey);
+    const [message, errorRegex] = getMatch(location, this.options.locationErrorKey)
 
     if (message !== null) {
-      location.hash = location.hash.replace(errorRegex, '');
+      location.hash = location.hash.replace(errorRegex, '')
 
-      return Promise.reject(new OauthError(decodeURIComponent(message)));
+      return Promise.reject(new OauthError(decodeURIComponent(message)))
     }
 
-    return Promise.resolve(null);
+    return Promise.resolve(null)
   }
 
-  setAccessToken (accessToken: string) {
-    return this.storage.setItem(this.options.storageKey, accessToken);
+  /**
+   * Set the access token in storage.
+   *
+   * @param accessToken The access token to set
+   * @returns
+   */
+  setAccessToken(accessToken: string) {
+    return this.storage.setItem(this.options.storageKey, accessToken)
   }
 
-  getAccessToken (): Promise<string|null> {
-    return this.storage.getItem(this.options.storageKey)
-      .then((accessToken: string) => {
-        if (!accessToken && typeof window !== 'undefined' && window.location) {
-          return this.getFromLocation(window.location);
-        }
-
-        return accessToken || null;
-      });
+  /**
+   * Returns the access token from storage or the window location hash.
+   *
+   * @returns The access token from storage or location hash
+   */
+  getAccessToken(): Promise<string | null> {
+    return this.storage.getItem(this.options.storageKey).then((accessToken: string) => {
+      if (!accessToken && typeof window !== 'undefined' && window.location) {
+        return this.getFromLocation(window.location)
+      }
+
+      return accessToken || null
+    })
   }
 
-  removeAccessToken () {
-    return this.storage.removeItem(this.options.storageKey);
+  /**
+   * Remove the access token from storage
+   * @returns The removed access token
+   */
+  removeAccessToken() {
+    return this.storage.removeItem(this.options.storageKey)
   }
 
-  reset () {
-    this.app.set('authentication', null);
-    this.authenticated = false;
+  /**
+   * Reset the internal authentication state. Usually not necessary to call directly.
+   *
+   * @returns null
+   */
+  reset() {
+    this.app.set('authentication', null)
+    this.authenticated = false
 
-    return Promise.resolve(null);
+    return Promise.resolve(null)
   }
 
-  handleError (error: FeathersError, type: 'authenticate'|'logout') {
-    if (error.code === 401 || error.code === 403) {
-      const promise = this.removeAccessToken().then(() => this.reset());
+  handleError(error: FeathersError, type: 'authenticate' | 'logout') {
+    // For NotAuthenticated, PaymentError, Forbidden, NotFound, MethodNotAllowed, NotAcceptable
+    // errors, remove the access token
+    if (error.code > 400 && error.code < 408) {
+      const promise = this.removeAccessToken().then(() => this.reset())
 
-      return type === 'logout' ? promise : promise.then(() => Promise.reject(error));
+      return type === 'logout' ? promise : promise.then(() => Promise.reject(error))
     }
 
-    return Promise.reject(error);
+    return this.reset().then(() => Promise.reject(error))
   }
 
-  reAuthenticate (force = false, strategy?: string): Promise<AuthenticationResult> {
+  /**
+   * Try to reauthenticate using the token from storage. Will do nothing if already authenticated unless
+   * `force` is true.
+   *
+   * @param force force reauthentication with the server
+   * @param strategy The name of the strategy to use. Defaults to `options.jwtStrategy`
+   * @returns The reauthentication result
+   */
+  reAuthenticate(force = false, strategy?: string): Promise<AuthenticationResult> {
     // Either returns the authentication state or
     // tries to re-authenticate with the stored JWT and strategy
-    const authPromise = this.app.get('authentication');
+    let authPromise = this.app.get('authentication')
 
     if (!authPromise || force === true) {
-      return this.getAccessToken().then(accessToken => {
+      authPromise = this.getAccessToken().then((accessToken) => {
         if (!accessToken) {
-          throw new NotAuthenticated('No accessToken found in storage');
+          return this.handleError(new NotAuthenticated('No accessToken found in storage'), 'authenticate')
         }
 
         return this.authenticate({
           strategy: strategy || this.options.jwtStrategy,
           accessToken
-        });
-      });
+        })
+      })
+      this.app.set('authentication', authPromise)
     }
 
-    return authPromise;
+    return authPromise
   }
 
-  authenticate (authentication?: AuthenticationRequest, params?: Params): Promise<AuthenticationResult> {
+  /**
+   * Authenticate using a specific strategy and data.
+   *
+   * @param authentication The authentication data
+   * @param params Additional parameters
+   * @returns The authentication result
+   */
+  authenticate(authentication?: AuthenticationRequest, params?: Params): Promise<AuthenticationResult> {
     if (!authentication) {
-      return this.reAuthenticate();
+      return this.reAuthenticate()
     }
 
-    const promise = this.service.create(authentication, params)
+    const promise = this.service
+      .create(authentication, params)
       .then((authResult: AuthenticationResult) => {
-        const { accessToken } = authResult;
+        const { accessToken } = authResult
 
-        this.authenticated = true;
-        this.app.emit('login', authResult);
-        this.app.emit('authenticated', authResult);
+        this.authenticated = true
+        this.app.emit('login', authResult)
+        this.app.emit('authenticated', authResult)
 
-        return this.setAccessToken(accessToken).then(() => authResult);
-      }).catch((error: FeathersError) =>
-        this.handleError(error, 'authenticate')
-      );
+        return this.setAccessToken(accessToken).then(() => authResult)
+      })
+      .catch((error: FeathersError) => this.handleError(error, 'authenticate'))
 
-    this.app.set('authentication', promise);
+    this.app.set('authentication', promise)
 
-    return promise;
+    return promise
   }
 
-  logout (): Promise<AuthenticationResult | null> {
+  /**
+   * Log out the current user and remove their token. Will do nothing
+   * if not authenticated.
+   *
+   * @returns The log out result.
+   */
+  logout(): Promise<AuthenticationResult | null> {
     return Promise.resolve(this.app.get('authentication'))
-      .then(() => this.service.remove(null)
-      .then((authResult: AuthenticationResult) => this.removeAccessToken()
-        .then(() => this.reset())
-        .then(() => {
-          this.app.emit('logout', authResult);
-
-          return authResult;
-        })
-      ))
-      .catch((error: FeathersError) =>
-        this.handleError(error, 'logout')
-      );
+      .then(() =>
+        this.service.remove(null).then((authResult: AuthenticationResult) =>
+          this.removeAccessToken()
+            .then(() => this.reset())
+            .then(() => {
+              this.app.emit('logout', authResult)
+
+              return authResult
+            })
+        )
+      )
+      .catch((error: FeathersError) => this.handleError(error, 'logout'))
   }
 }

package/src/hooks/authentication.ts

@@ -1,18 +1,26 @@
-import { HookContext, NextFunction } from '@feathersjs/feathers';
-import { stripSlashes } from '@feathersjs/commons';
+import { HookContext, NextFunction } from '@feathersjs/feathers'
+import { stripSlashes } from '@feathersjs/commons'
 
 export const authentication = () => {
   return (context: HookContext, next: NextFunction) => {
-    const { app, params, path, method, app: { authentication: service } } = context;
+    const {
+      app,
+      params,
+      path,
+      method,
+      app: { authentication: service }
+    } = context
 
     if (stripSlashes(service.options.path) === path && method === 'create') {
-      return next();
+      return next()
     }
 
-    return Promise.resolve(app.get('authentication')).then(authResult => {
-      if (authResult) {
-        context.params = Object.assign({}, authResult, params);
-      }
-    }).then(next);
-  };
-};
+    return Promise.resolve(app.get('authentication'))
+      .then((authResult) => {
+        if (authResult) {
+          context.params = Object.assign({}, authResult, params)
+        }
+      })
+      .then(next)
+  }
+}

package/src/hooks/index.ts

@@ -1,2 +1,2 @@
-export { authentication } from './authentication';
-export { populateHeader } from './populate-header';
+export { authentication } from './authentication'
+export { populateHeader } from './populate-header'

package/src/hooks/populate-header.ts

@@ -1,20 +1,27 @@
-import { HookContext, NextFunction } from '@feathersjs/feathers';
+import { HookContext, NextFunction } from '@feathersjs/feathers'
 
 export const populateHeader = () => {
   return (context: HookContext, next: NextFunction) => {
-    const { app, params: { accessToken } } = context;
-    const authentication = app.authentication;
+    const {
+      app,
+      params: { accessToken }
+    } = context
+    const authentication = app.authentication
 
     // Set REST header if necessary
     if (app.rest && accessToken) {
-      const { scheme, header } = authentication.options;
-      const authHeader = `${scheme} ${accessToken}`;
+      const { scheme, header } = authentication.options
+      const authHeader = `${scheme} ${accessToken}`
 
-      context.params.headers = Object.assign({}, {
-        [header]: authHeader
-      }, context.params.headers);
+      context.params.headers = Object.assign(
+        {},
+        {
+          [header]: authHeader
+        },
+        context.params.headers
+      )
     }
 
-    return next();
-  };
-};
+    return next()
+  }
+}

package/src/index.ts

@@ -1,32 +1,37 @@
-import { AuthenticationClient, AuthenticationClientOptions } from './core';
-import * as hooks from './hooks';
-import { Application } from '@feathersjs/feathers';
-import { Storage, MemoryStorage, StorageWrapper } from './storage';
+import { AuthenticationClient, AuthenticationClientOptions } from './core'
+import * as hooks from './hooks'
+import { Application } from '@feathersjs/feathers'
+import { Storage, MemoryStorage, StorageWrapper } from './storage'
 
 declare module '@feathersjs/feathers/lib/declarations' {
-  interface Application<ServiceTypes, AppSettings> { // eslint-disable-line
-    io?: any;
-    rest?: any;
-    authentication: AuthenticationClient;
-    authenticate: AuthenticationClient['authenticate'];
-    reAuthenticate: AuthenticationClient['reAuthenticate'];
-    logout: AuthenticationClient['logout'];
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface Application<Services, Settings> {
+    // eslint-disable-line
+    io: any
+    rest?: any
+    authentication: AuthenticationClient
+    authenticate: AuthenticationClient['authenticate']
+    reAuthenticate: AuthenticationClient['reAuthenticate']
+    logout: AuthenticationClient['logout']
   }
 }
 
 export const getDefaultStorage = () => {
   try {
-    return new StorageWrapper(window.localStorage);
-  } catch (error) {}
+    return new StorageWrapper(window.localStorage)
+  } catch (error: any) {}
 
-  return new MemoryStorage();
-};
+  return new MemoryStorage()
+}
 
-export { AuthenticationClient, AuthenticationClientOptions, Storage, MemoryStorage, hooks };
+export { AuthenticationClient, AuthenticationClientOptions, Storage, MemoryStorage, hooks }
 
-export type ClientConstructor = new (app: Application, options: AuthenticationClientOptions) => AuthenticationClient;
+export type ClientConstructor = new (
+  app: Application,
+  options: AuthenticationClientOptions
+) => AuthenticationClient
 
-export const defaultStorage: Storage = getDefaultStorage();
+export const defaultStorage: Storage = getDefaultStorage()
 
 export const defaults: AuthenticationClientOptions = {
   header: 'Authorization',
@@ -38,29 +43,26 @@ export const defaults: AuthenticationClientOptions = {
   path: '/authentication',
   Authentication: AuthenticationClient,
   storage: defaultStorage
-};
+}
 
 const init = (_options: Partial<AuthenticationClientOptions> = {}) => {
-  const options: AuthenticationClientOptions = Object.assign({}, defaults, _options);
-  const { Authentication } = options;
+  const options: AuthenticationClientOptions = Object.assign({}, defaults, _options)
+  const { Authentication } = options
 
   return (app: Application) => {
-    const authentication = new Authentication(app, options);
+    const authentication = new Authentication(app, options)
 
-    app.authentication = authentication;
-    app.authenticate = authentication.authenticate.bind(authentication);
-    app.reAuthenticate = authentication.reAuthenticate.bind(authentication);
-    app.logout = authentication.logout.bind(authentication);
+    app.authentication = authentication
+    app.authenticate = authentication.authenticate.bind(authentication)
+    app.reAuthenticate = authentication.reAuthenticate.bind(authentication)
+    app.logout = authentication.logout.bind(authentication)
 
-    app.hooks([
-      hooks.authentication(),
-      hooks.populateHeader()
-    ]);
-  };
-};
+    app.hooks([hooks.authentication(), hooks.populateHeader()])
+  }
+}
 
-export default init;
+export default init
 
 if (typeof module !== 'undefined') {
-  module.exports = Object.assign(init, module.exports);
+  module.exports = Object.assign(init, module.exports)
 }

package/src/storage.ts

@@ -1,49 +1,49 @@
 export interface Storage {
-  getItem (key: string): any;
-  setItem? (key: string, value: any): any;
-  removeItem? (key: string): any;
+  getItem(key: string): any
+  setItem?(key: string, value: any): any
+  removeItem?(key: string): any
 }
 
 export class MemoryStorage implements Storage {
-  store: { [key: string]: any };
+  store: { [key: string]: any }
 
-  constructor () {
-    this.store = {};
+  constructor() {
+    this.store = {}
   }
 
-  getItem (key: string) {
-    return Promise.resolve(this.store[key]);
+  getItem(key: string) {
+    return Promise.resolve(this.store[key])
   }
 
-  setItem (key: string, value: any) {
-    return Promise.resolve(this.store[key] = value);
+  setItem(key: string, value: any) {
+    return Promise.resolve((this.store[key] = value))
   }
 
-  removeItem (key: string) {
-    const value = this.store[key];
+  removeItem(key: string) {
+    const value = this.store[key]
 
-    delete this.store[key];
+    delete this.store[key]
 
-    return Promise.resolve(value);
+    return Promise.resolve(value)
   }
 }
 
 export class StorageWrapper implements Storage {
-  storage: any;
+  storage: any
 
-  constructor (storage: any) {
-    this.storage = storage;
+  constructor(storage: any) {
+    this.storage = storage
   }
 
-  getItem (key: string) {
-    return Promise.resolve(this.storage.getItem(key));
+  getItem(key: string) {
+    return Promise.resolve(this.storage.getItem(key))
   }
 
-  setItem (key: string, value: any) {
-    return Promise.resolve(this.storage.setItem(key, value));
+  setItem(key: string, value: any) {
+    return Promise.resolve(this.storage.setItem(key, value))
   }
 
-  removeItem (key: string) {
-    return Promise.resolve(this.storage.removeItem(key));
+  removeItem(key: string) {
+    return Promise.resolve(this.storage.removeItem(key))
   }
 }