@crossplatformai/dependency-graph 0.9.2 → 0.9.4

package/src/graph/analysis.ts

@@ -1,4 +1,4 @@
-import type { DependencyGraph, GraphStats } from './types.js';
+import type { DependencyGraph, GraphStats } from './types';
 
 export function analyzeGraph(graph: DependencyGraph): GraphStats {
   const leafNodes: string[] = [];

package/src/graph/builder.ts

@@ -1,4 +1,4 @@
-import type { WorkspacePackage, DependencyGraph } from './types.js';
+import type { WorkspacePackage, DependencyGraph } from './types';
 
 export function buildDependencyGraph(
   packages: WorkspacePackage[],

package/src/graph/traversal.ts

@@ -1,4 +1,4 @@
-import type { DependencyGraph, TraversalOptions } from './types.js';
+import type { DependencyGraph, TraversalOptions } from './types';
 
 export function findAffectedPackages(
   startingPackages: Set<string>,

package/src/index.test.ts

@@ -1,10 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import { buildDependencyGraph } from './graph/builder.js';
+import { buildDependencyGraph } from './graph/builder';
 import {
   findPackageForFile,
   mapFilesToPackages,
-} from './workspace/file-mapping.js';
-import type { WorkspacePackage } from './graph/types.js';
+} from './workspace/file-mapping';
+import type { WorkspacePackage } from './graph/types';
 
 describe('@repo/dependency-graph', () => {
   describe('buildDependencyGraph', () => {

package/src/index.ts

@@ -4,37 +4,48 @@ export type {
   TraversalOptions,
   GraphStats,
   PackageJson,
-} from './graph/types.js';
+} from './graph/types';
 
 export type {
   WorkspaceConfig,
   WorkspaceDiscoveryConfig,
-} from './workspace/discovery.js';
+} from './workspace/discovery';
+
+export type { FileSystemClient, GlobClient, YamlClient } from './types/clients';
 
 export type {
-  FileSystemClient,
-  GlobClient,
-  YamlClient,
-} from './types/clients.js';
+  WorkflowValidationIssue,
+  WorkflowValidationPolicy,
+  WorkflowValidationResult,
+} from './workflow/types';
 
-export { buildDependencyGraph } from './graph/builder.js';
+export { buildDependencyGraph } from './graph/builder';
 
 export {
   findAffectedPackages,
   findDependencyPath,
   findAllPaths,
-} from './graph/traversal.js';
+} from './graph/traversal';
 
 export {
   analyzeGraph,
   detectCycles,
   getTransitiveDependencies,
   getTransitiveDependents,
-} from './graph/analysis.js';
+} from './graph/analysis';
+
+export { discoverWorkspaces } from './workspace/discovery';
 
-export { discoverWorkspaces } from './workspace/discovery.js';
+export {
+  buildPackageMap,
+  normalizeRelativePath,
+} from './workspace/package-map';
 
 export {
   findPackageForFile,
   mapFilesToPackages,
-} from './workspace/file-mapping.js';
+} from './workspace/file-mapping';
+
+export { defaultWorkflowValidationPolicy } from './workflow/policy';
+
+export { validateWorkflows } from './workflow/validator';

package/src/workflow/discovery.ts

