@oneuptime/common 7.0.3010 → 7.0.3018

package/Models/DatabaseModels/CopilotActionTypePriority.ts

@@ -0,0 +1,325 @@
+import CodeRepository from "./CopilotCodeRepository";
+import Project from "./Project";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import CopilotActionType from "../../Types/Copilot/CopilotActionType";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import CanAccessIfCanReadOn from "../../Types/Database/CanAccessIfCanReadOn";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import EnableWorkflow from "../../Types/Database/EnableWorkflow";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+import ColumnLength from "../../Types/Database/ColumnLength";
+
+@CanAccessIfCanReadOn("codeRepository")
+@EnableDocumentation()
+@TenantColumn("projectId")
+@TableAccessControl({
+  create: [],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadCopilotAction,
+  ],
+  delete: [],
+  update: [],
+})
+@EnableWorkflow({
+  create: true,
+  delete: false,
+  update: true,
+  read: false,
+})
+@CrudApiEndpoint(new Route("/copilot-action-type-prority"))
+@TableMetadata({
+  tableName: "CopilotActionType",
+  singularName: "Copilot Action Priority",
+  pluralName: "Copilot Action Priorities",
+  icon: IconProp.Bolt,
+  tableDescription: "Priority of Copilot Actions",
+})
+@Entity({
+  name: "CopilotActionTypePriority",
+})
+export default class CopilotActionTypePriority extends BaseModel {
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: false,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "codeRepositoryId",
+    type: TableColumnType.Entity,
+    modelType: CodeRepository,
+    title: "Code Repository",
+    description:
+      "Relation to CodeRepository Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return CodeRepository;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "codeRepositoryId" })
+  public codeRepository?: CodeRepository = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Code Repository ID",
+    description:
+      "ID of your OneUptime Code Repository in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public codeRepositoryId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    title: "Copilot Action Type",
+    required: true,
+    description: "Copilot Action Type for this Code Repository",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: false,
+  })
+  public actionType?: CopilotActionType = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadCopilotAction,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Number,
+    title: "Priority",
+    required: true,
+    description: "Priority of Copilot Action Type for this Code Repository",
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: false,
+    default: 1,
+  })
+  public priority?: number = undefined;
+}

package/Models/DatabaseModels/Index.ts

@@ -136,6 +136,7 @@ import UserTwoFactorAuth from "./UserTwoFactorAuth";
 import TelemetryIngestionKey from "./TelemetryIngestionKey";
 
 import TelemetryException from "./TelemetryException";
