alp-node-auth 7.2.2 → 9.0.0

package/src/services/authentification/AuthenticationService.ts

@@ -2,12 +2,12 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable camelcase, max-lines */
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import 'alp-router';
 import type { Context, NodeConfig } from 'alp-types';
 import { Logger } from 'nightingale-logger';
-import type { OAuthClient } from 'simple-oauth2';
-import type { AccountId, User, Account, UserSanitized } from '../../../types.d';
+import type { Strategy as Oauth2Strategy } from '../../../strategies/strategies.d';
+import type { AccountId, User, Account, UserSanitized } from '../../types';
 import { randomHex } from '../../utils/generators';
 import type UserAccountsService from '../user/UserAccountsService';
 import type { AllowedStrategyKeys, Tokens } from './types';
@@ -30,14 +30,6 @@ export interface GetTokensOptions {
   redirectUri: string;
 }
 
-export interface Strategy {
-  type: string;
-}
-
-export interface Oauth2Strategy<Params extends string> extends Strategy {
-  oauth2: OAuthClient<Params>;
-}
-
 export type Strategies<StrategyKeys extends AllowedStrategyKeys> = Record<
   StrategyKeys,
   Oauth2Strategy<any>
@@ -46,21 +38,22 @@ export type Strategies<StrategyKeys extends AllowedStrategyKeys> = Record<
 export interface AccessResponseHooks<StrategyKeys, U extends User = User> {
   afterLoginSuccess?: <StrategyKey extends StrategyKeys>(
     strategy: StrategyKey,
-    connectedUser: U,
-  ) => void | Promise<void>;
+    loggedInUser: U,
+  ) => Promise<void> | void;
 
   afterScopeUpdate?: <StrategyKey extends StrategyKeys>(
     strategy: StrategyKey,
     scopeKey: string,
     account: Account,
     user: U,
-  ) => void | Promise<void>;
+  ) => Promise<void> | void;
 }
 
 export class AuthenticationService<
   StrategyKeys extends AllowedStrategyKeys,
   U extends User = User,
   USanitized extends UserSanitized = UserSanitized,
+  // eslint-disable-next-line unicorn/prefer-event-target
 > extends EventEmitter {
   config: NodeConfig;
 
@@ -105,17 +98,20 @@ export class AuthenticationService<
           },
         );
         if (!result) return result;
+        const tokens = result.token;
+
         return {
-          accessToken: result.access_token,
-          refreshToken: result.refresh_token,
-          tokenType: result.token_type,
-          expiresIn: result.expires_in,
+          accessToken: tokens.access_token as string,
+          refreshToken: tokens.refresh_token as string,
+          tokenType: tokens.token_type as string,
+          expiresIn: tokens.expires_in as number,
           expireDate: (() => {
+            if (tokens.expires_in == null) return null;
             const d = new Date();
-            d.setTime(d.getTime() + result.expires_in * 1000);
+            d.setTime(d.getTime() + (tokens.expires_in as number) * 1000);
             return d;
           })(),
-          idToken: result.id_token,
+          idToken: tokens.id_token as string,
         };
         // return strategyInstance.accessToken.create(result);
       }
@@ -136,21 +132,22 @@ export class AuthenticationService<
     const strategyInstance = this.strategies[strategy];
     switch (strategyInstance.type) {
       case 'oauth2': {
-        const token = strategyInstance.oauth2.accessToken.create({
+        const token = strategyInstance.oauth2.clientCredentials.createToken({
           refresh_token: tokensParam.refreshToken,
         });
         const result = await token.refresh();
         const tokens = result.token;
         return {
-          accessToken: tokens.access_token,
-          tokenType: tokens.token_type,
-          expiresIn: tokens.expires_in,
+          accessToken: tokens.access_token as string,
+          tokenType: tokens.token_type as string,
+          expiresIn: tokens.expires_in as number,
           expireDate: (() => {
+            if (tokens.expires_in == null) return null;
             const d = new Date();
-            d.setTime(d.getTime() + tokens.expires_in * 1000);
+            d.setTime(d.getTime() + (tokens.expires_in as number) * 1000);
             return d;
           })(),
-          idToken: tokens.id_token,
+          idToken: tokens.id_token as string,
         };
       }
 
@@ -223,9 +220,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) {
@@ -245,12 +242,12 @@ export class AuthenticationService<
     }
 
     cookie = JSON.parse(cookie);
-    if (!cookie || !cookie.scope) {
+    if (!cookie?.scope) {
       throw new Error('Unexpected cookie value');
     }
 
     if (!cookie.isLoginAccess) {
-      if (!isConnected) {
+      if (!isLoggedIn) {
         throw new Error('You are not connected');
       }
     }
@@ -275,9 +272,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 +285,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/services/authentification/types.ts

@@ -11,7 +11,7 @@ export interface Tokens {
   accessToken: string;
   refreshToken?: string;
   tokenType: string;
-  expiresIn: string;
-  expireDate: Date;
+  expiresIn: number;
+  expireDate: Date | null;
   idToken: string;
 }

package/src/services/user/UserAccountGoogleService.ts

@@ -1,6 +1,6 @@
+/* eslint-disable @typescript-eslint/class-methods-use-this */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import { fetch } from 'alp-node';
 import type { Tokens } from '../authentification/types';
 import type { AccountService, FullName } from './types';
 

package/src/services/user/UserAccountSlackService.ts

@@ -1,5 +1,5 @@
+/* eslint-disable @typescript-eslint/class-methods-use-this */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import { fetch } from 'alp-node';
 import type { Tokens } from '../authentification/types';
 import type { AccountService, FullName } from './types';
 
@@ -26,13 +26,7 @@ export default class UserAccountSlackService<ScopeKeys extends 'login'>
   }
 
   getId(profile: any): string | null {
-    if (
-      !profile ||
-      !profile.team ||
-      !profile.team.id ||
-      !profile.user ||
-      !profile.user.id
-    ) {
+    if (!profile?.team?.id || !profile.user?.id) {
       return null;
     }
     return `team:${profile.team.id as string};user:${

package/src/services/user/UserAccountsService.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-shadow */
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import { Logger } from 'nightingale-logger';
-import type { AccountId, User, Account, UserSanitized } from '../../../types.d';
 import type MongoUsersManager from '../../MongoUsersManager';
+import type { AccountId, User, Account, UserSanitized } from '../../types';
 import type { AllowedStrategyKeys } from '../authentification/types';
 import type { AccountService, TokensObject } from './types';
 
@@ -17,6 +17,7 @@ export default class UserAccountsService<
   StrategyKeys extends AllowedStrategyKeys,
   U extends User = User,
   USanitized extends UserSanitized = UserSanitized,
+  // eslint-disable-next-line unicorn/prefer-event-target
 > extends EventEmitter {
   private readonly strategyToService: Record<StrategyKeys, AccountService<any>>;
 
@@ -82,7 +83,7 @@ export default class UserAccountsService<
     if (tokens.refreshToken) {
       account.refreshToken = tokens.refreshToken;
     }
-    if (tokens.expireDate) {
+    if (tokens.expireDate !== undefined) {
       account.tokenExpireDate = tokens.expireDate;
     }
     account.scope = service.getScope(account.scope, scope);
@@ -117,7 +118,11 @@ export default class UserAccountsService<
         emails,
       });
 
-    logger.info(!user ? 'create user' : 'existing user', { emails, user });
+    logger.info(!user ? 'create user' : 'existing user', {
+      userId: user?._id,
+      accountId,
+      /*emails , user*/
+    });
 
     if (!user) {
       user = {};
@@ -149,7 +154,7 @@ export default class UserAccountsService<
     if (tokens.refreshToken) {
       account.refreshToken = tokens.refreshToken;
     }
-    if (tokens.expireDate) {
+    if (tokens.expireDate !== undefined) {
       account.tokenExpireDate = tokens.expireDate;
     }
     account.scope = service.getScope(account.scope, scope);

package/src/services/user/types.ts

@@ -7,8 +7,8 @@ export interface TokensObject {
   accessToken: string;
   refreshToken?: string;
   tokenType: string;
-  expiresIn: string;
-  expireDate: Date;
+  expiresIn: number;
+  expireDate: Date | null;
   idToken: string;
 }
 

package/{types.d.ts → src/types.ts}

@@ -1,6 +1,5 @@
-import { MongoBaseModel } from 'liwi-mongo';
+import type { MongoBaseModel } from 'liwi-mongo';
 
-/* eslint-disable no-restricted-globals */
 export interface UserName {
   familyName: string;
   givenName: string;
@@ -18,7 +17,7 @@ export interface Account {
   scope: string[];
   subservices?: string[];
   status: string;
-  tokenExpireDate: Date;
+  tokenExpireDate: Date | null;
 }
 
 export interface User extends MongoBaseModel {

package/src/utils/cookies.ts

@@ -1,18 +1,23 @@
-import type { IncomingMessage } from 'http';
+import type { IncomingMessage } from 'node: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}

@@ -1,4 +1,4 @@
-import { promisify } from 'util';
+import { promisify } from 'node:util';
 import type {
   GetPublicKeyOrSecret,
   Secret,
@@ -7,12 +7,12 @@ import type {
 } from 'jsonwebtoken';
 import jsonwebtoken from 'jsonwebtoken';
 import type { Logger } from 'nightingale-logger';
-import type { User, UserSanitized } from '../../types.d';
 import type MongoUsersManager from '../MongoUsersManager';
+import type { User, UserSanitized } from '../types';
 
 type Verify = (
   token: string,
-  secretOrPublicKey: Secret | GetPublicKeyOrSecret,
+  secretOrPublicKey: GetPublicKeyOrSecret | Secret,
   options?: VerifyOptions,
   callback?: VerifyCallback,
 ) => void;
@@ -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]>;
+) => Promise<[U['_id'] | null | undefined, U | null | undefined]>;
 
-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);
-    } catch (err: unknown) {
-      logger.debug('failed to verify authentification', { err });
+      loggedInUserId = await decodeJwt(token, jwtAudience);
+    } catch (error: unknown) {
+      logger.debug('failed to verify authentification', { err: error });
     }
 
-    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/src/utils/generators.ts

@@ -1,5 +1,5 @@
-import { randomBytes } from 'crypto';
-import { promisify } from 'util';
+import { randomBytes } from 'node:crypto';
+import { promisify } from 'node:util';
 
 const randomBytesPromisified = promisify(randomBytes);
 

package/strategies/dropbox.js

@@ -1,18 +1,28 @@
-import { create } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
 export default function dropboxStrategy(config) {
+  const options = {
+    client: {
+      id: config.get('dropbox').get('clientId'),
+      secret: config.get('dropbox').get('clientSecret'),
+    },
+    auth: {
+      tokenHost: 'https://www.dropbox.com',
+      tokenPath: '/1/oauth2/token',
+    },
+  };
+  const authOptions = {
+    ...options,
+    auth: {
+      ...options.auth,
+      authorizePath: '/1/oauth2/authorize',
+    },
+  };
   return {
     type: 'oauth2',
-    oauth2: create({
-      client: {
-        id: config.get('dropbox').get('clientId'),
-        secret: config.get('dropbox').get('clientSecret'),
-      },
-      auth: {
-        tokenHost: 'https://www.dropbox.com',
-        tokenPath: '/1/oauth2/token',
-        authorizePath: '/1/oauth2/authorize',
-      },
-    }),
+    oauth2: {
+      authorizationCode: new AuthorizationCode(authOptions),
+      clientCredentials: new ClientCredentials(options),
+    },
   };
 }

package/strategies/facebook.js

@@ -1,18 +1,28 @@
-import { create } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
 export default function facebookStrategy(config) {
+  const options = {
+    client: {
+      id: config.get('facebook').get('clientId'),
+      secret: config.get('facebook').get('clientSecret'),
+    },
+    auth: {
+      tokenHost: 'https://www.facebook.com',
+      tokenPath: '/oauth/access_token',
+    },
+  };
+  const authOptions = {
+    ...options,
+    auth: {
+      ...options.auth,
+      authorizePath: '/dialog/oauth',
+    },
+  };
   return {
     type: 'oauth2',
-    oauth2: create({
-      client: {
-        id: config.get('facebook').get('clientId'),
-        secret: config.get('facebook').get('clientSecret'),
-      },
-      auth: {
-        tokenHost: 'https://www.facebook.com',
-        tokenPath: '/oauth/access_token',
-        authorizePath: '/dialog/oauth',
-      },
-    }),
+    oauth2: {
+      authorizationCode: new AuthorizationCode(authOptions),
+      clientCredentials: new ClientCredentials(options),
+    },
   };
 }

package/strategies/foursquare.js

@@ -1,18 +1,28 @@
-import { create } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
 export default function foursquareStrategy(config) {
+  const options = {
+    client: {
+      id: config.get('foursquare').get('clientId'),
+      secret: config.get('foursquare').get('clientSecret'),
+    },
+    auth: {
+      tokenHost: 'https://foursquare.com',
+      tokenPath: '/oauth2/access_token',
+    },
+  };
+  const authOptions = {
+    ...options,
+    auth: {
+      ...options.auth,
+      authorizePath: '/oauth2/authenticate',
+    },
+  };
   return {
     type: 'oauth2',
-    oauth2: create({
-      client: {
-        id: config.get('foursquare').get('clientId'),
-        secret: config.get('foursquare').get('clientSecret'),
-      },
-      auth: {
-        tokenHost: 'https://foursquare.com',
-        tokenPath: '/oauth2/access_token',
-        authorizePath: '/oauth2/authenticate',
-      },
-    }),
+    oauth2: {
+      authorizationCode: new AuthorizationCode(authOptions),
+      clientCredentials: new ClientCredentials(options),
+    },
   };
 }

package/strategies/github.js

@@ -1,18 +1,28 @@
-import { create } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
 export default function githubStrategy(config) {
+  const options = {
+    client: {
+      id: config.get('github').get('clientId'),
+      secret: config.get('github').get('clientSecret'),
+    },
+    auth: {
+      tokenHost: 'https://github.com',
+      tokenPath: '/login/oauth/access_token',
+    },
+  };
+  const authOptions = {
+    ...options,
+    auth: {
+      ...options.auth,
+      authorizePath: '/login/oauth/authorize',
+    },
+  };
   return {
     type: 'oauth2',
-    oauth2: create({
-      client: {
-        id: config.get('github').get('clientId'),
-        secret: config.get('github').get('clientSecret'),
-      },
-      auth: {
-        tokenHost: 'https://github.com',
-        tokenPath: '/login/oauth/access_token',
-        authorizePath: '/login/oauth/authorize',
-      },
-    }),
+    oauth2: {
+      authorizationCode: new AuthorizationCode(authOptions),
+      clientCredentials: new ClientCredentials(options),
+    },
   };
 }

package/strategies/google.js

@@ -1,18 +1,29 @@
-import { create } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
 export default function googleStrategy(config) {
+  const options = {
+    client: {
+      id: config.get('google').get('clientId'),
+      secret: config.get('google').get('clientSecret'),
+    },
+    auth: {
+      tokenHost: 'https://accounts.google.com',
+      tokenPath: '/o/oauth2/token',
+    },
+  };
+  const authOptions = {
+    ...options,
+    auth: {
+      ...options.auth,
+      authorizePath: '/o/oauth2/auth',
+    },
+  };
+
   return {
     type: 'oauth2',
-    oauth2: create({
-      client: {
-        id: config.get('google').get('clientId'),
-        secret: config.get('google').get('clientSecret'),
-      },
-      auth: {
-        tokenHost: 'https://accounts.google.com',
-        tokenPath: '/o/oauth2/token',
-        authorizePath: '/o/oauth2/auth',
-      },
-    }),
+    oauth2: {
+      authorizationCode: new AuthorizationCode(authOptions),
+      clientCredentials: new ClientCredentials(options),
+    },
   };
 }

package/strategies/slack.js

@@ -1,18 +1,28 @@
-import { create } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
 export default function slackStrategy(config) {
+  const options = {
+    client: {
+      id: config.get('slack').get('clientId'),
+      secret: config.get('slack').get('clientSecret'),
+    },
+    auth: {
+      tokenHost: 'https://slack.com',
+      tokenPath: '/api/oauth.access',
+    },
+  };
+  const authOptions = {
+    ...options,
+    auth: {
+      ...options.auth,
+      authorizePath: '/oauth/authorize',
+    },
+  };
   return {
     type: 'oauth2',
-    oauth2: create({
-      client: {
-        id: config.get('slack').get('clientId'),
-        secret: config.get('slack').get('clientSecret'),
-      },
-      auth: {
-        tokenHost: 'https://slack.com',
-        tokenPath: '/api/oauth.access',
-        authorizePath: '/oauth/authorize',
-      },
-    }),
+    oauth2: {
+      authorizationCode: new AuthorizationCode(authOptions),
+      clientCredentials: new ClientCredentials(options),
+    },
   };
 }

package/strategies/strategies.d.ts

@@ -1,9 +1,14 @@
 import { Config, SlackParams } from 'alp-types';
-import { OAuthClient } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
 
-export interface Strategy {
+export interface Strategy<Params = SlackParams> {
   type: 'oauth2';
-  oauth2: OAuthClient<SlackParams>;
+  oauth2: {
+    authorizationCode: AuthorizationCode<Params>;
+    clientCredentials: ClientCredentials<Params>;
+  };
 }
 
-export default function createStrategy(config: Config): Strategy;
+export default function createStrategy<Params = SlackParams>(
+  config: Config,
+): Strategy<Params>;