@oneuptime/common 7.0.2994 → 7.0.3018

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/DatabaseService.ts

@@ -59,7 +59,6 @@ import Typeof from "../../Types/Typeof";
 import API from "Common/Utils/API";
 import Slug from "Common/Utils/Slug";
 import { DataSource, Repository, SelectQueryBuilder } from "typeorm";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 import { FindWhere } from "../../Types/BaseDatabase/Query";
 
 class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
@@ -427,10 +426,10 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
   }
 
   private async sanitizeCreateOrUpdate(
-    data: TBaseModel | QueryDeepPartialEntity<TBaseModel>,
+    data: TBaseModel | PartialEntity<TBaseModel>,
     props: DatabaseCommonInteractionProps,
     isUpdate: boolean = false,
-  ): Promise<TBaseModel | QueryDeepPartialEntity<TBaseModel>> {
+  ): Promise<TBaseModel | PartialEntity<TBaseModel>> {
     data = this.checkMaxLengthOfFields(data as TBaseModel);
 
     const columns: Columns = this.model.getTableColumns();
@@ -1274,12 +1273,12 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
         beforeUpdateBy.props,
       );
 
-      const data: QueryDeepPartialEntity<TBaseModel> =
+      const data: PartialEntity<TBaseModel> =
         (await this.sanitizeCreateOrUpdate(
           beforeUpdateBy.data,
           updateBy.props,
           true,
-        )) as QueryDeepPartialEntity<TBaseModel>;
+        )) as PartialEntity<TBaseModel>;
 
       if (!(updateBy.skip instanceof PositiveNumber)) {
         updateBy.skip = new PositiveNumber(updateBy.skip);

package/Server/Services/ExceptionInstanceService.ts

@@ -0,0 +1,11 @@
+import ClickhouseDatabase from "../Infrastructure/ClickhouseDatabase";
+import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
+import ExceptionInstance from "Common/Models/AnalyticsModels/ExceptionInstance";
+
+export class ExceptionInstanceService extends AnalyticsDatabaseService<ExceptionInstance> {
+  public constructor(clickhouseDatabase?: ClickhouseDatabase | undefined) {
+    super({ modelType: ExceptionInstance, database: clickhouseDatabase });
+  }
+}
+
+export default new ExceptionInstanceService();

package/Server/Services/Index.ts

@@ -130,6 +130,9 @@ import AnalyticsBaseModel from "Common/Models/AnalyticsModels/AnalyticsBaseModel
 import CopilotPullRequestService from "./CopilotPullRequestService";
 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,
@@ -271,6 +274,9 @@ const services: Array<BaseService> = [
   CopilotActionService,
   ServiceCopilotCodeRepositoryService,
   CopilotPullRequestService,
+  CopilotActionTypePriorityService,
+
+  TelemetryExceptionService,
 ];
 
 export const AnalyticsServices: Array<
@@ -281,6 +287,7 @@ export const AnalyticsServices: Array<
   MetricService,
   MonitorMetricsByMinuteService,
   TelemetryAttributeService,
+  ExceptionInstanceService,
 ];
 
 export default services;

package/Server/Services/StatusPageDomainService.ts

@@ -17,6 +17,7 @@ import AcmeCertificate from "Common/Models/DatabaseModels/AcmeCertificate";
 import Domain from "Common/Models/DatabaseModels/Domain";
 import StatusPageDomain from "Common/Models/DatabaseModels/StatusPageDomain";
 import AcmeCertificateService from "./AcmeCertificateService";
