@oneuptime/common 8.0.5466 → 8.0.5479

package/Server/Services/DatabaseService.ts

@@ -2,6 +2,7 @@ import { EncryptionSecret, WorkflowHostname } from "../EnvironmentConfig";
 import PostgresAppInstance from "../Infrastructure/PostgresDatabase";
 import ClusterKeyAuthorization from "../Middleware/ClusterKeyAuthorization";
 import CountBy from "../Types/Database/CountBy";
+import FindAllBy from "../Types/Database/FindAllBy";
 import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
 import DeleteById from "../Types/Database/DeleteById";
@@ -1168,6 +1169,75 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     }
   }
 
+  @CaptureSpan()
+  public async findAllBy(
+    findAllBy: FindAllBy<TBaseModel>,
+  ): Promise<Array<TBaseModel>> {
+    const { limit, skip, ...rest } = findAllBy;
+
+    let remaining: number | undefined = this.normalizePositiveNumber(limit);
+    let currentSkip: number = this.normalizePositiveNumber(skip) || 0;
+
+    const results: Array<TBaseModel> = [];
+
+    while (true) {
+      const currentBatchSize: number =
+        remaining !== undefined
+          ? Math.min(LIMIT_MAX, Math.max(remaining, 0))
+          : LIMIT_MAX;
+
+      if (currentBatchSize <= 0) {
+        break;
+      }
+
+      const page: Array<TBaseModel> = await this.findBy({
+        ...rest,
+        skip: currentSkip,
+        limit: currentBatchSize,
+      });
+
+      if (page.length === 0) {
+        break;
+      }
+
+      results.push(...page);
+
+      currentSkip += page.length;
+
+      if (remaining !== undefined) {
+        remaining -= page.length;
+
+        if (remaining <= 0) {
+          break;
+        }
+      }
+
+      if (page.length < currentBatchSize) {
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  private normalizePositiveNumber(
+    value?: PositiveNumber | number,
+  ): number | undefined {
+    if (value === undefined || value === null) {
+      return undefined;
+    }
+
+    if (value instanceof PositiveNumber) {
+      return value.toNumber();
+    }
+
+    if (typeof value === "number") {
+      return value;
+    }
+
+    return undefined;
+  }
+
   @CaptureSpan()
   public async findBy(findBy: FindBy<TBaseModel>): Promise<Array<TBaseModel>> {
     return await this._findBy(findBy);

package/Server/Services/ProjectService.ts

@@ -71,6 +71,8 @@ import URL from "../../Types/API/URL";
 import Exception from "../../Types/Exception/Exception";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import DatabaseConfig from "../DatabaseConfig";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import PositiveNumber from "../../Types/PositiveNumber";
 
 export interface CurrentPlan {
   plan: PlanType | null;
@@ -1435,6 +1437,28 @@ export class ProjectService extends DatabaseService<Model> {
     };
   }
 
+  @CaptureSpan()
+  public async getAllActiveProjects(params?: {
+    select?: Select<Model>;
+    props?: DatabaseCommonInteractionProps;
+    skip?: PositiveNumber | number;
+    limit?: PositiveNumber | number;
+  }): Promise<Array<Model>> {
+    const select: Select<Model> | undefined =
+      params?.select || ({ _id: true } as Select<Model>);
+    const props: DatabaseCommonInteractionProps = params?.props || {
+      isRoot: true,
+    };
+
+    return await this.findAllBy({
+      query: this.getActiveProjectStatusQuery(),
+      select,
+      props,
+      skip: params?.skip,
+      limit: params?.limit,
+    });
+  }
+
   @CaptureSpan()
   public async getProjectLinkInDashboard(projectId: ObjectID): Promise<URL> {
     const dashboardUrl: URL = await DatabaseConfig.getDashboardUrl();

package/Server/Types/Database/FindAllBy.ts

@@ -0,0 +1,25 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import GroupBy from "./GroupBy";
+import Query from "./Query";
+import Select from "./Select";
+import Sort from "./Sort";
+import PositiveNumber from "../../../Types/PositiveNumber";
+
+export default interface FindAllBy<TBaseModel extends BaseModel> {
+  query: Query<TBaseModel>;
+  select?: Select<TBaseModel> | undefined;
+  sort?: Sort<TBaseModel> | undefined;
+  groupBy?: GroupBy<TBaseModel> | undefined;
+  props: DatabaseCommonInteractionProps;
+  /**
+   * Optional number of documents to skip before fetching results.
+   * Acts the same way as `skip` in `findBy` but defaults to 0 when omitted.
+   */
+  skip?: PositiveNumber | number | undefined;
+  /**
+   * Optional total number of documents to return across all batches.
+   * When omitted, the method keeps fetching until no more data is returned.
+   */
+  limit?: PositiveNumber | number | undefined;
+}

package/Server/Utils/CodeRepository/CodeRepository.ts

@@ -1,33 +1,26 @@
+import path from "path";
+import fs from "fs";
 import Execute from "../Execute";
 import LocalFile from "../LocalFile";
 import logger from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import CodeRepositoryFile from "./CodeRepositoryFile";
 import Dictionary from "../../../Types/Dictionary";
+import BadDataException from "../../../Types/Exception/BadDataException";
 
 export default class CodeRepositoryUtil {
   @CaptureSpan()
   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);
+    return this.runGitCommand(data.repoPath, ["rev-parse", "HEAD"]);
   }
 
   @CaptureSpan()
   public static async addAllChangedFilesToGit(data: {
     repoPath: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git add -A`;
-
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
-
-    logger.debug(stdout);
+    await this.runGitCommand(data.repoPath, ["add", "-A"]);
   }
 
   @CaptureSpan()
@@ -36,26 +29,26 @@ export default class CodeRepositoryUtil {
     authorName: string;
     authorEmail: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git config --global user.name "${data.authorName}" && git config --global user.email "${data.authorEmail}"`;
-
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
-
-    logger.debug(stdout);
+    await this.runGitCommand(data.repoPath, [
+      "config",
+      "--global",
+      "user.name",
+      data.authorName,
+    ]);
+
+    await this.runGitCommand(data.repoPath, [
+      "config",
+      "--global",
+      "user.email",
+      data.authorEmail,
+    ]);
   }
 
   @CaptureSpan()
   public static async discardAllChangesOnCurrentBranch(data: {
     repoPath: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git checkout .`;
-
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
-
-    logger.debug(stdout);
+    await this.runGitCommand(data.repoPath, ["checkout", "."]);
   }
 
   // returns the folder name of the cloned repository
@@ -64,33 +57,25 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     repoUrl: string;
   }): Promise<string> {
-    const command: string = `cd ${data.repoPath} && git clone ${data.repoUrl}`;
-
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
+    await this.runGitCommand(data.repoPath, ["clone", data.repoUrl]);
 
-    logger.debug(stdout);
-
-    // get the folder name of the repository from the disk.
-
-    const getFolderNameCommand: string = `cd ${data.repoPath} && ls`;
+    const normalizedUrl: string = data.repoUrl.trim().replace(/\/+$/g, "");
+    const lastSegment: string =
+      normalizedUrl.split("/").pop() || normalizedUrl.split(":").pop() || "";
+    const folderName: string = lastSegment.replace(/\.git$/i, "");
 
-    const folderName: string =
-      await Execute.executeCommand(getFolderNameCommand);
+    if (!folderName) {
+      throw new BadDataException(
+        "Unable to determine repository folder name after cloning.",
+      );
+    }
 
     return folderName.trim();
   }
 
   @CaptureSpan()
   public static async pullChanges(data: { repoPath: string }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git pull`;
-
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
-
-    logger.debug(stdout);
+    await this.runGitCommand(data.repoPath, ["pull"]);
   }
 
   @CaptureSpan()
@@ -98,13 +83,26 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     branchName: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git checkout ${data.branchName} || git checkout -b ${data.branchName}`;
-
-    logger.debug("Executing command: " + command);
+    try {
+      await this.runGitCommand(data.repoPath, [
+        "rev-parse",
+        "--verify",
+        data.branchName,
+      ]);
+      await this.runGitCommand(data.repoPath, ["checkout", data.branchName]);
+    } catch (error) {
+      logger.debug(
+        `Branch ${data.branchName} not found. Creating a new branch instead.`,
+      );
 
-    const stdout: string = await Execute.executeCommand(command);
+      logger.debug(error);
 
-    logger.debug(stdout);
+      await this.runGitCommand(data.repoPath, [
+        "checkout",
+        "-b",
+        data.branchName,
+      ]);
+    }
   }
 
   @CaptureSpan()
@@ -112,15 +110,12 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     filePath: string;
   }): Promise<string> {
-    const path: string = LocalFile.sanitizeFilePath(
-      `${data.repoPath}/${data.filePath}`,
+    const absolutePath: string = this.resolvePathWithinRepo(
+      data.repoPath,
+      data.filePath,
     );
 
-    const command: string = `cat ${path}`;
-
-    logger.debug("Executing command: " + command);
-
-    return Execute.executeCommand(`${command}`);
+    return LocalFile.read(absolutePath);
   }
 
   // discard all changes in the working directory
@@ -128,13 +123,7 @@ export default class CodeRepositoryUtil {
   public static async discardChanges(data: {
     repoPath: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git checkout .`;
-
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
-
-    logger.debug(stdout);
+    await this.runGitCommand(data.repoPath, ["checkout", "."]);
   }
 
   @CaptureSpan()
@@ -183,13 +172,9 @@ export default class CodeRepositoryUtil {
       `${data.repoPath}/${data.directoryPath}`,
     );
 
-    const command: string = `rm -rf ${totalPath}`;
+    logger.debug("Deleting directory: " + totalPath);
 
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
-
-    logger.debug(stdout);
+    await LocalFile.deleteDirectory(totalPath);
   }
 
   @CaptureSpan()
@@ -197,11 +182,15 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     branchName: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git checkout -b ${data.branchName}`;
-
-    logger.debug("Executing command: " + command);
+    logger.debug(
+      `Creating git branch '${data.branchName}' in ${path.resolve(data.repoPath)}`,
+    );
 
-    const stdout: string = await Execute.executeCommand(command);
+    const stdout: string = await this.runGitCommand(data.repoPath, [
+      "checkout",
+      "-b",
+      data.branchName,
+    ]);
 
     logger.debug(stdout);
   }
@@ -211,11 +200,14 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     branchName: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git checkout ${data.branchName}`;
-
-    logger.debug("Executing command: " + command);
+    logger.debug(
+      `Checking out git branch '${data.branchName}' in ${path.resolve(data.repoPath)}`,
+    );
 
-    const stdout: string = await Execute.executeCommand(command);
+    const stdout: string = await this.runGitCommand(data.repoPath, [
+      "checkout",
+      data.branchName,
+    ]);
 
     logger.debug(stdout);
   }
@@ -225,22 +217,51 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     filePaths: Array<string>;
   }): Promise<void> {
-    const filePaths: Array<string> = data.filePaths.map((filePath: string) => {
-      if (filePath.startsWith("/")) {
-        // remove the leading slash and return
-        return filePath.substring(1);
+    const repoRoot: string = path.resolve(data.repoPath);
+
+    const sanitizedRelativeFilePaths: Array<string> = [];
+
+    for (const inputFilePath of data.filePaths) {
+      const normalizedPath: string = inputFilePath.startsWith("/")
+        ? inputFilePath.substring(1)
+        : inputFilePath;
+
+      if (normalizedPath.trim() === "") {
+        continue;
       }
 
-      return filePath;
-    });
+      const absoluteFilePath: string = this.resolvePathWithinRepo(
+        data.repoPath,
+        normalizedPath,
+      );
+
+      const relativeFilePath: string = path.relative(
+        repoRoot,
+        absoluteFilePath,
+      );
 
-    const command: string = `cd ${
-      data.repoPath
-    } && git add ${filePaths.join(" ")}`;
+      if (relativeFilePath.trim() === "") {
+        continue;
+      }
+
+      sanitizedRelativeFilePaths.push(
+        LocalFile.sanitizeFilePath(relativeFilePath),
+      );
+    }
 
-    logger.debug("Executing command: " + command);
+    if (sanitizedRelativeFilePaths.length === 0) {
+      logger.debug("git add skipped because no file paths were provided");
+      return;
+    }
+
+    logger.debug(
+      `Adding ${sanitizedRelativeFilePaths.length} file(s) to git in ${path.resolve(data.repoPath)}`,
+    );
 
-    const stdout: string = await Execute.executeCommand(command);
+    const stdout: string = await this.runGitCommand(data.repoPath, [
+      "add",
+      ...sanitizedRelativeFilePaths,
+    ]);
 
     logger.debug(stdout);
   }
@@ -250,11 +271,13 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     username: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git config user.name "${data.username}"`;
+    logger.debug(`Setting git user.name in ${path.resolve(data.repoPath)}`);
 
-    logger.debug("Executing command: " + command);
-
-    const stdout: string = await Execute.executeCommand(command);
+    const stdout: string = await this.runGitCommand(data.repoPath, [
+      "config",
+      "user.name",
+      data.username,
+    ]);
 
     logger.debug(stdout);
   }
@@ -264,11 +287,13 @@ export default class CodeRepositoryUtil {
     repoPath: string;
     message: string;
   }): Promise<void> {
-    const command: string = `cd ${data.repoPath} && git commit -m "${data.message}"`;
-
-    logger.debug("Executing command: " + command);
+    logger.debug("Executing git commit");
 
-    const stdout: string = await Execute.executeCommand(command);
+    const stdout: string = await Execute.executeCommandFile({
+      command: "git",
+      args: ["commit", "-m", data.message],
+      cwd: data.repoPath,
+    });
 
     logger.debug(stdout);
   }
@@ -288,15 +313,28 @@ export default class CodeRepositoryUtil {
 
     const { repoPath, filePath } = data;
 
-    const command: string = `cd ${repoPath} && git log -1 --pretty=format:"%H" ".${filePath}"`;
+    const repoRoot: string = path.resolve(repoPath);
+    const absoluteTarget: string = this.resolvePathWithinRepo(
+      repoPath,
+      filePath,
+    );
+    const relativeTarget: string = path.relative(repoRoot, absoluteTarget);
+    const gitArgument: string = LocalFile.sanitizeFilePath(
+      `./${relativeTarget}`,
+    );
 
-    logger.debug("Executing command: " + command);
+    logger.debug(`Getting last commit hash for ${gitArgument} in ${repoRoot}`);
 
-    const hash: string = await Execute.executeCommand(command);
+    const hash: string = await this.runGitCommand(repoRoot, [
+      "log",
+      "-1",
+      "--pretty=format:%H",
+      gitArgument,
+    ]);
 
     logger.debug(hash);
 
-    return hash;
+    return hash.trim();
   }
 
   @CaptureSpan()
@@ -318,11 +356,11 @@ export default class CodeRepositoryUtil {
 
     totalPath = LocalFile.sanitizeFilePath(totalPath); // clean up the path
 
-    const output: string = await Execute.executeCommand(`ls ${totalPath}`);
+    const entries: Array<fs.Dirent> = await LocalFile.readDirectory(totalPath);
 
-    const fileNames: Array<string> = output.split("\n");
-
-    return fileNames;
+    return entries.map((entry: fs.Dirent) => {
+      return entry.name;
+    });
   }
 
   @CaptureSpan()
@@ -350,16 +388,12 @@ export default class CodeRepositoryUtil {
     totalPath = LocalFile.sanitizeFilePath(totalPath); // clean up the path
 
     const files: Dictionary<CodeRepositoryFile> = {};
-    const output: string = await Execute.executeCommand(`ls ${totalPath}`);
-
-    const fileNames: Array<string> = output.split("\n");
-
     const subDirectories: Array<string> = [];
 
-    for (const fileName of fileNames) {
-      if (fileName === "") {
-        continue;
-      }
+    const entries: Array<fs.Dirent> = await LocalFile.readDirectory(totalPath);
+
+    for (const entry of entries) {
+      const fileName: string = entry.name;
 
       const filePath: string = LocalFile.sanitizeFilePath(
         `${directoryPath}/${fileName}`,
@@ -369,13 +403,7 @@ export default class CodeRepositoryUtil {
         continue;
       }
 
-      const isDirectory: boolean = (
-        await Execute.executeCommand(
-          `file "${LocalFile.sanitizeFilePath(`${totalPath}/${fileName}`)}"`,
-        )
-      ).includes("directory");
-
-      if (isDirectory) {
+      if (entry.isDirectory()) {
         subDirectories.push(
           LocalFile.sanitizeFilePath(`${directoryPath}/${fileName}`),
         );
@@ -449,4 +477,45 @@ export default class CodeRepositoryUtil {
 
     return files;
   }
+
+  private static runGitCommand(
+    repoPath: string,
+    args: Array<string>,
+  ): Promise<string> {
+    const cwd: string = path.resolve(repoPath);
+
+    logger.debug(
+      `Executing git command in ${cwd}: git ${args
+        .map((arg: string) => {
+          return arg.includes(" ") ? `"${arg}"` : arg;
+        })
+        .join(" ")}`,
+    );
+
+    return Execute.executeCommandFile({
+      command: "git",
+      args,
+      cwd,
+    });
+  }
+
+  private static resolvePathWithinRepo(
+    repoPath: string,
+    targetPath: string,
+  ): string {
+    const root: string = path.resolve(repoPath);
+    const sanitizedTarget: string = LocalFile.sanitizeFilePath(
+      targetPath,
+    ).replace(/^\/+/, "");
+    const absoluteTarget: string = path.resolve(root, sanitizedTarget);
+
+    if (
+      absoluteTarget !== root &&
+      !absoluteTarget.startsWith(root + path.sep)
+    ) {
+      throw new BadDataException("File path is outside the repository");
+    }
+
+    return absoluteTarget;
+  }
 }

package/Server/Utils/CodeRepository/GitHub/GitHub.ts

@@ -170,13 +170,15 @@ export default class GitHubUtil extends HostedCodeRepository {
       `https://github.com/${data.organizationName}/${data.repositoryName}.git`,
     );
 
-    const command: string = `git remote add ${
-      data.remoteName
-    } ${url.toString()}`;
-
-    logger.debug("Executing command: " + command);
+    logger.debug(
+      `Adding remote '${data.remoteName}' for ${data.organizationName}/${data.repositoryName}`,
+    );
 
-    const result: string = await Execute.executeCommand(command);
+    const result: string = await Execute.executeCommandFile({
+      command: "git",
+      args: ["remote", "add", data.remoteName, url.toString()],
+      cwd: process.cwd(),
+    });
 
     logger.debug(result);
   }
@@ -197,10 +199,19 @@ export default class GitHubUtil extends HostedCodeRepository {
       "Pushing changes to remote repository with username: " + username,
     );
 
-    const command: string = `cd ${data.repoPath} && git push -u https://${username}:${password}@github.com/${data.organizationName}/${data.repositoryName}.git ${branchName}`;
-    logger.debug("Executing command: " + command);
+    const encodedUsername: string = encodeURIComponent(username);
+    const encodedPassword: string = encodeURIComponent(password);
+    const remoteUrl: string = `https://${encodedUsername}:${encodedPassword}@github.com/${data.organizationName}/${data.repositoryName}.git`;
 
-    const result: string = await Execute.executeCommand(command);
+    logger.debug(
+      `Pushing branch '${branchName}' to ${data.organizationName}/${data.repositoryName}`,
+    );
+
+    const result: string = await Execute.executeCommandFile({
+      command: "git",
+      args: ["push", "-u", remoteUrl, branchName],
+      cwd: data.repoPath,
+    });
 
     logger.debug(result);
   }