alp-node-auth 7.2.1 → 8.0.0

package/src/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import type { IncomingMessage } from 'http';
 import { promisify } from 'util';
 import type { Context } from 'alp-node';
@@ -18,8 +19,12 @@ import { AuthenticationService } from './services/authentification/Authenticatio
 import type { AllowedStrategyKeys } from './services/authentification/types';
 import UserAccountsService from './services/user/UserAccountsService';
 import type { AccountService } from './services/user/types';
-import { getTokenFromRequest, COOKIE_NAME } from './utils/cookies';
-import { createFindConnectedAndUser } from './utils/createFindConnectedAndUser';
+import {
+  getTokenFromRequest,
+  COOKIE_NAME_TOKEN,
+  COOKIE_NAME_STATE,
+} from './utils/cookies';
+import { createFindLoggedInUser } from './utils/createFindLoggedInUser';
 
 export { default as MongoUsersManager } from './MongoUsersManager';
 export { default as UserAccountGoogleService } from './services/user/UserAccountGoogleService';
@@ -31,22 +36,25 @@ export { STATUSES } from './services/user/UserAccountsService';
 declare module 'alp-types' {
   // eslint-disable-next-line @typescript-eslint/no-shadow
   interface ContextState {
-    connected: NonNullable<ContextState['user']>['_id'] | null | undefined;
-    user: User | null | undefined;
+    loggedInUserId:
+      | NonNullable<ContextState['loggedInUser']>['_id']
+      | null
+      | undefined;
+    loggedInUser: User | null | undefined;
   }
 
   interface ContextSanitizedState {
-    connected:
-      | NonNullable<ContextSanitizedState['user']>['_id']
+    loggedInUserId:
+      | NonNullable<ContextSanitizedState['loggedInUser']>['_id']
       | null
       | undefined;
-    user: UserSanitized | null | undefined;
+    loggedInUser: UserSanitized | null | undefined;
   }
 
   interface BaseContext {
-    setConnected: (
-      connected: NonNullable<ContextState['user']>['_id'],
-      user: NonNullable<ContextState['user']>,
+    setLoggedIn: (
+      loggedInUserId: NonNullable<ContextState['loggedInUserId']>,
+      loggedInUser: NonNullable<ContextState['loggedInUser']>,
     ) => Promise<void>;
     logout: () => void;
   }
@@ -102,21 +110,21 @@ export default function init<
       authHooks,
     });
 
