@oneuptime/common 9.2.12 → 9.2.14

package/Models/DatabaseModels/ScheduledMaintenanceInternalNote.ts

@@ -424,4 +424,33 @@ export default class ScheduledMaintenanceInternalNote extends BaseModel {
     default: false,
   })
   public isOwnerNotified?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateScheduledMaintenanceInternalNote,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadScheduledMaintenanceInternalNote,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.LongText,
+    title: "Posted from Slack Message ID",
+    description:
+      "Unique identifier for the Slack message this note was created from (channel_id:message_ts). Used to prevent duplicate notes when multiple users react to the same message.",
+    required: false,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+  })
+  public postedFromSlackMessageId?: string = undefined;
 }

package/Models/DatabaseModels/ScheduledMaintenancePublicNote.ts

@@ -556,4 +556,33 @@ export default class ScheduledMaintenancePublicNote extends BaseModel {
     unique: false,
   })
   public postedAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateScheduledMaintenancePublicNote,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadScheduledMaintenancePublicNote,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.LongText,
+    title: "Posted from Slack Message ID",
+    description:
+      "Unique identifier for the Slack message this note was created from (channel_id:message_ts). Used to prevent duplicate notes when multiple users react to the same message.",
+    required: false,
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+  })
+  public postedFromSlackMessageId?: string = undefined;
 }

package/Server/API/LlmProviderAPI.ts

