alp-node-auth 7.2.2 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alp-node-auth",
-  "version": "7.2.2",
+  "version": "9.0.0",
   "description": "authentication with alp",
   "keywords": [
     "alp"
@@ -15,9 +15,9 @@
   "homepage": "https://github.com/christophehurpeau/alp",
   "type": "module",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.12.0"
   },
-  "main": "./dist/index-node16.mjs",
+  "main": "./dist/index-node18.mjs",
   "types": "./dist/definitions/index.d.ts",
   "typesVersions": {
     ">=3.1": {
@@ -29,16 +29,35 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
+      "types": "./dist/definitions/index.d.ts",
       "node": {
-        "import": "./dist/index-node16.mjs"
+        "import": "./dist/index-node18.mjs"
       }
     },
-    "./strategies/dropbox": "./strategies/dropbox.js",
-    "./strategies/facebook": "./strategies/facebook.js",
-    "./strategies/foursquare": "./strategies/foursquare.js",
-    "./strategies/github": "./strategies/github.js",
-    "./strategies/google": "./strategies/google.js",
-    "./strategies/slack": "./strategies/slack.js"
+    "./strategies/dropbox": {
+      "types": "./strategies/strategies.d.ts",
+      "default": "./strategies/dropbox.js"
+    },
+    "./strategies/facebook": {
+      "types": "./strategies/strategies.d.ts",
+      "default": "./strategies/facebook.js"
+    },
+    "./strategies/foursquare": {
+      "types": "./strategies/strategies.d.ts",
+      "default": "./strategies/foursquare.js"
+    },
+    "./strategies/github": {
+      "types": "./strategies/strategies.d.ts",
+      "default": "./strategies/github.js"
+    },
+    "./strategies/google": {
+      "types": "./strategies/strategies.d.ts",
+      "default": "./strategies/google.js"
+    },
+    "./strategies/slack": {
+      "types": "./strategies/strategies.d.ts",
+      "default": "./strategies/slack.js"
+    }
   },
   "sideEffects": false,
   "scripts": {
@@ -55,44 +74,62 @@
     "babelEnvs": [
       {
         "target": "node",
-        "version": "16"
+        "version": "18"
       }
     ],
     "entries": [
       "index"
     ],
     "extraEntries": [
-      "strategies/dropbox",
-      "strategies/facebook",
-      "strategies/foursquare",
-      "strategies/github",
-      "strategies/google",
-      "strategies/slack"
+      {
+        "name": "strategies/dropbox",
+        "types": "strategies/strategies.d.ts"
+      },
+      {
+        "name": "strategies/facebook",
+        "types": "strategies/strategies.d.ts"
+      },
+      {
+        "name": "strategies/foursquare",
+        "types": "strategies/strategies.d.ts"
+      },
+      {
+        "name": "strategies/github",
+        "types": "strategies/strategies.d.ts"
+      },
+      {
+        "name": "strategies/google",
+        "types": "strategies/strategies.d.ts"
+      },
+      {
+        "name": "strategies/slack",
+        "types": "strategies/strategies.d.ts"
+      }
     ]
   },
   "peerDependencies": {
     "alp-node": "^5.0.0",
     "alp-router": "^6.0.0",
-    "liwi-mongo": "^10.2.0",
-    "router-segments": "^6.0.0"
+    "liwi-mongo": "^10.5.0",
+    "router-segments": "^7.0.0"
   },
   "dependencies": {
     "@types/jsonwebtoken": "^9.0.1",
-    "@types/simple-oauth2": "^2.5.1",
+    "@types/simple-oauth2": "^5.0.4",
     "alp-types": "3.1.0",
     "cookies": "~0.8.0",
     "jsonwebtoken": "^9.0.0",
-    "nightingale-logger": "^13.0.0",
-    "simple-oauth2": "^2.2.1"
+    "nightingale-logger": "^14.1.0",
+    "simple-oauth2": "^5.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.20.12",
-    "alp-node": "5.1.2",
-    "alp-router": "6.1.2",
-    "liwi-mongo": "10.3.2",
-    "pob-babel": "35.5.0",
-    "router-segments": "6.0.0",
-    "typescript": "4.9.5"
+    "@babel/core": "7.22.9",
+    "alp-node": "6.0.0",
+    "alp-router": "7.0.0",
+    "liwi-mongo": "10.5.0",
+    "pob-babel": "36.2.0",
+    "router-segments": "7.0.0",
+    "typescript": "5.1.6"
   },
