@decohere/workspace 0.0.1-dev.126 → 0.0.1-dev.5

package/src/models/tsconfig.model.ts

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { io } from "@decohere/core/io";
+import ts, { type CompilerOptions } from "typescript";
+import { WorkspaceConfigurationError } from "../errors.js";
+
+const host = ts.sys;
+
+host.readFile = (file) => {
+	return fs.readFileSync(file, { encoding: "utf8" }) as string;
+};
+
+host.readDirectory = (directoryName) => {
+	return fs
+		.readdirSync(directoryName, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name);
+};
+
+export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = {
+	emitDeclarationOnly: true,
+	declaration: true,
+	baseUrl: "./",
+};
+
+export class Tsconfig {
+	public static default() {
+		return new Tsconfig();
+	}
+
+	public static async parse(filePath: string) {
+		if (!(await io.fileExists(filePath))) {
+			throw new WorkspaceConfigurationError(`TSConfig not found ${filePath}`);
+		}
+		const configFileText = await io.readFile(filePath);
+		const result = ts.parseConfigFileTextToJson(filePath, configFileText);
+		if (result.error) {
+			const errorMessage = result.error.messageText.toString();
+			throw new WorkspaceConfigurationError(`Error parsing ${filePath}. ${errorMessage}`);
+		}
+		const dirName = path.resolve(path.dirname(filePath));
+		const configParseResult = ts.parseJsonConfigFileContent(result.config, host, dirName);
+		return new Tsconfig({
+			compilerOptions: configParseResult.options,
+			errors: configParseResult.errors,
+		});
+	}
+
+	public static parseSync(filePath: string) {
+		if (!Tsconfig.fileExistsSync(filePath)) {
+			throw new WorkspaceConfigurationError(`TSConfig not found ${filePath}`);
+		}
+		const configFileText = fs.readFileSync(filePath, "utf8");
+		const result = ts.parseConfigFileTextToJson(filePath, configFileText);
+		if (result.error) {
+			const errorMessage = result.error.messageText.toString();
+			throw new WorkspaceConfigurationError(`Error parsing ${filePath}. ${errorMessage}`);
+		}
+		const dirName = path.resolve(path.dirname(filePath));
+		const configParseResult = ts.parseJsonConfigFileContent(result.config, host, dirName);
+		return new Tsconfig({
+			compilerOptions: configParseResult.options,
+			errors: configParseResult.errors,
+		});
+	}
+
+	private static fileExistsSync(filePath: string): boolean {
+		try {
+			return fs.statSync(filePath).isFile();
+		} catch {
+			return false;
+		}
+	}
+
+	public constructor(data: Partial<Tsconfig> = { compilerOptions: DEFAULT_COMPILER_OPTIONS }) {
+		Object.assign(this, data);
+	}
+
+	public readonly compilerOptions: CompilerOptions;
+	public readonly errors: readonly ts.Diagnostic[];
+}

package/src/models/workspace-config.type.ts

@@ -0,0 +1,57 @@
+/**
+ * Generic configuration for a workspace build profile.
+ * Concrete tools (e.g. @decohere/forge) extend this with tool-specific fields.
+ */
+export type Configuration = {
+	name: string;
+	include?: string[];
+	ignore?: string[];
+	/** Extra globs to copy into the configuration outDir (non-transpiled assets). */
+	copyFiles?: string[];
+	/** If true, the output is packed into a folder per project directory. */
+	pack?: boolean;
+};
+
+export type DockerConfig = {
+	image?: string;
+	dockerfile?: string;
+	buildArgs?: Record<string, string>;
+	secrets?: Record<string, string>;
+	tags?: string[];
+	push?: boolean;
+};
+
+/**
+ * The UI a deployable serves from its API (`withStatic` in `@decohere/http`). `forge package` copies the
+ * UI project's build output into the deployable's `.package/` folder.
+ */
+export type UiConfig = {
+	/** Package name of the UI project, e.g. `@app/shop.web`. */
+	project: string;
+	/** The UI project's build output folder, relative to that project. Defaults to `dist`. */
+	output?: string;
+	/** Where it lands inside `.package/`, which is also the folder the API serves. Defaults to `ui`. */
+	to?: string;
+};
+
+export type WorkspaceFactoryOptions = {
+	rootDir?: string;
+	configFile?: string;
+};
+
+export type ProjectOptions = {
+	include?: string[];
+	ignore?: string[];
+	copyFiles: string[];
+	configurations: Configuration[];
+	docker?: DockerConfig;
+	ui?: UiConfig;
+};
+
+export type WorkspaceOptions = {
+	rootDir?: string;
+	outDir: string;
+	includeProjects: string[];
+	ignoreProjects: string[];
+	projects?: Record<string, Partial<ProjectOptions>>;
+} & ProjectOptions;

