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

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

@@ -0,0 +1,654 @@
+"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