Add support for TS project not located at the root of the repo. (#45)

* add arg fowarding to call to `tsc --showConfig`

* add utility helper to get project path

* update util function naming

* add project path from args to isFileOnPath

* add / update e2e tests

* v2.1.0

Author: neenjaw

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2022-10-14
+
+### Added
+
+- Support for projects not located at root of repository using `tsc`'s `--project` flag.
+
 ## [2.0.2] - 2022-07-28
 
 ### Fixed

e2e/fixtures/non-root-config/nested/ignored.ts

@@ -0,0 +1,4 @@
+// @ts-strict-ignore
+const text: string = null;
+
+export {};

e2e/fixtures/non-root-config/nested/strict.ts

@@ -0,0 +1,3 @@
+const text: string = null;
+
+export {};

e2e/fixtures/non-root-config/nested/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "lib": ["es2018"],
+    "baseUrl": "./",
+    "outDir": "./dist",
+    "strict": false,
+    "pretty": true,
+    "esModuleInterop": true,
+    "noImplicitAny": true,
+    "plugins": [
+      {
+        "name": "../../dist/plugin"
+      }
+    ]
+  }
+}

e2e/fixtures/paths.ts

@@ -18,3 +18,12 @@ export const fixtureWithPathConfig = {
     excludedWithStrictComment: 'excluded/excludedWithStrictComment.ts',
   },
 };
+
+export const fixtureWithNonRootConfig = {
+  projectPath: path.resolve(__dirname, 'non-root-config'),
+  filePaths: {
+    strict: 'strict.ts',
+    ignored: 'ignored.ts',
+  },
+  args: ['--project', './nested/tsconfig.json'],
+};

e2e/plugin/singleFile.spec.ts

@@ -1,5 +1,9 @@
 import { getDiagnostics } from './utils/getDiagnostics';
