vimp-engine 0.37.1 → 0.38.1

package/src/client/components/model/LobbyAuth.js

@@ -1,17 +1,45 @@
 import Publisher from '../../../lib/Publisher.js';
 import { decodeJwtPayload } from '../../../lib/jwt.js';
+import { isValidNick } from '../../../lib/validators.js';
+import { isSessionRejected } from '../../lib/authApi.js';
 
 // Singleton LobbyAuthModel
 
 let lobbyAuthModel;
 
-// Модель логина лобби (Этап B2): OAuth-редирект на central auth-сервис
-// (packages/auth), выбор ника при первом входе, identity JWT в localStorage.
-// Хранит состояние сессии и делает единственный сетевой вызов сама (POST
-// /nick) — в отличие от Lobby/Auth-моделей это простой fetch без сигнального
-// сокета, отдельный REST-канал к другому домену.
+const SESSION_RE = /^s_[A-Za-z0-9_-]{43}$/;
+
+// Модель профиля лобби: регистрация ника, сессия устройства, identity-токен
+// (в памяти вкладки), возврат с OAuth (Restore и привязка). Сетевые вызовы —
+// через инъектированный authApi, PKCE — через pkce.
+//
+// События: loading, welcome { notice }, authenticated { nick, role, profile },
+// register-error <код>, restore-error <код>, service-error,
+// token-renewed { expiresAt }, session-lost, profile-changed <profile>.
 export default class LobbyAuthModel {
-  constructor(config) {
+  /**
+   * @param {Object} config - config/authClient.js.
+   * @param {Object} deps
+   * @param {Object} deps.api - client/lib/authApi.js.
+   * @param {Object} deps.pkce - { createVerifier, challengeOf }.
+   * @param {Storage} [deps.storage] - секрет сессии.
+   * @param {Storage} [deps.sessionStore] - попытка OAuth, уведомление.
+   * @param {boolean} [deps.isDev] - принимать ?devSession= (dev-сборка).
+   * @param {Function} [deps.getLocation]
+   * @param {Function} [deps.now] - () → мс эпохи по часам устройства.
+   */
+  constructor(
+    config,
+    {
+      api,
+      pkce,
+      storage = localStorage,
+      sessionStore = sessionStorage,
+      isDev = false,
+      getLocation = () => window.location,
+      now = () => Date.now(),
+    } = {},
+  ) {
     if (lobbyAuthModel) {
       return lobbyAuthModel;
     }
@@ -19,167 +47,406 @@ export default class LobbyAuthModel {
     lobbyAuthModel = this;
 
     this._config = config;
-    this._pendingToken = null;
-    this._identityToken = null;
-    this._nick = null;
+    this._api = api;
+    this._pkce = pkce;
+    this._storage = storage;
+    this._sessionStore = sessionStore;
+    this._isDev = isDev;
+    this._getLocation = getLocation;
+    this._now = now;
+
+    this._session = null;
+    this._token = null;
+    this._tokenExpiresAt = null;
+    this._profile = null;
+    this._clientConfig = null;
+    this._urlParams = { code: null, error: null, devSession: null };
+    this._linkResult = null;
+    this._refreshing = null;
 
     this.publisher = new Publisher();
   }
 
-  // разбирает query-параметры OAuth-редиректа (?token=/?pendingToken=/
-  // ?authError=); при их отсутствии — восстанавливает сессию из localStorage.
-  // Возвращает true, если параметры были найдены и вызывающий должен
-  // подчистить адресную строку (history.replaceState)
-  boot(search) {
-    const { queryParams, tokenStorageKey } = this._config;
+  // читает параметры возврата с OAuth и (в dev-сборке) dev-сессию; true —
+  // что-то найдено, вызывающий чистит адресную строку. Ищет только в search:
+  // колбэк auth собирает адрес через URL.searchParams, поэтому параметры
+  // стоят до #, а hash — маршрут #/<gameId>[/<roomId>] (его разбирает RouteBoot)
+  takeUrlParams(search) {
+    const { oauth, devSessionParam } = this._config;
     const params = new URLSearchParams(search);
 
-    const error = params.get(queryParams.error);
-    const token = params.get(queryParams.token);
-    const pendingToken = params.get(queryParams.pendingToken);
+    this._urlParams = {
+      code: params.get(oauth.codeParam),
+      error: params.get(oauth.errorParam),
+      devSession: this._isDev ? params.get(devSessionParam) : null,
+    };
+
+    const { code, error, devSession } = this._urlParams;
+
+    return Boolean(code || error || devSession);
+  }
 
-    if (error) {
-      this.publisher.emit('login-error', error);
-      this._restore(tokenStorageKey);
-      return true;
+  async boot() {
+    try {
+      await this._boot();
+    } catch {
+      // иначе экран навсегда остался бы на «Loading…» без Retry
+      this.publisher.emit('service-error');
     }
+  }
 
-    if (token) {
-      this._setIdentity(token, tokenStorageKey);
-      return true;
+  async _boot() {
+    const { sessionStorageKey } = this._config;
+    const { devSession } = this._urlParams;
+
+    if (devSession && SESSION_RE.test(devSession)) {
+      this._storage.setItem(sessionStorageKey, devSession);
+    }
+
+    this.publisher.emit('loading');
+
+    // секрет читается до сети: настройки и токен уходят одновременно, лобби
+    // вернувшегося игрока открывается на круг запроса раньше
+    const stored = this._storage.getItem(sessionStorageKey);
+    // значение не того формата секретом не является: на auth не уходит
+    const session = stored && SESSION_RE.test(stored) ? stored : null;
+    const [cfg, res] = await Promise.all([
+      this._api.clientConfig(),
+      session ? this._api.token(session) : null,
+    ]);
+
+    if (!cfg.ok) {
+      this.publisher.emit('service-error');
+      return;
     }
 
-    if (pendingToken) {
-      this._pendingToken = pendingToken;
-      this.publisher.emit('nick-required');
-      return true;
+    this._clientConfig = cfg.data;
+
+    // попытка живёт один возврат: любой исход её закрывает
+    const attempt = this._takeAttempt();
+    const { code, error } = this._urlParams;
+
+    this._urlParams = { code: null, error: null, devSession: null };
+
+    if (!session) {
+      await this._bootWithoutSession(attempt, code, error);
+      return;
     }
 
-    this._restore(tokenStorageKey);
-    return false;
+    this._session = session;
+
+    if (res.ok) {
+      this._adopt({ token: res.data.token, profile: res.data.profile });
+      // уведомление писала вкладка, потерявшая сессию в комнате; под принятой
+      // личностью оно ни к чему и не должно всплыть на Welcome позже
+      this._takeNotice();
+      await this._finishLink(attempt, code, error);
+      this._emitAuthenticated();
+    } else if (isSessionRejected(res)) {
+      this._forgetSession();
+      this.publisher.emit('welcome', { notice: 'profileGone' });
+    } else {
+      // код OAuth одноразовый: Retry доведёт привязку, а не потеряет её
+      this._restoreAttempt(attempt, code, error);
+      this.publisher.emit('service-error');
+    }
   }
 
-  // URL редиректа на старт OAuth-потока auth-сервиса; вызывающий должен сам
-  // сделать переход (window.location.href) — модель не трогает location.
-  // hash (#/<gameId>[/<roomId>]) едет в returnUrl: после логина игрок
-  // попадает туда, куда вёл открытый URL, а не в общее лобби
-  loginUrl(provider) {
-    const { origin, pathname, hash } = window.location;
-    const returnUrl = `${origin}${pathname}${hash}`;
+  async _bootWithoutSession(attempt, code, error) {
+    const notice = this._takeNotice();
+    const restoring = attempt?.mode === 'restore';
+
+    if (restoring && code) {
+      const res = await this._api.restore({
+        code,
+        verifier: attempt.verifier,
+        termsVersion: this._clientConfig.legal.version,
+      });
+
+      if (res.ok) {
+        this._adopt(res.data);
+        this._emitAuthenticated();
+        return;
+      }
+
+      this.publisher.emit('welcome', { notice });
+      this.publisher.emit('restore-error', res.error);
+      return;
+    }
+
+    this.publisher.emit('welcome', { notice });
 
-    return `${this._config.serviceUrl}/oauth/${provider}/start?returnUrl=${encodeURIComponent(returnUrl)}`;
+    if (restoring && error) {
+      this.publisher.emit(
+        'restore-error',
+        error === 'denied' ? 'denied' : 'failed',
+      );
+    }
   }
 
-  async submitNick(nick) {
-    if (!this._pendingToken) {
-      this.publisher.emit('nick-error', 'sessionExpired');
+  // привязка завершается до authenticated, а не в панели профиля: код живёт
+  // 120 с и не должен ждать, пока откроется лобби
+  async _finishLink(attempt, code, error) {
+    if (attempt?.mode !== 'link') {
       return;
     }
 
-    let res;
-    let data;
+    const { provider } = attempt;
 
-    try {
-      res = await fetch(`${this._config.serviceUrl}/nick`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${this._pendingToken}`,
-        },
-        body: JSON.stringify({ nick }),
+    if (code) {
+      const res = await this._api.linkOauth(this._session, {
+        code,
+        verifier: attempt.verifier,
+        consentVersion: attempt.consentVersion,
       });
-      data = await res.json().catch(() => ({}));
+
+      if (res.ok) {
+        this._profile = res.data.profile;
+        this._linkResult = { ok: true, provider };
+      } else {
+        this._linkResult = { ok: false, provider, code: res.error };
+      }
+    } else if (error) {
+      this._linkResult = {
+        ok: false,
+        provider,
+        code: error === 'denied' ? 'denied' : 'failed',
+      };
+    }
+  }
+
+  _restoreAttempt(attempt, code, error) {
+    if (attempt) {
+      this._sessionStore.setItem(
+        this._config.oauth.pendingKey,
+        JSON.stringify(attempt),
+      );
+    }
+
+    this._urlParams = { code, error, devSession: null };
+  }
+
+  _takeAttempt() {
+    const key = this._config.oauth.pendingKey;
+    const raw = this._sessionStore.getItem(key);
+
+    this._sessionStore.removeItem(key);
+
+    try {
+      return raw ? JSON.parse(raw) : null;
     } catch {
-      this.publisher.emit('nick-error', 'network');
-      return;
+      return null;
     }
+  }
 
-    if (!res.ok) {
-      this.publisher.emit('nick-error', data.error || 'unknown');
-      return;
+  _takeNotice() {
+    const key = this._config.noticeKey;
+    const notice = this._sessionStore.getItem(key);
+
+    this._sessionStore.removeItem(key);
+
+    return notice || null;
+  }
+
+  // принять личность: секрет сессии (если пришёл) — в хранилище, токен и
+  // профиль — в память
+  _adopt({ session, token, profile }) {
+    if (session) {
+      this._session = session;
+      this._storage.setItem(this._config.sessionStorageKey, session);
+    }
+
+    this._setToken(token);
+    this._profile = profile;
+  }
+
+  _emitAuthenticated() {
+    this.publisher.emit('authenticated', {
+      nick: this.getNick(),
+      role: this.getRole(),
+      profile: this._profile,
+    });
+  }
+
+  _forgetSession() {
+    const key = this._config.sessionStorageKey;
+
+    // в хранилище может лежать секрет ДРУГОГО профиля: его записала вкладка,
+    // сменившая личность браузера, пока эта доигрывала матч под прежней.
+    // Стирается только свой — у профиля без привязки он единственный ключ
+    if (this._storage.getItem(key) === this._session) {
+      this._storage.removeItem(key);
     }
 
-    this._pendingToken = null;
-    this._setIdentity(data.token, this._config.tokenStorageKey);
+    this._session = null;
+    this._token = null;
+    this._tokenExpiresAt = null;
+    this._profile = null;
   }
 
-  logout() {
-    delete localStorage[this._config.tokenStorageKey];
+  validateNick(nick) {
+    return isValidNick(nick);
+  }
 
-    this._identityToken = null;
-    this._nick = null;
+  async register(nick, turnstileToken) {
+    const res = await this._api.register({
+      nick,
+      turnstileToken,
+      termsVersion: this._clientConfig.legal.version,
+    });
 
-    this.publisher.emit('login-required', this._config.providers);
+    if (!res.ok) {
+      this.publisher.emit('register-error', res.error);
+      return false;
+    }
+
+    this._adopt(res.data);
+    this._emitAuthenticated();
+
+    return true;
   }
 
-  getToken() {
-    return this._identityToken;
+  // URL старта OAuth для Restore; попытка (verifier) остаётся в
+  // sessionStorage вкладки, на auth уходит только challenge
+  async restoreUrl(provider) {
+    return this._oauthUrl('restore', provider);
   }
 
-  getNick() {
-    return this._nick;
+  // то же для привязки из панели профиля; consentVersion — версия
+  // согласий, принятых чекбоксами перед переходом
+  async linkUrl(provider, consentVersion) {
+    return this._oauthUrl('link', provider, { consentVersion });
   }
 
-  // роль из payload уже проверенного на срок токена (master-game-registry,
-  // этап 4). Это ПОДСКАЗКА ИНТЕРФЕЙСУ — показывать ли кнопку модерации, — а
-  // не право: доступ к данным проверяет мастер по подписи, а запись —
-  // auth-сервис, перечитывая роль из БД
-  getRole() {
-    return decodeJwtPayload(this._identityToken)?.role ?? 'user';
+  async _oauthUrl(mode, provider, extra = {}) {
+    const verifier = this._pkce.createVerifier();
+    const challenge = await this._pkce.challengeOf(verifier);
+    const { origin, pathname, hash } = this._getLocation();
+
+    this._sessionStore.setItem(
+      this._config.oauth.pendingKey,
+      JSON.stringify({ mode, provider, verifier, ...extra }),
+    );
+
+    // hash (#/<gameId>[/<roomId>]) едет в returnUrl: после возврата игрок
+    // попадает туда, куда вёл открытый адрес
+    return this._api.oauthStartUrl(provider, {
+      mode,
+      returnUrl: `${origin}${pathname}${hash}`,
+      challenge,
+    });
   }
 
-  // срок входа (мс эпохи) или null — неизвестен. Вкладка с кончающимся
-  // токеном не принимает роль хоста: register_host/reclaim_host предъявят
-  // его мастеру посреди матча (host-migration-review этап 7)
-  getTokenExpiresAt() {
-    const exp = decodeJwtPayload(this._identityToken)?.exp;
+  // продление identity-токена по сессии; параллельные вызовы делят запрос
+  refresh() {
+    if (!this._refreshing) {
+      this._refreshing = this._refresh().finally(() => {
+        this._refreshing = null;
+      });
+    }
 
-    return typeof exp === 'number' ? exp * 1000 : null;
+    return this._refreshing;
   }
 
-  _restore(tokenStorageKey) {
-    const token = localStorage[tokenStorageKey];
+  async _refresh() {
+    if (!this._session) {
+      return 'lost';
+    }
 
-    if (token) {
-      this._setIdentity(token, tokenStorageKey, false);
-    } else {
-      this.publisher.emit('login-required', this._config.providers);
+    const res = await this._api.token(this._session);
+
+    if (res.ok) {
+      this._setToken(res.data.token);
+      this._profile = res.data.profile;
+      this.publisher.emit('token-renewed', {
+        expiresAt: this.getTokenExpiresAt(),
+      });
+      return 'ok';
     }
+
+    if (isSessionRejected(res)) {
+      this._forgetSession();
+      this.publisher.emit('session-lost');
+      return 'lost';
+    }
+
+    return 'retry';
+  }
+
+  // итог привязки, завершённой в boot(); отдаётся один раз
+  takeLinkResult() {
+    const result = this._linkResult;
+
+    this._linkResult = null;
+
+    return result;
   }
 
-  // payload JWT не проверяется подписью на клиенте (только для отображения
-  // ника) — авторитетная проверка по /jwks на хосте (Этап B3). exp
-  // проверяется (F5 кодревью) — иначе восстановленная из localStorage сессия
-  // показывает «залогинен» токеном, который хост уже отклонит при входе в игру
-  _setIdentity(token, tokenStorageKey, persist = true) {
+  setProfile(profile) {
+    this._profile = profile;
+    this.publisher.emit('profile-changed', profile);
+  }
+
+  // выход и удаление профиля (панель профиля)
+  clearSession() {
+    this._forgetSession();
+  }
+
+  // уведомление для экрана Welcome после перезагрузки страницы
+  setNotice(code) {
+    this._sessionStore.setItem(this._config.noticeKey, code);
+  }
+
+  getToken() {
+    return this._token;
+  }
+
+  getNick() {
+    return this._profile?.nick ?? null;
+  }
+
+  // роль из payload токена — ПОДСКАЗКА ИНТЕРФЕЙСУ (показывать ли кнопку
+  // модерации), не право: права админа auth-сервис проверяет сам, по нику
+  // из VIMP_ADMIN_NICKS
+  getRole() {
+    return decodeJwtPayload(this._token)?.role ?? 'user';
+  }
+
+  // Срок токена в шкале часов УСТРОЙСТВА: момент получения плюс время жизни
+  // из самого токена (exp − iat — оба выставлены часами auth-сервиса).
+  // Сдвиг часов устройства на срок не влияет. Токен без iat — срок по exp
+  _setToken(token) {
     const payload = decodeJwtPayload(token);
-    const isExpired =
-      typeof payload?.exp === 'number' && Date.now() >= payload.exp * 1000;
-
-    if (!payload || !payload.nick || isExpired) {
-      delete localStorage[tokenStorageKey];
-
-      // Тихое восстановление из localStorage (persist === false): просроченный/
-      // битый токен — штатная ситуация возврата на сайт, не ошибка. login-error
-      // — только на интерактивном пути.
-      if (persist) {
-        this.publisher.emit(
-          'login-error',
-          isExpired ? 'tokenExpired' : 'invalidToken',
-        );
-      }
+    const exp = payload?.exp;
+    const iat = payload?.iat;
 
-      this.publisher.emit('login-required', this._config.providers);
-      return;
+    this._token = token;
+
+    if (typeof exp !== 'number') {
+      this._tokenExpiresAt = null;
+    } else if (typeof iat === 'number' && exp > iat) {
+      this._tokenExpiresAt = this._now() + (exp - iat) * 1000;
+    } else {
+      this._tokenExpiresAt = exp * 1000;
     }
+  }
 
-    this._identityToken = token;
-    this._nick = payload.nick;
+  // срок входа (мс эпохи по часам устройства) или null — неизвестен.
+  // Вкладка с кончающимся токеном не принимает роль хоста:
+  // register_host/reclaim_host предъявят его мастеру посреди матча
+  getTokenExpiresAt() {
+    return this._tokenExpiresAt;
+  }
 
-    if (persist) {
-      localStorage[tokenStorageKey] = token;
-    }
+  getProfile() {
+    return this._profile;
+  }
+
+  getClientConfig() {
+    return this._clientConfig;
+  }
 
-    this.publisher.emit('authenticated', { nick: this._nick });
+  getSession() {
+    return this._session;
   }
 }