@oneuptime/common 12.0.32 → 12.0.33

package/build/dist/Server/Services/NetworkSiteTypeService.js

@@ -1,9 +1,872 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import QueryHelper from "../Types/Database/QueryHelper";
 import DatabaseService from "./DatabaseService";
+import NetworkSiteService from "./NetworkSiteService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import RelationIdUtil from "../Utils/Database/RelationIdUtil";
+import NetworkSiteHierarchyLock from "../Utils/NetworkSite/NetworkSiteHierarchyLock";
 import Model from "../../Models/DatabaseModels/NetworkSiteType";
+import NetworkSiteTypeHierarchyUtil from "../../Utils/NetworkSite/TypeHierarchyUtil";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import BadDataException from "../../Types/Exception/BadDataException";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import PositiveNumber from "../../Types/PositiveNumber";
+const PARENT_NETWORK_SITE_TYPE_KEYS = [
+    "parentNetworkSiteTypeId",
+    "parentNetworkSiteType",
+];
+const PROJECT_KEYS = ["projectId", "project"];
+const EXISTING_SITES_DO_NOT_MATCH_MESSAGE = "This site type's parent cannot be changed because existing sites do not match the proposed hierarchy. Create a new site type under the desired parent, then move and reassign the sites to it.";
+const REFERENCE_VALIDATION_BATCH_SIZE = 1000;
+const normalizeId = (id) => {
+    return id.toString().toLowerCase();
+};
+const sameId = (left, right) => {
+    return normalizeId(left) === normalizeId(right);
+};
+/*
+ * Model instances contain properties initialised to undefined. Those are
+ * omissions, not writes: TypeORM drops them before producing INSERT/SET.
+ * Null, on the other hand, is an explicit request to make this a root type.
+ */
+const isAnyKeyWritten = (data, keys) => {
+    return keys.some((key) => {
+        return key in data && data[key] !== undefined;
+    });
+};
+const assertNoSqlExpression = (data, keys) => {
+    for (const key of keys) {
+        if (typeof data[key] === "function") {
+            throw new BadDataException(`${key} cannot be set to a raw SQL expression because the site type hierarchy must be validated against an actual parent ID.`);
+        }
+    }
+};
+const assertIsUnitLevelIsNotSqlExpression = (data) => {
+    if (typeof data["isUnitLevel"] === "function") {
+        throw new BadDataException("isUnitLevel cannot be set to a raw SQL expression because unit-level leaf rules must be validated against an actual boolean value.");
+    }
+};
 export class Service extends DatabaseService {
     constructor() {
         super(Model);
     }
+    /*
+     * NetworkSite and NetworkSiteType validate one shared graph. Keep the Redis
+     * mutex around the complete DatabaseService mutation (before hooks, write,
+     * and success hooks), not inside an individual hook, so every error path
+     * releases it and a concurrent site/type request cannot validate stale
+     * project state.
+     */
+    async create(createBy) {
+        if (createBy.props.ignoreHooks) {
+            return await super.create(createBy);
+        }
+        const projectId = createBy.props.tenantId ||
+            this.readProjectId(createBy.data) ||
+            null;
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds: projectId ? [projectId] : [],
+            operation: async () => {
+                return await super.create(createBy);
+            },
+        });
+    }
+    async updateOneBy(updateOneBy) {
+        if (updateOneBy.props.ignoreHooks ||
+            !this.updateTouchesHierarchy(updateOneBy.data)) {
+            return await super.updateOneBy(updateOneBy);
+        }
+        const projectIds = await this.findMutationProjectIds({
+            query: updateOneBy.query,
+            props: updateOneBy.props,
+            limit: 1,
+            skip: 0,
+            isDelete: false,
+        });
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds,
+            operation: async () => {
+                return await super.updateOneBy(updateOneBy);
+            },
+        });
+    }
+    async updateBy(updateBy) {
+        if (updateBy.props.ignoreHooks ||
+            !this.updateTouchesHierarchy(updateBy.data)) {
+            return await super.updateBy(updateBy);
+        }
+        const projectIds = await this.findMutationProjectIds({
+            query: updateBy.query,
+            props: updateBy.props,
+            limit: this.positiveNumberValue(updateBy.limit, LIMIT_MAX),
+            skip: this.positiveNumberValue(updateBy.skip, 0),
+            isDelete: false,
+        });
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds,
+            operation: async () => {
+                return await super.updateBy(updateBy);
+            },
+        });
+    }
+    async deleteOneBy(deleteOneBy) {
+        if (deleteOneBy.props.ignoreHooks) {
+            return await super.deleteOneBy(deleteOneBy);
+        }
+        const projectIds = await this.findMutationProjectIds({
+            query: deleteOneBy.query,
+            props: deleteOneBy.props,
+            limit: 1,
+            skip: 0,
+            isDelete: true,
+        });
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds,
+            operation: async () => {
+                return await super.deleteOneBy(deleteOneBy);
+            },
+        });
+    }
+    async deleteBy(deleteBy) {
+        if (deleteBy.props.ignoreHooks) {
+            return await super.deleteBy(deleteBy);
+        }
+        const projectIds = await this.findMutationProjectIds({
+            query: deleteBy.query,
+            props: deleteBy.props,
+            limit: this.positiveNumberValue(deleteBy.limit, LIMIT_MAX),
+            skip: this.positiveNumberValue(deleteBy.skip, 0),
+            isDelete: true,
+        });
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds,
+            operation: async () => {
+                return await super.deleteBy(deleteBy);
+            },
+        });
+    }
+    async hardDeleteBy(deleteBy) {
+        if (deleteBy.props.ignoreHooks) {
+            return await super.hardDeleteBy(deleteBy);
+        }
+        /*
+         * The retention cron uses one root deletedAt query across all projects.
+         * Convert it to a closed batch of unused leaf types before locking. A
+         * parent and child can therefore never be split by the batch limit; once
+         * leaves are removed, the cron's next iteration can work upward.
+         */
+        if (!NetworkSiteHierarchyLock.isSafeRootMutationScope({
+            query: deleteBy.query,
+            props: deleteBy.props,
+            tenantScopeIsClosed: true,
+        })) {
+            return await this.hardDeleteClosedLeafBatch(deleteBy);
+        }
+        const projectIds = await this.findMutationProjectIds({
+            query: deleteBy.query,
+            props: deleteBy.props,
+            limit: this.positiveNumberValue(deleteBy.limit, LIMIT_MAX),
+            skip: this.positiveNumberValue(deleteBy.skip, 0),
+            isDelete: true,
+        });
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds,
+            operation: async () => {
+                return await super.hardDeleteBy(deleteBy);
+            },
+        });
+    }
+    updateTouchesHierarchy(data) {
+        const record = data;
+        return (isAnyKeyWritten(record, PARENT_NETWORK_SITE_TYPE_KEYS) ||
+            ("isUnitLevel" in record && record["isUnitLevel"] !== undefined) ||
+            isAnyKeyWritten(record, PROJECT_KEYS));
+    }
+    positiveNumberValue(value, fallback) {
+        if (value instanceof PositiveNumber) {
+            return value.toNumber();
+        }
+        return value !== null && value !== void 0 ? value : fallback;
+    }
+    async hardDeleteClosedLeafBatch(deleteBy) {
+        const requestedLimit = this.positiveNumberValue(deleteBy.limit, LIMIT_MAX);
+        if (requestedLimit <= 0) {
+            return 0;
+        }
+        const scanPageSize = Math.min(REFERENCE_VALIDATION_BATCH_SIZE, requestedLimit);
+        const leafTypes = [];
+        let scanSkip = this.positiveNumberValue(deleteBy.skip, 0);
+        while (leafTypes.length < requestedLimit) {
+            const candidates = await this.findBy({
+                query: deleteBy.query,
+                select: { _id: true, projectId: true },
+                sort: { _id: SortOrder.Ascending },
+                limit: scanPageSize,
+                skip: scanSkip,
+                props: { isRoot: true },
+            });
+            if (candidates.length === 0) {
+                break;
+            }
+            const candidateIds = candidates
+                .map((candidate) => {
+                return candidate.id || null;
+            })
+                .filter((id) => {
+                return Boolean(id);
+            });
+            const referencedTypeIds = new Set();
+            for (let candidateOffset = 0; candidateOffset < candidateIds.length; candidateOffset += REFERENCE_VALIDATION_BATCH_SIZE) {
+                const candidateIdBatch = candidateIds.slice(candidateOffset, candidateOffset + REFERENCE_VALIDATION_BATCH_SIZE);
+                let childSkip = 0;
+                while (candidateIdBatch.length > 0) {
+                    const childTypes = await this.findBy({
+                        query: {
+                            parentNetworkSiteTypeId: QueryHelper.any(candidateIdBatch),
+                        },
+                        select: { parentNetworkSiteTypeId: true },
+                        sort: { _id: SortOrder.Ascending },
+                        limit: REFERENCE_VALIDATION_BATCH_SIZE,
+                        skip: childSkip,
+                        props: { isRoot: true },
+                    });
+                    for (const childType of childTypes) {
+                        if (childType.parentNetworkSiteTypeId) {
+                            referencedTypeIds.add(normalizeId(childType.parentNetworkSiteTypeId));
+                        }
+                    }
+                    if (childTypes.length < REFERENCE_VALIDATION_BATCH_SIZE) {
+                        break;
+                    }
+                    childSkip += childTypes.length;
+                }
+                let siteSkip = 0;
+                while (candidateIdBatch.length > 0) {
+                    const sites = await NetworkSiteService.findBy({
+                        query: {
+                            networkSiteTypeId: QueryHelper.any(candidateIdBatch),
+                        },
+                        select: { networkSiteTypeId: true },
+                        sort: { _id: SortOrder.Ascending },
+                        limit: REFERENCE_VALIDATION_BATCH_SIZE,
+                        skip: siteSkip,
+                        props: { isRoot: true },
+                    });
+                    for (const site of sites) {
+                        if (site.networkSiteTypeId) {
+                            referencedTypeIds.add(normalizeId(site.networkSiteTypeId));
+                        }
+                    }
+                    if (sites.length < REFERENCE_VALIDATION_BATCH_SIZE) {
+                        break;
+                    }
+                    siteSkip += sites.length;
+                }
+            }
+            for (const candidate of candidates) {
+                if (candidate.id &&
+                    candidate.projectId &&
+                    !referencedTypeIds.has(normalizeId(candidate.id))) {
+                    leafTypes.push(candidate);
+                    if (leafTypes.length === requestedLimit) {
+                        break;
+                    }
+                }
+            }
+            scanSkip += candidates.length;
+            if (candidates.length < scanPageSize) {
+                break;
+            }
+        }
+        if (leafTypes.length === 0) {
+            return 0;
+        }
+        const leafTypeIds = leafTypes.map((networkSiteType) => {
+            return networkSiteType.id;
+        });
+        return await NetworkSiteHierarchyLock.runExclusive({
+            projectIds: leafTypes.map((networkSiteType) => {
+                return networkSiteType.projectId;
+            }),
+            operation: async () => {
+                return await super.hardDeleteBy(Object.assign(Object.assign({}, deleteBy), { query: Object.assign(Object.assign({}, deleteBy.query), { _id: QueryHelper.any(leafTypeIds) }), limit: leafTypeIds.length, skip: 0 }));
+            },
+        });
+    }
+    async findMutationProjectIds(data) {
+        NetworkSiteHierarchyLock.assertSafeRootMutationScope({
+            query: data.query,
+            props: data.props,
+            tenantScopeIsClosed: data.isDelete,
+        });
+        const networkSiteTypes = await this.findBy({
+            query: data.isDelete
+                ? this.scopeDeleteQueryToCallerTenant(data.query, data.props)
+                : this.scopeQueryToCallerTenant(data.query, data.props),
+            select: { projectId: true },
+            limit: data.limit,
+            skip: data.skip,
+            props: { isRoot: true },
+        });
+        const projectIds = networkSiteTypes
+            .map((networkSiteType) => {
+            return networkSiteType.projectId;
+        })
+            .filter((projectId) => {
+            return Boolean(projectId);
+        });
+        projectIds.push(...NetworkSiteHierarchyLock.getExplicitProjectIds(data.query));
+        if (projectIds.length === 0 && data.props.tenantId) {
+            projectIds.push(data.props.tenantId);
+        }
+        const seenProjectIds = new Set();
+        return projectIds.filter((projectId) => {
+            const normalizedProjectId = normalizeId(projectId);
+            if (seenProjectIds.has(normalizedProjectId)) {
+                return false;
+            }
+            seenProjectIds.add(normalizedProjectId);
+            return true;
+        });
+    }
+    scopeQueryToCallerTenant(query, props) {
+        if (props.isRoot || props.isMasterAdmin || !props.tenantId) {
+            return query;
+        }
+        return Object.assign(Object.assign({}, query), { projectId: props.tenantId });
+    }
+    /*
+     * DeletePermission retains tenant scoping for root callers that provide a
+     * tenantId. The hierarchy preflight must select the identical window.
+     */
+    scopeDeleteQueryToCallerTenant(query, props) {
+        if (!props.tenantId || props.isMultiTenantRequest) {
+            return query;
+        }
+        return Object.assign(Object.assign({}, query), { projectId: props.tenantId });
+    }
+    readProjectId(data) {
+        for (const key of PROJECT_KEYS) {
+            const value = data[key];
+            const isExplicitClear = value === null || value === "";
+            if (typeof value === "function") {
+                throw new BadDataException(`${key} cannot be set to a raw SQL expression because the Network Site Type project must be validated against an actual ID.`);
+            }
+            if (value !== undefined &&
+                !isExplicitClear &&
+                !RelationIdUtil.read(data, [key])) {
+                throw new BadDataException(`${key} must contain a valid Project ID.`);
+            }
+        }
+        return RelationIdUtil.readConsistent(data, PROJECT_KEYS, "project");
+    }
+    /*
+     * Dashboard entity pickers submit the relation object; services and
+     * migrations usually submit the scalar FK. Validate both, and refuse a
+     * contradictory pair rather than relying on ORM precedence for the shared
+     * join column.
+     */
+    readParentId(data) {
+        assertNoSqlExpression(data, PARENT_NETWORK_SITE_TYPE_KEYS);
+        for (const key of PARENT_NETWORK_SITE_TYPE_KEYS) {
+            const value = data[key];
+            const isExplicitClear = value === null || value === "";
+            if (value !== undefined &&
+                !isExplicitClear &&
+                !RelationIdUtil.read(data, [key])) {
+                throw new BadDataException(`${key} must contain a valid Network Site Type ID.`);
+            }
+        }
+        return RelationIdUtil.readConsistent(data, PARENT_NETWORK_SITE_TYPE_KEYS, "parent Network Site Type");
+    }
+    async getNextSiblingOrder(data) {
+        const siblings = await this.findAllNetworkSiteTypes({
+            query: {
+                projectId: data.projectId,
+                parentNetworkSiteTypeId: data.parentNetworkSiteTypeId
+                    ? data.parentNetworkSiteTypeId
+                    : QueryHelper.isNull(),
+            },
+            select: { order: true },
+        });
+        const maxOrder = siblings.reduce((currentMax, sibling) => {
+            return typeof sibling.order === "number"
+                ? Math.max(currentMax !== null && currentMax !== void 0 ? currentMax : sibling.order, sibling.order)
+                : currentMax;
+        }, null);
+        return maxOrder === null ? 1 : maxOrder + 1;
+    }
+    async findAllNetworkSiteTypes(data) {
+        const networkSiteTypes = [];
+        let skip = 0;
+        while (true) {
+            const page = await this.findBy({
+                query: data.query,
+                select: data.select,
+                sort: { _id: SortOrder.Ascending },
+                limit: LIMIT_MAX,
+                skip,
+                props: { isRoot: true },
+            });
+            networkSiteTypes.push(...page);
+            if (page.length < LIMIT_MAX) {
+                return networkSiteTypes;
+            }
+            skip += page.length;
+        }
+    }
+    /*
+     * Network estates regularly exceed LIMIT_MAX. Every hierarchy invariant is
+     * universal ("all sites match"), so silently validating only the first page
+     * would make its result depend on row order. A stable id sort also prevents
+     * offset pages from overlapping while these read-only checks run.
+     */
+    async findAllNetworkSites(data) {
+        const sites = [];
+        let skip = 0;
+        while (true) {
+            const page = await NetworkSiteService.findBy({
+                query: data.query,
+                select: data.select,
+                sort: { _id: SortOrder.Ascending },
+                limit: LIMIT_MAX,
+                skip,
+                props: { isRoot: true },
+            });
+            sites.push(...page);
+            if (page.length < LIMIT_MAX) {
+                return sites;
+            }
+            skip += page.length;
+        }
+    }
+    async assertParentIsValid(data) {
+        if (data.networkSiteTypeId &&
+            sameId(data.networkSiteTypeId, data.parentNetworkSiteTypeId)) {
+            throw new BadDataException("A Network Site Type cannot be its own parent.");
+        }
+        const parent = await this.findOneById({
+            id: data.parentNetworkSiteTypeId,
+            select: {
+                _id: true,
+                projectId: true,
+                isUnitLevel: true,
+            },
+            props: { isRoot: true },
+        });
+        if (!parent) {
+            throw new BadDataException("Parent Network Site Type not found.");
+        }
+        if (!parent.projectId || !sameId(parent.projectId, data.projectId)) {
+            throw new BadDataException("Parent Network Site Type must belong to the same project.");
+        }
+        if (parent.isUnitLevel === true) {
+            throw new BadDataException("A unit-level Network Site Type cannot have child types.");
+        }
+        if (!data.networkSiteTypeId) {
+            return;
+        }
+        const networkSiteTypes = await this.findAllNetworkSiteTypes({
+            query: { projectId: data.projectId },
+            select: {
+                _id: true,
+                parentNetworkSiteTypeId: true,
+            },
+        });
+        const movingType = new Model();
+        movingType.id = data.networkSiteTypeId;
+        const parentIsDescendant = NetworkSiteTypeHierarchyUtil.getDescendantNetworkSiteTypes({
+            networkSiteType: movingType,
+            networkSiteTypes,
+        }).some((descendant) => {
+            return Boolean(descendant.id && sameId(descendant.id, data.parentNetworkSiteTypeId));
+        });
+        if (parentIsDescendant) {
+            throw new BadDataException("A Network Site Type cannot be moved under one of its descendants.");
+        }
+    }
+    /*
+     * Changing a type definition must not retroactively make the concrete site
+     * tree invalid. A root type may only describe root sites; a child type may
+     * only describe sites whose actual parent has the declared parent type.
+     */
+    async assertExistingSitesMatchProposedParent(data) {
+        const sites = await this.findAllNetworkSites({
+            query: { networkSiteTypeId: data.networkSiteTypeId },
+            select: {
+                _id: true,
+                parentSiteId: true,
+            },
+        });
+        if (sites.length === 0) {
+            return;
+        }
+        if (!data.proposedParentNetworkSiteTypeId) {
+            if (sites.some((site) => {
+                return Boolean(site.parentSiteId);
+            })) {
+                throw new BadDataException(EXISTING_SITES_DO_NOT_MATCH_MESSAGE);
+            }
+            return;
+        }
+        const parentSiteIds = [];
+        const distinctParentSiteIds = new Set();
+        for (const site of sites) {
+            if (!site.parentSiteId) {
+                throw new BadDataException(EXISTING_SITES_DO_NOT_MATCH_MESSAGE);
+            }
+            const normalizedParentSiteId = normalizeId(site.parentSiteId);
+            if (!distinctParentSiteIds.has(normalizedParentSiteId)) {
+                distinctParentSiteIds.add(normalizedParentSiteId);
+                parentSiteIds.push(site.parentSiteId);
+            }
+        }
+        const parentSites = [];
+        for (let offset = 0; offset < parentSiteIds.length; offset += LIMIT_MAX) {
+            const parentSiteIdBatch = parentSiteIds.slice(offset, offset + LIMIT_MAX);
+            parentSites.push(...(await this.findAllNetworkSites({
+                query: {
+                    _id: QueryHelper.any(parentSiteIdBatch.map((parentSiteId) => {
+                        return parentSiteId.toString();
+                    })),
+                },
+                select: {
+                    _id: true,
+                    networkSiteTypeId: true,
+                },
+            })));
+        }
+        const parentTypeBySiteId = new Map();
+        for (const parentSite of parentSites) {
+            if (parentSite.id && parentSite.networkSiteTypeId) {
+                parentTypeBySiteId.set(normalizeId(parentSite.id), parentSite.networkSiteTypeId);
+            }
+        }
+        const hasMismatch = parentSiteIds.some((parentSiteId) => {
+            const actualParentTypeId = parentTypeBySiteId.get(normalizeId(parentSiteId));
+            return (!actualParentTypeId ||
+                !sameId(actualParentTypeId, data.proposedParentNetworkSiteTypeId));
+        });
+        if (hasMismatch) {
+            throw new BadDataException(EXISTING_SITES_DO_NOT_MATCH_MESSAGE);
+        }
+    }
+    async assertTypesCanBecomeUnitLevel(networkSiteTypes) {
+        const networkSiteTypeIds = networkSiteTypes
+            .map((networkSiteType) => {
+            return networkSiteType.id;
+        })
+            .filter((id) => {
+            return Boolean(id);
+        });
+        if (networkSiteTypeIds.length === 0) {
+            return;
+        }
+        const projectIds = [
+            ...new Set(networkSiteTypes
+                .map((networkSiteType) => {
+                var _a;
+                return (_a = networkSiteType.projectId) === null || _a === void 0 ? void 0 : _a.toString();
+            })
+                .filter((projectId) => {
+                return Boolean(projectId);
+            })),
+        ];
+        const child = await this.findOneBy({
+            query: Object.assign({ parentNetworkSiteTypeId: QueryHelper.any(networkSiteTypeIds.map((id) => {
+                    return id.toString();
+                })) }, (projectIds.length > 0
+                ? { projectId: QueryHelper.any(projectIds) }
+                : {})),
+            select: { _id: true },
+            props: { isRoot: true },
+        });
+        if (child) {
+            throw new BadDataException("A Network Site Type with child types cannot be made unit-level.");
+        }
+        const sitesOfTypes = await this.findAllNetworkSites({
+            query: {
+                networkSiteTypeId: QueryHelper.any(networkSiteTypeIds.map((id) => {
+                    return id.toString();
+                })),
+            },
+            select: { _id: true },
+        });
+        const siteIds = sitesOfTypes
+            .map((site) => {
+            var _a;
+            return (_a = site.id) === null || _a === void 0 ? void 0 : _a.toString();
+        })
+            .filter((id) => {
+            return Boolean(id);
+        });
+        if (siteIds.length === 0) {
+            return;
+        }
+        for (let offset = 0; offset < siteIds.length; offset += REFERENCE_VALIDATION_BATCH_SIZE) {
+            const childSite = await NetworkSiteService.findOneBy({
+                query: Object.assign({ parentSiteId: QueryHelper.any(siteIds.slice(offset, offset + REFERENCE_VALIDATION_BATCH_SIZE)) }, (projectIds.length > 0
+                    ? { projectId: QueryHelper.any(projectIds) }
+                    : {})),
+                select: { _id: true },
+                props: { isRoot: true },
+            });
+            if (childSite) {
+                throw new BadDataException("A Network Site Type whose sites have child sites cannot be made unit-level.");
+            }
+        }
+    }
+    async onBeforeCreate(createBy) {
+        const data = createBy.data;
+        assertIsUnitLevelIsNotSqlExpression(data);
+        const parentNetworkSiteTypeId = this.readParentId(data);
+        const projectId = createBy.props.tenantId || this.readProjectId(data) || null;
+        if (!projectId) {
+            throw new BadDataException("Project ID is required.");
+        }
+        if (parentNetworkSiteTypeId) {
+            await this.assertParentIsValid({
+                networkSiteTypeId: createBy.data.id,
+                parentNetworkSiteTypeId,
+                projectId,
+            });
+        }
+        if (createBy.data.order === undefined || createBy.data.order === null) {
+            createBy.data.order = await this.getNextSiblingOrder({
+                projectId,
+                parentNetworkSiteTypeId,
+            });
+        }
+        return { createBy, carryForward: null };
+    }
+    async onBeforeUpdate(updateBy) {
+        const data = (updateBy.data ||
+            {});
+        assertIsUnitLevelIsNotSqlExpression(data);
+        const isParentWritten = isAnyKeyWritten(data, PARENT_NETWORK_SITE_TYPE_KEYS);
+        const isBecomingUnitLevel = data["isUnitLevel"] === true;
+        const isProjectWritten = isAnyKeyWritten(data, PROJECT_KEYS);
+        const proposedProjectId = isProjectWritten
+            ? this.readProjectId(data)
+            : null;
+        if (!isParentWritten && !isBecomingUnitLevel && !isProjectWritten) {
+            return { updateBy, carryForward: null };
+        }
+        if (isProjectWritten && !proposedProjectId) {
+            throw new BadDataException("A Network Site Type cannot be moved to another project.");
+        }
+        const proposedParentNetworkSiteTypeId = isParentWritten
+            ? this.readParentId(data)
+            : null;
+        const updateLimit = updateBy.limit instanceof PositiveNumber
+            ? updateBy.limit.toNumber()
+            : updateBy.limit || LIMIT_MAX;
+        const updateSkip = updateBy.skip instanceof PositiveNumber
+            ? updateBy.skip.toNumber()
+            : updateBy.skip || 0;
+        const networkSiteTypesBeingUpdated = await this.findBy({
+            query: this.scopeQueryToCallerTenant(updateBy.query, updateBy.props),
+            select: {
+                _id: true,
+                projectId: true,
+                parentNetworkSiteTypeId: true,
+                isUnitLevel: true,
+            },
+            limit: updateLimit,
+            skip: updateSkip,
+            props: { isRoot: true },
+        });
+        if (isProjectWritten) {
+            for (const networkSiteType of networkSiteTypesBeingUpdated) {
+                if (!networkSiteType.projectId ||
+                    !proposedProjectId ||
+                    !sameId(networkSiteType.projectId, proposedProjectId)) {
+                    throw new BadDataException("A Network Site Type cannot be moved to another project.");
+                }
+            }
+        }
+        if (!isParentWritten && !isBecomingUnitLevel) {
+            return { updateBy, carryForward: null };
+        }
+        if (isBecomingUnitLevel) {
+            await this.assertTypesCanBecomeUnitLevel(networkSiteTypesBeingUpdated.filter((networkSiteType) => {
+                return networkSiteType.isUnitLevel !== true;
+            }));
+        }
+        if (isParentWritten) {
+            for (const networkSiteType of networkSiteTypesBeingUpdated) {
+                if (!networkSiteType.id || !networkSiteType.projectId) {
+                    continue;
+                }
+                if (proposedParentNetworkSiteTypeId) {
+                    await this.assertParentIsValid({
+                        networkSiteTypeId: networkSiteType.id,
+                        parentNetworkSiteTypeId: proposedParentNetworkSiteTypeId,
+                        projectId: networkSiteType.projectId,
+                    });
+                }
+                const currentParentId = NetworkSiteTypeHierarchyUtil.getParentId(networkSiteType);
+                const parentChanged = proposedParentNetworkSiteTypeId
+                    ? !currentParentId ||
+                        !sameId(currentParentId, proposedParentNetworkSiteTypeId)
+                    : Boolean(currentParentId);
+                if (parentChanged) {
+                    await this.assertExistingSitesMatchProposedParent({
+                        networkSiteTypeId: networkSiteType.id,
+                        proposedParentNetworkSiteTypeId,
+                    });
+                    if (networkSiteTypesBeingUpdated.length === 1 &&
+                        data["order"] === undefined) {
+                        updateBy.data.order = await this.getNextSiblingOrder({
+                            projectId: networkSiteType.projectId,
+                            parentNetworkSiteTypeId: proposedParentNetworkSiteTypeId,
+                        });
+                    }
+                }
+            }
+        }
+        return { updateBy, carryForward: null };
+    }
+    async onBeforeDelete(deleteBy) {
+        const deleteLimit = deleteBy.limit instanceof PositiveNumber
+            ? deleteBy.limit.toNumber()
+            : deleteBy.limit || LIMIT_MAX;
+        const deleteSkip = deleteBy.skip instanceof PositiveNumber
+            ? deleteBy.skip.toNumber()
+            : deleteBy.skip || 0;
+        const networkSiteTypesBeingDeleted = await this.findBy({
+            query: this.scopeDeleteQueryToCallerTenant(deleteBy.query, deleteBy.props),
+            select: { _id: true, projectId: true },
+            limit: deleteLimit,
+            skip: deleteSkip,
+            props: { isRoot: true },
+        });
+        const ids = networkSiteTypesBeingDeleted
+            .map((networkSiteType) => {
+            return networkSiteType.id;
+        })
+            .filter((id) => {
+            return Boolean(id);
+        });
+        if (ids.length === 0) {
+            return { deleteBy, carryForward: null };
+        }
+        const idStrings = ids.map((id) => {
+            return id.toString();
+        });
+        const deletingIds = new Set(idStrings.map((id) => {
+            return normalizeId(id);
+        }));
+        const projectIdStrings = [
+            ...new Set(networkSiteTypesBeingDeleted
+                .map((networkSiteType) => {
+                var _a;
+                return (_a = networkSiteType.projectId) === null || _a === void 0 ? void 0 : _a.toString();
+            })
+                .filter((projectId) => {
+                return Boolean(projectId);
+            })),
+        ];
+        for (let parentOffset = 0; parentOffset < idStrings.length; parentOffset += REFERENCE_VALIDATION_BATCH_SIZE) {
+            const parentIdBatch = idStrings.slice(parentOffset, parentOffset + REFERENCE_VALIDATION_BATCH_SIZE);
+            let childSkip = 0;
+            while (true) {
+                const childTypes = await this.findBy({
+                    query: Object.assign({ parentNetworkSiteTypeId: QueryHelper.any(parentIdBatch) }, (projectIdStrings.length > 0
+                        ? { projectId: QueryHelper.any(projectIdStrings) }
+                        : {})),
+                    select: { _id: true },
+                    sort: { _id: SortOrder.Ascending },
+                    limit: REFERENCE_VALIDATION_BATCH_SIZE,
+                    skip: childSkip,
+                    props: { isRoot: true },
+                });
+                const hasSurvivingChild = childTypes.some((child) => {
+                    return !child.id || !deletingIds.has(normalizeId(child.id));
+                });
+                if (hasSurvivingChild) {
+                    throw new BadDataException("A Network Site Type cannot be deleted while child types use it as their parent.");
+                }
+                if (childTypes.length < REFERENCE_VALIDATION_BATCH_SIZE) {
+                    break;
+                }
+                childSkip += childTypes.length;
+            }
+            const site = await NetworkSiteService.findOneBy({
+                query: {
+                    networkSiteTypeId: QueryHelper.any(parentIdBatch),
+                },
+                select: { _id: true },
+                props: { isRoot: true },
+            });
+            if (site) {
+                throw new BadDataException("A Network Site Type cannot be deleted while Network Sites use it.");
+            }
+        }
+        return { deleteBy, carryForward: null };
+    }
 }
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "create", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "updateOneBy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "updateBy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "deleteOneBy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "deleteBy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "hardDeleteBy", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeCreate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeUpdate", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeDelete", null);
 export default new Service();
 //# sourceMappingURL=NetworkSiteTypeService.js.map