@nx/dotnet 0.0.1 → 22.0.0-beta.9

package/src/plugins/plugin.ts

@@ -1,230 +0,0 @@
-import { join, basename, dirname, parse } from 'node:path';
-import {
-  CreateNodes,
-  CreateNodesContext,
-  createNodesFromFiles,
-  CreateNodesV2,
-  CreateDependencies,
-  DependencyType,
-  logger,
-  RawProjectGraphDependency,
-} from '@nx/devkit';
-import { calculateHashesForCreateNodes } from '@nx/devkit/src/utils/calculate-hash-for-create-nodes';
-import { workspaceDataDirectory } from 'nx/src/utils/cache-directory';
-import { hashObject } from 'nx/src/hasher/file-hasher';
-
-// Import utilities
-import {
-  readTargetsCache,
-  writeTargetsToCache,
-  DotNetTargets,
-} from '../utils/cache';
-import { NativeDotNetClient } from '../utils/dotnet-cli';
-import { inferProjectName } from '../utils/dotnet-project-parser';
-import { buildDotNetTargets, NormalizedOptions } from '../utils/target-builder';
-import {
-  createProjectRootMappings,
-  resolveReferenceToProject,
-} from '../utils/dependency-detection';
-import { verboseLog, verboseError } from '../utils/logger';
-
-export interface DotNetPluginOptions {
-  buildTargetName?: string;
-  testTargetName?: string;
-  cleanTargetName?: string;
-  restoreTargetName?: string;
-  publishTargetName?: string;
-  packTargetName?: string;
-}
-
-const dotnetProjectGlob = '**/*.{csproj,fsproj,vbproj}';
-
-export const createNodesV2: CreateNodesV2<DotNetPluginOptions> = [
-  dotnetProjectGlob,
-  async (configFilePaths, options, context) => {
-    const optionsHash = hashObject(options);
-    const cachePath = join(
-      workspaceDataDirectory,
-      `dotnet-${optionsHash}.hash`
-    );
-    const targetsCache = readTargetsCache(cachePath);
-    const normalizedOptions = normalizeOptions(options);
-
-    // Group project files by their project root
-    const projectRootToFiles = new Map<string, string[]>();
-    for (const configFile of configFilePaths) {
-      const projectRoot = dirname(configFile);
-      if (!projectRootToFiles.has(projectRoot)) {
-        projectRootToFiles.set(projectRoot, []);
-      }
-      projectRootToFiles.get(projectRoot)!.push(configFile);
-    }
-
-    const projectRoots = Array.from(projectRootToFiles.keys());
-
-    // Calculate all hashes at once
-    const hashes = await calculateHashesForCreateNodes(
-      projectRoots,
-      normalizedOptions,
-      context
-    );
-
-    try {
-      return await createNodesFromFiles(
-        (projectRoot, options, context, idx) =>
-          createNodesInternal(
-            projectRoot,
-            options,
-            context,
-            targetsCache,
-            projectRootToFiles.get(projectRoot)!,
-            hashes[idx]
-          ),
-        projectRoots,
-        options,
-        context
-      );
-    } finally {
-      writeTargetsToCache(cachePath, targetsCache);
-    }
-  },
-];
-
-async function createNodesInternal(
-  projectRoot: string,
-  options: DotNetPluginOptions,
-  context: CreateNodesContext,
-  targetsCache: Record<string, DotNetTargets>,
-  projectFiles: string[],
-  hash: string
-) {
-  // For .NET projects, we don't require package.json or project.json
-  // The .csproj/.fsproj/.vbproj file itself indicates a valid project
-
-  const normalizedOptions = normalizeOptions(options);
-
-  targetsCache[hash] ??= await buildDotNetTargets(
-    projectRoot,
-    projectFiles,
-    normalizedOptions,
-    context
-  );
-  const { targets, metadata } = targetsCache[hash];
-
-  // For project naming, use the directory name when multiple projects,
-  // or the single project file name when only one
-  const projectName =
-    projectFiles.length === 1
-      ? inferProjectName(projectFiles[0])
-      : basename(projectRoot)
-          .replace(/[^a-z0-9\-]/gi, '-')
-          .toLowerCase();
-
-  return {
-    projects: {
-      [projectRoot]: {
-        name: projectName,
-        root: projectRoot,
-        targets,
-        metadata,
-      },
-    },
-  };
-}
-
-function normalizeOptions(options: DotNetPluginOptions): NormalizedOptions {
-  return {
-    buildTargetName: options?.buildTargetName ?? 'build',
-    testTargetName: options?.testTargetName ?? 'test',
-    cleanTargetName: options?.cleanTargetName ?? 'clean',
-    restoreTargetName: options?.restoreTargetName ?? 'restore',
-    publishTargetName: options?.publishTargetName ?? 'publish',
-    packTargetName: options?.packTargetName ?? 'pack',
-  };
-}
-
-export const createDependencies: CreateDependencies<
-  DotNetPluginOptions
-> = async (_, ctx) => {
-  const dependencies: RawProjectGraphDependency[] = [];
-
-  const rootMap = createProjectRootMappings(ctx.projects);
-
-  verboseLog('[dotnet] createDependencies: Starting dependency detection');
-  verboseLog(`[dotnet] Workspace root: ${ctx.workspaceRoot}`);
-  verboseLog(
-    `[dotnet] Number of projects: ${Object.keys(ctx.projects).length}`
-  );
-  verboseLog(`[dotnet] Projects: ${Object.keys(ctx.projects).join(', ')}`);
-  verboseLog(`[dotnet] Root map entries: ${Object.keys(rootMap).length}`);
-  verboseLog(`[dotnet] Root map: ${JSON.stringify(rootMap, null, 2)}`);
-
-  // Use dotnet CLI for dependency detection
-  const dotnetClient = new NativeDotNetClient(ctx.workspaceRoot);
-
-  for (const [source] of Object.entries(ctx.projects)) {
-    const files = ctx.filesToProcess.projectFileMap[source] || [];
-    verboseLog(
-      `[dotnet] Processing project: ${source} (${files.length} files)`
-    );
-
-    for (const file of files) {
-      const { ext } = parse(file.file);
-      verboseLog(`[dotnet]   File: ${file.file} (ext: ${ext})`);
-      if (['.csproj', '.fsproj', '.vbproj'].includes(ext)) {
-        try {
-          const fullPath = join(ctx.workspaceRoot, file.file);
-          verboseLog(`[dotnet]   Getting references for: ${fullPath}`);
-          const references = await dotnetClient.getProjectReferencesAsync(
-            fullPath
-          );
-          verboseLog(
-            `[dotnet]   Found ${references.length} references: ${JSON.stringify(
-              references
-            )}`
-          );
-
-          for (const reference of references) {
-            verboseLog(`[dotnet]     Resolving reference: ${reference}`);
-            const target = resolveReferenceToProject(
-              reference,
-              file.file,
-              rootMap,
-              ctx.workspaceRoot
-            );
-            verboseLog(`[dotnet]     Resolved to target: ${target}`);
-            if (target) {
-              dependencies.push({
-                source,
-                target,
-                type: DependencyType.static,
-                sourceFile: file.file,
-              });
-              verboseLog(
-                `[dotnet]     ✓ Added dependency: ${source} -> ${target}`
-              );
-            } else {
-              verboseLog(
-                `[dotnet]     ✗ Could not resolve reference to project`
-              );
-            }
-          }
-        } catch (error) {
-          verboseError(
-            `[dotnet] Failed to get dependencies for ${file.file}: ${error.message}`
-          );
-          verboseError(`[dotnet] Error stack: ${error.stack}`);
-        }
-      }
-    }
-  }
-
-  verboseLog(
-    `[dotnet] createDependencies: Completed with ${dependencies.length} dependencies`
-  );
-  verboseLog(
-    `[dotnet] Final dependencies: ${JSON.stringify(dependencies, null, 2)}`
-  );
-
-  return dependencies;
-};