@@ -0,0 +1,58 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { WorkspacePackage } from '../graph/types';
+import { buildPackageMap } from '../workspace/package-map';
+import type { WorkflowTarget, WorkflowValidationPolicy } from './types';
+
+function patternToRegExp(pattern: string): RegExp {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+}
+
+export function discoverWorkflowTargets(
+  rootDir: string,
+  packages: WorkspacePackage[],
+  policy: WorkflowValidationPolicy,
+): WorkflowTarget[] {
+  const workflowsDir = join(rootDir, '.github/workflows');
+  if (!existsSync(workflowsDir)) {
+    return [];
+  }
+
+  const { packageMap } = buildPackageMap(packages, rootDir);
+  const appPackages = packages.filter((pkg) =>
+    packageMap.get(pkg.name)?.workflowPath?.startsWith('apps/'),
+  );
+  const bySlug = new Map<string, string>();
+
+  for (const pkg of appPackages) {
+    const relativePath = packageMap.get(pkg.name)?.workflowPath;
+    if (!relativePath) {
+      continue;
+    }
+
+    const slug = relativePath.split('/').at(-1);
+    if (slug) {
+      bySlug.set(slug, pkg.name);
+    }
+  }
+
+  const allowedPatterns = policy.workflowFilePatterns.map(patternToRegExp);
+  const files = readdirSync(workflowsDir)
+    .filter((file) => file.endsWith('.yml'))
+    .filter((file) => allowedPatterns.some((pattern) => pattern.test(file)));
+
+  return files
+    .map((workflowFile) => {
+      const match = /^(?:deploy|release)-(.+)\.yml$/.exec(workflowFile);
+      const targetSlug = match?.[1] ?? workflowFile.replace(/\.yml$/, '');
+
+      return {
+        workflowFile,
+        workflowPath: `.github/workflows/${workflowFile}`,
+        targetSlug,
+        targetPackage: bySlug.get(targetSlug) ?? null,
+      };
+    })
+    .sort((a, b) => a.workflowFile.localeCompare(b.workflowFile));
+}

package/src/workflow/expected-paths.ts

@@ -0,0 +1,112 @@
+import type { WorkspacePackage } from '../graph/types';
+import type { WorkflowTarget, WorkflowValidationPolicy } from './types';
+
+interface ExpectedPathsOptions {
+  workflowTarget: WorkflowTarget;
+  packages: WorkspacePackage[];
+  packageMap: Map<string, { workflowPath: string | null }>;
+  policy: WorkflowValidationPolicy;
+}
+
+function uniqueSorted(values: string[]): string[] {
+  return Array.from(new Set(values)).sort();
+}
+
+function resolveWorkspaceDependency(
+  dependencyName: string,
+  packages: WorkspacePackage[],
+): WorkspacePackage | undefined {
+  let match = packages.find((pkg) => pkg.name === dependencyName);
+  if (match) {
+    return match;
+  }
+
+  match = packages.find((pkg) => pkg.name === `@repo/${dependencyName}`);
+  if (match) {
+    return match;
+  }
+
+  const nameWithoutRepo = dependencyName.replace(/^@repo\//, '');
+  return packages.find((pkg) => pkg.name === nameWithoutRepo);
+}
+
+function collectWorkspaceDependencyNames(
+  pkg: WorkspacePackage,
+  packages: WorkspacePackage[],
+  visited: Set<string>,
+  includeDevDependencies: boolean,
+  includeDevDependenciesTransitively: boolean,
+): Set<string> {
+  const collected = new Set<string>();
+  const dependencyEntries = Object.entries(pkg.dependencies);
+  const devDependencyEntries = includeDevDependencies
+    ? Object.entries(pkg.devDependencies)
+    : [];
+
+  for (const [dependencyName] of [
+    ...dependencyEntries,
+    ...devDependencyEntries,
+  ]) {
+    const dependency = resolveWorkspaceDependency(dependencyName, packages);
+    if (!dependency || visited.has(dependency.name)) {
+      continue;
+    }
+
+    visited.add(dependency.name);
+    collected.add(dependency.name);
+
+    const nestedDependencies = collectWorkspaceDependencyNames(
+      dependency,
+      packages,
+      visited,
+      includeDevDependenciesTransitively,
+      includeDevDependenciesTransitively,
+    );
+
+    for (const nestedDependency of nestedDependencies) {
+      collected.add(nestedDependency);
+    }
+  }
+
+  return collected;
+}
+
+export function getExpectedWorkflowPaths({
+  workflowTarget,
+  packages,
+  packageMap,
+  policy,
+}: ExpectedPathsOptions): string[] {
+  const targetPackageName = workflowTarget.targetPackage;
+  if (!targetPackageName) {
+    return [];
+  }
+
+  const targetPackage = packages.find((pkg) => pkg.name === targetPackageName);
+  if (!targetPackage) {
+    return [];
+  }
+
+  const dependencyNames = collectWorkspaceDependencyNames(
+    targetPackage,
+    packages,
+    new Set<string>(),
+    policy.includeDevDependenciesForRootPackage,
+    policy.includeDevDependenciesTransitively,
+  );
+
+  const expectedPaths: string[] = [];
+  const targetPackagePath = packageMap.get(targetPackageName)?.workflowPath;
+  if (targetPackagePath) {
+    expectedPaths.push(`${targetPackagePath}/**`);
+  }
+
+  for (const dependencyName of dependencyNames) {
+    const dependencyPath = packageMap.get(dependencyName)?.workflowPath;
+    if (dependencyPath) {
+      expectedPaths.push(`${dependencyPath}/**`);
+    }
+  }
+
+  return uniqueSorted(expectedPaths);
+}

package/src/workflow/parser.test.ts

@@ -0,0 +1,54 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { parseWorkflowFile } from './parser';
+
+const tempDirs: string[] = [];
+
+function createTempRepo(): string {
+  const rootDir = mkdtempSync(join(tmpdir(), 'dependency-graph-parser-'));
+  tempDirs.push(rootDir);
+  mkdirSync(join(rootDir, '.github/workflows'), { recursive: true });
+  return rootDir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // Best effort cleanup.
+    }
+  }
+});
+
+describe('parseWorkflowFile', () => {
+  it('unions push and pull request path filters', () => {
+    const rootDir = createTempRepo();
+    writeFileSync(
+      join(rootDir, '.github/workflows/deploy-web.yml'),
+      `name: Deploy Web
+on:
+  push:
+    paths:
+      - 'package.json'
+      - 'apps/web/**'
+  pull_request:
+    paths:
+      - 'apps/shared/**'
+      - 'apps/web/**'
+`,
+    );
+
+    const parsed = parseWorkflowFile('deploy-web.yml', rootDir);
+
+    expect(parsed.pushPaths).toEqual(['apps/web/**', 'package.json']);
+    expect(parsed.pullRequestPaths).toEqual(['apps/shared/**', 'apps/web/**']);
+    expect(parsed.paths).toEqual([
+      'apps/shared/**',
+      'apps/web/**',
+      'package.json',
+    ]);
+  });
+});