package/src/models/workspace.model.ts

@@ -0,0 +1,178 @@
+import { injectable } from "@decohere/di/decorators";
+import { collections } from "@decohere/core/collections";
+import { mixwith } from "@decohere/core/extensibility";
+import type { FileEx } from "@decohere/core/io";
+import type { Subscription } from "rxjs";
+import { Subject } from "rxjs";
+import { WorkspaceConfigurationError } from "../errors.js";
+import { HasPackageJson } from "./has-package-json.mixin.js";
+import { HasTsConfig } from "./has-tsconfig.mixin.js";
+import { type PackageAliases, packageAliases } from "./package-aliases.js";
+import { PackageJson } from "./package-json.model.js";
+import { Project, type ProjectSeed } from "./project.model.js";
+import type { ProjectFileEvent } from "./project-file-event.js";
+import type { WorkspaceOptions } from "./workspace-config.type.js";
+
+export type WorkspaceInitOptions = {
+	packageJson?: PackageJson;
+	config: Partial<WorkspaceOptions>;
+	projects: ProjectSeed[];
+};
+
+@injectable()
+export class Workspace extends mixwith(HasPackageJson, HasTsConfig) {
+	protected packageJson?: PackageJson;
+	readonly #name: string;
+	readonly #config: Partial<WorkspaceOptions>;
+	readonly #projectSeeds: readonly ProjectSeed[] = [];
+	readonly #projectCache = new Map<string, readonly Project[]>();
+	/**
+	 * Each project's source file paths as a set, so `findProject` is a lookup rather than a scan
+	 * of every file: the Vitest plugin asks once per transformed file (#517). Keyed by the list
+	 * `getAllFiles` returns, so a new list (after its cache is flushed) gets a new set.
+	 */
+	readonly #sourcePaths = new WeakMap<readonly FileEx[], Set<string>>();
+	readonly #projectFileChangedSubject = new Subject<ProjectFileEvent>();
+	readonly #projectWatchSubscriptions = new Map<string, Subscription>();
+	#watchedProjects: readonly Project[] = [];
+
+	public constructor(options: Partial<WorkspaceInitOptions> = {}) {
+		super();
+		const { packageJson, config, projects } = options;
+		this.#name = packageJson?.name ?? "WORKSPACE";
+		this.packageJson = packageJson ?? new PackageJson();
+		this.#config = config ?? {};
+		this.#projectSeeds = projects ?? [];
+		this.validateWorkspace();
+	}
+
+	public get name() {
+		return this.#name;
+	}
+
+	protected get projectSeeds(): readonly ProjectSeed[] {
+		return this.#projectSeeds;
+	}
+
+	public getProjects(configuration: string): readonly Project[] {
+		const cached = this.#projectCache.get(configuration);
+		if (cached != null) {
+			return cached;
+		}
+
+		const projects = this.#projectSeeds.map(
+			(seed) => new Project(seed.name, seed.config ?? ({} as never), configuration),
+		);
+		this.#projectCache.set(configuration, projects);
+		return projects;
+	}
+
+	public get rootDir(): string {
+		return this.#config.rootDir ?? "./";
+	}
+
+	public get packageJsonDirectory(): string {
+		return this.rootDir;
+	}
+
+	protected get tsConfigDirectory(): string {
+		return this.rootDir;
+	}
+
+	protected get fallbackTsConfigDirectory(): string | undefined {
+		return undefined;
+	}
+
+	/**
+	 * Package-name aliases for this configuration: workspace convention, then
+	 * workspace `tsconfig.json` `paths` overrides. Forge and Flux must use this
+	 * instead of assembling the map themselves.
+	 */
+	public getPackageAliases(configuration: string): PackageAliases {
+		const tsconfig = this.findTsConfigPath() != null ? this.getTsConfigSync() : undefined;
+		const baseUrl =
+			typeof tsconfig?.compilerOptions?.baseUrl === "string" &&
+			tsconfig.compilerOptions.baseUrl.length > 0
+				? tsconfig.compilerOptions.baseUrl
+				: this.rootDir;
+
+		return packageAliases.build(this.getProjects(configuration), {
+			baseUrl,
+			tsconfigPaths: tsconfig?.compilerOptions?.paths as Record<string, string[]> | undefined,
+		});
+	}
+
+	public async watch(configuration: string) {
+		this.stopWatching();
+		const projects = this.getProjects(configuration);
+		this.#watchedProjects = projects;
+
+		for (const project of projects) {
+			await project.watch(configuration);
+			const subscription = project.projectFileChanged$.subscribe((evt) =>
+				this.#projectFileChangedSubject.next(evt),
+			);
+
+			this.#projectWatchSubscriptions.set(project.projectDirectory, subscription);
+		}
+	}
+
+	public stopWatching() {
+		for (const subscription of this.#projectWatchSubscriptions.values()) {
+			subscription.unsubscribe();
+		}
+
+		for (const project of this.#watchedProjects) {
+			project.stopWatching();
+		}
+
+		this.#watchedProjects = [];
+		this.#projectWatchSubscriptions.clear();
+	}
+
+	public [Symbol.dispose]() {
+		this.stopWatching();
+	}
+
+	public get projectFileChanged$() {
+		return this.#projectFileChangedSubject.asObservable();
+	}
+
+	public async findProject(
+		filePath: string,
+		buildConfig: string,
+	): Promise<Project | undefined> {
+		for (const project of this.getProjects(buildConfig)) {
+			if ((await this.sourcePathsOf(project)).has(filePath)) {
+				return project;
+			}
+		}
+		return undefined;
+	}
+
+	private async sourcePathsOf(project: Project): Promise<Set<string>> {
+		const files = await project.getAllFiles();
+		const cached = this.#sourcePaths.get(files);
+		if (cached != null) return cached;
+		const paths = new Set(files.map((file) => file.fullPath));
+		this.#sourcePaths.set(files, paths);
+		return paths;
+	}
+
+	private validateWorkspace() {
+		const errors = this.findDuplicateProjectSeeds(this.#projectSeeds);
+		if (errors.length > 0) {
+			throw new WorkspaceConfigurationError(errors.join("\n"));
+		}
+	}
+
+	private findDuplicateProjectSeeds(seeds: readonly ProjectSeed[]): string[] {
+		const duplicates = collections.findDuplicatesByKey([...seeds], "name");
+		return duplicates.map(
+			([name, group]) =>
+				`Duplicate project name "${name}" found at: ${group
+					.map((seed) => seed.config?.projectDir ?? name)
+					.join(", ")}`,
+		);
+	}
+}

