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

package/src/collectors/type-providers.ts

@@ -0,0 +1,51 @@
+/**
+ * DefinitelyTyped provider collector.
+ *
+ * The engine needs to know which `@types/*` packages are available for public
+ * `.d.ts` promotion. This module gathers that set from installed packages, root
+ * devDependencies, and explicit non-wildcard rules.
+ */
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+
+import type { PackageJson } from '../lib/package-json';
+import type { DependencyRule } from '../model/types';
+
+function collectInstalledTypeProviders(rootDir: string): Set<string> {
+  const result = new Set<string>();
+  const typesDir = path.join(rootDir, 'node_modules', '@types');
+
+  try {
+    for (const entry of readdirSync(typesDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) result.add(`@types/${entry.name}`);
+    }
+  } catch {
+    // node_modules may not exist yet; root devDeps and rules still contribute.
+  }
+
+  return result;
+}
+
+export function collectTypeProviderPackages(
+  rootDir: string,
+  rootPkg: PackageJson,
+  rules: DependencyRule[],
+): Set<string> {
+  const result = collectInstalledTypeProviders(rootDir);
+
+  for (const depIdent of Object.keys(rootPkg.devDependencies ?? {})) {
+    if (depIdent.startsWith('@types/')) result.add(depIdent);
+  }
+
+  for (const rule of rules) {
+    const patterns = Array.isArray(rule.match) ? rule.match : [rule.match];
+
+    for (const pattern of patterns) {
+      if (pattern.startsWith('@types/') && !pattern.includes('*')) {
+        result.add(pattern);
+      }
+    }
+  }
+
+  return result;
+}

package/src/collectors/workspaces.ts

@@ -0,0 +1,107 @@
+/**
+ * Workspace and usage collector.
+ *
+ * This module discovers Yarn workspaces, reads their manifests, and attaches
+ * source/`.d.ts` import usage facts. It is deliberately outside the engine
+ * because it executes Yarn and reads the filesystem.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+import {
+  collectDtsImports,
+  collectSourceFiles,
+  collectSourceImportsFromFiles,
+} from '../lib/imports';
+import { readPackageJson } from '../lib/package-json';
+import { isWorkspaceRole } from '../model/rules';
+import type { WorkspaceContext } from '../model/types';
+
+interface YarnWorkspaceInfo {
+  location: string;
+  name: string | null;
+}
+
+function collectUsage(workspace: WorkspaceContext, withDts: boolean): void {
+  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(),
+        runtimeFiles: new Set(),
+        typeOnlyFiles: new Set(),
+      });
+    }
+    const usage = workspace.sourceUsage.get(entry.packageName)!;
+
+    usage.files.add(entry.file);
+    if (entry.isTypeOnly) {
+      usage.typeOnlyFiles.add(entry.file);
+    } else {
+      usage.runtimeFiles.add(entry.file);
+    }
+  }
+
+  const distDir = path.join(workspace.dir, 'dist');
+  if (withDts || existsSync(distDir)) {
+    workspace.dtsImports = collectDtsImports(distDir);
+  }
+}
+
+export function loadWorkspaces(
+  rootDir: string,
+  withDts: boolean,
+): WorkspaceContext[] {
+  const rootPkg = readPackageJson(rootDir);
+  const raw = execSync('yarn workspaces list --json', {
+    cwd: rootDir,
+  }).toString();
+  const listed = raw
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as YarnWorkspaceInfo)
+    .filter((ws) => ws.location !== '.');
+
+  const root: WorkspaceContext = {
+    name: rootPkg.name,
+    location: '.',
+    dir: rootDir,
+    pkg: rootPkg,
+    role: undefined,
+    isRoot: true,
+    sourceUsage: new Map(),
+    dtsImports: new Set(),
+    hasSrc: false,
+    hasDist: false,
+  };
+
+  const workspaces: WorkspaceContext[] = [root];
+
+  for (const ws of listed) {
+    const dir = path.join(rootDir, ws.location);
+    const pkg = readPackageJson(dir);
+    const role = isWorkspaceRole(pkg.role) ? pkg.role : undefined;
+    const ctx: WorkspaceContext = {
+      name: ws.name ?? pkg.name,
+      location: ws.location,
+      dir,
+      pkg,
+      role,
+      isRoot: false,
+      sourceUsage: new Map(),
+      dtsImports: new Set(),
+      hasSrc: existsSync(path.join(dir, 'src')),
+      hasDist: existsSync(path.join(dir, 'dist')),
+    };
+
+    collectUsage(ctx, withDts);
+    workspaces.push(ctx);
+  }
+
+  return workspaces;
+}

package/src/dependency-model.ts

@@ -0,0 +1,26 @@
+/**
+ * Public dependency-model facade.
+ *
+ * Historically this file contained the whole implementation. It now keeps the
+ * public import path stable while delegating to focused modules: the pure model
+ * engine, the filesystem/Yarn runner, and CLI reporting helpers.
+ */
+export { deriveDependencyModel } from './model/engine';
+export { runDependencyModel } from './runner';
+export { explainDependency, formatDependencyModelResult } from './reporting';
+
+export type {
+  DependencyModelConfig,
+  DependencyModelFacts,
+  DependencyModelOptions,
+  DependencyModelOutput,
+  DependencyModelResult,
+  DependencyRule,
+  DependencyViolation,
+  DependencyWarning,
+  ExpectedWorkspace,
+  SectionType,
+  UsageSummary,
+  WorkspaceFacts,
+  WorkspaceRole,
+} from './model/types';

