@raresportan/marram 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raresportan/marram",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The gate, ratchet lints and journeys that keep agent-written code from drifting.",
   "license": "MIT",
   "type": "module",

package/src/core/boundaries.mjs

@@ -4,8 +4,11 @@
 // A project names its layers by folder pattern (`features/*/client`, `*` being one folder). A file may import from its
 // own layer and from the layers it lists. It may reach another feature (`features/<name>`) only through an `index.ts`:
 // the feature's own, or that of one of its sides, as an app's main process needs its host and its renderer its client,
-// and one index for both would pull the host into the renderer. Only a layer with `builtins: true` may import `node:` modules or `electron`. Existing violations go on a
-// ratchet list, by `file -> import`.
+// and one index for both would pull the host into the renderer. An index only opens the feature: the side it belongs
+// to must still be a layer the file may import. A file in no layer, such as a feature's own index, is no way around
+// that: importing it counts as importing what it imports. Only a layer with `builtins: true` may import Node's modules,
+// as `node:fs` or `fs`, or `electron`. Existing violations go on a ratchet list, by `file -> import`.
+import { isBuiltin } from "node:module";
 import { dirname, relative, resolve, sep } from "node:path";
 import ts from "typescript";
 import { lineOf, parse, ratchet, sourceFiles } from "./ratchet.mjs";
@@ -31,21 +34,36 @@ const featureOf = (path) => /^(features\/[^/]+)(\/|$)/.exec(path)?.[1];
 /** A feature's way in: its folder's `index.ts`, or the `index.ts` of one of its sides (`host/index.ts`, `client/index.ts`). */
 const isEntry = (target, feature) => target === feature || /^features\/[^/]+(\/[^/]+)?\/index(\.tsx?)?$/.test(target);
 
-const isBuiltin = (specifier) => specifier === "electron" || specifier.startsWith("node:");
+const needsHost = (specifier) => /^electron(\/|$)/.test(specifier) || specifier.startsWith("node:") || isBuiltin(specifier);
 
-/** What's wrong with `from` (a path from the folder) importing `specifier`, if anything. */
-function problem(from, specifier, layers) {
-	const mine = layerOf(from, layers);
-	if (isBuiltin(specifier)) return layers[mine?.pattern]?.builtins === true || mine === undefined ? undefined : `${mine.pattern} may not import ${specifier}, which needs a host`;
+/** The source file an import's target (a path from the folder) means, however it's spelled, if it's one of `sources`. */
+const fileOf = (target, sources) => [target, target.replace(/\.jsx?$/, ".ts"), target.replace(/\.jsx?$/, ".tsx"), `${target}.ts`, `${target}.tsx`, `${target}/index.ts`, `${target}/index.tsx`].find((path) => sources.has(path));
+
+/** What's wrong with `from` (a path from the folder) importing `specifier`, if anything, for a file in the layer `mine`. */
+function problem(from, specifier, layers, sources, mine = layerOf(from, layers), seen = new Set()) {
+	if (needsHost(specifier)) return layers[mine?.pattern]?.builtins === true || mine === undefined ? undefined : `${mine.pattern} may not import ${specifier}, which needs a host`;
 	if (!specifier.startsWith(".")) return undefined;
 	const target = posix(relative(".", resolve(dirname(from), specifier)));
 	const theirFeature = featureOf(target);
-	if (theirFeature !== undefined && theirFeature !== featureOf(from)) return isEntry(target, theirFeature) ? undefined : `reaches inside ${theirFeature}: import an index.ts`;
+	if (theirFeature !== undefined && theirFeature !== featureOf(from) && !isEntry(target, theirFeature)) return `reaches inside ${theirFeature}: import an index.ts`;
 	const theirs = layerOf(target, layers);
-	if (mine === undefined || theirs === undefined || theirs.pattern === mine.pattern) return undefined;
+	if (mine === undefined) return undefined;
+	if (theirs === undefined) return throughFile(fileOf(target, sources), layers, sources, mine, seen);
+	if (theirs.pattern === mine.pattern) return undefined;
 	return (layers[mine.pattern].may ?? []).includes(theirs.pattern) ? undefined : `${mine.pattern} may not import from ${theirs.pattern}`;
 }
 
+/** What's wrong with a file in the layer `mine` importing `file`, which is in no layer: the first of `file`'s imports it may not have. */
+function throughFile(file, layers, sources, mine, seen) {
+	if (file === undefined || seen.has(file)) return undefined;
+	seen.add(file);
+	for (const specifier of imports(parse(sources.get(file)))) {
+		const wrong = problem(file, specifier.text, layers, sources, mine, seen);
+		if (wrong !== undefined) return `${wrong} (through ${file})`;
+	}
+	return undefined;
+}
+
 /** Import specifiers in `source`, including `export … from` and `import()`, each with its node; types count too. */
 function imports(source) {
 	const found = [];
@@ -64,11 +82,13 @@ function imports(source) {
  */
 export function importBoundaries({ root, folder, layers, allowed = {}, list }) {
 	const base = resolve(root, folder);
-	const found = sourceFiles(base).flatMap((file) => {
+	const files = sourceFiles(base);
+	const sources = new Map(files.map((file) => [posix(relative(base, file)), file]));
+	const found = files.flatMap((file) => {
 		const source = parse(file);
 		const from = posix(relative(base, file));
 		return imports(source).flatMap((specifier) => {
-			const wrong = problem(from, specifier.text, layers);
+			const wrong = problem(from, specifier.text, layers, sources);
 			return wrong === undefined ? [] : [{ key: `${from} -> ${specifier.text}`, at: `${folder}/${from}:${lineOf(source, specifier)}`, what: wrong }];
 		});
 	});