@oneuptime/common 13.0.8 → 14.0.1

package/build/dist/Server/API/EnterpriseLicenseAPI.js

@@ -1,646 +0,0 @@
-import EnterpriseLicense from "../../Models/DatabaseModels/EnterpriseLicense";
-import EnterpriseLicenseInstance from "../../Models/DatabaseModels/EnterpriseLicenseInstance";
-import BadDataException from "../../Types/Exception/BadDataException";
-import EnterpriseLicenseUserCountSource from "../../Types/EnterpriseLicense/EnterpriseLicenseUserCountSource";
-import EnterpriseLicenseUsageUtil from "../../Utils/EnterpriseLicense/EnterpriseLicenseUsage";
-import VersionUtil from "../../Utils/VersionUtil";
-import LIMIT_MAX from "../../Types/Database/LimitMax";
-import ObjectID from "../../Types/ObjectID";
-import SortOrder from "../../Types/BaseDatabase/SortOrder";
-import EnterpriseLicenseService from "../Services/EnterpriseLicenseService";
-import EnterpriseLicenseInstanceService from "../Services/EnterpriseLicenseInstanceService";
-import UserMiddleware from "../Middleware/UserAuthorization";
-import JSONWebToken from "../Utils/JsonWebToken";
-import OneUptimeDate from "../../Types/Date";
-import Response from "../Utils/Response";
-import BaseAPI from "./BaseAPI";
-import MasterAdminAuthorization from "../Middleware/MasterAdminAuthorization";
-/*
- * Bounds how many instance rows one license key can register. Real customers
- * run a handful of instances; this stops a leaked key from being used to
- * fill the table with junk rows.
- */
-const MAX_INSTANCES_PER_LICENSE = 100;
-export default class EnterpriseLicenseAPI extends BaseAPI {
-    constructor() {
-        var _a, _b, _c;
-        super(EnterpriseLicense, EnterpriseLicenseService);
-        /*
-         * The dashboard needs a count and instance statuses from one cutoff
-         * instant. Calculate both on the server so the per-user hashes used for
-         * cross-instance deduplication never have to be sent to the browser.
-         */
-        this.router.get(`${(_a = new this.entityType().getCrudApiPath()) === null || _a === void 0 ? void 0 : _a.toString()}/:enterpriseLicenseId/active-usage`, MasterAdminAuthorization.isAuthorizedMasterAdminMiddleware, async (req, res, next) => {
-            try {
-                const licenseId = new ObjectID(req.params["enterpriseLicenseId"]);
-                const snapshot = await EnterpriseLicenseService.runWithUsageAggregationLock({
-                    licenseId,
-                    fn: async () => {
-                        /*
-                         * A report updates its instance row and then the license-wide
-                         * timestamp. Read both under the same lock so the dashboard
-                         * can never combine the new instance state with the previous
-                         * license state (or vice versa).
-                         */
-                        const license = await EnterpriseLicenseService.findOneById({
-                            id: licenseId,
-                            select: {
-                                _id: true,
-                                currentUserCount: true,
-                                userCountUpdatedAt: true,
-                                userCountSource: true,
-                                legacyUserCount: true,
-                                legacyUserCountUpdatedAt: true,
-                            },
-                            props: {
-                                isRoot: true,
-                            },
-                        });
-                        if (!license) {
-                            throw new BadDataException("Enterprise license not found");
-                        }
-                        const instances = await this.findLicenseInstances(licenseId);
-                        const calculatedAt = OneUptimeDate.getCurrentDate();
-                        const activeInstances = instances.filter((instance) => {
-                            return EnterpriseLicenseUsageUtil.isInstanceCountedTowardsUsage(instance, calculatedAt);
-                        });
-                        const currentUserCount = EnterpriseLicenseUsageUtil.getEffectiveUserCount({
-                            instances,
-                            storedUserCount: license.currentUserCount,
-                            storedUserCountUpdatedAt: license.userCountUpdatedAt,
-                            storedUserCountSource: license.userCountSource,
-                            legacyUserCount: license.legacyUserCount,
-                            legacyUserCountUpdatedAt: license.legacyUserCountUpdatedAt,
-                            now: calculatedAt,
-                        });
-                        const masterAdminEmailSet = new Set();
-                        for (const instance of instances) {
-                            for (const email of instance.masterAdminEmails || []) {
-                                const normalizedEmail = email.trim().toLowerCase();
-                                if (normalizedEmail) {
-                                    masterAdminEmailSet.add(normalizedEmail);
-                                }
-                            }
-                        }
-                        const masterAdminEmails = Array.from(masterAdminEmailSet).sort();
-                        const nextInstanceStatusChangeAt = activeInstances.reduce((earliestChange, instance) => {
-                            const lastCommunicatedAt = EnterpriseLicenseUsageUtil.getInstanceLastCommunicatedAt(instance);
-                            if (!lastCommunicatedAt) {
-                                return earliestChange;
-                            }
-                            const inactiveAt = new Date(lastCommunicatedAt.getTime() +
-                                EnterpriseLicenseUsageUtil.InstanceUsageFreshnessInDays *
-                                    24 *
-                                    60 *
-                                    60 *
-                                    1000);
-                            return !earliestChange || inactiveAt < earliestChange
-                                ? inactiveAt
-                                : earliestChange;
-                        }, null);
-                        const usesActiveModernUsage = EnterpriseLicenseUsageUtil.hasActiveReportedInstanceUsage(instances, calculatedAt);
-                        let activeLegacyUsageUpdatedAt;
-                        if (!usesActiveModernUsage) {
-                            if (EnterpriseLicenseUsageUtil.isTimestampWithinUsageWindow(license.legacyUserCountUpdatedAt, calculatedAt)) {
-                                activeLegacyUsageUpdatedAt =
-                                    license.legacyUserCountUpdatedAt;
-                            }
-                            else if (!license.legacyUserCountUpdatedAt &&
-                                license.userCountSource !==
-                                    EnterpriseLicenseUserCountSource.Instance &&
-                                (license.userCountSource ===
-                                    EnterpriseLicenseUserCountSource.Legacy ||
-                                    !EnterpriseLicenseUsageUtil.hasReportedInstanceUsage(instances)) &&
-                                EnterpriseLicenseUsageUtil.isTimestampWithinUsageWindow(license.userCountUpdatedAt, calculatedAt)) {
-                                /*
-                                 * Compatibility for rows written before the dedicated
-                                 * legacy heartbeat columns were introduced.
-                                 */
-                                activeLegacyUsageUpdatedAt = license.userCountUpdatedAt;
-                            }
-                        }
-                        const legacyUsageChangeAt = activeLegacyUsageUpdatedAt
-                            ? new Date(activeLegacyUsageUpdatedAt.getTime() +
-                                EnterpriseLicenseUsageUtil.InstanceUsageFreshnessInDays *
-                                    24 *
-                                    60 *
-                                    60 *
-                                    1000)
-                            : null;
-                        let nextUsageChangeAt = nextInstanceStatusChangeAt;
-                        if (legacyUsageChangeAt &&
-                            (!nextUsageChangeAt ||
-                                legacyUsageChangeAt < nextUsageChangeAt)) {
-                            nextUsageChangeAt = legacyUsageChangeAt;
-                        }
-                        const usageReportTimestamps = [
-                            license.userCountUpdatedAt,
-                            license.legacyUserCountUpdatedAt,
-                            ...instances.map((instance) => {
-                                return instance.lastReportedAt;
-                            }),
-                        ].filter((timestamp) => {
-                            return Boolean(timestamp);
-                        });
-                        const lastUsageReportedAt = usageReportTimestamps.reduce((latest, timestamp) => {
-                            return !latest || timestamp > latest ? timestamp : latest;
-                        }, null);
-                        return {
-                            currentUserCount,
-                            activeInstanceIds: activeInstances.map((instance) => {
-                                return instance.id.toString();
-                            }),
-                            masterAdminEmails,
-                            calculatedAt: calculatedAt.toISOString(),
-                            lastUsageReportedAt: (lastUsageReportedAt === null || lastUsageReportedAt === void 0 ? void 0 : lastUsageReportedAt.toISOString()) || null,
-                            nextInstanceStatusChangeAt: (nextUsageChangeAt === null || nextUsageChangeAt === void 0 ? void 0 : nextUsageChangeAt.toISOString()) || null,
-                        };
-                    },
-                });
-                return Response.sendJsonObjectResponse(req, res, snapshot);
-            }
-            catch (err) {
-                next(err);
-            }
-        });
-        this.router.post(`${(_b = new this.entityType().getCrudApiPath()) === null || _b === void 0 ? void 0 : _b.toString()}/validate`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
-            try {
-                const licenseKey = req.body["licenseKey"];
-                if (!licenseKey) {
-                    throw new BadDataException("License key is required");
-                }
-                //const serverHost: string = Host.toString();
-                /*
-                 * if (!serverHost.includes("oneuptime.com")) {
-                 *   throw new BadDataException(
-                 *     "Enterprise license validation is only available on oneuptime.com",
-                 *   );
-                 * }
-                 */
-                const license = await EnterpriseLicenseService.findOneBy({
-                    query: {
-                        licenseKey: licenseKey,
-                    },
-                    select: {
-                        _id: true,
-                        companyName: true,
-                        expiresAt: true,
-                        licenseKey: true,
-                        userLimit: true,
-                        currentUserCount: true,
-                        userCountUpdatedAt: true,
-                        isEvaluationLicense: true,
-                    },
-                    props: {
-                        isRoot: true,
-                    },
-                });
-                if (!license) {
-                    throw new BadDataException("License key is invalid");
-                }
-                if (!license.expiresAt) {
-                    throw new BadDataException("License expiration is not set");
-                }
-                const now = Date.now();
-                const expiresAtMs = license.expiresAt.getTime();
-                const secondsUntilExpiry = Math.floor((expiresAtMs - now) / 1000);
-                if (secondsUntilExpiry <= 0) {
-                    throw new BadDataException("License key has expired");
-                }
-                /*
-                 * The validating instance sends its instanceId and host so it
-                 * shows up in the instance list right away (usage is reported
-                 * later by the daily job on the instance).
-                 */
-                const instanceId = this.parseShortText(req.body["instanceId"]);
-                const instanceHost = this.parseShortText(req.body["host"]);
-                const instanceVersion = this.parseVersion(req.body["version"]);
-                const validationResult = await EnterpriseLicenseService.runWithUsageAggregationLock({
-                    licenseId: license.id,
-                    fn: async () => {
-                        /*
-                         * Registration is the instance's first communication and can
-                         * keep an upgrade-era count in its grace window. Serialize it
-                         * with reporting and reconciliation so a sweep cannot read the
-                         * old rows, then overwrite the count after this row appears.
-                         */
-                        if (instanceId) {
-                            await this.upsertLicenseInstance({
-                                licenseId: license.id,
-                                instanceId: instanceId,
-                                host: instanceHost || undefined,
-                                oneuptimeVersion: instanceVersion,
-                            });
-                        }
-                        const instances = await this.findLicenseInstances(license.id);
-                        const currentLicense = await EnterpriseLicenseService.findOneById({
-                            id: license.id,
-                            select: {
-                                currentUserCount: true,
-                                userCountUpdatedAt: true,
-                                userCountSource: true,
-                                legacyUserCount: true,
-                                legacyUserCountUpdatedAt: true,
-                            },
-                            props: {
-                                isRoot: true,
-                            },
-                        });
-                        if (!currentLicense) {
-                            throw new BadDataException("License key is invalid");
-                        }
-                        const calculatedAt = OneUptimeDate.getCurrentDate();
-                        const currentUserCount = EnterpriseLicenseUsageUtil.getEffectiveUserCount({
-                            instances,
-                            storedUserCount: currentLicense.currentUserCount,
-                            storedUserCountUpdatedAt: currentLicense.userCountUpdatedAt,
-                            storedUserCountSource: currentLicense.userCountSource,
-                            legacyUserCount: currentLicense.legacyUserCount,
-                            legacyUserCountUpdatedAt: currentLicense.legacyUserCountUpdatedAt,
-                            now: calculatedAt,
-                        });
-                        return {
-                            instances,
-                            currentUserCount,
-                            userCountUpdatedAt: currentLicense.userCountUpdatedAt || null,
-                            calculatedAt,
-                        };
-                    },
-                });
-                const terms = this.getLicenseTerms(license);
-                const token = this.signLicenseToken(license);
-                return Response.sendJsonObjectResponse(req, res, {
-                    companyName: terms.companyName,
-                    expiresAt: terms.expiresAt,
-                    licenseKey: terms.licenseKey,
-                    userLimit: terms.userLimit,
-                    currentUserCount: validationResult.currentUserCount,
-                    userCountUpdatedAt: validationResult.userCountUpdatedAt
-                        ? validationResult.userCountUpdatedAt.toISOString()
-                        : null,
-                    isEvaluationLicense: Boolean(license.isEvaluationLicense),
-                    instances: this.getInstanceSummaries(validationResult.instances, validationResult.calculatedAt),
-                    token,
-                });
-            }
-            catch (err) {
-                next(err);
-            }
-        });
-        this.router.post(`${(_c = new this.entityType().getCrudApiPath()) === null || _c === void 0 ? void 0 : _c.toString()}/report-user-count`, async (req, res, next) => {
-            var _a;
-            try {
-                const licenseKey = (_a = req.body["licenseKey"]) === null || _a === void 0 ? void 0 : _a.trim();
-                const rawUserCount = req.body["userCount"];
-                if (!licenseKey) {
-                    throw new BadDataException("License key is required");
-                }
-                const userCount = Number(rawUserCount);
-                if (!Number.isFinite(userCount) ||
-                    userCount < 0 ||
-                    !Number.isInteger(userCount)) {
-                    throw new BadDataException("userCount must be a non-negative integer");
-                }
-                const license = await EnterpriseLicenseService.findOneBy({
-                    query: {
-                        licenseKey: licenseKey,
-                    },
-                    /*
-                     * The full set of terms, not just the usage columns: this
-                     * response is what a self-hosted installation mirrors into its
-                     * own GlobalConfig every day, so anything it is missing here is
-                     * a field the customer keeps the stale value of until somebody
-                     * re-types the license key by hand. Same indexed lookup either
-                     * way.
-                     */
-                    select: {
-                        _id: true,
-                        companyName: true,
-                        expiresAt: true,
-                        licenseKey: true,
-                        userLimit: true,
-                        isEvaluationLicense: true,
-                    },
-                    props: {
-                        isRoot: true,
-                    },
-                });
-                if (!license) {
-                    throw new BadDataException("License key is invalid");
-                }
-                const instanceId = this.parseShortText(req.body["instanceId"]);
-                const instanceHost = this.parseShortText(req.body["host"]);
-                const instanceVersion = this.parseVersion(req.body["version"]);
-                const userEmailHashes = EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes(req.body["userEmailHashes"]);
-                const masterAdminEmails = EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails(req.body["masterAdminEmails"]);
-                const usageReport = await EnterpriseLicenseService.runWithUsageAggregationLock({
-                    licenseId: license.id,
-                    fn: async () => {
-                        /*
-                         * Capture this after acquiring the lock. Waiting reports can
-                         * never complete later with an earlier timestamp, and the
-                         * upsert/read/aggregate/write sequence is one serialized
-                         * critical section across every API replica.
-                         */
-                        const reportedAt = OneUptimeDate.getCurrentDate();
-                        if (instanceId) {
-                            /*
-                             * Multi-instance report: track usage per instance and count
-                             * users uniquely across all instances of this license.
-                             */
-                            await this.upsertLicenseInstance({
-                                licenseId: license.id,
-                                instanceId: instanceId,
-                                host: instanceHost || undefined,
-                                oneuptimeVersion: instanceVersion,
-                                userCount: userCount,
-                                userEmailHashes: userEmailHashes,
-                                masterAdminEmails: masterAdminEmails,
-                                lastReportedAt: reportedAt,
-                            });
-                        }
-                        const instances = await this.findLicenseInstances(license.id);
-                        const hasActiveReportedInstanceUsage = EnterpriseLicenseUsageUtil.hasActiveReportedInstanceUsage(instances, reportedAt);
-                        const currentUserCount = hasActiveReportedInstanceUsage
-                            ? EnterpriseLicenseUsageUtil.getUniqueUserCount(instances, reportedAt)
-                            : userCount;
-                        const usageUpdate = {};
-                        /*
-                         * Legacy reports (no instanceId) drive the license-wide count
-                         * only while no modern instance is active. Their separate
-                         * heartbeat is always retained, though, so a legacy reporter
-                         * can take over immediately when the last modern report ages
-                         * out instead of disappearing until its next daily call.
-                         */
-                        if (!instanceId) {
-                            usageUpdate.legacyUserCount = userCount;
-                            usageUpdate.legacyUserCountUpdatedAt = reportedAt;
-                        }
-                        if (instanceId || !hasActiveReportedInstanceUsage) {
-                            usageUpdate.currentUserCount = currentUserCount;
-                            usageUpdate.userCountUpdatedAt = reportedAt;
-                            usageUpdate.userCountSource = instanceId
-                                ? EnterpriseLicenseUserCountSource.Instance
-                                : EnterpriseLicenseUserCountSource.Legacy;
-                        }
-                        if (Object.keys(usageUpdate).length > 0) {
-                            await EnterpriseLicenseService.updateOneById({
-                                id: license.id,
-                                data: usageUpdate,
-                                props: {
-                                    isRoot: true,
-                                    ignoreHooks: true,
-                                },
-                            });
-                        }
-                        return {
-                            reportedAt,
-                            instances,
-                            currentUserCount,
-                        };
-                    },
-                });
-                const { reportedAt, instances, currentUserCount } = usageReport;
-                const terms = this.getLicenseTerms(license);
-                return Response.sendJsonObjectResponse(req, res, {
-                    companyName: terms.companyName,
-                    expiresAt: terms.expiresAt,
-                    licenseKey: terms.licenseKey,
-                    userLimit: terms.userLimit,
-                    currentUserCount: currentUserCount,
-                    userCountUpdatedAt: reportedAt.toISOString(),
-                    isEvaluationLicense: Boolean(license.isEvaluationLicense),
-                    instances: this.getInstanceSummaries(instances, reportedAt),
-                    /*
-                     * Null once the license has expired. Unlike /validate this route
-                     * does not reject an expired license - the instance is still
-                     * expected to report, and the expiry notification emails are built
-                     * from what it reports - but it must not keep being handed a fresh
-                     * token, and the expiresAt above is what tells it the truth.
-                     */
-                    token: this.signLicenseToken(license),
-                });
-            }
-            catch (err) {
-                next(err);
-            }
-        });
-    }
-    /*
-     * The license terms a self-hosted installation mirrors locally. Built in one
-     * place so /validate and /report-user-count cannot drift: the seat limit was
-     * missing from what an instance could refresh for exactly as long as the two
-     * responses were written out by hand, separately.
-     */
-    getLicenseTerms(license) {
-        return {
-            companyName: license.companyName || "",
-            expiresAt: license.expiresAt ? license.expiresAt.toISOString() : null,
-            licenseKey: license.licenseKey || "",
-            userLimit: typeof license.userLimit === "number" ? license.userLimit : null,
-        };
-    }
-    /*
-     * Signed with the license server's own secret, so it is opaque to the
-     * installation holding it - it is the proof that oneuptime.com recognized
-     * the key, and the instance only checks that it exists. An expired license
-     * gets none, which is why this returns null rather than a short-lived token.
-     */
-    signLicenseToken(license) {
-        if (!license.expiresAt) {
-            return null;
-        }
-        const secondsUntilExpiry = Math.floor((license.expiresAt.getTime() - Date.now()) / 1000);
-        if (secondsUntilExpiry <= 0) {
-            return null;
-        }
-        const terms = this.getLicenseTerms(license);
-        return JSONWebToken.signJsonPayload({
-            companyName: terms.companyName,
-            expiresAt: terms.expiresAt,
-            licenseKey: terms.licenseKey,
-            userLimit: terms.userLimit,
-        }, Math.max(secondsUntilExpiry, 1));
-    }
-    parseShortText(value) {
-        if (typeof value !== "string") {
-            return "";
-        }
-        return value.trim().substring(0, 100);
-    }
-    /*
-     * report-user-count is unauthenticated, so the reported version is only
-     * stored when it is a version we could actually compare against a release —
-     * garbage never reaches the admin dashboard or the customer's modal.
-     *
-     * Three outcomes, and the callers depend on the distinction:
-     *   undefined — the instance sent no version at all (it predates this
-     *               field). Leave whatever is stored alone.
-     *   null      — it sent something, but not a version. Clear the stored
-     *               value, so an instance rolled back to a build with no
-     *               APP_VERSION stops advertising the version it used to run.
-     *   string    — a valid, canonical version to store.
-     */
-    parseVersion(value) {
-        if (value === undefined || value === null) {
-            return undefined;
-        }
-        /*
-         * Canonicalized rather than passed through, so the stored string is never
-         * something the UIs would render with a doubled "v".
-         */
-        return VersionUtil.canonicalize(value);
-    }
-    async findLicenseInstances(licenseId) {
-        return EnterpriseLicenseInstanceService.findBy({
-            query: {
-                enterpriseLicenseId: licenseId,
-            },
-            select: {
-                _id: true,
-                createdAt: true,
-                instanceId: true,
-                host: true,
-                userCount: true,
-                userEmailHashes: true,
-                masterAdminEmails: true,
-                lastReportedAt: true,
-                oneuptimeVersion: true,
-            },
-            sort: {
-                createdAt: SortOrder.Ascending,
-            },
-            skip: 0,
-            limit: LIMIT_MAX,
-            props: {
-                isRoot: true,
-            },
-        });
-    }
-    getInstanceSummaries(instances, calculatedAt) {
-        return instances.map((instance) => {
-            return {
-                instanceId: instance.instanceId || "",
-                host: instance.host || null,
-                userCount: typeof instance.userCount === "number" ? instance.userCount : null,
-                isCountedTowardsUsage: EnterpriseLicenseUsageUtil.isInstanceCountedTowardsUsage(instance, calculatedAt),
-                lastReportedAt: instance.lastReportedAt
-                    ? instance.lastReportedAt.toISOString()
-                    : null,
-                version: instance.oneuptimeVersion || null,
-            };
-        });
-    }
-    async upsertLicenseInstance(data) {
-        const updated = await this.updateLicenseInstanceIfExists(data);
-        if (updated) {
-            return;
-        }
-        const instanceCount = await EnterpriseLicenseInstanceService.countBy({
-            query: {
-                enterpriseLicenseId: data.licenseId,
-            },
-            props: {
-                isRoot: true,
-            },
-        });
-        if (instanceCount.toNumber() >= MAX_INSTANCES_PER_LICENSE) {
-            throw new BadDataException("Too many instances are registered for this license. Please contact support@oneuptime.com.");
-        }
-        const newInstance = new EnterpriseLicenseInstance();
-        newInstance.enterpriseLicenseId = data.licenseId;
-        newInstance.instanceId = data.instanceId;
-        if (data.host !== undefined) {
-            newInstance.host = data.host;
-        }
-        // Null means "reported something that is not a version" — nothing to store.
-        if (data.oneuptimeVersion) {
-            newInstance.oneuptimeVersion = data.oneuptimeVersion;
-        }
-        if (data.userCount !== undefined) {
-            newInstance.userCount = data.userCount;
-        }
-        if (data.userEmailHashes !== undefined) {
-            newInstance.userEmailHashes = data.userEmailHashes;
-        }
-        if (data.masterAdminEmails !== undefined) {
-            newInstance.masterAdminEmails = data.masterAdminEmails;
-        }
-        if (data.lastReportedAt !== undefined) {
-            newInstance.lastReportedAt = data.lastReportedAt;
-        }
-        try {
-            await EnterpriseLicenseInstanceService.create({
-                data: newInstance,
-                props: {
-                    isRoot: true,
-                },
-            });
-        }
-        catch (err) {
-            /*
-             * A concurrent request created the row between our check and this
-             * insert — the unique index on (enterpriseLicenseId, instanceId)
-             * rejected the duplicate. Apply the report as an update instead.
-             */
-            const retried = await this.updateLicenseInstanceIfExists(data);
-            if (!retried) {
-                throw err;
-            }
-        }
-    }
-    async updateLicenseInstanceIfExists(data) {
-        const existingInstance = await EnterpriseLicenseInstanceService.findOneBy({
-            query: {
-                enterpriseLicenseId: data.licenseId,
-                instanceId: data.instanceId,
-            },
-            select: {
-                _id: true,
-            },
-            props: {
-                isRoot: true,
-            },
-        });
-        if (!existingInstance) {
-            return false;
-        }
-        const updateData = {};
-        if (data.host !== undefined) {
-            updateData.host = data.host;
-        }
-        /*
-         * Null clears the column: an instance rebuilt onto a build with no
-         * APP_VERSION must stop advertising the version it used to run, because
-         * lastReportedAt is refreshed on the same request and would otherwise
-         * read as "confirmed running v11.5.13 as of today".
-         */
-        if (data.oneuptimeVersion !== undefined) {
-            updateData.oneuptimeVersion = data.oneuptimeVersion;
-        }
-        if (data.userCount !== undefined) {
-            updateData.userCount = data.userCount;
-        }
-        if (data.userEmailHashes !== undefined) {
-            updateData.userEmailHashes = data.userEmailHashes;
-        }
-        if (data.masterAdminEmails !== undefined) {
-            updateData.masterAdminEmails = data.masterAdminEmails;
-        }
-        if (data.lastReportedAt !== undefined) {
-            updateData.lastReportedAt = data.lastReportedAt;
-        }
-        if (Object.keys(updateData).length > 0) {
-            await EnterpriseLicenseInstanceService.updateOneById({
-                id: existingInstance.id,
-                data: updateData,
-                props: {
-                    isRoot: true,
-                    ignoreHooks: true,
-                },
-            });
-        }
-        return true;
-    }
-}
-//# sourceMappingURL=EnterpriseLicenseAPI.js.map