@teambit/checkout 1.0.106 → 1.0.108

package/checkout-cmd.ts

@@ -0,0 +1,261 @@
+import chalk from 'chalk';
+import { Command, CommandOptions } from '@teambit/cli';
+import {
+  ApplyVersionResults,
+  applyVersionReport,
+  conflictSummaryReport,
+  installationErrorOutput,
+  compilationErrorOutput,
+  getRemovedOutput,
+  getAddedOutput,
+} from '@teambit/merging';
+import { COMPONENT_PATTERN_HELP, HEAD, LATEST } from '@teambit/legacy/dist/constants';
+import { MergeStrategy } from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
+import { ComponentID } from '@teambit/component-id';
+import { BitError } from '@teambit/bit-error';
+import { CheckoutMain, CheckoutProps } from './checkout.main.runtime';
+
+export class CheckoutCmd implements Command {
+  name = 'checkout <to> [component-pattern]';
+  arguments = [
+    {
+      name: 'to',
+      description:
+        "permitted values: [head, latest, reset, specific-version]. 'head' - last snap/tag. 'latest' - semver latest tag. 'reset' - removes local changes",
+    },
+    {
+      name: 'component-pattern',
+      description: COMPONENT_PATTERN_HELP,
+    },
+  ];
+  description = 'switch between component versions or remove local changes';
+  helpUrl = 'reference/components/merging-changes#checkout-snaps-to-the-working-directory';
+  group = 'development';
+  extendedDescription = `
+\`bit checkout <version> [component-pattern]\` => checkout the specified ids (or all components when --all is used) to the specified version
+\`bit checkout head [component-pattern]\` => checkout to the last snap/tag (use --latest if you only want semver tags), omit [component-pattern] to checkout head for all
+\`bit checkout latest [component-pattern]\` => checkout to the latest satisfying semver tag, omit [component-pattern] to checkout latest for all
+\`bit checkout reset [component-pattern]\` => remove local modifications from the specified ids (or all components when --all is used)
+when on a lane, "checkout head" only checks out components on this lane. to update main components, run "bit lane merge main"`;
+  alias = 'U';
+  options = [
+    [
+      'i',
+      'interactive-merge',
+      'when a component is modified and the merge process found conflicts, display options to resolve them',
+    ],
+    ['', 'ours', 'DEPRECATED. use --auto-merge-resolve. In the future, this flag will leave the current code intact'],
+    [
+      '',
+      'theirs',
+      'DEPRECATED. use --auto-merge-resolve. In the future, this flag will override the current code with the incoming code',
+    ],
+    ['', 'manual', 'DEPRECATED. use --auto-merge-resolve'],
+    [
+      '',
+      'auto-merge-resolve <merge-strategy>',
+      'in case of merge conflict, resolve according to the provided strategy: [ours, theirs, manual]',
+    ],
+    ['r', 'reset', 'revert changes that were not snapped/tagged'],
+    ['a', 'all', 'all components'],
+    [
+      'e',
+      'workspace-only',
+      "only relevant for 'bit checkout head' when on a lane. don't import components from the remote lane that are not already in the workspace",
+    ],
+    ['v', 'verbose', 'showing verbose output for inspection'],
+    ['x', 'skip-dependency-installation', 'do not auto-install dependencies of the imported components'],
+  ] as CommandOptions;
+  loader = true;
+
+  constructor(private checkout: CheckoutMain) {}
+
+  async report(
+    [to, componentPattern]: [string, string],
+    {
+      interactiveMerge = false,
+      ours = false,
+      theirs = false,
+      manual = false,
+      autoMergeResolve,
+      all = false,
+      workspaceOnly = false,
+      verbose = false,
+      skipDependencyInstallation = false,
+      revert = false,
+    }: {
+      interactiveMerge?: boolean;
+      ours?: boolean;
+      theirs?: boolean;
+      manual?: boolean;
+      autoMergeResolve?: MergeStrategy;
+      all?: boolean;
+      workspaceOnly?: boolean;
+      verbose?: boolean;
+      skipDependencyInstallation?: boolean;
+      revert?: boolean;
+    }
+  ) {
+    if (ours || theirs || manual) {
+      throw new BitError(
+        'the "--ours", "--theirs" and "--manual" flags are deprecated. use "--auto-merge-resolve" instead.'
+      );
+    }
+    if (
+      autoMergeResolve &&
+      autoMergeResolve !== 'ours' &&
+      autoMergeResolve !== 'theirs' &&
+      autoMergeResolve !== 'manual'
+    ) {
+      throw new BitError('--auto-merge-resolve must be one of the following: [ours, theirs, manual]');
+    }
+    if (workspaceOnly && to !== HEAD) {
+      throw new BitError('--workspace-only is only relevant when running "bit checkout head" on a lane');
+    }
+    const checkoutProps: CheckoutProps = {
+      promptMergeOptions: interactiveMerge,
+      mergeStrategy: autoMergeResolve,
+      all,
+      verbose,
+      isLane: false,
+      skipNpmInstall: skipDependencyInstallation,
+      workspaceOnly,
+      revert,
+    };
+    if (to === HEAD) checkoutProps.head = true;
+    else if (to === LATEST) checkoutProps.latest = true;
+    else if (to === 'reset') checkoutProps.reset = true;
+    else if (to === 'main') checkoutProps.main = true;
+    else {
+      if (!ComponentID.isValidVersion(to)) throw new BitError(`the specified version "${to}" is not a valid version`);
+      checkoutProps.version = to;
+    }
+
+    const checkoutResults = await this.checkout.checkoutByCLIValues(componentPattern || '', checkoutProps);
+    return checkoutOutput(checkoutResults, checkoutProps);
+  }
+}
+
+export function checkoutOutput(checkoutResults: ApplyVersionResults, checkoutProps: CheckoutProps) {
+  const {
+    components,
+    version,
+    failedComponents,
+    removedComponents,
+    addedComponents,
+    leftUnresolvedConflicts,
+    newFromLane,
+    newFromLaneAdded,
+    installationError,
+    compilationError,
+  }: ApplyVersionResults = checkoutResults;
+
+  const { head, reset, latest, main, revert, verbose, all } = checkoutProps;
+
+  // components that failed for no legitimate reason. e.g. merge-conflict.
+  const realFailedComponents = (failedComponents || []).filter((f) => !f.unchangedLegitimately);
+  // components that weren't checked out for legitimate reasons, e.g. up-to-date.
+  const notCheckedOutComponents = (failedComponents || []).filter((f) => f.unchangedLegitimately);
+
+  const getFailureOutput = () => {
+    if (!realFailedComponents.length) return '';
+    const title = 'the checkout has been failed on the following component(s)';
+    const body = realFailedComponents
+      .map(
+        (failedComponent) =>
+          `${chalk.bold(failedComponent.id.toString())} - ${chalk.red(failedComponent.unchangedMessage)}`
+      )
+      .join('\n');
+    return `${chalk.underline(title)}\n${body}\n\n`;
+  };
+  const getNotCheckedOutOutput = () => {
+    if (!notCheckedOutComponents.length) return '';
+    if (!verbose && all) {
+      return chalk.green(
+        `checkout was not needed for ${chalk.bold(
+          notCheckedOutComponents.length.toString()
+        )} components (use --verbose to get more details)\n`
+      );
+    }
+    const title = 'checkout was not required for the following component(s)';
+    const body = notCheckedOutComponents
+      .map((failedComponent) => `${failedComponent.id.toString()} - ${failedComponent.unchangedMessage}`)
+      .join('\n');
+    return `${chalk.underline(title)}\n${body}\n\n`;
+  };
+  const getConflictSummary = () => {
+    if (!components || !components.length || !leftUnresolvedConflicts) return '';
+    const title = `\n\nfiles with conflicts summary\n`;
+    const suggestion = `\n\nfix the conflicts above manually and then run "bit install".
+once ready, snap/tag the components to persist the changes`;
+    return chalk.underline(title) + conflictSummaryReport(components) + chalk.yellow(suggestion);
+  };
+  const getSuccessfulOutput = () => {
+    const switchedOrReverted = revert ? 'reverted' : 'switched';
+    if (!components || !components.length) return '';
+    if (components.length === 1) {
+      const component = components[0];
+      const componentName = reset ? component.id.toString() : component.id.toStringWithoutVersion();
+      if (reset) return `successfully reset ${chalk.bold(componentName)}\n`;
+      const title = `successfully ${switchedOrReverted} ${chalk.bold(componentName)} to version ${chalk.bold(
+        // @ts-ignore version is defined when !reset
+        head || latest ? component.id.version : version
+      )}\n`;
+      return chalk.bold(title) + applyVersionReport(components, false);
+    }
+    if (reset) {
+      const title = 'successfully reset the following components\n\n';
+      const body = components.map((component) => chalk.bold(component.id.toString())).join('\n');
+      return chalk.underline(title) + body;
+    }
+    const getVerOutput = () => {
+      if (head) return 'their head version';
+      if (latest) return 'their latest version';
+      if (main) return 'their main version';
+      // @ts-ignore version is defined when !reset
+      return `version ${chalk.bold(version)}`;
+    };
+    const versionOutput = getVerOutput();
+    const title = `successfully ${switchedOrReverted} ${components.length} components to ${versionOutput}\n`;
+    const showVersion = head || reset;
+    return chalk.bold(title) + applyVersionReport(components, true, showVersion);
+  };
+  const getNewOnLaneOutput = () => {
+    if (!newFromLane?.length) return '';
+    const title = newFromLaneAdded
+      ? `successfully added the following components from the lane`
+      : `the following components exist on the lane but were not added to the workspace. omit --workspace-only flag to add them`;
+    const body = newFromLane.join('\n');
+    return `\n\n${chalk.underline(title)}\n${body}`;
+  };
+  const getSummary = () => {
+    const checkedOut = components?.length || 0;
+    const notCheckedOutLegitimately = notCheckedOutComponents.length;
+    const failedToCheckOut = realFailedComponents.length;
+    const newLines = '\n\n';
+    const title = chalk.bold.underline('Summary');
+    const checkedOutStr = `\nTotal Changed: ${chalk.bold(checkedOut.toString())}`;
+    const unchangedLegitimatelyStr = `\nTotal Unchanged: ${chalk.bold(notCheckedOutLegitimately.toString())}`;
+    const failedToCheckOutStr = `\nTotal Failed: ${chalk.bold(failedToCheckOut.toString())}`;
+    const newOnLaneNum = newFromLane?.length || 0;
+    const newOnLaneAddedStr = newFromLaneAdded ? ' (added)' : ' (not added)';
+    const newOnLaneStr = newOnLaneNum
+      ? `\nNew on lane${newOnLaneAddedStr}: ${chalk.bold(newOnLaneNum.toString())}`
+      : '';
+
+    return newLines + title + checkedOutStr + unchangedLegitimatelyStr + failedToCheckOutStr + newOnLaneStr;
+  };
+
+  return (
+    getFailureOutput() +
+    getNotCheckedOutOutput() +
+    getSuccessfulOutput() +
+    getRemovedOutput(removedComponents) +
+    getAddedOutput(addedComponents) +
+    getNewOnLaneOutput() +
+    getConflictSummary() +
+    getSummary() +
+    installationErrorOutput(installationError) +
+    compilationErrorOutput(compilationError)
+  );
+}

