@superblocksteam/sdk 2.0.6-next.66 → 2.0.6-next.68

package/src/client.ts

@@ -11,6 +11,7 @@ import {
   NotFoundError,
   BadRequestError,
   unreachable,
+  getSuperblocksDevEnvironmentConfigJson,
 } from "@superblocksteam/util";
 import axios, { AxiosError } from "axios";
 import FormData from "form-data";
@@ -24,6 +25,10 @@ import { signingEnabled } from "./flag.js";
 import { connectToISocketRPCServer } from "./socket/index.js";
 import { AgentType } from "./types/index.js";
 import { getAgentUrl } from "./utils.js";
+import {
+  DEFAULT_BRANCH,
+  getCurrentGitBranchIfGit,
+} from "./version-control.mjs";
 import type { StdISocketRPCClient } from "./socket/index.js";
 import type {
   ApiWithPb,
@@ -133,6 +138,116 @@ enum ResourceType {
   BACKEND = "BACKEND",
 }
 
+export enum BranchSource {
+  DEV_ENVIRONMENT = "dev environment config file",
+  COMMAND_LINE = "command line",
+  GIT_REPO = "current git repository",
+  DEFAULT = "default",
+}
+
+export class CurrentBranch {
+  public readonly branchName: string;
+  public readonly source: BranchSource;
+  public readonly sourcePath?: string;
+  public readonly userSpecifiedBranch?: string;
+
+  constructor({
+    branchName,
+    source,
+    sourcePath,
+    userSpecifiedBranch,
+  }: {
+    branchName: string;
+    source: BranchSource;
+    sourcePath?: string;
+    userSpecifiedBranch?: string;
+  }) {
+    this.branchName = branchName;
+    this.source = source;
+    this.sourcePath = sourcePath;
+    this.userSpecifiedBranch = userSpecifiedBranch;
+  }
+  isDevEnvironmentWithUserSpecifiedBranch() {
+    return (
+      this.isDefinedInDevEnvironmentConfig() &&
+      this.userSpecifiedBranch !== undefined
+    );
+  }
+  isDefinedInDevEnvironmentConfig(): boolean {
+    return this.source === BranchSource.DEV_ENVIRONMENT;
+  }
+  isDefaultBranch(): boolean {
+    return this.source === BranchSource.DEFAULT;
+  }
+  isGitBranch(): boolean {
+    return this.source === BranchSource.GIT_REPO;
+  }
+}
+
+const DEFAULT_BRANCH_INFO = new CurrentBranch({
+  branchName: DEFAULT_BRANCH,
+  source: BranchSource.DEFAULT,
+});
+
+// TODO (randall): Remove this and the 'index.ts' export when it is no longer needed in the CLI.
+export function getDefaultBranchInfo(): CurrentBranch {
+  return DEFAULT_BRANCH_INFO;
+}
+
+/**
+ * Returns the current branch name, in the following order of precedence:
+ * 1. If a branch name is specified in the dev environment config, use that
+ * 2. If a branch name is specified, use that
+ * 3. If this is in a git repo, use the current branch
+ * 4. If this is not in a git repo, use the default branch
+ * @param userSpecifiedBranch - The branch name specified by the user
+ * @param pathPrefix - The path prefix to use when looking for the dev environment config
+ * @returns The current branch information
+ */
+export async function getCurrentBranchInfo(
+  userSpecifiedBranch?: string,
+  pathPrefix?: string,
+): Promise<CurrentBranch> {
+  // First, if there is a dev environment config and a branch name is specified, use that
+  try {
+    const [devEnvironmentConfig, devEnvConfigPath] =
+      await getSuperblocksDevEnvironmentConfigJson(true, pathPrefix);
+    if (devEnvironmentConfig.branch) {
+      return new CurrentBranch({
+        branchName: devEnvironmentConfig.branch,
+        source: BranchSource.DEV_ENVIRONMENT,
+        sourcePath: devEnvConfigPath,
+        userSpecifiedBranch: userSpecifiedBranch,
+      });
+    }
+  } catch {
+    // Did not find or could not parse the dev environment config, so continue
+  }
+  // Second, if the user specified a branch name, use that
+  if (userSpecifiedBranch) {
+    return new CurrentBranch({
+      branchName: userSpecifiedBranch,
+      source: BranchSource.COMMAND_LINE,
+      userSpecifiedBranch: userSpecifiedBranch,
+    });
+  }
+  // Third, if this is in a git repo, use the current branch
+  const currentGitBranch = await getCurrentGitBranchIfGit();
+  if (currentGitBranch) {
+    return new CurrentBranch({
+      branchName: currentGitBranch,
+      source: BranchSource.GIT_REPO,
+      userSpecifiedBranch: userSpecifiedBranch,
+    });
+  }
+  // Fourth, if this is not in a git repo, use the default branch
+  return new CurrentBranch({
+    branchName: DEFAULT_BRANCH,
+    source: BranchSource.DEFAULT,
+    userSpecifiedBranch: userSpecifiedBranch,
+  });
+}
+
 export async function fetchApplication({
   cliVersion,
   applicationId,

package/src/index.ts

@@ -11,6 +11,8 @@ export {
   fetchApplicationWithComponents,
   fetchApplications,
   fetchCurrentUser,
+  getDefaultBranchInfo,
+  getCurrentBranchInfo,
   pushApi,
   pushApplication,
   registerComponents,
@@ -20,8 +22,10 @@ export {
   type ApplicationWrapper,
   type Branch,
   type Branches,
+  type BranchSource,
   type CodeModeApplicationWrapper,
   type CommitDto,
+  type CurrentBranch,
   type GetCommitsResponseBody,
   type MultiPageApplicationWrapper,
   type MultiPageApplicationWrapperWithComponents,

package/test/clients.test.mts

@@ -0,0 +1,120 @@
+import fs from "fs";
+import path from "path";
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { BranchSource, getCurrentBranchInfo } from "../src/client.js";
+import { getCurrentGitBranch } from "../src/version-control.mjs";
+import type { SuperblocksDevEnvironmentConfig } from "@superblocksteam/util";
+
+// The .superblocks folder is located in the 'test' directory, so we need to prefix the path in order to find it.
+const testPathPrefix = "test";
+const superblocksTestFolder = path.join(
+  process.cwd(),
+  testPathPrefix,
+  ".superblocks",
+);
+const devEnvBranch = "dev-branch";
+const currentGitBranch = await getCurrentGitBranch();
+
+describe("get current branch info", () => {
+  let createdSuperblocksFolder = false;
+
+  before(async function () {
+    // Make the .superblocks folder in the test directory, if it is missing. It should be git-ignored.
+    if (!fs.existsSync(superblocksTestFolder)) {
+      fs.mkdirSync(superblocksTestFolder, { recursive: true });
+      createdSuperblocksFolder = true;
+    }
+    // Create a dev-environment.json file in the .superblocks folder.
+    const devEnvironmentJson = path.join(
+      superblocksTestFolder,
+      "dev-environment.json",
+    );
+    fs.writeFileSync(
+      devEnvironmentJson,
+      JSON.stringify({
+        branch: devEnvBranch,
+        configType: "DEV_ENVIRONMENT",
+      } as SuperblocksDevEnvironmentConfig),
+    );
+  });
+
+  after(async function () {
+    // Delete the .superblocks folder in the test directory.
+    if (createdSuperblocksFolder && fs.existsSync(superblocksTestFolder)) {
+      fs.rmSync(superblocksTestFolder, { recursive: true });
+    }
+  });
+
+  it("should find the dev environment config and return a valid branch info object", async () => {
+    const branchInfo = await getCurrentBranchInfo(undefined, testPathPrefix);
+
+    expect(branchInfo.branchName).to.equal(devEnvBranch);
+    expect(branchInfo.source).to.equal(BranchSource.DEV_ENVIRONMENT);
+    expect(branchInfo.userSpecifiedBranch).to.be.undefined;
+    expect(branchInfo.isDefinedInDevEnvironmentConfig()).to.be.true;
+    expect(branchInfo.isDevEnvironmentWithUserSpecifiedBranch()).to.be.false;
+    expect(branchInfo.isDefaultBranch()).to.be.false;
+
+    // Call it again to make sure it has the same properties
+    const branchInfo2 = await getCurrentBranchInfo(undefined, testPathPrefix);
+    expect(branchInfo).to.deep.equal(branchInfo2);
+  });
+
+  it("should find the dev environment config and include the user-specified branch parameter", async () => {
+    const userBranch = "test-user-branch";
+    const branchInfo = await getCurrentBranchInfo(userBranch, testPathPrefix);
+
+    expect(branchInfo.branchName).to.equal(devEnvBranch);
+    expect(branchInfo.source).to.equal(BranchSource.DEV_ENVIRONMENT);
+    expect(branchInfo.userSpecifiedBranch).to.equal(userBranch);
+    expect(branchInfo.isDefinedInDevEnvironmentConfig()).to.be.true;
+    expect(branchInfo.isDevEnvironmentWithUserSpecifiedBranch()).to.be.true;
+    expect(branchInfo.isDefaultBranch()).to.be.false;
+
+    // Call it again to make sure it's the same object
+    const branchInfo2 = await getCurrentBranchInfo(userBranch, testPathPrefix);
+    expect(branchInfo).to.deep.equal(branchInfo2);
+
+    // Call it again without the test path will find the user supplied branch
+    const branchInfo3 = await getCurrentBranchInfo(userBranch);
+    expect(branchInfo3.branchName).to.equal(userBranch);
+    expect(branchInfo3.source).to.equal(BranchSource.COMMAND_LINE);
+    expect(branchInfo3.userSpecifiedBranch).to.equal(userBranch);
+    expect(branchInfo3.isDefinedInDevEnvironmentConfig()).to.be.false;
+    expect(branchInfo3.isDevEnvironmentWithUserSpecifiedBranch()).to.be.false;
+    expect(branchInfo3.isDefaultBranch()).to.be.false;
+  });
+
+  it("should not find a dev environment config and return an info with our git branch", async () => {
+    const branchInfo = await getCurrentBranchInfo();
+    expect(branchInfo.branchName).to.equal(currentGitBranch);
+    expect(branchInfo.source).to.equal(BranchSource.GIT_REPO);
+    expect(branchInfo.userSpecifiedBranch).to.be.undefined;
+    expect(branchInfo.isDefinedInDevEnvironmentConfig()).to.be.false;
+    expect(branchInfo.isDevEnvironmentWithUserSpecifiedBranch()).to.be.false;
+    expect(branchInfo.isDefaultBranch()).to.be.false;
+
+    // Call it again to make sure it's the same object
+    const branchInfo2 = await getCurrentBranchInfo();
+    expect(branchInfo).to.deep.equal(branchInfo2);
+  });
+
+  it("should not find a dev environment config and return an info with the user-specified branch", async () => {
+    const userBranch = "test-user-branch";
+    expect(userBranch).to.not.equal(devEnvBranch);
+    expect(userBranch).to.not.equal(currentGitBranch);
+
+    const branchInfo = await getCurrentBranchInfo(userBranch);
+    expect(branchInfo.branchName).to.equal(userBranch);
+    expect(branchInfo.source).to.equal(BranchSource.COMMAND_LINE);
+    expect(branchInfo.userSpecifiedBranch).to.equal(userBranch);
+    expect(branchInfo.isDefinedInDevEnvironmentConfig()).to.be.false;
+    expect(branchInfo.isDevEnvironmentWithUserSpecifiedBranch()).to.be.false;
+    expect(branchInfo.isDefaultBranch()).to.be.false;
+
+    // Call it again to make sure it's the same object
+    const branchInfo2 = await getCurrentBranchInfo(userBranch);
+    expect(branchInfo).to.deep.equal(branchInfo2);
+  });
+});