@feathersjs/authentication 5.0.0-pre.2 → 5.0.0-pre.20

package/src/hooks/authenticate.ts

@@ -1,14 +1,14 @@
 import flatten from 'lodash/flatten';
 import omit from 'lodash/omit';
-import { HookContext } from '@feathersjs/feathers';
+import { HookContext, NextFunction } from '@feathersjs/feathers';
 import { NotAuthenticated } from '@feathersjs/errors';
-import Debug from 'debug';
+import { createDebug } from '@feathersjs/commons';
 
-const debug = Debug('@feathersjs/authentication/hooks/authenticate');
+const debug = createDebug('@feathersjs/authentication/hooks/authenticate');
 
 export interface AuthenticateHookSettings {
   service?: string;
-  strategies: string[];
+  strategies?: string[];
 }
 
 export default (originalSettings: string | AuthenticateHookSettings, ...originalStrategies: string[]) => {
@@ -20,7 +20,8 @@ export default (originalSettings: string | AuthenticateHookSettings, ...original
     throw new Error('The authenticate hook needs at least one allowed strategy');
   }
 
-  return async (context: HookContext<any, any>) => {
+  return async (context: HookContext, _next?: NextFunction) => {
+    const next = typeof _next === 'function' ? _next : async () => context;
     const { app, params, type, path, service } = context;
     const { strategies } = settings;
     const { provider, authentication } = params;
@@ -42,7 +43,7 @@ export default (originalSettings: string | AuthenticateHookSettings, ...original
     }
 
     if (params.authenticated === true) {
-      return context;
+      return next();
     }
 
     if (authentication) {
@@ -53,12 +54,10 @@ export default (originalSettings: string | AuthenticateHookSettings, ...original
       const authResult = await authService.authenticate(authentication, authParams, ...strategies);
 
       context.params = Object.assign({}, params, omit(authResult, 'accessToken'), { authenticated: true });
-
-      return context;
     } else if (provider) {
       throw new NotAuthenticated('Not authenticated');
     }
 
-    return context;
+    return next();
   };
 };

package/src/hooks/connection.ts

@@ -1,19 +1,17 @@
-import { HookContext } from '@feathersjs/feathers';
+import { HookContext, NextFunction } from '@feathersjs/feathers';
 import omit from 'lodash/omit';
 import { AuthenticationBase, ConnectionEvent } from '../core';
 
-export default (event: ConnectionEvent) => async (context: HookContext) => {
-  const { result, params: { connection } } = context;
-
-  if (!connection) {
-    return context;
-  }
+export default (event: ConnectionEvent) => async (context: HookContext, next: NextFunction) => {
+  await next();
 
-  const service = context.service as unknown as AuthenticationBase;
+  const { result, params: { connection } } = context;
 
-  Object.assign(connection, omit(result, 'accessToken', 'authentication'));
+  if (connection) {
+    const service = context.service as unknown as AuthenticationBase;
 
-  await service.handleConnection(event, connection, result);
+    Object.assign(connection, omit(result, 'accessToken', 'authentication'));
 
-  return context;
+    await service.handleConnection(event, connection, result);
+  }
 };

package/src/hooks/event.ts

@@ -1,16 +1,16 @@
-import Debug from 'debug';
-import { HookContext } from '@feathersjs/feathers';
+import { HookContext, NextFunction } from '@feathersjs/feathers';
+import { createDebug } from '@feathersjs/commons';
 import { ConnectionEvent } from '../core';
 
-const debug = Debug('@feathersjs/authentication/hooks/connection');
+const debug = createDebug('@feathersjs/authentication/hooks/connection');
+
+export default (event: ConnectionEvent) => async (context: HookContext, next: NextFunction) => {
+  await next();
 
-export default (event: ConnectionEvent) => async (context: HookContext) => {
   const { app, result, params } = context;
 
   if (params.provider && result) {
     debug(`Sending authentication event '${event}'`);
     app.emit(event, result, params, context);
   }
-
-  return context;
 };

package/src/index.ts

@@ -1,16 +1,14 @@
-import * as hooks from './hooks';
-
-const { authenticate } = hooks;
-
-export { hooks };
-export { authenticate };
+export * as hooks from './hooks';
+export { authenticate } from './hooks';
 export {
   AuthenticationBase,
   AuthenticationRequest,
   AuthenticationResult,
   AuthenticationStrategy,
+  AuthenticationParams,
   ConnectionEvent
 } from './core';
 export { AuthenticationBaseStrategy } from './strategy';
 export { AuthenticationService } from './service';
 export { JWTStrategy } from './jwt';
+export { authenticationSettingsSchema } from './options';

package/src/jwt.ts

@@ -1,16 +1,16 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import Debug from 'debug';
 import omit from 'lodash/omit';
 import { IncomingMessage } from 'http';
 import { NotAuthenticated } from '@feathersjs/errors';
 import { Params } from '@feathersjs/feathers';
+import { createDebug } from '@feathersjs/commons';
 // @ts-ignore
 import lt from 'long-timeout';
 
 import { AuthenticationBaseStrategy } from './strategy';
-import { AuthenticationRequest, AuthenticationResult, ConnectionEvent } from './core';
+import { AuthenticationParams, AuthenticationRequest, AuthenticationResult, ConnectionEvent } from './core';
 
-const debug = Debug('@feathersjs/authentication/jwt');
+const debug = createDebug('@feathersjs/authentication/jwt');
 const SPLIT_HEADER = /(\S+)\s+(\S+)/;
 
 export class JWTStrategy extends AuthenticationBaseStrategy {
@@ -116,7 +116,7 @@ export class JWTStrategy extends AuthenticationBaseStrategy {
     return authResult.authentication.payload.sub;
   }
 
-  async authenticate (authentication: AuthenticationRequest, params: Params) {
+  async authenticate (authentication: AuthenticationRequest, params: AuthenticationParams) {
     const { accessToken } = authentication;
     const { entity } = this.configuration;
 
@@ -147,7 +147,10 @@ export class JWTStrategy extends AuthenticationBaseStrategy {
     };
   }
 
-  async parse (req: IncomingMessage) {
+  async parse (req: IncomingMessage): Promise<{
+    strategy: string;
+    accessToken: string;
+  } | null> {
     const { header, schemes }: { header: string, schemes: string[] } = this.configuration;
     const headerValue = req.headers && req.headers[header.toLowerCase()];
 

package/src/options.ts

@@ -1,5 +1,5 @@
-export default {
-  authStrategies: [],
+export const defaultOptions = {
+  authStrategies: [] as string[],
   jwtOptions: {
     header: { typ: 'access' }, // by default is an access token but can be any type
     audience: 'https://yourdomain.com', // The resource server where the token is processed
@@ -8,3 +8,108 @@ export default {
     expiresIn: '1d'
   }
 };
+
+export const authenticationSettingsSchema = {
+  type: 'object',
+  required: ['secret', 'entity', 'authStrategies'],
+  properties: {
+    secret: {
+      type: 'string',
+      description: 'The JWT signing secret'
+    },
+    entity: {
+      oneOf: [{
+        type: 'null'
+      }, {
+        type: 'string'
+      }],
+      description: 'The name of the authentication entity (e.g. user)'
+    },
+    entityId: {
+      type: 'string',
+      description: 'The name of the authentication entity id property'
+    },
+    service: {
+      type: 'string',
+      description: 'The path of the entity service'
+    },
+    authStrategies: {
+      type: 'array',
+      items: { type: 'string' },
+      description: 'A list of authentication strategy names that are allowed to create JWT access tokens'
+    },
+    parseStrategies: {
+      type: 'array',
+      items: { type: 'string' },
+      description: 'A list of authentication strategy names that should parse HTTP headers for authentication information (defaults to `authStrategies`)'
+    },
+    jwtOptions: {
+      type: 'object'
+    },
+    jwt: {
+      type: 'object',
+      properties: {
+        header: {
+          type: 'string',
+          default: 'Authorization',
+          description: 'The HTTP header containing the JWT'
+        },
+        schemes: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'An array of schemes to support'
+        }
+      }
+    },
+    local: {
+      type: 'object',
+      required: ['usernameField', 'passwordField'],
+      properties: {
+        usernameField: {
+          type: 'string',
+          description: 'Name of the username field (e.g. `email`)'
+        },
+        passwordField: {
+          type: 'string',
+          description: 'Name of the password field (e.g. `password`)'
+        },
+        hashSize: {
+          type: 'number',
+          description: 'The BCrypt salt length'
+        },
+        errorMessage: {
+          type: 'string',
+          default: 'Invalid login',
+          description: 'The error message to return on errors'
+        },
+        entityUsernameField: {
+          type: 'string',
+          description: 'Name of the username field on the entity if authentication request data and entity field names are different'
+        },
+        entityPasswordField: {
+          type: 'string',
+          description: 'Name of the password field on the entity if authentication request data and entity field names are different'
+        }
+      }
+    },
+    oauth: {
+      type: 'object',
+      properties: {
+        redirect: {
+          type: 'string'
+        },
+        origins: {
+          type: 'array',
+          items: { type: 'string' }
+        },
+        defaults: {
+          type: 'object',
+          properties: {
+            key: { type: 'string' },
+            secret: { type: 'string' }
+          }
+        }
+      }
+    }
+  }
+} as const;

package/src/service.ts

@@ -1,16 +1,16 @@
-import Debug from 'debug';
 import merge from 'lodash/merge';
 import { NotAuthenticated } from '@feathersjs/errors';
-import { AuthenticationBase, AuthenticationResult, AuthenticationRequest } from './core';
+import { AuthenticationBase, AuthenticationResult, AuthenticationRequest, AuthenticationParams } from './core';
 import { connection, event } from './hooks';
 import '@feathersjs/transport-commons';
-import { Params, ServiceMethods, ServiceAddons } from '@feathersjs/feathers';
+import { createDebug } from '@feathersjs/commons';
+import { ServiceMethods, ServiceAddons } from '@feathersjs/feathers';
 import jsonwebtoken from 'jsonwebtoken';
 
-const debug = Debug('@feathersjs/authentication/service');
+const debug = createDebug('@feathersjs/authentication/service');
 
 declare module '@feathersjs/feathers/lib/declarations' {
-  interface FeathersApplication<ServiceTypes, AppSettings> { // eslint-disable-line
+  interface FeathersApplication<Services, Settings> { // eslint-disable-line
     /**
      * Returns the default authentication service or the
      * authentication service for a given path.
@@ -29,7 +29,7 @@ declare module '@feathersjs/feathers/lib/declarations' {
 // eslint-disable-next-line
 export interface AuthenticationService extends ServiceAddons<AuthenticationResult, AuthenticationResult> {}
 
-export class AuthenticationService extends AuthenticationBase implements Partial<ServiceMethods<AuthenticationResult>> {
+export class AuthenticationService extends AuthenticationBase implements Partial<ServiceMethods<AuthenticationResult, AuthenticationRequest, AuthenticationParams>> {
   constructor (app: any, configKey = 'authentication', options = {}) {
     super(app, configKey, options);
 
@@ -51,7 +51,7 @@ export class AuthenticationService extends AuthenticationBase implements Partial
    * @param _authResult The current authentication result
    * @param params The service call parameters
    */
-  async getPayload (_authResult: AuthenticationResult, params: Params) {
+  async getPayload (_authResult: AuthenticationResult, params: AuthenticationParams) {
     // Uses `params.payload` or returns an empty payload
     const { payload = {} } = params;
 
@@ -65,7 +65,7 @@ export class AuthenticationService extends AuthenticationBase implements Partial
    * @param authResult The authentication result
    * @param params Service call parameters
    */
-  async getTokenOptions (authResult: AuthenticationResult, params: Params) {
+  async getTokenOptions (authResult: AuthenticationResult, params: AuthenticationParams) {
     const { service, entity, entityId } = this.configuration;
     const jwtOptions = merge({}, params.jwtOptions, params.jwt);
     const value = service && entity && authResult[entity];
@@ -92,7 +92,7 @@ export class AuthenticationService extends AuthenticationBase implements Partial
    * @param data The authentication request (should include `strategy` key)
    * @param params Service call parameters
    */
-  async create (data: AuthenticationRequest, params?: Params) {
+  async create (data: AuthenticationRequest, params?: AuthenticationParams) {
     const authStrategies = params.authStrategies || this.configuration.authStrategies;
 
     if (!authStrategies.length) {
@@ -131,7 +131,7 @@ export class AuthenticationService extends AuthenticationBase implements Partial
    * @param id The JWT to remove or null
    * @param params Service call parameters
    */
-  async remove (id: string | null, params?: Params) {
+  async remove (id: string | null, params?: AuthenticationParams) {
     const { authentication } = params;
     const { authStrategies } = this.configuration;
 
@@ -149,6 +149,8 @@ export class AuthenticationService extends AuthenticationBase implements Partial
    * Validates the service configuration.
    */
   async setup () {
+    await super.setup();
+
     // The setup method checks for valid settings and registers the
     // connection and event (login, logout) hooks
     const { secret, service, entity, entityId } = this.configuration;
@@ -172,10 +174,8 @@ export class AuthenticationService extends AuthenticationBase implements Partial
     }
 
     (this as any).hooks({
-      after: {
-        create: [ connection('login'), event('login') ],
-        remove: [ connection('logout'), event('logout') ]
-      }
+      create: [ connection('login'), event('login') ],
+      remove: [ connection('logout'), event('logout') ]
     });
 
     this.app.on('disconnect', async (connection) => {

package/src/strategy.ts

@@ -22,7 +22,7 @@ export class AuthenticationBaseStrategy implements AuthenticationStrategy {
     return this.authentication.configuration[this.name];
   }
 
-  get entityService (): Service<any> {
+  get entityService (): Service {
     const { service } = this.configuration;
 
     if (!service) {