alp-node-auth 10.0.0 → 12.0.0

package/dist/{index-node18.mjs → index-node.mjs}

@@ -8,15 +8,15 @@ import Cookies from 'cookies';
 function createAuthController({
   usersManager,
   authenticationService,
-  homeRouterKey = '/',
+  homeRouterKey = "/",
   defaultStrategy,
   authHooks = {}
 }) {
   return {
     async login(ctx) {
-      const strategy = ctx.namedParam('strategy') || defaultStrategy;
-      if (!strategy) throw new Error('Strategy missing');
-      const params = authHooks.paramsForLogin && (await authHooks.paramsForLogin(strategy, ctx)) || {};
+      const strategy = ctx.namedRouteParam("strategy") || defaultStrategy;
+      if (!strategy) throw new Error("Strategy missing");
+      const params = authHooks.paramsForLogin && await authHooks.paramsForLogin(strategy, ctx) || {};
       await authenticationService.redirectAuthUrl(ctx, strategy, {}, params);
     },
     /**
@@ -28,25 +28,31 @@ function createAuthController({
         ctx.redirectTo(homeRouterKey);
         return;
       }
-      const strategy = ctx.namedParam('strategy') || defaultStrategy;
-      if (!strategy) throw new Error('Strategy missing');
-      const scopeKey = ctx.namedParam('scopeKey');
-      if (!scopeKey) throw new Error('Scope missing');
-      await authenticationService.redirectAuthUrl(ctx, strategy, {
-        scopeKey
-      });
+      const strategy = ctx.namedRouteParam("strategy") || defaultStrategy;
+      if (!strategy) throw new Error("Strategy missing");
+      const scopeKey = ctx.namedRouteParam("scopeKey");
+      if (!scopeKey) throw new Error("Scope missing");
+      await authenticationService.redirectAuthUrl(ctx, strategy, { scopeKey });
     },
     async response(ctx) {
-      const strategy = ctx.namedParam('strategy');
+      const strategy = ctx.namedRouteParam(
+        "strategy"
+      );
       ctx.assert(strategy);
-      const loggedInUser = await authenticationService.accessResponse(ctx, strategy, !!ctx.state.loggedInUser, {
-        afterLoginSuccess: authHooks.afterLoginSuccess,
-        afterScopeUpdate: authHooks.afterScopeUpdate
-      });
+      const loggedInUser = await authenticationService.accessResponse(
+        ctx,
+        strategy,
+        !!ctx.state.loggedInUser,
+        {
+          afterLoginSuccess: authHooks.afterLoginSuccess,
+          afterScopeUpdate: authHooks.afterScopeUpdate
+        }
+      );
       const keyPath = usersManager.store.keyPath;
       await ctx.setLoggedIn(loggedInUser[keyPath], loggedInUser);
       ctx.redirectTo(homeRouterKey);
     },
+    // eslint-disable-next-line @typescript-eslint/require-await -- keep async in case i later need await in this method
     async logout(ctx) {
       ctx.logout();
       ctx.redirectTo(homeRouterKey);
@@ -54,27 +60,29 @@ function createAuthController({
   };
 }
 
-const createRoutes = controller => ({
-  login: ['/login/:strategy?', segment => {
-    segment.add('/response', controller.response, 'authResponse');
-    segment.defaultRoute(controller.login, 'login');
-  }],
-  addScope: ['/add-scope/:strategy/:scopeKey', controller.addScope],
-  logout: ['/logout', controller.logout]
+const createRoutes = (controller) => ({
+  login: [
+    "/login/:strategy?",
+    (segment) => {
+      segment.add("/response", controller.response, "authResponse");
+      segment.defaultRoute(controller.login, "login");
+    }
+  ],
+  addScope: ["/add-scope/:strategy/:scopeKey", controller.addScope],
+  logout: ["/logout", controller.logout]
 });
 
 const randomBytesPromisified = promisify(randomBytes);
 async function randomHex(size) {
   const buffer = await randomBytesPromisified(size);
-  return buffer.toString('hex');
+  return buffer.toString("hex");
 }
 
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable camelcase, max-lines */
-const logger$4 = new Logger('alp:auth:authentication');
+const logger$4 = new Logger("alp:auth:authentication");
 class AuthenticationService extends EventEmitter {
+  config;
+  strategies;
+  userAccountsService;
   constructor(config, strategies, userAccountsService) {
     super();
     this.config = config;
@@ -82,88 +90,79 @@ class AuthenticationService extends EventEmitter {
     this.userAccountsService = userAccountsService;
   }
   generateAuthUrl(strategy, params) {
-    logger$4.debug('generateAuthUrl', {
-      strategy,
-      params
-    });
+    logger$4.debug("generateAuthUrl", { strategy, params });
     const strategyInstance = this.strategies[strategy];
     switch (strategyInstance.type) {
-      case 'oauth2':
+      case "oauth2":
         return strategyInstance.oauth2.authorizationCode.authorizeURL(params);
       default:
-        throw new Error('Invalid strategy');
+        throw new Error("Invalid strategy");
     }
   }
   async getTokens(strategy, options) {
-    logger$4.debug('getTokens', {
-      strategy,
-      options
-    });
+    logger$4.debug("getTokens", { strategy, options });
     const strategyInstance = this.strategies[strategy];
     switch (strategyInstance.type) {
-      case 'oauth2':
-        {
-          const result = await strategyInstance.oauth2.authorizationCode.getToken({
+      case "oauth2": {
+        const result = await strategyInstance.oauth2.authorizationCode.getToken(
+          {
             code: options.code,
             redirect_uri: options.redirectUri
-          });
-          if (!result) return result;
-          const tokens = result.token;
-          return {
-            accessToken: tokens.access_token,
-            refreshToken: tokens.refresh_token,
-            tokenType: tokens.token_type,
-            expiresIn: tokens.expires_in,
-            expireDate: (() => {
-              if (tokens.expires_in == null) return null;
-              const d = new Date();
-              d.setTime(d.getTime() + tokens.expires_in * 1000);
-              return d;
-            })(),
-            idToken: tokens.id_token
-          };
-          // return strategyInstance.accessToken.create(result);
-        }
+          }
+        );
+        if (!result) return result;
+        const tokens = result.token;
+        return {
+          accessToken: tokens.access_token,
+          refreshToken: tokens.refresh_token,
+          tokenType: tokens.token_type,
+          expiresIn: tokens.expires_in,
+          expireDate: (() => {
+            if (tokens.expires_in == null) return null;
+            const d = /* @__PURE__ */ new Date();
+            d.setTime(d.getTime() + tokens.expires_in * 1e3);
+            return d;
+          })(),
+          idToken: tokens.id_token
+        };
+      }
       default:
-        throw new Error('Invalid stategy');
+        throw new Error("Invalid stategy");
     }
   }
   async refreshToken(strategy, tokensParam) {
-    logger$4.debug('refreshToken', {
-      strategy
-    });
+    logger$4.debug("refreshToken", { strategy });
     if (!tokensParam.refreshToken) {
-      throw new Error('Missing refresh token');
+      throw new Error("Missing refresh token");
     }
     const strategyInstance = this.strategies[strategy];
     switch (strategyInstance.type) {
-      case 'oauth2':
-        {
-          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,
-            expireDate: (() => {
-              if (tokens.expires_in == null) return null;
-              const d = new Date();
-              d.setTime(d.getTime() + tokens.expires_in * 1000);
-              return d;
-            })(),
-            idToken: tokens.id_token
-          };
-        }
+      case "oauth2": {
+        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,
+          expireDate: (() => {
+            if (tokens.expires_in == null) return null;
+            const d = /* @__PURE__ */ new Date();
+            d.setTime(d.getTime() + tokens.expires_in * 1e3);
+            return d;
+          })(),
+          idToken: tokens.id_token
+        };
+      }
       default:
-        throw new Error('Invalid stategy');
+        throw new Error("Invalid stategy");
     }
   }
   redirectUri(ctx, strategy) {
-    const host = `http${this.config.get('allowHttps') ? 's' : ''}://${ctx.request.host}`;
-    return `${host}${ctx.urlGenerator('authResponse', {
+    const host = `http${this.config.get("allowHttps") ? "s" : ""}://${ctx.request.host}`;
+    return `${host}${ctx.urlGenerator("authResponse", {
       strategy
     })}`;
   }
@@ -173,56 +172,60 @@ class AuthenticationService extends EventEmitter {
     user,
     accountId
   }, params) {
-    logger$4.debug('redirectAuthUrl', {
-      strategy,
-      scopeKey,
-      refreshToken
-    });
+    logger$4.debug("redirectAuthUrl", { strategy, scopeKey, refreshToken });
     const state = await randomHex(8);
-    const scope = this.userAccountsService.getScope(strategy, scopeKey || 'login', user, accountId);
+    const isLoginAccess = !scopeKey || scopeKey === "login";
+    const scope = this.userAccountsService.getScope(
+      strategy,
+      scopeKey || "login",
+      user,
+      accountId
+    );
     if (!scope) {
-      throw new Error('Invalid empty scope');
-    }
-    ctx.cookies.set(`auth_${strategy}_${state}`, JSON.stringify({
-      scopeKey,
-      scope,
-      isLoginAccess: !scopeKey || scopeKey === 'login'
-    }), {
-      maxAge: 600000,
-      httpOnly: true,
-      secure: this.config.get('allowHttps')
-    });
+      throw new Error("Invalid empty scope");
+    }
+    ctx.cookies.set(
+      `auth_${strategy}_${state}`,
+      JSON.stringify({
+        scopeKey,
+        scope,
+        isLoginAccess
+      }),
+      {
+        maxAge: 10 * 60 * 1e3,
+        httpOnly: true,
+        secure: this.config.get("allowHttps")
+      }
+    );
     const redirectUri = this.generateAuthUrl(strategy, {
       redirect_uri: this.redirectUri(ctx, strategy),
       scope,
       state,
-      access_type: refreshToken ? 'offline' : 'online',
+      access_type: refreshToken ? "offline" : "online",
       ...params
     });
     ctx.redirect(redirectUri);
   }
   async accessResponse(ctx, strategy, isLoggedIn, hooks) {
-    const errorParam = ctx.params.queryParam('error').notEmpty();
+    const errorParam = ctx.params.queryParam("error").notEmpty();
     if (errorParam.isValid()) {
-      ctx.throw(errorParam.value, 403);
+      ctx.throw(403, errorParam.value);
     }
-    const code = ctx.validParams.queryParam('code').notEmpty().value;
-    const state = ctx.validParams.queryParam('state').notEmpty().value;
+    const code = ctx.validParams.queryParam("code").notEmpty().value;
+    const state = ctx.validParams.queryParam("state").notEmpty().value;
     const cookieName = `auth_${strategy}_${state}`;
     const cookie = ctx.cookies.get(cookieName);
-    ctx.cookies.set(cookieName, '', {
-      expires: new Date(1)
-    });
+    ctx.cookies.set(cookieName, "", { expires: /* @__PURE__ */ new Date(1) });
     if (!cookie) {
-      throw new Error('No cookie for this state');
+      throw new Error("No cookie for this state");
     }
     const parsedCookie = JSON.parse(cookie);
     if (!parsedCookie?.scope) {
-      throw new Error('Unexpected cookie value');
+      throw new Error("Unexpected cookie value");
     }
     if (!parsedCookie.isLoginAccess) {
       if (!isLoggedIn) {
-        throw new Error('You are not connected');
+        throw new Error("You are not connected");
       }
     }
     const tokens = await this.getTokens(strategy, {
@@ -230,19 +233,32 @@ class AuthenticationService extends EventEmitter {
       redirectUri: this.redirectUri(ctx, strategy)
     });
     if (parsedCookie.isLoginAccess) {
-      const user = await this.userAccountsService.findOrCreateFromStrategy(strategy, tokens, parsedCookie.scope, parsedCookie.scopeKey);
+      const user2 = await this.userAccountsService.findOrCreateFromStrategy(
+        strategy,
+        tokens,
+        parsedCookie.scope,
+        parsedCookie.scopeKey
+      );
       if (hooks.afterLoginSuccess) {
-        await hooks.afterLoginSuccess(strategy, user);
+        await hooks.afterLoginSuccess(strategy, user2);
       }
-      return user;
+      return user2;
     }
     const loggedInUser = ctx.state.loggedInUser;
-    const {
-      account,
-      user
-    } = await this.userAccountsService.update(loggedInUser, strategy, tokens, parsedCookie.scope, parsedCookie.scopeKey);
+    const { account, user } = await this.userAccountsService.update(
+      loggedInUser,
+      strategy,
+      tokens,
+      parsedCookie.scope,
+      parsedCookie.scopeKey
+    );
     if (hooks.afterScopeUpdate) {
-      await hooks.afterScopeUpdate(strategy, parsedCookie.scopeKey, account, user);
+      await hooks.afterScopeUpdate(
+        strategy,
+        parsedCookie.scopeKey,
+        account,
+        user
+      );
     }
     return loggedInUser;
   }
@@ -253,9 +269,8 @@ class AuthenticationService extends EventEmitter {
     return this.refreshToken(account.provider, {
       // accessToken: account.accessToken,
       refreshToken: account.refreshToken
-    }).then(tokens => {
+    }).then((tokens) => {
       if (!tokens) {
-        // serviceGoogle.updateFields({ accessToken:null, refreshToken:null, status: .OUTDATED });
         return false;
       }
       account.accessToken = tokens.accessToken;
@@ -265,53 +280,53 @@ class AuthenticationService extends EventEmitter {
   }
 }
 
-/* eslint-disable @typescript-eslint/no-shadow */
-const logger$3 = new Logger('alp:auth:userAccounts');
+const logger$3 = new Logger("alp:auth:userAccounts");
 const STATUSES = {
-  VALIDATED: 'validated',
-  DELETED: 'deleted'
+  VALIDATED: "validated",
+  DELETED: "deleted"
 };
 class UserAccountsService extends EventEmitter {
+  strategyToService;
+  usersManager;
   constructor(usersManager, strategyToService) {
     super();
     this.usersManager = usersManager;
     this.strategyToService = strategyToService;
   }
   getScope(strategy, scopeKey, user, accountId) {
-    logger$3.debug('getScope', {
-      strategy,
-      userId: user?._id
-    });
+    logger$3.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];
     if (!user || !accountId) {
       return newScope;
     }
-    const account = user.accounts.find(account => account.provider === strategy && account.accountId === accountId);
+    const account = user.accounts.find(
+      (account2) => account2.provider === strategy && account2.accountId === accountId
+    );
     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(user, strategy, tokens, scope, subservice) {
     const service = this.strategyToService[strategy];
     const profile = await service.getProfile(tokens);
     const accountId = service.getId(profile);
-    const account = user.accounts.find(account => account.provider === strategy && account.accountId === accountId);
+    const account = user.accounts.find(
+      (account2) => account2.provider === strategy && account2.accountId === accountId
+    );
     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;
     }
-    if (tokens.expireDate !== undefined) {
+    if (tokens.expireDate !== void 0) {
       account.tokenExpireDate = tokens.expireDate;
     }
     account.scope = service.getScope(account.scope, scope);
@@ -320,24 +335,21 @@ class UserAccountsService extends EventEmitter {
       account.subservices.push(subservice);
     }
     await this.usersManager.replaceOne(user);
-    return {
-      user,
-      account
-    };
+    return { user, account };
   }
   async findOrCreateFromStrategy(strategy, tokens, scope, subservice) {
     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);
     let user = await this.usersManager.findOneByAccountOrEmails({
       provider: service.providerKey,
       accountId,
       emails
     });
-    logger$3.info(!user ? 'create user' : 'existing user', {
+    logger$3.info(!user ? "create user" : "existing user", {
       userId: user?._id,
       accountId
       /*emails , user*/
@@ -351,23 +363,21 @@ class UserAccountsService extends EventEmitter {
       status: STATUSES.VALIDATED
     });
     if (!user.accounts) user.accounts = [];
-    let account = user.accounts.find(account => account.provider === strategy && account.accountId === accountId);
+    let account = user.accounts.find(
+      (account2) => account2.provider === strategy && account2.accountId === accountId
+    );
     if (!account) {
-      account = {
-        provider: strategy,
-        accountId
-      };
-      // @ts-expect-error well...
+      account = { provider: strategy, accountId };
       user.accounts.push(account);
     }
     account.name = service.getAccountName(profile);
-    account.status = 'valid';
+    account.status = "valid";
     account.profile = profile;
     account.accessToken = tokens.accessToken;
     if (tokens.refreshToken) {
       account.refreshToken = tokens.refreshToken;
     }
-    if (tokens.expireDate !== undefined) {
+    if (tokens.expireDate !== void 0) {
       account.tokenExpireDate = tokens.expireDate;
     }
     account.scope = service.getScope(account.scope, scope);
@@ -377,14 +387,18 @@ class UserAccountsService extends EventEmitter {
     }
     if (!user.emails) user.emails = [];
     const userEmails = user.emails;
-    emails.forEach(email => {
+    emails.forEach((email) => {
       if (!userEmails.includes(email)) {
         userEmails.push(email);
       }
     });
     user.emailDomains = [
-    // eslint-disable-next-line unicorn/no-array-reduce
-    ...user.emails.reduce((domains, email) => domains.add(email.split('@', 2)[1]), new Set())];
+      // eslint-disable-next-line unicorn/no-array-reduce
+      ...user.emails.reduce(
+        (domains, email) => domains.add(email.split("@", 2)[1]),
+        /* @__PURE__ */ new Set()
+      )
+    ];
     const keyPath = this.usersManager.store.keyPath;
     if (user[keyPath]) {
       await this.usersManager.replaceOne(user);
@@ -399,14 +413,12 @@ class UserAccountsService extends EventEmitter {
   }
 }
 
-const COOKIE_NAME_TOKEN = 'loggedInUserToken';
-const COOKIE_NAME_STATE = 'loggedInUserState';
+const COOKIE_NAME_TOKEN = "loggedInUserToken";
+const COOKIE_NAME_STATE = "loggedInUserState";
 const getTokenFromRequest = (req, options) => {
-  if (req.headers.authorization?.startsWith('Bearer ')) {
-    return req.headers.authorization.slice(7);
+  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, {
     ...options,
     secure: true
@@ -415,37 +427,36 @@ const getTokenFromRequest = (req, options) => {
 };
 
 const verifyPromisified = promisify(jsonwebtoken.verify);
-const createDecodeJWT = secretKey => async (token, jwtAudience) => {
+const createDecodeJWT = (secretKey) => async (token, jwtAudience) => {
   const result = await verifyPromisified(token, secretKey, {
-    algorithms: ['HS512'],
+    algorithms: ["HS512"],
     audience: jwtAudience
   });
   return result?.loggedInUserId;
 };
 const createFindLoggedInUser = (secretKey, usersManager, logger) => {
   const decodeJwt = createDecodeJWT(secretKey);
-  return async (jwtAudience, token) => {
+  const findLoggedInUser = async (jwtAudience, token) => {
     if (!token || !jwtAudience) return [null, null];
     let loggedInUserId;
     try {
       loggedInUserId = await decodeJwt(token, jwtAudience);
     } catch (error) {
-      logger.debug('failed to verify authentification', {
-        err: error
-      });
+      logger.debug("failed to verify authentification", { err: error });
     }
     if (loggedInUserId == null) return [null, null];
     const loggedInUser = await usersManager.findById(loggedInUserId);
     if (!loggedInUser) return [null, null];
     return [loggedInUserId, loggedInUser];
   };
+  return findLoggedInUser;
 };
 
 class MongoUsersManager {
+  store;
   constructor(store) {
     this.store = store;
   }
-
   /** @deprecated use findById instead */
   findConnected(connected) {
     return this.store.findByKey(connected);
@@ -468,26 +479,25 @@ class MongoUsersManager {
     provider
   }) {
     let query = {
-      'accounts.provider': provider,
-      'accounts.accountId': accountId
+      "accounts.provider": provider,
+      "accounts.accountId": accountId
     };
     if (emails && emails.length > 0) {
       query = {
-        $or: [query, {
-          emails: {
-            $in: emails
+        $or: [
+          query,
+          {
+            emails: { $in: emails }
           }
-        }]
+        ]
       };
     }
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     return this.store.findOne(query);
   }
   updateAccount(user, account) {
     const accountIndex = user.accounts.indexOf(account);
     if (accountIndex === -1) {
-      throw new Error('Invalid account');
+      throw new Error("Invalid account");
     }
     return this.store.partialUpdateOne(user, {
       $set: {
@@ -495,8 +505,6 @@ class MongoUsersManager {
       }
     });
   }
-
-  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   sanitizeBaseUser(user) {
     return {
       _id: user._id,
@@ -507,7 +515,7 @@ class MongoUsersManager {
       status: user.status,
       emails: user.emails,
       emailDomains: user.emailDomains,
-      accounts: user.accounts.map(account => ({
+      accounts: user.accounts.map((account) => ({
         provider: account.provider,
         accountId: account.accountId,
         name: account.name,
@@ -518,20 +526,19 @@ class MongoUsersManager {
   }
 }
 
-/* eslint-disable @typescript-eslint/class-methods-use-this */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-
 class UserAccountGoogleService {
+  scopeKeyToScope;
   constructor(scopeKeyToScope) {
     this.scopeKeyToScope = {
       ...scopeKeyToScope,
-      login: 'openid profile email'
+      login: "openid profile email"
     };
   }
-  providerKey = 'google';
+  providerKey = "google";
   getProfile(tokens) {
-    return fetch(`https://www.googleapis.com/oauth2/v1/userinfo?access_token=${tokens.accessToken}`).then(response => response.json());
+    return fetch(
+      `https://www.googleapis.com/oauth2/v1/userinfo?access_token=${tokens.accessToken}`
+    ).then((response) => response.json());
   }
   getId(profile) {
     return profile.id;
@@ -556,28 +563,28 @@ class UserAccountGoogleService {
     };
   }
   getDefaultScope(newScope) {
-    return this.getScope(undefined, newScope);
+    return this.getScope(void 0, newScope);
   }
   getScope(oldScope, newScope) {
-    return !oldScope ? newScope.split(' ') : [...oldScope, ...newScope.split(' ')].filter((item, i, ar) => ar.indexOf(item) === i);
+    return !oldScope ? newScope.split(" ") : [...oldScope, ...newScope.split(" ")].filter(
+      (item, i, ar) => ar.indexOf(item) === i
+    );
   }
 }
 
-/* eslint-disable @typescript-eslint/class-methods-use-this */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-
-// https://api.slack.com/methods/users.identity
-
 class UserAccountSlackService {
+  scopeKeyToScope;
   constructor(scopeKeyToScope) {
     this.scopeKeyToScope = {
       ...scopeKeyToScope,
-      login: 'identity.basic identity.email identity.avatar'
+      login: "identity.basic identity.email identity.avatar"
     };
   }
-  providerKey = 'google';
+  providerKey = "google";
   getProfile(tokens) {
-    return fetch(`https://slack.com/api/users.identity?token=${tokens.accessToken}`).then(response => response.json());
+    return fetch(
+      `https://slack.com/api/users.identity?token=${tokens.accessToken}`
+    ).then((response) => response.json());
   }
   getId(profile) {
     if (!profile?.team?.id || !profile.user?.id) {
@@ -594,78 +601,73 @@ class UserAccountSlackService {
   getDisplayName(profile) {
     return profile.user.name;
   }
-  getFullName() {
+  getFullName(profile) {
     return null;
   }
   getDefaultScope(newScope) {
-    return this.getScope(undefined, newScope);
+    return this.getScope(void 0, newScope);
   }
   getScope(oldScope, newScope) {
-    return !oldScope ? newScope.split(' ') : [...oldScope, ...newScope.split(' ')].filter((item, i, ar) => ar.indexOf(item) === i);
+    return !oldScope ? newScope.split(" ") : [...oldScope, ...newScope.split(" ")].filter(
+      (item, i, ar) => ar.indexOf(item) === i
+    );
   }
 }
 
-const logger$2 = new Logger('alp:auth');
+const logger$2 = new Logger("alp:auth");
 const authSocketIO = (app, usersManager, io, jwtAudience) => {
-  const findLoggedInUser = createFindLoggedInUser(app.config.get('authentication').get('secretKey'), usersManager, logger$2);
-  const users = new Map();
+  const findLoggedInUser = createFindLoggedInUser(
+    app.config.get("authentication").secretKey,
+    usersManager,
+    logger$2
+  );
+  const users = /* @__PURE__ */ new Map();
   io.users = users;
   io.use(async (socket, next) => {
     const handshakeData = socket.request;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const token = getTokenFromRequest(handshakeData);
     if (!token) return next();
     const [loggedInUserId, loggedInUser] = await findLoggedInUser(
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    jwtAudience || handshakeData.headers['user-agent'], token);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      jwtAudience || handshakeData.headers["user-agent"],
+      token
+    );
     if (!loggedInUserId || !loggedInUser) return next();
     socket.user = loggedInUser;
     users.set(socket.client.id, loggedInUser);
-    socket.on('disconnected', () => users.delete(socket.client.id));
+    socket.on("disconnected", () => users.delete(socket.client.id));
     await next();
   });
 };
 
-const logger$1 = new Logger('alp:auth');
-const getTokenFromReq = req => {
+const logger$1 = new Logger("alp:auth");
+const getTokenFromReq = (req) => {
   if (req.cookies) return req.cookies[COOKIE_NAME_TOKEN];
   return getTokenFromRequest(req);
 };
-
-/*
- * Not tested yet.
- * @internal
- */
 const createAuthApolloContext = (config, usersManager) => {
-  const findLoggedInUser = createFindLoggedInUser(config.get('authentication').get('secretKey'), usersManager, logger$1);
-  return async ({
-    req,
-    connection
-  }) => {
+  const findLoggedInUser = createFindLoggedInUser(
+    config.get("authentication").secretKey,
+    usersManager,
+    logger$1
+  );
+  return async ({ req, connection }) => {
     if (connection?.loggedInUser) {
-      return {
-        user: connection.loggedInUser
-      };
+      return { user: connection.loggedInUser };
     }
     if (!req) return null;
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const token = getTokenFromReq(req);
-    if (!token) return {
-      user: undefined
-    };
+    if (!token) return { user: void 0 };
     const [, loggedInUser] = await findLoggedInUser(
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    req.headers['user-agent'], token);
-    return {
-      user: loggedInUser
-    };
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      req.headers["user-agent"],
+      token
+    );
+    return { user: loggedInUser };
   };
 };
 
-/* eslint-disable max-lines */
-
-const logger = new Logger('alp:auth');
+const logger = new Logger("alp:auth");
 const signPromisified = promisify(jsonwebtoken.sign);
 function init({
   homeRouterKey,
@@ -676,10 +678,16 @@ function init({
   authHooks,
   jwtAudience
 }) {
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  return app => {
-    const userAccountsService = new UserAccountsService(usersManager, strategyToService);
-    const authenticationService = new AuthenticationService(app.config, strategies, userAccountsService);
+  return (app) => {
+    const userAccountsService = new UserAccountsService(
+      usersManager,
+      strategyToService
+    );
+    const authenticationService = new AuthenticationService(
+      app.config,
+      strategies,
+      userAccountsService
+    );
     const controller = createAuthController({
       usersManager,
       authenticationService,
@@ -687,82 +695,80 @@ function init({
       defaultStrategy,
       authHooks
     });
-    app.context.setLoggedIn = async function (loggedInUserId, loggedInUser) {
-      logger.debug('setLoggedIn', {
-        loggedInUser
-      });
+    app.context.setLoggedIn = async function setLoggedIn(loggedInUserId, loggedInUser) {
+      logger.debug("setLoggedIn", { loggedInUser });
       if (!loggedInUserId) {
-        throw new Error('Illegal value for setLoggedIn');
+        throw new Error("Illegal value for setLoggedIn");
       }
       this.state.loggedInUserId = loggedInUserId;
       this.state.loggedInUser = loggedInUser;
-      const token = await signPromisified({
-        loggedInUserId,
-        time: Date.now()
-      }, this.config.get('authentication').get('secretKey'), {
-        algorithm: 'HS512',
-        audience: jwtAudience || this.request.headers['user-agent'],
-        expiresIn: '30 days'
-      });
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      const token = await signPromisified(
+        { loggedInUserId, time: Date.now() },
+        this.config.get("authentication").get("secretKey"),
+        {
+          algorithm: "HS512",
+          audience: jwtAudience || this.request.headers["user-agent"],
+          expiresIn: "30 days"
+        }
+      );
+      const calcExpiresTime = () => {
+        const date = /* @__PURE__ */ new Date();
+        date.setDate(date.getDate() + 30);
+        return date.getTime();
+      };
       this.cookies.set(COOKIE_NAME_TOKEN, token, {
         httpOnly: true,
-        secure: this.config.get('allowHttps')
-      });
-      this.cookies.set(COOKIE_NAME_STATE, JSON.stringify({
-        loggedInUserId,
-        expiresIn: (() => {
-          const date = new Date();
-          date.setDate(date.getDate() + 30);
-          return date.getTime();
-        })()
-      }), {
-        httpOnly: false,
-        secure: this.config.get('allowHttps')
+        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 () {
+    app.context.logout = function logout() {
       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)
-      });
+      this.cookies.set(COOKIE_NAME_TOKEN, "", { expires: /* @__PURE__ */ new Date(1) });
+      this.cookies.set(COOKIE_NAME_STATE, "", { expires: /* @__PURE__ */ new Date(1) });
     };
-    const findLoggedInUser = createFindLoggedInUser(app.config.get('authentication').get('secretKey'), usersManager, logger);
+    const findLoggedInUser = createFindLoggedInUser(
+      app.config.get("authentication").secretKey,
+      usersManager,
+      logger
+    );
     return {
       routes: createRoutes(controller),
-      findLoggedInUserFromRequest: req => {
+      findLoggedInUserFromRequest: (req) => {
         const token = getTokenFromRequest(req);
-        return findLoggedInUser(jwtAudience || req.headers['user-agent'], token);
+        return findLoggedInUser(
+          jwtAudience || req.headers["user-agent"],
+          token
+        );
       },
       findLoggedInUser,
       middleware: async (ctx, next) => {
         const token = ctx.cookies.get(COOKIE_NAME_TOKEN);
-        const userAgent = ctx.request.headers['user-agent'];
-        logger.debug('middleware', {
-          token
-        });
-        const setState = (loggedInUserId, loggedInUser) => {
-          ctx.state.loggedInUserId = loggedInUserId;
-          ctx.state.user = loggedInUser;
-          ctx.sanitizedState.loggedInUserId = loggedInUserId;
-          ctx.sanitizedState.loggedInUser = loggedInUser && usersManager.sanitize(loggedInUser);
+        const userAgent = ctx.request.headers["user-agent"];
+        logger.debug("middleware", { token });
+        const setState = (loggedInUserId2, loggedInUser2) => {
+          ctx.state.loggedInUserId = loggedInUserId2;
+          ctx.state.user = loggedInUser2;
+          ctx.sanitizedState.loggedInUserId = loggedInUserId2;
+          ctx.sanitizedState.loggedInUser = loggedInUser2 && usersManager.sanitize(loggedInUser2);
         };
-        const [loggedInUserId, loggedInUser] = await findLoggedInUser(jwtAudience || userAgent, token);
-        logger.debug('middleware', {
-          loggedInUserId
-        });
+        const [loggedInUserId, loggedInUser] = await findLoggedInUser(
+          jwtAudience || userAgent,
+          token
+        );
+        logger.debug("middleware", { loggedInUserId });
         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)
-            });
+            ctx.cookies.set(COOKIE_NAME_TOKEN, "", { expires: /* @__PURE__ */ new Date(1) });
+            ctx.cookies.set(COOKIE_NAME_STATE, "", { expires: /* @__PURE__ */ new Date(1) });
           }
           setState(null, null);
           return next();
@@ -775,4 +781,4 @@ function init({
 }
 
 export { AuthenticationService, MongoUsersManager, STATUSES, UserAccountGoogleService, UserAccountSlackService, authSocketIO, createAuthApolloContext, init as default };
-//# sourceMappingURL=index-node18.mjs.map
+//# sourceMappingURL=index-node.mjs.map