@hot-updater/server 1.0.0-rc.14 → 1.0.0-rc.16

package/dist/plugins/insights/reads.cjs

@@ -0,0 +1,471 @@
+require("../../insights/provider.cjs");
+const require_schema = require("./schema.cjs");
+const require_recordEvent = require("./recordEvent.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+//#region src/plugins/insights/reads.ts
+const PAGE = 500;
+const hourFloor = (ms) => ms - ms % require_schema.HOUR_MS;
+const hourCeil = (ms) => hourFloor(ms + require_schema.HOUR_MS - 1);
+const dayFloor = (ms) => ms - ms % require_schema.DAY_MS;
+const dayCeil = (ms) => dayFloor(ms + require_schema.DAY_MS - 1);
+/** Every page of one read, in order. */
+const drain = async (read) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await read(cursor === void 0 ? {} : { cursor });
+		rows.push(...page.rows);
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+const EVENT_FIELDS = [
+	"id",
+	"type",
+	"install_id",
+	"user_id",
+	"from_release_id",
+	"from_bundle_id",
+	"to_release_id",
+	"to_bundle_id",
+	"platform",
+	"app_version",
+	"channel",
+	"metadata",
+	"received_at_ms"
+];
+/** A stored event or head, as the event row it holds. */
+const toEvent = (row) => Object.fromEntries(EVENT_FIELDS.map((field) => [field, row[field]]));
+const bundleRef = (filter) => filter.type === "RECOVERED" ? `from:${filter.fromBundleId}` : `to:${filter.toBundleId}`;
+const scopeOf = (filter) => ({
+	platform: filter.platform,
+	channel: filter.channel,
+	type: filter.type,
+	bundle_ref: bundleRef(filter)
+});
+/** One UTC day of a global or bundle list, newest first. */
+const eventsOfDay = (db, filter, day, range, limit) => filter.kind === "all" ? db.findMany("bundle_events", {
+	index: "byDay",
+	where: { day },
+	range,
+	order: "desc",
+	limit
+}) : db.findMany("bundle_events", {
+	index: "byBundle",
+	where: {
+		...scopeOf(filter),
+		day
+	},
+	range,
+	order: "desc",
+	limit
+});
+/**
+* The newest UTC day before `day`, and not before `since`'s, that holds an
+* event the list matches, from one outcome row: the global list's per-day
+* count, or the bundle filter's own hourly one.
+*/
+const newestDayBelow = async (db, filter, day, since) => {
+	const counted = filter.kind === "all" ? {
+		where: require_schema.DAILY_EVENTS,
+		from: dayFloor(since)
+	} : {
+		where: scopeOf(filter),
+		from: hourFloor(since)
+	};
+	const [newest] = (await db.findAggregates("insights_outcomes", {
+		index: "byRef",
+		where: counted.where,
+		range: {
+			gte: counted.from,
+			lt: day
+		},
+		order: "desc",
+		limit: 1
+	})).rows;
+	return newest === void 0 ? void 0 : dayFloor(newest.bucket_start_ms);
+};
+/**
+* Newest first over [since, before), after the cursor. The global and bundle
+* lists cover at most 90 × 24 hours, however many UTC days that touches, and
+* reject a longer range instead of cutting it short. They read one query per
+* UTC day that holds a matching event: a day that holds none is read once,
+* then one outcome row names the newest day below it that does, so a gap of
+* any length costs two reads.
+*/
+const listEvents = async (db, input) => {
+	const since = input.sinceMs ?? 0;
+	const range = {
+		gte: since,
+		lt: input.after === void 0 ? input.beforeReceivedAtMs : [input.after.receivedAtMs, input.after.id]
+	};
+	const { filter, limit } = input;
+	if (filter.kind === "installationMovement") return (await db.findMany("bundle_events", {
+		index: "movementsByInstall",
+		where: { movement_install_id: filter.installId },
+		range,
+		order: "desc",
+		limit
+	})).rows.map(toEvent);
+	if (input.beforeReceivedAtMs - since > 7776e6) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-query");
+	const rows = [];
+	const bottom = dayFloor(since);
+	let day = dayFloor(input.after?.receivedAtMs ?? input.beforeReceivedAtMs - 1);
+	while (day !== void 0 && day >= bottom && rows.length < limit) {
+		const page = await eventsOfDay(db, filter, day, range, limit - rows.length);
+		rows.push(...page.rows.map(toEvent));
+		day = page.rows.length > 0 ? day - require_schema.DAY_MS : day > bottom ? await newestDayBelow(db, filter, day, since) : void 0;
+	}
+	return rows;
+};
+/** One point read for an installation; a user's installations in binary install id order. */
+const findLatestEvents = async (db, input) => {
+	if ("installId" in input) {
+		const head = await db.findOne("bundle_event_heads", { install_id: input.installId });
+		return head === null ? [] : [toEvent(head)];
+	}
+	return (await db.findMany("bundle_event_heads", {
+		index: "byUser",
+		where: { user_id: input.userId },
+		...input.afterInstallId === void 0 ? {} : { range: { gt: input.afterInstallId } },
+		order: "asc",
+		limit: input.limit
+	})).rows.map(toEvent);
+};
+/** Raw events of one bundle filter over [from, to), which spans at most two partial hours. */
+const countRaw = async (db, filter, from, to) => {
+	let total = 0;
+	for (let day = dayFloor(from); from < to && day < to; day += require_schema.DAY_MS) {
+		const rows = await drain((page) => db.findMany("bundle_events", {
+			index: "byBundle",
+			where: {
+				...scopeOf(filter),
+				day
+			},
+			range: {
+				gte: from,
+				lt: to
+			},
+			limit: PAGE,
+			...page
+		}));
+		total += rows.length;
+	}
+	return total;
+};
+/** Whole hours from outcome counters; the partial hours at either edge from raw events. */
+const countEvents = async (db, input) => {
+	const { filter, sinceMs, beforeReceivedAtMs } = input;
+	const start = hourCeil(sinceMs);
+	const end = hourFloor(beforeReceivedAtMs);
+	if (start >= end) return countRaw(db, filter, sinceMs, beforeReceivedAtMs);
+	const hours = await drain((page) => db.findAggregates("insights_outcomes", {
+		index: "byRef",
+		where: scopeOf(filter),
+		range: {
+			gte: start,
+			lt: end
+		},
+		limit: PAGE,
+		...page
+	}));
+	return await countRaw(db, filter, sinceMs, start) + hours.reduce((sum, row) => sum + row.events, 0) + await countRaw(db, filter, end, beforeReceivedAtMs);
+};
+/** A bundle filter's distinct (field, value, type) predicates. */
+const latestPredicates = (bundle) => {
+	if (bundle === void 0) return void 0;
+	return [...new Map(bundle.flatMap(({ field, value, types }) => types.map((type) => [JSON.stringify([
+		field,
+		value,
+		type
+	]), {
+		field,
+		value,
+		type
+	}]))).values()];
+};
+/** Heads whose latest event falls in [sinceMs, end), a partial hour: those events' installs, then their heads. */
+const countPartialHeads = async (db, input, predicates, end) => {
+	const events = await drain((page) => db.findMany("bundle_events", {
+		index: "recent",
+		where: {
+			channel: input.channel,
+			platform: input.platform,
+			day: dayFloor(input.sinceMs)
+		},
+		range: {
+			gte: input.sinceMs,
+			lt: end
+		},
+		limit: PAGE,
+		...page
+	}));
+	const ids = new Set(events.map(({ id }) => id));
+	return (await Promise.all([...new Set(events.map(({ install_id }) => install_id))].map((install) => db.findOne("bundle_event_heads", { install_id: install })))).filter((head) => head !== null && ids.has(head.id) && (predicates === void 0 || predicates.some(({ field, value, type }) => head[field] === value && head.type === type))).length;
+};
+/** Latest events at or after `sinceMs`: whole hours from gauges, the first partial hour from heads. */
+const countLatestEvents = async (db, input) => {
+	const { platform, channel, sinceMs } = input;
+	const start = hourCeil(sinceMs);
+	const predicates = latestPredicates(input.bundle);
+	let total = 0;
+	if (predicates === void 0) {
+		const rows = await drain((page) => db.findAggregates("insights_distribution", {
+			index: "byScope",
+			where: {
+				channel,
+				platform
+			},
+			range: { gte: start },
+			limit: PAGE,
+			...page
+		}));
+		total += rows.reduce((sum, row) => sum + row.latest_installations, 0);
+	} else {
+		const gauge = async (bundleField, bundleId, type) => {
+			return (await drain((page) => db.findAggregates("insights_latest_by_bundle", {
+				index: "byBundle",
+				where: {
+					platform,
+					channel,
+					bundle_field: bundleField,
+					bundle_id: bundleId,
+					type
+				},
+				range: { gte: start },
+				limit: PAGE,
+				...page
+			}))).reduce((sum, row) => sum + row.installations, 0);
+		};
+		for (const { field, value, type } of predicates) total += await gauge(field, value, type);
+		for (const from of predicates) {
+			if (from.field !== "from_bundle_id") continue;
+			for (const to of predicates) {
+				if (to.field !== "to_bundle_id" || to.type !== from.type) continue;
+				total -= await gauge(require_recordEvent.PAIR_FIELD, require_recordEvent.bundlePairKey(from.value, to.value), from.type);
+			}
+		}
+	}
+	return sinceMs < start ? total + await countPartialHeads(db, input, predicates, start) : total;
+};
+/** Periods covering [start, end): whole UTC days when `days` and the window is over 48 hours, hours elsewhere. */
+const periodsOf = (range, days) => {
+	const { start, end } = range;
+	if (!days || end - start <= 1728e5) return [{
+		periodKind: "hour",
+		start,
+		end
+	}];
+	const first = Math.min(end, dayCeil(start));
+	const last = Math.max(first, dayFloor(end));
+	return [
+		{
+			periodKind: "hour",
+			start,
+			end: first
+		},
+		{
+			periodKind: "day",
+			start: first,
+			end: last
+		},
+		{
+			periodKind: "hour",
+			start: last,
+			end
+		}
+	].filter((period) => period.start < period.end);
+};
+/** Every overview or sketch row of one identity over [start, end), mixing day and hour periods. */
+const windowRows = async (db, model, parts, range, days) => {
+	const rows = [];
+	for (const period of periodsOf(range, days)) {
+		const identity = require_recordEvent.insightsIdentity({
+			...parts,
+			periodKind: period.periodKind
+		});
+		rows.push(...await drain((page) => db.findAggregates(model, {
+			index: "window",
+			where: { identity },
+			range: {
+				gte: period.start,
+				lt: period.end
+			},
+			limit: PAGE,
+			...page
+		})));
+	}
+	return rows;
+};
+const counterRows = (...args) => windowRows(args[0], "insights_overview", args[1], args[2], args[3]);
+const sketchRows = (...args) => windowRows(args[0], "insights_sketches", args[1], args[2], args[3]);
+const releaseParts = (release) => ({
+	scopeKind: "release",
+	releaseKind: "specific",
+	releaseId: release.releaseId,
+	channel: release.channel,
+	platform: release.platform,
+	appVersionKind: "all",
+	appVersion: ""
+});
+/** A release's lifetime counters: one logical row at bucket 0. */
+const lifetimeMetrics = async (db, release) => {
+	const identity = require_recordEvent.insightsIdentity({
+		...releaseParts(release),
+		periodKind: "lifetime"
+	});
+	const [lifetime] = (await db.findAggregates("insights_overview", {
+		index: "window",
+		where: { identity },
+		range: {
+			gte: 0,
+			lte: 0
+		},
+		limit: PAGE
+	})).rows;
+	return {
+		downloads: lifetime?.downloads ?? 0,
+		launches: lifetime?.launches ?? 0,
+		failedLaunches: lifetime?.failed_launches ?? 0
+	};
+};
+/** Counters, unique users, and a per-UTC-day series over a window. */
+const rangedMetrics = async (db, parts, range, days) => {
+	const [counters, sketches] = await Promise.all([counterRows(db, parts, range, days), sketchRows(db, parts, range, days)]);
+	const series = /* @__PURE__ */ new Map();
+	for (const row of counters) {
+		const day = dayFloor(row.bucket_start_ms);
+		const point = series.get(day) ?? {
+			launches: 0,
+			failedLaunches: 0
+		};
+		point.launches += row.launches;
+		point.failedLaunches += row.failed_launches;
+		series.set(day, point);
+	}
+	const total = (field) => counters.reduce((sum, row) => sum + row[field], 0);
+	return {
+		downloads: total("downloads"),
+		launches: total("launches"),
+		failedLaunches: total("failed_launches"),
+		uniqueUsers: (0, _hot_updater_plugin_core_internal.countInsightsDistinct)((0, _hot_updater_plugin_core_internal.mergeInsightsDistinct)(sketches.map((row) => row.launch_users))),
+		series: [...series].sort(([left], [right]) => left - right).map(([startMs, point]) => ({
+			startMs,
+			...point
+		}))
+	};
+};
+const getReleaseActivity = async (db, input, now) => {
+	return {
+		coverage: {
+			kind: "complete",
+			sinceMs: 0
+		},
+		data: input.scope !== void 0 ? [{
+			scope: input.scope,
+			metrics: await rangedMetrics(db, {
+				scopeKind: "channel",
+				releaseKind: "all",
+				releaseId: "",
+				channel: input.scope.channel,
+				platform: input.scope.platform,
+				appVersionKind: "all",
+				appVersion: ""
+			}, input.timeRange, true)
+		}] : await Promise.all(input.releases.map(async (release) => ({
+			release,
+			metrics: input.timeRange === void 0 ? await lifetimeMetrics(db, release) : await rangedMetrics(db, releaseParts(release), input.timeRange, false)
+		}))),
+		measuredAtMs: now()
+	};
+};
+const byInstallations = (values) => [...values].map(([name, installations]) => ({
+	name,
+	installations
+})).sort((left, right) => right.installations - left.installations || left.name.localeCompare(right.name, "en", { numeric: true }));
+const getAppUsage = async (db, input, now) => {
+	const { timeRange, intervalMs } = input;
+	const usage = await sketchRows(db, {
+		scopeKind: "usage",
+		releaseKind: "all",
+		releaseId: "",
+		channel: input.channel,
+		platform: input.platform,
+		appVersionKind: input.appVersion === void 0 ? "all" : "specific",
+		appVersion: input.appVersion ?? ""
+	}, timeRange, intervalMs % 864e5 === 0 && timeRange.start % 864e5 === 0);
+	const distribution = [];
+	for (const platform of input.platform === "all" ? ["ios", "android"] : [input.platform]) distribution.push(...await drain((page) => input.appVersion === void 0 ? db.findAggregates("insights_distribution", {
+		index: "byScope",
+		where: {
+			channel: input.channel,
+			platform
+		},
+		range: {
+			gte: timeRange.start,
+			lt: timeRange.end
+		},
+		limit: PAGE,
+		...page
+	}) : db.findAggregates("insights_distribution", {
+		index: "byVersion",
+		where: {
+			channel: input.channel,
+			platform,
+			app_version: input.appVersion
+		},
+		range: {
+			gte: timeRange.start,
+			lt: timeRange.end
+		},
+		limit: PAGE,
+		...page
+	})));
+	const points = [];
+	for (let start = timeRange.start; start < timeRange.end; start += intervalMs) points.push({
+		startMs: start,
+		installations: (0, _hot_updater_plugin_core_internal.countInsightsDistinct)((0, _hot_updater_plugin_core_internal.mergeInsightsDistinct)(usage.filter((row) => row.bucket_start_ms >= start && row.bucket_start_ms < start + intervalMs).map((row) => row.activity_users)))
+	});
+	const versions = /* @__PURE__ */ new Map();
+	const platforms = /* @__PURE__ */ new Map();
+	const bundles = /* @__PURE__ */ new Map();
+	for (const row of distribution) {
+		const count = row.latest_installations;
+		versions.set(row.app_version, (versions.get(row.app_version) ?? 0) + count);
+		platforms.set(row.platform, (platforms.get(row.platform) ?? 0) + count);
+		const releaseId = row.release_id === "" ? null : row.release_id;
+		const key = JSON.stringify([
+			row.app_version,
+			row.platform,
+			releaseId
+		]);
+		bundles.set(key, {
+			appVersion: row.app_version,
+			platform: row.platform,
+			releaseId,
+			installations: (bundles.get(key)?.installations ?? 0) + count
+		});
+	}
+	const sortedVersions = byInstallations(versions);
+	return {
+		coverage: {
+			kind: "complete",
+			sinceMs: 0
+		},
+		activeInstallations: (0, _hot_updater_plugin_core_internal.countInsightsDistinct)((0, _hot_updater_plugin_core_internal.mergeInsightsDistinct)(usage.map((row) => row.activity_users))),
+		points,
+		appVersions: sortedVersions.map(({ name }) => name),
+		versions: sortedVersions,
+		platforms: byInstallations(platforms),
+		bundleDistribution: [...bundles.values()],
+		measuredAtMs: now()
+	};
+};
+//#endregion
+exports.countEvents = countEvents;
+exports.countLatestEvents = countLatestEvents;
+exports.findLatestEvents = findLatestEvents;
+exports.getAppUsage = getAppUsage;
+exports.getReleaseActivity = getReleaseActivity;
+exports.listEvents = listEvents;