@rytass/bpm-core-nestjs-module 0.5.0 → 0.5.1

package/src/lib/organization/organization.service.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationService = void 0;
+const tslib_1 = require("tslib");
+const node_crypto_1 = require("node:crypto");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const manager_resolution_entity_1 = require("./manager-resolution.entity");
+const membership_entity_1 = require("./membership.entity");
+const org_unit_entity_1 = require("./org-unit.entity");
+const organization_enums_1 = require("./organization.enums");
+const position_entity_1 = require("./position.entity");
+const json_metadata_1 = require("./json-metadata");
+const ROOT_PATH_PREFIX = 'org';
+const BUSINESS_TIME_ZONE = 'Asia/Taipei';
+/**
+ * Upper bound for a single paginated page. Callers that need the complete list
+ * (org tree, id->name mapping, dropdowns) must instead opt in explicitly via
+ * `all: true` (or, historically, by omitting `pageSize`), which bypasses this
+ * cap. A `pageSize` larger than this is clamped and logged rather than silently
+ * truncated.
+ */
+const MAX_PAGE_SIZE = 100;
+const paginationLogger = new common_1.Logger('OrganizationPagination');
+let OrganizationService = class OrganizationService {
+    constructor(dataSource, orgUnitRepository, positionRepository, membershipRepository, managerResolutionRepository) {
+        this.dataSource = dataSource;
+        this.orgUnitRepository = orgUnitRepository;
+        this.positionRepository = positionRepository;
+        this.membershipRepository = membershipRepository;
+        this.managerResolutionRepository = managerResolutionRepository;
+    }
+    async createOrgUnit(input) {
+        await this.assertOrgUnitCodeAvailable(input.code);
+        const id = (0, node_crypto_1.randomUUID)();
+        const parent = input.parentId
+            ? await this.getOrgUnitOrThrow(input.parentId)
+            : null;
+        const pathSegment = this.buildPathSegment(id);
+        const path = parent
+            ? `${parent.path}.${pathSegment}`
+            : `${ROOT_PATH_PREFIX}.${pathSegment}`;
+        const entity = this.orgUnitRepository.create({
+            code: input.code,
+            id,
+            metadata: (0, json_metadata_1.parseMetadataJson)(input.metadataJson),
+            name: input.name,
+            parentId: input.parentId,
+            path,
+            type: input.type,
+        });
+        return this.orgUnitRepository.save(entity);
+    }
+    async updateOrgUnit(input) {
+        const existing = await this.getOrgUnitOrThrow(input.id);
+        const nextParentId = input.parentId === undefined ? existing.parentId : input.parentId;
+        const parent = nextParentId
+            ? await this.getOrgUnitOrThrow(nextParentId)
+            : null;
+        const nextCode = input.code ?? existing.code;
+        if (nextParentId === existing.id) {
+            throw new common_1.BadRequestException('Org unit cannot be its own parent');
+        }
+        if (parent && parent.path.startsWith(`${existing.path}.`)) {
+            throw new common_1.BadRequestException('Org unit cannot be moved under its descendant');
+        }
+        await this.assertOrgUnitCodeAvailable(nextCode, existing.id);
+        const pathSegment = this.buildPathSegment(existing.id);
+        const path = parent
+            ? `${parent.path}.${pathSegment}`
+            : `${ROOT_PATH_PREFIX}.${pathSegment}`;
+        const previousPath = existing.path;
+        const next = this.orgUnitRepository.merge(existing, {
+            code: nextCode,
+            metadata: input.metadataJson
+                ? (0, json_metadata_1.parseMetadataJson)(input.metadataJson)
+                : existing.metadata,
+            name: input.name ?? existing.name,
+            parentId: nextParentId,
+            path,
+            type: input.type ?? existing.type,
+        });
+        return this.dataSource.transaction(async (manager) => {
+            const saved = await manager.getRepository(org_unit_entity_1.OrgUnitEntity).save(next);
+            if (saved.path !== previousPath) {
+                const descendants = await manager
+                    .getRepository(org_unit_entity_1.OrgUnitEntity)
+                    .createQueryBuilder('orgUnit')
+                    .where('orgUnit.deleted_at IS NULL')
+                    .andWhere('orgUnit.path <@ :previousPath', { previousPath })
+                    .andWhere('orgUnit.id != :id', { id: saved.id })
+                    .getMany();
+                await Promise.all(descendants.map((descendant) => {
+                    const updatedDescendant = manager
+                        .getRepository(org_unit_entity_1.OrgUnitEntity)
+                        .merge(descendant, {
+                        path: descendant.path.replace(previousPath, saved.path),
+                    });
+                    return manager
+                        .getRepository(org_unit_entity_1.OrgUnitEntity)
+                        .save(updatedDescendant);
+                }));
+            }
+            return saved;
+        });
+    }
+    async commitOrgUnitTreeDraft(input) {
+        if (!input.moves.length) {
+            return { orgUnits: [] };
+        }
+        this.assertUniqueOrgUnitTreeMoves(input.moves);
+        return this.dataSource.transaction(async (manager) => {
+            const repository = manager.getRepository(org_unit_entity_1.OrgUnitEntity);
+            const orgUnitIds = collectOrgUnitTreeDraftIds(input.moves);
+            const orgUnits = await repository.find({
+                where: { deletedAt: (0, typeorm_2.IsNull)(), id: (0, typeorm_2.In)(orgUnitIds) },
+            });
+            const orgUnitById = new Map(orgUnits.map((orgUnit) => [
+                orgUnit.id,
+                orgUnit,
+            ]));
+            this.assertOrgUnitTreeDraftReferences(input.moves, orgUnitById);
+            this.assertOrgUnitTreeDraftVersions(input.moves, orgUnitById);
+            this.assertOrgUnitTreeDraftHierarchy(input.moves, orgUnitById);
+            const affectedOrgUnits = new Map();
+            const sortedMoves = sortOrgUnitTreeDraftMoves(input.moves);
+            for (const move of sortedMoves) {
+                const existing = orgUnitById.get(move.id);
+                if (!existing) {
+                    throw new common_1.NotFoundException(`Org unit ${move.id} was not found`);
+                }
+                const parent = move.parentId
+                    ? orgUnitById.get(move.parentId) ?? null
+                    : null;
+                const previousPath = existing.path;
+                const nextPath = parent
+                    ? `${parent.path}.${this.buildPathSegment(existing.id)}`
+                    : `${ROOT_PATH_PREFIX}.${this.buildPathSegment(existing.id)}`;
+                if (existing.parentId === move.parentId &&
+                    existing.path === nextPath) {
+                    affectedOrgUnits.set(existing.id, existing);
+                    continue;
+                }
+                const saved = await repository.save(repository.merge(existing, {
+                    parentId: move.parentId,
+                    path: nextPath,
+                }));
+                orgUnitById.set(saved.id, saved);
+                affectedOrgUnits.set(saved.id, saved);
+                const descendants = await repository
+                    .createQueryBuilder('orgUnit')
+                    .where('orgUnit.deleted_at IS NULL')
+                    .andWhere('orgUnit.path <@ :previousPath', { previousPath })
+                    .andWhere('orgUnit.id != :id', { id: saved.id })
+                    .getMany();
+                for (const descendant of descendants) {
+                    const updatedDescendant = await repository.save(repository.merge(descendant, {
+                        path: descendant.path.replace(previousPath, saved.path),
+                    }));
+                    orgUnitById.set(updatedDescendant.id, updatedDescendant);
+                    affectedOrgUnits.set(updatedDescendant.id, updatedDescendant);
+                }
+            }
+            return {
+                orgUnits: [...affectedOrgUnits.values()].sort(compareOrgUnitPath),
+            };
+        });
+    }
+    async deleteOrgUnit(id) {
+        await this.getOrgUnitOrThrow(id);
+        const childCount = await this.orgUnitRepository.count({
+            where: { deletedAt: (0, typeorm_2.IsNull)(), parentId: id },
+        });
+        if (childCount > 0) {
+            throw new common_1.BadRequestException('Org unit with child units cannot be deleted');
+        }
+        const membershipCount = await this.membershipRepository.count({
+            where: { orgUnitId: id },
+        });
+        if (membershipCount > 0) {
+            throw new common_1.BadRequestException('Org unit with memberships cannot be deleted');
+        }
+        await this.orgUnitRepository.softDelete(id);
+        return true;
+    }
+    async getOrgUnit(id) {
+        return this.getOrgUnitOrThrow(id);
+    }
+    async listOrgUnits({ all, page, pageSize, parentId, searchText, type, } = {}) {
+        return this.orgUnitRepository.find({
+            ...createPaginationFindOptions({ all, page, pageSize }),
+            order: { path: 'ASC' },
+            where: createOrgUnitWhere({ parentId, searchText, type }),
+        });
+    }
+    async countOrgUnits({ parentId, searchText, type, } = {}) {
+        return this.orgUnitRepository.count({
+            where: createOrgUnitWhere({ parentId, searchText, type }),
+        });
+    }
+    async createPosition(input) {
+        await this.assertPositionCodeAvailable(input.code);
+        return this.positionRepository.save(this.positionRepository.create({
+            code: input.code,
+            level: input.level,
+            metadata: (0, json_metadata_1.parseMetadataJson)(input.metadataJson),
+            name: input.name,
+        }));
+    }
+    async updatePosition(input) {
+        const existing = await this.getPositionOrThrow(input.id);
+        const nextCode = input.code ?? existing.code;
+        await this.assertPositionCodeAvailable(nextCode, existing.id);
+        const next = this.positionRepository.merge(existing, {
+            code: nextCode,
+            level: input.level ?? existing.level,
+            metadata: input.metadataJson
+                ? (0, json_metadata_1.parseMetadataJson)(input.metadataJson)
+                : existing.metadata,
+            name: input.name ?? existing.name,
+        });
+        return this.positionRepository.save(next);
+    }
+    async listPositions({ page, pageSize, searchText, } = {}) {
+        return this.positionRepository.find({
+            ...createPaginationFindOptions({ page, pageSize }),
+            order: { level: 'DESC', code: 'ASC' },
+            where: createPositionWhere({ searchText }),
+        });
+    }
+    async countPositions({ searchText, } = {}) {
+        return this.positionRepository.count({
+            where: createPositionWhere({ searchText }),
+        });
+    }
+    async createMembership(input) {
+        await this.assertMembershipReferences(input);
+        await this.assertMembershipDateRange(input.effectiveFrom, input.effectiveTo);
+        if (input.isPrimary) {
+            await this.clearPrimaryMemberships(input.memberId);
+        }
+        return this.membershipRepository.save(this.membershipRepository.create(input));
+    }
+    async updateMembership(input) {
+        const existing = await this.getMembershipOrThrow(input.id);
+        const nextMemberId = existing.memberId;
+        const nextOrgUnitId = input.orgUnitId ?? existing.orgUnitId;
+        const nextPositionId = input.positionId === undefined ? existing.positionId : input.positionId;
+        const nextEffectiveFrom = input.effectiveFrom ?? existing.effectiveFrom;
+        const nextEffectiveTo = input.effectiveTo === undefined
+            ? existing.effectiveTo
+            : input.effectiveTo;
+        const nextIsPrimary = input.isPrimary ?? existing.isPrimary;
+        await this.assertMembershipReferences({
+            effectiveFrom: nextEffectiveFrom,
+            effectiveTo: nextEffectiveTo,
+            isPrimary: nextIsPrimary,
+            memberId: nextMemberId,
+            orgUnitId: nextOrgUnitId,
+            positionId: nextPositionId,
+        });
+        await this.assertMembershipDateRange(nextEffectiveFrom, nextEffectiveTo);
+        if (nextIsPrimary) {
+            await this.clearPrimaryMemberships(nextMemberId, existing.id);
+        }
+        const next = this.membershipRepository.merge(existing, {
+            effectiveFrom: nextEffectiveFrom,
+            effectiveTo: nextEffectiveTo,
+            isPrimary: nextIsPrimary,
+            orgUnitId: nextOrgUnitId,
+            positionId: nextPositionId,
+        });
+        return this.membershipRepository.save(next);
+    }
+    async deleteMembership(id) {
+        await this.getMembershipOrThrow(id);
+        await this.membershipRepository.delete(id);
+        return true;
+    }
+    async listMemberships({ activeOnly = false, memberId, orgUnitId, page, pageSize, positionId, } = {}) {
+        const date = this.toDateOnly(new Date());
+        return this.membershipRepository.find({
+            ...createPaginationFindOptions({ page, pageSize }),
+            order: { memberId: 'ASC', isPrimary: 'DESC', effectiveFrom: 'DESC' },
+            where: createMembershipWhere({
+                activeOnly,
+                date,
+                memberId,
+                orgUnitId,
+                positionId,
+            }),
+        });
+    }
+    async countMemberships({ activeOnly = false, memberId, orgUnitId, positionId, } = {}) {
+        const date = this.toDateOnly(new Date());
+        return this.membershipRepository.count({
+            where: createMembershipWhere({
+                activeOnly,
+                date,
+                memberId,
+                orgUnitId,
+                positionId,
+            }),
+        });
+    }
+    async createManagerResolution(input) {
+        await this.assertManagerResolutionReferences(input);
+        await this.assertMembershipDateRange(input.effectiveFrom, input.effectiveTo);
+        return this.managerResolutionRepository.save(this.managerResolutionRepository.create(input));
+    }
+    async updateManagerResolution(input) {
+        const existing = await this.getManagerResolutionOrThrow(input.id);
+        const nextScopeType = input.scopeType ?? existing.scopeType;
+        const nextScopeId = input.scopeId ?? existing.scopeId;
+        const nextManagerMemberId = input.managerMemberId ?? existing.managerMemberId;
+        const nextEffectiveFrom = input.effectiveFrom ?? existing.effectiveFrom;
+        const nextEffectiveTo = input.effectiveTo === undefined
+            ? existing.effectiveTo
+            : input.effectiveTo;
+        await this.assertManagerResolutionReferences({
+            effectiveFrom: nextEffectiveFrom,
+            effectiveTo: nextEffectiveTo,
+            managerMemberId: nextManagerMemberId,
+            priority: input.priority ?? existing.priority,
+            scopeId: nextScopeId,
+            scopeType: nextScopeType,
+        });
+        await this.assertMembershipDateRange(nextEffectiveFrom, nextEffectiveTo);
+        const next = this.managerResolutionRepository.merge(existing, {
+            effectiveFrom: nextEffectiveFrom,
+            effectiveTo: nextEffectiveTo,
+            managerMemberId: nextManagerMemberId,
+            priority: input.priority ?? existing.priority,
+            scopeId: nextScopeId,
+            scopeType: nextScopeType,
+        });
+        return this.managerResolutionRepository.save(next);
+    }
+    async deleteManagerResolution(id) {
+        await this.getManagerResolutionOrThrow(id);
+        await this.managerResolutionRepository.delete(id);
+        return true;
+    }
+    async listManagerResolutions({ activeOnly = false, page, pageSize, scopeId, scopeType, } = {}) {
+        const date = this.toDateOnly(new Date());
+        return this.managerResolutionRepository.find({
+            ...createPaginationFindOptions({ page, pageSize }),
+            order: { priority: 'DESC', createdAt: 'DESC' },
+            where: createManagerResolutionWhere({
+                activeOnly,
+                date,
+                scopeId,
+                scopeType,
+            }),
+        });
+    }
+    async countManagerResolutions({ activeOnly = false, scopeId, scopeType, } = {}) {
+        const date = this.toDateOnly(new Date());
+        return this.managerResolutionRepository.count({
+            where: createManagerResolutionWhere({
+                activeOnly,
+                date,
+                scopeId,
+                scopeType,
+            }),
+        });
+    }
+    async readOrganizationSummary() {
+        const [orgUnitCount, positionCount, membershipCount, managerResolutionCount,] = await Promise.all([
+            this.orgUnitRepository.count({ where: { deletedAt: (0, typeorm_2.IsNull)() } }),
+            this.positionRepository.count(),
+            this.membershipRepository.count(),
+            this.managerResolutionRepository.count(),
+        ]);
+        return {
+            managerResolutionCount,
+            membershipCount,
+            orgUnitCount,
+            positionCount,
+        };
+    }
+    async resolveManagerMemberId(memberId, effectiveAt = new Date()) {
+        const date = this.toDateOnly(effectiveAt);
+        const memberships = await this.findActiveMemberships(memberId, date);
+        const orgUnits = await this.findMembershipOrgUnits(memberships);
+        const positionIds = memberships
+            .map((membership) => membership.positionId)
+            .filter((positionId) => Boolean(positionId));
+        const candidatePairs = [
+            { scopeId: memberId, scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER },
+            ...orgUnits.map((orgUnit) => ({
+                scopeId: orgUnit.id,
+                scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
+            })),
+            ...positionIds.map((positionId) => ({
+                scopeId: positionId,
+                scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
+            })),
+        ];
+        const scopeIds = candidatePairs.map((pair) => pair.scopeId);
+        const resolutions = scopeIds.length
+            ? await this.managerResolutionRepository.find({
+                where: {
+                    scopeId: (0, typeorm_2.In)(scopeIds),
+                    scopeType: (0, typeorm_2.In)([
+                        organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER,
+                        organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
+                        organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
+                    ]),
+                },
+            })
+            : [];
+        const active = resolutions
+            .filter((resolution) => candidatePairs.some((pair) => pair.scopeId === resolution.scopeId &&
+            pair.scopeType === resolution.scopeType))
+            .filter((resolution) => this.isDateActive(resolution, date))
+            .sort((left, right) => this.compareManagerResolution(left, right));
+        return active[0]?.managerMemberId ?? null;
+    }
+    assertUniqueOrgUnitTreeMoves(moves) {
+        const moveIds = moves.map((move) => move.id);
+        const uniqueMoveIds = new Set(moveIds);
+        if (uniqueMoveIds.size !== moveIds.length) {
+            throw new common_1.BadRequestException('Org unit tree draft includes duplicate moves');
+        }
+    }
+    assertOrgUnitTreeDraftReferences(moves, orgUnitById) {
+        const missingId = collectOrgUnitTreeDraftIds(moves).find((id) => !orgUnitById.has(id));
+        if (missingId) {
+            throw new common_1.NotFoundException(`Org unit ${missingId} was not found`);
+        }
+    }
+    assertOrgUnitTreeDraftVersions(moves, orgUnitById) {
+        const staleMove = moves.find((move) => {
+            const orgUnit = orgUnitById.get(move.id);
+            return orgUnit
+                ? orgUnit.updatedAt.getTime() !== parseBaseUpdatedAt(move).getTime()
+                : false;
+        });
+        if (staleMove) {
+            throw new common_1.ConflictException(`Org unit ${staleMove.id} has changed since this draft was based`);
+        }
+    }
+    assertOrgUnitTreeDraftHierarchy(moves, orgUnitById) {
+        for (const move of moves) {
+            if (move.id === move.parentId) {
+                throw new common_1.BadRequestException('Org unit cannot be its own parent');
+            }
+            const existing = orgUnitById.get(move.id);
+            const parent = move.parentId ? orgUnitById.get(move.parentId) : null;
+            if (existing && parent?.path.startsWith(`${existing.path}.`)) {
+                throw new common_1.BadRequestException('Org unit cannot be moved under its descendant');
+            }
+        }
+        assertOrgUnitTreeDraftHasNoCycles(moves);
+    }
+    async getOrgUnitOrThrow(id) {
+        const entity = await this.orgUnitRepository.findOne({
+            where: { deletedAt: (0, typeorm_2.IsNull)(), id },
+        });
+        if (!entity) {
+            throw new common_1.NotFoundException(`Org unit ${id} was not found`);
+        }
+        return entity;
+    }
+    async getPositionOrThrow(id) {
+        const entity = await this.positionRepository.findOne({ where: { id } });
+        if (!entity) {
+            throw new common_1.NotFoundException(`Position ${id} was not found`);
+        }
+        return entity;
+    }
+    async assertOrgUnitCodeAvailable(code, exceptId) {
+        const existing = await this.orgUnitRepository.findOne({
+            where: {
+                code,
+                deletedAt: (0, typeorm_2.IsNull)(),
+                ...(exceptId ? { id: (0, typeorm_2.Not)(exceptId) } : {}),
+            },
+        });
+        if (existing) {
+            throw new common_1.BadRequestException(`Org unit code ${code} is already used`);
+        }
+    }
+    async assertPositionCodeAvailable(code, exceptId) {
+        const existing = await this.positionRepository.findOne({
+            where: {
+                code,
+                ...(exceptId ? { id: (0, typeorm_2.Not)(exceptId) } : {}),
+            },
+        });
+        if (existing) {
+            throw new common_1.BadRequestException(`Position code ${code} is already used`);
+        }
+    }
+    async assertMembershipReferences(input) {
+        await this.getOrgUnitOrThrow(input.orgUnitId);
+        if (input.positionId) {
+            await this.getPositionOrThrow(input.positionId);
+        }
+    }
+    async assertManagerResolutionReferences(input) {
+        if (input.scopeType === organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER &&
+            input.scopeId === input.managerMemberId) {
+            throw new common_1.BadRequestException('Manager cannot be the scoped member');
+        }
+        if (input.scopeType === organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT) {
+            await this.getOrgUnitOrThrow(input.scopeId);
+        }
+        if (input.scopeType === organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION) {
+            await this.getPositionOrThrow(input.scopeId);
+        }
+    }
+    async assertMembershipDateRange(effectiveFrom, effectiveTo) {
+        if (effectiveTo && effectiveFrom > effectiveTo) {
+            throw new common_1.BadRequestException('Effective from cannot be after effective to');
+        }
+    }
+    async clearPrimaryMemberships(memberId, exceptId) {
+        await this.membershipRepository.update({
+            isPrimary: true,
+            memberId,
+            ...(exceptId ? { id: (0, typeorm_2.Not)(exceptId) } : {}),
+        }, { isPrimary: false });
+    }
+    async getMembershipOrThrow(id) {
+        const entity = await this.membershipRepository.findOne({ where: { id } });
+        if (!entity) {
+            throw new common_1.NotFoundException(`Membership ${id} was not found`);
+        }
+        return entity;
+    }
+    async getManagerResolutionOrThrow(id) {
+        const entity = await this.managerResolutionRepository.findOne({
+            where: { id },
+        });
+        if (!entity) {
+            throw new common_1.NotFoundException(`Manager resolution ${id} was not found`);
+        }
+        return entity;
+    }
+    async findActiveMemberships(memberId, date) {
+        const memberships = await this.membershipRepository.find({
+            where: { memberId },
+        });
+        return memberships.filter((membership) => this.isDateActive(membership, date));
+    }
+    async findMembershipOrgUnits(memberships) {
+        const orgUnitIds = memberships.map((membership) => membership.orgUnitId);
+        if (!orgUnitIds.length) {
+            return [];
+        }
+        const directOrgUnits = await this.orgUnitRepository.find({
+            where: { deletedAt: (0, typeorm_2.IsNull)(), id: (0, typeorm_2.In)(orgUnitIds) },
+        });
+        const ancestorGroups = await Promise.all(directOrgUnits.map((orgUnit) => this.orgUnitRepository
+            .createQueryBuilder('orgUnit')
+            .where('orgUnit.deleted_at IS NULL')
+            .andWhere('orgUnit.path @> :path', { path: orgUnit.path })
+            .getMany()));
+        const flattened = ancestorGroups.flat();
+        const byId = new Map(flattened.map((orgUnit) => [
+            orgUnit.id,
+            orgUnit,
+        ]));
+        return [...byId.values()];
+    }
+    buildPathSegment(id) {
+        return `n${id.replace(/-/g, '_')}`;
+    }
+    toDateOnly(date) {
+        const parts = new Intl.DateTimeFormat('en-US', {
+            day: '2-digit',
+            month: '2-digit',
+            timeZone: BUSINESS_TIME_ZONE,
+            year: 'numeric',
+        }).formatToParts(date);
+        const byType = new Map(parts.map((part) => [part.type, part.value]));
+        return `${byType.get('year') ?? '1970'}-${byType.get('month') ?? '01'}-${byType.get('day') ?? '01'}`;
+    }
+    isDateActive(value, date) {
+        return (value.effectiveFrom <= date &&
+            (!value.effectiveTo || value.effectiveTo >= date));
+    }
+    compareManagerResolution(left, right) {
+        const priorityDiff = right.priority - left.priority;
+        if (priorityDiff !== 0) {
+            return priorityDiff;
+        }
+        return (this.scopeRank(right.scopeType) - this.scopeRank(left.scopeType) ||
+            right.effectiveFrom.localeCompare(left.effectiveFrom));
+    }
+    scopeRank(scopeType) {
+        const ranks = {
+            [organization_enums_1.ManagerResolutionScopeTypeEnum.MEMBER]: 3,
+            [organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT]: 2,
+            [organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION]: 1,
+        };
+        return ranks[scopeType];
+    }
+};
+exports.OrganizationService = OrganizationService;
+exports.OrganizationService = OrganizationService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(org_unit_entity_1.OrgUnitEntity)),
+    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(position_entity_1.PositionEntity)),
+    tslib_1.__param(3, (0, typeorm_1.InjectRepository)(membership_entity_1.MembershipEntity)),
+    tslib_1.__param(4, (0, typeorm_1.InjectRepository)(manager_resolution_entity_1.ManagerResolutionEntity)),
+    tslib_1.__metadata("design:paramtypes", [typeorm_2.DataSource,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository])
+], OrganizationService);
+function createOrgUnitWhere({ parentId, searchText, type, }) {
+    const parentWhere = parentId === undefined
+        ? {}
+        : { parentId: parentId === null ? (0, typeorm_2.IsNull)() : parentId };
+    const baseWhere = {
+        deletedAt: (0, typeorm_2.IsNull)(),
+        ...parentWhere,
+        ...(type ? { type } : {}),
+    };
+    const trimmedSearchText = searchText?.trim();
+    if (!trimmedSearchText) {
+        return baseWhere;
+    }
+    const searchPattern = `%${trimmedSearchText}%`;
+    return [
+        { ...baseWhere, code: (0, typeorm_2.ILike)(searchPattern) },
+        { ...baseWhere, name: (0, typeorm_2.ILike)(searchPattern) },
+    ];
+}
+function createPositionWhere({ searchText, }) {
+    const trimmedSearchText = searchText?.trim();
+    if (!trimmedSearchText) {
+        return {};
+    }
+    const searchPattern = `%${trimmedSearchText}%`;
+    return [{ code: (0, typeorm_2.ILike)(searchPattern) }, { name: (0, typeorm_2.ILike)(searchPattern) }];
+}
+function createMembershipWhere({ activeOnly, date, memberId, orgUnitId, positionId, }) {
+    const baseWhere = {
+        ...(memberId ? { memberId } : {}),
+        ...(orgUnitId ? { orgUnitId } : {}),
+        ...(positionId ? { positionId } : {}),
+    };
+    if (!activeOnly) {
+        return baseWhere;
+    }
+    return [
+        {
+            ...baseWhere,
+            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
+            effectiveTo: (0, typeorm_2.IsNull)(),
+        },
+        {
+            ...baseWhere,
+            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
+            effectiveTo: (0, typeorm_2.MoreThanOrEqual)(date),
+        },
+    ];
+}
+function createManagerResolutionWhere({ activeOnly, date, scopeId, scopeType, }) {
+    const baseWhere = {
+        ...(scopeId ? { scopeId } : {}),
+        ...(scopeType ? { scopeType } : {}),
+    };
+    if (!activeOnly) {
+        return baseWhere;
+    }
+    return [
+        {
+            ...baseWhere,
+            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
+            effectiveTo: (0, typeorm_2.IsNull)(),
+        },
+        {
+            ...baseWhere,
+            effectiveFrom: (0, typeorm_2.LessThanOrEqual)(date),
+            effectiveTo: (0, typeorm_2.MoreThanOrEqual)(date),
+        },
+    ];
+}
+function createPaginationFindOptions({ all, page, pageSize, }) {
+    if (all) {
+        return {};
+    }
+    const normalizedPageSize = normalizePageSize(pageSize);
+    if (!normalizedPageSize) {
+        return {};
+    }
+    return {
+        skip: (normalizePage(page) - 1) * normalizedPageSize,
+        take: normalizedPageSize,
+    };
+}
+function normalizePage(page) {
+    if (typeof page !== 'number' || !Number.isFinite(page)) {
+        return 1;
+    }
+    return Math.max(1, Math.floor(page));
+}
+function normalizePageSize(pageSize) {
+    if (typeof pageSize !== 'number' || !Number.isFinite(pageSize)) {
+        return null;
+    }
+    const flooredPageSize = Math.max(1, Math.floor(pageSize));
+    if (flooredPageSize > MAX_PAGE_SIZE) {
+        paginationLogger.warn(`Requested pageSize ${flooredPageSize} exceeds the maximum of ${MAX_PAGE_SIZE} and was clamped. ` +
+            `To fetch the complete list, pass all: true (or omit pageSize) instead of an oversized pageSize.`);
+    }
+    return Math.min(MAX_PAGE_SIZE, flooredPageSize);
+}
+function collectOrgUnitTreeDraftIds(moves) {
+    return [
+        ...new Set(moves.flatMap((move) => move.parentId ? [move.id, move.parentId] : [move.id])),
+    ];
+}
+function parseBaseUpdatedAt(move) {
+    const baseUpdatedAt = new Date(move.baseUpdatedAt);
+    if (Number.isNaN(baseUpdatedAt.getTime())) {
+        throw new common_1.BadRequestException(`Org unit ${move.id} baseUpdatedAt is invalid`);
+    }
+    return baseUpdatedAt;
+}
+function assertOrgUnitTreeDraftHasNoCycles(moves) {
+    const parentById = new Map(moves.map((move) => [
+        move.id,
+        move.parentId,
+    ]));
+    for (const move of moves) {
+        const visited = new Set();
+        let parentId = move.parentId;
+        while (parentId && parentById.has(parentId)) {
+            if (parentId === move.id || visited.has(parentId)) {
+                throw new common_1.BadRequestException('Org unit tree draft cannot create a cycle');
+            }
+            visited.add(parentId);
+            parentId = parentById.get(parentId) ?? null;
+        }
+    }
+}
+function sortOrgUnitTreeDraftMoves(moves) {
+    const moveById = new Map(moves.map((move) => [
+        move.id,
+        move,
+    ]));
+    return [...moves].sort((left, right) => {
+        const leftDepth = calculateOrgUnitTreeDraftMoveDepth(left, moveById);
+        const rightDepth = calculateOrgUnitTreeDraftMoveDepth(right, moveById);
+        return leftDepth - rightDepth || left.id.localeCompare(right.id);
+    });
+}
+function calculateOrgUnitTreeDraftMoveDepth(move, moveById) {
+    let depth = 0;
+    let parentId = move.parentId;
+    while (parentId && moveById.has(parentId)) {
+        depth += 1;
+        parentId = moveById.get(parentId)?.parentId ?? null;
+    }
+    return depth;
+}
+function compareOrgUnitPath(left, right) {
+    return left.path.localeCompare(right.path);
+}
+//# sourceMappingURL=organization.service.js.map