vimp-engine 0.24.1 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vimp-engine",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "VIMP — движок-приложение (мастер, P2P-транспорт, Worker-хост, мета, MVC-каркас клиента)",
   "license": "MIT",
   "repository": {
@@ -46,6 +46,7 @@
     "express": "^5.1.0",
     "howler": "^2.2.4",
     "pixi.js": "8.19.0",
+    "tar": "^7.5.1",
     "uuid": "^13.0.0",
     "vite-express": "^0.21.1",
     "ws": "^8.18.3"

package/src/client/components/controller/Games.js

@@ -0,0 +1,99 @@
+import Publisher from '../../../lib/Publisher.js';
+
+// Singleton GamesCtrl
+
+let gamesCtrl;
+
+// Контроллер реестра игр: связывает view-события с моделью, как LobbyCtrl.
+// Собственного сетевого I/O не делает. Наружу (main.js) пробрасывает только
+// 'staged' — манифест застейдженной версии, который нужно положить в каталог
+// вкладки, чтобы админ мог поднять по нему комнату
+export default class GamesCtrl {
+  constructor(model, view) {
+    if (gamesCtrl) {
+      return gamesCtrl;
+    }
+
+    gamesCtrl = this;
+
+    this._model = model;
+    this._view = view;
+
+    this.publisher = new Publisher();
+
+    const vp = view.publisher;
+
+    vp.on('open-mine', 'openMine', this);
+    vp.on('open-moderation', 'openModeration', this);
+    vp.on('submit', 'submit', this);
+    vp.on('update-version', 'updateVersion', this);
+    vp.on('filter', 'filter', this);
+    vp.on('stage', 'stage', this);
+    vp.on('approve', 'approve', this);
+    vp.on('reject', 'reject', this);
+    vp.on('disable', 'disable', this);
+    vp.on('load-versions', 'loadVersions', this);
+
+    model.publisher.on('staged', 'staged', this);
+  }
+
+  // роль решает только видимость кнопки модерации: доступ к данным
+  // проверяет мастер, а запись — auth-сервис по роли из БД
+  setAdmin(isAdmin) {
+    this._view.setAdmin(isAdmin);
+
+    // черновики, уже скачанные этим мастером, возвращаются в каталог вкладки
+    // сразу: после матча лобби перезагружает страницу, и без этого админ
+    // терял бы из селектора версию, которую сам же поставил на тест
+    if (isAdmin) {
+      this._model.loadStaged();
+    }
+  }
+
+  openMine() {
+    this._view.show(false);
+    this._model.loadMine();
+  }
+
+  openModeration() {
+    this._view.show(true);
+    this._model.loadMine();
+    this._model.loadAdmin();
+  }
+
+  submit(form) {
+    this._model.submit(form);
+  }
+
+  updateVersion({ id, version }) {
+    this._model.requestVersion(id, version);
+  }
+
+  filter(status) {
+    this._model.setFilter(status);
+  }
+
+  stage({ id, version }) {
+    this._model.stage(id, version);
+  }
+
+  approve({ id }) {
+    this._model.moderate(id, { status: 'approved' });
+  }
+
+  reject({ id, note }) {
+    this._model.moderate(id, { status: 'rejected', note });
+  }
+
+  disable({ id }) {
+    this._model.moderate(id, { status: 'disabled' });
+  }
+
+  loadVersions({ id }) {
+    this._model.loadVersions(id);
+  }
+
+  staged(data) {
+    this.publisher.emit('staged', data);
+  }
+}

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

@@ -0,0 +1,209 @@
+import Publisher from '../../../lib/Publisher.js';
+
+// Singleton GamesModel
+
+let gamesModel;
+
+// коды отказов мастера и auth-сервиса — единственное, что приезжает вместо
+// текста; человеческая формулировка живёт во view, как в LobbyAuthView
+const REQUEST_FAILED = 'requestFailed';
+
+// Модель реестра игр в лобби (master-game-registry, этап 4): заявки
+// вызывающего, очередь модерации и «Test» новой версии. В отличие от
+// LobbyModel сетевые запросы делает сама — это простой REST к мастеру,
+// сигнальный сокет здесь ни при чём (тот же приём, что у LobbyAuthModel с
+// POST /nick). DOM не трогает.
+export default class GamesModel {
+  /**
+   * @param {Object} config - Блок `games` конфига лобби (urls, statuses).
+   * @param {Function} getToken - Возвращает identity-токен лобби.
+   */
+  constructor(config, getToken) {
+    if (gamesModel) {
+      return gamesModel;
+    }
+
+    gamesModel = this;
+
+    this._config = config;
+    this._getToken = getToken;
+
+    this._mine = [];
+    this._all = [];
+    this._versions = new Map(); // id игры -> версии, опубликованные в npm
+    this._filter = config.defaultStatus;
+
+    this.publisher = new Publisher();
+  }
+
+  getFilter() {
+    return this._filter;
+  }
+
+  // фильтр очереди модерации: строки уже загружены, повторный запрос не нужен
+  setFilter(status) {
+    this._filter = status;
+    this._emitAdmin();
+  }
+
+  async loadMine() {
+    const { ok, json } = await this._request(this._config.urls.mine);
+
+    if (!ok) {
+      this._fail('mine', json);
+      return;
+    }
+
+    this._mine = json.games ?? [];
+    this.publisher.emit('mine-changed', this._mine);
+  }
+
+  // застейдженные версии, уже лежащие на этом мастере: после перезагрузки
+  // вкладки (а lobby-режим перезагружает её после каждого матча) черновик
+  // иначе исчезал бы из селектора, оставаясь скачанным
+  async loadStaged() {
+    const { ok, json } = await this._request(this._config.urls.staged);
+
+    if (!ok) {
+      return;
+    }
+
+    (json.manifests ?? []).forEach(({ id, version, manifest }) => {
+      this.publisher.emit('staged', { id, version, manifest });
+    });
+  }
+
+  async loadAdmin() {
+    const { ok, json } = await this._request(this._config.urls.admin);
+
+    if (!ok) {
+      this._fail('admin', json);
+      return;
+    }
+
+    this._all = json.games ?? [];
+    this._emitAdmin();
+  }
+
+  // список опубликованных версий пакета: индикатор «есть версия новее
+  // раздаваемой». Запрашивается по игре, а не для всей очереди сразу —
+  // каждый ответ стоит похода мастера в npm registry
+  async loadVersions(id) {
+    const { ok, json } = await this._request(this._config.urls.versions(id));
+
+    if (!ok) {
+      return;
+    }
+
+    this._versions.set(id, json.versions ?? []);
+    this._emitAdmin();
+  }
+
+  async submit(form) {
+    const { ok, json } = await this._request(this._config.urls.submit, {
+      method: 'POST',
+      body: form,
+    });
+
+    if (!ok) {
+      this._fail('mine', json);
+      return;
+    }
+
+    // отдельным событием, а не внутри loadMine: список перерисовывается и
+    // при открытии панели, а чистить форму нужно ровно на успехе отправки —
+    // иначе повторная отправка того же содержимого выглядит как «кнопка не
+    // сработала» (ответ gameExists при заполненных полях)
+    this.publisher.emit('submitted');
+
+    await this.loadMine();
+  }
+
+  async requestVersion(id, version) {
+    const { ok, json } = await this._request(this._config.urls.version(id), {
+      method: 'POST',
+      body: { version },
+    });
+
+    if (!ok) {
+      this._fail('mine', json);
+      return;
+    }
+
+    await this.loadMine();
+  }
+
+  // «Test»: мастер качает версию и кладёт её в каталог не раздаваемой.
+  // Манифест едет наружу — по нему вкладка админа поднимает комнату
+  async stage(id, version) {
+    const { ok, json } = await this._request(this._config.urls.stage(id), {
+      method: 'POST',
+      body: { version },
+    });
+
+    if (!ok) {
+      this._fail('admin', json);
+      return;
+    }
+
+    this.publisher.emit('staged', { id, version: json.version, manifest: json.manifest });
+    await this.loadAdmin();
+  }
+
+  async moderate(id, patch) {
+    const { ok, json } = await this._request(this._config.urls.moderate(id), {
+      method: 'PATCH',
+      body: patch,
+    });
+
+    if (!ok) {
+      this._fail('admin', json);
+      return;
+    }
+
+    await this.loadAdmin();
+  }
+
+  _emitAdmin() {
+    this.publisher.emit('admin-changed', {
+      games: this._all.filter(game => game.status === this._filter),
+      filter: this._filter,
+      versions: this._versions,
+    });
+  }
+
+  // ошибки приезжают двумя формами: список проблем пакета от мастера
+  // ({errors: [...]}, структурная проверка до записи в реестр) и код отказа
+  // auth-сервиса ({error: '...'}). Наружу уходит одна
+  _fail(scope, json) {
+    const errors = Array.isArray(json?.errors)
+      ? json.errors.map(error => ({ name: 'package', error }))
+      : [{ name: 'request', error: json?.error ?? REQUEST_FAILED }];
+
+    this.publisher.emit('error', { scope, errors });
+  }
+
+  async _request(url, { method = 'GET', body } = {}) {
+    const token = this._getToken();
+
+    if (!token) {
+      return { ok: false, json: { error: 'unauthorized' } };
+    }
+
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: {
+          authorization: `Bearer ${token}`,
+          ...(body ? { 'content-type': 'application/json' } : {}),
+        },
+        body: body ? JSON.stringify(body) : undefined,
+      });
+      const json = await res.json().catch(() => null);
+
+      return { ok: res.ok, json };
+    } catch {
+      return { ok: false, json: { error: 'network' } };
+    }
+  }
+}

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