-  "gitHead": "56d4a6e4ec5e4163624bb5aec4575f8b5e3854ff"
+  "gitHead": "c01392e16b2d914a332fe835333dd6a82c677ab8"
 }

package/src/MongoUsersManager.ts

@@ -1,5 +1,5 @@
 import type { MongoInsertType, MongoStore, Update } from 'liwi-mongo';
-import type { User, Account, UserSanitized } from '../types.d';
+import type { User, Account, UserSanitized } from './types';
 
 export default class MongoUsersManager<
   U extends User = User,
@@ -11,10 +11,15 @@ export default class MongoUsersManager<
     this.store = store;
   }
 
+  /** @deprecated use findById instead */
   findConnected(connected: string): Promise<U | undefined> {
     return this.store.findByKey(connected);
   }
 
+  findById(userId: string): Promise<U | undefined> {
+    return this.store.findByKey(userId);
+  }
+
   insertOne(user: MongoInsertType<U>): Promise<any> {
     return this.store.insertOne(user);
   }
@@ -32,7 +37,7 @@ export default class MongoUsersManager<
     emails,
     provider,
   }: {
-    accountId: string | number;
+    accountId: number | string;
     emails?: string[];
     provider: string;
   }): Promise<U | undefined> {
@@ -69,6 +74,7 @@ export default class MongoUsersManager<
     } as Update<U>);
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   sanitizeBaseUser(user: U): UserSanitized {
     return {
       _id: user._id,

package/src/authApolloContext.ts

@@ -1,17 +1,17 @@
-import type { IncomingMessage } from 'http';
+import type { IncomingMessage } from 'node:http';
 import type { NodeConfig } from 'alp-types';
 import { Logger } from 'nightingale-logger';
-import type { User } from '../types.d';
 import type MongoUsersManager from './MongoUsersManager';
-import { getTokenFromRequest, COOKIE_NAME } from './utils/cookies';
-import { createFindConnectedAndUser } from './utils/createFindConnectedAndUser';
+import type { User } from './types';
+import { getTokenFromRequest, COOKIE_NAME_TOKEN } from './utils/cookies';
+import { createFindLoggedInUser } from './utils/createFindLoggedInUser';
 
 const logger = new Logger('alp:auth');
 
 const getTokenFromReq = (
   req: IncomingMessage & { cookies?: Record<string, string> },
 ): string | undefined => {
-  if (req.cookies) return req.cookies[COOKIE_NAME];
+  if (req.cookies) return req.cookies[COOKIE_NAME_TOKEN];
   return getTokenFromRequest(req);
 };
 
@@ -23,15 +23,15 @@ export const createAuthApolloContext = <U extends User = User>(
   config: NodeConfig,
   usersManager: MongoUsersManager<U>,
 ): any => {
-  const findConnectedAndUser = createFindConnectedAndUser(
+  const findLoggedInUser = createFindLoggedInUser(
     config.get<Map<string, string>>('authentication').get('secretKey')!,
     usersManager,
     logger,
   );
 
   return async ({ req, connection }: { req: any; connection: any }) => {
-    if (connection?.user) {
-      return { user: connection.user };
+    if (connection?.loggedInUser) {
+      return { user: connection.loggedInUser };
     }
 
     if (!req) return null;
@@ -41,12 +41,12 @@ export const createAuthApolloContext = <U extends User = User>(
 
     if (!token) return { user: undefined };
 
-    const [, user] = await findConnectedAndUser(
+    const [, loggedInUser] = await findLoggedInUser(
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
       req.headers['user-agent'],
       token,
     );
 
-    return { user };
+    return { user: loggedInUser };
   };
 };

package/src/authSocketIO.ts

@@ -1,9 +1,9 @@
 import type { NodeApplication } from 'alp-types';
 import { Logger } from 'nightingale-logger';
-import type { User } from '../types.d';
 import type MongoUsersManager from './MongoUsersManager';
+import type { User } from './types';
 import { getTokenFromRequest } from './utils/cookies';
-import { createFindConnectedAndUser } from './utils/createFindConnectedAndUser';
+import { createFindLoggedInUser } from './utils/createFindLoggedInUser';
 
 const logger = new Logger('alp:auth');
 
@@ -12,8 +12,9 @@ export const authSocketIO = <U extends User = User>(
   usersManager: MongoUsersManager<U>,
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   io: any,
+  jwtAudience?: string,
 ): void => {
-  const findConnectedAndUser = createFindConnectedAndUser(
+  const findLoggedInUser = createFindLoggedInUser(
     app.config.get<Map<string, string>>('authentication').get('secretKey')!,
     usersManager,
     logger,
@@ -29,16 +30,16 @@ export const authSocketIO = <U extends User = User>(
 
     if (!token) return next();
 
-    const [connected, user] = await findConnectedAndUser(
+    const [loggedInUserId, loggedInUser] = await findLoggedInUser(
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      handshakeData.headers['user-agent'],
+      jwtAudience || handshakeData.headers['user-agent'],
       token,
     );
 
-    if (!connected || !user) return next();
+    if (!loggedInUserId || !loggedInUser) return next();
 
-    socket.user = user;
-    users.set(socket.client.id, user);
+    socket.user = loggedInUser;
+    users.set(socket.client.id, loggedInUser);
 
     socket.on('disconnected', () => users.delete(socket.client.id));
 

package/src/createAuthController.ts

@@ -1,6 +1,5 @@
 import type { Context } from 'alp-node';
 import 'alp-router';
-import type { User, UserSanitized } from '../types.d';
 import type MongoUsersManager from './MongoUsersManager';
 import type {
   AuthenticationService,
@@ -10,6 +9,7 @@ import type {
   AllowedStrategyKeys,
   AllowedMapParamsStrategy,
 } from './services/authentification/types';
+import type { User, UserSanitized } from './types';
 
 export interface CreateAuthControllerParams<
   StrategyKeys extends AllowedStrategyKeys,
@@ -37,11 +37,12 @@ export interface AuthHooks<StrategyKeys extends AllowedStrategyKeys>
   paramsForLogin?: <StrategyKey extends StrategyKeys>(
     strategy: StrategyKey,
     ctx: Context,
-  ) => // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  | void
-    | Promise<void>
+  ) =>
     | OptionalRecord<AllowedMapParamsStrategy[StrategyKey], any>
-    | Promise<OptionalRecord<AllowedMapParamsStrategy[StrategyKey], any>>;
+    | Promise<OptionalRecord<AllowedMapParamsStrategy[StrategyKey], any>>
+    | Promise<void>
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    | void;
 }
 
 export function createAuthController<
@@ -72,7 +73,7 @@ export function createAuthController<
      * The user must already be connected
      */
     async addScope(ctx: Context): Promise<void> {
-      if (!ctx.state.connected) {
+      if (!ctx.state.loggedInUser) {
         await ctx.redirectTo(homeRouterKey);
         return;
       }
@@ -89,17 +90,17 @@ export function createAuthController<
       const strategy: StrategyKeys = ctx.namedParam('strategy') as StrategyKeys;
       ctx.assert(strategy);
 
-      const connectedUser = await authenticationService.accessResponse(
+      const loggedInUser = await authenticationService.accessResponse(
         ctx,
         strategy,
-        ctx.state.connected as boolean | undefined,
+        !!ctx.state.loggedInUser,
         {
           afterLoginSuccess: authHooks.afterLoginSuccess,
           afterScopeUpdate: authHooks.afterScopeUpdate,
         },
       );
       const keyPath = usersManager.store.keyPath;
-      await ctx.setConnected(connectedUser[keyPath], connectedUser);
+      await ctx.setLoggedIn(loggedInUser[keyPath], loggedInUser);
       await ctx.redirectTo(homeRouterKey);
     },
 

package/src/index.ts

@@ -1,10 +1,10 @@
-import type { IncomingMessage } from 'http';
-import { promisify } from 'util';
+/* eslint-disable max-lines */
+import type { IncomingMessage } from 'node:http';
+import { promisify } from 'node:util';
 import type { Context } from 'alp-node';
 import type { ContextState, NodeApplication } from 'alp-types';
 import jsonwebtoken from 'jsonwebtoken';
 import { Logger } from 'nightingale-logger';
-import type { User, UserSanitized } from '../types.d';
 import type MongoUsersManager from './MongoUsersManager';
 import type {
   AuthController as AuthControllerType,
@@ -18,8 +18,13 @@ 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 type { User, UserSanitized } from './types';
+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';
@@ -28,25 +33,30 @@ export { authSocketIO } from './authSocketIO';
 export { createAuthApolloContext } from './authApolloContext';
 export { STATUSES } from './services/user/UserAccountsService';
 
+export * from './types';
+
 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 +112,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 +137,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 +176,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>,
+        next: () => Promise<T> | 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();
       },
     };