package/src/index.ts

@@ -1,46 +1,29 @@
-import { Value } from '@sinclair/typebox/value';
-import type { Yarn } from '@yarnpkg/types';
-import type { Constraints } from '@yarnpkg/types/lib/yarn';
-import { access, constants, readFile } from 'node:fs/promises';
-import yaml from 'yaml';
+/**
+ * Package public API.
+ *
+ * Consumers should import from this barrel instead of reaching into the model,
+ * runner, or collector internals. The split modules remain implementation
+ * details unless explicitly exported here.
+ */
+export {
+  deriveDependencyModel,
+  runDependencyModel,
+  formatDependencyModelResult,
+  explainDependency,
+} from './dependency-model';
 
-import { ConstraintSchema } from './constraint-schema';
-import { DependencyChecker } from './dependency-checker';
-
-const constraintsManifestPath =
-  process.env.RSDK_YARN_CONSTRAINTS_CFG ?? './.rsdk/.constraints.yml';
-
-export const createConstraints =
-  (overrideConfig?: Yarn.Config) =>
-  async (ctx: Constraints.Context): Promise<void> => {
-    const { Yarn } = ctx;
-
-    await access(constraintsManifestPath, constants.R_OK);
-    const constraints = yaml.parse(
-      await readFile(constraintsManifestPath, 'utf8'),
-    );
-    const isValid = Value.Check(ConstraintSchema, constraints);
-    if (!isValid) {
-      const cause = [...Value.Errors(ConstraintSchema, constraints)];
-
-      throw new Error(
-        'Invalid constraints.yml\n' + JSON.stringify(cause, null, 2),
-        {
-          cause: cause,
-        },
-      );
-    }
-    new DependencyChecker(Yarn).enforceConsistentDependenciesAcrossTheProject(
-      constraints,
-    );
-    overrideConfig?.constraints?.(ctx);
-  };
-
-export const config: Yarn.Config = {
-  constraints: createConstraints(),
-};
-
-export const override = (config: Yarn.Config): Yarn.Config => ({
-  ...config,
-  constraints: createConstraints(config),
-});
+export type {
+  DependencyRule,
+  DependencyModelConfig,
+  DependencyModelOptions,
+  DependencyModelFacts,
+  DependencyModelOutput,
+  DependencyModelResult,
+  DependencyViolation,
+  DependencyWarning,
+  WorkspaceFacts,
+  WorkspaceRole,
+  SectionType,
+  UsageSummary,
+  ExpectedWorkspace,
+} from './dependency-model';