@@ -117,6 +117,14 @@ export default class LobbyAuthModel {
     return this._nick;
   }
 
+  // роль из payload уже проверенного на срок токена (master-game-registry,
+  // этап 4). Это ПОДСКАЗКА ИНТЕРФЕЙСУ — показывать ли кнопку модерации, — а
+  // не право: доступ к данным проверяет мастер по подписи, а запись —
+  // auth-сервис, перечитывая роль из БД
+  getRole() {
+    return decodeJwtPayload(this._identityToken)?.role ?? 'user';
+  }
+
   _restore(tokenStorageKey) {
     const token = localStorage[tokenStorageKey];
 

package/src/client/components/view/Games.js

@@ -0,0 +1,341 @@
+import Publisher from '../../../lib/Publisher.js';
+import { renderFormErrors } from '../../lib/formBuilder.js';
+
+// Singleton GamesView
+
+let gamesView;
+
+// коды отказов мастера/auth — человеческая формулировка живёт здесь, как в
+// LobbyAuthView: модель кодов не переводит, view не ходит в сеть.
+// Язык интерфейса — английский, как и в остальном лобби
+const ERROR_MESSAGES = {
+  unauthorized: 'Please sign in again',
+  forbidden: 'Not enough rights',
+  network: 'Network unavailable, try again',
+  requestFailed: 'Request failed',
+  // лимитер мастера (5 заявок в минуту на пользователя) считает и заявки,
+  // отклонённые по формату, — без своей строки код уезжал бы в интерфейс сырым
+  tooManyRequests: 'Too many requests, try again in a minute',
+  gameExists: 'A game with this id already exists',
+  tooManyGames: 'Too many submissions from one author',
+  unknownGame: 'Game is not in the registry',
+  invalidGameId: 'Invalid game id',
+  invalidPackageName: 'Invalid npm package name',
+  invalidVersion: 'Invalid version',
+  invalidTitle: 'Invalid title',
+  invalidRepoUrl: 'Invalid repository URL',
+  invalidMaxGameScore: 'Invalid score cap',
+  authServiceUnavailable: 'Registry service unavailable',
+};
+
+const STATUS_TITLES = {
+  pending: 'in review',
+  approved: 'published',
+  rejected: 'rejected',
+  disabled: 'disabled',
+};
+
+// Представление реестра игр: списки заявок и очереди модерации, фильтры,
+// строки ошибок. В сеть не ходит и состояния не держит — рисует то, что
+// пришло событием модели, и публикует намерения пользователя
+export default class GamesView {
+  /**
+   * @param {Object} model - GamesModel (источник событий).
+   * @param {Object} config - Блок `games` конфига лобби.
+   */
+  constructor(model, config) {
+    if (gamesView) {
+      return gamesView;
+    }
+
+    gamesView = this;
+
+    const { elems } = config;
+
+    this._config = config;
+    this._elems = elems;
+
+    this._panel = document.getElementById(elems.panelId);
+    this._lobby = document.getElementById(elems.lobbyId);
+    this._openMine = document.getElementById(elems.openMineBtnId);
+    this._openModeration = document.getElementById(elems.openModerationBtnId);
+    this._close = document.getElementById(elems.closeBtnId);
+
+    this._mineList = document.getElementById(elems.mineListId);
+    this._submitForm = document.getElementById(elems.submitFormId);
+    this._submitError = document.getElementById(elems.submitErrorId);
+
+    this._moderation = document.getElementById(elems.moderationId);
+    this._adminList = document.getElementById(elems.adminListId);
+    this._adminError = document.getElementById(elems.adminErrorId);
+    this._filters = document.getElementById(elems.filtersId);
+
+    this._fields = new Map(
+      Object.entries(elems.fieldIds).map(([name, id]) => [
+        name,
+        document.getElementById(id),
+      ]),
+    );
+
+    this.publisher = new Publisher();
+
+    this._openMine.onclick = () => this.publisher.emit('open-mine');
+    this._openModeration.onclick = () => this.publisher.emit('open-moderation');
+    this._close.onclick = () => this.hide();
+
+    this._submitForm.onsubmit = e => {
+      e.preventDefault();
+      this.publisher.emit('submit', this._readForm());
+    };
+
+    this._renderFilters();
+
+    const mp = model.publisher;
+
+    mp.on('submitted', 'clearForm', this);
+    mp.on('mine-changed', 'renderMine', this);
+    mp.on('admin-changed', 'renderAdmin', this);
+    mp.on('error', 'renderError', this);
+  }
+
+  // кнопку модерации показывает не сама панель, а роль вызывающего
+  // (main.js по LobbyAuthModel.getRole())
+  setAdmin(isAdmin) {
+    this._openModeration.style.display = isAdmin ? '' : 'none';
+  }
+
+  show(moderation = false) {
+    this._panel.style.display = 'flex';
+    this._lobby.style.display = 'none';
+    this._moderation.style.display = moderation ? 'block' : 'none';
+  }
+
+  hide() {
+    // закрытой панели закрывать нечего: возврат черновиков после
+    // перезагрузки идёт тем же событием 'staged', что и «Test», и не должен
+    // трогать разметку лобби
+    if (this._panel.style.display === 'none') {
+      return;
+    }
+
+    this._panel.style.display = 'none';
+    this._lobby.style.display = 'flex';
+  }
+
+  // заявка ушла — поля пустые: следующая отправка начинается с чистой формы
+  clearForm() {
+    this._fields.forEach(field => {
+      field.value = '';
+    });
+  }
+
+  renderMine(games) {
+    this._submitError.textContent = '';
+    this._mineList.textContent = '';
+
+    (games || []).forEach(game => {
+      const item = document.createElement('li');
+
+      item.className = 'games-item';
+      item.appendChild(
+        this._line(
+          `${game.title ? `${game.title} · ` : ''}${game.id} — ` +
+            `${game.packageName} @ ${game.version ?? '—'}`,
+          'games-item-title',
+        ),
+      );
+      item.appendChild(this._line(this._statusLine(game)));
+      this._appendRepo(item, game.repoUrl);
+
+      if (game.moderatorNote) {
+        item.appendChild(this._line(`Note: ${game.moderatorNote}`));
+      }
+
+      // заявка на новую версию своей игры: поле рядом со строкой, а не
+      // отдельной формой — версия относится к конкретной заявке
+      const version = document.createElement('input');
+      const send = document.createElement('input');
+
+      version.type = 'text';
+      version.className = 'field-text games-version-input';
+      version.placeholder = 'New version';
+      send.type = 'button';
+      send.value = 'Update version';
+      send.onclick = () =>
+        this.publisher.emit('update-version', { id: game.id, version: version.value.trim() });
+
+      item.appendChild(version);
+      item.appendChild(send);
+      this._mineList.appendChild(item);
+    });
+  }
+
+  renderAdmin({ games, filter, versions }) {
+    this._adminError.textContent = '';
+    this._adminList.textContent = '';
+    this._markFilter(filter);
+
+    (games || []).forEach(game => {
+      this._adminList.appendChild(this._adminItem(game, versions));
+    });
+  }
+
+  renderError({ scope, errors }) {
+    const container = scope === 'admin' ? this._adminError : this._submitError;
+
+    renderFormErrors(
+      container,
+      errors.map(({ name, error }) => ({
+        name,
+        label: name,
+        error: ERROR_MESSAGES[error] ?? error,
+      })),
+    );
+  }
+
+  _adminItem(game, versions) {
+    const item = document.createElement('li');
+    const published = versions?.get(game.id) ?? [];
+    const latest = published[published.length - 1];
+
+    item.className = 'games-item';
+    item.appendChild(
+      this._line(
+        `${game.title ? `${game.title} · ` : ''}${game.id} — ${game.packageName}`,
+        'games-item-title',
+      ),
+    );
+    // у игр, засеянных миграцией, автора нет вовсе: без запасного прочерка
+    // в строке печаталось бы литеральное "null"
+    item.appendChild(this._line(`Author: ${game.authorNick ?? game.authorUserId ?? '—'}`));
+    this._appendRepo(item, game.repoUrl);
+    item.appendChild(
+      this._line(
+        `Served: ${game.version ?? '—'}; requested: ${game.pendingVersion ?? '—'}` +
+          (latest ? `; in npm: ${latest}` : ''),
+      ),
+    );
+    item.appendChild(this._line(this._statusLine(game)));
+
+    if (game.local) {
+      item.appendChild(
+        this._line(
+          `On this master: ${game.local.downloaded ? 'downloaded' : 'not downloaded'}` +
+            (game.local.stagedVersion ? `; staged ${game.local.stagedVersion}` : '') +
+            (game.local.lastError ? `; error: ${game.local.lastError}` : ''),
+        ),
+      );
+    }
+
+    const note = document.createElement('input');
+
+    note.type = 'text';
+    note.className = 'field-text games-note-input';
+    note.placeholder = 'Rejection reason';
+
+    item.appendChild(note);
+    item.appendChild(
+      this._button('Test', () =>
+        this.publisher.emit('stage', {
+          id: game.id,
+          version: game.pendingVersion ?? game.version,
+        }),
+      ),
+    );
+    item.appendChild(
+      this._button('Approve', () => this.publisher.emit('approve', { id: game.id })),
+    );
+    item.appendChild(
+      this._button('Reject', () =>
+        this.publisher.emit('reject', { id: game.id, note: note.value.trim() }),
+      ),
+    );
+    item.appendChild(
+      this._button('Disable', () => this.publisher.emit('disable', { id: game.id })),
+    );
+    item.appendChild(
+      this._button('npm versions', () =>
+        this.publisher.emit('load-versions', { id: game.id }),
+      ),
+    );
+
+    return item;
+  }
+
+  // Ссылка на репозиторий игры. Протокол проверяется и здесь, хотя auth уже
+  // принимает только http(s): href — единственное место представления, где
+  // содержимое поля становится исполняемым (javascript:), и полагаться на
+  // одну проверку на другой стороне сети тут не стоит
+  _appendRepo(item, url) {
+    if (typeof url !== 'string' || !/^https?:\/\//i.test(url)) {
+      return;
+    }
+
+    const line = document.createElement('div');
+    const link = document.createElement('a');
+
+    link.href = url;
+    link.textContent = url;
+    link.target = '_blank';
+    link.rel = 'noopener noreferrer';
+    line.appendChild(link);
+    item.appendChild(line);
+  }
+
+  _statusLine(game) {
+    const status = STATUS_TITLES[game.status] ?? game.status;
+    const date = game.createdAt ? new Date(game.createdAt).toLocaleDateString() : '';
+
+    return date ? `Status: ${status} (submitted ${date})` : `Status: ${status}`;
+  }
+
+  _renderFilters() {
+    this._filterButtons = new Map();
+
+    this._config.statuses.forEach(({ id, title }) => {
+      const btn = this._button(title, () => this.publisher.emit('filter', id));
+
+      btn.className = 'games-filter-btn';
+      this._filterButtons.set(id, btn);
+      this._filters.appendChild(btn);
+    });
+  }
+
+  _markFilter(filter) {
+    this._filterButtons.forEach((btn, id) => {
+      btn.classList.toggle('active', id === filter);
+    });
+  }
+
+  _button(value, onclick) {
+    const btn = document.createElement('input');
+
+    btn.type = 'button';
+    btn.value = value;
+    btn.onclick = onclick;
+
+    return btn;
+  }
+
+  _line(text, className) {
+    const line = document.createElement('div');
+
+    line.textContent = text;
+
+    if (className) {
+      line.className = className;
+    }
+
+    return line;
+  }
+
+  _readForm() {
+    const form = {};
+
+    this._fields.forEach((field, name) => {
+      form[name] = field.value.trim();
+    });
+
+    return form;
+  }
+}