@teambit/merge-lanes 1.0.106 → 1.0.108

package/last-merged.ts

@@ -0,0 +1,179 @@
+import path from 'path';
+import tempy from 'tempy';
+import fs from 'fs-extra';
+import yesno from 'yesno';
+import chalk from 'chalk';
+import BitMap from '@teambit/legacy/dist/consumer/bit-map';
+import { PromptCanceled } from '@teambit/legacy/dist/prompts/exceptions';
+import { ScopeMain } from '@teambit/scope';
+import { Lane } from '@teambit/legacy/dist/scope/models';
+import { StagedSnaps } from '@teambit/legacy/dist/scope/staged-snaps';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { BitError } from '@teambit/bit-error';
+import { BitObject } from '@teambit/legacy/dist/scope/objects';
+import { Logger } from '@teambit/logger';
+import { MergeAbortOpts } from './merge-abort.cmd';
+
+const LAST_MERGED_LANE_FILENAME = 'lane';
+const LAST_MERGED_BITMAP_FILENAME = 'bitmap';
+
+type Snapshot = {
+  copyOfCurrentLane?: Lane;
+  copyOfBitmap: string;
+  copyOfWorkspaceJsonc: string;
+  copyOfStagedSnaps?: string;
+  copyOfStagedConfig?: string;
+};
+
+export class LastMerged {
+  constructor(private scope: ScopeMain, private consumer: Consumer, private logger: Logger) {}
+
+  get path() {
+    return this.scope.getLastMergedPath();
+  }
+
+  async takeSnapshot(currentLane?: Lane | null): Promise<Snapshot> {
+    const consumer = this.consumer;
+    const copyOfCurrentLane = currentLane ? currentLane.clone() : undefined;
+    const copyOfBitmap = tempy.file();
+    const copyOfWorkspaceJsonc = tempy.file();
+    let copyOfStagedSnaps: string | undefined;
+    await fs.copyFile(consumer.bitMap.mapPath, copyOfBitmap);
+    await fs.copyFile(consumer.config.path, copyOfWorkspaceJsonc);
+    if (!consumer.scope.stagedSnaps.isEmpty()) {
+      copyOfStagedSnaps = tempy.file();
+      await fs.copyFile(StagedSnaps.getPath(consumer.scope.path), copyOfStagedSnaps);
+    }
+    const stagedConfig = await this.scope.getStagedConfig();
+    let copyOfStagedConfig: string | undefined;
+    if (!stagedConfig.isEmpty()) {
+      copyOfStagedConfig = tempy.file();
+      await fs.copyFile(stagedConfig.filePath, copyOfStagedConfig);
+    }
+
+    return {
+      copyOfCurrentLane,
+      copyOfBitmap,
+      copyOfWorkspaceJsonc,
+      copyOfStagedSnaps,
+      copyOfStagedConfig,
+    };
+  }
+
+  async persistSnapshot(snapshot: Snapshot) {
+    const { copyOfCurrentLane, copyOfBitmap, copyOfWorkspaceJsonc, copyOfStagedSnaps, copyOfStagedConfig } = snapshot;
+    await fs.remove(this.path);
+    await fs.ensureDir(this.path);
+    await fs.copyFile(copyOfBitmap, this.getLastMergedBitmapPath());
+    await fs.copyFile(copyOfWorkspaceJsonc, this.getLastMergedWorkspacePath());
+    if (copyOfCurrentLane) {
+      const compressed = await copyOfCurrentLane.compress();
+      await fs.outputFile(this.getLastMergedLanePath(), compressed);
+    }
+    if (copyOfStagedSnaps) {
+      await fs.copyFile(copyOfStagedSnaps, this.getLastMergedStagedSnapsPath());
+    }
+    if (copyOfStagedConfig) {
+      await fs.copyFile(copyOfStagedConfig, this.getLastMergedStagedConfigPath());
+    }
+  }
+
+  async restoreFromLastMerged(mergeAbortOpts: MergeAbortOpts, currentLane?: Lane | null) {
+    if (!fs.pathExistsSync(this.path)) {
+      throw new BitError(`unable to abort the last lane-merge because "bit export" was running since then`);
+    }
+    const lastLane = await this.getLastMergedLaneContentIfExists();
+
+    if (!fs.pathExistsSync(this.getLastMergedBitmapPath())) {
+      throw new BitError(
+        `unable to abort the last lane-merge because the ${LAST_MERGED_BITMAP_FILENAME} is missing from ${this.path}`
+      );
+    }
+    if (!fs.pathExistsSync(this.getLastMergedWorkspacePath())) {
+      throw new BitError(
+        `unable to abort the last lane-merge because the workspace.jsonc is missing from ${this.path}`
+      );
+    }
+    if (currentLane) {
+      if (!lastLane) {
+        throw new BitError(
+          `unable to abort the last lane-merge because the ${LAST_MERGED_LANE_FILENAME} is missing from ${this.path}`
+        );
+      }
+      const laneFromBackup = await BitObject.parseObject(lastLane, LAST_MERGED_LANE_FILENAME);
+      await this.scope.legacyScope.objects.writeObjectsToTheFS([laneFromBackup]);
+    }
+    const previousBitmapBuffer = await fs.readFile(this.getLastMergedBitmapPath());
+    const previousBitmap = BitMap.loadFromContentWithoutLoadingFiles(previousBitmapBuffer, '', '', '');
+    const currentRootDirs = this.consumer.bitMap.getAllTrackDirs();
+    const previousRootDirs = previousBitmap.getAllTrackDirs();
+    const compDirsToRemove = Object.keys(currentRootDirs).filter((dir) => !previousRootDirs[dir]);
+
+    if (!mergeAbortOpts.silent) {
+      await this.mergeAbortPrompt(compDirsToRemove);
+    }
+    await Promise.all(compDirsToRemove.map((dir) => fs.remove(dir))); // it doesn't throw if not-exist, so we're good here.
+    await fs.copyFile(this.getLastMergedBitmapPath(), this.consumer.bitMap.mapPath);
+    await fs.copyFile(this.getLastMergedWorkspacePath(), this.consumer.config.path);
+    if (fs.pathExistsSync(this.getLastMergedStagedSnapsPath())) {
+      await fs.copyFile(this.getLastMergedStagedSnapsPath(), StagedSnaps.getPath(this.scope.path));
+    } else {
+      await this.scope.legacyScope.stagedSnaps.deleteFile();
+    }
+    const stagedConfig = await this.scope.getStagedConfig();
+    if (fs.pathExistsSync(this.getLastMergedStagedConfigPath())) {
+      await fs.copyFile(this.getLastMergedStagedConfigPath(), stagedConfig.filePath);
+    } else {
+      await stagedConfig.deleteFile();
+    }
+    await fs.remove(this.path);
+
+    return {
+      compDirsToRemove,
+    };
+  }
+
+  private async mergeAbortPrompt(dirsToRemove: string[]) {
+    this.logger.clearStatusLine();
+    const dirsToRemoveStr = dirsToRemove.length
+      ? `\nThe following directories introduced by the merge will be deleted: ${dirsToRemove.join(', ')}`
+      : '';
+    const ok = await yesno({
+      question: `Code changes that were done since the last lane-merge will be lost.${dirsToRemoveStr}
+The .bitmap and workspace.jsonc files will be restored to the state before the merge.
+This action is irreversible.
+${chalk.bold('Do you want to continue? [yes(y)/no(n)]')}`,
+    });
+    if (!ok) {
+      throw new PromptCanceled();
+    }
+  }
+
+  private async getLastMergedLaneContentIfExists(): Promise<Buffer | null> {
+    const filename = this.getLastMergedLanePath();
+    return this.getFileContentIfExist(filename);
+  }
+  private async getFileContentIfExist(filename: string): Promise<Buffer | null> {
+    try {
+      return await fs.readFile(filename);
+    } catch (err: any) {
+      if (err.code === 'ENOENT') return null;
+      throw err;
+    }
+  }
+  private getLastMergedBitmapPath() {
+    return path.join(this.path, LAST_MERGED_BITMAP_FILENAME);
+  }
+  private getLastMergedWorkspacePath() {
+    return path.join(this.path, 'workspace.jsonc');
+  }
+  private getLastMergedLanePath() {
+    return path.join(this.path, LAST_MERGED_LANE_FILENAME);
+  }
+  private getLastMergedStagedSnapsPath() {
+    return path.join(this.path, 'staged-snaps');
+  }
+  private getLastMergedStagedConfigPath() {
+    return path.join(this.path, 'staged-config.json');
+  }
+}

