@oneuptime/common 7.0.3010 → 7.0.3022

package/Models/DatabaseModels/CopilotActionTypePriority.ts

@@ -0,0 +1,340 @@
+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: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.CreateCopilotAction,
+  ],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadCopilotAction,
+  ],
+  delete: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.DeleteCopilotAction,
+  ],
+  update: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.EditCopilotAction,
+  ],
+})
+@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/CopilotPullRequest.ts

@@ -411,6 +411,7 @@ export default class CopilotPullRequest extends BaseModel {
     type: TableColumnType.ShortText,
     required: false,
     isDefaultValueColumn: false,
+    canReadOnRelationQuery: true,
     title: "Pull Request ID",
     description:
       "ID of Pull Request in the repository where this event was executed and then PR was created.",

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,13 @@ 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";
+import JSONFunctions from "../../Types/JSONFunctions";
+import CopilotActionType from "../../Types/Copilot/CopilotActionType";
+import { JSONObject } from "../../Types/JSON";
 
 export default class CopilotActionAPI extends BaseAPI<
   CopilotAction,
@@ -26,7 +33,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 +43,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 (!filePath) {
-            throw new BadDataException("File path is required");
+          if (!codeRepository) {
+            throw new BadDataException(
+              "Code repository not found. Secret key is invalid.",
+            );
+          }
+
+          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 +136,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,
@@ -107,10 +171,96 @@ export default class CopilotActionAPI extends BaseAPI<
       },
     );
 
+    this.router.get(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/get-copilot-action/: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"]!;
+
+          if (!serviceCatalogId) {
+            throw new BadDataException("Service catalog id is required");
+          }
+
+          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.",
+            );
+          }
+
+          const actionType: CopilotActionType = req.body["actionType"]!;
+
+          if (!actionType) {
+            throw new BadDataException("Action type is required");
+          }
+
+          const actionProps: JSONObject = req.body["actionProps"]!;
+
+          const copilotAction: CopilotAction | null =
+            await CopilotActionService.findOneBy({
+              query: {
+                codeRepositoryId: codeRepository.id!,
+                serviceCatalogId: new ObjectID(serviceCatalogId),
+                copilotActionType: actionType,
+                copilotActionProp: actionProps as any,
+              },
+              select: {
+                _id: true,
+                codeRepositoryId: true,
+                serviceCatalogId: true,
+                copilotActionStatus: true,
+                copilotActionType: true,
+                createdAt: true,
+                copilotPullRequest: {
+                  _id: true,
+                  pullRequestId: true,
+                  copilotPullRequestStatus: true,
+                },
+              },
+              sort: {
+                createdAt: SortOrder.Descending,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            copilotAction: copilotAction
+              ? CopilotAction.toJSONObject(copilotAction, CopilotAction)
+              : null,
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
-        ?.toString()}/add-copilot-action/:secretkey`,
+        ?.toString()}/create-copilot-action/:secretkey`,
       CodeRepositoryAuthorization.isAuthorizedRepository,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -147,6 +297,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({
@@ -167,5 +318,98 @@ export default class CopilotActionAPI extends BaseAPI<
         }
       },
     );
+
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/update-copilot-action/: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 codeRepository: CopilotCodeRepository | null =
+            await CopilotCodeRepositoryService.findOneBy({
+              query: {
+                secretToken: new ObjectID(secretkey),
+              },
+              select: {
+                _id: true,
+                projectId: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!codeRepository) {
+            throw new BadDataException(
+              "Code repository not found. Secret key is invalid.",
+            );
+          }
+
+          req.body = JSONFunctions.deserialize(req.body);
+
+          const {
+            actionStatus,
+            pullRequestId,
+            commitHash,
+            statusMessage,
+            logs,
+            actionId,
+          }: {
+            actionStatus: CopilotActionStatus;
+            pullRequestId?: ObjectID | undefined;
+            commitHash?: string | undefined;
+            statusMessage?: string | undefined;
+            logs?: Array<string> | undefined;
+            actionId: ObjectID;
+          } = req.body;
+
+          const exisingAction: CopilotAction | null =
+            await CopilotActionService.findOneBy({
+              query: {
+                _id: actionId,
+                codeRepositoryId: codeRepository.id!,
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!exisingAction) {
+            throw new BadDataException("Action not found");
+          }
+
+          await CopilotActionService.updateOneBy({
+            query: {
+              _id: actionId,
+              codeRepositoryId: codeRepository.id!,
+            },
+            data: {
+              copilotActionStatus: actionStatus!,
+              copilotPullRequestId: pullRequestId!,
+              commitHash: commitHash!,
+              statusMessage: statusMessage!,
+              logs: logs?.join("\n") || "",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
   }
 }

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/API/StatusPageAPI.ts

@@ -36,7 +36,7 @@ import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
 import CommonAPI from "./CommonAPI";
 import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
-import ArrayUtil from "Common/Types/ArrayUtil";
+import ArrayUtil from "Common/Utils/Array";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
 import SortOrder from "Common/Types/BaseDatabase/SortOrder";
 import { LIMIT_PER_PROJECT } from "Common/Types/Database/LimitMax";

package/Server/API/TelemetryAPI.ts

@@ -11,7 +11,7 @@ import CommonAPI from "./CommonAPI";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
 import TelemetryType from "Common/Types/Telemetry/TelemetryType";
 import TelemetryAttributeService from "../Services/TelemetryAttributeService";
-import ArrayUtil from "Common/Types/ArrayUtil";
+import ArrayUtil from "Common/Utils/Array";
 
 const router: ExpressRouter = Express.getRouter();