+import CopilotActionTypePriority from "./CopilotActionTypePriority";
 
 export default [
   User,
@@ -284,6 +285,7 @@ export default [
   CopilotAction,
   ServiceCopilotCodeRepository,
   CopilotPullRequest,
+  CopilotActionTypePriority,
 
   ProbeOwnerTeam,
   ProbeOwnerUser,

package/Server/API/CopilotActionAPI.ts

@@ -15,6 +15,10 @@ import ObjectID from "Common/Types/ObjectID";
 import CopilotAction from "Common/Models/DatabaseModels/CopilotAction";
 import CopilotCodeRepositoryService from "../Services/CopilotCodeRepositoryService";
 import CodeRepositoryAuthorization from "../Middleware/CodeRepositoryAuthorization";
+import CopilotActionStatus from "../../Types/Copilot/CopilotActionStatus";
+import CopilotActionTypePriority from "../../Models/DatabaseModels/CopilotActionTypePriority";
+import CopilotActionTypePriorityService from "../Services/CopilotActionTypePriorityService";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
 
 export default class CopilotActionAPI extends BaseAPI<
   CopilotAction,
@@ -26,7 +30,7 @@ export default class CopilotActionAPI extends BaseAPI<
     this.router.get(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/copilot-actions-by-file/:secretkey`,
+        ?.toString()}/copilot-action-types-by-priority/:secretkey`,
       CodeRepositoryAuthorization.isAuthorizedRepository,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -36,10 +40,68 @@ export default class CopilotActionAPI extends BaseAPI<
             throw new BadDataException("Secret key is required");
           }
 
-          const filePath: string = req.body["filePath"]!;
+          const codeRepository: CopilotCodeRepository | null =
+            await CopilotCodeRepositoryService.findOneBy({
+              query: {
+                secretToken: new ObjectID(secretkey),
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!codeRepository) {
+            throw new BadDataException(
+              "Code repository not found. Secret key is invalid.",
+            );
+          }
 
-          if (!filePath) {
-            throw new BadDataException("File path is required");
+          const copilotActionTypes: Array<CopilotActionTypePriority> =
+            await CopilotActionTypePriorityService.findBy({
+              query: {
+                codeRepositoryId: codeRepository.id!,
+              },
+              select: {
+                _id: true,
+                actionType: true,
+                priority: true,
+              },
+              skip: 0,
+              sort: {
+                priority: SortOrder.Ascending,
+              },
+              limit: LIMIT_PER_PROJECT,
+              props: {
+                isRoot: true,
+              },
+            });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            actionTypes: CopilotActionTypePriority.toJSONArray(
+              copilotActionTypes,
+              CopilotActionTypePriority,
+            ),
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/copilot-actions-in-queue/:secretkey`,
+      CodeRepositoryAuthorization.isAuthorizedRepository,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const secretkey: string = req.params["secretkey"]!;
+
+          if (!secretkey) {
+            throw new BadDataException("Secret key is required");
           }
 
           const serviceCatalogId: string = req.body["serviceCatalogId"]!;
@@ -71,14 +133,13 @@ export default class CopilotActionAPI extends BaseAPI<
             await CopilotActionService.findBy({
               query: {
                 codeRepositoryId: codeRepository.id!,
-                filePath: filePath,
                 serviceCatalogId: new ObjectID(serviceCatalogId),
+                copilotActionStatus: CopilotActionStatus.IN_QUEUE,
               },
               select: {
                 _id: true,
                 codeRepositoryId: true,
                 serviceCatalogId: true,
-                filePath: true,
                 copilotActionStatus: true,
                 copilotActionType: true,
                 createdAt: true,
@@ -110,7 +171,7 @@ export default class CopilotActionAPI extends BaseAPI<
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/add-copilot-action/:secretkey`,
+        ?.toString()}/queue-copilot-action/:secretkey`,
       CodeRepositoryAuthorization.isAuthorizedRepository,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -147,6 +208,7 @@ export default class CopilotActionAPI extends BaseAPI<
 
           copilotAction.codeRepositoryId = codeRepository.id!;
           copilotAction.projectId = codeRepository.projectId!;
+          copilotAction.copilotActionStatus = CopilotActionStatus.IN_QUEUE;
 
           const createdAction: CopilotAction =
             await CopilotActionService.create({

package/Server/API/StatusAPI.ts

@@ -76,8 +76,6 @@ export default class StatusAPI {
               logger.info("Ready check: ok");
               stausReadySuccess.add(1);
 
-              span.recordException(new ServerException("Server is ready"));
-
               Response.sendJsonObjectResponse(req, res, {
                 status: "ok",
               });

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

@@ -0,0 +1,51 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725291476867 implements MigrationInterface {
+  public name = "MigrationName1725291476867";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "CopilotActionTypePriority" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP, "version" integer NOT NULL, "projectId" uuid NOT NULL, "codeRepositoryId" uuid NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, "actionType" character varying(100) NOT NULL, "priority" integer NOT NULL DEFAULT '1', CONSTRAINT "PK_e87af58e75ac25610e48807703e" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d8e9d95bc4e4094b84d812950f" ON "CopilotActionTypePriority" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_a4c64c718646aebbfe469d6c95" ON "CopilotActionTypePriority" ("codeRepositoryId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" ADD CONSTRAINT "FK_d8e9d95bc4e4094b84d812950f2" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" ADD CONSTRAINT "FK_a4c64c718646aebbfe469d6c950" FOREIGN KEY ("codeRepositoryId") REFERENCES "CopilotCodeRepository"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" ADD CONSTRAINT "FK_039fd3af73a2c910eee5ed67669" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" ADD CONSTRAINT "FK_01864ec4b8b5f343e484a09128a" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" DROP CONSTRAINT "FK_01864ec4b8b5f343e484a09128a"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" DROP CONSTRAINT "FK_039fd3af73a2c910eee5ed67669"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" DROP CONSTRAINT "FK_a4c64c718646aebbfe469d6c950"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotActionTypePriority" DROP CONSTRAINT "FK_d8e9d95bc4e4094b84d812950f2"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_a4c64c718646aebbfe469d6c95"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d8e9d95bc4e4094b84d812950f"`,
+    );
+    await queryRunner.query(`DROP TABLE "CopilotActionTypePriority"`);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725357719072 implements MigrationInterface {
+  public name = "MigrationName1725357719072";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "CopilotAction" ADD "copilotActionProp" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotAction" ADD "statusMessage" text`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "CopilotAction" DROP COLUMN "statusMessage"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "CopilotAction" DROP COLUMN "copilotActionProp"`,
+    );
+  }
+}

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

@@ -0,0 +1,13 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725360199561 implements MigrationInterface {
+  public name = "MigrationName1725360199561";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "CopilotAction" ADD "logs" text`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "CopilotAction" DROP COLUMN "logs"`);
+  }
+}

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

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1725379949648 implements MigrationInterface {
+  public name = "MigrationName1725379949648";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "CopilotAction" ADD "isPriority" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "CopilotAction" DROP COLUMN "isPriority"`,
+    );
+  }
+}

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

@@ -44,6 +44,10 @@ import { MigrationName1724078044172 } from "./1724078044172-MigrationName";
 import { MigrationName1724610006927 } from "./1724610006927-MigrationName";
 import { MigrationName1724613666632 } from "./1724613666632-MigrationName";
 import { MigrationName1724659071843 } from "./1724659071843-MigrationName";
+import { MigrationName1725291476867 } from "./1725291476867-MigrationName";
+import { MigrationName1725357719072 } from "./1725357719072-MigrationName";
+import { MigrationName1725360199561 } from "./1725360199561-MigrationName";
+import { MigrationName1725379949648 } from "./1725379949648-MigrationName";
 
 export default [
   InitialMigration,
@@ -92,4 +96,8 @@ export default [
   MigrationName1724610006927,
   MigrationName1724613666632,
   MigrationName1724659071843,
+  MigrationName1725291476867,
+  MigrationName1725357719072,
+  MigrationName1725360199561,
+  MigrationName1725379949648,
 ];

package/Server/Services/CopilotActionTypePriorityService.ts

@@ -0,0 +1,66 @@
+import CopilotActionType from "../../Types/Copilot/CopilotActionType";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/CopilotActionTypePriority";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    // check if the action exits witht he same name exists in the same repo.
+
+    const actionType: CopilotActionType | undefined = createBy.data.actionType;
+    const codeRepositoryId: ObjectID | undefined =
+      createBy.data.codeRepositoryId;
+
+    if (!actionType) {
+      throw new BadDataException("ActionType is required");
+    }
+
+    if (!codeRepositoryId) {
+      throw new BadDataException("CodeRepositoryId is required");
+    }
+
+    const existingItem: Model | null = await this.findOneBy({
+      query: {
+        actionType,
+        codeRepositoryId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingItem) {
+      throw new BadDataException(
+        "Action Type already exists for this repository.",
+      );
+    }
+
+    // check if the priority is in between 1 and 5.
+
+    const priority: number | undefined = createBy.data.priority;
+
+    if (!priority) {
+      throw new BadDataException("Priority is required");
+    }
+
+    if (priority < 1 || priority > 5) {
+      throw new BadDataException("Priority must be between 1 and 5");
+    }
+
+    return {
+      createBy: createBy,
+      carryForward: null,
+    };
+  }
+}
+
+export default new Service();

package/Server/Services/Index.ts

@@ -132,6 +132,7 @@ import ServiceCatalogDependencyService from "./ServiceCatalogDependencyService";
 import TelemetryAttributeService from "./TelemetryAttributeService";
 import TelemetryExceptionService from "./TelemetryExceptionService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
+import CopilotActionTypePriorityService from "./CopilotActionTypePriorityService";
 
 const services: Array<BaseService> = [
   AcmeCertificateService,
@@ -273,6 +274,7 @@ const services: Array<BaseService> = [
   CopilotActionService,
   ServiceCopilotCodeRepositoryService,
   CopilotPullRequestService,
+  CopilotActionTypePriorityService,
 
   TelemetryExceptionService,
 ];