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

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"]);
+});

package/tests/source-extensions.spec.ts

@@ -0,0 +1,33 @@
+import { sourceExtensions } from "@decohere/workspace";
+import { describe, expect, it } from "vitest";
+
+describe("sourceExtensions (#518)", () => {
+	it("maps an import's extension to the sources it can name", () => {
+		expect(sourceExtensions.candidates("/a/b.js")).toEqual(["/a/b.ts", "/a/b.tsx"]);
+		expect(sourceExtensions.candidates("/a/b.mjs")).toEqual(["/a/b.mts"]);
+		expect(sourceExtensions.candidates("/a/b.cjs")).toEqual(["/a/b.cts"]);
+		expect(sourceExtensions.candidates("/a/b.jsx")).toEqual(["/a/b.tsx"]);
+		expect(sourceExtensions.candidates("/a/b")).toEqual(["/a/b.ts", "/a/b.tsx"]);
+		expect(sourceExtensions.candidates("/a/b.mts")).toEqual(["/a/b.mts"]);
+	});
+
+	it("treats declaration files as not sources", () => {
+		expect(sourceExtensions.isSource("/a/b.ts")).toBe(true);
+		expect(sourceExtensions.isSource("/a/b.tsx")).toBe(true);
+		expect(sourceExtensions.isSource("/a/b.d.ts")).toBe(false);
+		expect(sourceExtensions.isSource("/a/b.d.mts")).toBe(false);
+	});
+
+	it("names build output and module kind by source extension", () => {
+		expect(sourceExtensions.outputExtension("/a/b.mts")).toBe(".mjs");
+		expect(sourceExtensions.outputExtension("/a/b.cts")).toBe(".cjs");
+		expect(sourceExtensions.outputExtension("/a/b.tsx")).toBe(".js");
+		expect(sourceExtensions.outputPath("src/a.mts")).toBe("src/a.mjs");
+		expect(sourceExtensions.outputPath("src/a.cts")).toBe("src/a.cjs");
+		expect(sourceExtensions.outputPath("src/a.tsx")).toBe("src/a.js");
+		expect(sourceExtensions.outputPath("src/a.ts")).toBe("src/a.js");
+		expect(sourceExtensions.outputPath("bin/cli")).toBe("bin/cli.js");
+		expect(sourceExtensions.isCommonJs("/a/b.cts")).toBe(true);
+		expect(sourceExtensions.isCommonJs("/a/b.mts")).toBe(false);
+	});
+});