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

package/src/lib/template/template.service.js

@@ -1,654 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateService = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("@nestjs/typeorm");
-const typeorm_2 = require("typeorm");
-const condition_service_1 = require("../condition/condition.service");
-const form_definition_entity_1 = require("../form/form-definition.entity");
-const form_definition_version_entity_1 = require("../form/form-definition-version.entity");
-const form_enums_1 = require("../form/form.enums");
-const form_service_1 = require("../form/form.service");
-const approval_template_category_entity_1 = require("./approval-template-category.entity");
-const approval_template_entity_1 = require("./approval-template.entity");
-const approval_template_version_entity_1 = require("./approval-template-version.entity");
-const template_enums_1 = require("./template.enums");
-const workflow_definition_validator_1 = require("./workflow-definition.validator");
-let TemplateService = class TemplateService {
-    constructor(templateRepository, templateCategoryRepository, templateVersionRepository, formDefinitionVersionRepository, conditionService, formService) {
-        this.templateRepository = templateRepository;
-        this.templateCategoryRepository = templateCategoryRepository;
-        this.templateVersionRepository = templateVersionRepository;
-        this.formDefinitionVersionRepository = formDefinitionVersionRepository;
-        this.conditionService = conditionService;
-        this.formService = formService;
-    }
-    async createApprovalTemplate(input, manager) {
-        const run = (txManager) => this.createApprovalTemplateWithManager(txManager, input);
-        return manager
-            ? run(manager)
-            : this.templateRepository.manager.transaction(run);
-    }
-    async createApprovalTemplateWithManager(manager, input) {
-        await this.validateOptionalFormDefinitionVersion(input.formDefinitionVersionId, manager);
-        const category = await this.validateOptionalTemplateCategory(input.categoryId, manager);
-        const templateRepository = manager.getRepository(approval_template_entity_1.ApprovalTemplateEntity);
-        const versionRepository = manager.getRepository(approval_template_version_entity_1.ApprovalTemplateVersionEntity);
-        const template = await templateRepository.save(templateRepository.create({
-            category: input.category ?? category?.name ?? null,
-            categoryId: category?.id ?? null,
-            createdByMemberId: input.createdByMemberId,
-            currentVersionId: null,
-            description: input.description,
-            name: input.name,
-        }));
-        await versionRepository.save(versionRepository.create({
-            archivedAt: null,
-            formDefinitionVersionId: input.formDefinitionVersionId,
-            initiatorPolicyCel: null,
-            notificationConfig: null,
-            publishedAt: null,
-            publishedByMemberId: null,
-            slaDefaults: null,
-            status: template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT,
-            templateId: template.id,
-            version: 1,
-            workflowDefinition: workflow_definition_validator_1.EMPTY_WORKFLOW_DEFINITION,
-        }));
-        return template;
-    }
-    /**
-     * Atomically build (and optionally publish) a form definition together with
-     * the approval template that binds it. The whole flow runs in a single DB
-     * transaction so a partial failure rolls back both sides.
-     */
-    async composeApprovalTemplateWithForm(input, currentMemberId) {
-        return this.templateRepository.manager.transaction(async (manager) => {
-            const formDefinitionVersion = await this.resolveComposedFormVersion(manager, input, currentMemberId);
-            const templateDraftVersion = await this.resolveComposedTemplateDraftVersion(manager, input, currentMemberId);
-            let templateVersion = await this.updateApprovalTemplateDraft({
-                formDefinitionVersionId: formDefinitionVersion.id,
-                initiatorPolicyCel: input.initiatorPolicyCel,
-                notificationConfigJson: input.notificationConfigJson,
-                slaDefaultsJson: input.slaDefaultsJson,
-                versionId: templateDraftVersion.id,
-                workflowDefinitionJson: input.workflowDefinitionJson,
-            }, manager);
-            if (input.publish) {
-                templateVersion = await this.publishApprovalTemplateVersion(templateDraftVersion.id, currentMemberId ?? undefined, manager);
-            }
-            const formDefinition = await manager
-                .getRepository(form_definition_entity_1.FormDefinitionEntity)
-                .findOneByOrFail({ id: formDefinitionVersion.formDefinitionId });
-            const template = await manager
-                .getRepository(approval_template_entity_1.ApprovalTemplateEntity)
-                .findOneByOrFail({ id: templateVersion.templateId });
-            return {
-                formDefinition,
-                formDefinitionVersion,
-                published: input.publish,
-                template,
-                templateVersion,
-            };
-        });
-    }
-    async resolveComposedFormVersion(manager, input, currentMemberId) {
-        if (!input.formDefinitionId) {
-            const definition = await this.formService.createFormDefinition({
-                createdByMemberId: currentMemberId,
-                description: input.formDescription,
-                name: input.formName,
-                schemaJson: input.schemaJson,
-                uiSchemaJson: input.uiSchemaJson,
-            }, manager);
-            const draft = await this.formService.findDraftVersion(definition.id, manager);
-            if (!draft) {
-                throw new common_1.NotFoundException(`Form definition ${definition.id} draft version was not created`);
-            }
-            return input.publish
-                ? this.formService.publishFormDefinitionVersion(draft.id, currentMemberId ?? undefined, manager)
-                : draft;
-        }
-        const existingDraft = await this.formService.findDraftVersion(input.formDefinitionId, manager);
-        if (existingDraft) {
-            const updated = await this.formService.updateFormDefinitionDraft({
-                schemaJson: input.schemaJson ?? '',
-                uiSchemaJson: input.uiSchemaJson ?? '',
-                versionId: existingDraft.id,
-            }, manager);
-            return input.publish
-                ? this.formService.publishFormDefinitionVersion(updated.id, currentMemberId ?? undefined, manager)
-                : updated;
-        }
-        // Published definitions no longer keep a parallel draft: edits publish a
-        // new version immediately (content-identical saves reuse the current
-        // version) so the template draft can bind a published form version.
-        return this.formService.publishFormDefinitionContent({
-            formDefinitionId: input.formDefinitionId,
-            schemaJson: input.schemaJson,
-            uiSchemaJson: input.uiSchemaJson,
-        }, currentMemberId ?? undefined, manager);
-    }
-    async resolveComposedTemplateDraftVersion(manager, input, currentMemberId) {
-        if (!input.templateId) {
-            const template = await this.createApprovalTemplate({
-                category: input.category,
-                categoryId: input.categoryId,
-                createdByMemberId: currentMemberId,
-                description: input.templateDescription,
-                formDefinitionVersionId: null,
-                name: input.templateName,
-            }, manager);
-            const draft = await this.findDraftTemplateVersion(template.id, manager);
-            if (!draft) {
-                throw new common_1.NotFoundException(`Approval template ${template.id} draft version was not created`);
-            }
-            return draft;
-        }
-        return ((await this.findDraftTemplateVersion(input.templateId, manager)) ??
-            (await this.forkApprovalTemplate(input.templateId, manager)));
-    }
-    async findDraftTemplateVersion(templateId, manager) {
-        return this.templateVersions(manager).findOne({
-            where: {
-                status: template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT,
-                templateId,
-            },
-        });
-    }
-    async updateApprovalTemplate(input) {
-        const existing = await this.getTemplateOrThrow(input.id);
-        const category = input.categoryId === undefined
-            ? undefined
-            : await this.validateOptionalTemplateCategory(input.categoryId);
-        const next = this.templateRepository.merge(existing, {
-            category: input.category !== undefined
-                ? input.category
-                : category !== undefined
-                    ? (category?.name ?? null)
-                    : existing.category,
-            categoryId: input.categoryId === undefined
-                ? existing.categoryId
-                : (category?.id ?? null),
-            description: input.description ?? existing.description,
-            name: input.name ?? existing.name,
-        });
-        return this.templateRepository.save(next);
-    }
-    async listApprovalTemplates(options = {}) {
-        const isPaginated = typeof options.page === 'number' || typeof options.pageSize === 'number';
-        const normalizedPageSize = isPaginated
-            ? normalizePageSize(options.pageSize ?? 10)
-            : undefined;
-        return this.templateRepository.find({
-            order: { updatedAt: 'DESC', createdAt: 'DESC' },
-            relations: { categoryDetail: true },
-            ...(normalizedPageSize
-                ? {
-                    skip: (normalizePage(options.page ?? 1) - 1) * normalizedPageSize,
-                    take: normalizedPageSize,
-                }
-                : {}),
-            where: createApprovalTemplateWhere({
-                categoryId: options.categoryId,
-                searchText: options.searchText,
-                status: options.status,
-            }),
-        });
-    }
-    async countApprovalTemplates({ categoryId, searchText, status, } = {}) {
-        return this.templateRepository.count({
-            where: createApprovalTemplateWhere({ categoryId, searchText, status }),
-        });
-    }
-    async getApprovalTemplate(id) {
-        return this.getTemplateOrThrow(id);
-    }
-    async listApprovalTemplateCategories(options = {}) {
-        const isPaginated = typeof options.page === 'number' || typeof options.pageSize === 'number';
-        const normalizedPageSize = isPaginated
-            ? normalizePageSize(options.pageSize ?? 10)
-            : undefined;
-        return this.templateCategoryRepository.find({
-            order: { sortOrder: 'ASC', name: 'ASC', createdAt: 'ASC' },
-            ...(normalizedPageSize
-                ? {
-                    skip: (normalizePage(options.page ?? 1) - 1) * normalizedPageSize,
-                    take: normalizedPageSize,
-                }
-                : {}),
-            where: createApprovalTemplateCategoryWhere({
-                searchText: options.searchText,
-                status: options.status,
-            }),
-        });
-    }
-    async countApprovalTemplateCategories({ searchText, status, } = {}) {
-        return this.templateCategoryRepository.count({
-            where: createApprovalTemplateCategoryWhere({ searchText, status }),
-        });
-    }
-    async createApprovalTemplateCategory(input) {
-        return this.templateCategoryRepository.save(this.templateCategoryRepository.create({
-            description: input.description,
-            isActive: input.isActive ?? true,
-            name: input.name,
-            sortOrder: input.sortOrder ?? 0,
-        }));
-    }
-    async updateApprovalTemplateCategory(input) {
-        const existing = await this.getTemplateCategoryOrThrow(input.id);
-        return this.templateCategoryRepository.save(this.templateCategoryRepository.merge(existing, {
-            description: input.description ?? existing.description,
-            isActive: input.isActive ?? existing.isActive,
-            name: input.name ?? existing.name,
-            sortOrder: input.sortOrder ?? existing.sortOrder,
-        }));
-    }
-    async activateApprovalTemplateCategory(id) {
-        return this.setApprovalTemplateCategoryActive(id, true);
-    }
-    async deactivateApprovalTemplateCategory(id) {
-        return this.setApprovalTemplateCategoryActive(id, false);
-    }
-    async deleteApprovalTemplateCategory(id) {
-        const category = await this.getTemplateCategoryOrThrow(id);
-        const templateCount = await this.templateRepository.count({
-            where: { categoryId: id, deletedAt: (0, typeorm_2.IsNull)() },
-        });
-        if (templateCount > 0) {
-            return this.templateCategoryRepository.save(this.templateCategoryRepository.merge(category, {
-                isActive: false,
-            }));
-        }
-        await this.templateCategoryRepository.remove(category);
-        return category;
-    }
-    async listApprovalTemplateVersions(templateId) {
-        await this.getTemplateOrThrow(templateId);
-        return this.templateVersionRepository.find({
-            order: { version: 'DESC' },
-            where: { templateId },
-        });
-    }
-    async getApprovalTemplateVersion(id) {
-        return this.getTemplateVersionOrThrow(id);
-    }
-    async updateApprovalTemplateDraft(input, manager) {
-        const versionRepository = this.templateVersions(manager);
-        const existing = await this.getTemplateVersionOrThrow(input.versionId, manager);
-        if (existing.status !== template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT) {
-            throw new common_1.ConflictException('Only draft approval template versions can be updated');
-        }
-        await this.validateOptionalFormDefinitionVersion(input.formDefinitionVersionId, manager);
-        const workflowDefinition = this.parseWorkflowDefinitionOrThrow(input.workflowDefinitionJson);
-        const next = versionRepository.merge(existing, {
-            formDefinitionVersionId: input.formDefinitionVersionId,
-            initiatorPolicyCel: input.initiatorPolicyCel,
-            notificationConfig: parseOptionalJsonObject(input.notificationConfigJson),
-            slaDefaults: parseOptionalJsonObject(input.slaDefaultsJson),
-            workflowDefinition,
-        });
-        return versionRepository.save(next);
-    }
-    async forkApprovalTemplate(templateId, manager) {
-        const versionRepository = this.templateVersions(manager);
-        const template = await this.getTemplateOrThrow(templateId, manager);
-        const existingDraft = await versionRepository.findOne({
-            where: {
-                status: template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT,
-                templateId: template.id,
-            },
-        });
-        if (existingDraft) {
-            throw new common_1.ConflictException('A draft approval template version already exists');
-        }
-        const source = template.currentVersionId
-            ? await this.getTemplateVersionOrThrow(template.currentVersionId, manager)
-            : null;
-        const nextVersion = await this.readNextVersionNumber(template.id, manager);
-        return versionRepository.save(versionRepository.create({
-            archivedAt: null,
-            formDefinitionVersionId: source?.formDefinitionVersionId ?? null,
-            initiatorPolicyCel: source?.initiatorPolicyCel ?? null,
-            notificationConfig: source?.notificationConfig ?? null,
-            publishedAt: null,
-            publishedByMemberId: null,
-            slaDefaults: source?.slaDefaults ?? null,
-            status: template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT,
-            templateId: template.id,
-            version: nextVersion,
-            workflowDefinition: source?.workflowDefinition ?? workflow_definition_validator_1.EMPTY_WORKFLOW_DEFINITION,
-        }));
-    }
-    async publishApprovalTemplateVersion(versionId, publishedByMemberId, manager) {
-        const version = await this.getTemplateVersionOrThrow(versionId, manager);
-        if (version.status !== template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT) {
-            throw new common_1.ConflictException('Only draft approval template versions can be published');
-        }
-        await this.validatePublishableVersion(version, manager);
-        const run = (txManager) => this.publishApprovalTemplateVersionWithManager(txManager, version, publishedByMemberId);
-        return manager
-            ? run(manager)
-            : this.templateRepository.manager.transaction(run);
-    }
-    async publishApprovalTemplateVersionWithManager(manager, version, publishedByMemberId) {
-        const templateRepository = manager.getRepository(approval_template_entity_1.ApprovalTemplateEntity);
-        const versionRepository = manager.getRepository(approval_template_version_entity_1.ApprovalTemplateVersionEntity);
-        const template = await templateRepository.findOne({
-            where: { deletedAt: (0, typeorm_2.IsNull)(), id: version.templateId },
-        });
-        if (!template) {
-            throw new common_1.NotFoundException(`Approval template ${version.templateId} was not found`);
-        }
-        if (template.currentVersionId) {
-            await versionRepository.update({ id: template.currentVersionId }, {
-                archivedAt: new Date(),
-                status: template_enums_1.ApprovalTemplateVersionStatusEnum.ARCHIVED,
-            });
-        }
-        const published = versionRepository.merge(version, {
-            archivedAt: null,
-            publishedAt: new Date(),
-            publishedByMemberId: publishedByMemberId ?? null,
-            status: template_enums_1.ApprovalTemplateVersionStatusEnum.PUBLISHED,
-        });
-        const saved = await versionRepository.save(published);
-        await templateRepository.save(templateRepository.merge(template, {
-            currentVersionId: saved.id,
-        }));
-        return saved;
-    }
-    async rollbackApprovalTemplateVersion(versionId) {
-        const target = await this.getTemplateVersionOrThrow(versionId);
-        if (target.status === template_enums_1.ApprovalTemplateVersionStatusEnum.DRAFT) {
-            throw new common_1.ConflictException('Draft approval template versions cannot be rollback targets');
-        }
-        return this.templateRepository.manager.transaction(async (manager) => {
-            const templateRepository = manager.getRepository(approval_template_entity_1.ApprovalTemplateEntity);
-            const versionRepository = manager.getRepository(approval_template_version_entity_1.ApprovalTemplateVersionEntity);
-            const template = await templateRepository.findOne({
-                where: { deletedAt: (0, typeorm_2.IsNull)(), id: target.templateId },
-            });
-            if (!template) {
-                throw new common_1.NotFoundException(`Approval template ${target.templateId} was not found`);
-            }
-            if (template.currentVersionId &&
-                template.currentVersionId !== target.id) {
-                await versionRepository.update({ id: template.currentVersionId }, {
-                    archivedAt: new Date(),
-                    status: template_enums_1.ApprovalTemplateVersionStatusEnum.ARCHIVED,
-                });
-            }
-            const restored = versionRepository.merge(target, {
-                archivedAt: null,
-                status: template_enums_1.ApprovalTemplateVersionStatusEnum.PUBLISHED,
-            });
-            const saved = await versionRepository.save(restored);
-            await templateRepository.save(templateRepository.merge(template, {
-                currentVersionId: saved.id,
-            }));
-            return saved;
-        });
-    }
-    async validatePublishableVersion(version, manager) {
-        if (!version.formDefinitionVersionId) {
-            throw new common_1.BadRequestException('Approval template version must bind a form definition version before publishing');
-        }
-        const formVersion = await this.formVersions(manager).findOne({
-            where: { id: version.formDefinitionVersionId },
-        });
-        if (!formVersion) {
-            throw new common_1.NotFoundException(`Form definition version ${version.formDefinitionVersionId} was not found`);
-        }
-        if (formVersion.status !== form_enums_1.FormDefinitionVersionStatusEnum.PUBLISHED) {
-            throw new common_1.BadRequestException('Approval template can only bind a published form definition version');
-        }
-        const workflowResult = (0, workflow_definition_validator_1.lintWorkflowDefinition)(version.workflowDefinition);
-        const conditionErrors = this.conditionService.lintExpressions(readConditionExpressions(version.workflowDefinition, version.initiatorPolicyCel), {
-            allowedRootIdentifiers: [
-                'env',
-                'form',
-                'formData',
-                'initiator',
-                'instance',
-                'subject',
-            ],
-        });
-        const errors = [...workflowResult.errors, ...conditionErrors];
-        if (errors.length) {
-            throw new common_1.BadRequestException(errors.join('; '));
-        }
-    }
-    async validateOptionalFormDefinitionVersion(formDefinitionVersionId, manager) {
-        if (!formDefinitionVersionId) {
-            return;
-        }
-        const formVersion = await this.formVersions(manager).findOne({
-            where: { id: formDefinitionVersionId },
-        });
-        if (!formVersion) {
-            throw new common_1.NotFoundException(`Form definition version ${formDefinitionVersionId} was not found`);
-        }
-    }
-    async validateOptionalTemplateCategory(categoryId, manager) {
-        if (!categoryId) {
-            return null;
-        }
-        return this.getTemplateCategoryOrThrow(categoryId, manager);
-    }
-    templates(manager) {
-        return manager
-            ? manager.getRepository(approval_template_entity_1.ApprovalTemplateEntity)
-            : this.templateRepository;
-    }
-    templateVersions(manager) {
-        return manager
-            ? manager.getRepository(approval_template_version_entity_1.ApprovalTemplateVersionEntity)
-            : this.templateVersionRepository;
-    }
-    templateCategories(manager) {
-        return manager
-            ? manager.getRepository(approval_template_category_entity_1.ApprovalTemplateCategoryEntity)
-            : this.templateCategoryRepository;
-    }
-    formVersions(manager) {
-        return manager
-            ? manager.getRepository(form_definition_version_entity_1.FormDefinitionVersionEntity)
-            : this.formDefinitionVersionRepository;
-    }
-    async getTemplateOrThrow(id, manager) {
-        const entity = await this.templates(manager).findOne({
-            relations: { categoryDetail: true },
-            where: { deletedAt: (0, typeorm_2.IsNull)(), id },
-        });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Approval template ${id} was not found`);
-        }
-        return entity;
-    }
-    async getTemplateCategoryOrThrow(id, manager) {
-        const entity = await this.templateCategories(manager).findOne({
-            where: { id },
-        });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Approval template category ${id} was not found`);
-        }
-        return entity;
-    }
-    async setApprovalTemplateCategoryActive(id, isActive) {
-        const category = await this.getTemplateCategoryOrThrow(id);
-        return this.templateCategoryRepository.save(this.templateCategoryRepository.merge(category, {
-            isActive,
-        }));
-    }
-    async getTemplateVersionOrThrow(id, manager) {
-        const entity = await this.templateVersions(manager).findOne({
-            where: { id },
-        });
-        if (!entity) {
-            throw new common_1.NotFoundException(`Approval template version ${id} was not found`);
-        }
-        return entity;
-    }
-    async readNextVersionNumber(templateId, manager) {
-        const row = await this.templateVersions(manager)
-            .createQueryBuilder('version')
-            .select('MAX(version.version)', 'maxVersion')
-            .where('version.template_id = :templateId', { templateId })
-            .getRawOne();
-        const maxVersion = typeof row?.maxVersion === 'number'
-            ? row.maxVersion
-            : Number(row?.maxVersion ?? 0);
-        return maxVersion + 1;
-    }
-    parseWorkflowDefinitionOrThrow(value) {
-        try {
-            return (0, workflow_definition_validator_1.parseWorkflowDefinitionJson)(value);
-        }
-        catch (error) {
-            throw new common_1.BadRequestException(error instanceof Error ? error.message : 'Invalid workflow definition');
-        }
-    }
-};
-exports.TemplateService = TemplateService;
-exports.TemplateService = TemplateService = tslib_1.__decorate([
-    (0, common_1.Injectable)(),
-    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(approval_template_entity_1.ApprovalTemplateEntity)),
-    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(approval_template_category_entity_1.ApprovalTemplateCategoryEntity)),
-    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(approval_template_version_entity_1.ApprovalTemplateVersionEntity)),
-    tslib_1.__param(3, (0, typeorm_1.InjectRepository)(form_definition_version_entity_1.FormDefinitionVersionEntity)),
-    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        condition_service_1.ConditionService,
-        form_service_1.FormService])
-], TemplateService);
-function parseOptionalJsonObject(value) {
-    if (!value) {
-        return null;
-    }
-    const parsedValue = parseJson(value);
-    if (!isRecord(parsedValue)) {
-        throw new common_1.BadRequestException('JSON value must be an object');
-    }
-    return parsedValue;
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value);
-    }
-    catch (error) {
-        throw new common_1.BadRequestException(error instanceof Error ? error.message : 'Invalid JSON value');
-    }
-}
-function normalizePage(page) {
-    return Number.isInteger(page) && page > 0 ? page : 1;
-}
-function normalizePageSize(pageSize) {
-    if (!Number.isInteger(pageSize) || pageSize <= 0) {
-        return 10;
-    }
-    return Math.min(pageSize, 100);
-}
-function createApprovalTemplateWhere(options) {
-    const activeTemplateWhere = {
-        deletedAt: (0, typeorm_2.IsNull)(),
-    };
-    const statusWhere = options.status === template_enums_1.ApprovalTemplateListStatusEnum.DRAFT
-        ? { currentVersionId: (0, typeorm_2.IsNull)() }
-        : {};
-    const publicationWhere = options.status === template_enums_1.ApprovalTemplateListStatusEnum.PUBLISHED
-        ? { currentVersionId: (0, typeorm_2.Not)((0, typeorm_2.IsNull)()) }
-        : {};
-    const baseWhere = {
-        ...activeTemplateWhere,
-        ...(options.categoryId ? { categoryId: options.categoryId } : {}),
-        ...statusWhere,
-        ...publicationWhere,
-    };
-    const trimmedSearchText = options.searchText?.trim();
-    if (!trimmedSearchText) {
-        return baseWhere;
-    }
-    const searchPattern = `%${trimmedSearchText}%`;
-    return [
-        { ...baseWhere, name: (0, typeorm_2.ILike)(searchPattern) },
-        { ...baseWhere, category: (0, typeorm_2.ILike)(searchPattern) },
-        { ...baseWhere, description: (0, typeorm_2.ILike)(searchPattern) },
-    ];
-}
-function createApprovalTemplateCategoryWhere(options) {
-    const statusWhere = options.status === template_enums_1.ApprovalTemplateCategoryStatusEnum.ALL
-        ? {}
-        : options.status === template_enums_1.ApprovalTemplateCategoryStatusEnum.INACTIVE
-            ? { isActive: false }
-            : { isActive: true };
-    const trimmedSearchText = options.searchText?.trim();
-    if (!trimmedSearchText) {
-        return statusWhere;
-    }
-    const searchPattern = `%${trimmedSearchText}%`;
-    return [
-        { ...statusWhere, name: (0, typeorm_2.ILike)(searchPattern) },
-        { ...statusWhere, description: (0, typeorm_2.ILike)(searchPattern) },
-    ];
-}
-function readConditionExpressions(definition, initiatorPolicyCel) {
-    return [
-        { expression: initiatorPolicyCel, label: 'initiatorPolicyCel' },
-        ...definition.edges.map((edge) => ({
-            expression: edge.data.condition,
-            label: `workflow.edges.${edge.id}.data.condition`,
-        })),
-        ...definition.nodes.flatMap((node) => {
-            if (node.type === 'userTask') {
-                return [
-                    {
-                        expression: node.data.entryCondition,
-                        label: `workflow.nodes.${node.id}.data.entryCondition`,
-                    },
-                    ...(node.data.approverResolver.type === 'EXPRESSION'
-                        ? [
-                            {
-                                expression: node.data.approverResolver.expression,
-                                label: `workflow.nodes.${node.id}.data.approverResolver.expression`,
-                            },
-                        ]
-                        : []),
-                ];
-            }
-            if (node.type === 'serviceTask') {
-                return [
-                    {
-                        expression: node.data.entryCondition,
-                        label: `workflow.nodes.${node.id}.data.entryCondition`,
-                    },
-                    ...(node.data.action.type === 'WEBHOOK'
-                        ? [
-                            {
-                                expression: node.data.action.payload,
-                                label: `workflow.nodes.${node.id}.data.action.payload`,
-                            },
-                        ]
-                        : []),
-                    ...(node.data.action.type === 'SET_FORM_FIELD'
-                        ? [
-                            {
-                                expression: node.data.action.value,
-                                label: `workflow.nodes.${node.id}.data.action.value`,
-                            },
-                        ]
-                        : []),
-                ];
-            }
-            return [];
-        }),
-    ];
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-//# sourceMappingURL=template.service.js.map