@oneuptime/common 14.0.10 → 14.0.11

package/Models/DatabaseModels/ServerlessFunction.ts

@@ -1,3 +1,5 @@
+import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+import ColumnBillingAccessControl from "../../Types/Database/AccessControl/ColumnBillingAccessControl";
 import Label from "./Label";
 import Project from "./Project";
 import User from "./User";
@@ -696,6 +698,11 @@ export default class ServerlessFunction extends BaseModel {
     nullable: true,
     unique: false,
   })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Scale,
+  })
   public retainTelemetryDataForDays?: number = undefined;
 
   @ColumnAccessControl({
@@ -737,6 +744,11 @@ export default class ServerlessFunction extends BaseModel {
     type: ColumnType.JSON,
     nullable: true,
   })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Scale,
+  })
   public telemetryRetentionConfig?: TelemetryRetentionConfig = undefined;
 
   @ColumnAccessControl({

package/Models/DatabaseModels/Service.ts

@@ -1,3 +1,5 @@
+import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+import ColumnBillingAccessControl from "../../Types/Database/AccessControl/ColumnBillingAccessControl";
 import Label from "./Label";
 import Project from "./Project";
 import User from "./User";
@@ -874,6 +876,11 @@ export default class Service extends BaseModel {
     nullable: true,
     unique: false,
   })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Scale,
+  })
   public retainTelemetryDataForDays?: number = undefined;
 
   @ColumnAccessControl({
@@ -999,6 +1006,11 @@ export default class Service extends BaseModel {
     type: ColumnType.JSON,
     nullable: true,
   })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Scale,
+  })
   public telemetryRetentionConfig?: TelemetryRetentionConfig = undefined;
 
   @ColumnAccessControl({

package/Models/DatabaseModels/StatusPageOidc.ts

@@ -9,7 +9,6 @@ import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccess
 import OwnedThrough from "../../Types/Database/AccessControl/OwnedThrough";
 import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
 import TableBillingAccessControl from "../../Types/Database/AccessControl/TableBillingAccessControl";
-import TableEditionAccessControl from "../../Types/Database/AccessControl/TableEditionAccessControl";
 import CanAccessIfCanReadOn from "../../Types/Database/CanAccessIfCanReadOn";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
@@ -27,9 +26,6 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 
 @EnableDocumentation()
 @CanAccessIfCanReadOn("statusPage")
-@TableEditionAccessControl({
-  requiresEnterprise: true,
-})
 @TableBillingAccessControl({
   create: PlanType.Scale,
   read: PlanType.Scale,

package/Models/DatabaseModels/StatusPageSso.ts

@@ -9,7 +9,6 @@ import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccess
 import OwnedThrough from "../../Types/Database/AccessControl/OwnedThrough";
 import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
 import TableBillingAccessControl from "../../Types/Database/AccessControl/TableBillingAccessControl";
-import TableEditionAccessControl from "../../Types/Database/AccessControl/TableEditionAccessControl";
 import CanAccessIfCanReadOn from "../../Types/Database/CanAccessIfCanReadOn";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
@@ -29,9 +28,6 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 
 @EnableDocumentation()
 @CanAccessIfCanReadOn("statusPage")
-@TableEditionAccessControl({
-  requiresEnterprise: true,
-})
 @TableBillingAccessControl({
   create: PlanType.Scale,
   read: PlanType.Scale,

package/Models/DatabaseModels/TeamComplianceSetting.ts

@@ -75,7 +75,7 @@ import {
  * No unique (teamId, ruleType) index: one team can hold several rules of the
  * same type - "Call for Critical incidents" and "Push for Critical incidents"
  * are both HasIncidentOnCallRules. TeamComplianceSettingService rejects exact
- * duplicates (same type, channel and severities) instead.
+ * duplicates (same type, channels and severities) instead.
  */
 @Entity({
   name: "TeamComplianceSetting",
@@ -450,12 +450,24 @@ export default class TeamComplianceSetting extends BaseModel {
       Permission.EditProjectTeam,
     ],
   })
+  /*
+   * Deprecated in favour of notificationChannels, and kept for everything
+   * that only knows this column: API clients written before a rule could
+   * require several channels, and a replica of an older build still running
+   * during an upgrade (or after a downgrade). TeamComplianceSettingService
+   * keeps it equal to the first of notificationChannels on every write, so
+   * such a build checks one of the rule's channels rather than "any
+   * channel"; a payload that sends only this column sets the list to that
+   * one channel; and a row whose list it disagrees with was last written by
+   * an older build, which is how the rule is then read
+   * (TeamComplianceSettingService.getStoredChannels).
+   */
   @TableColumn({
     required: false,
     type: TableColumnType.ShortText,
     title: "Notification Channel",
     description:
-      "On-call rules only: the channel the member's rule must notify them on (Call, SMS, Push, Email, WhatsApp, Telegram, Slack, MicrosoftTeams or Webhook). Leave empty to accept any channel.",
+      "Deprecated: use notificationChannels. The first of the rule's notification channels, or empty when it accepts any channel. Sending this field without notificationChannels sets the rule to that one channel (Call, SMS, Push, Email, WhatsApp, Telegram, Slack, MicrosoftTeams or Webhook).",
   })
   @Column({
     nullable: true,
@@ -464,6 +476,39 @@ export default class TeamComplianceSetting extends BaseModel {
   })
   public notificationChannel?: ComplianceNotificationChannel = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditProjectTeam,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.ReadProjectTeam,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.EditProjectTeam,
+    ],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.JSON,
+    title: "Notification Channels",
+    description:
+      "On-call rules only: the channels members must be notified on, as a list - each member needs a rule on every one of them (Call, SMS, Push, Email, WhatsApp, Telegram, Slack, MicrosoftTeams or Webhook). Leave empty to accept any channel.",
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public notificationChannels?: Array<ComplianceNotificationChannel> =
+    undefined;
+
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Models/DatabaseModels/VMwareVCenter.ts

@@ -1,3 +1,5 @@
+import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+import ColumnBillingAccessControl from "../../Types/Database/AccessControl/ColumnBillingAccessControl";
 import Label from "./Label";
 import Project from "./Project";
 import User from "./User";
@@ -1078,6 +1080,11 @@ export default class VMwareVCenter extends BaseModel {
     nullable: true,
     unique: false,
   })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Scale,
+  })
   public retainTelemetryDataForDays?: number = undefined;
 
   @ColumnAccessControl({
@@ -1119,6 +1126,11 @@ export default class VMwareVCenter extends BaseModel {
     type: ColumnType.JSON,
     nullable: true,
   })
+  @ColumnBillingAccessControl({
+    read: PlanType.Free,
+    update: PlanType.Scale,
+    create: PlanType.Scale,
+  })
   public telemetryRetentionConfig?: TelemetryRetentionConfig = undefined;
 
   /*

package/Server/API/AIChatAPI.ts

@@ -32,7 +32,6 @@ import {
   AIChatToolActionStatus,
 } from "../../Types/AI/AIChatTypes";
 import { JSONArray, JSONObject } from "../../Types/JSON";
-import AIRunEventType from "../../Types/AI/AIRunEventType";
 import AIRunStatus from "../../Types/AI/AIRunStatus";
 import AIRunType from "../../Types/AI/AIRunType";
 import AIConversation from "../../Models/DatabaseModels/AIConversation";
@@ -40,11 +39,9 @@ import AIConversationMessage, {
   AIConversationMessageFeedback,
 } from "../../Models/DatabaseModels/AIConversationMessage";
 import AIRun from "../../Models/DatabaseModels/AIRun";
-import AIRunEvent from "../../Models/DatabaseModels/AIRunEvent";
 import Project from "../../Models/DatabaseModels/Project";
 import AIConversationService from "../Services/AIConversationService";
 import AIConversationMessageService from "../Services/AIConversationMessageService";
-import AIRunEventService from "../Services/AIRunEventService";
 import AIRunService from "../Services/AIRunService";
 import ProjectService from "../Services/ProjectService";
 import { AI_DISABLED_MESSAGE } from "../Services/AIService";
@@ -54,21 +51,14 @@ import ChatAgentRunner, {
   ResumeToolDecision,
 } from "../Utils/AI/Chat/ChatAgentRunner";
 import QueryHelper from "../Types/Database/QueryHelper";
+import ChatRunCancellation, {
+  ChatRunCancellationResult,
+} from "../Utils/AI/Chat/ChatRunCancellation";
 import logger from "../Utils/Logger";
 
 const MAX_USER_MESSAGE_LENGTH: number = 8000;
 const MAX_CONCURRENT_RUNS_PER_PROJECT: number = 3;
 
-// Final message content and run error for a turn the user stopped.
-const STOPPED_BY_USER_TEXT: string = "Stopped by user.";
-
-/*
- * Cancel's terminal event must sort after every progress event the runner
- * emitted — same convention as the runner's own failure finalizer, which
- * starts its event sequence at 100000.
- */
-const CANCEL_EVENT_SEQUENCE: number = 100000;
-
 const router: ExpressRouter = Express.getRouter();
 
 /*
@@ -806,115 +796,24 @@ router.post(
         throw new BadDataException("Conversation not found.");
       }
 
-      /*
-       * The conversation's live run: actively generating (Running) or paused
-       * for the user's approval (WaitingForApproval). The per-conversation
-       * governor allows at most one, so no sort is needed.
-       */
-      const activeRun: AIRun | null = await AIRunService.findOneBy({
-        query: {
-          conversationId: conversationId,
-          projectId: projectId,
-          status: QueryHelper.any([
-            AIRunStatus.Running,
-            AIRunStatus.WaitingForApproval,
-          ]),
-        },
-        select: { _id: true },
-        props: { isRoot: true },
-      });
+      // The shared, status-guarded stop (see ChatRunCancellation).
+      const cancellation: ChatRunCancellationResult | null =
+        await ChatRunCancellation.cancelActiveRun({
+          projectId,
+          conversationId,
+          userId,
+        });
 
-      if (!activeRun) {
+      if (!cancellation) {
         throw new BadDataException(
           "No response is being generated in this conversation.",
         );
       }
 
-      /*
-       * Status-guarded finalization, the same shape as the runner's own
-       * finalizer: only a still-in-flight run is flipped, so a run the runner
-       * completed (or errored) inside the race window is never overwritten.
-       * updateOneBy returns the matched-row count — zero from both guards
-       * means the other side won and already wrote the final state.
-       */
-      let cancelledRunCount: number = 0;
-
-      for (const inFlightRunStatus of [
-        AIRunStatus.Running,
-        AIRunStatus.WaitingForApproval,
-      ]) {
-        cancelledRunCount += await AIRunService.updateOneBy({
-          query: {
-            _id: activeRun.id!.toString(),
-            status: inFlightRunStatus,
-          },
-          data: {
-            status: AIRunStatus.Cancelled,
-            completedAt: OneUptimeDate.getCurrentDate(),
-            errorMessage: STOPPED_BY_USER_TEXT,
-            // A cancelled turn must never be resumable.
-            pausedState: null,
-          } as never,
-          props: { isRoot: true },
-        });
-      }
-
-      /*
-       * Finalize the run's in-flight assistant message the same guarded way:
-       * a message another path already finalized — completed with its full
-       * answer, or errored — keeps what it has.
-       */
-      for (const inFlightMessageStatus of [
-        AIChatMessageStatus.InProgress,
-        AIChatMessageStatus.WaitingForApproval,
-      ]) {
-        await AIConversationMessageService.updateOneBy({
-          query: {
-            aiRunId: activeRun.id!,
-            status: inFlightMessageStatus,
-          },
-          data: {
-            status: AIChatMessageStatus.Cancelled,
-            contentInMarkdown: STOPPED_BY_USER_TEXT,
-          } as never,
-          props: { isRoot: true },
-        });
-      }
-
-      /*
-       * Terminal event, only when this request actually took the run —
-       * emitting closure over a turn the runner finished would tell the UI a
-       * completed answer failed. RunFailed is the event enum's terminal
-       * "did not finish" member; the summary carries the human reason.
-       */
-      if (cancelledRunCount > 0) {
-        try {
-          const cancelEvent: AIRunEvent = new AIRunEvent();
-          cancelEvent.projectId = projectId;
-          cancelEvent.aiRunId = activeRun.id!;
-          cancelEvent.userId = userId;
-          cancelEvent.sequence = CANCEL_EVENT_SEQUENCE;
-          cancelEvent.eventType = AIRunEventType.RunFailed;
-          cancelEvent.resultSummary = { errorMessage: STOPPED_BY_USER_TEXT };
-
-          await AIRunEventService.create({
-            data: cancelEvent,
-            props: { isRoot: true },
-          });
-        } catch (error) {
-          // Events are progress telemetry — never fail the cancel over them.
-          logger.error(
-            `Failed to emit AI chat cancel event: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-          );
-        }
-      }
-
       Response.sendJsonObjectResponse(req, res, {
         conversationId: conversationId.toString(),
-        aiRunId: activeRun.id!.toString(),
-        cancelled: cancelledRunCount > 0,
+        aiRunId: cancellation.aiRunId.toString(),
+        cancelled: cancellation.cancelled,
       });
       return;
     } catch (err) {

package/Server/API/AIInvestigationAPI.ts

@@ -194,7 +194,7 @@ export function isAnalysisPendingForRun(data: {
  * incident/alert under THEIR permissions, then read the run + events as root.
  */
 
-async function getLoggedInProps(
+export async function getLoggedInProps(
   req: ExpressRequest,
 ): Promise<DatabaseCommonInteractionProps> {
   const props: DatabaseCommonInteractionProps =
@@ -215,7 +215,7 @@ async function getLoggedInProps(
  * and the subject is then asserted to belong to it, so "whose grants were
  * checked" and "which project was queried" can never diverge.
  */
-function pinPropsToTenant(
+export function pinPropsToTenant(
   props: DatabaseCommonInteractionProps,
 ): DatabaseCommonInteractionProps {
   return { ...props, isMultiTenantRequest: false };
@@ -225,7 +225,7 @@ function pinPropsToTenant(
  * Access check under the VIEWER's tenant-pinned permissions: throws unless
  * they can read the incident/alert AND it belongs to the tenant.
  */
-async function assertSubjectReadableInTenant(data: {
+export async function assertSubjectReadableInTenant(data: {
   subjectType: InvestigationReferenceKind;
   subjectId: ObjectID;
   tenantId: ObjectID;

package/Server/API/AIInvestigationConversationAPI.ts

@@ -0,0 +1,266 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import CommonAPI from "./CommonAPI";
+import Express, {
+  ExpressRequest,
+  ExpressResponse,
+  ExpressRouter,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONArray, JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import {
+  assertSubjectReadableInTenant,
+  getLoggedInProps,
+  pinPropsToTenant,
+} from "./AIInvestigationAPI";
+import InvestigationThreadService, {
+  InvestigationThreadSendResult,
+} from "../Utils/AI/SRE/InvestigationThreadService";
+import {
+  InvestigationThreadSubject,
+  InvestigationThreadSubjectType,
+} from "../Utils/AI/SRE/InvestigationThread";
+import { ChatRunCancellationResult } from "../Utils/AI/Chat/ChatRunCancellation";
+
+/*
+ * The conversation inside an incident's / alert's AI investigation box.
+ *
+ * Every route starts the same way: a logged-in member of the authenticated
+ * tenant, props pinned to that tenant, and the incident or alert readable
+ * under the VIEWER's own permissions inside it (the same gate as the
+ * investigation panel itself). Only then does InvestigationThreadService
+ * touch the shared thread. Anyone who can see the incident can read the
+ * thread, ask in it, decide on an action it paused on, or stop an answer;
+ * the tools the AI runs for them still run under their own permissions.
+ */
+
+const router: ExpressRouter = Express.getRouter();
+
+export interface InvestigationConversationRequestContext {
+  tenantId: ObjectID;
+  userId: ObjectID;
+  props: DatabaseCommonInteractionProps;
+  subject: InvestigationThreadSubject;
+}
+
+export function parseInvestigationThreadSubject(
+  body: JSONObject,
+): InvestigationThreadSubject {
+  const subjectType: unknown = body["subjectType"];
+
+  if (subjectType !== "incident" && subjectType !== "alert") {
+    throw new BadDataException('subjectType must be "incident" or "alert".');
+  }
+
+  const subjectIdRaw: unknown = body["subjectId"];
+
+  if (typeof subjectIdRaw !== "string" || !subjectIdRaw.trim()) {
+    throw new BadDataException("subjectId is required.");
+  }
+
+  ObjectID.validateUUID(subjectIdRaw.trim());
+
+  return {
+    type: subjectType as InvestigationThreadSubjectType,
+    id: new ObjectID(subjectIdRaw.trim()),
+  };
+}
+
+/*
+ * Who is asking, in which tenant, about which subject — with the read check
+ * on that subject already passed. Membership is asserted too: a thread is
+ * a project member's tool, never reachable with a bare session.
+ */
+export async function resolveInvestigationConversationRequest(
+  req: ExpressRequest,
+): Promise<InvestigationConversationRequestContext> {
+  const props: DatabaseCommonInteractionProps = await getLoggedInProps(req);
+
+  const tenantId: ObjectID = CommonAPI.assertTenantScoped(props);
+  CommonAPI.assertAuthenticatedProjectMember(props);
+
+  const viewerProps: DatabaseCommonInteractionProps = pinPropsToTenant(props);
+  const subject: InvestigationThreadSubject = parseInvestigationThreadSubject(
+    (req.body || {}) as JSONObject,
+  );
+
+  await assertSubjectReadableInTenant({
+    subjectType: subject.type,
+    subjectId: subject.id,
+    tenantId,
+    viewerProps,
+  });
+
+  return {
+    tenantId,
+    userId: props.userId!,
+    props: viewerProps,
+    subject,
+  };
+}
+
+// The thread as the box renders it (see InvestigationThreadService.getView).
+router.post(
+  "/ai-investigation/conversation",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const context: InvestigationConversationRequestContext =
+        await resolveInvestigationConversationRequest(req);
+
+      const view: JSONObject = await InvestigationThreadService.getView({
+        projectId: context.tenantId,
+        subject: context.subject,
+        viewerUserId: context.userId,
+      });
+
+      Response.sendJsonObjectResponse(req, res, {
+        ...view,
+        viewerUserId: context.userId.toString(),
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
+// Ask a question — or ask OneUptime AI to do something.
+router.post(
+  "/ai-investigation/conversation/send-message",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const context: InvestigationConversationRequestContext =
+        await resolveInvestigationConversationRequest(req);
+
+      const content: unknown = req.body["content"];
+
+      if (typeof content !== "string") {
+        throw new BadDataException("content is required.");
+      }
+
+      const permissionMode: unknown = req.body["permissionMode"];
+
+      const result: InvestigationThreadSendResult =
+        await InvestigationThreadService.sendMessage({
+          projectId: context.tenantId,
+          subject: context.subject,
+          userId: context.userId,
+          props: context.props,
+          content,
+          permissionMode:
+            typeof permissionMode === "string" ? permissionMode : undefined,
+        });
+
+      Response.sendJsonObjectResponse(req, res, {
+        conversationId: result.conversationId.toString(),
+        userMessageId: result.userMessageId.toString(),
+        assistantMessageId: result.assistantMessageId.toString(),
+        aiRunId: result.aiRunId.toString(),
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
+// Approve or deny the action(s) an answer paused on.
+router.post(
+  "/ai-investigation/conversation/respond-to-approval",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const context: InvestigationConversationRequestContext =
+        await resolveInvestigationConversationRequest(req);
+
+      const assistantMessageIdRaw: unknown = req.body["assistantMessageId"];
+
+      if (
+        typeof assistantMessageIdRaw !== "string" ||
+        !assistantMessageIdRaw.trim()
+      ) {
+        throw new BadDataException("assistantMessageId is required.");
+      }
+
+      ObjectID.validateUUID(assistantMessageIdRaw.trim());
+
+      const result: { aiRunId: ObjectID } =
+        await InvestigationThreadService.respondToApproval({
+          projectId: context.tenantId,
+          subject: context.subject,
+          userId: context.userId,
+          props: context.props,
+          assistantMessageId: new ObjectID(assistantMessageIdRaw.trim()),
+          decisions: Array.isArray(req.body["decisions"])
+            ? (req.body["decisions"] as JSONArray)
+            : undefined,
+          approved:
+            typeof req.body["approved"] === "boolean"
+              ? (req.body["approved"] as boolean)
+              : undefined,
+        });
+
+      Response.sendJsonObjectResponse(req, res, {
+        assistantMessageId: assistantMessageIdRaw.trim(),
+        aiRunId: result.aiRunId.toString(),
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
+// Stop the answer in flight.
+router.post(
+  "/ai-investigation/conversation/cancel-run",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const context: InvestigationConversationRequestContext =
+        await resolveInvestigationConversationRequest(req);
+
+      const result: ChatRunCancellationResult =
+        await InvestigationThreadService.cancelRun({
+          projectId: context.tenantId,
+          subject: context.subject,
+          userId: context.userId,
+        });
+
+      Response.sendJsonObjectResponse(req, res, {
+        aiRunId: result.aiRunId.toString(),
+        cancelled: result.cancelled,
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
+export default router;