@oneuptime/common 8.0.5469 → 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

@@ -13,24 +13,14 @@ 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);
+    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()
@@ -39,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
@@ -67,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 normalizedUrl: string = data.repoUrl.trim().replace(/\/+$/g, "");
+    const lastSegment: string =
+      normalizedUrl.split("/").pop() || normalizedUrl.split(":").pop() || "";
+    const folderName: string = lastSegment.replace(/\.git$/i, "");
 
-    const getFolderNameCommand: string = `cd ${data.repoPath} && ls`;
-
-    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()
@@ -101,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()
@@ -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()
@@ -193,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);
   }
@@ -207,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);
   }
@@ -221,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 command: string = `cd ${
-      data.repoPath
-    } && git add ${filePaths.join(" ")}`;
+      const relativeFilePath: string = path.relative(
+        repoRoot,
+        absoluteFilePath,
+      );
 
-    logger.debug("Executing command: " + command);
+      if (relativeFilePath.trim() === "") {
+        continue;
+      }
 
-    const stdout: string = await Execute.executeCommand(command);
+      sanitizedRelativeFilePaths.push(
+        LocalFile.sanitizeFilePath(relativeFilePath),
+      );
+    }
+
+    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 this.runGitCommand(data.repoPath, [
+      "add",
+      ...sanitizedRelativeFilePaths,
+    ]);
 
     logger.debug(stdout);
   }
@@ -246,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("Executing command: " + command);
+    logger.debug(`Setting git user.name in ${path.resolve(data.repoPath)}`);
 
-    const stdout: string = await Execute.executeCommand(command);
+    const stdout: string = await this.runGitCommand(data.repoPath, [
+      "config",
+      "user.name",
+      data.username,
+    ]);
 
     logger.debug(stdout);
   }
@@ -286,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()
@@ -438,6 +478,27 @@ 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,

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);
   }

package/Server/Utils/Execute.ts

@@ -1,26 +1,47 @@
 import { PromiseRejectErrorFunction } from "../../Types/FunctionTypes";
-import { ExecException, exec, execFile } from "node:child_process";
+import {
+  ExecException,
+  ExecOptions,
+  exec,
+  execFile,
+} from "node:child_process";
 import logger from "./Logger";
 import CaptureSpan from "./Telemetry/CaptureSpan";
 
 export default class Execute {
   @CaptureSpan()
-  public static executeCommand(command: string): Promise<string> {
+  public static executeCommand(
+    command: string,
+    options?: ExecOptions,
+  ): Promise<string> {
     return new Promise(
       (
         resolve: (output: string) => void,
         reject: PromiseRejectErrorFunction,
       ) => {
-        exec(`${command}`, (err: ExecException | null, stdout: string) => {
+        exec(
+          `${command}`,
+          {
+            ...options,
+          },
+          (err: ExecException | null, stdout: string, stderr: string) => {
           if (err) {
             logger.error(`Error executing command: ${command}`);
             logger.error(err);
             logger.error(stdout);
+              if (stderr) {
+                logger.error(stderr);
+              }
             return reject(err);
           }
 
+            if (stderr) {
+              logger.debug(stderr);
+            }
+
           return resolve(stdout);
-        });
+          },
+        );
       },
     );
   }