package/src/workflow/parser.ts

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import type { ParsedWorkflow } from './types';
+
+interface WorkflowConfig {
+  name?: string;
+  on?: {
+    push?: {
+      paths?: string[];
+    };
+    pull_request?: {
+      paths?: string[];
+    };
+  };
+}
+
+function uniqueSorted(values: string[]): string[] {
+  return Array.from(new Set(values)).sort();
+}
+
+export function parseWorkflowFile(
+  workflowFile: string,
+  rootDir: string,
+): ParsedWorkflow {
+  const workflowPath = join(rootDir, '.github/workflows', workflowFile);
+
+  if (!existsSync(workflowPath)) {
+    throw new Error(`Workflow file not found: ${workflowFile}`);
+  }
+
+  const content = readFileSync(workflowPath, 'utf-8');
+  const workflow = parseYaml(content) as WorkflowConfig;
+  const pushPaths = workflow.on?.push?.paths ?? [];
+  const pullRequestPaths = workflow.on?.pull_request?.paths ?? [];
+
+  const parsedWorkflow: ParsedWorkflow = {
+    pushPaths: uniqueSorted(pushPaths),
+    pullRequestPaths: uniqueSorted(pullRequestPaths),
+    paths: uniqueSorted([...pushPaths, ...pullRequestPaths]),
+  };
+
+  if (workflow.name) {
+    parsedWorkflow.name = workflow.name;
+  }
+
+  return parsedWorkflow;
+}

package/src/workflow/policy.ts

