fix(local-only), do not auto-tag/snap local-only, block export when some ids are local-only (#9059)

also, remove the --include-local-only flag.

This is related to the recently-merged local-only feature:
#9057.
The original implementation has two issues: 
1. It's possible to snap/tag local-only components with
`--include-local-only` flag. Then, the export filters them out. However,
what if it has been unset later on, snapped again and exported. The
remote doesn't have part of the history which was local-only back then.
2. when on a lane and some local-only components were snapped with the
flag above, the export sends a lane object to the remote with some
components that exist only locally.

This PR handles the issues above by the follwoing:
1. removes the `--include-local-only` flag, so it's impossible to
snap/tag local-only components.
2.  block `bit local-only set` from running on staged components.
3. just in case somehow a component was managed to be local-only when
it's staged, `bit export` blocks the export and suggests running `bit
reset` or `bit local-only unset`.

Author: davidfirst

scopes/component/snapping/snapping.main.runtime.ts

@@ -159,7 +159,6 @@ export class SnappingMain {
     incrementBy = 1,
     disableTagAndSnapPipelines = false,
     failFast = false,
-    includeLocalOnly,
   }: {
     ids?: string[];
     all?: boolean | string;
@@ -193,8 +192,7 @@ export class SnappingMain {
       persist,
       ids,
       snapped,
-      unmerged,
-      includeLocalOnly
+      unmerged
     );
     if (!bitIds.length) return null;
 
@@ -550,7 +548,6 @@ if you're willing to lose the history from the head to the specified version, us
     rebuildDepsGraph,
     unmodified = false,
     exitOnFirstFailedTask = false,
-    includeLocalOnly,
   }: Partial<BasicTagSnapParams> & {
     pattern?: string;
     legacyBitIds?: ComponentIdList;
@@ -619,7 +616,7 @@ if you're willing to lose the history from the head to the specified version, us
       if (unmerged) {
         return componentsList.listDuringMergeStateComponents();
       }
-      const tagPendingComponentsIds = await self.getTagPendingComponentsIds(unmodified, includeLocalOnly);
+      const tagPendingComponentsIds = await self.getTagPendingComponentsIds(unmodified);
       if (!tagPendingComponentsIds.length) return null;
       // when unmodified, we ask for all components, throw if no matching. if not unmodified and no matching, see error
       // below, suggesting to use --unmodified flag.
@@ -1178,13 +1175,10 @@ another option, in case this dependency is not in main yet is to remove all refe
     component.config.extensions.push(extension);
   }
 
-  private async getTagPendingComponentsIds(includeUnmodified = false, includeLocalOnly = false) {
+  private async getTagPendingComponentsIds(includeUnmodified = false) {
     const ids = includeUnmodified
       ? await this.workspace.listPotentialTagIds()
       : await this.workspace.listTagPendingIds();
-    if (includeLocalOnly) {
-      return ids;
-    }
     const localOnlyIds = this.workspace.filter.byLocalOnly(ids);
     if (!localOnlyIds.length) {
       return ids;
@@ -1199,8 +1193,7 @@ another option, in case this dependency is not in main yet is to remove all refe
     persist: boolean,
     ids: string[],
     snapped: boolean,
-    unmerged: boolean,
-    includeLocalOnly = false
+    unmerged: boolean
   ): Promise<{ bitIds: ComponentID[]; warnings: string[] }> {
     const warnings: string[] = [];
     const componentsList = new ComponentsList(this.workspace.consumer);
@@ -1209,13 +1202,13 @@ another option, in case this dependency is not in main yet is to remove all refe
       return { bitIds: softTaggedComponents, warnings: [] };
     }
 
-    const tagPendingComponentsIds = await this.getTagPendingComponentsIds(includeUnmodified, includeLocalOnly);
+    const tagPendingComponentsIds = await this.getTagPendingComponentsIds(includeUnmodified);
 
     const snappedComponentsIds = (await this.workspace.filter.bySnappedOnMain()).map((id) =>
       id.changeVersion(undefined)
     );
 
-    if (snappedComponentsIds.length && !includeLocalOnly) {
+    if (snappedComponentsIds.length) {
       const localOnlyIds = this.workspace.filter.byLocalOnly(snappedComponentsIds);
       const localOnlyListIds = ComponentIdList.fromArray(localOnlyIds);
       snappedComponentsIds.forEach((id) => {

scopes/component/snapping/snapping.spec.ts

@@ -183,14 +183,24 @@ describe('Snapping aspect', function () {
       const taggedNames = tagResults?.snappedComponents.map((c) => c.name);
       expect(taggedNames).to.not.include('comp1');
     });
-    it('should never be exported even when tagged with --include-local-only', async () => {
+    it('should be ignored when it is an auto-tag candidate', async () => {
       const snapping = harmony.get<SnappingMain>(SnappingAspect.id);
-      const tagResults = await snapping.tag({ unmodified: true, includeLocalOnly: true });
-      expect(tagResults?.taggedComponents).to.have.lengthOf(3);
-
-      const exportAspect = harmony.get<ExportMain>(ExportAspect.id);
-      const result = await exportAspect.export();
-      expect(result.componentsIds).to.have.lengthOf(2);
+      await snapping.tag({ unmodified: true });
+      const tagResults = await snapping.tag({ ids: ['comp3'], unmodified: true });
+      expect(tagResults?.autoTaggedResults).to.have.lengthOf(1); // only comp3 should be auto-tagged
+      const taggedNames = tagResults?.autoTaggedResults.map((c) => c.component.name);
+      expect(taggedNames).to.not.include('comp1');
+    });
+    it('should block setting local-only when a component is staged', async () => {
+      const snapping = harmony.get<SnappingMain>(SnappingAspect.id);
+      await snapping.tag({ unmodified: true });
+      const comp2Id = await workspace.idsByPattern('comp2');
+      try {
+        await workspace.setLocalOnly(comp2Id);
+        expect.fail('should have thrown an error');
+      } catch (err: any) {
+        expect(err.message).to.include('unable to set the following component(s) as local-only');
+      }
     });
   });
 });

scopes/component/snapping/tag-cmd.ts

@@ -93,7 +93,6 @@ to ignore multiple issues, separate them by a comma and wrap with quotes. to ign
       'stop pipeline execution on the first failed task (by default a task is skipped only when its dependency failed)',
     ],
     ['b', 'build', 'locally run the build pipeline (i.e. not via rippleCI) and complete the tag'],
-    ['', 'include-local-only', 'include local-only components in the tag process'],
   ] as CommandOptions;
   remoteOp = true; // In case a compiler / tester is not installed
   examples = [{ cmd: 'tag --ver 1.0.0', description: 'tag all components to version 1.0.0' }];
@@ -130,7 +129,6 @@ to ignore multiple issues, separate them by a comma and wrap with quotes. to ign
       rebuildDepsGraph,
       failFast = false,
       incrementBy = 1,
-      includeLocalOnly,
     }: {
       snapped?: boolean;
       unmerged?: boolean;
@@ -234,7 +232,6 @@ To undo local tag use the "bit reset" command.`
       incrementBy,
       version: ver,
       failFast,
-      includeLocalOnly,
     };
 
     const results = await this.snapping.tag(params);

