@teambit/workspace-config-files 1.0.106 → 1.0.108

package/workspace-config-files.main.runtime.ts

@@ -0,0 +1,429 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import globby from 'globby';
+import chalk from 'chalk';
+import { PromptCanceled } from '@teambit/legacy/dist/prompts/exceptions';
+import pMapSeries from 'p-map-series';
+import { ConsumerNotFound } from '@teambit/legacy/dist/consumer/exceptions';
+import yesno from 'yesno';
+import { defaults, flatMap, isFunction, pick, uniq } from 'lodash';
+import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
+import { WorkspaceAspect } from '@teambit/workspace';
+import type { Workspace } from '@teambit/workspace';
+import { Environment, EnvsAspect, ExecutionContext } from '@teambit/envs';
+import type { EnvsMain } from '@teambit/envs';
+import { Logger, LoggerAspect } from '@teambit/logger';
+import type { LoggerMain } from '@teambit/logger';
+import { WorkspaceConfigFilesAspect } from './workspace-config-files.aspect';
+import { ConfigWriterEntry } from './config-writer-entry';
+import { WsConfigCleanCmd, WsConfigCmd, WsConfigListCmd, WsConfigWriteCmd } from './ws-config.cmd';
+import WriteConfigFilesFailed from './exceptions/write-failed';
+import { WorkspaceConfigFilesService } from './workspace-config-files.service';
+import {
+  handleRealConfigFiles,
+  handleExtendingConfigFiles,
+  EnvsWrittenExtendingConfigFiles,
+  EnvsWrittenRealConfigFiles,
+} from './writers';
+
+/**
+ * Configs that can be configured in the workspace.jsonc file
+ */
+export type WorkspaceConfigFilesAspectConfig = {
+  configsRootDir?: string;
+  enableWorkspaceConfigWrite?: boolean;
+};
+
+export type EnvConfigWriter = {
+  envId: string;
+  executionContext: ExecutionContext;
+  configWriters: ConfigWriterEntry[];
+};
+
+export type EnvConfigWriterEntry = {
+  envId: string;
+  configWriter: ConfigWriterEntry;
+  executionContext: ExecutionContext;
+};
+
+type WriterIdsToEnvEntriesMap = {
+  [writerId: string]: EnvConfigWriterEntry[];
+};
+
+export type EnvConfigWritersList = Array<EnvConfigWriter>;
+
+export type CleanConfigFilesOptions = {
+  silent?: boolean; // no prompt
+  dryRun?: boolean;
+  writers?: string[];
+};
+
+export type WriteConfigFilesOptions = {
+  clean?: boolean;
+  silent?: boolean; // no prompt
+  dedupe?: boolean;
+  dryRun?: boolean;
+  throw?: boolean;
+  writers?: string[];
+};
+
+export type CompPathExtendingHashMap = { [compPath: string]: string };
+
+export type EnvMapValue = { env: Environment; id: string[]; paths: string[] };
+export type EnvCompsDirsMap = { [envId: string]: EnvMapValue };
+
+export type OneConfigWriterIdResult = {
+  writerId: string;
+  totalWrittenFiles: number;
+  realConfigFiles: EnvsWrittenRealConfigFiles;
+  totalRealConfigFiles: number;
+  extendingConfigFiles: EnvsWrittenExtendingConfigFiles;
+  totalExtendingConfigFiles: number;
+};
+
+export type WriteResults = {
+  writersResult: OneConfigWriterIdResult[];
+  totalWrittenFiles: number;
+  totalRealConfigFiles: number;
+  totalExtendingConfigFiles: number;
+};
+
+export type WriteConfigFilesResult = {
+  cleanResults?: string[];
+  writeResults: WriteResults;
+  wsDir: string;
+  err?: Error;
+};
+
+export class WorkspaceConfigFilesMain {
+  private envsNotImplementing = {};
+
+  constructor(
+    private workspace: Workspace,
+    private envs: EnvsMain,
+    private logger: Logger,
+    private config: WorkspaceConfigFilesAspectConfig
+  ) {}
+
+  /**
+   * It writes the configuration files for the workspace
+   * for example: tsconfig, eslint config and prettier config files.
+   * @param {WriteConfigFilesOptions} options - WriteConfigFilesOptions = {}
+   * @returns An object with the following properties:
+   * - writeResults: An object with the following properties:
+   *   - aspectsWritersResults: An array of objects with the following properties:
+   *     - aspect: The aspect that was written
+   *     - totalWrittenFiles: The number of files that were written
+   *   - totalWrittenFiles: The total number of files that were written
+   * - cleanResults: array of deleted paths
+   */
+  async writeConfigFiles(options: WriteConfigFilesOptions = {}): Promise<WriteConfigFilesResult> {
+    if (!this.workspace) {
+      throw new ConsumerNotFound();
+    }
+    const defaultOpts: WriteConfigFilesOptions = {
+      clean: false,
+      dedupe: false,
+      silent: false,
+      dryRun: false,
+      throw: true,
+    };
+    const optionsWithDefaults = defaults(options, defaultOpts);
+    const execContext = await this.getExecContext();
+
+    let pathsToClean: string[] | undefined = [];
+    if (optionsWithDefaults.clean) {
+      pathsToClean = await this.calcPathsToClean({ writers: optionsWithDefaults.writers });
+    }
+
+    let writeErr;
+    let writeResults;
+    try {
+      writeResults = await this.write(execContext, optionsWithDefaults);
+      const allWrittenFiles = writeResults.writersResult.flatMap((writerResult) => {
+        return writerResult.extendingConfigFiles.flatMap((extendingConfigFile) => {
+          return extendingConfigFile.extendingConfigFile.filePaths;
+        });
+      });
+      // Avoid delete and re-create files that were written by other config writers
+      // instead of deleting at the beginning then write all
+      // we write all and then delete the files that were not written by the config writers
+      // This reduces the config files that re-created (as many times no changes needed)
+      // which prevent issues with needing to restart the ts-server in the ide
+      pathsToClean = pathsToClean.filter(
+        (pathToClean) => !allWrittenFiles.includes(join(this.workspace.path, pathToClean))
+      );
+      await this.deleteFiles(pathsToClean);
+    } catch (err) {
+      this.logger.info('writeConfigFiles failed', err);
+      if (optionsWithDefaults.throw) {
+        throw new WriteConfigFilesFailed();
+      }
+      writeErr = err;
+    }
+
+    return { writeResults, cleanResults: pathsToClean, wsDir: this.workspace.path, err: writeErr };
+  }
+
+  /**
+   * This will check the config.enableWorkspaceConfigWrite before writing the config files.
+   */
+  async writeConfigFilesIfEnabled(options: WriteConfigFilesOptions = {}): Promise<WriteConfigFilesResult | undefined> {
+    const shouldWrite = this.isWorkspaceConfigWriteEnabled();
+    if (!shouldWrite) return undefined;
+    return this.writeConfigFiles(options);
+  }
+
+  /**
+   * It cleans (delete) the config files from the workspace.
+   * This will check each file and will only delete it in case it was generated by bit
+   * @param {CleanConfigFilesOptions} options - CleanConfigFilesOptions = {}
+   * @returns An array of strings.
+   */
+  async cleanConfigFiles(options: CleanConfigFilesOptions = {}): Promise<string[]> {
+    // const execContext = await this.getExecContext();
+    if (!this.workspace) {
+      throw new ConsumerNotFound();
+    }
+    const cleanResults = await this.clean(options);
+    return cleanResults;
+  }
+
+  /**
+   * The function checks if the auto writing of workspace configuration is enabled.
+   * if it's enabled we will re-generate the configuration files upon bit create
+   * @returns the boolean value of `!!this.config.enableWorkspaceConfigWrite`.
+   */
+  isWorkspaceConfigWriteEnabled() {
+    return !!this.config.enableWorkspaceConfigWrite;
+  }
+
+  /**
+   * It returns a list of all the config writers that have been registered with the config writer slot
+   * @returns An array of objects with aspectId and configWriter properties.
+   */
+  async listConfigWriters(): Promise<EnvConfigWritersList> {
+    if (!this.workspace) {
+      throw new ConsumerNotFound();
+    }
+    const execContexts = await this.getExecContext();
+
+    const result: EnvConfigWritersList = execContexts.map((executionContext) => {
+      const configWriters = this.getConfigWriters(executionContext);
+      return { envId: executionContext.envRuntime.id, executionContext, configWriters };
+    });
+    return result;
+  }
+
+  private groupByWriterId(writerList: EnvConfigWritersList): WriterIdsToEnvEntriesMap {
+    return writerList.reduce((acc, envConfigWriter: EnvConfigWriter) => {
+      envConfigWriter.configWriters.forEach((configWriter: ConfigWriterEntry) => {
+        acc[configWriter.id] = acc[configWriter.id] || [];
+        acc[configWriter.id].push({ configWriter, envId: envConfigWriter.envId });
+      });
+      return acc;
+    }, {});
+  }
+
+  private async write(envsExecutionContext: ExecutionContext[], opts: WriteConfigFilesOptions): Promise<WriteResults> {
+    const envCompDirsMap = this.getEnvComponentsDirsMap(envsExecutionContext);
+    const configsRootDir = this.getConfigsRootDir();
+    const configWriters = await this.listConfigWriters();
+    const writerIdsToEnvEntriesMap = this.groupByWriterId(configWriters);
+    const filteredWriterIdsToEnvEntriesMap = opts.writers
+      ? pick(writerIdsToEnvEntriesMap, opts.writers)
+      : writerIdsToEnvEntriesMap;
+    let totalRealConfigFiles = 0;
+    let totalExtendingConfigFiles = 0;
+    const results = await pMapSeries(
+      Object.entries(filteredWriterIdsToEnvEntriesMap),
+      async ([writerId, envEntries]) => {
+        const oneResult = await this.handleOneIdWriter(writerId, envEntries, envCompDirsMap, configsRootDir, opts);
+        totalRealConfigFiles += oneResult.totalRealConfigFiles;
+        totalExtendingConfigFiles += oneResult.totalExtendingConfigFiles;
+        return oneResult;
+      }
+    );
+
+    const totalWrittenFiles = totalRealConfigFiles + totalExtendingConfigFiles;
+    return { writersResult: results, totalWrittenFiles, totalRealConfigFiles, totalExtendingConfigFiles };
+  }
+
+  private async handleOneIdWriter(
+    writerId: string,
+    envEntries: EnvConfigWriterEntry[],
+    envCompsDirsMap: EnvCompsDirsMap,
+    configsRootDir: string,
+    opts: WriteConfigFilesOptions
+  ): Promise<OneConfigWriterIdResult> {
+    const writtenRealConfigFilesMap = await handleRealConfigFiles(envEntries, envCompsDirsMap, configsRootDir, opts);
+    const writtenExtendingConfigFiles = await handleExtendingConfigFiles(
+      envEntries,
+      envCompsDirsMap,
+      writtenRealConfigFilesMap,
+      configsRootDir,
+      this.workspace.path,
+      opts
+    );
+
+    const writtenRealConfigFiles = Object.values(writtenRealConfigFilesMap);
+    const totalRealConfigFiles = writtenRealConfigFiles.length;
+    const totalExtendingConfigFiles = writtenExtendingConfigFiles.reduce(
+      (acc, curr) => acc + curr.extendingConfigFile.filePaths.length,
+      0
+    );
+    const totalWrittenFiles = totalRealConfigFiles + totalExtendingConfigFiles;
+    return {
+      writerId,
+      totalWrittenFiles,
+      realConfigFiles: writtenRealConfigFiles,
+      totalRealConfigFiles,
+      extendingConfigFiles: writtenExtendingConfigFiles,
+      totalExtendingConfigFiles,
+    };
+  }
+
+  private getConfigsRootDir(): string {
+    const userConfiguredDir = this.config.configsRootDir;
+    return userConfiguredDir ? join(this.workspace.path, userConfiguredDir) : this.getCacheDir(this.workspace.path);
+  }
+
+  private getCacheDir(rootDir): string {
+    return join(rootDir, 'node_modules', '.cache');
+  }
+
+  private async getExecContext(): Promise<ExecutionContext[]> {
+    const components = await this.workspace.list();
+    const runtime = await this.envs.createEnvironment(components);
+    const execContext = runtime.getEnvExecutionContext();
+    return execContext;
+  }
+
+  private getEnvComponentsDirsMap(envsExecutionContext: ExecutionContext[]): EnvCompsDirsMap {
+    const envCompDirsMap = envsExecutionContext.reduce((acc, envExecution) => {
+      const envRuntime = envExecution.envRuntime;
+      const envId = envRuntime.id.toString();
+      const value = {
+        id: envRuntime.id,
+        env: envRuntime.env,
+        paths: envRuntime.components.map((c) => this.workspace.componentDir(c.id, undefined, { relative: true })),
+      };
+      acc[envId] = value;
+      return acc;
+    }, {});
+    return envCompDirsMap;
+  }
+
+  private getConfigWriters(envExecutionContext: ExecutionContext): ConfigWriterEntry[] {
+    if (envExecutionContext.env.workspaceConfig && isFunction(envExecutionContext.env.workspaceConfig)) {
+      return envExecutionContext.env.workspaceConfig();
+    }
+    this.addToEnvsNotImplementing(envExecutionContext.env.id);
+    return [];
+  }
+
+  private getFlatConfigWriters(envsExecutionContext: ExecutionContext[]): ConfigWriterEntry[] {
+    return flatMap(envsExecutionContext, (envExecutionContext) => {
+      return this.getConfigWriters(envExecutionContext);
+    });
+  }
+
+  /**
+   * Clean config files written by the config-writers
+   * @param envsExecutionContext
+   * @param param1
+   * @returns Array of paths of deleted config files
+   */
+  async clean({ dryRun, silent, writers }: WriteConfigFilesOptions): Promise<string[]> {
+    const paths = await this.calcPathsToClean({ writers });
+    if (dryRun) return paths;
+    if (!silent) await this.promptForCleaning(paths);
+    await this.deleteFiles(paths);
+    return paths;
+  }
+
+  private async calcPathsToClean({ writers }: WriteConfigFilesOptions): Promise<string[]> {
+    const execContext = await this.getExecContext();
+    const configWriters = this.getFlatConfigWriters(execContext);
+    const filteredConfigWriters = writers
+      ? configWriters.filter((configWriter) => writers.includes(configWriter.id))
+      : configWriters;
+
+    const paths = uniq(
+      filteredConfigWriters
+        .map((configWriter) => {
+          const patterns = configWriter.patterns;
+          const currPaths = globby.sync(patterns, {
+            cwd: this.workspace.path,
+            dot: true,
+            onlyFiles: true,
+            ignore: ['**/node_modules/**'],
+          });
+          const filteredPaths = currPaths.filter((path) => {
+            const fullPath = join(this.workspace.path, path);
+            return configWriter.isBitGenerated ? configWriter.isBitGenerated(fullPath) : true;
+          });
+          return filteredPaths;
+        })
+        .flat()
+    );
+    return paths;
+  }
+
+  private addToEnvsNotImplementing(envId: string) {
+    this.envsNotImplementing[envId] = true;
+  }
+
+  getEnvsNotImplementing() {
+    return Object.keys(this.envsNotImplementing);
+  }
+
+  private async promptForCleaning(paths: string[]) {
+    this.logger.clearStatusLine();
+    const ok = await yesno({
+      question: `${chalk.underline('The following files will be deleted:')}
+${paths.join('\n')}
+${chalk.bold('Do you want to continue? [yes(y)/no(n)]')}`,
+    });
+    if (!ok) {
+      throw new PromptCanceled();
+    }
+  }
+
+  private async deleteFiles(paths: string[]) {
+    await Promise.all(paths.map((f) => fs.remove(join(this.workspace.path, f))));
+  }
+
+  static slots = [];
+  // define your aspect dependencies here.
+  // in case you need to use another aspect API.
+  static dependencies = [CLIAspect, WorkspaceAspect, EnvsAspect, LoggerAspect];
+
+  static runtime = MainRuntime;
+
+  static defaultConfig: Partial<WorkspaceConfigFilesAspectConfig> = {
+    enableWorkspaceConfigWrite: false,
+  };
+
+  static async provider(
+    [cli, workspace, envs, loggerAspect]: [CLIMain, Workspace, EnvsMain, LoggerMain],
+    config: WorkspaceConfigFilesAspectConfig
+  ) {
+    const logger = loggerAspect.createLogger(WorkspaceConfigFilesAspect.id);
+    envs.registerService(new WorkspaceConfigFilesService(logger));
+
+    const workspaceConfigFilesMain = new WorkspaceConfigFilesMain(workspace, envs, logger, config);
+    const wsConfigCmd = new WsConfigCmd();
+    wsConfigCmd.commands = [
+      new WsConfigWriteCmd(workspaceConfigFilesMain),
+      new WsConfigCleanCmd(workspaceConfigFilesMain),
+      new WsConfigListCmd(workspaceConfigFilesMain),
+    ];
+    cli.register(wsConfigCmd);
+    return workspaceConfigFilesMain;
+  }
+}
+
+WorkspaceConfigFilesAspect.addRuntime(WorkspaceConfigFilesMain);
+
+export default WorkspaceConfigFilesMain;

