alp-node-auth 11.0.0 → 12.0.1

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

@@ -16,7 +16,7 @@ function createAuthController({
     async login(ctx) {
       const strategy = ctx.namedRouteParam("strategy") || defaultStrategy;
       if (!strategy) throw new Error("Strategy missing");
-      const params = authHooks.paramsForLogin && (await authHooks.paramsForLogin(strategy, ctx)) || {};
+      const params = authHooks.paramsForLogin && await authHooks.paramsForLogin(strategy, ctx) || {};
       await authenticationService.redirectAuthUrl(ctx, strategy, {}, params);
     },
     /**
@@ -32,17 +32,22 @@ function createAuthController({
       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
-      });
+      await authenticationService.redirectAuthUrl(ctx, strategy, { scopeKey });
     },
     async response(ctx) {
-      const strategy = ctx.namedRouteParam("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);
@@ -55,11 +60,14 @@ function createAuthController({
   };
 }
 
-const createRoutes = controller => ({
-  login: ["/login/:strategy?", segment => {
-    segment.add("/response", controller.response, "authResponse");
-    segment.defaultRoute(controller.login, "login");
-  }],
+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]
 });
@@ -70,12 +78,11 @@ async function randomHex(size) {
   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 */
 const logger$4 = new Logger("alp:auth:authentication");
 class AuthenticationService extends EventEmitter {
+  config;
+  strategies;
+  userAccountsService;
   constructor(config, strategies, userAccountsService) {
     super();
     this.config = config;
@@ -83,10 +90,7 @@ 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":
@@ -96,68 +100,62 @@ class AuthenticationService extends EventEmitter {
     }
   }
   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");
     }
   }
   async refreshToken(strategy, tokensParam) {
-    logger$4.debug("refreshToken", {
-      strategy
-    });
+    logger$4.debug("refreshToken", { strategy });
     if (!tokensParam.refreshToken) {
       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");
     }
@@ -174,25 +172,31 @@ 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")
-    });
+    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,
@@ -211,9 +215,7 @@ class AuthenticationService extends EventEmitter {
     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");
     }
@@ -231,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;
   }
@@ -254,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;
@@ -272,16 +286,15 @@ const STATUSES = {
   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");
@@ -290,7 +303,9 @@ class UserAccountsService extends EventEmitter {
     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");
     }
@@ -300,10 +315,10 @@ class UserAccountsService extends EventEmitter {
     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");
     }
     account.status = "valid";
@@ -311,7 +326,7 @@ class UserAccountsService extends EventEmitter {
     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,10 +335,7 @@ 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];
@@ -351,12 +363,11 @@ 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
-      };
+      account = { provider: strategy, accountId };
       user.accounts.push(account);
     }
     account.name = service.getAccountName(profile);
@@ -366,7 +377,7 @@ class UserAccountsService extends EventEmitter {
     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);
@@ -376,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);
@@ -402,10 +417,8 @@ 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);
+    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
@@ -414,7 +427,7 @@ 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"],
     audience: jwtAudience
@@ -423,28 +436,27 @@ const createDecodeJWT = secretKey => async (token, jwtAudience) => {
 };
 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);
@@ -472,15 +484,14 @@ class MongoUsersManager {
     };
     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) {
@@ -504,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,
@@ -515,10 +526,8 @@ class MongoUsersManager {
   }
 }
 
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-
 class UserAccountGoogleService {
+  scopeKeyToScope;
   constructor(scopeKeyToScope) {
     this.scopeKeyToScope = {
       ...scopeKeyToScope,
@@ -527,8 +536,9 @@ class UserAccountGoogleService {
   }
   providerKey = "google";
   getProfile(tokens) {
-    // eslint-disable-next-line n/no-unsupported-features/node-builtins
-    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;
@@ -553,18 +563,17 @@ 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/explicit-module-boundary-types */
-
-// https://api.slack.com/methods/users.identity
-
 class UserAccountSlackService {
+  scopeKeyToScope;
   constructor(scopeKeyToScope) {
     this.scopeKeyToScope = {
       ...scopeKeyToScope,
@@ -573,8 +582,9 @@ class UserAccountSlackService {
   }
   providerKey = "google";
   getProfile(tokens) {
-    // eslint-disable-next-line n/no-unsupported-features/node-builtins
-    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) {
@@ -591,30 +601,37 @@ 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 authSocketIO = (app, usersManager, io, jwtAudience) => {
-  const findLoggedInUser = createFindLoggedInUser(app.config.get("authentication").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);
@@ -624,39 +641,29 @@ const authSocketIO = (app, usersManager, io, jwtAudience) => {
 };
 
 const logger$1 = new Logger("alp:auth");
-const getTokenFromReq = req => {
+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").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 };
   };
 };
 
@@ -671,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,
@@ -683,80 +696,79 @@ function init({
       authHooks
     });
     app.context.setLoggedIn = async function setLoggedIn(loggedInUserId, loggedInUser) {
-      logger.debug("setLoggedIn", {
-        loggedInUser
-      });
+      logger.debug("setLoggedIn", { loggedInUser });
       if (!loggedInUserId) {
         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"
-      });
+      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")
-      });
+      this.cookies.set(
+        COOKIE_NAME_STATE,
+        JSON.stringify({ loggedInUserId, expiresIn: calcExpiresTime() }),
+        {
+          httpOnly: false,
+          secure: this.config.get("allowHttps")
+        }
+      );
     };
     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").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);
+        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();
@@ -769,4 +781,4 @@ function init({
 }
 
 export { AuthenticationService, MongoUsersManager, STATUSES, UserAccountGoogleService, UserAccountSlackService, authSocketIO, createAuthApolloContext, init as default };
-//# sourceMappingURL=index-node20.mjs.map
+//# sourceMappingURL=index-node.mjs.map