package/src/utils/cache.ts

@@ -1,19 +0,0 @@
-import { ProjectConfiguration, readJsonFile, writeJsonFile } from '@nx/devkit';
-import { existsSync } from 'fs';
-
-export type DotNetTargets = Pick<ProjectConfiguration, 'targets' | 'metadata'>;
-
-export function readTargetsCache(
-  cachePath: string
-): Record<string, DotNetTargets> {
-  return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && existsSync(cachePath)
-    ? readJsonFile(cachePath)
-    : {};
-}
-
-export function writeTargetsToCache(
-  cachePath: string,
-  results: Record<string, DotNetTargets>
-) {
-  writeJsonFile(cachePath, results);
-}

package/src/utils/dependency-detection.ts

@@ -1,84 +0,0 @@
-import { dirname, relative, resolve, normalize } from 'node:path';
-import { ProjectConfiguration, normalizePath } from '@nx/devkit';
-import { verboseLog } from './logger';
-
-export function createProjectRootMappings(
-  projects: Record<string, ProjectConfiguration>
-): Record<string, string> {
-  const rootMap: Record<string, string> = {};
-  verboseLog('[dotnet-deps] Creating project root mappings');
-  for (const [, project] of Object.entries(projects)) {
-    if (project.root && project.name) {
-      rootMap[project.root] = project.name;
-      verboseLog(`[dotnet-deps]   Mapping: ${project.root} -> ${project.name}`);
-    }
-  }
-  verboseLog(`[dotnet-deps] Created ${Object.keys(rootMap).length} mappings`);
-  return rootMap;
-}
-
-export function findProjectForPath(
-  filePath: string,
-  rootMap: Record<string, string>
-): string | undefined {
-  let currentPath = normalizePath(filePath);
-  verboseLog(`[dotnet-deps] Finding project for path: ${filePath}`);
-  verboseLog(`[dotnet-deps]   Normalized path: ${currentPath}`);
-
-  const checkedPaths: string[] = [];
-  for (
-    ;
-    currentPath !== dirname(currentPath);
-    currentPath = dirname(currentPath)
-  ) {
-    checkedPaths.push(currentPath);
-    const project = rootMap[currentPath];
-    if (project) {
-      verboseLog(`[dotnet-deps]   Found project: ${project} at ${currentPath}`);
-      return project;
-    }
-  }
-
-  const result = rootMap[currentPath];
-  checkedPaths.push(currentPath);
-  verboseLog(`[dotnet-deps]   Checked paths: ${checkedPaths.join(' -> ')}`);
-  verboseLog(`[dotnet-deps]   Result: ${result || 'NOT FOUND'}`);
-  return result;
-}
-
-export function resolveReferenceToProject(
-  reference: string,
-  sourceFile: string,
-  rootMap: Record<string, string>,
-  workspaceRoot: string
-): string | undefined {
-  verboseLog(`[dotnet-deps] Resolving reference to project:`);
-  verboseLog(`[dotnet-deps]   Reference: ${reference}`);
-  verboseLog(`[dotnet-deps]   Source file: ${sourceFile}`);
-  verboseLog(`[dotnet-deps]   Workspace root: ${workspaceRoot}`);
-
-  const resolved = resolve(workspaceRoot, dirname(sourceFile), reference);
-  verboseLog(`[dotnet-deps]   Resolved absolute path: ${resolved}`);
-
-  const relativePath = relative(workspaceRoot, resolved);
-  verboseLog(`[dotnet-deps]   Relative path (raw): ${relativePath}`);
-
-  // First normalize path separators (backslashes to forward slashes)
-  // Then resolve .. segments
-  const pathWithForwardSlashes = normalizePath(relativePath);
-  verboseLog(
-    `[dotnet-deps]   Path with forward slashes: ${pathWithForwardSlashes}`
-  );
-
-  const normalizedRelativePath = normalize(pathWithForwardSlashes);
-  verboseLog(
-    `[dotnet-deps]   Relative path (normalized): ${normalizedRelativePath}`
-  );
-
-  const result = findProjectForPath(normalizedRelativePath, rootMap);
-  verboseLog(
-    `[dotnet-deps]   Final resolved project: ${result || 'NOT FOUND'}`
-  );
-
-  return result;
-}

