@oneuptime/common 13.0.0 → 13.0.3

package/Server/Services/PodmanHostOwnerRuleEngineService.ts

@@ -14,6 +14,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class PodmanHostOwnerRuleEngineServiceClass {
@@ -40,6 +41,7 @@ class PodmanHostOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             podmanHostLabels: { _id: true },
             podmanHostNamePattern: true,
@@ -182,6 +184,24 @@ class PodmanHostOwnerRuleEngineServiceClass {
   private doesPodmanHostMatchRule(
     podmanHost: PodmanHost,
     rule: PodmanHostOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "podmanHostLabels",
+        "podmanHostNamePattern",
+        "podmanHostDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (podmanHostRule: PodmanHostOwnerRule): boolean => {
+        return this.doesPodmanHostMatchRuleLegacy(podmanHost, podmanHostRule);
+      },
+    });
+  }
+
+  private doesPodmanHostMatchRuleLegacy(
+    podmanHost: PodmanHost,
+    rule: PodmanHostOwnerRule,
   ): boolean {
     if (rule.podmanHostLabels && rule.podmanHostLabels.length > 0) {
       if (!podmanHost.labels || podmanHost.labels.length === 0) {

package/Server/Services/ProjectCallSMSConfigService.ts

@@ -14,6 +14,9 @@ import IncomingCallPolicyService from "./IncomingCallPolicyService";
 import IncomingCallPolicy from "../../Models/DatabaseModels/IncomingCallPolicy";
 import releaseIncomingCallPhoneNumber from "../Utils/IncomingCallPhoneNumber";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import IncomingCallPolicyPhoneNumberService from "./IncomingCallPolicyPhoneNumberService";
+import IncomingCallPolicyPhoneNumber from "../../Models/DatabaseModels/IncomingCallPolicyPhoneNumber";
+import ModelPermission from "../Types/Database/Permissions/Index";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -100,6 +103,17 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<Model>,
   ): Promise<OnDelete<Model>> {
+    /*
+     * This hook releases provider resources before DatabaseService reaches its
+     * usual delete permission check. Scope the query first so a denied config
+     * delete cannot release or clear another tenant's phone numbers.
+     */
+    deleteBy.query = await ModelPermission.checkDeleteQueryPermission(
+      Model,
+      deleteBy.query,
+      deleteBy.props,
+    );
+
     /*
      * When a Call/SMS config is deleted, release any incoming-call numbers
      * provisioned through it (so they don't keep billing on the provider) and
@@ -111,20 +125,59 @@ export class Service extends DatabaseService<Model> {
       select: {
         _id: true,
       },
-      limit: LIMIT_MAX,
-      skip: 0,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
       props: {
         isRoot: true,
       },
     });
 
+    const configIds: Array<ObjectID> = configs
+      .map((config: Model): ObjectID | null => {
+        return config.id;
+      })
+      .filter((configId: ObjectID | null): configId is ObjectID => {
+        return Boolean(configId);
+      });
+
+    /*
+     * Freeze the caller's offset/limit window before provider side effects.
+     * The original window could otherwise select different rows when
+     * DatabaseService evaluates it again after the releases complete.
+     */
+    deleteBy.query = {
+      _id: QueryHelper.any(configIds),
+    };
+    deleteBy.skip = 0;
+    deleteBy.limit = configIds.length;
+
     for (const config of configs) {
       if (!config.id) {
         continue;
       }
 
+      const phoneNumbers: Array<IncomingCallPolicyPhoneNumber> =
+        await IncomingCallPolicyPhoneNumberService.findAllBy({
+          query: {
+            projectCallSMSConfigId: config.id,
+          },
+          select: {
+            _id: true,
+            callProviderPhoneNumberId: true,
+            projectCallSMSConfigId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      /*
+       * Snapshot scalar-only attachments before deleting child rows. The child
+       * delete hook updates the compatibility mirror and can otherwise erase
+       * an unmatched legacy SID before it is released from the provider.
+       */
       const policies: Array<IncomingCallPolicy> =
-        await IncomingCallPolicyService.findBy({
+        await IncomingCallPolicyService.findAllBy({
           query: {
             projectCallSMSConfigId: config.id,
           },
@@ -133,17 +186,44 @@ export class Service extends DatabaseService<Model> {
             callProviderPhoneNumberId: true,
             projectCallSMSConfigId: true,
           },
-          limit: LIMIT_MAX,
-          skip: 0,
           props: {
             isRoot: true,
           },
         });
 
+      const releasedProviderPhoneNumberIds: Set<string> = new Set();
+
+      for (const phoneNumber of phoneNumbers) {
+        if (
+          !phoneNumber.callProviderPhoneNumberId ||
+          !phoneNumber.projectCallSMSConfigId
+        ) {
+          continue;
+        }
+
+        if (
+          releasedProviderPhoneNumberIds.has(
+            phoneNumber.callProviderPhoneNumberId,
+          )
+        ) {
+          continue;
+        }
+
+        await releaseIncomingCallPhoneNumber({
+          projectCallSMSConfigId: phoneNumber.projectCallSMSConfigId,
+          callProviderPhoneNumberId: phoneNumber.callProviderPhoneNumberId,
+        });
+
+        releasedProviderPhoneNumberIds.add(
+          phoneNumber.callProviderPhoneNumberId,
+        );
+      }
+
       for (const policy of policies) {
         if (
           !policy.callProviderPhoneNumberId ||
-          !policy.projectCallSMSConfigId
+          !policy.projectCallSMSConfigId ||
+          releasedProviderPhoneNumberIds.has(policy.callProviderPhoneNumberId)
         ) {
           continue;
         }
@@ -153,8 +233,77 @@ export class Service extends DatabaseService<Model> {
           callProviderPhoneNumberId: policy.callProviderPhoneNumberId,
         });
 
+        releasedProviderPhoneNumberIds.add(policy.callProviderPhoneNumberId);
+      }
+
+      /*
+       * Delete through the child service before the config itself is removed.
+       * Its hooks re-select the oldest remaining number for each affected
+       * policy and update the legacy compatibility fields accordingly.
+       */
+      const phoneNumberIds: Array<ObjectID> = phoneNumbers
+        .map((phoneNumber: IncomingCallPolicyPhoneNumber): ObjectID | null => {
+          return phoneNumber.id;
+        })
+        .filter((phoneNumberId: ObjectID | null): phoneNumberId is ObjectID => {
+          return Boolean(phoneNumberId);
+        });
+
+      /*
+       * deleteBy is intentionally bounded, so delete the exact snapshotted
+       * child ids in batches. This covers configs with more than LIMIT_MAX
+       * attached numbers and keeps the explicit cleanup bound to the rows
+       * whose provider resources were released above.
+       */
+      for (
+        let offset: number = 0;
+        offset < phoneNumberIds.length;
+        offset += LIMIT_MAX
+      ) {
+        const phoneNumberIdBatch: Array<ObjectID> = phoneNumberIds.slice(
+          offset,
+          offset + LIMIT_MAX,
+        );
+
+        await IncomingCallPolicyPhoneNumberService.deleteBy({
+          query: {
+            _id: QueryHelper.any(phoneNumberIdBatch),
+          },
+          limit: phoneNumberIdBatch.length,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+
+      for (const policy of policies) {
+        if (!policy.id) {
+          continue;
+        }
+
+        const remainingPhoneNumber: IncomingCallPolicyPhoneNumber | null =
+          await IncomingCallPolicyPhoneNumberService.findOneBy({
+            query: {
+              incomingCallPolicyId: policy.id,
+            },
+            select: {
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (remainingPhoneNumber) {
+          await IncomingCallPolicyPhoneNumberService.syncPrimaryPhoneNumberToPolicy(
+            policy.id,
+          );
+          continue;
+        }
+
         await IncomingCallPolicyService.updateOneById({
-          id: policy.id!,
+          id: policy.id,
           data: {
             routingPhoneNumber: null,
             callProviderPhoneNumberId: null,

package/Server/Services/ProjectService.ts

@@ -113,6 +113,7 @@ import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCom
 import PositiveNumber from "../../Types/PositiveNumber";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
+import { IsNull, UpdateResult } from "typeorm";
 
 export interface CurrentPlan {
   plan: PlanType | null;
@@ -2704,6 +2705,41 @@ These are no longer recorded against the project and have to be cancelled by han
     }
   }
 
+  /**
+   * Record seat synchronization state only for the subscription that was read.
+   * The normal update path locates rows first and then writes by id, which can
+   * overwrite a replacement subscription's state during a concurrent plan change.
+   */
+  @CaptureSpan()
+  public async updateSubscriptionSeats(data: {
+    projectId: ObjectID;
+    subscriptionId: string;
+    planId: string;
+    seats: number | null;
+  }): Promise<number> {
+    const result: UpdateResult = await this.getRepository().update(
+      {
+        _id: data.projectId.toString(),
+        paymentProviderSubscriptionId: data.subscriptionId,
+        paymentProviderPlanId: data.planId,
+        deletedAt: IsNull(),
+      },
+      {
+        paymentProviderSubscriptionSeats:
+          data.seats === null
+            ? () => {
+                return "NULL";
+              }
+            : data.seats,
+        version: () => {
+          return '"version" + 1';
+        },
+      },
+    );
+
+    return result.affected || 0;
+  }
+
   @CaptureSpan()
   public async reactiveSubscription(projectId: ObjectID): Promise<void> {
     logger.debug("Reactivating subscription for project " + projectId, {
@@ -2744,7 +2780,15 @@ These are no longer recorded against the project and have to be cancelled by han
       );
     }
 
-    if (!project.paymentProviderSubscriptionSeats) {
+    /*
+     * A pending seat synchronization leaves the acknowledged count empty.
+     * Reactivation can still use the memberships already stored in the project.
+     */
+    const seats: number =
+      project.paymentProviderSubscriptionSeats ??
+      (await TeamMemberService.getUniqueTeamMemberCountInProject(projectId));
+
+    if (!seats) {
       throw new BadDataException(
         "Payment Provider subscription seats not found",
       );
@@ -2792,7 +2836,7 @@ These are no longer recorded against the project and have to be cancelled by han
       meteredSubscriptionId: project.paymentProviderMeteredSubscriptionId,
       serverMeteredPlans: AllMeteredPlans,
       newPlan: subscriptionPlan,
-      quantity: project.paymentProviderSubscriptionSeats,
+      quantity: seats,
       isYearly: SubscriptionPlan.isYearlyPlan(project.paymentProviderPlanId),
       endTrialAt: endTrialAt,
     });

package/Server/Services/ProxmoxClusterLabelRuleEngineService.ts

@@ -10,6 +10,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class ProxmoxClusterLabelRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class ProxmoxClusterLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             proxmoxClusterLabels: { _id: true },
             proxmoxClusterNamePattern: true,
             proxmoxClusterDescriptionPattern: true,
@@ -173,6 +175,29 @@ class ProxmoxClusterLabelRuleEngineServiceClass {
   private doesProxmoxClusterMatchRule(
     proxmoxCluster: ProxmoxCluster,
     rule: ProxmoxClusterLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "proxmoxClusterLabels",
+        "proxmoxClusterNamePattern",
+        "proxmoxClusterDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        proxmoxClusterRule: ProxmoxClusterLabelRule,
+      ): boolean => {
+        return this.doesProxmoxClusterMatchRuleLegacy(
+          proxmoxCluster,
+          proxmoxClusterRule,
+        );
+      },
+    });
+  }
+
+  private doesProxmoxClusterMatchRuleLegacy(
+    proxmoxCluster: ProxmoxCluster,
+    rule: ProxmoxClusterLabelRule,
   ): boolean {
     if (rule.proxmoxClusterLabels && rule.proxmoxClusterLabels.length > 0) {
       if (!proxmoxCluster.labels || proxmoxCluster.labels.length === 0) {

package/Server/Services/ProxmoxClusterOwnerRuleEngineService.ts

@@ -14,6 +14,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class ProxmoxClusterOwnerRuleEngineServiceClass {
@@ -42,6 +43,7 @@ class ProxmoxClusterOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             proxmoxClusterLabels: { _id: true },
             proxmoxClusterNamePattern: true,
@@ -185,6 +187,29 @@ class ProxmoxClusterOwnerRuleEngineServiceClass {
   private doesProxmoxClusterMatchRule(
     proxmoxCluster: ProxmoxCluster,
     rule: ProxmoxClusterOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "proxmoxClusterLabels",
+        "proxmoxClusterNamePattern",
+        "proxmoxClusterDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        proxmoxClusterRule: ProxmoxClusterOwnerRule,
+      ): boolean => {
+        return this.doesProxmoxClusterMatchRuleLegacy(
+          proxmoxCluster,
+          proxmoxClusterRule,
+        );
+      },
+    });
+  }
+
+  private doesProxmoxClusterMatchRuleLegacy(
+    proxmoxCluster: ProxmoxCluster,
+    rule: ProxmoxClusterOwnerRule,
   ): boolean {
     if (rule.proxmoxClusterLabels && rule.proxmoxClusterLabels.length > 0) {
       if (!proxmoxCluster.labels || proxmoxCluster.labels.length === 0) {

package/Server/Services/RumApplicationLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RumApplicationLabelRuleEngineServiceClass {
@@ -34,6 +35,7 @@ class RumApplicationLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
             descriptionRegexPattern: true,
@@ -130,6 +132,26 @@ class RumApplicationLabelRuleEngineServiceClass {
   private doesMatchRule(
     rumApplication: RumApplication,
     rule: RumApplicationLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        rumApplicationRule: RumApplicationLabelRule,
+      ): boolean => {
+        return this.doesMatchRuleLegacy(rumApplication, rumApplicationRule);
+      },
+    });
+  }
+
+  private doesMatchRuleLegacy(
+    rumApplication: RumApplication,
+    rule: RumApplicationLabelRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (!rumApplication.labels || rumApplication.labels.length === 0) {

package/Server/Services/RumApplicationOwnerRuleEngineService.ts

@@ -11,6 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RumApplicationOwnerRuleEngineServiceClass {
@@ -38,6 +39,7 @@ class RumApplicationOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             matchLabels: { _id: true },
             nameRegexPattern: true,
@@ -147,6 +149,26 @@ class RumApplicationOwnerRuleEngineServiceClass {
   private doesMatchRule(
     rumApplication: RumApplication,
     rule: RumApplicationOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "matchLabels",
+        "nameRegexPattern",
+        "descriptionRegexPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (
+        rumApplicationRule: RumApplicationOwnerRule,
+      ): boolean => {
+        return this.doesMatchRuleLegacy(rumApplication, rumApplicationRule);
+      },
+    });
+  }
+
+  private doesMatchRuleLegacy(
+    rumApplication: RumApplication,
+    rule: RumApplicationOwnerRule,
   ): boolean {
     if (rule.matchLabels && rule.matchLabels.length > 0) {
       if (!rumApplication.labels || rumApplication.labels.length === 0) {

package/Server/Services/RunbookLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RunbookLabelRuleEngineServiceClass {
@@ -32,6 +33,7 @@ class RunbookLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             runbookLabels: { _id: true },
             runbookNamePattern: true,
             runbookDescriptionPattern: true,
@@ -141,6 +143,24 @@ class RunbookLabelRuleEngineServiceClass {
   private doesRunbookMatchRule(
     runbook: Runbook,
     rule: RunbookLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "runbookLabels",
+        "runbookNamePattern",
+        "runbookDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (runbookRule: RunbookLabelRule): boolean => {
+        return this.doesRunbookMatchRuleLegacy(runbook, runbookRule);
+      },
+    });
+  }
+
+  private doesRunbookMatchRuleLegacy(
+    runbook: Runbook,
+    rule: RunbookLabelRule,
   ): boolean {
     if (rule.runbookLabels && rule.runbookLabels.length > 0) {
       if (!runbook.labels || runbook.labels.length === 0) {

package/Server/Services/RunbookOwnerRuleEngineService.ts

@@ -11,6 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class RunbookOwnerRuleEngineServiceClass {
@@ -37,6 +38,7 @@ class RunbookOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             runbookLabels: { _id: true },
             runbookNamePattern: true,
@@ -159,6 +161,24 @@ class RunbookOwnerRuleEngineServiceClass {
   private doesRunbookMatchRule(
     runbook: Runbook,
     rule: RunbookOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "runbookLabels",
+        "runbookNamePattern",
+        "runbookDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (runbookRule: RunbookOwnerRule): boolean => {
+        return this.doesRunbookMatchRuleLegacy(runbook, runbookRule);
+      },
+    });
+  }
+
+  private doesRunbookMatchRuleLegacy(
+    runbook: Runbook,
+    rule: RunbookOwnerRule,
   ): boolean {
     if (rule.runbookLabels && rule.runbookLabels.length > 0) {
       if (!runbook.labels || runbook.labels.length === 0) {

package/Server/Services/RunbookRuleEngineService.ts

@@ -18,6 +18,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
+import RuleCriteriaMatcher from "../../Utils/Rules/RuleCriteriaMatcher";
 
 type EnqueueExecutionFn = (data: {
   runbookExecutionId: ObjectID;
@@ -98,6 +99,7 @@ class RunbookRuleEngineServiceClass {
         select: {
           _id: true,
           name: true,
+          criteria: true,
           titlePattern: true,
           descriptionPattern: true,
           runbooks: { _id: true },
@@ -168,7 +170,22 @@ class RunbookRuleEngineServiceClass {
     }
   }
 
-  private matches(
+  public matches(
+    rule: RunbookRule,
+    title: string | undefined,
+    description: string | undefined,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: ["titlePattern", "descriptionPattern"],
+      emptyResult: true,
+      matchesLegacyRule: (legacyRule: RunbookRule): boolean => {
+        return this.matchesLegacy(legacyRule, title, description);
+      },
+    });
+  }
+
+  private matchesLegacy(
     rule: RunbookRule,
     title: string | undefined,
     description: string | undefined,