@rsdk/yarn.constraints 6.0.0-next.40 → 6.0.0-next.41

package/src/collectors/config.ts

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import yaml from 'yaml';
 
+import { assertValidDependencyModelConfig } from '../model/config-validation';
 import type { DependencyModelConfig } from '../model/types';
 
 export function loadConfig(
@@ -22,5 +23,11 @@ export function loadConfig(
 
   if (!existsSync(filepath)) return { rules: [] };
 
-  return yaml.parse(readFileSync(filepath, 'utf8')) as DependencyModelConfig;
+  const config = yaml.parse(
+    readFileSync(filepath, 'utf8'),
+  ) as DependencyModelConfig;
+
+  assertValidDependencyModelConfig(config);
+
+  return config;
 }

package/src/collectors/workspaces.ts

@@ -9,7 +9,11 @@ import { execSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 
-import { collectDtsImports, collectSourceImports } from '../lib/imports';
+import {
+  collectDtsImports,
+  collectSourceFiles,
+  collectSourceImportsFromFiles,
+} from '../lib/imports';
 import { readPackageJson } from '../lib/package-json';
 import { isWorkspaceRole } from '../model/rules';
 import type { WorkspaceContext } from '../model/types';
@@ -20,7 +24,11 @@ interface YarnWorkspaceInfo {
 }
 
 function collectUsage(workspace: WorkspaceContext, withDts: boolean): void {
-  for (const entry of collectSourceImports(workspace.dir, workspace.pkg)) {
+  const sourceFiles = collectSourceFiles(workspace.dir, workspace.pkg);
+
+  workspace.sourceFileCount = sourceFiles.length;
+
+  for (const entry of collectSourceImportsFromFiles(sourceFiles)) {
     if (!workspace.sourceUsage.has(entry.packageName)) {
       workspace.sourceUsage.set(entry.packageName, {
         files: new Set(),

package/src/lib/imports.ts

@@ -18,6 +18,11 @@ export interface ImportEntry {
   file: string;
 }
 
+interface ModuleReference {
+  specifier: string;
+  isTypeOnly: boolean;
+}
+
 const BUILTINS = new Set([
   ...builtinModules,
   ...builtinModules.map((m) => `node:${m}`),
@@ -35,6 +40,19 @@ const SOURCE_EXTENSIONS = new Set([
 ]);
 
 const DTS_RE = /\.d\.(?:c|m)?ts$/;
+const DEFAULT_SOURCE_ROOTS = ['src', 'test', 'tests', '__tests__'];
+const IGNORED_ENTRYPOINT_DIRS = new Set([
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+]);
+const IGNORED_WALK_DIRS = new Set([
+  'node_modules',
+  'fixtures',
+  '__fixtures__',
+  '__mocks__',
+]);
 
 export function getPackageName(specifier: string): string | null {
   if (
@@ -62,7 +80,7 @@ function walkFiles(dir: string, filter: (name: string) => boolean): string[] {
   try {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const full = path.join(dir, entry.name);
-      if (entry.isDirectory() && entry.name !== 'node_modules') {
+      if (entry.isDirectory() && !IGNORED_WALK_DIRS.has(entry.name)) {
         results.push(...walkFiles(full, filter));
       } else if (entry.isFile() && filter(entry.name)) {
         results.push(full);
@@ -74,6 +92,22 @@ function walkFiles(dir: string, filter: (name: string) => boolean): string[] {
   return results;
 }
 
+function isInside(parent: string, child: string): boolean {
+  const relative = path.relative(parent, child);
+
+  return (
+    relative !== '' &&
+    !relative.startsWith('..') &&
+    !path.isAbsolute(relative)
+  );
+}
+
+function startsWithIgnoredEntrypointDir(relative: string): boolean {
+  const [first] = relative.split('/');
+
+  return first !== undefined && IGNORED_ENTRYPOINT_DIRS.has(first);
+}
+
 function isSourceFile(name: string): boolean {
   return SOURCE_EXTENSIONS.has(path.extname(name)) && !DTS_RE.test(name);
 }
@@ -105,6 +139,15 @@ function addImport(
   results.push({ packageName, isTypeOnly, file });
 }
 
+function addModuleReference(
+  results: ModuleReference[],
+  specifier: string | null,
+  isTypeOnly: boolean,
+): void {
+  if (!specifier) return;
+  results.push({ specifier, isTypeOnly });
+}
+
 function isImportDeclarationTypeOnly(node: ts.ImportDeclaration): boolean {
   const clause = node.importClause;
   if (!clause) return false;
@@ -136,12 +179,12 @@ function collectExternalModuleReference(
   return stringLiteralText(node.expression);
 }
 
-function extractImports(
+function extractModuleReferences(
   file: string,
   content: string,
   options: { includeDtsForms?: boolean } = {},
-): ImportEntry[] {
-  const results: ImportEntry[] = [];
+): ModuleReference[] {
+  const results: ModuleReference[] = [];
   const sourceFile = ts.createSourceFile(
     file,
     content,
@@ -152,25 +195,21 @@ function extractImports(
 
   if (options.includeDtsForms) {
     for (const reference of sourceFile.typeReferenceDirectives) {
-      addImport(results, file, reference.fileName, true);
+      addModuleReference(results, reference.fileName, true);
     }
   }
 
   const visit = (node: ts.Node): void => {
     if (ts.isImportDeclaration(node)) {
       const specifier = stringLiteralText(node.moduleSpecifier);
-      if (specifier) {
-        addImport(results, file, specifier, isImportDeclarationTypeOnly(node));
-      }
+      addModuleReference(results, specifier, isImportDeclarationTypeOnly(node));
     } else if (ts.isExportDeclaration(node)) {
       const specifier = stringLiteralText(node.moduleSpecifier);
-      if (specifier) {
-        addImport(results, file, specifier, isExportDeclarationTypeOnly(node));
-      }
+      addModuleReference(results, specifier, isExportDeclarationTypeOnly(node));
     } else if (ts.isImportEqualsDeclaration(node)) {
       if (ts.isExternalModuleReference(node.moduleReference)) {
         const specifier = collectExternalModuleReference(node.moduleReference);
-        if (specifier) addImport(results, file, specifier, node.isTypeOnly);
+        addModuleReference(results, specifier, node.isTypeOnly);
       }
     } else if (ts.isCallExpression(node)) {
       if (
@@ -178,27 +217,27 @@ function extractImports(
         node.arguments.length === 1
       ) {
         const specifier = stringLiteralText(node.arguments[0]);
-        if (specifier) addImport(results, file, specifier, false);
+        addModuleReference(results, specifier, false);
       } else if (
         ts.isIdentifier(node.expression) &&
         node.expression.text === 'require' &&
         node.arguments.length === 1
       ) {
         const specifier = stringLiteralText(node.arguments[0]);
-        if (specifier) addImport(results, file, specifier, false);
+        addModuleReference(results, specifier, false);
       }
     } else if (ts.isImportTypeNode(node)) {
       const argument = node.argument;
       if (ts.isLiteralTypeNode(argument)) {
         const specifier = stringLiteralText(argument.literal);
-        if (specifier) addImport(results, file, specifier, true);
+        addModuleReference(results, specifier, true);
       }
     } else if (
       options.includeDtsForms &&
       ts.isModuleDeclaration(node) &&
       ts.isStringLiteral(node.name)
     ) {
-      addImport(results, file, node.name.text, true);
+      addModuleReference(results, node.name.text, true);
     }
 
     ts.forEachChild(node, visit);
@@ -208,6 +247,20 @@ function extractImports(
   return results;
 }
 
+function extractImports(
+  file: string,
+  content: string,
+  options: { includeDtsForms?: boolean } = {},
+): ImportEntry[] {
+  const results: ImportEntry[] = [];
+
+  for (const reference of extractModuleReferences(file, content, options)) {
+    addImport(results, file, reference.specifier, reference.isTypeOnly);
+  }
+
+  return results;
+}
+
 function collectEntrypointStrings(value: unknown, result: Set<string>): void {
   if (typeof value === 'string') {
     result.add(value);
@@ -243,39 +296,128 @@ function getPackageEntrypointFiles(
     const full = path.resolve(workspaceDir, candidate);
     const relative = path.relative(workspaceDir, full);
     if (relative.startsWith('..') || path.isAbsolute(relative)) continue;
+    const normalized = relative.split(path.sep).join('/');
+    if (startsWithIgnoredEntrypointDir(normalized)) continue;
     if (!existsSync(full) || !isSourceFile(full)) continue;
 
-    const normalized = relative.split(path.sep).join('/');
-    const isSrc = normalized.startsWith('src/');
-    const isRoot = !normalized.includes('/');
-    if (isSrc || isRoot) result.add(full);
+    result.add(full);
   }
 
   return [...result];
 }
 
-export function collectSourceImports(
+function isRelativeSpecifier(specifier: string): boolean {
+  return specifier.startsWith('./') || specifier.startsWith('../');
+}
+
+function getJsToTsCandidates(file: string): string[] {
+  const ext = path.extname(file);
+  const withoutExt = file.slice(0, -ext.length);
+
+  if (ext === '.js') return [`${withoutExt}.ts`, `${withoutExt}.tsx`, file];
+  if (ext === '.jsx') return [`${withoutExt}.tsx`, file];
+  if (ext === '.mjs') return [`${withoutExt}.mts`, file];
+  if (ext === '.cjs') return [`${withoutExt}.cts`, file];
+
+  return [file];
+}
+
+function resolveRelativeSourceFile(
+  workspaceDir: string,
+  importer: string,
+  specifier: string,
+): string | null {
+  const target = path.resolve(path.dirname(importer), specifier);
+  const candidates: string[] = [];
+  const ext = path.extname(target);
+
+  if (ext) {
+    candidates.push(...getJsToTsCandidates(target));
+  } else {
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.push(`${target}${sourceExt}`);
+    }
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.push(path.join(target, `index${sourceExt}`));
+    }
+  }
+
+  for (const candidate of candidates) {
+    if (!isInside(workspaceDir, candidate)) continue;
+    if (existsSync(candidate) && isSourceFile(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function collectEntrypointGraphFiles(
+  workspaceDir: string,
+  pkg: PackageJson,
+): string[] {
+  const result = new Set<string>();
+  const stack = getPackageEntrypointFiles(workspaceDir, pkg);
+
+  while (stack.length > 0) {
+    const file = stack.pop()!;
+    if (result.has(file)) continue;
+    result.add(file);
+
+    for (const reference of extractModuleReferences(
+      file,
+      readFileSync(file, 'utf8'),
+    )) {
+      if (!isRelativeSpecifier(reference.specifier)) continue;
+      const resolved = resolveRelativeSourceFile(
+        workspaceDir,
+        file,
+        reference.specifier,
+      );
+      if (resolved && !result.has(resolved)) stack.push(resolved);
+    }
+  }
+
+  return [...result];
+}
+
+export function collectSourceFiles(
   srcDirOrWorkspaceDir: string,
   pkg?: PackageJson,
-): ImportEntry[] {
-  const srcDir = pkg
-    ? path.join(srcDirOrWorkspaceDir, 'src')
-    : srcDirOrWorkspaceDir;
-  const files = new Set(
-    walkFiles(srcDir, (name) => isSourceFile(name)),
-  );
+): string[] {
+  if (!pkg) return walkFiles(srcDirOrWorkspaceDir, (name) => isSourceFile(name));
+
+  const files = new Set<string>();
 
-  if (pkg) {
-    for (const file of getPackageEntrypointFiles(srcDirOrWorkspaceDir, pkg)) {
+  for (const sourceRoot of DEFAULT_SOURCE_ROOTS) {
+    for (const file of walkFiles(
+      path.join(srcDirOrWorkspaceDir, sourceRoot),
+      (name) => isSourceFile(name),
+    )) {
       files.add(file);
     }
   }
 
-  return [...files].flatMap((file) =>
+  for (const file of collectEntrypointGraphFiles(srcDirOrWorkspaceDir, pkg)) {
+    files.add(file);
+  }
+
+  return [...files].sort();
+}
+
+export function collectSourceImportsFromFiles(files: string[]): ImportEntry[] {
+  return files.flatMap((file) =>
     extractImports(file, readFileSync(file, 'utf8')),
   );
 }
 
+export function collectSourceImports(
+  srcDirOrWorkspaceDir: string,
+  pkg?: PackageJson,
+): ImportEntry[] {
+  return collectSourceImportsFromFiles(
+    collectSourceFiles(srcDirOrWorkspaceDir, pkg),
+  );
+}
+
 export function collectDtsImports(distDir: string): Set<string> {
   const files = walkFiles(distDir, (name) => DTS_RE.test(name));
   const result = new Set<string>();

package/src/model/config-validation.ts

@@ -0,0 +1,49 @@
+/**
+ * Config validation for rule shapes that the model cannot interpret safely.
+ */
+import type { DependencyModelConfig, DependencyRule } from './types';
+
+function getRuleMatches(rule: DependencyRule): string[] {
+  return Array.isArray(rule.match) ? rule.match : [rule.match];
+}
+
+function getRuleLabel(rule: DependencyRule, index: number): string {
+  return `rules[${index}] (${getRuleMatches(rule).join(', ')})`;
+}
+
+export function validateDependencyRules(rules: DependencyRule[]): string[] {
+  const errors: string[] = [];
+
+  rules.forEach((rule, index) => {
+    const label = getRuleLabel(rule, index);
+    const matches = getRuleMatches(rule);
+
+    if (rule.required === true && matches.some((match) => match.includes('*'))) {
+      errors.push(
+        `${label}: required: true requires concrete match patterns; wildcard matches are ignored by required dependency expansion`,
+      );
+    }
+
+    if (rule.section === 'devDependencies' && rule.rootOnly !== true) {
+      errors.push(
+        `${label}: section: devDependencies is only supported together with rootOnly: true; workspace devDependencies are derived by the model`,
+      );
+    }
+  });
+
+  return errors;
+}
+
+export function assertValidDependencyModelConfig(
+  config: DependencyModelConfig,
+): void {
+  const errors = validateDependencyRules(config.rules ?? []);
+
+  if (errors.length === 0) return;
+
+  throw new Error(
+    ['Invalid dependency constraints config:', ...errors.map((e) => `- ${e}`)].join(
+      '\n',
+    ),
+  );
+}

package/src/model/diagnostics.ts

@@ -32,6 +32,21 @@ function collectActualDependencyNames(workspace: WorkspaceFacts): Set<string> {
   );
 }
 
+function hasExternalCollectedUsage(
+  workspace: WorkspaceFacts,
+  workspaceNames: Set<string>,
+): boolean {
+  for (const depIdent of workspace.sourceUsage.keys()) {
+    if (isExternal(depIdent, workspaceNames)) return true;
+  }
+
+  for (const depIdent of workspace.dtsImports) {
+    if (isExternal(depIdent, workspaceNames)) return true;
+  }
+
+  return false;
+}
+
 export function compareManifest(
   expected: ExpectedWorkspace,
   violations: DependencyViolation[],
@@ -181,6 +196,21 @@ export function validateBasicShape(
       });
     }
 
+    if (
+      workspace.role &&
+      workspace.sourceFileCount !== undefined &&
+      workspace.sourceFileCount > 0 &&
+      !hasExternalCollectedUsage(workspace, workspaceNames)
+    ) {
+      warnings.push({
+        code: 'zero-external-dependencies',
+        workspace: getWorkspaceLabel(workspace),
+        workspaceLocation: workspace.location,
+        message:
+          `no external source imports were collected from ${workspace.sourceFileCount} source file(s); check source roots and entrypoints before trusting autofix`,
+      });
+    }
+
     if (workspace.hasSrc && !workspace.hasDist && withDts) {
       violations.push({
         code: 'dist-missing',

package/src/model/placement.ts

@@ -71,7 +71,7 @@ function addPublicDependency(
   rules: DependencyRule[],
   depIdent: string,
   reason: Reason,
-  options: { allowRootOnly?: boolean } = {},
+  options: { allowRootOnly?: boolean; rootOnlyRequired?: boolean } = {},
 ): void {
   const workspace = expected.workspace;
   const rule = getEffectiveRule(
@@ -88,15 +88,20 @@ function addPublicDependency(
   addRuleReason(expected, depIdent, rule);
 
   if (rule.rootOnly && !isLocal && !options.allowRootOnly) {
+    addRuleReason(rootExpected, depIdent, rule);
     setExpectedDependency(rootExpected, 'devDependencies', depIdent, range, {
-      kind: 'root-only',
-      detail: `${depIdent} is marked rootOnly`,
+      kind: options.rootOnlyRequired ? reason.kind : 'root-only',
+      detail: options.rootOnlyRequired
+        ? `${reason.detail} for ${workspace.name}; rootOnly keeps it in root devDependencies`
+        : `${depIdent} is marked rootOnly`,
     });
     addReason(expected, depIdent, reason);
-    addReason(expected, depIdent, {
-      kind: 'root-only',
-      detail: `${depIdent} is marked rootOnly and cannot be used by ${workspace.name}`,
-    });
+    if (!options.rootOnlyRequired) {
+      addReason(expected, depIdent, {
+        kind: 'root-only',
+        detail: `${depIdent} is marked rootOnly and cannot be used by ${workspace.name}`,
+      });
+    }
     return;
   }
 
@@ -326,6 +331,7 @@ export function addRequiredRuleDependencies(
           kind: 'required-rule',
           detail: `${depIdent} is marked required by dependency rule`,
         },
+        { rootOnlyRequired: rule.rootOnly },
       );
     }
   }

package/src/model/rules.ts

@@ -66,6 +66,18 @@ export function hasGlobalVersionRule(
   );
 }
 
+export function hasWorkspaceVersionRule(
+  rules: DependencyRule[],
+  depIdent: string,
+): boolean {
+  return rules.some(
+    (rule) =>
+      rule.workspace &&
+      rule.version !== undefined &&
+      matchesPatterns(depIdent, rule.match),
+  );
+}
+
 export function isWorkspaceRole(
   value: string | undefined,
 ): value is WorkspaceRole {

package/src/model/types.ts

@@ -69,7 +69,7 @@ export interface DependencyViolation {
 }
 
 export interface DependencyWarning {
-  code: 'bin-role-mismatch';
+  code: 'bin-role-mismatch' | 'zero-external-dependencies';
   workspace?: string | undefined;
   workspaceLocation?: string | undefined;
   dependency?: string | undefined;
@@ -92,6 +92,7 @@ export interface WorkspaceFacts {
   dtsImports: Set<string>;
   hasSrc: boolean;
   hasDist: boolean;
+  sourceFileCount?: number;
 }
 
 export interface WorkspaceContext extends WorkspaceFacts {

package/src/model/versions.ts

@@ -7,7 +7,7 @@
  */
 import { addReason } from './expected';
 import { isExternal, resolveExpectedRangeAfterRulePass } from './placement';
-import { hasGlobalVersionRule } from './rules';
+import { hasGlobalVersionRule, hasWorkspaceVersionRule } from './rules';
 import type {
   DependencyRule,
   DependencyViolation,
@@ -97,13 +97,18 @@ export function collectUnconstrainedVersionViolations(
     )
     .map(([depIdent, byOccurrence]) => {
       const rangeList = [...(ranges.get(depIdent) ?? [])].join(', ');
+      const occurrencesList = [...byOccurrence].sort().join(', ');
+      const workspaceRuleHint = hasWorkspaceVersionRule(rules, depIdent)
+        ? '; workspace-scoped version rules do not satisfy V1'
+        : '';
 
       return {
         code: 'unconstrained-version' as const,
         workspace: '<root>',
         workspaceLocation: '.',
         dependency: depIdent,
-        message: `${depIdent} appears ${byOccurrence.size} times without a global version rule (${rangeList})`,
+        message:
+          `${depIdent} appears ${byOccurrence.size} times without a global version rule (${rangeList}); occurrences: ${occurrencesList}${workspaceRuleHint}`,
       };
     });
 }