package/tests/find-workspace-root.spec.ts

@@ -0,0 +1,30 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resetMemfs } from "@decohere/core/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { findWorkspaceRoot } from "../src/factories/find-workspace-root.js";
+
+describe("findWorkspaceRoot", () => {
+	beforeEach(() => {
+		resetMemfs();
+		mkdirSync("/ws/projects/api/src", { recursive: true });
+		writeFileSync("/ws/package.json", "{}");
+		writeFileSync("/ws/projects/api/package.json", "{}");
+	});
+
+	it("finds the root from a package directory below it", () => {
+		expect(findWorkspaceRoot("/ws/projects/api/src")).toBe("/ws");
+	});
+
+	it("returns the root itself", () => {
+		expect(findWorkspaceRoot("/ws")).toBe("/ws");
+	});
+
+	it("skips a package.json that has no projects/ folder (a package, not the root)", () => {
+		expect(findWorkspaceRoot("/ws/projects/api")).toBe("/ws");
+	});
+
+	it("falls back to the start directory outside any workspace", () => {
+		mkdirSync("/elsewhere/deep", { recursive: true });
+		expect(findWorkspaceRoot("/elsewhere/deep")).toBe("/elsewhere/deep");
+	});
+});

package/tests/package-aliases.spec.ts

@@ -0,0 +1,160 @@
+import path from "node:path";
+import {
+	PackageJson,
+	packageAliases,
+	Workspace,
+	WorkspaceDefaults,
+} from "@decohere/workspace";
+import { resetMemfs } from "@decohere/core/testing";
+import { vol } from "memfs";
+import { afterEach, expect, it } from "vitest";
+
+afterEach(() => {
+	resetMemfs();
+});
+
+function libWorkspace(rootDir = "/ws") {
+	// Aliases point at entries that exist.
+	vol.mkdirSync(`${rootDir}/projects/lib/src`, { recursive: true });
+	vol.writeFileSync(`${rootDir}/projects/lib/src/index.ts`, "");
+	return new Workspace({
+		config: { ...WorkspaceDefaults, rootDir },
+		projects: [
+			{
+				name: "@hmr/lib",
+				config: {
+					...WorkspaceDefaults,
+					rootDir,
+					projectDir: "projects/lib",
+					packageJson: new PackageJson({ name: "@hmr/lib", main: "src/index.ts" }),
+				},
+			},
+		],
+	});
+}
+
+it("maps workspace package names to source entries relative to the workspace root", () => {
+	const aliases = libWorkspace().getPackageAliases("debug");
+	expect(aliases.baseUrl).toBe(path.resolve("/ws"));
+	expect(aliases.paths["@hmr/lib"]).toEqual(["projects/lib/src/index.ts"]);
+	expect(aliases.paths["@hmr/lib/*"]).toEqual(["projects/lib/src/*"]);
+});
+
+it("lets workspace tsconfig paths override convention aliases", () => {
+	vol.fromJSON({
+		"/ws/tsconfig.json": JSON.stringify({
+			compilerOptions: {
+				baseUrl: "/ws",
+				paths: { "@hmr/lib": ["projects/lib/src/override.ts"] },
+			},
+		}),
+	});
+
+	const aliases = libWorkspace().getPackageAliases("debug");
+	expect(aliases.paths["@hmr/lib"]).toEqual(["projects/lib/src/override.ts"]);
+	expect(aliases.paths["@hmr/lib/*"]).toEqual(["projects/lib/src/*"]);
+});
+
+const aliasPaths = {
+	"@hmr/lib": ["projects/lib/src/index.ts"],
+	"@hmr/lib/*": ["projects/lib/src/*"],
+};
+
+it("does not treat relative specifiers as packages", () => {
+	expect(packageAliases.resolvePath("./dep-a.js", aliasPaths, "/workspace")).toBeNull();
+});
+
+it("maps an exact package name to its source entry", () => {
+	expect(packageAliases.resolvePath("@hmr/lib", aliasPaths, "/workspace")).toBe(
+		path.resolve("/workspace/projects/lib/src/index.ts"),
+	);
+});
+
+it("maps a package subpath through the name/* alias", () => {
+	expect(packageAliases.resolvePath("@hmr/lib/other", aliasPaths, "/workspace")).toBe(
+		path.resolve("/workspace/projects/lib/src/other.ts"),
+	);
+});
+
+it("maps a .js alias target to the corresponding .ts source", () => {
+	expect(
+		packageAliases.resolvePath(
+			"@hmr/lib",
+			{ "@hmr/lib": ["projects/lib/src/index.js"] },
+			"/workspace",
+		),
+	).toBe(path.resolve("/workspace/projects/lib/src/index.ts"));
+});
+
+it("ignores node builtins, internals, and empty specifiers", () => {
+	expect(packageAliases.resolvePath("node:fs", aliasPaths, "/workspace")).toBeNull();
+	expect(packageAliases.resolvePath("#internal", aliasPaths, "/workspace")).toBeNull();
+	expect(packageAliases.resolvePath("", aliasPaths, "/workspace")).toBeNull();
+});
+
+// #518: subpaths resolve from the package's exports and by convention, without tsconfig paths.
+function publishedLayoutWorkspace() {
+	vol.fromJSON({
+		"/ws/projects/web/src/index.ts": "",
+		"/ws/projects/web/src/auth/auth.extensions.ts": "",
+		"/ws/projects/web/src/http/index.ts": "",
+		"/ws/projects/util/src/io/index.ts": "",
+	});
+	const project = (name: string, projectDir: string, packageJson: PackageJson) => ({
+		name,
+		config: { ...WorkspaceDefaults, rootDir: "/ws", projectDir, packageJson },
+	});
+	return new Workspace({
+		config: { ...WorkspaceDefaults, rootDir: "/ws" },
+		projects: [
+			// `main` and `exports` describe the published layout, as for a released package.
+			project(
+				"@t/web",
+				"projects/web",
+				new PackageJson({
+					name: "@t/web",
+					main: "index.js",
+					exports: {
+						".": { types: "./types/src/index.d.ts", import: "./es6/src/index.js" },
+						"./auth": { import: "./es6/src/auth/auth.extensions.js" },
+						"./gone": { import: "./es6/src/gone/index.js" },
+					},
+				}),
+			),
+			// Only subpaths, no root entry.
+			project(
+				"@t/util",
+				"projects/util",
+				new PackageJson({ name: "@t/util", main: "index.js" }),
+			),
+		],
+	});
+}
+
+it("maps a published-layout main and exported subpaths back to their sources", () => {
+	const { paths } = publishedLayoutWorkspace().getPackageAliases("debug");
+	expect(paths["@t/web"]).toEqual(["projects/web/src/index.ts"]);
+	expect(paths["@t/web/auth"]).toEqual(["projects/web/src/auth/auth.extensions.ts"]);
+	expect(paths["@t/web/*"]).toEqual(["projects/web/src/*"]);
+});
+
+it("leaves out an exported subpath whose source does not exist", () => {
+	const { paths } = publishedLayoutWorkspace().getPackageAliases("debug");
+	expect(paths["@t/web/gone"]).toBeUndefined();
+});
+
+it("gives a package with only subpaths no bare alias, and resolves its subpaths under src", () => {
+	const { paths, baseUrl } = publishedLayoutWorkspace().getPackageAliases("debug");
+	expect(paths["@t/util"]).toBeUndefined();
+	expect(paths["@t/util/*"]).toEqual(["projects/util/src/*"]);
+	expect(packageAliases.resolvePath("@t/util/io", paths, baseUrl)).toBe(
+		path.resolve("/ws/projects/util/src/io/index.ts"),
+	);
+});
+
+it("resolves a wildcard subpath to the directory's index.ts when there is no <sub>.ts", () => {
+	const { paths, baseUrl } = publishedLayoutWorkspace().getPackageAliases("debug");
+	expect(packageAliases.resolvePath("@t/web/http", paths, baseUrl)).toBe(
+		path.resolve("/ws/projects/web/src/http/index.ts"),
+	);
+});