package/merge-abort.cmd.ts

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import { CheckoutProps, checkoutOutput } from '@teambit/checkout';
+import { Command, CommandOptions } from '@teambit/cli';
+import { MergeLanesMain } from './merge-lanes.main.runtime';
+
+export type MergeAbortOpts = {
+  silent?: boolean; // don't show prompt before aborting
+};
+
+export class MergeAbortLaneCmd implements Command {
+  name = 'merge-abort';
+  description = `abort the recent lane-merge. revert the lane object and checkout accordingly`;
+  extendedDescription = `restore the lane-object to its state before the last "bit lane merge" command.
+also, checkout the workspace components according to the restored lane state`;
+  alias = '';
+  options = [
+    ['', 'verbose', "show details of components that didn't need to be merged"],
+    ['s', 'silent', 'skip confirmation'],
+    ['x', 'skip-dependency-installation', 'do not install packages of the imported components'],
+  ] as CommandOptions;
+  loader = true;
+  private = true;
+  migration = true;
+  remoteOp = true;
+
+  constructor(private mergeLanes: MergeLanesMain) {}
+
+  async report(
+    _,
+    {
+      skipDependencyInstallation = false,
+      verbose = false,
+      silent = false,
+    }: {
+      skipDependencyInstallation?: boolean;
+      verbose?: boolean;
+      silent?: boolean;
+    }
+  ): Promise<string> {
+    const checkoutProps: CheckoutProps = {
+      reset: true,
+      all: true,
+      verbose,
+      skipNpmInstall: skipDependencyInstallation,
+    };
+    const mergeAbortOpts = { silent };
+    const { checkoutResults, restoredItems, checkoutError } = await this.mergeLanes.abortLaneMerge(
+      checkoutProps,
+      mergeAbortOpts
+    );
+
+    const getCheckoutErrorStr = () => {
+      if (!checkoutError) return '';
+      const errMsg = `\n\nFailed to change component files to the pre-merge state due to an error:
+${checkoutError.message}
+please fix the error and then run "bit checkout reset --all" to revert the components to the pre-merge state`;
+      return chalk.red(errMsg);
+    };
+
+    const checkoutOutputStr = checkoutResults ? checkoutOutput(checkoutResults, checkoutProps) : '';
+    const restoredItemsTitle = chalk.green('The following have been restored successfully:');
+    const restoredItemsOutput = restoredItems.map((item) => `[√] ${item}`).join('\n');
+
+    return `${checkoutOutputStr}\n\n${restoredItemsTitle}\n${restoredItemsOutput}${getCheckoutErrorStr()}`;
+  }
+}

