feat(stash), introduce a new flag "--include-new" for new components (#9273)

By default, only modified components are stashed. With this flag, new
components are stashed as well and then get removed from the workspace.
Upon `bit stash load`, they are re-created.

Author: davidfirst

e2e/harmony/stash.e2e.ts

@@ -106,4 +106,31 @@ describe('bit stash command', function () {
       expect(index).to.not.have.string('hello');
     });
   });
+  describe('stash new components along with modified', () => {
+    before(() => {
+      helper.scopeHelper.reInitLocalScope();
+      helper.fixtures.populateComponents(2);
+      helper.command.tagWithoutBuild('comp2');
+      helper.fixtures.populateComponents(2, undefined, 'version2');
+      helper.command.stash('--include-new');
+    });
+    it('should stash both of them', () => {
+      const stashList = helper.command.stashList();
+      expect(stashList).to.have.string('2 components');
+    });
+    it('should remove the new component from .bitmap', () => {
+      const bitMap = helper.bitMap.read();
+      expect(bitMap).to.have.property('comp2');
+      expect(bitMap).to.not.have.property('comp1');
+    });
+    describe('stash load them', () => {
+      before(() => {
+        helper.command.stashLoad();
+      });
+      it('should re-create the new component', () => {
+        const bitMap = helper.bitMap.read();
+        expect(bitMap).to.have.property('comp1');
+      });
+    });
+  });
 });

scopes/component/checkout/checkout.main.runtime.ts

@@ -24,6 +24,7 @@ import { CheckoutCmd } from './checkout-cmd';
 import { CheckoutAspect } from './checkout.aspect';
 import { applyVersion, ComponentStatus, ComponentStatusBase, throwForFailures } from './checkout-version';
 import { RevertCmd } from './revert-cmd';