@@ -0,0 +1,57 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import LlmProviderService, {
+  Service as LlmProviderServiceType,
+} from "../Services/LlmProviderService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import PositiveNumber from "../../Types/PositiveNumber";
+import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
+
+export default class LlmProviderAPI extends BaseAPI<
+  LlmProvider,
+  LlmProviderServiceType
+> {
+  public constructor() {
+    super(LlmProvider, LlmProviderService);
+
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/global-llms`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const llmProviders: Array<LlmProvider> =
+            await LlmProviderService.findBy({
+              query: {
+                isGlobalLlm: true,
+              },
+              select: {
+                name: true,
+                description: true,
+              },
+              props: {
+                isRoot: true,
+              },
+              skip: 0,
+              limit: LIMIT_MAX,
+            });
+
+          return Response.sendEntityArrayResponse(
+            req,
+            res,
+            llmProviders,
+            new PositiveNumber(llmProviders.length),
+            LlmProvider,
+          );
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+}

package/Server/API/MicrosoftTeamsAPI.ts

@@ -473,152 +473,6 @@ export default class MicrosoftTeamsAPI {
       },
     );
 
-    // Endpoint to finalize team selection when multiple teams are available.
-    router.post(
-      "/microsoft-teams/select-team",
-      async (req: ExpressRequest, res: ExpressResponse) => {
-        try {
-          const projectIdString: string | undefined = req.body["projectId"];
-          const userIdString: string | undefined = req.body["userId"];
-          const teamId: string | undefined = req.body["teamId"];
-
-          if (!projectIdString || !userIdString || !teamId) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadRequestException(
-                "projectId, userId and teamId are required",
-              ),
-            );
-          }
-
-          const projectId: ObjectID = new ObjectID(projectIdString);
-          const userId: ObjectID = new ObjectID(userIdString);
-
-          // Fetch user auth to get access token and available teams.
-          const userAuth: WorkspaceUserAuthToken | null =
-            await WorkspaceUserAuthTokenService.getUserAuth({
-              projectId: projectId,
-              userId: userId,
-              workspaceType: WorkspaceType.MicrosoftTeams,
-            });
-
-          if (!userAuth) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadRequestException(
-                "User Microsoft Teams auth not found. Please re-authenticate.",
-              ),
-            );
-          }
-
-          const accessToken: string = userAuth.authToken || "";
-          const miscData: any = userAuth.miscData || {};
-          const availableTeams: Record<string, MicrosoftTeamsTeam> =
-            await MicrosoftTeamsUtil.refreshTeams({
-              projectId: projectId,
-            });
-          const matchedTeam: MicrosoftTeamsTeam | undefined = Object.values(
-            availableTeams,
-          ).find((t: MicrosoftTeamsTeam) => {
-            return t.id === teamId;
-          });
-
-          if (!matchedTeam) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadRequestException(
-                "Selected teamId is not in availableTeams list",
-              ),
-            );
-          }
-
-          // Decode JWT to get tenant ID
-          const tokenParts: Array<string> = accessToken.split(".");
-          if (tokenParts.length !== 3) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadRequestException("Invalid JWT token"),
-            );
-          }
-          const payload: JSONObject = JSON.parse(
-            Buffer.from(tokenParts[1]!, "base64").toString("utf-8"),
-          );
-          const tenantId: string = payload["tid"] as string;
-
-          if (!tenantId) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadRequestException("Tenant ID not found in token"),
-            );
-          }
-
-          /*
-           * Persist project auth now that team is selected.
-           * IMPORTANT: Do NOT overwrite project-level auth token (admin-consent app token)
-           * with the user delegated token. Preserve existing project auth token if present.
-           */
-          const existingProjectAuth: WorkspaceProjectAuthToken | null =
-            await WorkspaceProjectAuthTokenService.getProjectAuth({
-              projectId: projectId,
-              workspaceType: WorkspaceType.MicrosoftTeams,
-            });
-
-          const projectAuthTokenToPersist: string =
-            existingProjectAuth?.authToken || "";
-
-          // Merge miscData while updating team selection details
-          const mergedProjectMiscData: MicrosoftTeamsMiscData = {
-            ...(existingProjectAuth?.miscData as any),
-            tenantId: tenantId,
-            teamId: teamId,
-            teamName: matchedTeam.name,
-            botId: MicrosoftTeamsAppClientId || "",
-          };
-
-          await WorkspaceProjectAuthTokenService.refreshAuthToken({
-            projectId: projectId,
-            workspaceType: WorkspaceType.MicrosoftTeams,
-            authToken: projectAuthTokenToPersist,
-            workspaceProjectId: tenantId, // Use tenant ID as the workspace project identifier
-            miscData: mergedProjectMiscData,
-          });
-
-          // Update user token to remove availableTeams (cleanup) and store selected team info
-          await WorkspaceUserAuthTokenService.refreshAuthToken({
-            projectId: projectId,
-            userId: userId,
-            workspaceType: WorkspaceType.MicrosoftTeams,
-            authToken: accessToken,
-            workspaceUserId: miscData.userId || "",
-            miscData: {
-              userId: miscData.userId,
-              displayName: miscData.displayName,
-              email: miscData.email,
-              teamId: teamId,
-              teamName: matchedTeam.name,
-            },
-          });
-
-          return Response.sendJsonObjectResponse(req, res, {
-            success: true,
-          });
-        } catch (err) {
-          logger.error("Error selecting Microsoft Teams team: ");
-          logger.error(err);
-          return Response.sendErrorResponse(
-            req,
-            res,
-            new BadDataException("Failed to select Microsoft Teams team"),
-          );
-        }
-      },
-    );
-
     /*
      * Admin consent - start flow (tenant-wide admin consent)
      * Uses state in the same format as OAuth: <projectId>:<userId>
@@ -1118,6 +972,7 @@ export default class MicrosoftTeamsAPI {
           const availableTeams: Record<string, MicrosoftTeamsTeam> =
             await MicrosoftTeamsUtil.refreshTeams({
               projectId: projectId,
+              ...(databaseProps.userId && { userId: databaseProps.userId }),
             });
 
           return Response.sendJsonObjectResponse(req, res, {
@@ -1151,6 +1006,7 @@ export default class MicrosoftTeamsAPI {
           const availableTeams: Record<string, MicrosoftTeamsTeam> =
             await MicrosoftTeamsUtil.refreshTeams({
               projectId: projectId,
+              ...(databaseProps.userId && { userId: databaseProps.userId }),
             });
 
           return Response.sendJsonObjectResponse(req, res, {

package/Server/API/SlackAPI.ts

@@ -42,6 +42,10 @@ import UserMiddleware from "../Middleware/UserAuthorization";
 import CommonAPI from "./CommonAPI";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import {
+  PrivateNoteEmojis,
+  PublicNoteEmojis,
+} from "../Utils/Workspace/Slack/Actions/ActionTypes";
 
 export default class SlackAPI {
   public getRouter(): ExpressRouter {
@@ -731,6 +735,107 @@ export default class SlackAPI {
       },
     );
 
+    // Slack Events API endpoint for handling events like emoji reactions
+    router.post(
+      "/slack/events",
+      SlackAuthorization.isAuthorizedSlackRequest,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        logger.debug("Slack Events API Request received");
+        logger.debug(req.body);
+
+        const payload: JSONObject = req.body;
+
+        // Handle URL verification challenge from Slack
+        if (payload["type"] === "url_verification") {
+          logger.debug("Slack URL verification challenge received");
+          return Response.sendJsonObjectResponse(req, res, {
+            challenge: payload["challenge"],
+          });
+        }
+
+        // Handle event callbacks
+        if (payload["type"] === "event_callback") {
+          const event: JSONObject = payload["event"] as JSONObject;
+
+          if (!event) {
+            logger.debug("No event found in payload");
+            return Response.sendTextResponse(req, res, "ok");
+          }
+
+          // Handle reaction_added events
+          if (event["type"] === "reaction_added") {
+            logger.debug("Reaction added event received");
+
+            /*
+             * Respond immediately to Slack to prevent retry
+             * Process the event asynchronously
+             */
+            Response.sendTextResponse(req, res, "ok");
+
+            const reactionData: {
+              teamId: string;
+              reaction: string;
+              userId: string;
+              channelId: string;
+              messageTs: string;
+            } = {
+              teamId: payload["team_id"] as string,
+              reaction: event["reaction"] as string,
+              userId: event["user"] as string,
+              channelId: (event["item"] as JSONObject)?.["channel"] as string,
+              messageTs: (event["item"] as JSONObject)?.["ts"] as string,
+            };
+
+            // OPTIMIZATION: Quick check if this is a supported emoji before any DB queries
+            const isSupportedEmoji: boolean =
+              PrivateNoteEmojis.includes(reactionData.reaction) ||
+              PublicNoteEmojis.includes(reactionData.reaction);
+
+            if (!isSupportedEmoji) {
+              logger.debug(
+                `Emoji "${reactionData.reaction}" is not supported. Skipping.`,
+              );
+              return;
+            }
+
+            /*
+             * Process emoji reactions for Incidents, Alerts, and Scheduled Maintenance
+             * Each handler will silently ignore if the channel is not linked to their resource type
+             */
+            try {
+              await SlackIncidentActions.handleEmojiReaction(reactionData);
+            } catch (err) {
+              logger.error("Error handling incident emoji reaction:");
+              logger.error(err);
+            }
+
+            try {
+              await SlackAlertActions.handleEmojiReaction(reactionData);
+            } catch (err) {
+              logger.error("Error handling alert emoji reaction:");
+              logger.error(err);
+            }
+
+            try {
+              await SlackScheduledMaintenanceActions.handleEmojiReaction(
+                reactionData,
+              );
+            } catch (err) {
+              logger.error(
+                "Error handling scheduled maintenance emoji reaction:",
+              );
+              logger.error(err);
+            }
+
+            return;
+          }
+        }
+
+        // For any other event types, just acknowledge
+        return Response.sendTextResponse(req, res, "ok");
+      },
+    );
+
     // options load endpoint.
 
     router.post(

package/Server/API/StatusPageAPI.ts

@@ -2510,6 +2510,9 @@ export default class StatusPageAPI extends BaseAPI<
         },
         select: {
           statusPageGroupId: true,
+          statusPageGroup: {
+            name: true,
+          },
           monitorId: true,
           displayTooltip: true,
           displayDescription: true,
@@ -3631,6 +3634,9 @@ export default class StatusPageAPI extends BaseAPI<
         },
         select: {
           statusPageGroupId: true,
+          statusPageGroup: {
+            name: true,
+          },
           monitorId: true,
           displayTooltip: true,
           displayDescription: true,

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

@@ -0,0 +1,71 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1765477339178 implements MigrationInterface {
+  public name = "MigrationName1765477339178";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentInternalNote" ADD "postedFromSlackMessageId" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPublicNote" ADD "postedFromSlackMessageId" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceInternalNote" ADD "postedFromSlackMessageId" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenancePublicNote" ADD "postedFromSlackMessageId" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertInternalNote" ADD "postedFromSlackMessageId" character varying`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_6007d639fd6dededbc77393761" ON "IncidentInternalNote" ("postedFromSlackMessageId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_7ffc0c79197aca5dd604c9b556" ON "IncidentPublicNote" ("postedFromSlackMessageId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_6dff06e544ac3b99e5ec720508" ON "ScheduledMaintenanceInternalNote" ("postedFromSlackMessageId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_2131c4ba2b8d8e793dcc3add9e" ON "ScheduledMaintenancePublicNote" ("postedFromSlackMessageId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_dd2d9bc2dbd669143263ae58c4" ON "AlertInternalNote" ("postedFromSlackMessageId") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_dd2d9bc2dbd669143263ae58c4"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_2131c4ba2b8d8e793dcc3add9e"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_6dff06e544ac3b99e5ec720508"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_7ffc0c79197aca5dd604c9b556"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_6007d639fd6dededbc77393761"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertInternalNote" DROP COLUMN "postedFromSlackMessageId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenancePublicNote" DROP COLUMN "postedFromSlackMessageId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenanceInternalNote" DROP COLUMN "postedFromSlackMessageId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentPublicNote" DROP COLUMN "postedFromSlackMessageId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentInternalNote" DROP COLUMN "postedFromSlackMessageId"`,
+    );
+  }
+}

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