package/merge-lane-from-scope.cmd.ts

@@ -0,0 +1,124 @@
+import chalk from 'chalk';
+import { DEFAULT_LANE } from '@teambit/lane-id';
+import { Command, CommandOptions } from '@teambit/cli';
+import { fromBase64 } from '@teambit/legacy/dist/utils';
+import { BitError } from '@teambit/bit-error';
+import { MergeLanesMain } from './merge-lanes.main.runtime';
+
+type Flags = {
+  pattern?: string;
+  push?: boolean;
+  keepReadme?: boolean;
+  noSquash: boolean;
+  includeDeps?: boolean;
+  title?: string;
+  titleBase64?: string;
+};
+
+/**
+ * private command. the underscore prefix is intended.
+ */
+export class MergeLaneFromScopeCmd implements Command {
+  name = '_merge-lane <from-lane> [to-lane]';
+  description = `merge a remote lane into another lane or main via a bare-scope (not workspace)`;
+  extendedDescription = `to merge from a workspace, use "bit lane merge" command.
+this is intended to use from the UI, which will have a button to merge an existing lane.
+the lane must be up-to-date with the other lane, otherwise, conflicts might occur which are not handled in this command`;
+  arguments = [
+    {
+      name: 'from-lane',
+      description: 'lane-id to merge from',
+    },
+    {
+      name: 'to-lane',
+      description: `lane-id to merge to. default is "${DEFAULT_LANE}"`,
+    },
+  ];
+  alias = '';
+  options = [
+    ['', 'pattern <string>', 'partially merge the lane with the specified component-pattern'],
+    [
+      '',
+      'title <string>',
+      'if provided, it replaces the original message with this title and append squashed snaps messages',
+    ],
+    ['', 'title-base64 <string>', 'same as --title flag but the title is base64 encoded'],
+    ['', 'push', 'export the updated objects to the original scopes once done'],
+    ['', 'keep-readme', 'skip deleting the lane readme component after merging'],
+    ['', 'no-squash', 'relevant for merging lanes into main, which by default squash.'],
+    ['', 'include-deps', 'relevant for "--pattern". merge also dependencies of the given components'],
+    ['j', 'json', 'output as json format'],
+  ] as CommandOptions;
+  loader = true;
+  private = true;
+  migration = true;
+  remoteOp = true;
+
+  constructor(private mergeLanes: MergeLanesMain) {}
+
+  async report(
+    [fromLane, toLane]: [string, string],
+    { pattern, push = false, keepReadme = false, noSquash = false, includeDeps = false, title, titleBase64 }: Flags
+  ): Promise<string> {
+    if (includeDeps && !pattern) {
+      throw new BitError(`"--include-deps" flag is relevant only for --pattern flag`);
+    }
+
+    const titleBase64Decoded = titleBase64 ? fromBase64(titleBase64) : undefined;
+
+    const { mergedNow, mergedPreviously, exportedIds } = await this.mergeLanes.mergeFromScope(
+      fromLane,
+      toLane || DEFAULT_LANE,
+      {
+        push,
+        keepReadme,
+        noSquash,
+        pattern,
+        includeDeps,
+        snapMessage: titleBase64Decoded || title,
+      }
+    );
+
+    const mergedTitle = chalk.green(
+      `successfully merged ${mergedNow.length} components from ${fromLane} to ${toLane || DEFAULT_LANE}`
+    );
+    const mergedOutput = mergedNow.length ? `${mergedTitle}\n${mergedNow.join('\n')}` : '';
+
+    const nonMergedTitle = chalk.bold(
+      `the following ${mergedPreviously.length} components were already merged before, they were left intact`
+    );
+    const nonMergedOutput = mergedPreviously.length ? `\n${nonMergedTitle}\n${mergedPreviously.join('\n')}` : '';
+
+    const exportedTitle = chalk.green(`successfully exported ${exportedIds.length} components`);
+    const exportedOutput = exportedIds.length ? `\n${exportedTitle}\n${exportedIds.join('\n')}` : '';
+
+    return mergedOutput + nonMergedOutput + exportedOutput;
+  }
+  async json(
+    [fromLane, toLane]: [string, string],
+    { pattern, push = false, keepReadme = false, noSquash = false, includeDeps = false }: Flags
+  ) {
+    if (includeDeps && !pattern) {
+      throw new BitError(`"--include-deps" flag is relevant only for --pattern flag`);
+    }
+    let results: any;
+    try {
+      results = await this.mergeLanes.mergeFromScope(fromLane, toLane || DEFAULT_LANE, {
+        push,
+        keepReadme,
+        noSquash,
+        pattern,
+        includeDeps,
+      });
+      return {
+        code: 0,
+        data: results,
+      };
+    } catch (err: any) {
+      return {
+        code: 1,
+        error: err.message,
+      };
+    }
+  }
+}