-    app.context.setConnected = async function (
+    app.context.setLoggedIn = async function (
       this: Context,
-      connected: NonNullable<ContextState['user']>['_id'],
-      user: NonNullable<ContextState['user']>,
+      loggedInUserId: NonNullable<ContextState['loggedInUser']>['_id'],
+      loggedInUser: NonNullable<ContextState['loggedInUser']>,
     ): Promise<void> {
-      logger.debug('setConnected', { connected });
-      if (!connected) {
-        throw new Error('Illegal value for setConnected');
+      logger.debug('setLoggedIn', { loggedInUser });
+      if (!loggedInUserId) {
+        throw new Error('Illegal value for setLoggedIn');
       }
 
-      this.state.connected = connected;
-      this.state.user = user;
+      this.state.loggedInUserId = loggedInUserId;
+      this.state.loggedInUser = loggedInUser;
 
       const token = await signPromisified(
-        { connected, time: Date.now() },
+        { loggedInUserId, time: Date.now() },
         this.config
           .get<Map<string, unknown>>('authentication')
           .get('secretKey'),
@@ -127,20 +135,36 @@ export default function init<
         },
       );
 
+      const calcExpiresTime = (): number => {
+        const date = new Date();
+        date.setDate(date.getDate() + 30);
+        return date.getTime();
+      };
+
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      this.cookies.set(COOKIE_NAME, token, {
+      this.cookies.set(COOKIE_NAME_TOKEN, token, {
         httpOnly: true,
         secure: this.config.get('allowHttps'),
       });
+
+      this.cookies.set(
+        COOKIE_NAME_STATE,
+        JSON.stringify({ loggedInUserId, expiresIn: calcExpiresTime() }),
+        {
+          httpOnly: false,
+          secure: this.config.get('allowHttps'),
+        },
+      );
     };
 
     app.context.logout = function (this: Context): void {
-      delete this.state.connected;
-      delete this.state.user;
-      this.cookies.set(COOKIE_NAME, '', { expires: new Date(1) });
+      delete this.state.loggedInUserId;
+      delete this.state.loggedInUser;
+      this.cookies.set(COOKIE_NAME_TOKEN, '', { expires: new Date(1) });
+      this.cookies.set(COOKIE_NAME_STATE, '', { expires: new Date(1) });
     };
 
-    const getConnectedAndUser = createFindConnectedAndUser(
+    const findLoggedInUser = createFindLoggedInUser(
       app.config
         .get<Map<string, unknown>>('authentication')
         .get('secretKey') as string,
@@ -150,49 +174,51 @@ export default function init<
 
     return {
       routes: createRoutes(controller),
-
-      getConnectedAndUserFromRequest: (
+      findLoggedInUserFromRequest: (
         req: IncomingMessage,
-      ): ReturnType<typeof getConnectedAndUser> => {
+      ): ReturnType<typeof findLoggedInUser> => {
         const token = getTokenFromRequest(req);
-        return getConnectedAndUser(
+        return findLoggedInUser(
           jwtAudience || req.headers['user-agent'],
           token,
         );
       },
-      getConnectedAndUser,
-
+      findLoggedInUser,
       middleware: async <T>(
         ctx: Context,
         next: () => T | Promise<T>,
       ): Promise<T> => {
-        const token = ctx.cookies.get(COOKIE_NAME);
+        const token = ctx.cookies.get(COOKIE_NAME_TOKEN);
         const userAgent = ctx.request.headers['user-agent'];
         logger.debug('middleware', { token });
 
         const setState = (
-          connected: U['_id'] | null | undefined,
-          user: U | null | undefined,
+          loggedInUserId: U['_id'] | null | undefined,
+          loggedInUser: U | null | undefined,
         ): void => {
-          ctx.state.connected = connected;
-          ctx.state.user = user;
-          ctx.sanitizedState.connected = connected;
-          ctx.sanitizedState.user = user && usersManager.sanitize(user);
+          ctx.state.loggedInUserId = loggedInUserId;
+          ctx.state.user = loggedInUser;
+          ctx.sanitizedState.loggedInUserId = loggedInUserId;
+          ctx.sanitizedState.loggedInUser =
+            loggedInUser && usersManager.sanitize(loggedInUser);
         };
 
-        const [connected, user] = await getConnectedAndUser(
+        const [loggedInUserId, loggedInUser] = await findLoggedInUser(
           jwtAudience || userAgent,
           token,
         );
-        logger.debug('middleware', { connected });
+        logger.debug('middleware', { loggedInUserId });
 
-        if (connected == null || user == null) {
-          if (token) ctx.cookies.set(COOKIE_NAME, '', { expires: new Date(1) });
+        if (loggedInUserId == null || loggedInUser == null) {
+          if (token) {
+            ctx.cookies.set(COOKIE_NAME_TOKEN, '', { expires: new Date(1) });
+            ctx.cookies.set(COOKIE_NAME_STATE, '', { expires: new Date(1) });
+          }
           setState(null, null);
           return next();
         }
 
-        setState(connected, user);
+        setState(loggedInUserId, loggedInUser);
         return next();
       },
     };

package/src/services/authentification/AuthenticationService.ts

@@ -46,7 +46,7 @@ export type Strategies<StrategyKeys extends AllowedStrategyKeys> = Record<
 export interface AccessResponseHooks<StrategyKeys, U extends User = User> {
   afterLoginSuccess?: <StrategyKey extends StrategyKeys>(
     strategy: StrategyKey,
-    connectedUser: U,
+    loggedInUser: U,
   ) => void | Promise<void>;
 
   afterScopeUpdate?: <StrategyKey extends StrategyKeys>(
@@ -223,9 +223,9 @@ export class AuthenticationService<
   }
 
   async accessResponse<StrategyKey extends StrategyKeys>(
-    ctx: any,
+    ctx: Context,
     strategy: StrategyKey,
-    isConnected: undefined | boolean,
+    isLoggedIn: boolean,
     hooks: AccessResponseHooks<StrategyKeys, U>,
   ): Promise<U> {
     if (ctx.query.error) {
@@ -250,7 +250,7 @@ export class AuthenticationService<
     }
 
     if (!cookie.isLoginAccess) {
-      if (!isConnected) {
+      if (!isLoggedIn) {
         throw new Error('You are not connected');
       }
     }
@@ -275,9 +275,9 @@ export class AuthenticationService<
       return user;
     }
 
-    const connectedUser = ctx.state.user;
+    const loggedInUser = ctx.state.loggedInUser as U;
     const { account, user } = await this.userAccountsService.update(
-      connectedUser,
+      loggedInUser,
       strategy,
       tokens,
       cookie.scope,
@@ -288,7 +288,7 @@ export class AuthenticationService<
       await hooks.afterScopeUpdate(strategy, cookie.scopeKey, account, user);
     }
 
-    return connectedUser;
+    return loggedInUser;
   }
 
   refreshAccountTokens(user: U, account: Account): Promise<boolean> {

package/src/utils/cookies.ts

@@ -2,17 +2,22 @@ import type { IncomingMessage } from 'http';
 import type { Option } from 'cookies';
 import Cookies from 'cookies';
 
-export const COOKIE_NAME = 'connectedUser';
+export const COOKIE_NAME_TOKEN = 'loggedInUserToken';
+export const COOKIE_NAME_STATE = 'loggedInUserState';
 
 export const getTokenFromRequest = (
   req: IncomingMessage,
   options?: Pick<Option, Exclude<keyof Option, 'secure'>>,
 ): string | undefined => {
+  if (req.headers.authorization?.startsWith('Bearer ')) {
+    return req.headers.authorization.slice('Bearer '.length);
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
   const cookies = new Cookies(req, null as unknown as any, {
     ...options,
     secure: true,
   });
 
-  return cookies.get(COOKIE_NAME);
+  return cookies.get(COOKIE_NAME_TOKEN);
 };

package/src/utils/{createFindConnectedAndUser.ts → createFindLoggedInUser.ts}

@@ -7,7 +7,7 @@ import type {
 } from 'jsonwebtoken';
 import jsonwebtoken from 'jsonwebtoken';
 import type { Logger } from 'nightingale-logger';
-import type { User, UserSanitized } from '../../types.d';
+import type { User, UserSanitized } from '../../types';
 import type MongoUsersManager from '../MongoUsersManager';
 
 type Verify = (
@@ -31,43 +31,42 @@ const createDecodeJWT =
       algorithms: ['HS512'],
       audience: jwtAudience,
     });
-    return (result as any)?.connected as string | undefined;
+    return (result as any)?.loggedInUserId as string | undefined;
   };
 
-export type FindConnectedAndUser<U extends User> = (
+export type FindLoggedInUser<U extends User> = (
   jwtAudience?: string,
   token?: string,
 ) => Promise<[null | undefined | U['_id'], null | undefined | U]>;
 
-export const createFindConnectedAndUser = <
+export const createFindLoggedInUser = <
   U extends User,
   USanitized extends UserSanitized,
 >(
   secretKey: string,
   usersManager: MongoUsersManager<U, USanitized>,
   logger: Logger,
-): FindConnectedAndUser<U> => {
+): FindLoggedInUser<U> => {
   const decodeJwt = createDecodeJWT(secretKey);
 
-  const findConnectedAndUser: FindConnectedAndUser<U> = async (
-    jwtAudience,
-    token,
-  ) => {
+  const findLoggedInUser: FindLoggedInUser<U> = async (jwtAudience, token) => {
     if (!token || !jwtAudience) return [null, null];
 
-    let connected;
+    let loggedInUserId;
     try {
-      connected = await decodeJwt(token, jwtAudience);
+      loggedInUserId = await decodeJwt(token, jwtAudience);
     } catch (err: unknown) {
       logger.debug('failed to verify authentification', { err });
     }
 
-    if (connected == null) return [null, null];
+    if (loggedInUserId == null) return [null, null];
 
-    const user = await usersManager.findConnected(connected);
+    const loggedInUser = await usersManager.findById(loggedInUserId);
 
-    return [connected, user];
+    if (!loggedInUser) return [null, null];
+
+    return [loggedInUserId, loggedInUser];
   };
 
-  return findConnectedAndUser;
+  return findLoggedInUser;
 };

package/dist/definitions/utils/createFindConnectedAndUser.d.ts

@@ -1,6 +0,0 @@
-import type { Logger } from 'nightingale-logger';
-import type { User, UserSanitized } from '../../types.d';
-import type MongoUsersManager from '../MongoUsersManager';
-export type FindConnectedAndUser<U extends User> = (jwtAudience?: string, token?: string) => Promise<[null | undefined | U['_id'], null | undefined | U]>;
-export declare const createFindConnectedAndUser: <U extends User, USanitized extends UserSanitized>(secretKey: string, usersManager: MongoUsersManager<U, USanitized>, logger: Logger) => FindConnectedAndUser<U>;
-//# sourceMappingURL=createFindConnectedAndUser.d.ts.map

package/dist/definitions/utils/createFindConnectedAndUser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFindConnectedAndUser.d.ts","sourceRoot":"","sources":["../../../src/utils/createFindConnectedAndUser.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,iBAAiB,MAAM,sBAAsB,CAAC;AA0B1D,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,IAAI,IAAI,CACjD,WAAW,CAAC,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,KACX,OAAO,CAAC,CAAC,IAAI,GAAG,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;AAElE,eAAO,MAAM,0BAA0B,gEAI1B,MAAM,0DAET,MAAM,4BAyBf,CAAC"}