-import { fixtureWithDefaultConfig, fixtureWithPathConfig } from '../fixtures/paths';
+import {
+  fixtureWithDefaultConfig,
+  fixtureWithNonRootConfig,
+  fixtureWithPathConfig,
+} from '../fixtures/paths';
 
 describe('single file diagnostics', () => {
   it('should enable strict mode by default in project without config', async () => {

e2e/tsc-strict/tsc-strict.spec.ts

@@ -1,6 +1,10 @@
 import execa from 'execa';
 import { join } from 'path';
-import { fixtureWithDefaultConfig, fixtureWithPathConfig } from '../fixtures/paths';
+import {
+  fixtureWithDefaultConfig,
+  fixtureWithNonRootConfig,
+  fixtureWithPathConfig,
+} from '../fixtures/paths';
 
 const runInPath = async (
   path: string,
@@ -67,3 +71,18 @@ it('should enable strict mode with a relative path config', async () => {
   expect(stdout).toEqual(expect.stringContaining(filePaths.included));
   expect(stdout).toMatch(/error TS2322: Type 'null' is not assignable to type 'string'\./i);
 });
+
+it('should enable strict mode with a non-root path config', async () => {
+  //given
+  const { projectPath, filePaths, args } = fixtureWithNonRootConfig;
+
+  //when
+  const stdout = await runInPath(projectPath, args);
+
+  // then
+  expect(stdout).toEqual(expect.stringContaining(filePaths.strict));
+  expect(stdout).not.toEqual(expect.stringContaining(filePaths.ignored));
+  expect(stdout).toMatch(/error TS2322: Type 'null' is not assignable to type 'string'\./i);
+  expect(stdout).toMatch(/Found 1 strict file/i);
+  expect(stdout).toMatch(/Found 1 error/i);
+});

package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-strict-plugin",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Typescript tools that help with migration to the strict mode",
   "author": "Allegro",
   "contributors": [

src/cli/typescript/typescript.ts

@@ -1,7 +1,7 @@
 import execa, { ExecaError } from 'execa';
 
 export const showConfig = async (): Promise<string> => {
-  const output = await execa('tsc', ['--showConfig'], {
+  const output = await execa('tsc', [...process.argv.slice(2), '--showConfig'], {
     all: true,
     preferLocal: true,
   });

src/common/__tests__/isFileOnPath.spec.ts

@@ -0,0 +1,65 @@
+import { getProjectPathFromArgs } from '../utils';
+import { getAbsolutePath } from '../getAbsolutePath';
+import { mocked } from 'jest-mock';
+import { isFileOnPath } from '../isFileOnPath';
+
+jest.mock('../utils', () => ({
+  ...jest.requireActual('../utils'),
+  getProjectPathFromArgs: jest.fn(),
+}));
+
+jest.mock('../getAbsolutePath', () => ({
+  getAbsolutePath: jest.fn(),
+}));
+
+const getProjectPathFromArgsMock = mocked(getProjectPathFromArgs);
+const getAbsolutePathMock = mocked(getAbsolutePath);
+
+const projectPathFromArgs = './defined_project_path';
+
+describe('isFileOnPath', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+    getProjectPathFromArgsMock.mockReturnValue(projectPathFromArgs);
+    getAbsolutePathMock.mockReturnValue('/some_file_path/lib_dir');
+  });
+
+  it('when projectPath argument used, prefer argument value', () => {
+    // given
+    const projectPath = '/some_path';
+
+    // when
+    isFileOnPath({
+      filePath: '/some_file_path/lib_dir/file.ts',
+      targetPath: './lib_dir',
+      projectPath,
+    });
+
+    // then
+    expect(getAbsolutePathMock).toHaveBeenCalledTimes(1);
+    expect(getAbsolutePathMock).toHaveBeenCalledWith(projectPath, './lib_dir');
+  });
+
+  it('when getProjectPathFromArgs is defined, use defined value', () => {
+    //when
+    isFileOnPath({ filePath: '/some_file_path/lib_dir/file.ts', targetPath: './lib_dir' });
+
+    // then
+    expect(getAbsolutePathMock).toHaveBeenCalledTimes(1);
+    expect(getAbsolutePathMock).toHaveBeenCalledWith(projectPathFromArgs, './lib_dir');
+    expect(projectPathFromArgs).not.toEqual(process.cwd());
+  });
+
+  it('when getProjectPathFromArgs is undefined, fallback to current working directory to match', () => {
+    // given
+    getProjectPathFromArgsMock.mockReturnValue(undefined);
+    const cwd = process.cwd();
+
+    // when
+    isFileOnPath({ filePath: '/some_file_path/lib_dir/file.ts', targetPath: './lib_dir' });
+
+    // then
+    expect(getAbsolutePathMock).toHaveBeenCalledTimes(1);
+    expect(getAbsolutePathMock).toHaveBeenCalledWith(cwd, './lib_dir');
+  });
+});

src/common/__tests__/utils.spec.ts

@@ -0,0 +1,35 @@
+import { getProjectPathFromArgs } from '../utils';
+
+let globalProcessArgv: string[];
+
+describe('utils', () => {
+  describe('getProjectPathFromArgs', () => {
+    beforeEach(() => {
+      globalProcessArgv = process.argv;
+    });
+
+    afterEach(() => {
+      process.argv = globalProcessArgv;
+    });
+
+    it('should return undefined if --project not present in path', () => {
+      process.argv = [
+        '/usr/bin/nodejs/18.7.0/bin/node',
+        '/home/neenjaw/typescript-strict-plugin/node_modules/.bin/update-strict-comments',
+      ];
+
+      expect(getProjectPathFromArgs()).toEqual(undefined);
+    });
+
+    it('should return undefined if --project not present in path', () => {
+      process.argv = [
+        '/usr/bin/nodejs/18.7.0/bin/node',
+        '/home/neenjaw/typescript-strict-plugin/node_modules/.bin/update-strict-comments',
+        '--project',
+        './some/inner/project/tsconfig.json',
+      ];
+
+      expect(getProjectPathFromArgs()).toEqual('./some/inner/project');
+    });
+  });
+});

src/common/isFileOnPath.ts

@@ -1,5 +1,6 @@
 import { getPosixFilePath } from './utils';
 import { getAbsolutePath } from './getAbsolutePath';
+import { getProjectPathFromArgs } from './utils';
 
 interface IsFileOnPathParams {
   filePath: string;
@@ -10,7 +11,7 @@ interface IsFileOnPathParams {
 export function isFileOnPath({
   filePath,
   targetPath,
-  projectPath = process.cwd(),
+  projectPath = getProjectPathFromArgs() ?? process.cwd(),
 }: IsFileOnPathParams): boolean {
   const absolutePathToStrictFiles = getAbsolutePath(projectPath, targetPath);
 

src/common/utils.ts

@@ -18,3 +18,13 @@ export function isFile(path: string) {
     return false;
   }
 }
+
+export function getProjectPathFromArgs(): string | undefined {
+  const args = process.argv.slice(2);
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === '--project') {
+      return path.dirname(args[index + 1]);
+    }
+  }
+}