@@ -0,0 +1,13 @@
+import type { WorkflowValidationPolicy } from './types';
+
+export const defaultWorkflowValidationPolicy: WorkflowValidationPolicy = {
+  workflowFilePatterns: ['deploy-*.yml', 'release-*.yml'],
+  allowedRootPaths: [
+    'package.json',
+    'pnpm-lock.yaml',
+    'pnpm-workspace.yaml',
+    'turbo.json',
+  ],
+  includeDevDependenciesForRootPackage: true,
+  includeDevDependenciesTransitively: false,
+};

package/src/workflow/types.ts

@@ -0,0 +1,42 @@
+export interface WorkflowValidationPolicy {
+  workflowFilePatterns: string[];
+  allowedRootPaths: string[];
+  includeDevDependenciesForRootPackage: boolean;
+  includeDevDependenciesTransitively: boolean;
+}
+
+export interface WorkflowValidationIssue {
+  kind:
+    | 'missing'
+    | 'unnecessary'
+    | 'broad-wildcard'
+    | 'parse-error'
+    | 'config-error';
+  message: string;
+  path?: string;
+}
+
+export interface WorkflowValidationResult {
+  workflow: string;
+  targetPackage: string;
+  valid: boolean;
+  expectedPaths: string[];
+  actualPaths: string[];
+  missing: string[];
+  unnecessary: string[];
+  issues: WorkflowValidationIssue[];
+}
+
+export interface ParsedWorkflow {
+  name?: string;
+  pushPaths: string[];
+  pullRequestPaths: string[];
+  paths: string[];
+}
+
+export interface WorkflowTarget {
+  workflowFile: string;
+  workflowPath: string;
+  targetSlug: string;
+  targetPackage: string | null;
+}

package/src/workflow/validator.test.ts