@@ -0,0 +1,45 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1765540325149 implements MigrationInterface {
+  public name = "MigrationName1765540325149";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "LlmProvider" ("_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, "name" character varying(50) NOT NULL, "description" character varying, "slug" character varying(100) NOT NULL, "llmType" character varying(100) NOT NULL, "apiKey" character varying, "modelName" character varying(100), "baseUrl" character varying(100), "projectId" uuid, "deletedByUserId" uuid, "createdByUserId" uuid, "isGlobalLlm" boolean NOT NULL DEFAULT false, "isEnabled" boolean NOT NULL DEFAULT true, CONSTRAINT "PK_c057270b82040d0c3f3eb7904d6" 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":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" ADD CONSTRAINT "FK_745a31adc0966cf0444cc321541" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" ADD CONSTRAINT "FK_082f150ef63369af3cd022d3720" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" ADD CONSTRAINT "FK_6d1f986fccda177f98ec3549629" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" DROP CONSTRAINT "FK_6d1f986fccda177f98ec3549629"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" DROP CONSTRAINT "FK_082f150ef63369af3cd022d3720"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" DROP CONSTRAINT "FK_745a31adc0966cf0444cc321541"`,
+    );
+    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 "LlmProvider"`);
+  }
+}

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

@@ -0,0 +1,61 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1765540549739 implements MigrationInterface {
+  public name = "MigrationName1765540549739";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Delete all Copilot and CodeRepository related tables
+     * Drop tables in correct order respecting foreign key constraints
+     */
+
+    // First drop CopilotActionTypePriority (depends on CopilotCodeRepository)
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "CopilotActionTypePriority" CASCADE`,
+    );
+
+    // Drop CopilotPullRequest (depends on CopilotCodeRepository, ServiceCopilotCodeRepository)
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "CopilotPullRequest" CASCADE`,
+    );
+
+    // Drop CopilotAction (depends on CodeRepository, ServiceRepository)
+    await queryRunner.query(`DROP TABLE IF EXISTS "CopilotAction" CASCADE`);
+
+    // Drop ServiceCopilotCodeRepository (depends on CopilotCodeRepository)
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "ServiceCopilotCodeRepository" CASCADE`,
+    );
+
+    // Drop CopilotCodeRepositoryLabel (junction table)
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "CopilotCodeRepositoryLabel" CASCADE`,
+    );
+
+    // Drop CopilotCodeRepository
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "CopilotCodeRepository" CASCADE`,
+    );
+
+    // Drop ServiceRepository (depends on CodeRepository)
+    await queryRunner.query(`DROP TABLE IF EXISTS "ServiceRepository" CASCADE`);
+
+    // Drop CodeRepositoryLabel (junction table)
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "CodeRepositoryLabel" CASCADE`,
+    );
+
+    // Drop CodeRepository
+    await queryRunner.query(`DROP TABLE IF EXISTS "CodeRepository" CASCADE`);
+  }
+
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Note: The down migration does not recreate the Copilot and CodeRepository tables
+     * as they are being permanently removed from the system.
+     * If you need to restore these tables, you would need to run the original migrations
+     * that created them (1717955235341, 1718037833516, 1718124277321, 1718879960254,
+     * 1720532068612, 1720785305192, 1725291476867).
+     */
+  }
+}

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

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1765544010078 implements MigrationInterface {
+  public name = "MigrationName1765544010078";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" RENAME COLUMN "isEnabled" TO "isDefault"`,
+    );
+    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(
+      `ALTER TABLE "LlmProvider" ALTER COLUMN "isDefault" SET DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "LlmProvider" ALTER COLUMN "isDefault" SET DEFAULT true`,
+    );
+    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 "LlmProvider" RENAME COLUMN "isDefault" TO "isEnabled"`,
+    );
+  }
+}

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

@@ -192,6 +192,10 @@ import { MigrationName1764767371788 } from "./1764767371788-MigrationName";
 import { MigrationName1764789433216 } from "./1764789433216-MigrationName";
 import { MigrationName1764850876394 } from "./1764850876394-MigrationName";
 import { MigrationName1765195603978 } from "./1765195603978-MigrationName";
+import { MigrationName1765477339178 } from "./1765477339178-MigrationName";
+import { MigrationName1765540325149 } from "./1765540325149-MigrationName";
+import { MigrationName1765540549739 } from "./1765540549739-MigrationName";
+import { MigrationName1765544010078 } from "./1765544010078-MigrationName";
 
 export default [
   InitialMigration,
@@ -388,4 +392,8 @@ export default [
   MigrationName1764789433216,
   MigrationName1764850876394,
   MigrationName1765195603978,
+  MigrationName1765477339178,
+  MigrationName1765540325149,
+  MigrationName1765540549739,
+  MigrationName1765544010078
 ];