package/tests/package-json.model.spec.ts

@@ -0,0 +1,78 @@
+import { PackageJson } from "@decohere/workspace";
+import { describe, expect, it } from "vitest";
+
+describe("PackageJson repository parsing", () => {
+	it("parses github shorthand repository", () => {
+		const packageJson = new PackageJson({
+			name: "workspace",
+			version: "1.2.3",
+			repository: "github:typesmiths/decohere",
+		});
+
+		expect(packageJson.getRepositoryOwner()).toBe("typesmiths");
+		expect(packageJson.getRepositoryName()).toBe("decohere");
+		expect(packageJson.getRepositoryFullName()).toBe("typesmiths/decohere");
+	});
+
+	it("parses git+https GitHub repository URL object", () => {
+		const packageJson = new PackageJson({
+			name: "workspace",
+			version: "1.2.3",
+			repository: {
+				type: "git",
+				url: "git+https://github.com/typesmiths/decohere.git",
+			},
+		});
+
+		expect(packageJson.getRepositoryOwner()).toBe("typesmiths");
+		expect(packageJson.getRepositoryName()).toBe("decohere");
+		expect(packageJson.getRepositoryFullName()).toBe("typesmiths/decohere");
+	});
+
+	it("normalizes owner and repository name to lowercase", () => {
+		const packageJson = new PackageJson({
+			name: "workspace",
+			version: "1.2.3",
+			repository: "github:TypeSmiths/DecoHere",
+		});
+
+		expect(packageJson.getRepositoryOwner()).toBe("typesmiths");
+		expect(packageJson.getRepositoryName()).toBe("decohere");
+		expect(packageJson.getRepositoryFullName()).toBe("typesmiths/decohere");
+	});
+
+	it("parses non-GitHub repository URL values", () => {
+		const packageJson = new PackageJson({
+			name: "workspace",
+			version: "1.2.3",
+			repository: "https://gitlab.com/typesmiths/decohere.git",
+		});
+
+		expect(packageJson.getRepositoryOwner()).toBe("typesmiths");
+		expect(packageJson.getRepositoryName()).toBe("decohere");
+		expect(packageJson.getRepositoryFullName()).toBe("typesmiths/decohere");
+	});
+
+	it("parses SSH repository URL values", () => {
+		const packageJson = new PackageJson({
+			name: "workspace",
+			version: "1.2.3",
+			repository: "git@gitlab.com:typesmiths/decohere.git",
+		});
+
+		expect(packageJson.getRepositoryOwner()).toBe("typesmiths");
+		expect(packageJson.getRepositoryName()).toBe("decohere");
+		expect(packageJson.getRepositoryFullName()).toBe("typesmiths/decohere");
+	});
+
+	it("returns undefined when repository is missing", () => {
+		const packageJson = new PackageJson({
+			name: "workspace",
+			version: "1.2.3",
+		});
+
+		expect(packageJson.getRepositoryOwner()).toBeUndefined();
+		expect(packageJson.getRepositoryName()).toBeUndefined();
+		expect(packageJson.getRepositoryFullName()).toBeUndefined();
+	});
+});