@@ -0,0 +1,214 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { validateWorkflows } from './validator';
+
+const tempDirs: string[] = [];
+
+function createTempRepo(): string {
+  const tempBaseDir = mkdtempSync(
+    join(tmpdir(), 'dependency-graph-validator-'),
+  );
+  tempDirs.push(tempBaseDir);
+  const rootDir = join(tempBaseDir, 'repo');
+  mkdirSync(join(rootDir, '.github/workflows'), { recursive: true });
+  return rootDir;
+}
+
+function writeJson(path: string, content: unknown): void {
+  writeFileSync(path, JSON.stringify(content, null, 2));
+}
+
+function writeWorkspacePackage(
+  rootDir: string,
+  relativeDir: string,
+  packageJson: Record<string, unknown>,
+): void {
+  const packageDir = join(rootDir, relativeDir);
+  mkdirSync(packageDir, { recursive: true });
+  writeJson(join(packageDir, 'package.json'), packageJson);
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('validateWorkflows', () => {
+  it('uses pnpm-workspace packages including ui and ignores non-workspace paths', async () => {
+    const rootDir = createTempRepo();
+
+    writeJson(join(rootDir, 'package.json'), {
+      name: 'fixture',
+      packageManager: 'pnpm@10.28.0',
+    });
+
+    writeFileSync(
+      join(rootDir, 'pnpm-workspace.yaml'),
+      `packages:\n  - 'apps/*'\n  - 'ui/*'\n`,
+    );
+
+    writeWorkspacePackage(rootDir, 'apps/web', {
+      name: 'web',
+      dependencies: {
+        '@repo/shared': 'workspace:*',
+      },
+      devDependencies: {},
+    });
+    writeWorkspacePackage(rootDir, 'apps/shared', {
+      name: '@repo/shared',
+      dependencies: {
+        '@repo/components': 'workspace:*',
+      },
+      devDependencies: {},
+    });
+    writeWorkspacePackage(rootDir, 'ui/components', {
+      name: '@repo/components',
+      dependencies: {},
+      devDependencies: {},
+    });
+
+    mkdirSync(join(rootDir, 'scripts'), { recursive: true });
+    writeFileSync(join(rootDir, 'scripts/run-next.mjs'), 'export {}\n');
+
+    writeFileSync(
+      join(rootDir, '.github/workflows/deploy-web.yml'),
+      `name: Deploy Web
+on:
+  pull_request:
+    paths:
+      - 'apps/web/**'
+      - 'apps/shared/**'
+      - 'ui/components/**'
+      - 'scripts/run-next.mjs'
+      - '.github/workflows/deploy-web.yml'
+`,
+    );
+
+    const [result] = await validateWorkflows(rootDir);
+
+    expect(result?.valid).toBe(true);
+    expect(result?.expectedPaths).toEqual([
+      'apps/shared/**',
+      'apps/web/**',
+      'ui/components/**',
+    ]);
+    expect(result?.actualPaths).toEqual([
+      'apps/shared/**',
+      'apps/web/**',
+      'ui/components/**',
+    ]);
+  });
+
+  it('maps external workspaces to local mirrors when validating workflows', async () => {
+    const rootDir = createTempRepo();
+
+    writeJson(join(rootDir, 'package.json'), {
+      name: 'fixture',
+      packageManager: 'pnpm@10.28.0',
+    });
+
+    writeFileSync(
+      join(rootDir, 'pnpm-workspace.yaml'),
+      `packages:\n  - 'apps/*'\n  - '../crossplatform.ai/plugins/*'\n`,
+    );
+
+    writeWorkspacePackage(rootDir, 'apps/web', {
+      name: 'web',
+      dependencies: {
+        '@repo/design-system': 'workspace:*',
+      },
+      devDependencies: {},
+    });
+
+    mkdirSync(join(rootDir, 'plugins/design-system'), { recursive: true });
+    writeWorkspacePackage(
+      rootDir,
+      '../crossplatform.ai/plugins/design-system',
+      {
+        name: '@repo/design-system',
+        dependencies: {},
+        devDependencies: {},
+      },
+    );
+
+    writeFileSync(
+      join(rootDir, '.github/workflows/deploy-web.yml'),
+      `name: Deploy Web
+on:
+  pull_request:
+    paths:
+      - 'apps/web/**'
+      - 'plugins/design-system/**'
+      - '.github/workflows/deploy-web.yml'
+`,
+    );
+
+    const [result] = await validateWorkflows(rootDir);
+
+    expect(result?.valid).toBe(true);
+    expect(result?.expectedPaths).toEqual([
+      'apps/web/**',
+      'plugins/design-system/**',
+    ]);
+  });
+
+  it('flags stale package paths and broad workspace wildcards', async () => {
+    const rootDir = createTempRepo();
+
+    writeJson(join(rootDir, 'package.json'), {
+      name: 'fixture',
+      packageManager: 'pnpm@10.28.0',
+    });
+
+    writeFileSync(
+      join(rootDir, 'pnpm-workspace.yaml'),
+      `packages:\n  - 'apps/*'\n  - 'ui/*'\n`,
+    );
+
+    writeWorkspacePackage(rootDir, 'apps/web', {
+      name: 'web',
+      dependencies: {
+        '@repo/shared': 'workspace:*',
+      },
+      devDependencies: {},
+    });
+    writeWorkspacePackage(rootDir, 'apps/shared', {
+      name: '@repo/shared',
+      dependencies: {
+        '@repo/components': 'workspace:*',
+      },
+      devDependencies: {},
+    });
+    writeWorkspacePackage(rootDir, 'ui/components', {
+      name: '@repo/components',
+      dependencies: {},
+      devDependencies: {},
+    });
+
+    writeFileSync(
+      join(rootDir, '.github/workflows/deploy-web.yml'),
+      `name: Deploy Web
+on:
+  pull_request:
+    paths:
+      - 'apps/web/**'
+      - 'apps/shared/**'
+      - 'packages/components/**'
+      - 'ui/**'
+      - '.github/workflows/deploy-web.yml'
+`,
+    );
+
+    const [result] = await validateWorkflows(rootDir);
+
+    expect(result?.valid).toBe(false);
+    expect(result?.missing).toContain('ui/components/**');
+    expect(result?.unnecessary).toEqual(['ui/**']);
+    expect(
+      result?.issues.some((issue) => issue.kind === 'broad-wildcard'),
+    ).toBe(true);
+  });
+});