package/src/lib/imports.ts

@@ -0,0 +1,435 @@
+/**
+ * TypeScript/JavaScript import collectors.
+ *
+ * These helpers parse source and emitted declaration files into package-level
+ * import facts. They do not decide dependency placement; they only normalize
+ * specifiers and classify imports as runtime or type-only.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { builtinModules } from 'node:module';
+import path from 'node:path';
+import ts = require('typescript');
+
+import type { PackageJson } from './package-json';
+
+export interface ImportEntry {
+  packageName: string;
+  isTypeOnly: boolean;
+  file: string;
+}
+
+interface ModuleReference {
+  specifier: string;
+  isTypeOnly: boolean;
+}
+
+const BUILTINS = new Set([
+  ...builtinModules,
+  ...builtinModules.map((m) => `node:${m}`),
+]);
+
+const SOURCE_EXTENSIONS = new Set([
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+]);
+
+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 (
+    specifier.startsWith('.') ||
+    specifier.startsWith('/') ||
+    specifier.includes('*')
+  )
+    return null;
+  if (BUILTINS.has(specifier) || specifier.startsWith('node:')) return null;
+  if (specifier.startsWith('@')) {
+    const scopeSlash = specifier.indexOf('/', 1);
+    if (scopeSlash === -1) return null;
+    const subpathSlash = specifier.indexOf('/', scopeSlash + 1);
+
+    return subpathSlash === -1 ? specifier : specifier.slice(0, subpathSlash);
+  }
+  const slash = specifier.indexOf('/');
+
+  return slash === -1 ? specifier : specifier.slice(0, slash);
+}
+
+function walkFiles(dir: string, filter: (name: string) => boolean): string[] {
+  const results: string[] = [];
+
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory() && !IGNORED_WALK_DIRS.has(entry.name)) {
+        results.push(...walkFiles(full, filter));
+      } else if (entry.isFile() && filter(entry.name)) {
+        results.push(full);
+      }
+    }
+  } catch {
+    // dir doesn't exist - return empty
+  }
+  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);
+}
+
+function getScriptKind(file: string): ts.ScriptKind {
+  if (file.endsWith('.tsx')) return ts.ScriptKind.TSX;
+  if (file.endsWith('.jsx')) return ts.ScriptKind.JSX;
+  if (
+    file.endsWith('.js') ||
+    file.endsWith('.mjs') ||
+    file.endsWith('.cjs')
+  )
+    return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}
+
+function stringLiteralText(node: ts.Node | undefined): string | null {
+  return node && ts.isStringLiteralLike(node) ? node.text : null;
+}
+
+function addImport(
+  results: ImportEntry[],
+  file: string,
+  specifier: string,
+  isTypeOnly: boolean,
+): void {
+  const packageName = getPackageName(specifier);
+  if (!packageName) return;
+  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;
+  if (clause.isTypeOnly) return true;
+  if (clause.name) return false;
+  if (!clause.namedBindings) return true;
+  if (ts.isNamespaceImport(clause.namedBindings)) return false;
+
+  return (
+    clause.namedBindings.elements.length > 0 &&
+    clause.namedBindings.elements.every((element) => element.isTypeOnly)
+  );
+}
+
+function isExportDeclarationTypeOnly(node: ts.ExportDeclaration): boolean {
+  if (node.isTypeOnly) return true;
+  const clause = node.exportClause;
+  if (!clause || !ts.isNamedExports(clause)) return false;
+
+  return (
+    clause.elements.length > 0 &&
+    clause.elements.every((element) => element.isTypeOnly)
+  );
+}
+
+function collectExternalModuleReference(
+  node: ts.ExternalModuleReference,
+): string | null {
+  return stringLiteralText(node.expression);
+}
+
+function extractModuleReferences(
+  file: string,
+  content: string,
+  options: { includeDtsForms?: boolean } = {},
+): ModuleReference[] {
+  const results: ModuleReference[] = [];
+  const sourceFile = ts.createSourceFile(
+    file,
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+    getScriptKind(file),
+  );
+
+  if (options.includeDtsForms) {
+    for (const reference of sourceFile.typeReferenceDirectives) {
+      addModuleReference(results, reference.fileName, true);
+    }
+  }
+
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node)) {
+      const specifier = stringLiteralText(node.moduleSpecifier);
+      addModuleReference(results, specifier, isImportDeclarationTypeOnly(node));
+    } else if (ts.isExportDeclaration(node)) {
+      const specifier = stringLiteralText(node.moduleSpecifier);
+      addModuleReference(results, specifier, isExportDeclarationTypeOnly(node));
+    } else if (ts.isImportEqualsDeclaration(node)) {
+      if (ts.isExternalModuleReference(node.moduleReference)) {
+        const specifier = collectExternalModuleReference(node.moduleReference);
+        addModuleReference(results, specifier, node.isTypeOnly);
+      }
+    } else if (ts.isCallExpression(node)) {
+      if (
+        node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+        node.arguments.length === 1
+      ) {
+        const specifier = stringLiteralText(node.arguments[0]);
+        addModuleReference(results, specifier, false);
+      } else if (
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'require' &&
+        node.arguments.length === 1
+      ) {
+        const specifier = stringLiteralText(node.arguments[0]);
+        addModuleReference(results, specifier, false);
+      }
+    } else if (ts.isImportTypeNode(node)) {
+      const argument = node.argument;
+      if (ts.isLiteralTypeNode(argument)) {
+        const specifier = stringLiteralText(argument.literal);
+        addModuleReference(results, specifier, true);
+      }
+    } else if (
+      options.includeDtsForms &&
+      ts.isModuleDeclaration(node) &&
+      ts.isStringLiteral(node.name)
+    ) {
+      addModuleReference(results, node.name.text, true);
+    }
+
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  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);
+    return;
+  }
+  if (!value || typeof value !== 'object') return;
+  if (Array.isArray(value)) {
+    for (const item of value) collectEntrypointStrings(item, result);
+    return;
+  }
+  for (const item of Object.values(value as Record<string, unknown>)) {
+    collectEntrypointStrings(item, result);
+  }
+}
+
+function getPackageEntrypointFiles(
+  workspaceDir: string,
+  pkg: PackageJson,
+): string[] {
+  const candidates = new Set<string>();
+  if (pkg.main) candidates.add(pkg.main);
+  if (typeof pkg.bin === 'string') {
+    candidates.add(pkg.bin);
+  } else if (pkg.bin) {
+    for (const value of Object.values(pkg.bin)) candidates.add(value);
+  }
+  collectEntrypointStrings(pkg.exports, candidates);
+
+  const result = new Set<string>();
+
+  for (const candidate of candidates) {
+    if (!candidate || candidate.includes('*')) continue;
+    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;
+
+    result.add(full);
+  }
+
+  return [...result];
+}
+
+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,
+): string[] {
+  if (!pkg) return walkFiles(srcDirOrWorkspaceDir, (name) => isSourceFile(name));
+
+  const files = new Set<string>();
+
+  for (const sourceRoot of DEFAULT_SOURCE_ROOTS) {
+    for (const file of walkFiles(
+      path.join(srcDirOrWorkspaceDir, sourceRoot),
+      (name) => isSourceFile(name),
+    )) {
+      files.add(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>();
+
+  for (const file of files) {
+    for (const { packageName } of extractImports(
+      file,
+      readFileSync(file, 'utf8'),
+      { includeDtsForms: true },
+    )) {
+      result.add(packageName);
+    }
+  }
+  return result;
+}