vimp-engine 0.37.1 → 0.38.0

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

@@ -1,17 +1,42 @@
 import Publisher from '../../../lib/Publisher.js';
 import { decodeJwtPayload } from '../../../lib/jwt.js';
+import { isValidNick } from '../../../lib/validators.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]
+   */
+  constructor(
+    config,
+    {
+      api,
+      pkce,
+      storage = localStorage,
+      sessionStore = sessionStorage,
+      isDev = false,
+      getLocation = () => window.location,
+    } = {},
+  ) {
     if (lobbyAuthModel) {
       return lobbyAuthModel;
     }
@@ -19,167 +44,371 @@ 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._session = null;
+    this._token = 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);
     }
 
-    if (pendingToken) {
-      this._pendingToken = pendingToken;
-      this.publisher.emit('nick-required');
-      return true;
+    this.publisher.emit('loading');
+
+    const cfg = await this._api.clientConfig();
+
+    if (!cfg.ok) {
+      this.publisher.emit('service-error');
+      return;
     }
 
-    this._restore(tokenStorageKey);
-    return false;
+    this._clientConfig = cfg.data;
+
+    // попытка живёт один возврат: любой исход её закрывает
+    const attempt = this._takeAttempt();
+    const { code, error } = this._urlParams;
+
+    this._urlParams = { code: null, error: null, devSession: null };
+
+    const session = this._storage.getItem(sessionStorageKey);
+
+    if (!session) {
+      await this._bootWithoutSession(attempt, code, error);
+      return;
+    }
+
+    this._session = session;
+
+    const res = await this._api.token(session);
+
+    if (res.ok) {
+      this._adopt({ token: res.data.token, profile: res.data.profile });
+      await this._finishLink(attempt, code, error);
+      this._emitAuthenticated();
+    } else if (res.status === 401) {
+      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;
+    }
 
-    return `${this._config.serviceUrl}/oauth/${provider}/start?returnUrl=${encodeURIComponent(returnUrl)}`;
+    this.publisher.emit('welcome', { notice });
+
+    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;
+    }
+  }
+
+  _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._token = token;
+    this._profile = profile;
+  }
+
+  _emitAuthenticated() {
+    this.publisher.emit('authenticated', {
+      nick: this.getNick(),
+      role: this.getRole(),
+      profile: this._profile,
+    });
+  }
+
+  _forgetSession() {
+    this._storage.removeItem(this._config.sessionStorageKey);
+    this._session = null;
+    this._token = null;
+    this._profile = null;
+  }
+
+  validateNick(nick) {
+    return isValidNick(nick);
+  }
+
+  async register(nick, turnstileToken) {
+    const res = await this._api.register({
+      nick,
+      turnstileToken,
+      termsVersion: this._clientConfig.legal.version,
+    });
+
     if (!res.ok) {
-      this.publisher.emit('nick-error', data.error || 'unknown');
-      return;
+      this.publisher.emit('register-error', res.error);
+      return false;
+    }
+
+    this._adopt(res.data);
+    this._emitAuthenticated();
+
+    return true;
+  }
+
+  // URL старта OAuth для Restore; попытка (verifier) остаётся в
+  // sessionStorage вкладки, на auth уходит только challenge
+  async restoreUrl(provider) {
+    return this._oauthUrl('restore', provider);
+  }
+
+  // то же для привязки из панели профиля; consentVersion — версия
+  // согласий, принятых чекбоксами перед переходом
+  async linkUrl(provider, consentVersion) {
+    return this._oauthUrl('link', provider, { consentVersion });
+  }
+
+  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,
+    });
+  }
+
+  // продление identity-токена по сессии; параллельные вызовы делят запрос
+  refresh() {
+    if (!this._refreshing) {
+      this._refreshing = this._refresh().finally(() => {
+        this._refreshing = null;
+      });
+    }
+
+    return this._refreshing;
+  }
+
+  async _refresh() {
+    if (!this._session) {
+      return 'lost';
+    }
+
+    const res = await this._api.token(this._session);
+
+    if (res.ok) {
+      this._token = res.data.token;
+      this._profile = res.data.profile;
+      this.publisher.emit('token-renewed', {
+        expiresAt: this.getTokenExpiresAt(),
+      });
+      return 'ok';
     }
 
-    this._pendingToken = null;
-    this._setIdentity(data.token, this._config.tokenStorageKey);
+    if (res.status === 401) {
+      this._forgetSession();
+      this.publisher.emit('session-lost');
+      return 'lost';
+    }
+
+    return 'retry';
   }
 