package/src/utils/dotnet-cli.ts

@@ -1,52 +0,0 @@
-import { execSync } from 'node:child_process';
-import { verboseLog, verboseError } from './logger';
-
-export interface DotNetClient {
-  getProjectReferencesAsync(projectFile: string): Promise<string[]>;
-}
-
-export class NativeDotNetClient implements DotNetClient {
-  constructor(private workspaceRoot: string) {}
-
-  async getProjectReferencesAsync(projectFile: string): Promise<string[]> {
-    try {
-      verboseLog(`[dotnet-cli] Getting references for: ${projectFile}`);
-      verboseLog(`[dotnet-cli]   Working directory: ${this.workspaceRoot}`);
-      const command = `dotnet list "${projectFile}" reference`;
-      verboseLog(`[dotnet-cli]   Command: ${command}`);
-
-      const output = execSync(command, {
-        cwd: this.workspaceRoot,
-        encoding: 'utf8',
-        windowsHide: true,
-        stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
-      });
-
-      verboseLog(`[dotnet-cli]   Raw output (${output.length} chars):`);
-      verboseLog(
-        `[dotnet-cli]   ${output.split('\n').join('\n[dotnet-cli]   ')}`
-      );
-
-      const references = output
-        .split('\n')
-        .slice(2) // Skip header lines
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-
-      verboseLog(
-        `[dotnet-cli]   Parsed references (${
-          references.length
-        }): ${JSON.stringify(references)}`
-      );
-      return references;
-    } catch (error) {
-      verboseError(
-        `[dotnet-cli] Failed to get project references for ${projectFile}: ${error.message}`
-      );
-      verboseError(
-        `[dotnet-cli] Error details: ${JSON.stringify(error, null, 2)}`
-      );
-      return [];
-    }
-  }
-}