+import Telemetry, { Span } from "../Utils/Telemetry";
 
 export class Service extends DatabaseService<StatusPageDomain> {
   public constructor() {
@@ -86,49 +87,79 @@ export class Service extends DatabaseService<StatusPageDomain> {
   }
 
   public async orderCert(statusPageDomain: StatusPageDomain): Promise<void> {
-    if (!statusPageDomain.fullDomain) {
-      const fetchedStatusPageDomain: StatusPageDomain | null =
-        await this.findOneBy({
-          query: {
-            _id: statusPageDomain.id!.toString(),
-          },
-          select: {
-            _id: true,
-            fullDomain: true,
-          },
-          props: {
-            isRoot: true,
-          },
-        });
-
-      if (!fetchedStatusPageDomain) {
-        throw new BadDataException("Domain not found");
-      }
+    return Telemetry.startActiveSpan<Promise<void>>({
+      name: "StatusPageDomainService.orderCert",
+      options: {
+        attributes: {
+          fullDomain: statusPageDomain.fullDomain,
+          _id: statusPageDomain.id?.toString(),
+        },
+      },
+      fn: async (span: Span): Promise<void> => {
+        try {
+          if (!statusPageDomain.fullDomain) {
+            const fetchedStatusPageDomain: StatusPageDomain | null =
+              await this.findOneBy({
+                query: {
+                  _id: statusPageDomain.id!.toString(),
+                },
+                select: {
+                  _id: true,
+                  fullDomain: true,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+
+            if (!fetchedStatusPageDomain) {
+              throw new BadDataException("Domain not found");
+            }
+
+            statusPageDomain = fetchedStatusPageDomain;
+          }
+
+          if (!statusPageDomain.fullDomain) {
+            throw new BadDataException(
+              "Unable to order certificate because domain is null",
+            );
+          }
+
+          logger.debug(
+            "Ordering SSL for domain: " + statusPageDomain.fullDomain,
+          );
 
-      statusPageDomain = fetchedStatusPageDomain;
-    }
+          await GreenlockUtil.orderCert({
+            domain: statusPageDomain.fullDomain as string,
+            validateCname: async (fullDomain: string) => {
+              return await this.isCnameValid(fullDomain);
+            },
+          });
 
-    if (!statusPageDomain.fullDomain) {
-      throw new BadDataException(
-        "Unable to order certificate because domain is null",
-      );
-    }
+          logger.debug(
+            "SSL ordered for domain: " + statusPageDomain.fullDomain,
+          );
 
-    await GreenlockUtil.orderCert({
-      domain: statusPageDomain.fullDomain as string,
-      validateCname: async (fullDomain: string) => {
-        return await this.isCnameValid(fullDomain);
-      },
-    });
+          // update the order.
+          await this.updateOneById({
+            id: statusPageDomain.id!,
+            data: {
+              isSslOrdered: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          Telemetry.endSpan(span);
+        } catch (err) {
+          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+            span,
+            exception: err,
+          });
 
-    // update the order.
-    await this.updateOneById({
-      id: statusPageDomain.id!,
-      data: {
-        isSslOrdered: true,
-      },
-      props: {
-        isRoot: true,
+          throw err;
+        }
       },
     });
   }
@@ -215,6 +246,8 @@ export class Service extends DatabaseService<StatusPageDomain> {
     try {
       // get the token from the domain.
 
+      logger.debug("Checking for CNAME " + fullDomain);
+
       const statusPageDomain: StatusPageDomain | null = await this.findOneBy({
         query: {
           fullDomain: fullDomain,
@@ -234,6 +267,8 @@ export class Service extends DatabaseService<StatusPageDomain> {
 
       const token: string = statusPageDomain.cnameVerificationToken!;
 
+      logger.debug("Checking for CNAME " + fullDomain + " with token " + token);
+
       const result: HTTPErrorResponse | HTTPResponse<JSONObject> =
         await API.get(
           URL.fromString(
@@ -244,6 +279,9 @@ export class Service extends DatabaseService<StatusPageDomain> {
           ),
         );
 
+      logger.debug("CNAME verification result");
+      logger.debug(result);
+
       if (result.isSuccess()) {
         await this.updateCnameStatusForStatusPageDomain({
           domain: fullDomain,
@@ -265,6 +303,9 @@ export class Service extends DatabaseService<StatusPageDomain> {
           ),
         );
 
+      logger.debug("CNAME verification result for https");
+      logger.debug(resultHttps);
+
       if (resultHttps.isSuccess()) {
         await this.updateCnameStatusForStatusPageDomain({
           domain: fullDomain,
@@ -370,28 +411,46 @@ export class Service extends DatabaseService<StatusPageDomain> {
   }
 
   public async orderSSLForDomainsWhichAreNotOrderedYet(): Promise<void> {
-    const domains: Array<StatusPageDomain> = await this.findBy({
-      query: {
-        isSslOrdered: false,
-      },
-      select: {
-        _id: true,
-        fullDomain: true,
-      },
-      limit: LIMIT_MAX,
-      skip: 0,
-      props: {
-        isRoot: true,
+    return Telemetry.startActiveSpan<Promise<void>>({
+      name: "StatusPageDomainService.orderSSLForDomainsWhichAreNotOrderedYet",
+      options: { attributes: {} },
+      fn: async (span: Span): Promise<void> => {
+        try {
+          const domains: Array<StatusPageDomain> = await this.findBy({
+            query: {
+              isSslOrdered: false,
+            },
+            select: {
+              _id: true,
+              fullDomain: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          for (const domain of domains) {
+            try {
+              logger.debug("Ordering SSL for domain: " + domain.fullDomain);
+              await this.orderCert(domain);
+            } catch (e) {
+              logger.error(e);
+            }
+          }
+
+          Telemetry.endSpan(span);
+        } catch (err) {
+          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+            span,
+            exception: err,
+          });
+
+          throw err;
+        }
       },
     });
-
-    for (const domain of domains) {
-      try {
-        await this.orderCert(domain);
-      } catch (e) {
-        logger.error(e);
-      }
-    }
   }
 
   public async verifyCnameWhoseCnameisNotVerified(): Promise<void> {

package/Server/Services/TelemetryExceptionService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/TelemetryException";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Types/Database/Permissions/Index.ts

@@ -1,3 +1,4 @@
+import QueryDeepPartialEntity from "../../../../Types/Database/PartialEntity";
 import Query from "../Query";
 import Select from "../Select";
 import CreatePermission from "./CreatePermission";
@@ -6,7 +7,6 @@ import ReadPermission, { CheckReadPermissionType } from "./ReadPermission";
 import UpdatePermission from "./UpdatePermission";
 import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 
 export default class ModelPermission {
   public static async checkDeletePermissionByModel<

package/Server/Types/Database/UpdateByID.ts

@@ -1,7 +1,7 @@
 import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
 import ObjectID from "Common/Types/ObjectID";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import QueryDeepPartialEntity from "../../../Types/Database/PartialEntity";
 
 export default interface UpdateBy<TBaseModel extends BaseModel> {
   id: ObjectID;

package/Server/Types/Workflow/Components/Email.ts

@@ -5,6 +5,7 @@ import ComponentMetadata, { Port } from "Common/Types/Workflow/Component";
 import ComponentID from "Common/Types/Workflow/ComponentID";
 import Components from "Common/Types/Workflow/Components/Email";
 import nodemailer, { Transporter } from "nodemailer";
+import SMTPTransport from "nodemailer/lib/smtp-transport";
 
 export default class Email extends ComponentCode {
   public constructor() {
@@ -48,53 +49,49 @@ export default class Email extends ComponentCode {
     }
 
     if (!args["to"]) {
-      throw options.onError(new BadDataException("to not found"));
+      throw options.onError(new BadDataException("To Email not found"));
     }
 
     if (args["to"] && typeof args["to"] !== "string") {
-      throw options.onError(new BadDataException("to is not type of string"));
+      throw options.onError(
+        new BadDataException("To Email is not type of string"),
+      );
     }
 
     if (!args["from"]) {
-      throw options.onError(new BadDataException("from not found"));
+      throw options.onError(new BadDataException("From Email not found"));
     }
 
     if (args["from"] && typeof args["from"] !== "string") {
-      throw options.onError(new BadDataException("from is not type of string"));
-    }
-
-    if (!args["smtp-username"]) {
-      throw options.onError(new BadDataException("email not found"));
+      throw options.onError(
+        new BadDataException("From Email is not type of string"),
+      );
     }
 
     if (args["smtp-username"] && typeof args["smtp-username"] !== "string") {
       throw options.onError(
-        new BadDataException("smtp-username is not type of string"),
+        new BadDataException("SMTP Username is not type of string"),
       );
     }
 
-    if (!args["smtp-password"]) {
-      throw options.onError(new BadDataException("email not found"));
-    }
-
     if (args["smtp-password"] && typeof args["smtp-password"] !== "string") {
       throw options.onError(
-        new BadDataException("smtp-username is not type of string"),
+        new BadDataException("SMTP Password is not type of string"),
       );
     }
 
     if (!args["smtp-host"]) {
-      throw options.onError(new BadDataException("email not found"));
+      throw options.onError(new BadDataException("SMTP Host not found"));
     }
 
     if (args["smtp-host"] && typeof args["smtp-host"] !== "string") {
       throw options.onError(
-        new BadDataException("smtp-host is not type of string"),
+        new BadDataException("SMTP Host is not type of string"),
       );
     }
 
     if (!args["smtp-port"]) {
-      throw options.onError(new BadDataException("email not found"));
+      throw options.onError(new BadDataException("SMTP Port not found"));
     }
 
     if (args["smtp-port"] && typeof args["smtp-port"] === "string") {
@@ -103,20 +100,30 @@ export default class Email extends ComponentCode {
 
     if (args["smtp-port"] && typeof args["smtp-port"] !== "number") {
       throw options.onError(
-        new BadDataException("smtp-host is not type of number"),
+        new BadDataException("SMTP Port is not type of number"),
       );
     }
 
     try {
-      const mailer: Transporter = nodemailer.createTransport({
+      const username: string | undefined =
+        args["smtp-username"]?.toString() || undefined;
+      const password: string | undefined =
+        args["smtp-password"]?.toString() || undefined;
+
+      const smtpTransport: SMTPTransport.Options = {
         host: args["smtp-host"]?.toString(),
         port: args["smtp-port"] as number,
         secure: Boolean(args["secure"]),
-        auth: {
-          user: args["smtp-username"] as string,
-          pass: args["smtp-password"] as string,
-        },
-      });
+      };
+
+      if (username && password) {
+        smtpTransport.auth = {
+          user: username,
+          pass: password,
+        };
+      }
+
+      const mailer: Transporter = nodemailer.createTransport(smtpTransport);
 
       await mailer.sendMail({
         from: args["from"].toString(),
@@ -135,7 +142,7 @@ export default class Email extends ComponentCode {
       options.log(err as Error);
       return Promise.resolve({
         returnValues: {},
-        executePort: successPort,
+        executePort: errorPort,
       });
     }
   }

package/Server/Utils/CodeRepository/CodeRepository.ts

@@ -3,9 +3,18 @@ import LocalFile from "../LocalFile";
 import logger from "../Logger";
 import CodeRepositoryFile from "./CodeRepositoryFile";
 import Dictionary from "Common/Types/Dictionary";
-import ServiceLanguageUtil from "Common/Utils/TechStack";
 
 export default class CodeRepositoryUtil {
+  public static getCurrentCommitHash(data: {
+    repoPath: string;
+  }): Promise<string> {
+    const command: string = `cd ${data.repoPath} && git rev-parse HEAD`;
+
+    logger.debug("Executing command: " + command);
+
+    return Execute.executeCommand(command);
+  }
+
   public static async addAllChangedFilesToGit(data: {
     repoPath: string;
   }): Promise<void> {
@@ -367,24 +376,11 @@ export default class CodeRepositoryUtil {
         }
       }
 
-      const gitCommitHash: string = await this.getGitCommitHashForFile({
-        filePath,
-        repoPath,
-      });
-
-      const fileExtension: string = fileName.split(".").pop() || "";
       files[filePath] = {
-        filePath: LocalFile.sanitizeFilePath(`${directoryPath}/${fileName}`),
-        gitCommitHash,
-        fileExtension,
-        fileName,
         fileContent: await this.getFileContent({
           filePath: LocalFile.sanitizeFilePath(`${directoryPath}/${fileName}`),
           repoPath,
         }),
-        fileLanguage: ServiceLanguageUtil.getLanguageByFileExtension({
-          fileExtension,
-        }),
       };
     }
 

package/Server/Utils/CodeRepository/CodeRepositoryFile.ts

@@ -1,10 +1,3 @@
-import TechStack from "Common/Types/ServiceCatalog/TechStack";
-
 export default interface CodeRepositoryFile {
-  filePath: string;
-  gitCommitHash: string;
-  fileExtension: string;
-  fileName: string;
   fileContent: string;
-  fileLanguage: TechStack;
 }