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

package/src/model/peer-propagation.ts

@@ -0,0 +1,199 @@
+/**
+ * Peer propagation across dependency edges.
+ *
+ * This module applies peer requirements from local libraries and external
+ * packages to the current workspace. It consumes already collected peer
+ * metadata and does not inspect `node_modules` itself.
+ */
+import {
+  addExpectedMirrorDependency,
+  addReason,
+  addRuleReason,
+  getExpectedRange,
+  getExpectedSection,
+  setExpectedDependency,
+} from './expected';
+import { getEffectiveRule } from './rules';
+import type {
+  DependencyRule,
+  ExpectedWorkspace,
+  WorkspaceFacts,
+} from './types';
+
+function providePeer(
+  expected: ExpectedWorkspace,
+  rootExpected: ExpectedWorkspace,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+  depIdent: string,
+  range: string,
+  provider: string,
+): boolean {
+  if (workspaceNames.has(depIdent)) return false;
+  if (expected.sections.dependencies.has(depIdent)) return false;
+
+  const beforeSection = getExpectedSection(expected, depIdent);
+  const beforeRange = getExpectedRange(expected, depIdent);
+  const rule = getEffectiveRule(
+    rules,
+    depIdent,
+    expected.workspace.name,
+    expected.workspace.location,
+  );
+  const resolvedRange = rule.version ?? range;
+
+  addRuleReason(expected, depIdent, rule);
+
+  if (rule.rootOnly) {
+    setExpectedDependency(
+      rootExpected,
+      'devDependencies',
+      depIdent,
+      resolvedRange,
+      {
+        kind: 'root-only',
+        detail: `${depIdent} is required by ${provider} but marked rootOnly`,
+      },
+    );
+    addReason(expected, depIdent, {
+      kind: 'root-only',
+      detail: `${depIdent} is required by ${provider} but marked rootOnly`,
+    });
+    return false;
+  }
+
+  if (
+    expected.workspace.role === 'library' &&
+    rule.section !== 'dependencies'
+  ) {
+    setExpectedDependency(
+      expected,
+      'peerDependencies',
+      depIdent,
+      resolvedRange,
+      {
+        kind: 'peer-propagation',
+        detail: `${depIdent} is required peer of ${provider}`,
+      },
+    );
+    addExpectedMirrorDependency(expected, depIdent, resolvedRange, {
+      kind: 'mirror',
+      detail: `${depIdent} mirrors propagated peer`,
+    });
+  } else {
+    setExpectedDependency(expected, 'dependencies', depIdent, resolvedRange, {
+      kind: 'peer-propagation',
+      detail: `${depIdent} is required peer of ${provider}`,
+    });
+  }
+
+  return (
+    beforeSection !== getExpectedSection(expected, depIdent) ||
+    beforeRange !== getExpectedRange(expected, depIdent)
+  );
+}
+
+export function propagatePeers(
+  expectedByLocation: Map<string, ExpectedWorkspace>,
+  workspacesByName: Map<string, WorkspaceFacts>,
+  workspaceNames: Set<string>,
+  externalPeerMetadata: Map<string, Map<string, string> | null>,
+  rules: DependencyRule[],
+): void {
+  const rootExpected = expectedByLocation.get('.')!;
+  let changed = true;
+  let passes = 0;
+
+  while (changed && passes < 10) {
+    changed = false;
+    passes++;
+
+    for (const expected of expectedByLocation.values()) {
+      const workspace = expected.workspace;
+      const providerDeps = new Map<string, string>();
+
+      for (const [depIdent, range] of expected.sections.dependencies) {
+        providerDeps.set(depIdent, range);
+      }
+      for (const [depIdent, range] of expected.sections.peerDependencies) {
+        providerDeps.set(depIdent, range);
+      }
+      if (workspace.isRoot) {
+        for (const [depIdent, range] of expected.sections.devDependencies) {
+          providerDeps.set(depIdent, range);
+        }
+      }
+
+      for (const [providerIdent] of providerDeps) {
+        if (workspaceNames.has(providerIdent)) {
+          const provider = workspacesByName.get(providerIdent);
+          if (!provider || provider.role !== 'library') continue;
+          const providerExpected = expectedByLocation.get(provider.location);
+          if (!providerExpected) continue;
+
+          for (const [peerIdent, peerRange] of providerExpected.sections
+            .peerDependencies) {
+            if (provider.pkg.peerDependenciesMeta?.[peerIdent]?.optional) {
+              continue;
+            }
+            if (workspaceNames.has(peerIdent)) continue;
+            if (workspace.isRoot) {
+              setExpectedDependency(
+                rootExpected,
+                'devDependencies',
+                peerIdent,
+                peerRange,
+                {
+                  kind: 'peer-propagation',
+                  detail: `${peerIdent} is required by ${providerIdent}`,
+                },
+              );
+            } else {
+              changed =
+                providePeer(
+                  expected,
+                  rootExpected,
+                  workspaceNames,
+                  rules,
+                  peerIdent,
+                  peerRange,
+                  providerIdent,
+                ) || changed;
+            }
+          }
+          continue;
+        }
+
+        const externalPeers = externalPeerMetadata.get(providerIdent) ?? null;
+        if (!externalPeers) continue;
+
+        for (const [peerIdent, peerRange] of externalPeers) {
+          if (workspaceNames.has(peerIdent)) continue;
+          if (workspace.isRoot) {
+            setExpectedDependency(
+              rootExpected,
+              'devDependencies',
+              peerIdent,
+              peerRange,
+              {
+                kind: 'peer-propagation',
+                detail: `${peerIdent} is required by ${providerIdent}`,
+              },
+            );
+          } else {
+            changed =
+              providePeer(
+                expected,
+                rootExpected,
+                workspaceNames,
+                rules,
+                peerIdent,
+                peerRange,
+                providerIdent,
+              ) || changed;
+          }
+        }
+      }
+    }
+  }
+}