package/merge-lane.cmd.ts

@@ -0,0 +1,202 @@
+import chalk from 'chalk';
+import { Command, CommandOptions } from '@teambit/cli';
+import { MergeStrategy } from '@teambit/legacy/dist/consumer/versions-ops/merge-version';
+import { mergeReport } from '@teambit/merging';
+import { GlobalConfigMain } from '@teambit/global-config';
+import { COMPONENT_PATTERN_HELP, CFG_FORCE_LOCAL_BUILD } from '@teambit/legacy/dist/constants';
+import { BitError } from '@teambit/bit-error';
+import { removeTemplate } from '@teambit/remove';
+import { MergeLanesMain } from './merge-lanes.main.runtime';
+
+export class MergeLaneCmd implements Command {
+  name = 'merge <lane> [pattern]';
+  description = `merge a local or a remote lane to the current lane`;
+  extendedDescription = `by default, the provided lane will be fetched from the remote before merging.
+to merge the lane from the local scope without updating it first, use "--skip-fetch" flag.
+
+when the current and merge candidate lanes are diverged in history and the files could be merged with no conflicts,
+these components will be snap-merged to complete the merge. use "no-snap" to opt-out, or "tag" to tag instead.
+
+in case a component in both ends don't share history (no snap is found in common), the merge will require "--resolve-unrelated" flag.
+this flag keeps the history of one end and saves a reference to the other end. the decision of which end to keep is determined by the following:
+1. if the component exists on main, then the history linked to main will be kept.
+in this case, the strategy of "--resolve-unrelated" only determines which source-code to keep. it's not about the history.
+2. if the component doesn't exist on main, then by default, the history of the current lane will be kept.
+unless "--resolve-unrelated" is set to "theirs", in which case the history of the other lane will be kept.
+2. a. an edge case: if the component is deleted on the current lane, the strategy will always be "theirs".
+so then the history (and the source-code) of the other lane will be kept.
+`;
+  arguments = [
+    {
+      name: 'lane',
+      description: 'lane-name or full lane-id (if remote) to merge to the current lane',
+    },
+    {
+      name: 'pattern',
+      description: `partially merge the lane - only components that match the specified component-pattern
+Component pattern format: ${COMPONENT_PATTERN_HELP}`,
+    },
+  ];
+  alias = '';
+  options = [
+    ['', 'ours', 'DEPRECATED. use --auto-merge-resolve. in case of a conflict, keep local modifications'],
+    ['', 'theirs', 'DEPRECATED. use --auto-merge-resolve. in case of a conflict, override local with incoming changes'],
+    ['', 'manual', 'DEPRECATED. use --auto-merge-resolve'],
+    [
+      '',
+      'auto-merge-resolve <merge-strategy>',
+      'in case of a merge conflict, resolve according to the provided strategy: [ours, theirs, manual]',
+    ],
+    ['', 'workspace', 'merge only lane components that are in the current workspace'],
+    ['', 'no-snap', 'do not auto snap after merge completed without conflicts'],
+    ['', 'tag', 'auto-tag all lane components after merging into main (or tag-merge in case of snap-merge)'],
+    ['', 'build', 'in case of snap during the merge, run the build-pipeline (similar to bit snap --build)'],
+    ['m', 'message <message>', 'override the default message for the auto snap'],
+    ['', 'keep-readme', 'skip deleting the lane readme component after merging'],
+    ['', 'no-squash', 'relevant for merging lanes into main, which by default squashes all lane snaps'],
+    [
+      '',
+      'squash',
+      'EXPERIMENTAL. relevant for merging a lane into another non-main lane, which by default does not squash',
+    ],
+    [
+      '',
+      'ignore-config-changes',
+      'allow merging when components are modified due to config changes (such as dependencies) only and not files',
+    ],
+    ['', 'verbose', 'show details of components that were not merged successfully'],
+    ['x', 'skip-dependency-installation', 'do not install dependencies of the imported components'],
+    ['', 'skip-fetch', 'use the local state of target-lane if exits locally, without updating it from the remote'],
+    [
+      '',
+      'include-deps',
+      'relevant for "--pattern" and "--workspace". merge also dependencies of the specified components',
+    ],
+    [
+      '',
+      'resolve-unrelated [merge-strategy]',
+      'relevant when a component on a lane and the component on main have nothing in common. merge-strategy can be "ours" (default) or "theirs"',
+    ],
+    [
+      '',
+      'include-non-lane-comps',
+      'DEPRECATED (this is now the default). when merging main, include workspace components that are not on the lane (by default only lane components are merged)',
+    ],
+    [
+      '',
+      'exclude-non-lane-comps',
+      'when merging main into a lane, exclude workspace components that are not on the lane (by default all workspace components are merged)',
+    ],
+  ] as CommandOptions;
+  loader = true;
+  private = true;
+  migration = true;
+  remoteOp = true;
+
+  constructor(private mergeLanes: MergeLanesMain, private globalConfig: GlobalConfigMain) {}
+
+  async report(
+    [name, pattern]: [string, string],
+    {
+      ours,
+      theirs,
+      manual,
+      autoMergeResolve,
+      build,
+      workspace: existingOnWorkspaceOnly = false,
+      squash = false,
+      noSnap = false,
+      tag = false,
+      message: snapMessage = '',
+      keepReadme = false,
+      noSquash = false,
+      skipDependencyInstallation = false,
+      skipFetch = false,
+      includeDeps = false,
+      resolveUnrelated,
+      ignoreConfigChanges,
+      verbose = false,
+      excludeNonLaneComps = false,
+    }: {
+      ours?: boolean;
+      theirs?: boolean;
+      manual?: boolean;
+      autoMergeResolve?: string;
+      workspace?: boolean;
+      build?: boolean;
+      noSnap: boolean;
+      tag: boolean;
+      message: string;
+      keepReadme?: boolean;
+      squash?: boolean;
+      noSquash: boolean;
+      skipDependencyInstallation?: boolean;
+      skipFetch: boolean;
+      includeDeps?: boolean;
+      resolveUnrelated?: string | boolean;
+      ignoreConfigChanges?: boolean;
+      verbose?: boolean;
+      excludeNonLaneComps?: boolean;
+    }
+  ): Promise<string> {
+    build = (await this.globalConfig.getBool(CFG_FORCE_LOCAL_BUILD)) || Boolean(build);
+    if (ours || theirs || manual) {
+      throw new BitError(
+        'the "--ours", "--theirs" and "--manual" flags are deprecated. use "--auto-merge-resolve" instead. see "bit lane merge --help" for more information'
+      );
+    }
+    if (
+      autoMergeResolve &&
+      autoMergeResolve !== 'ours' &&
+      autoMergeResolve !== 'theirs' &&
+      autoMergeResolve !== 'manual'
+    ) {
+      throw new BitError('--auto-merge-resolve must be one of the following: [ours, theirs, manual]');
+    }
+    const mergeStrategy = autoMergeResolve;
+    if (noSnap && snapMessage) throw new BitError('unable to use "no-snap" and "message" flags together');
+    if (includeDeps && !pattern && !existingOnWorkspaceOnly) {
+      throw new BitError(`"--include-deps" flag is relevant only for --workspace and --pattern flags`);
+    }
+    const getResolveUnrelated = (): MergeStrategy | undefined => {
+      if (!resolveUnrelated) return undefined;
+      if (typeof resolveUnrelated === 'boolean') return 'ours';
+      if (resolveUnrelated !== 'ours' && resolveUnrelated !== 'theirs' && resolveUnrelated !== 'manual') {
+        throw new Error('--resolve-unrelated must be one of the following: [ours, theirs, manual]');
+      }
+      return resolveUnrelated;
+    };
+    if (resolveUnrelated && typeof resolveUnrelated === 'boolean') {
+      resolveUnrelated = 'ours';
+    }
+    const { mergeResults, deleteResults, configMergeResults } = await this.mergeLanes.mergeLane(name, {
+      build,
+      // @ts-ignore
+      mergeStrategy,
+      ours,
+      theirs,
+      existingOnWorkspaceOnly,
+      noSnap,
+      snapMessage,
+      keepReadme,
+      squash,
+      noSquash,
+      tag,
+      pattern,
+      skipDependencyInstallation,
+      skipFetch,
+      resolveUnrelated: getResolveUnrelated(),
+      ignoreConfigChanges,
+      includeDeps,
+      excludeNonLaneComps,
+    });
+
+    const mergeResult = mergeReport({ ...mergeResults, configMergeResults, verbose });
+    const deleteOutput = `\n${deleteResults.localResult ? removeTemplate(deleteResults.localResult, false) : ''}${(
+      deleteResults.remoteResult || []
+    ).map((item) => removeTemplate(item, true))}${
+      (deleteResults.readmeResult && chalk.yellow(deleteResults.readmeResult)) || ''
+    }\n`;
+    return mergeResult + deleteOutput;
+  }
+}

package/merge-lanes.aspect.ts

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