games_app/backend/dist-test-faq/services/mobileAppReleaseService.js

583 lines
24 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"use strict";
/**
* Mobile app release lifecycle: admin CRUD, APK validation, public check/download, telemetry.
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MobileReleaseError = void 0;
exports.rolloutBucket = rolloutBucket;
exports.isRolloutEligible = isRolloutEligible;
exports.hashDeviceId = hashDeviceId;
exports.createDownloadToken = createDownloadToken;
exports.verifyDownloadToken = verifyDownloadToken;
exports.getLatestPublicAndroidApk = getLatestPublicAndroidApk;
exports.getSettings = getSettings;
exports.updateSettings = updateSettings;
exports.listReleases = listReleases;
exports.getRelease = getRelease;
exports.createRelease = createRelease;
exports.updateReleaseMeta = updateReleaseMeta;
exports.attachApk = attachApk;
exports.submitForValidation = submitForValidation;
exports.publish = publish;
exports.suspend = suspend;
exports.retire = retire;
exports.hardDelete = hardDelete;
exports.checkAndroidUpdate = checkAndroidUpdate;
exports.openDownloadStream = openDownloadStream;
exports.recordClientEvent = recordClientEvent;
exports.getStats = getStats;
exports.evaluateClientVersionGate = evaluateClientVersionGate;
const crypto_1 = __importDefault(require("crypto"));
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const config_1 = require("../config");
const httpError_1 = require("../utils/httpError");
const apkParser_1 = require("../utils/apkParser");
const virusScanService_1 = require("./virusScanService");
const apkStorageService_1 = require("./apkStorageService");
const repo = __importStar(require("../repositories/mobileAppReleaseRepository"));
const fileIntegrityService_1 = require("./fileIntegrityService");
const fileIntegrityRepository = __importStar(require("../repositories/fileIntegrityRepository"));
const auditLogRepository = __importStar(require("../repositories/auditLogRepository"));
class MobileReleaseError extends httpError_1.HttpError {
constructor(status, message, code) {
super(status, message, code);
this.name = 'MobileReleaseError';
}
}
exports.MobileReleaseError = MobileReleaseError;
/** Deterministic rollout bucket 0–99 from device id. */
function rolloutBucket(deviceId) {
const hash = crypto_1.default.createHash('sha256').update(String(deviceId || 'anonymous')).digest();
return hash.readUInt32BE(0) % 100;
}
function isRolloutEligible(deviceId, rolloutPercent) {
if (rolloutPercent >= 100)
return true;
if (rolloutPercent <= 0)
return false;
return rolloutBucket(deviceId) < rolloutPercent;
}
function hashDeviceId(deviceId) {
return crypto_1.default.createHash('sha256').update(`tloto-device:${deviceId}`).digest('hex').slice(0, 32);
}
function signDownloadToken(releaseId, exp) {
const payload = `${releaseId}.${exp}`;
const sig = crypto_1.default
.createHmac('sha256', config_1.config.mobileReleases.downloadTokenSecret)
.update(payload)
.digest('base64url');
return `${payload}.${sig}`;
}
function createDownloadToken(releaseId) {
const expiresAt = Math.floor(Date.now() / 1000) + config_1.config.mobileReleases.downloadTokenTtlSeconds;
return { token: signDownloadToken(releaseId, expiresAt), expiresAt };
}
function verifyDownloadToken(token, releaseId) {
const parts = token.split('.');
if (parts.length !== 3)
return false;
const [id, expStr, sig] = parts;
if (id !== releaseId)
return false;
const exp = parseInt(expStr, 10);
if (!Number.isFinite(exp) || exp < Math.floor(Date.now() / 1000))
return false;
const expected = signDownloadToken(releaseId, exp);
try {
return crypto_1.default.timingSafeEqual(Buffer.from(token), Buffer.from(expected));
}
catch {
return false;
}
}
function publicDownloadPath(releaseId, token) {
const api = config_1.config.apiPrefix.replace(/\/$/, '');
return `${api}/app-updates/android/download/${releaseId}?token=${encodeURIComponent(token)}`;
}
function publicDownloadUrl(releaseId, token) {
const base = config_1.config.app.publicUrl.replace(/\/$/, '');
return `${base}${publicDownloadPath(releaseId, token)}`;
}
/** Latest published Android APK for the public website (ignores staged rollout). */
async function getLatestPublicAndroidApk(channel = 'production') {
const latest = await repo.findLatestPublished('android', channel);
if (!latest || !latest.storageKey || !latest.sha256) {
return {
available: false,
versionName: null,
versionCode: null,
fileSizeBytes: null,
sha256: null,
downloadUrl: null,
downloadPath: null,
publishedAt: null,
packageName: null,
};
}
const { token } = createDownloadToken(latest.id);
return {
available: true,
versionName: latest.versionName,
versionCode: latest.versionCode,
fileSizeBytes: latest.fileSizeBytes,
sha256: latest.sha256,
downloadUrl: publicDownloadUrl(latest.id, token),
downloadPath: publicDownloadPath(latest.id, token),
publishedAt: latest.publishedAt?.toISOString() ?? null,
packageName: latest.packageName,
};
}
async function getSettings() {
return repo.getSettings();
}
async function updateSettings(input) {
return repo.updateSettings(input);
}
async function listReleases(filters) {
return repo.listReleases(filters);
}
async function getRelease(id) {
const release = await repo.findById(id);
if (!release)
throw new MobileReleaseError(404, 'Release not found');
return release;
}
async function createRelease(input) {
if (input.platform === 'ios') {
throw new MobileReleaseError(400, 'iOS IPA distribution is not supported; use App Store / TestFlight');
}
try {
return await repo.createRelease({
platform: 'android',
channel: input.channel ?? 'production',
versionName: input.versionName,
versionCode: input.versionCode,
previousVersionName: input.previousVersionName,
whatsNew: input.whatsNew,
bugFixes: input.bugFixes,
updatePolicy: input.updatePolicy,
rolloutPercent: input.rolloutPercent,
createdBy: input.createdBy,
});
}
catch (e) {
const msg = e instanceof Error ? e.message : String(e);
if (/unique|duplicate/i.test(msg)) {
throw new MobileReleaseError(409, 'A release with this versionCode already exists for the channel');
}
throw e;
}
}
async function updateReleaseMeta(id, patch) {
const existing = await getRelease(id);
if (existing.status === 'retired') {
throw new MobileReleaseError(400, 'Retired releases cannot be edited');
}
const updated = await repo.updateRelease(id, patch);
if (!updated)
throw new MobileReleaseError(404, 'Release not found');
return updated;
}
async function attachApk(id, uploadedAbsolutePath) {
const release = await getRelease(id);
if (!['draft', 'pending_validation', 'suspended'].includes(release.status)) {
throw new MobileReleaseError(400, 'APK can only be uploaded for draft, pending, or suspended releases');
}
const stat = fs_1.default.statSync(uploadedAbsolutePath);
if (stat.size > (0, apkStorageService_1.getApkMaxUploadBytes)()) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(400, 'APK exceeds maximum upload size');
}
try {
await (0, virusScanService_1.scanUploadedFile)(uploadedAbsolutePath);
}
catch (e) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(422, e instanceof Error ? e.message : 'Virus scan failed');
}
let parsed;
try {
parsed = await (0, apkParser_1.parseApkFile)(uploadedAbsolutePath);
}
catch (e) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(400, e instanceof Error ? e.message : 'Invalid APK');
}
const settings = await repo.getSettings();
const expectedPackage = config_1.config.mobileReleases.expectedPackage || settings.expectedPackageName;
if (parsed.packageName !== expectedPackage) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(400, `APK package "${parsed.packageName}" does not match expected "${expectedPackage}"`);
}
// Draft/pending: adopt APK versionCode/name when they differ (admin often mistypes the form).
let nextVersionCode = release.versionCode;
if (parsed.versionCode !== release.versionCode) {
const conflict = await repo.findByPlatformChannelVersionCode(release.platform, release.channel, parsed.versionCode);
if (conflict && conflict.id !== release.id) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(409, `APK versionCode ${parsed.versionCode} is already used by another release (${conflict.versionName})`);
}
nextVersionCode = parsed.versionCode;
}
const expectedCert = config_1.config.mobileReleases.expectedCertSha256;
if (expectedCert) {
if (!parsed.signingCertSha256) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(400, 'Could not read APK signing certificate');
}
if (parsed.signingCertSha256.toLowerCase() !== expectedCert) {
(0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`);
throw new MobileReleaseError(400, 'APK signing certificate does not match the expected fingerprint');
}
}
if (release.storageKey)
(0, apkStorageService_1.removeApkIfExists)(release.storageKey);
const stagingKey = `staging/${path_1.default.basename(uploadedAbsolutePath)}`;
const fileSha = await (0, apkStorageService_1.sha256File)(uploadedAbsolutePath);
const updated = await repo.updateRelease(id, {
packageName: parsed.packageName,
versionName: parsed.versionName || release.versionName,
versionCode: nextVersionCode,
storageKey: stagingKey,
fileSizeBytes: stat.size,
sha256: fileSha,
signingCertSha256: parsed.signingCertSha256,
status: release.status === 'draft' ? 'pending_validation' : release.status,
});
if (!updated)
throw new MobileReleaseError(404, 'Release not found');
return updated;
}
async function submitForValidation(id) {
const release = await getRelease(id);
if (!release.storageKey || !release.sha256) {
throw new MobileReleaseError(400, 'Upload an APK before submitting for validation');
}
if (release.status !== 'draft' && release.status !== 'pending_validation') {
throw new MobileReleaseError(400, 'Only draft releases can be submitted');
}
const updated = await repo.updateRelease(id, { status: 'pending_validation' });
if (!updated)
throw new MobileReleaseError(404, 'Release not found');
return updated;
}
async function publish(id) {
const release = await getRelease(id);
if (!['pending_validation', 'suspended', 'draft'].includes(release.status)) {
throw new MobileReleaseError(400, 'Release cannot be published from its current status');
}
if (!release.storageKey || !release.sha256 || !release.fileSizeBytes) {
throw new MobileReleaseError(400, 'APK file is required before publication');
}
const settings = await repo.getSettings();
const expectedPackage = config_1.config.mobileReleases.expectedPackage || settings.expectedPackageName;
if (release.packageName && release.packageName !== expectedPackage) {
throw new MobileReleaseError(400, 'Package name mismatch — re-upload the APK');
}
const expectedCert = config_1.config.mobileReleases.expectedCertSha256;
if (expectedCert && release.signingCertSha256?.toLowerCase() !== expectedCert) {
throw new MobileReleaseError(400, 'Signing certificate fingerprint mismatch');
}
const latest = await repo.findLatestPublished(release.platform, release.channel);
if (latest && latest.versionCode >= release.versionCode && latest.id !== release.id) {
throw new MobileReleaseError(400, `versionCode must be strictly greater than the current published release (${latest.versionCode})`);
}
let storageKey = release.storageKey;
if (storageKey.startsWith('staging/')) {
storageKey = (0, apkStorageService_1.moveApkToPublished)(storageKey, release.id);
try {
await (0, fileIntegrityService_1.recordUploadedFile)(fileIntegrityService_1.FILE_INTEGRITY_ROOTS.apkPublished, `${release.id}.apk`);
}
catch (e) {
console.warn('[mobile-releases] FIM baseline skipped:', e);
}
}
const updated = await repo.updateRelease(id, {
storageKey,
status: 'published',
publishedAt: new Date(),
});
if (!updated)
throw new MobileReleaseError(404, 'Release not found');
return updated;
}
async function suspend(id) {
const release = await getRelease(id);
if (release.status !== 'published') {
throw new MobileReleaseError(400, 'Only published releases can be suspended');
}
const updated = await repo.updateRelease(id, { status: 'suspended' });
if (!updated)
throw new MobileReleaseError(404, 'Release not found');
return updated;
}
async function retire(id) {
const release = await getRelease(id);
if (release.status === 'retired')
return release;
const updated = await repo.updateRelease(id, { status: 'retired' });
if (!updated)
throw new MobileReleaseError(404, 'Release not found');
return updated;
}
/**
* Permanently deletes a release: APK file on disk, FIM snapshot, events, DB row.
* Blocks deletion of the current highest published release for that platform/channel
* (would leave clients without an update target).
*/
async function hardDelete(id, actor) {
const release = await getRelease(id);
if (release.status === 'published') {
const latest = await repo.findLatestPublished(release.platform, release.channel);
if (latest && latest.id === release.id) {
throw new MobileReleaseError(400, 'Cannot delete the current published release. Publish a newer build first, or suspend/retire this one.', 'MOBILE_RELEASE_IS_LATEST_PUBLISHED');
}
}
const storageKey = release.storageKey;
const eventsRemoved = await repo.deleteEventsForRelease(id);
const deleted = await repo.deleteRelease(id);
if (!deleted)
throw new MobileReleaseError(404, 'Release not found');
(0, apkStorageService_1.removeApkIfExists)(storageKey);
if (storageKey?.startsWith('published/')) {
try {
await fileIntegrityRepository.deleteSnapshot(fileIntegrityService_1.FILE_INTEGRITY_ROOTS.apkPublished, `${id}.apk`);
}
catch (e) {
console.warn('[mobile-releases] FIM snapshot cleanup skipped:', e);
}
}
if (actor?.userId) {
await auditLogRepository.create({
userId: actor.userId,
action: 'mobile_release_deleted',
resourceType: 'mobile_app_release',
resourceId: id,
ipAddress: actor.ipAddress ?? null,
userAgent: actor.userAgent ?? null,
metadata: {
versionName: release.versionName,
versionCode: release.versionCode,
status: release.status,
storageKey,
eventsRemoved,
},
});
}
return {
deleted: true,
versionCode: release.versionCode,
versionName: release.versionName,
};
}
async function checkAndroidUpdate(input) {
const channel = input.channel ?? 'production';
const settings = await repo.getSettings();
const latest = await repo.findLatestPublished('android', channel);
const mandatory = await repo.findHighestMandatoryPublished('android', channel);
const minSupported = settings.minSupportedVersionCode;
const blocked = input.versionCode < minSupported;
await repo.insertEvent({
releaseId: latest?.id ?? null,
eventType: 'check',
platform: 'android',
channel,
clientVersionCode: input.versionCode,
deviceIdHash: hashDeviceId(input.deviceId),
});
const base = {
updateAvailable: false,
blocked,
policy: null,
versionName: null,
versionCode: null,
whatsNew: null,
bugFixes: null,
fileSizeBytes: null,
sha256: null,
downloadUrl: null,
downloadPath: null,
minSupportedVersionCode: minSupported,
checkIntervalSeconds: settings.checkIntervalSeconds,
publishedAt: null,
packageName: settings.expectedPackageName,
};
if (!latest || latest.versionCode <= input.versionCode) {
return base;
}
if (!isRolloutEligible(input.deviceId, latest.rolloutPercent)) {
return base;
}
const { token } = createDownloadToken(latest.id);
let policy = latest.updatePolicy;
if (mandatory && mandatory.versionCode > input.versionCode) {
policy = 'mandatory';
}
if (blocked)
policy = 'mandatory';
return {
...base,
updateAvailable: true,
policy,
versionName: latest.versionName,
versionCode: latest.versionCode,
whatsNew: latest.whatsNew,
bugFixes: latest.bugFixes,
fileSizeBytes: latest.fileSizeBytes,
sha256: latest.sha256,
downloadUrl: publicDownloadUrl(latest.id, token),
downloadPath: publicDownloadPath(latest.id, token),
publishedAt: latest.publishedAt?.toISOString() ?? null,
packageName: latest.packageName,
};
}
async function openDownloadStream(releaseId, token) {
if (!verifyDownloadToken(token, releaseId)) {
throw new MobileReleaseError(403, 'Invalid or expired download token');
}
const release = await getRelease(releaseId);
if (release.status !== 'published' || !release.storageKey) {
throw new MobileReleaseError(404, 'Release is not available for download');
}
const absolutePath = (0, apkStorageService_1.resolveApkStoragePath)(release.storageKey);
if (!fs_1.default.existsSync(absolutePath)) {
throw new MobileReleaseError(404, 'APK file missing on server');
}
await repo.insertEvent({
releaseId,
eventType: 'download_start',
platform: release.platform,
channel: release.channel,
});
await repo.incrementCounter(releaseId, 'download_count');
return { release, absolutePath };
}
async function recordClientEvent(input) {
const allowed = [
'download_start',
'download_ok',
'download_fail',
'install_confirm',
];
if (!allowed.includes(input.eventType)) {
throw new MobileReleaseError(400, 'Unsupported event type');
}
// download_count is incremented when the authenticated download stream starts.
if (input.releaseId && input.eventType === 'download_fail') {
await repo.incrementCounter(input.releaseId, 'download_fail_count');
}
if (input.releaseId && input.eventType === 'install_confirm') {
await repo.incrementCounter(input.releaseId, 'install_confirm_count');
}
await repo.insertEvent({
releaseId: input.releaseId ?? null,
eventType: input.eventType,
platform: 'android',
channel: input.channel ?? 'production',
clientVersionCode: input.versionCode ?? null,
deviceIdHash: input.deviceId ? hashDeviceId(input.deviceId) : null,
userId: input.userId ?? null,
});
}
async function getStats() {
return repo.getStatsSummary('android');
}
/**
* Returns whether a client versionCode is allowed to call sensitive APIs.
* When blocked, returns the update payload for a 426 response.
*/
async function evaluateClientVersionGate(versionCode) {
if (versionCode == null || !Number.isFinite(versionCode)) {
// Web / unknown clients are not gated by mobile version headers.
return { allowed: true };
}
const settings = await repo.getSettings();
const mandatory = await repo.findHighestMandatoryPublished('android', 'production');
const latest = await repo.findLatestPublished('android', 'production');
const belowMin = versionCode < settings.minSupportedVersionCode;
const behindMandatory = !!mandatory && mandatory.versionCode > versionCode;
if (!belowMin && !behindMandatory)
return { allowed: true };
const target = mandatory && mandatory.versionCode > versionCode ? mandatory : latest;
if (!target) {
return {
allowed: false,
update: {
updateAvailable: false,
blocked: true,
policy: 'mandatory',
versionName: null,
versionCode: null,
whatsNew: null,
bugFixes: null,
fileSizeBytes: null,
sha256: null,
downloadUrl: null,
downloadPath: null,
minSupportedVersionCode: settings.minSupportedVersionCode,
checkIntervalSeconds: settings.checkIntervalSeconds,
publishedAt: null,
packageName: settings.expectedPackageName,
},
};
}
const { token } = createDownloadToken(target.id);
return {
allowed: false,
update: {
updateAvailable: true,
blocked: true,
policy: 'mandatory',
versionName: target.versionName,
versionCode: target.versionCode,
whatsNew: target.whatsNew,
bugFixes: target.bugFixes,
fileSizeBytes: target.fileSizeBytes,
sha256: target.sha256,
downloadUrl: publicDownloadUrl(target.id, token),
downloadPath: publicDownloadPath(target.id, token),
minSupportedVersionCode: settings.minSupportedVersionCode,
checkIntervalSeconds: settings.checkIntervalSeconds,
publishedAt: target.publishedAt?.toISOString() ?? null,
packageName: target.packageName,
},
};
}
//# sourceMappingURL=mobileAppReleaseService.js.map