scopes/component/snapping/tag-model-component.ts

@@ -39,7 +39,6 @@ export type BasicTagSnapParams = {
   build?: boolean;
   ignoreBuildErrors?: boolean;
   rebuildDepsGraph?: boolean;
-  includeLocalOnly?: boolean;
 };
 
 export type BasicTagParams = BasicTagSnapParams & {
@@ -243,8 +242,12 @@ export async function tagModelComponent({
   // ids without versions are new. it's impossible that tagged (and not-modified) components has
   // them as dependencies.
   const idsToTriggerAutoTag = idsToTag.filter((id) => id.hasVersion());
-  const autoTagData =
+  const autoTagDataWithLocalOnly =
     skipAutoTag || !consumer ? [] : await getAutoTagInfo(consumer, ComponentIdList.fromArray(idsToTriggerAutoTag));
+  const localOnly = workspace?.listLocalOnly();
+  const autoTagData = localOnly
+    ? autoTagDataWithLocalOnly.filter((autoTagItem) => !localOnly.hasWithoutVersion(autoTagItem.component.id))
+    : autoTagDataWithLocalOnly;
   const autoTagComponents = autoTagData.map((autoTagItem) => autoTagItem.component);
   const autoTagComponentsFiltered = autoTagComponents.filter((c) => !idsToTag.has(c.id));
   const autoTagIds = ComponentIdList.fromArray(autoTagComponentsFiltered.map((autoTag) => autoTag.id));

scopes/scope/export/export.main.runtime.ts

@@ -761,12 +761,17 @@ if the export fails with missing objects/versions/components, run "bit fetch --l
     const consumer = this.workspace.consumer;
     const componentsList = new ComponentsList(consumer);
     const idsHaveWildcard = hasWildcard(ids);
-    const filterLocalOnlyIfNeeded = async (
+    const throwForLocalOnlyIfNeeded = async (
       bitIds: ComponentIdList
     ): Promise<{ idsToExport: ComponentIdList; missingScope: ComponentID[]; idsWithFutureScope: ComponentIdList }> => {
       const localOnlyComponents = this.workspace.listLocalOnly();
-      const idsToExport = bitIds.filter((id) => !localOnlyComponents.hasWithoutScopeAndVersion(id));
-      return { idsToExport: ComponentIdList.fromArray(idsToExport), missingScope: [], idsWithFutureScope: bitIds };
+      const localOnlyExportPending = bitIds.filter((id) => localOnlyComponents.hasWithoutScopeAndVersion(id));
+      if (localOnlyExportPending.length) {
+        throw new BitError(`unable to export the following components as they are local only:
+(either bit-reset them or run "bit local-only unset" to make them non local only)
+${localOnlyExportPending.map((c) => c.toString()).join('\n')}`);
+      }
+      return { idsToExport: ComponentIdList.fromArray(bitIds), missingScope: [], idsWithFutureScope: bitIds };
     };
     if (isUserTryingToExportLanes(consumer)) {
       if (ids.length) {
@@ -775,7 +780,7 @@ if the export fails with missing objects/versions/components, run "bit fetch --l
       const { componentsToExport, laneObject } = await this.getLaneCompIdsToExport(consumer, includeNonStaged);
       const loaderMsg = componentsToExport.length > 1 ? BEFORE_EXPORTS : BEFORE_EXPORT;
       loader.start(loaderMsg);
-      const filtered = await filterLocalOnlyIfNeeded(componentsToExport);
+      const filtered = await throwForLocalOnlyIfNeeded(componentsToExport);
       return { ...filtered, laneObject };
     }
     if (!ids.length || idsHaveWildcard) {
@@ -788,14 +793,14 @@ if the export fails with missing objects/versions/components, run "bit fetch --l
         : exportPendingComponents;
       const loaderMsg = componentsToExport.length > 1 ? BEFORE_EXPORTS : BEFORE_EXPORT;
       loader.start(loaderMsg);
-      return filterLocalOnlyIfNeeded(componentsToExport);
+      return throwForLocalOnlyIfNeeded(componentsToExport);
     }
     loader.start(BEFORE_EXPORT); // show single export
     const parsedIds = await Promise.all(ids.map((id) => getParsedId(consumer, id)));
     // load the components for fixing any out-of-sync issues.
     await consumer.loadComponents(ComponentIdList.fromArray(parsedIds));
 
-    return filterLocalOnlyIfNeeded(ComponentIdList.fromArray(parsedIds));
+    return throwForLocalOnlyIfNeeded(ComponentIdList.fromArray(parsedIds));
   }
 
   private async getLaneCompIdsToExport(

scopes/workspace/workspace/workspace.ts

@@ -2160,6 +2160,19 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
   }
 
   async setLocalOnly(ids: ComponentID[]) {
+    const staged = compact(
+      await mapSeries(ids, async (id) => {
+        const componentStatus = await this.getComponentStatusById(id);
+        if (componentStatus.staged) return id;
+      })
+    );
+    if (staged.length) {
+      throw new BitError(
+        `unable to set the following component(s) as local-only because they have local snaps/tags: ${staged.join(
+          ', '
+        )}`
+      );
+    }
     this.bitMap.setLocalOnly(ids);
     await this.bitMap.write('setLocalOnly');
   }