package/ws-config.cmd.ts

@@ -0,0 +1,186 @@
+/* eslint-disable max-classes-per-file */
+
+import { Command, CommandOptions } from '@teambit/cli';
+import chalk from 'chalk';
+import { WorkspaceConfigFilesMain, WriteConfigFilesResult } from './workspace-config-files.main.runtime';
+import { formatCleanOutput, formatListOutput, formatWriteOutput, verboseFormatWriteOutput } from './outputs';
+
+export type CleanConfigCmdFlags = {
+  dryRun?: boolean;
+  silent?: boolean;
+};
+
+export type WriteConfigCmdFlags = {
+  dryRun?: boolean;
+  writers?: string;
+  noDedupe?: boolean;
+  dryRunWithContent?: boolean;
+  clean?: boolean;
+  silent?: boolean;
+  verbose?: boolean;
+};
+
+const COMMAND_NAME = 'ws-config';
+
+export class WsConfigCmd implements Command {
+  name = `${COMMAND_NAME} <sub-command>`;
+  alias = 'workspace-config';
+  description = 'manage workspace config files';
+  options = [];
+  group = 'development';
+  commands: Command[] = [];
+  // helpUrl = '';
+
+  async report([unrecognizedSubcommand]: [string]) {
+    return chalk.red(
+      `"${unrecognizedSubcommand}" is not a subcommand of "ws-config", please run "bit ws-config --help" to list the subcommands`
+    );
+  }
+}
+
+export class WsConfigWriteCmd implements Command {
+  name = 'write';
+  description = 'write config files in the workspace. useful for IDEs';
+  alias = '';
+  group = 'development';
+  options = [
+    [
+      'c',
+      'clean',
+      'delete existing config files from the workspace. highly recommended to run it with "--dry-run" first',
+    ],
+    [
+      'w',
+      'writers <writers>',
+      `only write config files for the given writers. use comma to separate multiple writers. use ${COMMAND_NAME} list to see all writers`,
+    ],
+    ['s', 'silent', 'do not prompt for confirmation'],
+    ['', 'no-dedupe', "write configs inside each one of the component's dir, avoid deduping"],
+    ['', 'dry-run', 'show the paths that configs will be written per env'],
+    [
+      '',
+      'dry-run-with-content',
+      'use with --json flag. show the config content and the paths that will be written per env',
+    ],
+    ['v', 'verbose', 'showing verbose output for writing'],
+    ['j', 'json', 'json format'],
+  ] as CommandOptions;
+
+  constructor(private workspaceConfigFilesMain: WorkspaceConfigFilesMain) {}
+
+  async report(_args, flags: WriteConfigCmdFlags) {
+    const results = (await this.json(_args, flags)) as WriteConfigFilesResult;
+    if (flags.dryRunWithContent) {
+      throw new Error(`use --json flag along with --dry-run-with-content`);
+    }
+    const envsNotImplementing = this.workspaceConfigFilesMain.getEnvsNotImplementing();
+    const warning = getWarningForNonImplementingEnvs(envsNotImplementing);
+    const output = flags.verbose ? verboseFormatWriteOutput(results, flags) : formatWriteOutput(results, flags);
+    return warning + output;
+  }
+
+  async json(_args, flags: WriteConfigCmdFlags) {
+    const { clean, silent, noDedupe, dryRunWithContent, writers } = flags;
+    const dryRun = dryRunWithContent ? true : !!flags.dryRun;
+    const { cleanResults, writeResults, wsDir } = await this.workspaceConfigFilesMain.writeConfigFiles({
+      clean,
+      dedupe: !noDedupe,
+      dryRun,
+      silent,
+      writers: writers?.split(','),
+    });
+
+    if (dryRun) {
+      const updatedWriteResults = writeResults;
+      if (!dryRunWithContent) {
+        updatedWriteResults.writersResult = updatedWriteResults.writersResult.map((oneWriterResult) => {
+          oneWriterResult.realConfigFiles.forEach((realConfigFile) => {
+            realConfigFile.writtenRealConfigFile.content = '';
+          });
+          oneWriterResult.extendingConfigFiles.forEach((extendingConfigFile) => {
+            extendingConfigFile.extendingConfigFile.content = '';
+          });
+          return oneWriterResult;
+        });
+      }
+
+      return {
+        wsDir,
+        cleanResults,
+        writeResults: updatedWriteResults,
+      };
+    }
+    return { wsDir, cleanResults, writeResults };
+  }
+}
+
+export class WsConfigCleanCmd implements Command {
+  name = 'clean';
+  description = 'clean (delete) written config files in the workspace. useful for IDEs';
+  alias = '';
+  group = 'development';
+  options = [
+    ['s', 'silent', 'do not prompt for confirmation'],
+    [
+      'w',
+      'writers <writers>',
+      `only clean config files for the given writers. use comma to separate multiple writers. use ${COMMAND_NAME} list to see all writers`,
+    ],
+    ['', 'dry-run', 'show the paths of configs that will be cleaned'],
+    ['j', 'json', 'json format'],
+  ] as CommandOptions;
+
+  constructor(private workspaceConfigFilesMain: WorkspaceConfigFilesMain) {}
+
+  async report(_args, flags: CleanConfigCmdFlags) {
+    const results = await this.json(_args, flags);
+    const envsNotImplementing = this.workspaceConfigFilesMain.getEnvsNotImplementing();
+    const warning = getWarningForNonImplementingEnvs(envsNotImplementing);
+    const output = formatCleanOutput(results, flags);
+    return warning + output;
+  }
+
+  async json(_args, flags: WriteConfigCmdFlags) {
+    const { silent, dryRun } = flags;
+    const cleanResults = await this.workspaceConfigFilesMain.cleanConfigFiles({
+      dryRun,
+      silent,
+      writers: flags.writers?.split(','),
+    });
+    return cleanResults;
+  }
+}
+
+export class WsConfigListCmd implements Command {
+  name = 'list';
+  description = 'list config writers';
+  alias = '';
+  group = 'development';
+  options = [['j', 'json', 'json format']] as CommandOptions;
+
+  constructor(private workspaceConfigFilesMain: WorkspaceConfigFilesMain) {}
+
+  async report() {
+    const results = await this.json();
+    const envsNotImplementing = this.workspaceConfigFilesMain.getEnvsNotImplementing();
+    const warning = getWarningForNonImplementingEnvs(envsNotImplementing);
+    const output = formatListOutput(results);
+    return warning + output;
+  }
+
+  async json() {
+    const cleanResults = await this.workspaceConfigFilesMain.listConfigWriters();
+    return cleanResults;
+  }
+}
+
+function getWarningForNonImplementingEnvs(envsNotImplementing: string[]) {
+  if (!envsNotImplementing.length) return '';
+  const message =
+    chalk.yellow(`Bit cannot determine the correct contents for the config files to write. this may result in incorrect content.
+The following environments need to add support for config files: ${chalk.cyan(envsNotImplementing.join(', '))}.
+Read here how to correct and improve dev-ex - LINK
+
+`);
+  return message;
+}