package/checkout-version.ts

@@ -0,0 +1,240 @@
+import * as path from 'path';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { ComponentID } from '@teambit/component-id';
+import GeneralError from '@teambit/legacy/dist/error/general-error';
+import Version from '@teambit/legacy/dist/scope/models/version';
+import { SourceFile } from '@teambit/legacy/dist/consumer/component/sources';
+import { pathNormalizeToLinux, PathOsBased } from '@teambit/legacy/dist/utils/path';
+import DataToPersist from '@teambit/legacy/dist/consumer/component/sources/data-to-persist';
+import RemovePath from '@teambit/legacy/dist/consumer/component/sources/remove-path';
+import {
+  ApplyVersionResult,
+  FilesStatus,
+  FileStatus,
+  MergeOptions,
+  MergeStrategy,
+} from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
+import { MergeResultsThreeWay } from '@teambit/legacy/dist/consumer/versions-ops/merge-version/three-way-merge';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import { BitError } from '@teambit/bit-error';
+import chalk from 'chalk';
+
+export type CheckoutProps = {
+  version?: string; // if reset is true, the version is undefined
+  ids?: ComponentID[];
+  latestVersion?: boolean;
+  promptMergeOptions?: boolean;
+  mergeStrategy?: MergeStrategy | null;
+  verbose?: boolean;
+  skipNpmInstall?: boolean;
+  ignorePackageJson?: boolean;
+  writeConfig?: boolean;
+  reset?: boolean; // remove local changes. if set, the version is undefined.
+  all?: boolean; // checkout all ids
+  ignoreDist?: boolean;
+  isLane?: boolean;
+};
+
+export type ComponentStatusBase = {
+  currentComponent?: ConsumerComponent;
+  componentFromModel?: Version;
+  id: ComponentID;
+  shouldBeRemoved?: boolean; // in case the component is soft-removed, it should be removed from the workspace
+  unchangedMessage?: string; // this gets populated either upon skip or failure.
+  unchangedLegitimately?: boolean; // true for skipped legitimately (e.g. already up to date). false for failure.
+};
+
+export type ComponentStatus = ComponentStatusBase & {
+  mergeResults?: MergeResultsThreeWay | null | undefined;
+};
+
+export type ApplyVersionWithComps = {
+  applyVersionResult: ApplyVersionResult;
+  component?: ConsumerComponent;
+  // in case the component needs to be written to the filesystem, this is the component to write.
+  legacyCompToWrite?: ConsumerComponent;
+};
+
+/**
+ * 1) when the files are modified with conflicts and the strategy is "ours", leave the FS as is
+ * and update only bitmap id version. (not the componentMap object).
+ *
+ * 2) when the files are modified with conflicts and the strategy is "theirs", write the component
+ * according to id.version.
+ *
+ * 3) when files are modified with no conflict or files are modified with conflicts and the
+ * strategy is manual, load the component according to id.version and update component.files.
+ * applyModifiedVersion() docs explains what files are updated/added.
+ *
+ * 4) when --reset flag is used, write the component according to the bitmap version
+ *
+ * Side note:
+ * Deleted file => if files are in used version but not in the modified one, no need to delete it. (similar to git).
+ * Added file => if files are not in used version but in the modified one, they'll be under mergeResults.addFiles
+ */
+export async function applyVersion(
+  consumer: Consumer,
+  id: ComponentID,
+  componentFromFS: ConsumerComponent | null | undefined, // it can be null only when isLanes is true
+  mergeResults: MergeResultsThreeWay | null | undefined,
+  checkoutProps: CheckoutProps
+): Promise<ApplyVersionWithComps> {
+  if (!checkoutProps.isLane && !componentFromFS)
+    throw new Error(`applyVersion expect to get componentFromFS for ${id.toString()}`);
+  const { mergeStrategy } = checkoutProps;
+  let filesStatus = {};
+  if (mergeResults && mergeResults.hasConflicts && mergeStrategy === MergeOptions.ours) {
+    // even when isLane is true, the mergeResults is possible only when the component is on the filesystem
+    // otherwise it's impossible to have conflicts
+    if (!componentFromFS) throw new Error(`applyVersion expect to get componentFromFS for ${id.toString()}`);
+    componentFromFS.files.forEach((file) => {
+      filesStatus[pathNormalizeToLinux(file.relative)] = FileStatus.unchanged;
+    });
+    consumer.bitMap.updateComponentId(id);
+    return { applyVersionResult: { id, filesStatus } };
+  }
+  const component = await consumer.loadComponentFromModelImportIfNeeded(id);
+  const componentMap = componentFromFS && componentFromFS.componentMap;
+  if (componentFromFS && !componentMap) throw new GeneralError('applyVersion: componentMap was not found');
+
+  const files = component.files;
+  updateFileStatus(files, filesStatus, componentFromFS || undefined);
+
+  await removeFilesIfNeeded(filesStatus, componentFromFS || undefined);
+
+  if (mergeResults) {
+    // update files according to the merge results
+    const { filesStatus: modifiedStatus, modifiedFiles } = applyModifiedVersion(files, mergeResults, mergeStrategy);
+    filesStatus = { ...filesStatus, ...modifiedStatus };
+    component.files = modifiedFiles;
+  }
+
+  return {
+    applyVersionResult: { id, filesStatus },
+    component,
+  };
+}
+
+export function updateFileStatus(files: SourceFile[], filesStatus: FilesStatus, componentFromFS?: ConsumerComponent) {
+  files.forEach((file) => {
+    const fileFromFs = componentFromFS?.files.find((f) => f.relative === file.relative);
+    const areFilesEqual = fileFromFs && Buffer.compare(fileFromFs.contents, file.contents) === 0;
+    // @ts-ignore
+    filesStatus[pathNormalizeToLinux(file.relative)] = areFilesEqual ? FileStatus.unchanged : FileStatus.updated;
+  });
+}
+
+/**
+ * when files exist on the filesystem but not on the checked out versions, they need to be deleted.
+ * without this function, these files would be left on the filesystem. (we don't delete the comp-dir before writing).
+ * this needs to be done *before* the component is written to the filesystem, otherwise, it won't work when a file
+ * has a case change. e.g. from uppercase to lowercase. (see merge-lane.e2e 'renaming files from uppercase to lowercase').
+ */
+export async function removeFilesIfNeeded(filesStatus: FilesStatus, componentFromFS?: ConsumerComponent) {
+  if (!componentFromFS) return;
+  const filePathsFromFS = componentFromFS.files || [];
+  const dataToPersist = new DataToPersist();
+  filePathsFromFS.forEach((file) => {
+    const filename = pathNormalizeToLinux(file.relative);
+    if (!filesStatus[filename]) {
+      // @ts-ignore todo: typescript has a good point here. it should be the string "removed", not chalk.green(removed).
+      filesStatus[filename] = FileStatus.removed;
+      dataToPersist.removePath(new RemovePath(file.path));
+    }
+  });
+  await dataToPersist.persistAllToFS();
+}
+
+/**
+ * relevant only when
+ * 1) there is no conflict => add files from mergeResults: addFiles, overrideFiles and modifiedFiles.output.
+ * 2) there is conflict and mergeStrategy is manual => add files from mergeResults: addFiles, overrideFiles and modifiedFiles.conflict.
+ *
+ * this function only updates the files content, it doesn't write the files
+ */
+export function applyModifiedVersion(
+  componentFiles: SourceFile[],
+  mergeResults: MergeResultsThreeWay,
+  mergeStrategy: MergeStrategy | null | undefined
+): { filesStatus: Record<string, any>; modifiedFiles: SourceFile[] } {
+  let modifiedFiles = componentFiles.map((file) => file.clone());
+  const filesStatus = {};
+  if (mergeResults.hasConflicts && mergeStrategy !== MergeOptions.manual) {
+    return { filesStatus, modifiedFiles };
+  }
+  mergeResults.modifiedFiles.forEach((file) => {
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    const foundFile = modifiedFiles.find((componentFile) => componentFile.relative === filePath);
+    if (!foundFile) throw new GeneralError(`file ${filePath} not found`);
+    if (file.conflict) {
+      foundFile.contents = Buffer.from(file.conflict);
+      filesStatus[file.filePath] = FileStatus.manual;
+    } else if (typeof file.output === 'string') {
+      foundFile.contents = Buffer.from(file.output);
+      filesStatus[file.filePath] = FileStatus.merged;
+    } else if (file.isBinaryConflict) {
+      // leave the file as is and notify the user later about it.
+      foundFile.contents = file.fsFile.contents;
+      filesStatus[file.filePath] = FileStatus.binaryConflict;
+    } else {
+      throw new GeneralError(`file ${filePath} does not have output nor conflict`);
+    }
+  });
+
+  mergeResults.addFiles.forEach((file) => {
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    if (modifiedFiles.find((m) => m.relative === filePath)) return;
+    modifiedFiles.push(file.fsFile);
+    filesStatus[file.filePath] = FileStatus.added;
+  });
+  mergeResults.deletedConflictFiles.forEach((file) => {
+    if (!file.fsFile) return;
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    if (modifiedFiles.find((m) => m.relative === filePath)) return;
+    modifiedFiles.push(file.fsFile);
+    filesStatus[file.filePath] = FileStatus.added;
+  });
+  mergeResults.removeFiles.forEach((file) => {
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    filesStatus[file.filePath] = FileStatus.removed;
+    modifiedFiles = modifiedFiles.filter((f) => f.relative !== filePath);
+  });
+  mergeResults.remainDeletedFiles.forEach((file) => {
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    modifiedFiles = modifiedFiles.filter((f) => f.relative !== filePath);
+    filesStatus[file.filePath] = FileStatus.remainDeleted;
+  });
+  mergeResults.deletedConflictFiles.forEach((file) => {
+    filesStatus[file.filePath] = FileStatus.deletedConflict;
+  });
+
+  mergeResults.overrideFiles.forEach((file) => {
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    const foundFile = modifiedFiles.find((componentFile) => componentFile.relative === filePath);
+    if (!foundFile) throw new GeneralError(`file ${filePath} not found`);
+    foundFile.contents = file.fsFile.contents;
+    filesStatus[file.filePath] = FileStatus.overridden;
+  });
+  mergeResults.updatedFiles.forEach((file) => {
+    const filePath: PathOsBased = path.normalize(file.filePath);
+    const foundFile = modifiedFiles.find((componentFile) => componentFile.relative === filePath);
+    if (!foundFile) throw new GeneralError(`file ${filePath} not found`);
+    foundFile.contents = file.content;
+    filesStatus[file.filePath] = FileStatus.updated;
+  });
+
+  return { filesStatus, modifiedFiles };
+}
+
+export function throwForFailures(allComponentsStatus: ComponentStatusBase[]) {
+  const failedComponents = allComponentsStatus.filter((c) => c.unchangedMessage && !c.unchangedLegitimately);
+  if (failedComponents.length) {
+    const failureMsgs = failedComponents
+      .map(
+        (failedComponent) =>
+          `${chalk.bold(failedComponent.id.toString())} - ${chalk.red(failedComponent.unchangedMessage as string)}`
+      )
+      .join('\n');
+    throw new BitError(`unable to proceed due to the following failures:\n${failureMsgs}`);
+  }
+}

package/checkout.aspect.ts

@@ -0,0 +1,5 @@
+import { Aspect } from '@teambit/harmony';
+
+export const CheckoutAspect = Aspect.create({
+  id: 'teambit.component/checkout',
+});