@crossplatformai/dependency-graph 0.9.2 → 0.9.4

package/src/workflow/validator.ts

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

package/src/workspace/discovery.ts

@@ -1,10 +1,10 @@
 import { join, resolve } from 'node:path';
-import type { WorkspacePackage } from '../graph/types.js';
+import type { WorkspacePackage } from '../graph/types';
 import type {
   FileSystemClient,
   GlobClient,
   YamlClient,
-} from '../types/clients.js';
+} from '../types/clients';
 
 export interface WorkspaceConfig {
   packages: string[];

package/src/workspace/file-mapping.ts

@@ -1,4 +1,4 @@
-import type { WorkspacePackage } from '../graph/types.js';
+import type { WorkspacePackage } from '../graph/types';
 
 export function findPackageForFile(
   filePath: string,

package/src/workspace/package-map.test.ts

@@ -0,0 +1,95 @@
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import type { WorkspacePackage } from '../graph/types';
+import { buildPackageMap } from './package-map';
+
+const tempDirs: string[] = [];
+
+function createTempRepo(): string {
+  const tempBaseDir = mkdtempSync(
+    join(tmpdir(), 'dependency-graph-package-map-'),
+  );
+  tempDirs.push(tempBaseDir);
+  const rootDir = join(tempBaseDir, 'repo');
+  mkdirSync(rootDir, { recursive: true });
+  return rootDir;
+}
+
+function createWorkspacePackage(path: string, name: string): WorkspacePackage {
+  return {
+    name,
+    version: '0.0.0',
+    path,
+    packageJson: { name },
+    dependencies: {},
+    devDependencies: {},
+  };
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('buildPackageMap', () => {
+  it('keeps in-repo workspace paths as workflow paths', () => {
+    const rootDir = createTempRepo();
+    const packageDir = join(rootDir, 'apps/web');
+    mkdirSync(packageDir, { recursive: true });
+
+    const { packageMap, workspaceRoots } = buildPackageMap(
+      [createWorkspacePackage(packageDir, 'web')],
+      rootDir,
+    );
+
+    expect(packageMap.get('web')).toEqual({
+      filesystemPath: 'apps/web',
+      workflowPath: 'apps/web',
+    });
+    expect(Array.from(workspaceRoots)).toEqual(['apps']);
+  });
+
+  it('rebases external workspace paths to in-repo mirrors', () => {
+    const rootDir = createTempRepo();
+    mkdirSync(join(rootDir, 'plugins/design-system'), { recursive: true });
+    const externalPackageDir = join(
+      rootDir,
+      '../crossplatform.ai/plugins/design-system',
+    );
+    mkdirSync(externalPackageDir, { recursive: true });
+
+    const { packageMap, workspaceRoots } = buildPackageMap(
+      [createWorkspacePackage(externalPackageDir, '@repo/design-system')],
+      rootDir,
+    );
+
+    expect(packageMap.get('@repo/design-system')).toEqual({
+      filesystemPath: '../crossplatform.ai/plugins/design-system',
+      workflowPath: 'plugins/design-system',
+    });
+    expect(Array.from(workspaceRoots)).toEqual(['plugins']);
+  });
+
+  it('skips workflow paths for external workspaces without local mirrors', () => {
+    const rootDir = createTempRepo();
+    const externalPackageDir = join(
+      rootDir,
+      '../crossplatform.ai/plugins/ghost',
+    );
+    mkdirSync(externalPackageDir, { recursive: true });
+
+    const { packageMap, workspaceRoots } = buildPackageMap(
+      [createWorkspacePackage(externalPackageDir, '@repo/ghost')],
+      rootDir,
+    );
+
+    expect(packageMap.get('@repo/ghost')).toEqual({
+      filesystemPath: '../crossplatform.ai/plugins/ghost',
+      workflowPath: null,
+    });
+    expect(Array.from(workspaceRoots)).toEqual([]);
+  });
+});

package/src/workspace/package-map.ts

@@ -0,0 +1,74 @@
+import { existsSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import type { WorkspacePackage } from '../graph/types';
+
+export interface MappedWorkspacePath {
+  filesystemPath: string;
+  workflowPath: string | null;
+}
+
+export interface WorkspacePackageMap {
+  packageMap: Map<string, MappedWorkspacePath>;
+  workspaceRoots: Set<string>;
+}
+
+export function normalizeRelativePath(path: string): string {
+  return path.split(sep).join('/');
+}
+
+function resolveWorkflowPath(
+  relativePath: string,
+  rootDir: string,
+): string | null {
+  if (!relativePath.startsWith('../')) {
+    return relativePath;
+  }
+
+  const segments = relativePath.split('/');
+
+  for (let index = 0; index < segments.length; index += 1) {
+    const candidateSegments = segments.slice(index);
+    if (candidateSegments.length === 0 || candidateSegments[0] === '..') {
+      continue;
+    }
+
+    const candidatePath = candidateSegments.join('/');
+    if (existsSync(join(rootDir, candidatePath))) {
+      return candidatePath;
+    }
+  }
+
+  return null;
+}
+
+export function buildPackageMap(
+  packages: WorkspacePackage[],
+  rootDir: string,
+): WorkspacePackageMap {
+  const packageMap = new Map<string, MappedWorkspacePath>();
+  const workspaceRoots = new Set<string>();
+
+  for (const pkg of packages) {
+    const relativePath = normalizeRelativePath(relative(rootDir, pkg.path));
+    const workflowPath = resolveWorkflowPath(relativePath, rootDir);
+
+    packageMap.set(pkg.name, {
+      filesystemPath: relativePath,
+      workflowPath,
+    });
+
+    if (!workflowPath) {
+      continue;
+    }
+
+    const [workspaceRoot] = workflowPath.split('/');
+    if (workspaceRoot) {
+      workspaceRoots.add(workspaceRoot);
+    }
+  }
+
+  return {
+    packageMap,
+    workspaceRoots,
+  };
+}