feat(core): support multiple entry points

feat: update get entries

chore: add test project for multi-project setup

docs(core): update CLI docs with information about entryPoints

refactor(core): remove unused import

refactor(core): move entry type

feat(core): validate correct entry settings

chore(core): add tests for list in case of entryPoints

refactor(core): fix case for parse-config

chore(core): fix spacing

fix(core): re-add entryPoints to Configuration

chore(core): surpass eslint issue

refactor(test-projects): remove empty style sheets

refactor(core): remove type assertions

refactor(core): correct type-narrowing for isEmptyRecord

Author: michaelbe812

docs/docs/cli.md

@@ -10,20 +10,29 @@ The core package (@softarc/sheriff-core) comes with a CLI to initialize the conf
 
 Run `npx sheriff init` to create a `sheriff.config.ts`. Its configuration runs with [automatic tagging](./dependency-rules#automatic-tagging), meaning no dependency rules are in place, and it only checks for the module boundaries.
 
-## `verify [main.ts]`
+## `verify`
+Run `npx sheriff verify` either against an `entryFile` or against one or multiple `entryPoints` to check if your project violates any of your rules. 
 
-Run `npx sheriff verify main.ts` to check if your project violates any of your rules. `main.ts` is the entry file where Sheriff should traverse the imports.
+To run sheriff against an `entryFile` run `npx sheriff verify main.ts`. `main.ts` is the entry file where Sheriff should traverse the imports.
 
 Depending on your project, you will likely have a different entry file. For example, with an Angular CLI-based project, it would be `npx sheriff verify src/main.ts`.
 
 You can omit the entry file if you set a value to the property `entryFile` in the `sheriff.config.ts`.
 
 In that case, you only run `npx sheriff verify`.
 
-## `list [main.ts]`
+To run sheriff against `entryPoints` run `npx sheriff verify app-i,app-ii`. `app-i` and `app-ii` are the entry points where Sheriff should traverse the imports.
+
+The `entryPoints` must be defined in the `sheriff.config.ts` file.
+
+## `list`
 
 Run `npx sheriff list main.ts` to print out all your modules along their tags. As explained above, you can alternatively use the `entryFile` property in `sheriff.config.ts`.
 
-## `export [main.ts]`
+Alternatively, you can run `npx sheriff list app-i,app-ii` to list the modules for the specified `entryPoints`.
+
+## `export`
 
 Run `npx sheriff export main.ts > export.json` and the dependency graph will be stored in `export.json` in JSON format. The dependency graph starts from the entry file and includes all reachable files. For every file, it will include the assigned module as well as the tags.
+
+Alternatively, you can run `npx sheriff export app-i,app-ii > export.json`.

packages/core/src/lib/cli/export-data.ts

@@ -1,12 +1,16 @@
-import { getEntryFromCliOrConfig } from './internal/get-entry-from-cli-or-config';
+import { getEntriesFromCliOrConfig } from './internal/get-entries-from-cli-or-config';
 import { cli } from './cli';
 import { getProjectData } from '../api/get-project-data';
 import getFs from '../fs/getFs';
 
 export function exportData(...args: string[]): void {
   const fs = getFs();
-  const entryFile = getEntryFromCliOrConfig(args[0], false);
+  const projectEntries = getEntriesFromCliOrConfig(args[0], false);
 
-  const data = getProjectData(entryFile, fs.cwd(), { includeExternalLibraries: true });
-  cli.log(JSON.stringify(data, null, '  '));
+  for (const entry of projectEntries) {
+    const data = getProjectData(entry.entry, fs.cwd(), {
+      includeExternalLibraries: true,
+    });
+    cli.log(JSON.stringify(data, null, '  '));
+  }
 }

packages/core/src/lib/cli/internal/entry.ts

@@ -0,0 +1,4 @@
+export type Entry<TEntry> = {
+  projectName: string;
+  entry: TEntry;
+};

packages/core/src/lib/cli/internal/get-entries-from-cli-or-config.ts

@@ -0,0 +1,111 @@
+import getFs from '../../fs/getFs';
+import { init, ProjectInfo } from '../../main/init';
+import { parseConfig } from '../../config/parse-config';
+import { toFsPath } from '../../file-info/fs-path';
+import { isEmptyRecord } from '../../util/is-empty-record';
+import { parseEntryPointsFromCli } from './parse-entry-points-from-cli';
+import { Entry } from './entry';
+
+export const DEFAULT_PROJECT_NAME = 'default';
+
+export function getEntriesFromCliOrConfig(
+  entryFileOrEntryPoints?: string,
+): Array<Entry<ProjectInfo>>;
+export function getEntriesFromCliOrConfig(
+  entryFileOrEntryPoints?: string,
+  runInit?: true,
+): Array<Entry<ProjectInfo>>;
+export function getEntriesFromCliOrConfig(
+  entryFileOrEntryPoints?: string,
+  runInit?: false,
+): Array<Entry<string>>;
+export function getEntriesFromCliOrConfig(
+  /**
+   * the CLI forwards either the entry file e.g. "src/main.ts" or
+   * the entry point(s) e.g. app-i,app-ii
+   */
+  entryFileOrEntryPoints = '',
+  runInit = true,
+): Array<Entry<string>> | Array<Entry<ProjectInfo>> {
+  const fs = getFs();
+  const potentialConfigFile = fs.join(fs.cwd(), 'sheriff.config.ts');
+
+  /**
+   * CLI argument given
+   */
+  if (entryFileOrEntryPoints) {
+    // CLI argument given and no config file is present -> only entry file can work
+    if (!fs.exists(potentialConfigFile)) {
+      return processEntryFile(entryFileOrEntryPoints, runInit, fs);
+    }
+
+    if (fs.exists(potentialConfigFile)) {
+      // two cases to check: check for entry points otherwise it is an entry file
+      const sheriffConfig = parseConfig(potentialConfigFile);
+
+      const potentialEntryPoints = parseEntryPointsFromCli(
+        entryFileOrEntryPoints,
+        sheriffConfig,
+      );
+
+      if (potentialEntryPoints) {
+        // if entry points are given, return them
+        return processEntryFile(potentialEntryPoints, runInit, fs);
+      } else {
+        // otherwise it is an entry file
+        return processEntryFile(entryFileOrEntryPoints, runInit, fs);
+      }
+    }
+  }
+
+  if (fs.exists(potentialConfigFile)) {
+    const sheriffConfig = parseConfig(potentialConfigFile);
+
+    if (sheriffConfig.entryFile) {
+      return processEntryFile(sheriffConfig.entryFile, runInit, fs);
+    } else if (
+      sheriffConfig.entryPoints &&
+      !isEmptyRecord(sheriffConfig.entryPoints)
+    ) {
+      return processEntryFile(sheriffConfig.entryPoints, runInit, fs);
+    } else {
+      throw new Error(
+        'No entry file or entry points found in sheriff.config.ts. Please provide the option via the CLI.',
+      );
+    }
+  }
+
+  throw new Error(
+    'Please provide an entry file (e.g. main.ts) or entry points (e.g. { projectName: "main.ts" })',
+  );
+}
+
+// Helper function to process entry file consistently
+function processEntryFile(
+  entryFileValue: string | Record<string, string>,
+  runInit: boolean,
+  fs: ReturnType<typeof getFs>,
+): Array<Entry<ProjectInfo>> | Array<Entry<string>> {
+  if (typeof entryFileValue === 'string') {
+    return runInit
+      ? [
+          {
+            projectName: DEFAULT_PROJECT_NAME,
+            entry: init(toFsPath(fs.join(fs.cwd(), entryFileValue))),
+          },
+        ]
+      : [{ projectName: DEFAULT_PROJECT_NAME, entry: entryFileValue }];
+  } else {
+    const entries = Object.entries(entryFileValue);
+
+    return runInit
+      ? (entries.map(([projectName, entry]) => ({
+          projectName,
+          entry: init(toFsPath(fs.join(fs.cwd(), entry))),
+        })) as Array<Entry<ProjectInfo>>)
+      : (entries.map(([projectName, entry]) => ({
+          projectName,
+          entry: entry,
+        })) as Array<Entry<string>>);
+  }
+}

packages/core/src/lib/cli/internal/get-entry-from-cli-or-config.ts

@@ -0,0 +1,35 @@
+import { Configuration } from '../../config/configuration';
+import { isEmptyRecord } from '../../util/is-empty-record';
+
+export function parseEntryPointsFromCli(
+  entryFileOrEntryPoints: string,
+  sheriffConfig: Configuration,
+): Record<string, string> | undefined {
+  const entryPointsFromConfig = sheriffConfig.entryPoints;
+  if (entryFileOrEntryPoints.includes(',')) {
+    if (!entryPointsFromConfig || isEmptyRecord(entryPointsFromConfig)) {
+      return undefined;
+    }
+    const splittedEntries = entryFileOrEntryPoints.split(',');
+    const entryPoints: Record<string, string> = {};
+
+    for (const entry of splittedEntries) {
+      const entryPoint = entryPointsFromConfig[entry];
+      if (entryPoint) {
+        entryPoints[entry] = entryPoint;
+      }
+    }
+    return entryPoints;
+  }
+
+  // If no comma is found, it could be a single entry point
+  if (
+    entryPointsFromConfig &&
+    entryFileOrEntryPoints in entryPointsFromConfig
+  ) {
+    const singleEntryPoint = entryPointsFromConfig[entryFileOrEntryPoints];
+    return { [entryFileOrEntryPoints]: singleEntryPoint };
+  }
+
+  return undefined;
+}

packages/core/src/lib/cli/internal/parse-entry-points-from-cli.ts

@@ -1,31 +1,42 @@
 import { FsPath, toFsPath } from '../file-info/fs-path';
 import { ProjectInfo } from '../main/init';
 import { calcTagsForModule } from '../tags/calc-tags-for-module';
-import { getEntryFromCliOrConfig } from './internal/get-entry-from-cli-or-config';
+import {
+  DEFAULT_PROJECT_NAME,
+  getEntriesFromCliOrConfig,
+} from './internal/get-entries-from-cli-or-config';
 import getFs from '../fs/getFs';
 import { cli } from './cli';
 import { logInfoForMissingSheriffConfig } from './internal/log-info-for-missing-sheriff-config';
 
 export function list(args: string[]) {
-  const projectInfo = getEntryFromCliOrConfig(args[0]);
-  logInfoForMissingSheriffConfig(projectInfo);
-
-  // root doesn't count
-  const modulesCount = projectInfo.modules.length - 1;
+  const projectEntries = getEntriesFromCliOrConfig(args[0]);
+  if (projectEntries.length > 0) {
+    logInfoForMissingSheriffConfig(projectEntries[0].entry);
+  }
 
-  cli.log(`This project contains ${modulesCount} modules:`);
-  cli.log('');
+  for (const projectEntry of projectEntries) {
+    // root doesn't count
+    const modulesCount = projectEntry.entry.modules.length - 1;
+    const projectName = projectEntry.projectName;
+    if (projectName !== DEFAULT_PROJECT_NAME) {
+      cli.log(cli.bold(`Project: ${projectName}`));
+      cli.log('');
+    }
+    cli.log(`This project contains ${modulesCount} modules:`);
+    cli.log('');
 
-  cli.log('. (root)');
-  const directory = mapModulesToDirectory(
-    Array.from(
-      projectInfo.modules
-        .filter((module) => !module.isRoot)
-        .map((module) => toFsPath(module.path)),
-    ),
-    projectInfo,
-  );
-  printDirectory(directory);
+    cli.log('. (root)');
+    const directory = mapModulesToDirectory(
+      Array.from(
+        projectEntry.entry.modules
+          .filter((module) => !module.isRoot)
+          .map((module) => toFsPath(module.path)),
+      ),
+      projectEntry.entry,
+    );
+    printDirectory(directory);
+  }
 }
 
 type Directory = Record<

packages/core/src/lib/cli/list.ts

@@ -13,6 +13,43 @@ exports[`list > should include modules not reachable by entryFile > log 1`] = `
     └── <b>model</b> (domain:customers, type:model)"
 `;
 
+exports[`list > should list all files reachable by entryPoints > log 1`] = `
+"<b>Project: holidays</b>
+
+This project contains 5 modules:
+
+. (root)
+└── projects
+  ├── holidays
+    └── src
+      └── holidays
+        ├── <b>feature</b> (noTag)
+        └── <b>data</b> (noTag)
+  └── customer-support
+    └── src
+      └── self-service
+        ├── <b>feature</b> (noTag)
+        ├── <b>data</b> (noTag)
+        └── <b>model</b> (noTag)
+<b>Project: customer-support</b>
+
+This project contains 5 modules:
+
+. (root)
+└── projects
+  ├── holidays
+    └── src
+      └── holidays
+        ├── <b>feature</b> (noTag)
+        └── <b>data</b> (noTag)
+  └── customer-support
+    └── src
+      └── self-service
+        ├── <b>feature</b> (noTag)
+        ├── <b>data</b> (noTag)
+        └── <b>model</b> (noTag)"
+`;
+
 exports[`list > should list modules without sheriff config > log 1`] = `
 "Default settings applied. For more control, run "npx sheriff init" to create a sheriff.config.ts.
 This project contains 2 modules: