alp-node-auth 9.3.0 → 11.0.0

package/src/services/user/UserAccountsService.ts

@@ -1,16 +1,15 @@
-/* eslint-disable @typescript-eslint/no-shadow */
-import { EventEmitter } from 'node:events';
-import { Logger } from 'nightingale-logger';
-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';
+import { EventEmitter } from "node:events";
+import { Logger } from "nightingale-logger";
+import type MongoUsersManager from "../../MongoUsersManager";
+import type { Account, AccountId, User, UserSanitized } from "../../types";
+import type { AllowedStrategyKeys } from "../authentification/types";
+import type { AccountService, TokensObject } from "./types";
 
-const logger = new Logger('alp:auth:userAccounts');
+const logger = new Logger("alp:auth:userAccounts");
 
 export const STATUSES = {
-  VALIDATED: 'validated',
-  DELETED: 'deleted',
+  VALIDATED: "validated",
+  DELETED: "deleted",
 };
 
 export default class UserAccountsService<
@@ -38,13 +37,13 @@ export default class UserAccountsService<
     user?: U,
     accountId?: AccountId,
   ): string {
-    logger.debug('getScope', { strategy, userId: user?._id });
+    logger.debug("getScope", { strategy, userId: user?._id });
     const service = this.strategyToService[strategy];
     if (!service) {
-      throw new Error('Strategy not supported');
+      throw new Error("Strategy not supported");
     }
 
-    const newScope = service.scopeKeyToScope[scopeKey];
+    const newScope = service.scopeKeyToScope[scopeKey]!;
     if (!user || !accountId) {
       return newScope;
     }
@@ -54,9 +53,9 @@ export default class UserAccountsService<
     );
 
     if (!account) {
-      throw new Error('Could not found associated account');
+      throw new Error("Could not found associated account");
     }
-    return service.getScope(account.scope, newScope).join(' ');
+    return service.getScope(account.scope, newScope).join(" ");
   }
 
   async update(
@@ -65,7 +64,7 @@ export default class UserAccountsService<
     tokens: TokensObject,
     scope: string,
     subservice: string,
-  ): Promise<{ user: U; account: U['accounts'][number] }> {
+  ): Promise<{ user: U; account: U["accounts"][number] }> {
     const service = this.strategyToService[strategy];
     const profile = await service.getProfile(tokens);
     const accountId = service.getId(profile);
@@ -76,9 +75,9 @@ export default class UserAccountsService<
     if (!account) {
       // TODO check if already exists in other user => merge
       // TODO else add a new account in this user
-      throw new Error('Could not found associated account');
+      throw new Error("Could not found associated account");
     }
-    account.status = 'valid';
+    account.status = "valid";
     account.accessToken = tokens.accessToken;
     if (tokens.refreshToken) {
       account.refreshToken = tokens.refreshToken;
@@ -103,11 +102,11 @@ export default class UserAccountsService<
     subservice: string,
   ): Promise<U> {
     const service = this.strategyToService[strategy];
-    if (!service) throw new Error('Strategy not supported');
+    if (!service) throw new Error("Strategy not supported");
 
     const profile = await service.getProfile(tokens);
     const accountId = service.getId(profile);
-    if (!accountId) throw new Error('Invalid profile: no id found');
+    if (!accountId) throw new Error("Invalid profile: no id found");
 
     const emails = service.getEmails(profile);
 
@@ -118,7 +117,7 @@ export default class UserAccountsService<
         emails,
       });
 
