@oneuptime/common 11.7.1 → 11.7.3

package/Server/API/StatusPageAPI.ts

@@ -8,7 +8,6 @@ import IncidentPublicNoteService from "../Services/IncidentPublicNoteService";
 import IncidentService from "../Services/IncidentService";
 import IncidentStateService from "../Services/IncidentStateService";
 import IncidentStateTimelineService from "../Services/IncidentStateTimelineService";
-import MonitorGroupResourceService from "../Services/MonitorGroupResourceService";
 import MonitorGroupService from "../Services/MonitorGroupService";
 import MonitorStatusService from "../Services/MonitorStatusService";
 import ScheduledMaintenancePublicNoteService from "../Services/ScheduledMaintenancePublicNoteService";
@@ -120,44 +119,19 @@ type ResolveStatusPageIdOrThrowFunction = (
 const resolveStatusPageIdOrThrow: ResolveStatusPageIdOrThrowFunction = async (
   statusPageIdOrDomain: string,
 ): Promise<ObjectID> => {
-  if (!statusPageIdOrDomain) {
+  /*
+   * Delegates to the service resolver so every endpoint shares its
+   * custom-domain -> statusPageId cache (one Postgres lookup per domain per
+   * TTL instead of one per request).
+   */
+  const statusPageId: ObjectID | null =
+    await StatusPageService.resolveStatusPageIdOrNull(statusPageIdOrDomain);
+
+  if (!statusPageId) {
     throw new NotFoundException("Status Page not found");
   }
 
-  if (statusPageIdOrDomain.includes(".")) {
-    const statusPageDomain: StatusPageDomain | null =
-      await StatusPageDomainService.findOneBy({
-        query: {
-          fullDomain: statusPageIdOrDomain,
-          domain: {
-            isVerified: true,
-          } as any,
-        },
-        select: {
-          statusPageId: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-    if (!statusPageDomain || !statusPageDomain.statusPageId) {
-      throw new NotFoundException("Status Page not found");
-    }
-
-    return statusPageDomain.statusPageId;
-  }
-
-  try {
-    ObjectID.validateUUID(statusPageIdOrDomain);
-    return new ObjectID(statusPageIdOrDomain);
-  } catch (err) {
-    logger.error(
-      `Error converting statusPageIdOrDomain to ObjectID: ${statusPageIdOrDomain}`,
-    );
-    logger.error(err);
-    throw new NotFoundException("Status Page not found");
-  }
+  return statusPageId;
 };
 
 export default class StatusPageAPI extends BaseAPI<
@@ -176,52 +150,18 @@ export default class StatusPageAPI extends BaseAPI<
           "statusPageIdOrDomain"
         ] as string;
 
-        let statusPageId: ObjectID | null = null;
-
-        if (statusPageIdOrDomain && statusPageIdOrDomain.includes(".")) {
-          // then this is a domain and not the status page id. We need to get the status page id from the domain.
-
-          const statusPageDomain: StatusPageDomain | null =
-            await StatusPageDomainService.findOneBy({
-              query: {
-                fullDomain: statusPageIdOrDomain,
-                domain: {
-                  isVerified: true,
-                } as any,
-              },
-              select: {
-                statusPageId: true,
-              },
-              props: {
-                isRoot: true,
-              },
-            });
-
-          if (!statusPageDomain || !statusPageDomain.statusPageId) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new NotFoundException("Status Page not found"),
-            );
-          }
+        // Shares the service resolver's custom-domain -> statusPageId cache.
+        const statusPageId: ObjectID | null =
+          await StatusPageService.resolveStatusPageIdOrNull(
+            statusPageIdOrDomain,
+          );
 
-          statusPageId = statusPageDomain.statusPageId;
-        } else {
-          // then this is a status page id. We need to get the status page id from the id.
-          try {
-            statusPageId = new ObjectID(statusPageIdOrDomain);
-          } catch (err) {
-            logger.error(
-              `Error converting statusPageIdOrDomain to ObjectID: ${statusPageIdOrDomain}`,
-              getLogAttributesFromRequest(req as any),
-            );
-            logger.error(err, getLogAttributesFromRequest(req as any));
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new NotFoundException("Status Page not found"),
-            );
-          }
+        if (!statusPageId) {
+          return Response.sendErrorResponse(
+            req,
+            res,
+            new NotFoundException("Status Page not found"),
+          );
         }
 
         const statusPage: StatusPage | null = await StatusPageService.findOneBy(
@@ -1530,34 +1470,13 @@ export default class StatusPageAPI extends BaseAPI<
           req: req,
         });
 
-        // First fetch the status page to get the configured uptime history days
-        const statusPageForDays: StatusPage | null =
-          await StatusPageService.findOneBy({
-            query: {
-              _id: statusPageId.toString(),
-            },
-            select: {
-              showUptimeHistoryInDays: true,
-            },
-            props: {
-              isRoot: true,
-            },
-          });
-
-        let uptimeHistoryDays: number =
-          statusPageForDays?.showUptimeHistoryInDays || 90;
-
-        if (uptimeHistoryDays > 90) {
-          uptimeHistoryDays = 90;
-        }
-
-        if (uptimeHistoryDays < 1) {
-          uptimeHistoryDays = 1;
-        }
-
-        const startDate: Date = OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
-        const endDate: Date = OneUptimeDate.getCurrentDate();
-
+        /*
+         * The timeline window comes from the status page's configured
+         * showUptimeHistoryInDays. getStatusPageResourcesAndTimelines
+         * fetches the status page row anyway, so let it compute the window
+         * (clamped to 1..90 days, ending now) instead of issuing a separate
+         * StatusPage query here just to read that one column.
+         */
         const {
           monitorStatuses,
           monitorGroupCurrentStatuses,
@@ -1567,10 +1486,10 @@ export default class StatusPageAPI extends BaseAPI<
           monitorStatusTimelines,
           statusPageGroups,
           monitorsInGroup,
-        } = await this.getStatusPageResourcesAndTimelines({
-          statusPageId: statusPageId,
           startDateForMonitorTimeline: startDate,
           endDateForMonitorTimeline: endDate,
+        } = await this.getStatusPageResourcesAndTimelines({
+          statusPageId: statusPageId,
         });
 
         // check if status page has active incident.
@@ -1727,10 +1646,54 @@ export default class StatusPageAPI extends BaseAPI<
         let episodePublicNotes: Array<IncidentEpisodePublicNote> = [];
         let episodeStateTimelines: Array<IncidentEpisodeStateTimeline> = [];
 
+        /*
+         * Cheap guard before the expensive part: the block below scans every
+         * incident ever attached to this page's monitors (a many-to-many
+         * join, up to LIMIT_PER_PROJECT rows) just to discover episode
+         * membership — on every overview view, even though most pages have
+         * zero active episodes most of the time. One indexed COUNT of the
+         * project's unresolved, visible episodes lets us skip all of it in
+         * the common case. Behavior-preserving: the final activeEpisodes
+         * query applies exactly these three constraints, so count == 0
+         * implies the block's outputs stay empty.
+         */
+        let unresolvedIncidentStateIds: Array<ObjectID> = [];
+        let hasActiveEpisodes: boolean = false;
+
         if (
           statusPage.showEpisodesOnStatusPage &&
           monitorsOnStatusPage.length > 0
         ) {
+          const unresolvedIncidentStates: Array<IncidentState> =
+            await IncidentStateService.getUnresolvedIncidentStates(
+              statusPage.projectId!,
+              { isRoot: true },
+            );
+
+          unresolvedIncidentStateIds = unresolvedIncidentStates.map(
+            (state: IncidentState) => {
+              return state.id!;
+            },
+          );
+
+          const activeEpisodeCount: PositiveNumber =
+            await IncidentEpisodeService.countBy({
+              query: {
+                projectId: statusPage.projectId!,
+                isVisibleOnStatusPage: true,
+                currentIncidentStateId: QueryHelper.any(
+                  unresolvedIncidentStateIds,
+                ),
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          hasActiveEpisodes = activeEpisodeCount.toNumber() > 0;
+        }
+
+        if (hasActiveEpisodes) {
           // First, get incidents that have monitors on status page
           const incidentsForEpisodes: Array<Incident> =
             await IncidentService.findBy({
@@ -1784,17 +1747,7 @@ export default class StatusPageAPI extends BaseAPI<
 
           // Fetch active (unresolved) episodes
           if (episodeIdsFromMembers.size > 0) {
-            const unresolvedIncidentStates: Array<IncidentState> =
-              await IncidentStateService.getUnresolvedIncidentStates(
-                statusPage.projectId!,
-                { isRoot: true },
-              );
-
-            const unresolvedIncidentStateIds: Array<ObjectID> =
-              unresolvedIncidentStates.map((state: IncidentState) => {
-                return state.id!;
-              });
-
+            // unresolvedIncidentStateIds was fetched by the guard above.
             let selectEpisodes: Select<IncidentEpisode> = {
               createdAt: true,
               declaredAt: true,
@@ -3009,31 +2962,15 @@ export default class StatusPageAPI extends BaseAPI<
         return Boolean(id); // remove nulls
       });
 
+    // Batched: one query for all monitor groups instead of one per group.
+    const monitorIdsByGroupId: Dictionary<Array<ObjectID>> =
+      await MonitorGroupService.getMonitorIdsInMonitorGroups(monitorGroupIds);
+
     for (const monitorGroupId of monitorGroupIds) {
       // get monitors in the group.
 
-      const groupResources: Array<MonitorGroupResource> =
-        await MonitorGroupResourceService.findBy({
-          query: {
-            monitorGroupId: monitorGroupId,
-          },
-          select: {
-            monitorId: true,
-          },
-          props: {
-            isRoot: true,
-          },
-          limit: LIMIT_PER_PROJECT,
-          skip: 0,
-        });
-
-      const monitorsInGroupIds: Array<ObjectID> = groupResources
-        .map((resource: MonitorGroupResource) => {
-          return resource.monitorId!;
-        })
-        .filter((id: ObjectID) => {
-          return Boolean(id); // remove nulls
-        });
+      const monitorsInGroupIds: Array<ObjectID> =
+        monitorIdsByGroupId[monitorGroupId.toString()] || [];
 
       for (const monitorId of monitorsInGroupIds) {
         if (
@@ -3232,31 +3169,15 @@ export default class StatusPageAPI extends BaseAPI<
         return Boolean(id); // remove nulls
       });
 
+    // Batched: one query for all monitor groups instead of one per group.
+    const monitorIdsByGroupId: Dictionary<Array<ObjectID>> =
+      await MonitorGroupService.getMonitorIdsInMonitorGroups(monitorGroupIds);
+
     for (const monitorGroupId of monitorGroupIds) {
       // get monitors in the group.
 
-      const groupResources: Array<MonitorGroupResource> =
-        await MonitorGroupResourceService.findBy({
-          query: {
-            monitorGroupId: monitorGroupId,
-          },
-          select: {
-            monitorId: true,
-          },
-          props: {
-            isRoot: true,
-          },
-          limit: LIMIT_PER_PROJECT,
-          skip: 0,
-        });
-
-      const monitorsInGroupIds: Array<ObjectID> = groupResources
-        .map((resource: MonitorGroupResource) => {
-          return resource.monitorId!;
-        })
-        .filter((id: ObjectID) => {
-          return Boolean(id); // remove nulls
-        });
+      const monitorsInGroupIds: Array<ObjectID> =
+        monitorIdsByGroupId[monitorGroupId.toString()] || [];
 
       for (const monitorId of monitorsInGroupIds) {
         if (
@@ -4177,6 +4098,8 @@ export default class StatusPageAPI extends BaseAPI<
     const { monitorsOnStatusPage, monitorsInGroup } =
       await StatusPageService.getMonitorIdsOnStatusPage({
         statusPageId: statusPageId,
+        // reuse the resources fetched above instead of re-querying them
+        statusPageResources: statusPageResources,
       });
 
     const today: Date = OneUptimeDate.getCurrentDate();
@@ -4453,6 +4376,8 @@ export default class StatusPageAPI extends BaseAPI<
     const { monitorsOnStatusPage, monitorsInGroup } =
       await StatusPageService.getMonitorIdsOnStatusPage({
         statusPageId: statusPageId,
+        // reuse the resources fetched above instead of re-querying them
+        statusPageResources: statusPageResources,
       });
 
     const today: Date = OneUptimeDate.getCurrentDate();
@@ -4876,8 +4801,15 @@ export default class StatusPageAPI extends BaseAPI<
   @CaptureSpan()
   public async getStatusPageResourcesAndTimelines(data: {
     statusPageId: ObjectID;
-    startDateForMonitorTimeline: Date;
-    endDateForMonitorTimeline: Date;
+    /*
+     * When omitted, the timeline window is computed from the status page's
+     * own showUptimeHistoryInDays (clamped to 1..90 days, ending now) —
+     * the status page row is fetched below anyway, so callers that want the
+     * page-configured window (the overview endpoint) don't need their own
+     * StatusPage query just to read that column.
+     */
+    startDateForMonitorTimeline?: Date | undefined;
+    endDateForMonitorTimeline?: Date | undefined;
   }): Promise<{
     statusPageResources: StatusPageResource[];
     monitorStatuses: MonitorStatus[];
@@ -4887,6 +4819,8 @@ export default class StatusPageAPI extends BaseAPI<
     statusPage: StatusPage;
     monitorsOnStatusPage: ObjectID[];
     monitorsInGroup: Dictionary<ObjectID[]>;
+    startDateForMonitorTimeline: Date;
+    endDateForMonitorTimeline: Date;
   }> {
     const objectId: ObjectID = data.statusPageId;
 
@@ -4923,6 +4857,27 @@ export default class StatusPageAPI extends BaseAPI<
       throw new BadDataException("Status Page not found");
     }
 
+    let startDateForMonitorTimeline: Date | undefined =
+      data.startDateForMonitorTimeline;
+    let endDateForMonitorTimeline: Date | undefined =
+      data.endDateForMonitorTimeline;
+
+    if (!startDateForMonitorTimeline || !endDateForMonitorTimeline) {
+      let uptimeHistoryDays: number = statusPage.showUptimeHistoryInDays || 90;
+
+      if (uptimeHistoryDays > 90) {
+        uptimeHistoryDays = 90;
+      }
+
+      if (uptimeHistoryDays < 1) {
+        uptimeHistoryDays = 1;
+      }
+
+      startDateForMonitorTimeline =
+        OneUptimeDate.getSomeDaysAgo(uptimeHistoryDays);
+      endDateForMonitorTimeline = OneUptimeDate.getCurrentDate();
+    }
+
     //get monitor statuses
 
     const monitorStatuses: Array<MonitorStatus> =
@@ -5049,35 +5004,43 @@ export default class StatusPageAPI extends BaseAPI<
         return Boolean(id); // remove nulls
       });
 
+    /*
+     * Batched: this loop used to issue 4 queries per monitor group per page
+     * view (3 inside MonitorGroupService.getCurrentStatus + one duplicate
+     * group-resource fetch), on the hottest public endpoint in the product.
+     * One shared fetch + the already-loaded `monitorStatuses` now serve every
+     * group.
+     */
+    const monitorGroupResourcesByGroupId: Dictionary<
+      Array<MonitorGroupResource>
+    > =
+      await MonitorGroupService.getMonitorGroupResourcesByGroupIds(
+        monitorGroupIds,
+      );
+
+    const monitorGroupStatuses: Dictionary<MonitorStatus> =
+      await MonitorGroupService.getCurrentStatusesForMonitorGroups({
+        monitorGroupIds: monitorGroupIds,
+        monitorStatuses: monitorStatuses,
+        monitorGroupResources: monitorGroupResourcesByGroupId,
+      });
+
     for (const monitorGroupId of monitorGroupIds) {
       // get current status of monitors in the group.
 
-      const currentStatus: MonitorStatus =
-        await MonitorGroupService.getCurrentStatus(monitorGroupId, {
-          isRoot: true,
-        });
+      const currentStatus: MonitorStatus | undefined =
+        monitorGroupStatuses[monitorGroupId.toString()];
 
-      monitorGroupCurrentStatuses[monitorGroupId.toString()] =
-        currentStatus.id!;
+      if (currentStatus) {
+        monitorGroupCurrentStatuses[monitorGroupId.toString()] =
+          currentStatus.id!;
+      }
 
       // get monitors in the group.
 
-      const groupResources: Array<MonitorGroupResource> =
-        await MonitorGroupResourceService.findBy({
-          query: {
-            monitorGroupId: monitorGroupId,
-          },
-          select: {
-            monitorId: true,
-          },
-          props: {
-            isRoot: true,
-          },
-          limit: LIMIT_PER_PROJECT,
-          skip: 0,
-        });
-
-      const monitorsInGroupIds: Array<ObjectID> = groupResources
+      const monitorsInGroupIds: Array<ObjectID> = (
+        monitorGroupResourcesByGroupId[monitorGroupId.toString()] || []
+      )
         .map((resource: MonitorGroupResource) => {
           return resource.monitorId!;
         })
@@ -5125,8 +5088,8 @@ export default class StatusPageAPI extends BaseAPI<
     const monitorStatusTimelines: Array<MonitorStatusTimeline> =
       await StatusPageService.getMonitorStatusTimelineForStatusPage({
         monitorIds: monitorsOnStatusPageForTimeline,
-        startDate: data.startDateForMonitorTimeline,
-        endDate: data.endDateForMonitorTimeline,
+        startDate: startDateForMonitorTimeline,
+        endDate: endDateForMonitorTimeline,
       });
 
     // return everything.
@@ -5140,6 +5103,8 @@ export default class StatusPageAPI extends BaseAPI<
       statusPage,
       monitorsOnStatusPage,
       monitorsInGroup,
+      startDateForMonitorTimeline,
+      endDateForMonitorTimeline,
     };
   }
 

package/Server/Infrastructure/Postgres/SchemaMigrations/1785140242697-AddHotQueryIndexes.ts

@@ -0,0 +1,89 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddHotQueryIndexes1785140242697 implements MigrationInterface {
+  public name = "AddHotQueryIndexes1785140242697";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ff92577021975c63c570943872" ON "Monitor" ("monitorType") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_de21b5271b886e528ca36388be" ON "IncidentEpisode" ("subscriberNotificationStatusOnEpisodeCreated") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_0a33db54e9454945d865a6461b" ON "Incident" ("subscriberNotificationStatusOnIncidentCreated") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_1319bc680d15900efa8f2caac6" ON "Incident" ("subscriberNotificationStatusOnPostmortemPublished") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_33865d2e485cb1b63cf6cb8b67" ON "ScheduledMaintenance" ("subscriberNotificationStatusOnEventScheduled") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_1d37348eb2a0eab9ab6b739e1b" ON "StatusPageAnnouncement" ("subscriberNotificationStatus") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_90c4580b2ad6fe6611f58975f7" ON "IncidentPublicNote" ("subscriberNotificationStatusOnNoteCreated") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b64685d3d7303e1b62477b729e" ON "IncidentStateTimeline" ("subscriberNotificationStatus") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c75caf0b6a8d66a7c64975c015" ON "OnCallDutyPolicyExecutionLog" ("status") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_13813da8afd9f7b4f3bdc27e68" ON "ScheduledMaintenancePublicNote" ("subscriberNotificationStatusOnNoteCreated") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ae269b43b4d03e69ee3176477c" ON "ScheduledMaintenanceStateTimeline" ("subscriberNotificationStatus") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_203246e9d08f4673386512ca29" ON "IncidentEpisodeStateTimeline" ("subscriberNotificationStatus") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_e8b681595d105b37012921df1b" ON "IncidentEpisodePublicNote" ("subscriberNotificationStatusOnNoteCreated") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_e8b681595d105b37012921df1b"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_203246e9d08f4673386512ca29"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ae269b43b4d03e69ee3176477c"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_13813da8afd9f7b4f3bdc27e68"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c75caf0b6a8d66a7c64975c015"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b64685d3d7303e1b62477b729e"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_90c4580b2ad6fe6611f58975f7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_1d37348eb2a0eab9ab6b739e1b"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_33865d2e485cb1b63cf6cb8b67"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_1319bc680d15900efa8f2caac6"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_0a33db54e9454945d865a6461b"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_de21b5271b886e528ca36388be"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ff92577021975c63c570943872"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1785148065137-AddHotQueryIndexesSecondPass.ts

@@ -0,0 +1,61 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddHotQueryIndexesSecondPass1785148065137
+  implements MigrationInterface
+{
+  public name: string = "AddHotQueryIndexesSecondPass1785148065137";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9ba5449f967cce45bfa9f79d72" ON "StatusPageDomain" ("fullDomain") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ea265f709c2e27ba37c8c91bb7" ON "DashboardDomain" ("fullDomain") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_62a81ecebd87bb91860b8820ab" ON "StatusPage" ("sendNextReportBy") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c382913dd4288e74af031d7110" ON "OnCallDutyPolicySchedule" ("rosterHandoffAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_814e5dbdcf3b61f3ae43e1da10" ON "OnCallDutyPolicySchedule" ("rosterNextStartAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_7d9ec527863baaeb823af7ef04" ON "WorkspaceNotificationSummary" ("nextSendAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_f799bfe4eeb42c29999e5df874" ON "ScheduledMaintenanceTemplate" ("scheduleNextEventAt") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_14ff60254ae31509cb2ceeb814" ON "NetworkSite" ("lastRollupAt") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_14ff60254ae31509cb2ceeb814"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_f799bfe4eeb42c29999e5df874"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_7d9ec527863baaeb823af7ef04"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_814e5dbdcf3b61f3ae43e1da10"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c382913dd4288e74af031d7110"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_62a81ecebd87bb91860b8820ab"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ea265f709c2e27ba37c8c91bb7"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_9ba5449f967cce45bfa9f79d72"`,
+    );
+  }
+}