package/src/model/placement.ts

@@ -0,0 +1,378 @@
+/**
+ * Dependency placement rules.
+ *
+ * This module converts source and `.d.ts` usage facts into expected manifest
+ * sections. It is pure: it receives workspace facts, rules, type metadata, and
+ * local workspace names, then mutates only the in-memory expected graph.
+ */
+import {
+  addExpectedMirrorDependency,
+  addReason,
+  addRuleReason,
+  getDeclaredRange,
+  getRangeSource,
+  setExpectedDependency,
+} from './expected';
+import { getEffectiveRule } from './rules';
+import type {
+  DependencyRule,
+  ExpectedWorkspace,
+  Reason,
+  WorkspaceFacts,
+} from './types';
+
+function isTestFile(file: string): boolean {
+  return /(^|[/.])(__test__|__tests__|test|tests|spec|e2e)([/.]|$)|\.(spec|test|e2e)\.[cm]?[tj]sx?$/.test(
+    file,
+  );
+}
+
+export function isExternal(
+  depIdent: string,
+  workspaceNames: Set<string>,
+): boolean {
+  return !workspaceNames.has(depIdent);
+}
+
+function getDefinitelyTypedProvider(depIdent: string): string | null {
+  if (depIdent.startsWith('@types/')) return null;
+  if (depIdent.startsWith('@')) {
+    const [scope, name] = depIdent.slice(1).split('/');
+    if (!scope || !name) return null;
+    return `@types/${scope}__${name}`;
+  }
+
+  return `@types/${depIdent}`;
+}
+
+function shouldAddDefinitelyTypedProvider(
+  depIdent: string,
+  externalTypeMetadata: Map<string, { hasBundledTypes: boolean }>,
+  typeProviderPackages: Set<string>,
+): string | null {
+  const provider = getDefinitelyTypedProvider(depIdent);
+  if (!provider || !typeProviderPackages.has(provider)) return null;
+  if (externalTypeMetadata.get(depIdent)?.hasBundledTypes) return null;
+
+  return provider;
+}
+
+function getConcreteRuleMatches(rule: DependencyRule): string[] {
+  const matches = Array.isArray(rule.match) ? rule.match : [rule.match];
+
+  return matches.filter((match) => !match.includes('*'));
+}
+
+function addPublicDependency(
+  expected: ExpectedWorkspace,
+  rootExpected: ExpectedWorkspace,
+  root: WorkspaceFacts,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+  depIdent: string,
+  reason: Reason,
+  options: { allowRootOnly?: boolean; rootOnlyRequired?: boolean } = {},
+): void {
+  const workspace = expected.workspace;
+  const rule = getEffectiveRule(
+    rules,
+    depIdent,
+    workspace.name,
+    workspace.location,
+  );
+  const isLocal = workspaceNames.has(depIdent);
+  const range = isLocal
+    ? 'workspace:*'
+    : getRangeSource(root, workspace, depIdent, rules);
+
+  addRuleReason(expected, depIdent, rule);
+
+  if (rule.rootOnly && !isLocal && !options.allowRootOnly) {
+    addRuleReason(rootExpected, depIdent, rule);
+    setExpectedDependency(rootExpected, 'devDependencies', depIdent, range, {
+      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);
+    if (!options.rootOnlyRequired) {
+      addReason(expected, depIdent, {
+        kind: 'root-only',
+        detail: `${depIdent} is marked rootOnly and cannot be used by ${workspace.name}`,
+      });
+    }
+    return;
+  }
+
+  if (isLocal) {
+    setExpectedDependency(expected, 'dependencies', depIdent, 'workspace:*', {
+      kind: reason.kind,
+      detail: `${reason.detail}; local workspace edge`,
+    });
+    return;
+  }
+
+  if (
+    workspace.role === 'library' &&
+    rule.section !== 'dependencies' &&
+    rule.section !== 'devDependencies'
+  ) {
+    setExpectedDependency(
+      expected,
+      'peerDependencies',
+      depIdent,
+      range,
+      reason,
+    );
+    addExpectedMirrorDependency(expected, depIdent, range, {
+      kind: 'mirror',
+      detail: `${depIdent} mirrors peerDependencies in devDependencies`,
+    });
+    return;
+  }
+
+  setExpectedDependency(expected, 'dependencies', depIdent, range, reason);
+}
+
+function addPrivateDependency(
+  rootExpected: ExpectedWorkspace,
+  root: WorkspaceFacts,
+  requester: ExpectedWorkspace,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+  depIdent: string,
+  reason: Reason,
+): void {
+  const workspace = requester.workspace;
+  if (workspaceNames.has(depIdent)) return;
+  const rule = getEffectiveRule(
+    rules,
+    depIdent,
+    workspace.name,
+    workspace.location,
+  );
+  const range = getRangeSource(root, workspace, depIdent, rules);
+
+  addRuleReason(rootExpected, depIdent, rule);
+  addRuleReason(requester, depIdent, rule);
+
+  if (rule.rootOnly) {
+    addReason(requester, depIdent, {
+      kind: 'root-only',
+      detail: `${depIdent} is marked rootOnly and cannot be used by ${workspace.name}`,
+    });
+  }
+
+  setExpectedDependency(
+    rootExpected,
+    'devDependencies',
+    depIdent,
+    range,
+    reason,
+  );
+}
+
+export function seedRootDevDependencies(
+  expectedByLocation: Map<string, ExpectedWorkspace>,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+): void {
+  const rootExpected = expectedByLocation.get('.')!;
+
+  for (const [depIdent, declaredRange] of Object.entries(
+    rootExpected.workspace.pkg.devDependencies ?? {},
+  )) {
+    const rule = getEffectiveRule(
+      rules,
+      depIdent,
+      rootExpected.workspace.name,
+      rootExpected.workspace.location,
+    );
+    const range = workspaceNames.has(depIdent)
+      ? 'workspace:*'
+      : (rule.version ?? declaredRange);
+
+    setExpectedDependency(rootExpected, 'devDependencies', depIdent, range, {
+      kind: 'declared',
+      detail: `${depIdent} is declared in root devDependencies baseline`,
+    });
+    addRuleReason(rootExpected, depIdent, rule);
+  }
+}
+
+export function addUsageDependencies(
+  expectedByLocation: Map<string, ExpectedWorkspace>,
+  root: WorkspaceFacts,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+  externalTypeMetadata: Map<string, { hasBundledTypes: boolean }>,
+  typeProviderPackages: Set<string>,
+): void {
+  const rootExpected = expectedByLocation.get('.')!;
+
+  for (const expected of expectedByLocation.values()) {
+    const workspace = expected.workspace;
+    if (workspace.isRoot) continue;
+
+    for (const [depIdent, usage] of workspace.sourceUsage) {
+      const publicType = workspace.dtsImports.has(depIdent);
+      const runtime = [...usage.runtimeFiles].some((file) => !isTestFile(file));
+      const allTestOnly = [...usage.files].every(isTestFile);
+
+      if (runtime || publicType) {
+        addPublicDependency(
+          expected,
+          rootExpected,
+          root,
+          workspaceNames,
+          rules,
+          depIdent,
+          {
+            kind: publicType ? 'source-public-type' : 'source-runtime',
+            detail: publicType
+              ? `${depIdent} appears in emitted .d.ts`
+              : `${depIdent} is imported at runtime`,
+          },
+        );
+      } else {
+        addPrivateDependency(
+          rootExpected,
+          root,
+          expected,
+          workspaceNames,
+          rules,
+          depIdent,
+          {
+            kind: 'source-private-dev',
+            detail: allTestOnly
+              ? `${depIdent} is only used by test files in ${workspace.name}`
+              : `${depIdent} is only used as private type/tooling dependency in ${workspace.name}`,
+          },
+        );
+      }
+    }
+
+    for (const depIdent of workspace.dtsImports) {
+      addPublicDependency(
+        expected,
+        rootExpected,
+        root,
+        workspaceNames,
+        rules,
+        depIdent,
+        {
+          kind: 'source-public-type',
+          detail: `${depIdent} appears in emitted .d.ts`,
+        },
+      );
+
+      const typeProvider = shouldAddDefinitelyTypedProvider(
+        depIdent,
+        externalTypeMetadata,
+        typeProviderPackages,
+      );
+      if (!typeProvider) continue;
+
+      addPublicDependency(
+        expected,
+        rootExpected,
+        root,
+        workspaceNames,
+        rules,
+        typeProvider,
+        {
+          kind: 'dts-provider',
+          detail: `${typeProvider} provides public types for ${depIdent}`,
+        },
+        { allowRootOnly: true },
+      );
+    }
+  }
+}
+
+export function addRequiredRuleDependencies(
+  expectedByLocation: Map<string, ExpectedWorkspace>,
+  root: WorkspaceFacts,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+): void {
+  const rootExpected = expectedByLocation.get('.')!;
+  const candidates = new Set<string>();
+
+  for (const rule of rules) {
+    if (rule.required === undefined) continue;
+    for (const depIdent of getConcreteRuleMatches(rule)) {
+      candidates.add(depIdent);
+    }
+  }
+
+  for (const expected of expectedByLocation.values()) {
+    const workspace = expected.workspace;
+    if (workspace.isRoot) continue;
+
+    for (const depIdent of candidates) {
+      const rule = getEffectiveRule(
+        rules,
+        depIdent,
+        workspace.name,
+        workspace.location,
+      );
+      if (!rule.required) continue;
+
+      addPublicDependency(
+        expected,
+        rootExpected,
+        root,
+        workspaceNames,
+        rules,
+        depIdent,
+        {
+          kind: 'required-rule',
+          detail: `${depIdent} is marked required by dependency rule`,
+        },
+        { rootOnlyRequired: rule.rootOnly },
+      );
+    }
+  }
+}
+
+export function rebuildLibraryMirrors(
+  expectedByLocation: Map<string, ExpectedWorkspace>,
+): void {
+  for (const expected of expectedByLocation.values()) {
+    if (expected.workspace.role !== 'library') continue;
+    expected.sections.devDependencies = new Map(
+      expected.sections.peerDependencies,
+    );
+    for (const [depIdent] of expected.sections.devDependencies) {
+      addReason(expected, depIdent, {
+        kind: 'mirror',
+        detail: `${depIdent} mirrors peerDependencies in devDependencies`,
+      });
+    }
+  }
+}
+
+export function resolveExpectedRangeAfterRulePass(
+  root: WorkspaceFacts,
+  expected: ExpectedWorkspace,
+  workspaceNames: Set<string>,
+  rules: DependencyRule[],
+  depIdent: string,
+  currentRange: string,
+): string {
+  const rule = getEffectiveRule(
+    rules,
+    depIdent,
+    expected.workspace.name,
+    expected.workspace.location,
+  );
+
+  return workspaceNames.has(depIdent)
+    ? 'workspace:*'
+    : (rule.version ??
+      getDeclaredRange(expected.workspace.pkg, depIdent) ??
+      getDeclaredRange(root.pkg, depIdent) ??
+      currentRange);
+}

package/src/model/rules.ts

@@ -0,0 +1,85 @@
+/**
+ * Rule matching and precedence.
+ *
+ * Dependency rules are the explicit override surface for the model: versions,
+ * section overrides, root-only constraints, and workspace-specific exceptions.
+ * The helpers here are pure and apply the documented "last matching rule wins"
+ * semantics.
+ */
+import type { DependencyRule, EffectiveRule, WorkspaceRole } from './types';
+
+export function matchesGlob(value: string, pattern: string): boolean {
+  if (!pattern.includes('*')) return value === pattern;
+  const escaped = pattern.replaceAll(
+    /[-[\]{}()+?.,\\^$|#\s]/g,
+    String.raw`\$&`,
+  );
+
+  return new RegExp(
+    '^' + escaped.replaceAll('**', '.*').replaceAll('*', '[^/]*') + '$',
+  ).test(value);
+}
+
+export function matchesPatterns(
+  value: string,
+  pattern: string | string[],
+): boolean {
+  const patterns = Array.isArray(pattern) ? pattern : [pattern];
+
+  return patterns.some((p) => matchesGlob(value, p));
+}
+
+export function getEffectiveRule(
+  rules: DependencyRule[],
+  depIdent: string,
+  wsIdent: string,
+  wsCwd: string,
+): EffectiveRule {
+  const effective: EffectiveRule = { rootOnly: false };
+
+  for (const rule of rules) {
+    if (!matchesPatterns(depIdent, rule.match)) continue;
+    if (
+      rule.workspace &&
+      !matchesPatterns(wsIdent, rule.workspace) &&
+      !matchesPatterns(wsCwd, rule.workspace)
+    )
+      continue;
+    if (rule.section) effective.section = rule.section;
+    if (rule.version !== undefined) effective.version = rule.version;
+    if (rule.rootOnly !== undefined) effective.rootOnly = rule.rootOnly;
+    if (rule.required !== undefined) effective.required = rule.required;
+  }
+
+  return effective;
+}
+
+export function hasGlobalVersionRule(
+  rules: DependencyRule[],
+  depIdent: string,
+): boolean {
+  return rules.some(
+    (rule) =>
+      !rule.workspace &&
+      rule.version !== undefined &&
+      matchesPatterns(depIdent, rule.match),
+  );
+}
+
+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 {
+  return value === 'library' || value === 'service' || value === 'cli';
+}