feat(core): pickup global.json overrides at the project level

To accomplish this `dotnet` must be launched from the project's root directories.

Closes #87
Closes #86

Author: AgentEnder

.github/workflows/pr.yml

@@ -1,9 +1,7 @@
 name: Run PR checks
 
-on:
-  # Triggers the workflow on push or pull request events but only for the master branch
-  pull_request:
-    branches: [master, dev]
+on: pull_request
+    
 
 env:
   NX_BRANCH: ${{ github.event.number }}

docs/core/executors/test.md

@@ -100,3 +100,7 @@ Runs test via the dotnet cli
 ### verbosity
 
 - (string): Sets the verbosity level of the command. For more information, see LoggerVerbosity.
+
+### watch
+
+- (boolean): Determines if `dotnet test` or `dotnet watch test` is used to execute tests.

packages/core/src/executors/build/executor.ts

@@ -1,4 +1,5 @@
 import { ExecutorContext } from '@nrwl/devkit';
+import { appRootPath } from '@nrwl/tao/src/utils/app-root';
 
 import {
   dotnetBuildFlags,
@@ -9,6 +10,7 @@ import {
   getExecutedProjectConfiguration,
   getProjectFileForNxProject,
 } from '@nx-dotnet/utils';
+import { resolve } from 'path';
 
 import { BuildExecutorSchema } from './schema';
 
@@ -18,9 +20,15 @@ export default async function runExecutor(
   dotnetClient: DotNetClient = new DotNetClient(dotnetFactory()),
 ) {
   const nxProjectConfiguration = getExecutedProjectConfiguration(context);
-  const projectFilePath = await getProjectFileForNxProject(
-    nxProjectConfiguration,
+  dotnetClient.cwd = resolve(appRootPath, nxProjectConfiguration.root);
+  dotnetClient.printSdkVersion();
+  const projectFilePath = resolve(
+    appRootPath,
+    await getProjectFileForNxProject(nxProjectConfiguration),
   );
+  options.output = options.output
+    ? resolve(appRootPath, options.output)
+    : undefined;
 
   dotnetClient.build(
     projectFilePath,

packages/core/src/executors/publish/executor.spec.ts

@@ -18,7 +18,7 @@ jest.mock('../../../../dotnet/src/lib/core/dotnet.client');
 
 describe('Publish Executor', () => {
   let context: ExecutorContext;
-  let dotnetClient: DotNetClient;
+  let dotnetClient: jest.Mocked<DotNetClient>;
 
   beforeEach(() => {
     context = {
@@ -42,7 +42,9 @@ describe('Publish Executor', () => {
       },
       isVerbose: false,
     };
-    dotnetClient = new DotNetClient(mockDotnetFactory());
+    dotnetClient = new DotNetClient(
+      mockDotnetFactory(),
+    ) as jest.Mocked<DotNetClient>;
   });
 
   afterEach(async () => {
@@ -95,9 +97,21 @@ describe('Publish Executor', () => {
     }
 
     const res = await executor(options, context, dotnetClient);
-    expect(
-      (dotnetClient as jest.Mocked<DotNetClient>).publish,
-    ).toHaveBeenCalled();
+    expect(dotnetClient.publish).toHaveBeenCalled();
+    expect(res.success).toBeTruthy();
+  });
+
+  it('should pass path relative to project root, not workspace root', async () => {
+    const directoryPath = `${root}/apps/my-app`;
+    try {
+      await fs.mkdir(directoryPath, { recursive: true });
+      await Promise.all([fs.writeFile(`${directoryPath}/1.csproj`, '')]);
+    } catch (e) {
+      console.warn(e.message);
+    }
+    const res = await executor(options, context, dotnetClient);
+    expect(dotnetClient.publish).toHaveBeenCalled();
+    expect(dotnetClient.cwd).toEqual(directoryPath);
     expect(res.success).toBeTruthy();
   });
 });

packages/core/src/executors/publish/executor.ts

@@ -1,4 +1,5 @@
 import { ExecutorContext } from '@nrwl/devkit';
+import { appRootPath } from '@nrwl/tao/src/utils/app-root';
 
 import {
   DotNetClient,
@@ -9,6 +10,7 @@ import {
   getExecutedProjectConfiguration,
   getProjectFileForNxProject,
 } from '@nx-dotnet/utils';
+import { resolve } from 'path';
 
 import { PublishExecutorSchema } from './schema';
 
@@ -18,14 +20,17 @@ export default async function runExecutor(
   dotnetClient: DotNetClient = new DotNetClient(dotnetFactory()),
 ) {
   const nxProjectConfiguration = getExecutedProjectConfiguration(context);
+  const cwd = resolve(appRootPath, nxProjectConfiguration.root);
+  dotnetClient.cwd = cwd;
   const projectFilePath = await getProjectFileForNxProject(
     nxProjectConfiguration,
   );
 
   const { publishProfile, extraParameters, ...flags } = options;
+  flags.output = flags.output ? resolve(appRootPath, flags.output) : undefined;
 
   dotnetClient.publish(
-    projectFilePath,
+    resolve(appRootPath, projectFilePath),
     Object.keys(flags).map((x) => ({
       flag: x as dotnetPublishFlags,
       value: (options as Record<string, string | boolean>)[x],

packages/core/src/executors/publish/schema.d.ts

@@ -3,6 +3,7 @@ import { dotnetPublishFlags } from '@nx-dotnet/dotnet';
 export type PublishExecutorSchema = {
   [key in dotnetPublishFlags]?: string | boolean;
 } & {
+  output?: string;
   publishProfile?: string;
   extraParameters?: string;
 };

packages/core/src/executors/serve/executor.ts

@@ -1,7 +1,8 @@
 import { ExecutorContext } from '@nrwl/devkit';
+import { appRootPath } from '@nrwl/tao/src/utils/app-root';
 
 import { ChildProcess } from 'child_process';
-import * as chockidar from 'chokidar';
+import { resolve as pathResolve } from 'path';
 
 import {
   DotNetClient,
@@ -10,17 +11,15 @@ import {
   dotnetRunOptions,
 } from '@nx-dotnet/dotnet';
 import {
-  getDependantProjectsForNxProject,
   getExecutedProjectConfiguration,
   getProjectFileForNxProject,
+  handleChildProcessPassthrough,
   rimraf,
 } from '@nx-dotnet/utils';
 
 import { ServeExecutorSchema } from './schema';
 
-let resolver: (returnObject: { success: boolean }) => void;
 let childProcess: ChildProcess;
-let timeout: NodeJS.Timeout;
 let projectDirectory: string;
 
 export default function dotnetRunExecutor(
@@ -29,90 +28,28 @@ export default function dotnetRunExecutor(
   dotnetClient: DotNetClient = new DotNetClient(dotnetFactory()),
 ): Promise<{ success: boolean }> {
   const nxProjectConfiguration = getExecutedProjectConfiguration(context);
+  const cwd = pathResolve(appRootPath, nxProjectConfiguration.root);
+  dotnetClient.cwd = cwd;
 
-  return getProjectFileForNxProject(nxProjectConfiguration).then((project) => {
-    projectDirectory = nxProjectConfiguration.root;
-
-    return new Promise((resolve) => {
-      resolver = resolve;
-
-      const watcher = chockidar.watch(nxProjectConfiguration.root);
-
-      getDependantProjectsForNxProject(
-        context.projectName as string,
-        context.workspace,
-        (dependency) => {
-          watcher.add(dependency.root);
-        },
-      );
-
-      watcher.on('all', (event, path) => {
-        if (path.includes('bin') || path.includes('obj')) {
-          return;
-        }
-
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-
-        timeout = setTimeout(() => {
-          setupDotnetRun(dotnetClient, project, options);
-        }, 1000);
-
-        console.log(event, path);
-      });
-    });
-  });
+  return getProjectFileForNxProject(nxProjectConfiguration).then((project) =>
+    runDotnetRun(dotnetClient, pathResolve(appRootPath, project), options),
+  );
 }
 
-const setupDotnetRun = (
+const runDotnetRun = (
   dotnetClient: DotNetClient,
   project: string,
   options: ServeExecutorSchema,
 ) => {
-  if (childProcess) {
-    childProcess.kill('SIGTERM');
-  }
-
   const opts: dotnetRunOptions = Object.keys(options).map((x) => ({
     flag: x as dotnetRunFlags,
     value: (options as Record<string, string | boolean>)[x],
   }));
 
-  childProcess = dotnetClient.run(project, opts);
-
-  childProcess.on('error', (err) => {
-    console.error(err);
+  childProcess = dotnetClient.run(project, true, opts);
+  return handleChildProcessPassthrough(childProcess).then(async () => {
+    await rimraf(projectDirectory + '/bin');
+    await rimraf(projectDirectory + '/obj');
+    return { success: true };
   });
 };
-
-const exitHandler = async (options: { exit: boolean }, exitCode = 0) => {
-  console.log('Exit Handler Called');
-
-  await rimraf(projectDirectory + '/bin');
-  await rimraf(projectDirectory + '/obj');
-
-  if (exitCode || exitCode === 0) console.log(exitCode);
-
-  if (childProcess) {
-    childProcess.kill('SIGINT');
-  }
-  resolver({
-    success: true,
-  });
-
-  if (options.exit) process.exit();
-};
-
-//do something when app is closing
-process.on('exit', () => exitHandler({ exit: false }));
-
-//catches ctrl+c event
-process.on('SIGINT', () => exitHandler({ exit: true }));
-
-// catches "kill pid" (for example: nodemon restart)
-process.on('SIGUSR1', () => exitHandler({ exit: true }));
-process.on('SIGUSR2', () => exitHandler({ exit: true }));
-
-//catches uncaught exceptions
-process.on('uncaughtException', () => exitHandler({ exit: true }));

packages/core/src/executors/test/executor.ts

@@ -1,4 +1,7 @@
 import { ExecutorContext } from '@nrwl/devkit';
+import { appRootPath } from '@nrwl/tao/src/utils/app-root';
+
+import { resolve } from 'path';
 
 import {
   DotNetClient,
@@ -8,28 +11,42 @@ import {
 import {
   getExecutedProjectConfiguration,
   getProjectFileForNxProject,
+  handleChildProcessPassthrough,
+  isChildProcess,
+  rimraf,
 } from '@nx-dotnet/utils';
 
 import { TestExecutorSchema } from './schema';
 
+let projectDirectory: string;
+
 export default async function runExecutor(
   options: TestExecutorSchema,
   context: ExecutorContext,
   dotnetClient: DotNetClient = new DotNetClient(dotnetFactory()),
-) {
+): Promise<{ success: boolean }> {
   const nxProjectConfiguration = getExecutedProjectConfiguration(context);
+  projectDirectory = resolve(appRootPath, nxProjectConfiguration.root);
   const projectFilePath = await getProjectFileForNxProject(
     nxProjectConfiguration,
   );
+  dotnetClient.cwd = projectDirectory;
+  const { watch, ...parsedOptions } = options;
 
-  dotnetClient.test(
-    projectFilePath,
+  const result = dotnetClient.test(
+    resolve(appRootPath, projectFilePath),
+    watch,
     Object.keys(options).map((x) => ({
       flag: x as dotnetTestFlags,
-      value: (options as Record<string, string | boolean>)[x],
+      value: (parsedOptions as Record<string, string | boolean>)[x],
     })),
   );
 
+  if (watch && isChildProcess(result)) {
+    await handleChildProcessPassthrough(result);
+    await rimraf(projectDirectory + '/bin');
+    await rimraf(projectDirectory + '/obj');
+  }
   return {
     success: true,
   };

packages/core/src/executors/test/schema.d.ts

@@ -31,4 +31,5 @@ export interface TestExecutorSchema {
     | 'detailed'
     | 'diag'
     | 'diagnostic';
+  watch?: boolean;
 }

packages/core/src/executors/test/schema.json

@@ -108,6 +108,11 @@
         "diag",
         "diagnostic"
       ]
+    },
+    "watch": {
+      "description": "Determines if `dotnet test` or `dotnet watch test` is used to execute tests.",
+      "type": "boolean",
+      "default": false
     }
   },
   "required": []