@oneuptime/common 9.5.6 → 9.5.7

package/Models/DatabaseModels/AlertEpisode.ts

@@ -543,6 +543,31 @@ export default class AlertEpisode extends BaseModel {
   })
   public resolvedAt?: Date = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadAlertEpisode,
+      Permission.ReadAllProjectResources,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "All Alerts Resolved At",
+    description:
+      "When all alerts in this episode were first detected as resolved. Used for resolve delay calculation.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+    unique: false,
+  })
+  public allAlertsResolvedAt?: Date = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/AlertGroupingRule.ts

@@ -674,13 +674,13 @@ export default class AlertGroupingRule extends BaseModel {
     title: "Group By Monitor",
     description:
       "When enabled, alerts from different monitors will be grouped into separate episodes. When disabled, alerts from any monitor can be grouped together.",
-    defaultValue: true,
+    defaultValue: false,
     isDefaultValueColumn: true,
   })
   @Column({
     type: ColumnType.Boolean,
     nullable: false,
-    default: true,
+    default: false,
   })
   public groupByMonitor?: boolean = undefined;
 

package/Models/DatabaseModels/IncidentEpisode.ts

@@ -542,6 +542,31 @@ export default class IncidentEpisode extends BaseModel {
   })
   public resolvedAt?: Date = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadIncidentEpisode,
+      Permission.ReadAllProjectResources,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "All Incidents Resolved At",
+    description:
+      "When all incidents in this episode were first detected as resolved. Used for resolve delay calculation.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+    unique: false,
+  })
+  public allIncidentsResolvedAt?: Date = undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/IncidentGroupingRule.ts

@@ -678,13 +678,13 @@ export default class IncidentGroupingRule extends BaseModel {
     title: "Group By Monitor",
     description:
       "When enabled, incidents from different monitors will be grouped into separate episodes. When disabled, incidents from any monitor can be grouped together.",
-    defaultValue: true,
+    defaultValue: false,
     isDefaultValueColumn: true,
   })
   @Column({
     type: ColumnType.Boolean,
     nullable: false,
-    default: true,
+    default: false,
   })
   public groupByMonitor?: boolean = undefined;
 

package/Models/DatabaseModels/Index.ts

@@ -98,6 +98,7 @@ import ProjectSmtpConfig from "./ProjectSmtpConfig";
 import ProjectSSO from "./ProjectSso";
 import PromoCode from "./PromoCode";
 import EnterpriseLicense from "./EnterpriseLicense";
+import OpenSourceDeployment from "./OpenSourceDeployment";
 import Reseller from "./Reseller";
 import ResellerPlan from "./ResellerPlan";
 // ScheduledMaintenances
@@ -411,6 +412,7 @@ const AllModelTypes: Array<{
 
   PromoCode,
   EnterpriseLicense,
+  OpenSourceDeployment,
 
   GlobalConfig,
 

package/Models/DatabaseModels/OpenSourceDeployment.ts

@@ -0,0 +1,140 @@
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import IconProp from "../../Types/Icon/IconProp";
+import { Column, Entity } from "typeorm";
+
+@TableAccessControl({
+  create: [],
+  read: [],
+  update: [],
+  delete: [],
+})
+@CrudApiEndpoint(new Route("/open-source-deployment"))
+@TableMetadata({
+  tableName: "OpenSourceDeployment",
+  singularName: "Open Source Deployment",
+  pluralName: "Open Source Deployments",
+  icon: IconProp.Globe,
+  tableDescription:
+    "Open source deployment registrations from self-hosted instances.",
+})
+@Entity({
+  name: "OpenSourceDeployment",
+})
+export default class OpenSourceDeployment extends BaseModel {
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.Email,
+    title: "Email",
+    description: "Email address of the user who registered.",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.Email,
+    length: ColumnLength.Email,
+  })
+  public email?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "Name",
+    description: "Full name of the user who registered.",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public name?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Company Name",
+    description: "Company name of the user who registered.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public companyName?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Phone,
+    title: "Company Phone Number",
+    description: "Phone number of the user who registered.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Phone,
+    length: ColumnLength.Phone,
+  })
+  public companyPhoneNumber?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "Version",
+    description: "OneUptime version of the self-hosted instance.",
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public oneuptimeVersion?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Instance URL",
+    description: "URL of the self-hosted instance.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public instanceUrl?: string = undefined;
+}