+import { ComponentMap } from '@teambit/legacy.bit-map';
 
 export type CheckoutProps = {
   version?: string; // if reset/head/latest is true, the version is undefined
@@ -47,6 +48,7 @@ export type CheckoutProps = {
   versionPerId?: ComponentID[]; // if given, the ComponentID.version is the version to checkout to.
   skipUpdatingBitmap?: boolean; // needed for stash
   loadStash?: boolean;
+  stashedBitmapEntries?: Array<Partial<ComponentMap>>;
   restoreMissingComponents?: boolean; // in case .bitmap has a component and it's missing from the workspace, restore it (from model)
   allowAddingComponentsFromScope?: boolean; // in case the id doesn't exist in .bitmap, add it from the scope (relevant for switch)
   includeLocallyDeleted?: boolean; // include components that were deleted locally. currently enabled for "bit checkout reset" only.
@@ -74,6 +76,7 @@ export class CheckoutMain {
     const { version, ids, promptMergeOptions } = checkoutProps;
     await this.syncNewComponents(checkoutProps);
     const addedComponents = await this.restoreMissingComponents(checkoutProps);
+    const newComponents = await this.addNewComponents(checkoutProps);
     const bitIds = ComponentIdList.fromArray(ids?.map((id) => id) || []);
     // don't use Promise.all, it loads the components and this operation must be in sequence.
     const allComponentStatusBeforeMerge = await mapSeries(bitIds, (id) =>
@@ -189,6 +192,7 @@ export class CheckoutMain {
       components: appliedVersionComponents,
       removedComponents: componentIdsToRemove,
       addedComponents,
+      newComponents,
       version,
       failedComponents,
       leftUnresolvedConflicts,
@@ -231,6 +235,44 @@ export class CheckoutMain {
     return missing;
   }
 
+  async addNewComponents(checkoutProps: CheckoutProps): Promise<undefined | ComponentID[]> {
+    const stashedBitmapEntries = checkoutProps.stashedBitmapEntries;
+    if (!stashedBitmapEntries) return;
+    const newBitmapEntries = stashedBitmapEntries.filter((entry) => entry.defaultScope);
+    if (!newBitmapEntries.length) return;
+    const newComps = await mapSeries(newBitmapEntries, async (bitmapEntry) => {
+      const id = bitmapEntry.id!;
+      const existingId = this.workspace.bitMap.getBitmapEntryIfExist(id, { ignoreVersion: true });
+      if (existingId) return;
+      const modelComponent = ModelComponent.fromBitId(id);
+      const repo = this.workspace.scope.legacyScope.objects;
+      const consumerComp = await modelComponent.toConsumerComponent(id.version, id.scope, repo);
+      const newCompId = ComponentID.fromObject({ name: id.fullName }, bitmapEntry.defaultScope!);
+      await this.componentWriter.writeMany({
+        components: [consumerComp],
+        skipDependencyInstallation: true,
+        writeToPath: bitmapEntry.rootDir,
+        skipUpdatingBitMap: true,
+      });
+
+      this.workspace.consumer.bitMap.addComponent({
+        componentId: newCompId,
+        files: consumerComp.files.map((f) => ({
+          name: f.basename,
+          relativePath: f.relative,
+          test: f.test,
+        })),
+        mainFile: bitmapEntry.mainFile!,
+        config: bitmapEntry.config,
+        defaultScope: bitmapEntry.defaultScope,
+      });
+      await this.workspace.triggerOnComponentAdd(newCompId, { compile: true });
+      return newCompId;
+    });
+    await this.workspace.bitMap.write();
+    return compact(newComps);
+  }
+
   async checkoutByCLIValues(componentPattern: string, checkoutProps: CheckoutProps): Promise<ApplyVersionResults> {
     const { revert, head } = checkoutProps;
     this.logger.setStatusLine(revert ? 'reverting components...' : BEFORE_CHECKOUT);

scopes/component/merging/merging.main.runtime.ts

@@ -96,6 +96,7 @@ export type ApplyVersionResults = {
   failedComponents?: FailedComponents[];
   removedComponents?: ComponentID[];
   addedComponents?: ComponentID[]; // relevant when restoreMissingComponents is true (e.g. bit lane merge-abort)
+  newComponents?: ComponentID[]; // relevant for "bit stash load". (stashedBitmapEntries is populated)
   resolvedComponents?: ConsumerComponent[]; // relevant for bit merge --resolve
   abortedComponents?: ApplyVersionResult[]; // relevant for bit merge --abort
   mergeSnapResults?: MergeSnapResults;

scopes/component/stash/stash-data.ts

@@ -1,7 +1,8 @@
 import { ComponentID, ComponentIdObj } from '@teambit/component-id';
 
-export type StashCompData = { id: ComponentID; hash: string };
-export type StashCompDataWithIdObj = { id: ComponentIdObj; hash: string };
+type StashCompBase = { hash: string; isNew: boolean; bitmapEntry: Record<string, any> };
+export type StashCompData = { id: ComponentID } & StashCompBase;
+export type StashCompDataWithIdObj = { id: ComponentIdObj } & StashCompBase;
 export type StashMetadata = { message?: string };
 export type StashDataObj = {
   metadata: StashMetadata;
@@ -17,9 +18,11 @@ export class StashData {
   toObject(): StashDataObj {
     return {
       metadata: this.metadata,
-      stashCompsData: this.stashCompsData.map(({ id, hash }) => ({
+      stashCompsData: this.stashCompsData.map(({ id, hash, bitmapEntry, isNew }) => ({
         id: id.changeVersion(undefined).toObject(),
         hash,
+        bitmapEntry,
+        isNew,
       })),
     };
   }
@@ -31,6 +34,8 @@ export class StashData {
         return {
           id,
           hash: compData.hash,
+          bitmapEntry: compData.bitmapEntry,
+          isNew: compData.isNew,
         };
       })
     );

scopes/component/stash/stash.cmd.ts

@@ -14,6 +14,11 @@ export class StashSaveCmd implements Command {
   group = 'development';
   options = [
     ['p', 'pattern', COMPONENT_PATTERN_HELP],
+    [
+      '',
+      'include-new',
+      'EXPERIMENTAL. by default, only modified components are stashed. use this flag to include new components',
+    ],
     ['m', 'message <string>', 'message to be attached to the stashed components'],
   ] as CommandOptions;
   loader = true;
@@ -25,12 +30,14 @@ export class StashSaveCmd implements Command {
     {
       pattern,
       message,
+      includeNew,
     }: {
       pattern?: string;
       message?: string;
+      includeNew?: boolean;
     }
   ) {
-    const compIds = await this.stash.save({ pattern, message });
+    const compIds = await this.stash.save({ pattern, message, includeNew });
     return chalk.green(`stashed ${compIds.length} components`);
   }
 }

scopes/component/stash/stash.main.runtime.ts

@@ -11,6 +11,8 @@ import { StashAspect } from './stash.aspect';
 import { StashCmd, StashListCmd, StashLoadCmd, StashSaveCmd } from './stash.cmd';
 import { StashData } from './stash-data';
 import { StashFiles } from './stash-files';
+import { getBasicLog } from '@teambit/harmony.modules.get-basic-log';
+import { RemoveAspect, RemoveMain } from '@teambit/remove';
 
 type ListResult = {
   id: string;
@@ -23,33 +25,45 @@ export class StashMain {
   constructor(
     private workspace: Workspace,
     private checkout: CheckoutMain,
-    private snapping: SnappingMain
+    private snapping: SnappingMain,
+    private remove: RemoveMain
   ) {
     this.stashFiles = new StashFiles(workspace);
   }
 
-  async save(options: { message?: string; pattern?: string }): Promise<ComponentID[]> {
+  async save(options: { message?: string; pattern?: string; includeNew?: boolean }): Promise<ComponentID[]> {
     const compIds = options?.pattern ? await this.workspace.idsByPattern(options?.pattern) : this.workspace.listIds();
     const comps = await this.workspace.getMany(compIds);
+    const newComps: Component[] = [];
     const modifiedComps = compact(
       await Promise.all(
         comps.map(async (comp) => {
-          if (!comp.head) return undefined; // it's new
+          if (!comp.head) {
+            // it's a new component
+            if (options.includeNew) newComps.push(comp);
+            return undefined;
+          }
           const isModified = await this.workspace.isModified(comp);
           if (isModified) return comp;
           return undefined;
         })
       )
     );
-    if (!modifiedComps.length) return [];
+    const allComps = [...modifiedComps, ...newComps];
+    if (!allComps.length) return [];
 
     // per comp: create Version object, save it in the local scope and return the hash. don't save anything in the .bitmap
-    const consumeComponents = modifiedComps.map((comp) => comp.state._consumer);
+    const consumeComponents = allComps.map((comp) => comp.state._consumer);
     await this.snapping._addFlattenedDependenciesToComponents(consumeComponents);
     const hashPerId = await Promise.all(
-      modifiedComps.map(async (comp) => {
+      allComps.map(async (comp) => {
         const versionObj = await this.addComponentDataToRepo(comp);
-        return { id: comp.id, hash: versionObj.hash().toString() };
+        return {
+          id: comp.id,
+          hash: versionObj.hash().toString(),
+          bitmapEntry: this.workspace.bitMap.getBitmapEntry(comp.id).toPlainObject(),
+          isNew: !comp.id.hasVersion(),
+        };
       })
     );
     await this.workspace.scope.legacyScope.objects.persist();
@@ -63,8 +77,13 @@ export class StashMain {
       skipNpmInstall: true,
       reset: true,
     });
+    // remove new components from the workspace
+    const newCompIds = newComps.map((c) => c.id);
+    if (newComps.length) {
+      await this.remove.removeLocallyByIds(newCompIds);
+    }
 
-    return modifiedCompIds;
+    return [...modifiedCompIds, ...newCompIds];
   }
 
   async list(): Promise<ListResult[]> {
@@ -87,8 +106,14 @@ export class StashMain {
       throw new BitError('no stashed components found');
     }
     const stashData = await this.stashFiles.getStashData(stashFile);
-    const compIds = stashData.stashCompsData.map((c) => c.id);
-    const versionPerId = stashData.stashCompsData.map((c) => c.id.changeVersion(c.hash.toString()));
+    const stashModifiedCompsData = stashData.stashCompsData.filter((c) => !c.isNew);
+    const stashNewCompsData = stashData.stashCompsData.filter((c) => c.isNew);
+    const compIds = stashModifiedCompsData.map((c) => c.id);
+    const versionPerId = stashModifiedCompsData.map((c) => c.id.changeVersion(c.hash.toString()));
+    const stashedBitmapEntries = stashNewCompsData.map((s) => ({
+      ...s.bitmapEntry,
+      id: s.id.changeVersion(s.hash.toString()),
+    }));
 
     await this.checkout.checkout({
       ...checkoutProps,
@@ -98,17 +123,21 @@ export class StashMain {
       skipUpdatingBitmap: true,
       promptMergeOptions: true,
       loadStash: true,
+      stashedBitmapEntries,
     });
 
     await this.stashFiles.deleteStashFile(stashFile);
 
-    return compIds;
+    return [...compIds, ...stashNewCompsData.map((c) => c.id)];
   }
 
   private async addComponentDataToRepo(component: Component) {
     const previousVersion = component.getSnapHash();
     const consumerComponent = component.state._consumer.clone() as ConsumerComponent;
     consumerComponent.setNewVersion();
+    if (!consumerComponent.log) {
+      consumerComponent.log = await getBasicLog();
+    }
     const { version, files } =
       await this.workspace.scope.legacyScope.sources.consumerComponentToVersion(consumerComponent);
     if (previousVersion) {
@@ -126,10 +155,16 @@ export class StashMain {
   }
 
   static slots = [];
-  static dependencies = [CLIAspect, WorkspaceAspect, CheckoutAspect, SnappingAspect];
+  static dependencies = [CLIAspect, WorkspaceAspect, CheckoutAspect, SnappingAspect, RemoveAspect];
   static runtime = MainRuntime;
-  static async provider([cli, workspace, checkout, snapping]: [CLIMain, Workspace, CheckoutMain, SnappingMain]) {
-    const stashMain = new StashMain(workspace, checkout, snapping);
+  static async provider([cli, workspace, checkout, snapping, remove]: [
+    CLIMain,
+    Workspace,
+    CheckoutMain,
+    SnappingMain,
+    RemoveMain,
+  ]) {
+    const stashMain = new StashMain(workspace, checkout, snapping, remove);
     const stashCmd = new StashCmd(stashMain);
     stashCmd.commands = [new StashSaveCmd(stashMain), new StashLoadCmd(stashMain), new StashListCmd(stashMain)];
     cli.register(stashCmd);

src/e2e-helper/e2e-command-helper.ts

@@ -637,8 +637,12 @@ export default class CommandHelper {
     return this.runCmd(`bit revert ${pattern} ${to} ${flags}`);
   }
 
-  stash() {
-    return this.runCmd('bit stash save');
+  stash(flags = '') {
+    return this.runCmd(`bit stash save ${flags}`);
+  }
+
+  stashList(flags = '') {
+    return this.runCmd(`bit stash list ${flags}`);
   }
 
   stashLoad(flags = '') {