-  logout() {
-    delete localStorage[this._config.tokenStorageKey];
+  // итог привязки, завершённой в boot(); отдаётся один раз
+  takeLinkResult() {
+    const result = this._linkResult;
+
+    this._linkResult = null;
 
-    this._identityToken = null;
-    this._nick = null;
+    return result;
+  }
+
+  setProfile(profile) {
+    this._profile = profile;
+    this.publisher.emit('profile-changed', profile);
+  }
 
-    this.publisher.emit('login-required', this._config.providers);
+  // выход и удаление профиля (панель профиля)
+  clearSession() {
+    this._forgetSession();
+  }
+
+  // уведомление для экрана Welcome после перезагрузки страницы
+  setNotice(code) {
+    this._sessionStore.setItem(this._config.noticeKey, code);
   }
 
   getToken() {
-    return this._identityToken;
+    return this._token;
   }
 
   getNick() {
-    return this._nick;
+    return this._profile?.nick ?? null;
   }
 
-  // роль из payload уже проверенного на срок токена (master-game-registry,
-  // этап 4). Это ПОДСКАЗКА ИНТЕРФЕЙСУ — показывать ли кнопку модерации, — а
-  // не право: доступ к данным проверяет мастер по подписи, а запись —
-  // auth-сервис, перечитывая роль из БД
+  // роль из payload токена — ПОДСКАЗКА ИНТЕРФЕЙСУ (показывать ли кнопку
+  // модерации), не право: доступ к данным проверяет мастер по подписи, а
+  // запись — auth-сервис, перечитывая роль из БД
   getRole() {
-    return decodeJwtPayload(this._identityToken)?.role ?? 'user';
+    return decodeJwtPayload(this._token)?.role ?? 'user';
   }
 
   // срок входа (мс эпохи) или null — неизвестен. Вкладка с кончающимся
   // токеном не принимает роль хоста: register_host/reclaim_host предъявят
-  // его мастеру посреди матча (host-migration-review этап 7)
+  // его мастеру посреди матча
   getTokenExpiresAt() {
-    const exp = decodeJwtPayload(this._identityToken)?.exp;
+    const exp = decodeJwtPayload(this._token)?.exp;
 
     return typeof exp === 'number' ? exp * 1000 : null;
   }
 
-  _restore(tokenStorageKey) {
-    const token = localStorage[tokenStorageKey];
-
-    if (token) {
-      this._setIdentity(token, tokenStorageKey, false);
-    } else {
-      this.publisher.emit('login-required', this._config.providers);
-    }
-  }
-
-  // payload JWT не проверяется подписью на клиенте (только для отображения
-  // ника) — авторитетная проверка по /jwks на хосте (Этап B3). exp
-  // проверяется (F5 кодревью) — иначе восстановленная из localStorage сессия
-  // показывает «залогинен» токеном, который хост уже отклонит при входе в игру
-  _setIdentity(token, tokenStorageKey, persist = true) {
-    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',
-        );
-      }
-
-      this.publisher.emit('login-required', this._config.providers);
-      return;
-    }
-
-    this._identityToken = token;
-    this._nick = payload.nick;
+  getProfile() {
+    return this._profile;
+  }
 
-    if (persist) {
-      localStorage[tokenStorageKey] = token;
-    }
+  getClientConfig() {
+    return this._clientConfig;
+  }
 
-    this.publisher.emit('authenticated', { nick: this._nick });
+  getSession() {
+    return this._session;
   }
 }

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