-    logger.info(!user ? 'create user' : 'existing user', {
+    logger.info(!user ? "create user" : "existing user", {
       userId: user?._id,
       accountId,
       /*emails , user*/
@@ -143,12 +142,11 @@ export default class UserAccountsService<
 
     if (!account) {
       account = { provider: strategy, accountId };
-      // @ts-expect-error well...
-      user.accounts.push(account);
+      user.accounts.push(account as Account);
     }
 
     account.name = service.getAccountName(profile);
-    account.status = 'valid';
+    account.status = "valid";
     account.profile = profile;
     account.accessToken = tokens.accessToken;
     if (tokens.refreshToken) {
@@ -176,7 +174,7 @@ export default class UserAccountsService<
       // eslint-disable-next-line unicorn/no-array-reduce
       ...user.emails.reduce(
         (domains: Set<string>, email: string) =>
-          domains.add(email.split('@', 2)[1]),
+          domains.add(email.split("@", 2)[1]!),
         new Set<string>(),
       ),
     ];

package/src/services/user/types.ts

@@ -12,7 +12,7 @@ export interface TokensObject {
   idToken: string;
 }
 
-export interface AccountService<ScopeKeys extends 'login'> {
+export interface AccountService<ScopeKeys extends "login"> {
   scopeKeyToScope: Record<ScopeKeys, string>;
   providerKey: string;
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { MongoBaseModel } from 'liwi-mongo';
+import type { MongoBaseModel } from "liwi-mongo";
 
 export interface UserName {
   familyName: string;

package/src/utils/cookies.ts

@@ -1,16 +1,16 @@
-import type { IncomingMessage } from 'node:http';
-import type { Option } from 'cookies';
-import Cookies from 'cookies';
+import type { IncomingMessage } from "node:http";
+import type { Option } from "cookies";
+import Cookies from "cookies";
 
-export const COOKIE_NAME_TOKEN = 'loggedInUserToken';
-export const COOKIE_NAME_STATE = 'loggedInUserState';
+export const COOKIE_NAME_TOKEN = "loggedInUserToken";
+export const COOKIE_NAME_STATE = "loggedInUserState";
 
 export const getTokenFromRequest = (
   req: IncomingMessage,
-  options?: Pick<Option, Exclude<keyof Option, 'secure'>>,
+  options?: Pick<Option, Exclude<keyof Option, "secure">>,
 ): string | undefined => {
-  if (req.headers.authorization?.startsWith('Bearer ')) {
-    return req.headers.authorization.slice('Bearer '.length);
+  if (req.headers.authorization?.startsWith("Bearer ")) {
+    return req.headers.authorization.slice("Bearer ".length);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument

package/src/utils/createFindLoggedInUser.ts

@@ -1,14 +1,14 @@
-import { promisify } from 'node:util';
+import { promisify } from "node:util";
 import type {
   GetPublicKeyOrSecret,
   Secret,
   VerifyCallback,
   VerifyOptions,
-} from 'jsonwebtoken';
-import jsonwebtoken from 'jsonwebtoken';
-import type { Logger } from 'nightingale-logger';
-import type MongoUsersManager from '../MongoUsersManager';
-import type { User, UserSanitized } from '../types';
+} from "jsonwebtoken";
+import jsonwebtoken from "jsonwebtoken";
+import type { Logger } from "nightingale-logger";
+import type MongoUsersManager from "../MongoUsersManager";
+import type { User, UserSanitized } from "../types";
 
 type Verify = (
   token: string,
@@ -28,7 +28,7 @@ const createDecodeJWT =
   (secretKey: string) =>
   async (token: string, jwtAudience: string): Promise<string | undefined> => {
     const result = await verifyPromisified(token, secretKey, {
-      algorithms: ['HS512'],
+      algorithms: ["HS512"],
       audience: jwtAudience,
     });
     return (result as any)?.loggedInUserId as string | undefined;
@@ -37,7 +37,7 @@ const createDecodeJWT =
 export type FindLoggedInUser<U extends User> = (
   jwtAudience?: string,
   token?: string,
-) => Promise<[U['_id'] | null | undefined, U | null | undefined]>;
+) => Promise<[U["_id"] | null | undefined, U | null | undefined]>;
 
 export const createFindLoggedInUser = <
   U extends User,
@@ -56,7 +56,7 @@ export const createFindLoggedInUser = <
     try {
       loggedInUserId = await decodeJwt(token, jwtAudience);
     } catch (error: unknown) {
-      logger.debug('failed to verify authentification', { err: error });
+      logger.debug("failed to verify authentification", { err: error });
     }
 
     if (loggedInUserId == null) return [null, null];

package/src/utils/generators.ts

@@ -1,14 +1,14 @@
-import { randomBytes } from 'node:crypto';
-import { promisify } from 'node:util';
+import { randomBytes } from "node:crypto";
+import { promisify } from "node:util";
 
 const randomBytesPromisified = promisify(randomBytes);
 
 export async function randomBase64(size: number): Promise<string> {
   const buffer = await randomBytesPromisified(size);
-  return buffer.toString('base64');
+  return buffer.toString("base64");
 }
 
 export async function randomHex(size: number): Promise<string> {
   const buffer = await randomBytesPromisified(size);
-  return buffer.toString('hex');
+  return buffer.toString("hex");
 }

package/strategies/dropbox.js

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

package/strategies/facebook.js

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

package/strategies/foursquare.js

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

package/strategies/github.js

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

package/strategies/google.js

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

package/strategies/slack.js

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

package/strategies/strategies.d.ts

@@ -1,8 +1,13 @@
-import { Config, SlackParams } from 'alp-types';
-import { ClientCredentials, AuthorizationCode } from 'simple-oauth2';
+import { ClientCredentials, AuthorizationCode } from "simple-oauth2";
+export type GoogleParams =
+  | "access_type"
+  | "include_granted_scopes"
+  | "login_hint"
+  | "prompt";
+export type SlackParams = "client_id" | "team";
 
 export interface Strategy<Params = SlackParams> {
-  type: 'oauth2';
+  type: "oauth2";
   oauth2: {
     authorizationCode: AuthorizationCode<Params>;
     clientCredentials: ClientCredentials<Params>;