@crossplatformai/dependency-graph 0.9.4 → 0.11.0-next.0

package/src/workflow/expected-paths.ts

@@ -1,112 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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);
-  });
-});

package/src/workflow/validator.ts

@@ -1,230 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { glob } from 'glob';
-import { parse as parseYaml } from 'yaml';
-import { discoverWorkspaces } from '../workspace/discovery';
-import { buildPackageMap } from '../workspace/package-map';
-import type {
-  WorkflowValidationIssue,
-  WorkflowValidationPolicy,
-  WorkflowValidationResult,
-} from './types';
-import { discoverWorkflowTargets } from './discovery';
-import { getExpectedWorkflowPaths } from './expected-paths';
-import { parseWorkflowFile } from './parser';
-import { defaultWorkflowValidationPolicy } from './policy';
-
-function uniqueSorted(values: string[]): string[] {
-  return Array.from(new Set(values)).sort();
-}
-
-function buildBroadWildcards(workspaceRoots: Set<string>): Set<string> {
-  const wildcards = new Set<string>();
-
-  for (const root of workspaceRoots) {
-    wildcards.add(`${root}/*`);
-    wildcards.add(`${root}/**`);
-  }
-
-  return wildcards;
-}
-
-function splitActualPaths(
-  paths: string[],
-  workspaceRoots: Set<string>,
-  allowedRootPaths: string[],
-  workflowPath: string,
-): { workspacePaths: string[]; ignoredPaths: string[] } {
-  const workspacePaths: string[] = [];
-  const ignoredPaths: string[] = [];
-
-  for (const path of paths) {
-    if (path === workflowPath || allowedRootPaths.includes(path)) {
-      ignoredPaths.push(path);
-      continue;
-    }
-
-    const [rootSegment] = path.split('/');
-    if (rootSegment && workspaceRoots.has(rootSegment)) {
-      workspacePaths.push(path);
-      continue;
-    }
-
-    ignoredPaths.push(path);
-  }
-
-  return {
-    workspacePaths: uniqueSorted(workspacePaths),
-    ignoredPaths: uniqueSorted(ignoredPaths),
-  };
-}
-
-function isCoveredByExpectedPath(
-  actualPath: string,
-  expectedPaths: string[],
-): boolean {
-  return expectedPaths.some((expectedPath) => {
-    if (expectedPath === actualPath) {
-      return true;
-    }
-
-    if (!expectedPath.endsWith('/**')) {
-      return false;
-    }
-
-    const expectedPrefix = expectedPath.slice(0, -3);
-    return actualPath.startsWith(`${expectedPrefix}/`);
-  });
-}
-
-function validateWorkflowResult(
-  workflow: string,
-  targetPackage: string,
-  expectedPaths: string[],
-  actualPaths: string[],
-  broadWildcards: Set<string>,
-): WorkflowValidationResult {
-  const issues: WorkflowValidationIssue[] = [];
-  const missing = expectedPaths.filter((path) => !actualPaths.includes(path));
-  const unnecessary = actualPaths.filter(
-    (path) => !isCoveredByExpectedPath(path, expectedPaths),
-  );
-
-  for (const path of missing) {
-    issues.push({
-      kind: 'missing',
-      path,
-      message: `Missing path '${path}'`,
-    });
-  }
-
-  for (const path of unnecessary) {
-    issues.push({
-      kind: 'unnecessary',
-      path,
-      message: `Unnecessary path '${path}'`,
-    });
-  }
-
-  for (const path of actualPaths) {
-    if (broadWildcards.has(path)) {
-      issues.push({
-        kind: 'broad-wildcard',
-        path,
-        message: `Uses broad wildcard '${path}' which triggers on all workspace changes under that root`,
-      });
-    }
-  }
-
-  return {
-    workflow,
-    targetPackage,
-    valid: issues.length === 0,
-    expectedPaths,
-    actualPaths,
-    missing,
-    unnecessary,
-    issues,
-  };
-}
-
-export async function validateWorkflows(
-  rootDir: string,
-  policyOverrides?: Partial<WorkflowValidationPolicy>,
-): Promise<WorkflowValidationResult[]> {
-  const discoveredPackages = await discoverWorkspaces(rootDir, {
-    fs: {
-      readFile: (path, encoding) => readFile(path, encoding),
-      exists: (path) => Promise.resolve(existsSync(path)),
-    },
-    glob: {
-      glob: (pattern, options) => glob(pattern, options),
-    },
-    yaml: {
-      parse: (content): unknown => parseYaml(content),
-    },
-  });
-
-  const policy: WorkflowValidationPolicy = {
-    ...defaultWorkflowValidationPolicy,
-    ...policyOverrides,
-    allowedRootPaths: uniqueSorted([
-      ...defaultWorkflowValidationPolicy.allowedRootPaths,
-      ...(policyOverrides?.allowedRootPaths ?? []),
-    ]),
-  };
-
-  const { packageMap, workspaceRoots } = buildPackageMap(
-    discoveredPackages,
-    rootDir,
-  );
-  const workflowTargets = discoverWorkflowTargets(
-    rootDir,
-    discoveredPackages,
-    policy,
-  );
-  const broadWildcards = buildBroadWildcards(workspaceRoots);
-
-  return workflowTargets.map((workflowTarget) => {
-    if (!workflowTarget.targetPackage) {
-      return {
-        workflow: workflowTarget.workflowFile,
-        targetPackage: workflowTarget.targetSlug,
-        valid: false,
-        expectedPaths: [],
-        actualPaths: [],
-        missing: [],
-        unnecessary: [],
-        issues: [
-          {
-            kind: 'config-error',
-            message: `Could not resolve workflow target package for '${workflowTarget.workflowFile}'`,
-          },
-        ],
-      };
-    }
-
-    try {
-      const parsedWorkflow = parseWorkflowFile(
-        workflowTarget.workflowFile,
-        rootDir,
-      );
-      const { workspacePaths: actualPaths } = splitActualPaths(
-        parsedWorkflow.paths,
-        workspaceRoots,
-        policy.allowedRootPaths,
-        workflowTarget.workflowPath,
-      );
-      const expectedPaths = getExpectedWorkflowPaths({
-        workflowTarget,
-        packages: discoveredPackages,
-        packageMap,
-        policy,
-      });
-
-      return validateWorkflowResult(
-        workflowTarget.workflowFile,
-        workflowTarget.targetPackage,
-        expectedPaths,
-        actualPaths,
-        broadWildcards,
-      );
-    } catch (error) {
-      return {
-        workflow: workflowTarget.workflowFile,
-        targetPackage: workflowTarget.targetPackage,
-        valid: false,
-        expectedPaths: [],
-        actualPaths: [],
-        missing: [],
-        unnecessary: [],
-        issues: [
-          {
-            kind: 'parse-error',
-            message: error instanceof Error ? error.message : String(error),
-          },
-        ],
-      };
-    }
-  });
-}