package/src/utils/dotnet-project-parser.ts

@@ -1,105 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, basename, parse } from 'node:path';
-
-export interface ProjectInfo {
-  targetFramework?: string;
-  outputType?: string;
-  packageReferences: string[];
-  projectReferences: string[];
-  isTestProject: boolean;
-  isExecutable: boolean;
-  projectType: 'csharp' | 'fsharp' | 'vb';
-}
-
-export function parseProjectFile(projectFilePath: string): ProjectInfo {
-  const content = readFileSync(projectFilePath, 'utf-8');
-  const packageReferences: string[] = [];
-  const projectReferences: string[] = [];
-
-  // Simple regex parsing for MSBuild project files
-  const packageReferenceRegex = /<PackageReference\s+Include="([^"]+)"/g;
-  const projectReferenceRegex = /<ProjectReference\s+Include="([^"]+)"/g;
-  const targetFrameworkRegex = /<TargetFramework>([^<]+)<\/TargetFramework>/;
-  const outputTypeRegex = /<OutputType>([^<]+)<\/OutputType>/;
-
-  let match: RegExpExecArray | null;
-  while ((match = packageReferenceRegex.exec(content)) !== null) {
-    packageReferences.push(match[1]);
-  }
-
-  while ((match = projectReferenceRegex.exec(content)) !== null) {
-    projectReferences.push(match[1]);
-  }
-
-  const targetFrameworkMatch = content.match(targetFrameworkRegex);
-  const outputTypeMatch = content.match(outputTypeRegex);
-
-  const targetFramework = targetFrameworkMatch?.[1];
-  const outputType = outputTypeMatch?.[1];
-
-  // Detect test projects by common test package references
-  const testPackages = [
-    'Microsoft.NET.Test.Sdk',
-    'xunit',
-    'xunit.runner.visualstudio',
-    'MSTest.TestAdapter',
-    'MSTest.TestFramework',
-    'NUnit',
-    'NUnit3TestAdapter',
-  ];
-  const isTestProject = packageReferences.some((pkg) =>
-    testPackages.some((testPkg) => pkg.includes(testPkg))
-  );
-
-  const isExecutable =
-    outputType?.toLowerCase() === 'exe' ||
-    content.includes('<OutputType>Exe</OutputType>');
-
-  // Determine project type from file extension
-  const { ext } = parse(projectFilePath);
-  let projectType: 'csharp' | 'fsharp' | 'vb';
-  switch (ext) {
-    case '.fsproj':
-      projectType = 'fsharp';
-      break;
-    case '.vbproj':
-      projectType = 'vb';
-      break;
-    default:
-      projectType = 'csharp';
-  }
-
-  return {
-    targetFramework,
-    outputType,
-    packageReferences,
-    projectReferences,
-    isTestProject,
-    isExecutable,
-    projectType,
-  };
-}
-
-export function inferProjectName(configFilePath: string): string {
-  const { name } = parse(configFilePath);
-
-  // Convert PascalCase to kebab-case for regular project names
-  return name
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
-    .toLowerCase()
-    .replace(/[^a-z0-9\-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-}
-
-export function extractProjectNameFromFile(projectFileName: string): string {
-  const { name } = parse(projectFileName);
-
-  // Convert PascalCase to kebab-case for target names
-  return name
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
-    .toLowerCase()
-    .replace(/[^a-z0-9\-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-}

package/src/utils/logger.ts

@@ -1,24 +0,0 @@
-import { logger } from '@nx/devkit';
-
-let verboseLoggingEnabled: boolean | undefined;
-
-function isVerboseLoggingEnabled(): boolean {
-  if (verboseLoggingEnabled === undefined) {
-    verboseLoggingEnabled =
-      process.env.NX_DOTNET_VERBOSE_LOGGING === 'true' ||
-      process.env.NX_VERBOSE_LOGGING === 'true';
-  }
-  return verboseLoggingEnabled;
-}
-
-export function verboseLog(message: string): void {
-  if (isVerboseLoggingEnabled()) {
-    logger.log(message);
-  }
-}
-
-export function verboseError(message: string): void {
-  if (isVerboseLoggingEnabled()) {
-    logger.error(message);
-  }
-}