@@ -0,0 +1,142 @@
+import Publisher from '../../../lib/Publisher.js';
+
+// Singleton ProfileModel
+
+let profileModel;
+
+// Модель панели профиля: привязка и отвязка OAuth, выход, выгрузка данных,
+// удаление. Личность и сессию держит LobbyAuthModel, сеть — authApi; сама
+// модель только оркестрирует и сообщает исход событиями.
+//
+// События: profile <profile>, busy <boolean>, export { data, fileName },
+// left (выход или удаление — вкладка меняет личность),
+// error { area: 'link' | 'session' | 'export' | 'delete', code }.
+export default class ProfileModel {
+  /**
+   * @param {Object} config - Блок `profile` конфига лобби.
+   * @param {Object} deps
+   * @param {Object} deps.auth - LobbyAuthModel.
+   * @param {Object} deps.api - client/lib/authApi.js.
+   */
+  constructor(config, { auth, api }) {
+    if (profileModel) {
+      return profileModel;
+    }
+
+    profileModel = this;
+
+    this._config = config;
+    this._auth = auth;
+    this._api = api;
+    this._busy = false;
+
+    this.publisher = new Publisher();
+
+    auth.publisher.on('profile-changed', profile =>
+      this.publisher.emit('profile', profile),
+    );
+  }
+
+  getProfile() {
+    return this._auth.getProfile();
+  }
+
+  getClientConfig() {
+    return this._auth.getClientConfig();
+  }
+
+  // версия согласий — версия условий из /client-config: чекбоксы панели
+  // принимают именно их
+  async linkUrl(provider) {
+    return this._auth.linkUrl(provider, this.getClientConfig().legal.version);
+  }
+
+  takeLinkResult() {
+    return this._auth.takeLinkResult();
+  }
+
+  async unlink(provider) {
+    const data = await this._run('link', () =>
+      this._api.unlinkOauth(this._auth.getSession(), provider),
+    );
+
+    if (data) {
+      this._auth.setProfile(data.profile);
+    }
+  }
+
+  async signOut() {
+    const data = await this._run('session', () =>
+      this._api.logout(this._auth.getSession()),
+    );
+
+    if (data !== undefined) {
+      this._leave('signedOut');
+    }
+  }
+
+  async deleteProfile(confirmNick) {
+    const data = await this._run('delete', () =>
+      this._api.deleteAccount(this._auth.getSession(), confirmNick),
+    );
+
+    if (data !== undefined) {
+      this._leave('deleted');
+    }
+  }
+
+  async exportData() {
+    const data = await this._run('export', () =>
+      this._api.exportData(this._auth.getSession()),
+    );
+
+    if (data) {
+      this.publisher.emit('export', {
+        data,
+        fileName: this._config.exportFileName(this.getProfile().nick),
+      });
+    }
+  }
+
+  // сессия стёрта, уведомление ждёт экран Welcome: дальше вкладка
+  // перезагружается (решение ◆13), состояние по частям не чистится
+  _leave(notice) {
+    this._auth.clearSession();
+    this._auth.setNotice(notice);
+    this.publisher.emit('left');
+  }
+
+  // один запрос за раз; успех — data тела ответа (null у 204); отказ —
+  // undefined и событие error, а при 401 (сессия мертва: профиль удалён в
+  // другой вкладке, срок вышел) — вместо error событие left с уведомлением
+  // profileGone, уже после снятия busy; запрос во время другого не стартует
+  async _run(area, request) {
+    if (this._busy) {
+      return undefined;
+    }
+
+    this._busy = true;
+    this.publisher.emit('busy', true);
+
+    let res;
+
+    try {
+      res = await request();
+    } finally {
+      this._busy = false;
+      this.publisher.emit('busy', false);
+    }
+
+    if (res.ok) {
+      return res.data;
+    }
+
+    if (res.status === 401) {
+      this._leave('profileGone');
+    } else {
+      this.publisher.emit('error', { area, code: res.error });
+    }
+
+    return undefined;
+  }
+}