package/tests/project.factory.spec.ts

@@ -0,0 +1,100 @@
+import { ProjectFactory, type WorkspaceOptions } from "@decohere/workspace";
+import { resetMemfs } from "@decohere/core/testing";
+import { vol } from "memfs";
+import { afterEach, expect, it } from "vitest";
+
+const baseOptions: WorkspaceOptions = {
+	rootDir: ".",
+	outDir: "dist",
+	includeProjects: ["projects/**/package.json"],
+	ignoreProjects: ["**/node_modules/**", "**/__fixtures__/**"],
+	copyFiles: [],
+	configurations: [{ name: "debug" }],
+};
+
+afterEach(() => {
+	resetMemfs();
+});
+
+it("builds projects from discovered package.json files", async () => {
+	vol.fromJSON({
+		"projects/path/to/nested1/package.json": JSON.stringify({ name: "MOCK_PROJ" }),
+		"projects/path/to/nested2/package.json": JSON.stringify({ name: "MOCK_PROJ2" }),
+	});
+
+	const projects = await ProjectFactory.getProjects(baseOptions, "debug");
+	expect(projects).toHaveLength(2);
+	expect(projects.map((p) => p.name)).toEqual(["MOCK_PROJ", "MOCK_PROJ2"]);
+});
+
+it("detects projects using include patterns", async () => {
+	vol.fromJSON({
+		"projects/package.json": JSON.stringify({ name: "NOT_INCLUDED" }),
+		"MOCK_DIR/package.json": JSON.stringify({ name: "MOCK_PROJ1" }),
+		"MOCK_DIR1/package.json": JSON.stringify({ name: "MOCK_PROJ2" }),
+	});
+
+	const config: WorkspaceOptions = {
+		...baseOptions,
+		includeProjects: ["MOCK_DIR/**", "MOCK_DIR1/**"],
+	};
+	const projects = await ProjectFactory.getProjects(config, "debug");
+	expect(projects).toHaveLength(2);
+	expect(projects).toEqual(
+		expect.arrayContaining([
+			expect.objectContaining({ name: "MOCK_PROJ1" }),
+			expect.objectContaining({ name: "MOCK_PROJ2" }),
+		]),
+	);
+});
+
+it("ignores projects when ignore patterns overlap include patterns", async () => {
+	vol.fromJSON({
+		"MOCK_DIR/package.json": JSON.stringify({ name: "MOCK_PROJ" }),
+		"MOCK_DIR/IGNORE/package.json": JSON.stringify({ name: "IGNORE" }),
+		"MOCK_DIR/IGNORE1/package.json": JSON.stringify({ name: "IGNORE" }),
+	});
+
+	const config: WorkspaceOptions = {
+		...baseOptions,
+		includeProjects: ["MOCK_DIR/**"],
+		ignoreProjects: ["MOCK_DIR/IGNORE/**", "MOCK_DIR/IGNORE1/**"],
+	};
+	const projects = await ProjectFactory.getProjects(config, "debug");
+	expect(projects).toHaveLength(1);
+	expect(projects[0]?.name).toBe("MOCK_PROJ");
+});
+
+it("ignores projects by exact file path", async () => {
+	vol.fromJSON({
+		"MOCK_DIR/package.json": JSON.stringify({ name: "MOCK_PROJ1" }),
+		"MOCK_DIR/IGNORE/PROJ_1/package.json": JSON.stringify({ name: "MOCK_PROJ2" }),
+		"MOCK_DIR/IGNORE/PROJ_2/package.json": JSON.stringify({ name: "IGNORED" }),
+	});
+
+	const config: WorkspaceOptions = {
+		...baseOptions,
+		includeProjects: ["MOCK_DIR/**"],
+		ignoreProjects: ["MOCK_DIR/IGNORE/PROJ_2/package.json"],
+	};
+	const projects = await ProjectFactory.getProjects(config, "debug");
+	expect(projects).toHaveLength(1);
+	expect(projects.map((p) => p.name)).toEqual(["MOCK_PROJ1"]);
+});
+
+it("excludes package.json nested under another package.json", async () => {
+	vol.fromJSON({
+		"projects/root/package.json": JSON.stringify({ name: "ROOT" }),
+		"projects/root/fixtures/bench/lib-a/package.json": JSON.stringify({ name: "BENCH_A" }),
+		"projects/root/fixtures/bench/lib-b/package.json": JSON.stringify({ name: "BENCH_B" }),
+		"projects/standalone/package.json": JSON.stringify({ name: "STANDALONE" }),
+	});
+
+	const config: WorkspaceOptions = {
+		...baseOptions,
+		includeProjects: ["projects/**/package.json"],
+	};
+	const projects = await ProjectFactory.getProjects(config, "debug");
+
+	expect(projects.map((p) => p.name)).toEqual(["ROOT", "STANDALONE"]);
+});