package/Server/API/OpenSourceDeploymentAPI.ts

@@ -0,0 +1,73 @@
+import OpenSourceDeployment from "../../Models/DatabaseModels/OpenSourceDeployment";
+import { JSONObject } from "../../Types/JSON";
+import URL from "../../Types/API/URL";
+import API from "../../Utils/API";
+import OpenSourceDeploymentService, {
+  Service as OpenSourceDeploymentServiceType,
+} from "../Services/OpenSourceDeploymentService";
+import { OpenSourceDeploymentWebhookUrl } from "../EnvironmentConfig";
+import logger from "../Utils/Logger";
+import Response from "../Utils/Response";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import BaseAPI from "./BaseAPI";
+
+export default class OpenSourceDeploymentAPI extends BaseAPI<
+  OpenSourceDeployment,
+  OpenSourceDeploymentServiceType
+> {
+  public constructor() {
+    super(OpenSourceDeployment, OpenSourceDeploymentService);
+
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/register`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const body: JSONObject = req.body;
+
+          const deployment: OpenSourceDeployment = new OpenSourceDeployment();
+
+          deployment.email = (body["email"] as string) || "";
+          deployment.name = (body["name"] as string) || "";
+          deployment.companyName = (body["companyName"] as string) || "";
+          deployment.companyPhoneNumber =
+            (body["companyPhoneNumber"] as string) || "";
+          deployment.oneuptimeVersion =
+            (body["oneuptimeVersion"] as string) || "unknown";
+          deployment.instanceUrl = (body["instanceUrl"] as string) || "";
+
+          await OpenSourceDeploymentService.create({
+            data: deployment,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          if (OpenSourceDeploymentWebhookUrl) {
+            API.post({
+              url: URL.fromString(OpenSourceDeploymentWebhookUrl),
+              data: {
+                email: deployment.email?.toString() || "",
+                name: deployment.name?.toString() || "",
+                companyName: deployment.companyName?.toString() || "",
+                companyPhoneNumber:
+                  deployment.companyPhoneNumber?.toString() || "",
+                oneuptimeVersion: deployment.oneuptimeVersion?.toString() || "",
+                instanceUrl: deployment.instanceUrl?.toString() || "",
+              },
+            }).catch((err: Error) => {
+              logger.error(err);
+            });
+          }
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+}

package/Server/EnvironmentConfig.ts

@@ -148,6 +148,9 @@ export const EncryptionSecret: ObjectID = new ObjectID(
   process.env["ENCRYPTION_SECRET"] || "secret",
 );
 
+export const OpenSourceDeploymentWebhookUrl: string =
+  process.env["OPEN_SOURCE_DEPLOYMENT_WEBHOOK_URL"] || "";
+
 export const AirtableApiKey: string = process.env["AIRTABLE_API_KEY"] || "";
 
 export const AirtableBaseId: string = process.env["AIRTABLE_BASE_ID"] || "";

package/Server/Infrastructure/Postgres/SchemaMigrations/1770237245070-MigrationName.ts

@@ -22,23 +22,23 @@ export class MigrationName1770237245070 implements MigrationInterface {
     );
 
     /*
-     * Backfill counters from COUNT of each entity table (including soft-deleted rows)
-     * Using JOIN-based updates instead of correlated subqueries for performance
+     * Backfill counters from MAX number of each entity table (per project)
+     * Using MAX instead of COUNT to correctly handle deleted rows
      */
     await queryRunner.query(
-      `UPDATE "Project" SET "incidentCounter" = sub.cnt FROM (SELECT "projectId", COUNT(*) as cnt FROM "Incident" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
+      `UPDATE "Project" SET "incidentCounter" = sub.max_num FROM (SELECT "projectId", COALESCE(MAX("incidentNumber"), 0) as max_num FROM "Incident" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
     );
     await queryRunner.query(
-      `UPDATE "Project" SET "alertCounter" = sub.cnt FROM (SELECT "projectId", COUNT(*) as cnt FROM "Alert" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
+      `UPDATE "Project" SET "alertCounter" = sub.max_num FROM (SELECT "projectId", COALESCE(MAX("alertNumber"), 0) as max_num FROM "Alert" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
     );
     await queryRunner.query(
-      `UPDATE "Project" SET "scheduledMaintenanceCounter" = sub.cnt FROM (SELECT "projectId", COUNT(*) as cnt FROM "ScheduledMaintenance" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
+      `UPDATE "Project" SET "scheduledMaintenanceCounter" = sub.max_num FROM (SELECT "projectId", COALESCE(MAX("scheduledMaintenanceNumber"), 0) as max_num FROM "ScheduledMaintenance" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
     );
     await queryRunner.query(
-      `UPDATE "Project" SET "incidentEpisodeCounter" = sub.cnt FROM (SELECT "projectId", COUNT(*) as cnt FROM "IncidentEpisode" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
+      `UPDATE "Project" SET "incidentEpisodeCounter" = sub.max_num FROM (SELECT "projectId", COALESCE(MAX("episodeNumber"), 0) as max_num FROM "IncidentEpisode" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
     );
     await queryRunner.query(
-      `UPDATE "Project" SET "alertEpisodeCounter" = sub.cnt FROM (SELECT "projectId", COUNT(*) as cnt FROM "AlertEpisode" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
+      `UPDATE "Project" SET "alertEpisodeCounter" = sub.max_num FROM (SELECT "projectId", COALESCE(MAX("episodeNumber"), 0) as max_num FROM "AlertEpisode" GROUP BY "projectId") sub WHERE "Project"."_id" = sub."projectId"`,
     );
   }
 

package/Server/Infrastructure/Postgres/SchemaMigrations/1770668054908-MigrationName.ts

@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+import CaptureSpan from "../../../Utils/Telemetry/CaptureSpan";
+
+export class MigrationName1770668054908 implements MigrationInterface {
+  public name = "MigrationName1770668054908";
+
+  @CaptureSpan()
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ALTER COLUMN "groupByMonitor" SET DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" ALTER COLUMN "groupByMonitor" SET DEFAULT false`,
+    );
+  }
+
+  @CaptureSpan()
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ALTER COLUMN "groupByMonitor" SET DEFAULT true`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" ALTER COLUMN "groupByMonitor" SET DEFAULT true`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1770728946893-MigrationName.ts

@@ -0,0 +1,47 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1770728946893 implements MigrationInterface {
+  public name = "MigrationName1770728946893";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" ADD "allIncidentsResolvedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertEpisode" ADD "allAlertsResolvedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0610406e5c436c20a5068b1006" ON "IncidentEpisode" ("allIncidentsResolvedAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ea5d1f899fe52445dd6e0d0d55" ON "AlertEpisode" ("allAlertsResolvedAt") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ea5d1f899fe52445dd6e0d0d55"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0610406e5c436c20a5068b1006"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertEpisode" DROP COLUMN "allAlertsResolvedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentEpisode" DROP COLUMN "allIncidentsResolvedAt"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1770732721195-MigrationName.ts

@@ -0,0 +1,27 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1770732721195 implements MigrationInterface {
+  public name = "MigrationName1770732721195";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "OpenSourceDeployment" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "email" character varying(100) NOT NULL, "name" character varying(100) NOT NULL, "companyName" character varying(100), "companyPhoneNumber" character varying(30), "oneuptimeVersion" character varying(100) NOT NULL, "instanceUrl" character varying(100), CONSTRAINT "PK_cf6728c16db1c0c1b89f8ffc6dd" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(`DROP TABLE "OpenSourceDeployment"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -253,6 +253,9 @@ import { MigrationName1770232207959 } from "./1770232207959-MigrationName";
 import { MigrationName1770237245069 } from "./1770237245069-MigrationName";
 import { MigrationName1770237245070 } from "./1770237245070-MigrationName";
 import { MigrationName1770407024682 } from "./1770407024682-MigrationName";
+import { MigrationName1770668054908 } from "./1770668054908-MigrationName";
+import { MigrationName1770728946893 } from "./1770728946893-MigrationName";
+import { MigrationName1770732721195 } from "./1770732721195-MigrationName";
 
 export default [
   InitialMigration,
@@ -510,4 +513,7 @@ export default [
   MigrationName1770237245069,
   MigrationName1770237245070,
   MigrationName1770407024682,
+  MigrationName1770668054908,
+  MigrationName1770728946893,
+  MigrationName1770732721195,
 ];

package/Server/Services/AlertEpisodeMemberService.ts

@@ -94,26 +94,16 @@ export class Service extends DatabaseService<Model> {
     });
 
     // Update episode's alertCount and lastAlertAddedAt
-    Promise.resolve()
-      .then(async () => {
-        try {
-          await AlertEpisodeService.updateAlertCount(
-            createdItem.alertEpisodeId!,
-          );
-          await AlertEpisodeService.updateLastAlertAddedAt(
-            createdItem.alertEpisodeId!,
-          );
-        } catch (error) {
-          logger.error(
-            `Error updating episode counts in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
-          );
-        }
-      })
-      .catch((error: Error) => {
-        logger.error(
-          `Critical error in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
-        );
-      });
+    try {
+      await AlertEpisodeService.updateAlertCount(createdItem.alertEpisodeId!);
+      await AlertEpisodeService.updateLastAlertAddedAt(
+        createdItem.alertEpisodeId!,
+      );
+    } catch (error) {
+      logger.error(
+        `Error updating episode counts in AlertEpisodeMemberService.onCreateSuccess: ${error}`,
+      );
+    }
 
     // Get alert details for feed
     const alert: Alert | null = await AlertService.findOneById({

package/Server/Services/AlertEpisodeService.ts

@@ -815,11 +815,12 @@ export class Service extends DatabaseService<Model> {
       },
     });
 
-    // Clear resolved timestamp
+    // Clear resolved timestamp and allAlertsResolvedAt
     await this.updateOneById({
       id: episodeId,
       data: {
-        resolvedAt: undefined as any,
+        resolvedAt: null,
+        allAlertsResolvedAt: null,
       },
       props: {
         isRoot: true,

package/Server/Services/AlertGroupingEngineService.ts

@@ -688,6 +688,7 @@ class AlertGroupingEngineServiceClass {
     newEpisode.alertGroupingRuleId = rule.id!;
     newEpisode.groupingKey = groupingKey;
     newEpisode.isManuallyCreated = false;
+    newEpisode.lastAlertAddedAt = OneUptimeDate.getCurrentDate();
 
     // Set severity from alert
     if (alert.alertSeverityId) {

package/Server/Services/IncidentEpisodeMemberService.ts

@@ -96,26 +96,18 @@ export class Service extends DatabaseService<Model> {
     });
 
     // Update episode's incidentCount and lastIncidentAddedAt
-    Promise.resolve()
-      .then(async () => {
-        try {
-          await IncidentEpisodeService.updateIncidentCount(
-            createdItem.incidentEpisodeId!,
-          );
-          await IncidentEpisodeService.updateLastIncidentAddedAt(
-            createdItem.incidentEpisodeId!,
-          );
-        } catch (error) {
-          logger.error(
-            `Error updating episode counts in IncidentEpisodeMemberService.onCreateSuccess: ${error}`,
-          );
-        }
-      })
-      .catch((error: Error) => {
-        logger.error(
-          `Critical error in IncidentEpisodeMemberService.onCreateSuccess: ${error}`,
-        );
-      });
+    try {
+      await IncidentEpisodeService.updateIncidentCount(
+        createdItem.incidentEpisodeId!,
+      );
+      await IncidentEpisodeService.updateLastIncidentAddedAt(
+        createdItem.incidentEpisodeId!,
+      );
+    } catch (error) {
+      logger.error(
+        `Error updating episode counts in IncidentEpisodeMemberService.onCreateSuccess: ${error}`,
+      );
+    }
 
     // Get incident details for feed
     const incident: Incident | null = await IncidentService.findOneById({