583 lines
24 KiB
JavaScript
583 lines
24 KiB
JavaScript
"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
|