@feathersjs/authentication-client 5.0.0-pre.10

package/src/core.ts

@@ -0,0 +1,200 @@
+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);
+  }
+}
+
+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;
+
+    return [ value, regex ];
+  }
+
+  return [ null, regex ];
+};
+
+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;
+}
+
+export class AuthenticationClient {
+  app: Application;
+  authenticated: boolean;
+  options: AuthenticationClientOptions;
+
+  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);
+
+    if (socket) {
+      this.handleSocket(socket);
+    }
+  }
+
+  get service () {
+    return this.app.service(this.options.path);
+  }
+
+  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);
+    });
+  }
+
+  getFromLocation (location: Location) {
+    const [ accessToken, tokenRegex ] = getMatch(location, this.options.locationKey);
+
+    if (accessToken !== null) {
+      location.hash = location.hash.replace(tokenRegex, '');
+
+      return Promise.resolve(accessToken);
+    }
+
+    const [ message, errorRegex ] = getMatch(location, this.options.locationErrorKey);
+
+    if (message !== null) {
+      location.hash = location.hash.replace(errorRegex, '');
+
+      return Promise.reject(new OauthError(decodeURIComponent(message)));
+    }
+
+    return Promise.resolve(null);
+  }
+
+  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;
+      });
+  }
+
+  removeAccessToken () {
+    return this.storage.removeItem(this.options.storageKey);
+  }
+
+  reset () {
+    this.app.set('authentication', null);
+    this.authenticated = false;
+
+    return Promise.resolve(null);
+  }
+
+  handleError (error: FeathersError, type: 'authenticate'|'logout') {
+    if (error.code === 401 || error.code === 403) {
+      const promise = this.removeAccessToken().then(() => this.reset());
+
+      return type === 'logout' ? promise : promise.then(() => Promise.reject(error));
+    }
+
+    return Promise.reject(error);
+  }
+
+  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');
+
+    if (!authPromise || force === true) {
+      return this.getAccessToken().then(accessToken => {
+        if (!accessToken) {
+          throw new NotAuthenticated('No accessToken found in storage');
+        }
+
+        return this.authenticate({
+          strategy: strategy || this.options.jwtStrategy,
+          accessToken
+        });
+      });
+    }
+
+    return authPromise;
+  }
+
+  authenticate (authentication?: AuthenticationRequest, params?: Params): Promise<AuthenticationResult> {
+    if (!authentication) {
+      return this.reAuthenticate();
+    }
+
+    const promise = this.service.create(authentication, params)
+      .then((authResult: AuthenticationResult) => {
+        const { accessToken } = 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')
+      );
+
+    this.app.set('authentication', promise);
+
+    return promise;
+  }
+
+  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')
+      );
+  }
+}

package/src/hooks/authentication.ts

@@ -0,0 +1,18 @@
+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;
+
+    if (stripSlashes(service.options.path) === path && method === 'create') {
+      return next();
+    }
+
+    return Promise.resolve(app.get('authentication')).then(authResult => {
+      if (authResult) {
+        context.params = Object.assign({}, authResult, params);
+      }
+    }).then(next);
+  };
+};

package/src/hooks/index.ts

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

package/src/hooks/populate-header.ts

@@ -0,0 +1,20 @@
+import { HookContext, NextFunction } from '@feathersjs/feathers';
+
+export const populateHeader = () => {
+  return (context: HookContext, next: NextFunction) => {
+    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}`;
+
+      context.params.headers = Object.assign({}, {
+        [header]: authHeader
+      }, context.params.headers);
+    }
+
+    return next();
+  };
+};

package/src/index.ts

@@ -0,0 +1,66 @@
+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'];
+  }
+}
+
+export const getDefaultStorage = () => {
+  try {
+    return new StorageWrapper(window.localStorage);
+  } catch (error: any) {}
+
+  return new MemoryStorage();
+};
+
+export { AuthenticationClient, AuthenticationClientOptions, Storage, MemoryStorage, hooks };
+
+export type ClientConstructor = new (app: Application, options: AuthenticationClientOptions) => AuthenticationClient;
+
+export const defaultStorage: Storage = getDefaultStorage();
+
+export const defaults: AuthenticationClientOptions = {
+  header: 'Authorization',
+  scheme: 'Bearer',
+  storageKey: 'feathers-jwt',
+  locationKey: 'access_token',
+  locationErrorKey: 'error',
+  jwtStrategy: 'jwt',
+  path: '/authentication',
+  Authentication: AuthenticationClient,
+  storage: defaultStorage
+};
+
+const init = (_options: Partial<AuthenticationClientOptions> = {}) => {
+  const options: AuthenticationClientOptions = Object.assign({}, defaults, _options);
+  const { Authentication } = options;
+
+  return (app: Application) => {
+    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.hooks([
+      hooks.authentication(),
+      hooks.populateHeader()
+    ]);
+  };
+};
+
+export default init;
+
+if (typeof module !== 'undefined') {
+  module.exports = Object.assign(init, module.exports);
+}

package/src/storage.ts

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