@shivaedev/quality 0.31.1 → 0.32.1

package/src/hooks/shim.ts

@@ -1,6 +1,6 @@
 import { type HookCommand, shellWords } from "./command.ts";
 
-const OWNER = "# Installed by @shivaedev/quality: `quality hooks install` writes it, `quality hooks uninstall` removes it.";
+export const OWNER = "# Installed by @shivaedev/quality: `quality hooks install` writes it, `quality hooks uninstall` removes it.";
 
 export function isHookShim(text: string): boolean {
 	return text.split("\n").includes(OWNER);
@@ -14,6 +14,8 @@ export function hookShim(directory: string, command: HookCommand): string {
 	return [
 		"#!/bin/sh",
 		OWNER,
+		'if [ -n "$QUALITY_PRE_COMMIT_ACTIVE" ]; then exit 0; fi',
+		"export QUALITY_PRE_COMMIT_ACTIVE=1",
 		'top="$(git rev-parse --show-toplevel)" || exit 2',
 		'if [ -n "$GIT_DIR" ] && [ -z "$GIT_WORK_TREE" ]; then export GIT_WORK_TREE="$top"; fi',
 		'cd "$top" || exit 2',

package/src/hooks/status.ts

@@ -3,8 +3,9 @@ import { access, realpath } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { Console, Effect } from "effect";
 import { GateFailed, SetupFailure } from "#failure.ts";
-import { git, gitOrFail } from "#git/command.ts";
+import { gitOrFail } from "#git/command.ts";
 import { readOptionalText } from "#inventory/filesystem.ts";
+import { forwardingPath, globalHooksPath } from "./forwarding.ts";
 import { type HookLocation, hookLocation } from "./location.ts";
 import { isHookShim } from "./shim.ts";
 
@@ -20,11 +21,7 @@ function executable(file: string) {
 }
 
 export const globalHookStatus = Effect.fn("Hooks.globalHookStatus")(function* (location: HookLocation) {
-	const global = yield* git(location.toplevel, ["config", "--global", "--includes", "--type=path", "--get", "core.hooksPath"]);
-	if (global.code !== 0 && global.code !== 1) {
-		return yield* new SetupFailure({ message: `cannot read global core.hooksPath: ${global.stderr.trim()}` });
-	}
-	const path = global.stdout.trim();
+	const path = yield* globalHooksPath(location.toplevel);
 	const hook = resolve(location.toplevel, path, "pre-commit");
 	const target = path === "" ? undefined : yield* executable(hook);
 	const own = yield* executable(location.file);
@@ -45,6 +42,13 @@ export const hookStatus = Effect.fn("Hooks.hookStatus")(function* (cwd: string)
 		);
 		return yield* new GateFailed();
 	}
+	const global = yield* globalHooksPath(cwd);
+	if (global !== "" && dirname(path) !== resolve(location.toplevel, global) && dirname(path) !== forwardingPath(location.file)) {
+		yield* Console.error(
+			"quality: the repository-local core.hooksPath hides global hooks other than pre-commit.\nhelp: run `quality hooks install` to keep all global hooks running.",
+		);
+		return yield* new GateFailed();
+	}
 	yield* Console.log(`quality: git runs Quality's pre-commit hook at ${path}.`);
 	yield* globalHookStatus(location);
 });

package/src/hooks/uninstall.ts

@@ -3,6 +3,7 @@ import { Console, Effect, FileSystem } from "effect";
 import { SetupFailure } from "#failure.ts";
 import { git, gitOrFail } from "#git/command.ts";
 import { readOptionalText } from "#inventory/filesystem.ts";
+import { forwardingPath, removeForwarding } from "./forwarding.ts";
 import { hookLocation } from "./location.ts";
 import { isHookShim } from "./shim.ts";
 
@@ -18,7 +19,8 @@ export const uninstallHook = Effect.fn("Hooks.uninstallHook")(function* (cwd: st
 	}
 	yield* Effect.mapError(fs.remove(file), (error) => new SetupFailure({ message: `cannot remove ${file}: ${error.message}` }));
 	const local = yield* git(cwd, ["config", "--local", "--get", "core.hooksPath"]);
-	if (local.stdout.trim() === dirname(file)) {
+	yield* removeForwarding(file).pipe(Effect.mapError((error) => new SetupFailure({ message: error.message })));
+	if ([dirname(file), forwardingPath(file)].includes(local.stdout.trim())) {
 		yield* gitOrFail(cwd, ["config", "--local", "--unset-all", "core.hooksPath"]);
 	}
 	yield* Console.log(`quality: removed the pre-commit hook at ${file}.`);

package/src/imports/packageExports.ts

@@ -0,0 +1,55 @@
+export function blockedExport(exports: unknown, subpath: string): boolean {
+	if (typeof exports !== "object" || exports === null || Array.isArray(exports)) {
+		return false;
+	}
+	const entries = Object.entries(exports);
+	const exact = entries.find(([key]) => key === subpath);
+	if (exact !== undefined) {
+		return exact[1] === null;
+	}
+	const matching = entries.filter(([key]) => {
+		const [prefix = "", suffix, ...rest] = key.split("*");
+		return (
+			suffix !== undefined
+			&& rest.length === 0
+			&& subpath.length > prefix.length + suffix.length
+			&& subpath.startsWith(prefix)
+			&& subpath.endsWith(suffix)
+		);
+	});
+	const best = matching.toSorted(([left], [right]) => right.indexOf("*") - left.indexOf("*") || right.length - left.length)[0];
+	return best?.[1] === null;
+}
+
+export function exportTargets(value: unknown): string[] {
+	if (typeof value === "string") {
+		return [value];
+	}
+	return typeof value === "object" && value !== null ? Object.values(value).flatMap(exportTargets) : [];
+}
+
+export function exportedModule(exports: unknown, local: string): boolean {
+	if (typeof exports !== "object" || exports === null) {
+		return false;
+	}
+	const paths = [
+		`./${local}`,
+		`./${local.replace(/^src\//u, "dist/").replace(/\.(?<mode>[cm]?)tsx?$/u, ".$<mode>js")}`,
+		`./${local.replace(/^src\//u, "dist/").replace(/\.(?<mode>[cm]?)tsx?$/u, ".d.$<mode>ts")}`,
+	];
+	return Object.entries(exports).some(([key, value]) =>
+		exportTargets(value).some((target) =>
+			paths.some((path) => {
+				const [prefix = "", suffix] = target.split("*");
+				if (suffix === undefined) {
+					return path === target && !blockedExport(exports, key);
+				}
+				if (!(path.startsWith(prefix) && path.endsWith(suffix)) || path.length <= prefix.length + suffix.length) {
+					return false;
+				}
+				const star = path.slice(prefix.length, path.length - suffix.length);
+				return !blockedExport(exports, key.replace("*", star));
+			}),
+		),
+	);
+}

package/src/imports/publicModules.ts

@@ -0,0 +1,27 @@
+import { posix } from "node:path";
+import type { RuleInputs } from "#rule.ts";
+import type { ImportGraph } from "./graph.ts";
+import { exportedModule } from "./packageExports.ts";
+import { packageOf } from "./workspace.ts";
+
+export async function publicModules(inputs: RuleInputs, graph: ImportGraph): Promise<ReadonlySet<string>> {
+	const exports = new Map(
+		await Promise.all(
+			graph.packages.map(async (owner) => {
+				const manifest: { readonly exports?: unknown } = JSON.parse((await inputs.readText(posix.join(owner.directory, "package.json"))) ?? "");
+				return [owner, manifest.exports] as const;
+			}),
+		),
+	);
+	const modules = new Set<string>();
+	for (const edge of graph.edges) {
+		if (edge.to.kind !== "file") {
+			continue;
+		}
+		const owner = packageOf(graph.packages, edge.to.path);
+		if (owner !== undefined && exportedModule(exports.get(owner), posix.relative(owner.directory, edge.to.path))) {
+			modules.add(edge.to.path);
+		}
+	}
+	return modules;
+}

package/src/rules/imports/bundleInputs.ts

@@ -1,66 +1,11 @@
 import { posix } from "node:path";
 import { outgoing } from "#imports/fences/reach.ts";
 import type { ImportGraph } from "#imports/graph.ts";
+import { blockedExport, exportedModule, exportTargets } from "#imports/packageExports.ts";
 import { packageOf, type WorkspacePackage } from "#imports/workspace.ts";
 
-function blocked(exports: unknown, subpath: string): boolean {
-	if (typeof exports !== "object" || exports === null || Array.isArray(exports)) {
-		return false;
-	}
-	const entries = Object.entries(exports);
-	const exact = entries.find(([key]) => key === subpath);
-	if (exact !== undefined) {
-		return exact[1] === null;
-	}
-	const matching = entries.filter(([key]) => {
-		const [prefix = "", suffix, ...rest] = key.split("*");
-		return (
-			suffix !== undefined
-			&& rest.length === 0
-			&& subpath.length > prefix.length + suffix.length
-			&& subpath.startsWith(prefix)
-			&& subpath.endsWith(suffix)
-		);
-	});
-	const best = matching.toSorted(([left], [right]) => right.indexOf("*") - left.indexOf("*") || right.length - left.length)[0];
-	return best?.[1] === null;
-}
-
-function targets(value: unknown): string[] {
-	if (typeof value === "string") {
-		return [value];
-	}
-	return typeof value === "object" && value !== null ? Object.values(value).flatMap(targets) : [];
-}
-
-function exported(exports: unknown, local: string): boolean {
-	if (typeof exports !== "object" || exports === null) {
-		return false;
-	}
-	const paths = [
-		`./${local}`,
-		`./${local.replace(/^src\//u, "dist/").replace(/\.(?<mode>[cm]?)tsx?$/u, ".$<mode>js")}`,
-		`./${local.replace(/^src\//u, "dist/").replace(/\.(?<mode>[cm]?)tsx?$/u, ".d.$<mode>ts")}`,
-	];
-	return Object.entries(exports).some(([key, value]) =>
-		targets(value).some((target) =>
-			paths.some((path) => {
-				const [prefix = "", suffix] = target.split("*");
-				if (suffix === undefined) {
-					return path === target && !blocked(exports, key);
-				}
-				if (!(path.startsWith(prefix) && path.endsWith(suffix)) || path.length <= prefix.length + suffix.length) {
-					return false;
-				}
-				const star = path.slice(prefix.length, path.length - suffix.length);
-				return !blocked(exports, key.replace("*", star));
-			}),
-		),
-	);
-}
-
 function executable(manifest: object, local: string): boolean {
-	const binTargets = targets(Reflect.get(manifest, "bin"));
+	const binTargets = exportTargets(Reflect.get(manifest, "bin"));
 	const built = local.replace(/^src\//u, "dist/").replace(/\.(?<mode>[cm]?)tsx?$/u, ".$<mode>js");
 	return binTargets.some((target) => typeof target === "string" && [local, built].includes(posix.normalize(target)));
 }
@@ -72,8 +17,8 @@ export function bundleInputs(graph: ImportGraph, owner: WorkspacePackage, manife
 			const local = posix.relative(owner.directory, path);
 			return (
 				local.startsWith("src/")
-				&& blocked(Reflect.get(manifest, "exports"), `./${local.slice(4)}`)
-				&& !exported(Reflect.get(manifest, "exports"), local)
+				&& blockedExport(Reflect.get(manifest, "exports"), `./${local.slice(4)}`)
+				&& !exportedModule(Reflect.get(manifest, "exports"), local)
 			);
 		}),
 	);

package/src/rules/stories/supportImports.ts

@@ -1,5 +1,6 @@
 import { Effect, Schema } from "effect";
 import { importGraph } from "#imports/graph.ts";
+import { publicModules } from "#imports/publicModules.ts";
 import { isTestSupport } from "#naming/testName.ts";
 import { defineRule } from "#rule.ts";
 import { matchesAny } from "./matchesAny.ts";
@@ -14,18 +15,24 @@ export const supportImports = defineRule({
 			return [];
 		}
 		const graph = await importGraph(inputs);
+		const exported = await publicModules(inputs, graph);
 		return graph.edges
 			.filter(
-				(edge) => isTestSupport(edge.from) && edge.to.kind === "file" && !isTestSupport(edge.to.path) && !matchesAny(edge.to.path, options.modules),
+				(edge) =>
+					isTestSupport(edge.from)
+					&& edge.to.kind === "file"
+					&& !isTestSupport(edge.to.path)
+					&& !exported.has(edge.to.path)
+					&& !matchesAny(edge.to.path, options.modules),
 			)
 			.map((edge) => ({
 				file: edge.from,
 				line: edge.line,
-				message: `Test-support imports "${edge.specifier}" outside its allowed public surface. Drive the app through its host, schemas or queue definitions; list those public module paths in tests/support-imports.options.modules in the repository's quality config.`,
+				message: `Test-support imports "${edge.specifier}" outside its allowed public surface. Drive the app through its host, schemas or queue definitions, or a workspace package's exports; list additional internal module paths in tests/support-imports.options.modules in the repository's quality config.`,
 				subject: edge.specifier,
 			}));
 	},
-	description: "Test-support reaches repository modules only through the public surface named by the repository's module allowlist.",
+	description: "Test-support reaches repository modules through workspace package exports and the repository's additional module allowlist.",
 	id: "tests/support-imports",
 	options: Schema.toStandardSchemaV1(SupportImportsOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
 });