intershell 0.3.0

package/src/entities/affected/affected.test.ts

@@ -0,0 +1,427 @@
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+import type { $ } from "bun";
+
+describe("EntityAffected", async () => {
+	beforeEach(async () => {
+		// Import and mock entitiesShell methods directly
+		const { entitiesShell } = await import("../entities.shell");
+
+		// Mock turboRunBuild directly
+		entitiesShell.turboRunBuild = mock(
+			() =>
+				({
+					exitCode: 0,
+					json: () => Promise.resolve({ packages: ["package1", "package2"] }),
+					text: () => Promise.resolve('{"packages":["package1","package2"]}'),
+				}) as unknown as $.ShellPromise,
+		);
+	});
+
+	describe("getAffectedPackages", () => {
+		it("should call EntityTag.getBaseCommitSha with correct parameters", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+
+			// Store original method
+			const originalGetBaseCommitSha = EntityTag.getBaseCommitSha;
+
+			// Mock EntityTag.getBaseCommitSha
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			await EntityAffected.getAffectedPackages("custom-sha").catch(() => undefined);
+
+			// Assert
+			expect(mockGetBaseTagSha).toHaveBeenCalledWith("custom-sha");
+
+			// Restore original method
+			EntityTag.getBaseCommitSha = originalGetBaseCommitSha;
+		});
+
+		it("should call EntityTag.getBaseCommitSha with undefined when no baseSha provided", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+
+			// Store original method
+			const originalGetBaseCommitSha = EntityTag.getBaseCommitSha;
+
+			// Mock EntityTag.getBaseCommitSha
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			await EntityAffected.getAffectedPackages().catch(() => undefined);
+
+			// Assert
+			expect(mockGetBaseTagSha).toHaveBeenCalledWith(undefined);
+
+			// Restore original method
+			EntityTag.getBaseCommitSha = originalGetBaseCommitSha;
+		});
+
+		it("should handle EntityTag.getBaseCommitSha throwing an error", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+
+			// Store original method
+			const originalGetBaseCommitSha = EntityTag.getBaseCommitSha;
+
+			// Mock EntityTag.getBaseCommitSha to throw error
+			const mockGetBaseTagSha = mock(() => Promise.reject(new Error("Failed to get base tag SHA")));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act & Assert
+			expect(EntityAffected.getAffectedPackages()).rejects.toThrow("Failed to get base tag SHA");
+
+			// Restore original method
+			EntityTag.getBaseCommitSha = originalGetBaseCommitSha;
+		});
+	});
+
+	describe("function structure and behavior", () => {
+		it("should have getAffectedPackages function", async () => {
+			// Import fresh EntityAffected module
+			const { EntityAffected } = await import("./affected");
+
+			expect(EntityAffected.getAffectedPackages).toBeDefined();
+			expect(typeof EntityAffected.getAffectedPackages).toBe("function");
+		});
+
+		it("should return a promise", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+
+			// Store original method
+			const originalGetBaseCommitSha = EntityTag.getBaseCommitSha;
+
+			// Mock the EntityTag to prevent actual execution
+			const mockGetBaseTagSha = mock(() => Promise.resolve("test-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			const result = EntityAffected.getAffectedPackages();
+			expect(result).toBeInstanceOf(Promise);
+
+			// Restore original method
+			EntityTag.getBaseCommitSha = originalGetBaseCommitSha;
+		});
+
+		it("should accept optional baseSha parameter", async () => {
+			// Import fresh EntityAffected module
+			const { EntityAffected } = await import("./affected");
+
+			// This test verifies the function signature
+			// The function has 2 parameters: baseSha (optional) and to (with default value)
+			// But function.length only counts parameters before the first default value, so it's 1
+			expect(EntityAffected.getAffectedPackages.length).toBe(1);
+		});
+
+		it("should accept optional to parameter with default value", async () => {
+			// Import fresh EntityAffected module
+			const { EntityAffected } = await import("./affected");
+
+			// This test verifies the function signature
+			// The function has 2 parameters: baseSha (optional) and to (with default value)
+			// But function.length only counts parameters before the first default value, so it's 1
+			expect(EntityAffected.getAffectedPackages.length).toBe(1);
+		});
+	});
+
+	describe("parameter handling", () => {
+		it("should handle string baseSha parameter", async () => {
+			// Import EntityAffected first
+			const { EntityAffected } = await import("./affected");
+
+			// Now import EntityTag and mock its method
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Act
+			await EntityAffected.getAffectedPackages("test-sha").catch(() => undefined);
+
+			// Assert
+			expect(mockGetBaseTagSha).toHaveBeenCalledWith("test-sha");
+		});
+
+		it("should handle undefined baseSha parameter", async () => {
+			// Import EntityAffected first
+			const { EntityAffected } = await import("./affected");
+
+			// Now import EntityTag and mock its method
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Act
+			await EntityAffected.getAffectedPackages().catch(() => undefined);
+
+			// Assert
+			expect(mockGetBaseTagSha).toHaveBeenCalledWith(undefined);
+		});
+
+		it("should handle custom to parameter", async () => {
+			// Import EntityAffected first
+			const { EntityAffected } = await import("./affected");
+
+			// Now import EntityTag and mock its method
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Act
+			await EntityAffected.getAffectedPackages("test-sha", "custom-branch").catch(() => undefined);
+
+			// Assert
+			expect(mockGetBaseTagSha).toHaveBeenCalledWith("test-sha");
+		});
+
+		it("should use HEAD as default to parameter", async () => {
+			// Import EntityAffected first
+			const { EntityAffected } = await import("./affected");
+
+			// Now import EntityTag and mock its method
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Act
+			await EntityAffected.getAffectedPackages("test-sha").catch(() => undefined);
+
+			// Assert
+			expect(mockGetBaseTagSha).toHaveBeenCalledWith("test-sha");
+		});
+	});
+
+	describe("successful execution", () => {
+		it("should return affected packages from turbo output", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Import and mock entitiesShell
+			const { entitiesShell } = await import("../entities.shell");
+			const mockTurboRunBuild = mock(
+				() =>
+					({
+						text: () =>
+							Promise.resolve(
+								JSON.stringify({
+									tasks: [
+										{ package: "package1" },
+										{ package: "package2" },
+										{ package: "//" }, // root package should be filtered out
+									],
+								}),
+							),
+					}) as unknown as $.ShellPromise,
+			);
+			entitiesShell.turboRunBuild = mockTurboRunBuild as unknown as (
+				args: string[],
+			) => $.ShellPromise;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			const result = await EntityAffected.getAffectedPackages("test-sha");
+
+			// Assert
+			expect(result).toEqual(["package1", "package2"]);
+			expect(mockTurboRunBuild).toHaveBeenCalledWith(["--filter=...[resolved-sha...HEAD]"]);
+		});
+
+		it("should handle empty tasks array", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Import and mock entitiesShell
+			const { entitiesShell } = await import("../entities.shell");
+			const mockTurboRunBuild = mock(
+				() =>
+					({
+						text: () =>
+							Promise.resolve(
+								JSON.stringify({
+									tasks: [],
+								}),
+							),
+					}) as unknown as $.ShellPromise,
+			);
+			entitiesShell.turboRunBuild = mockTurboRunBuild as unknown as (
+				args: string[],
+			) => $.ShellPromise;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			const result = await EntityAffected.getAffectedPackages("test-sha");
+
+			// Assert
+			expect(result).toEqual([]);
+		});
+
+		it("should handle missing tasks property", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Import and mock entitiesShell
+			const { entitiesShell } = await import("../entities.shell");
+			const mockTurboRunBuild = mock(
+				() =>
+					({
+						text: () =>
+							Promise.resolve(
+								JSON.stringify({
+									packages: ["package1", "package2"],
+								}),
+							),
+					}) as unknown as $.ShellPromise,
+			);
+			entitiesShell.turboRunBuild = mockTurboRunBuild as unknown as (
+				args: string[],
+			) => $.ShellPromise;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			const result = await EntityAffected.getAffectedPackages("test-sha");
+
+			// Assert
+			expect(result).toEqual([]);
+		});
+
+		it("should filter out root package and undefined values", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Import and mock entitiesShell
+			const { entitiesShell } = await import("../entities.shell");
+			const mockTurboRunBuild = mock(() => ({
+				text: () =>
+					Promise.resolve(
+						JSON.stringify({
+							tasks: [
+								{ package: "package1" },
+								{ package: "//" }, // root package should be filtered out
+								{ package: "" }, // empty string should be filtered out
+								{ package: undefined }, // undefined should be filtered out
+								{ package: "package2" },
+							],
+						}),
+					),
+			}));
+			entitiesShell.turboRunBuild = mockTurboRunBuild as unknown as (
+				args: string[],
+			) => $.ShellPromise;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			const result = await EntityAffected.getAffectedPackages("test-sha");
+
+			// Assert
+			expect(result).toEqual(["package1", "package2"]);
+		});
+	});
+
+	describe("error handling", () => {
+		it("should propagate EntityTag.getBaseCommitSha errors", async () => {
+			// Import EntityAffected first
+			const { EntityAffected } = await import("./affected");
+
+			// Now import EntityTag and mock its method
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.reject(new Error("Custom error message")));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Act & Assert
+			expect(EntityAffected.getAffectedPackages()).rejects.toThrow("Custom error message");
+		});
+
+		it("should handle different error types from EntityTag.getBaseCommitSha", async () => {
+			// Import EntityAffected first
+			const { EntityAffected } = await import("./affected");
+
+			// Now import EntityTag and mock its method
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.reject(new TypeError("Type error")));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Act & Assert
+			expect(EntityAffected.getAffectedPackages()).rejects.toThrow("Type error");
+		});
+
+		it("should handle turbo command errors and return empty array", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Import and mock entitiesShell
+			const { entitiesShell } = await import("../entities.shell");
+			const mockTurboRunBuild = mock(() => ({
+				text: () => Promise.reject(new Error("Turbo command failed")),
+			}));
+			entitiesShell.turboRunBuild = mockTurboRunBuild as unknown as (
+				args: string[],
+			) => $.ShellPromise;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			const result = await EntityAffected.getAffectedPackages("test-sha");
+
+			// Assert
+			expect(result).toEqual([]);
+		});
+
+		it("should handle JSON parsing errors and return empty array", async () => {
+			// Import and mock EntityTag first
+			const { EntityTag } = await import("../tag");
+			const mockGetBaseTagSha = mock(() => Promise.resolve("resolved-sha"));
+			EntityTag.getBaseCommitSha = mockGetBaseTagSha;
+
+			// Import and mock entitiesShell
+			const { entitiesShell } = await import("../entities.shell");
+			const mockTurboRunBuild = mock(() => ({
+				text: () => Promise.resolve("invalid json"),
+			}));
+			entitiesShell.turboRunBuild = mockTurboRunBuild as unknown as (
+				args: string[],
+			) => $.ShellPromise;
+
+			// Now import EntityAffected after mocking
+			const { EntityAffected } = await import("./affected");
+
+			// Act
+			const result = await EntityAffected.getAffectedPackages("test-sha");
+
+			// Assert
+			expect(result).toEqual([]);
+		});
+	});
+});

package/src/entities/affected/affected.ts

@@ -0,0 +1,22 @@
+import { entitiesShell } from "../entities.shell";
+
+export const EntityAffected = {
+	async getAffectedPackages(baseSha?: string, to = "HEAD"): Promise<string[]> {
+		const { EntityTag } = await import("../tag");
+		const fromSha = await EntityTag.getBaseCommitSha(baseSha);
+
+		try {
+			const result = await entitiesShell.turboRunBuild([`--filter=...[${fromSha}...${to}]`]).text();
+			const turboOutput = JSON.parse(result);
+
+			const packages = turboOutput.tasks?.map((task: { package: string }) => task.package) || [];
+
+			// Filter out root package and undefined values
+			return packages.filter((pkg: string) => pkg && pkg !== "//");
+		} catch (error) {
+			console.warn(`Failed to get affected packages via turbo: ${error}`);
+			// Fallback: return empty array
+			return [];
+		}
+	},
+};

package/src/entities/affected/index.ts

@@ -0,0 +1 @@
+export * from "./affected";