fix: change CSB to build from all sources combined

WillieRuemmele · WillieRuemmele · commit 4a29b08db5ce · 2025-02-03T17:11:50.000-07:00
diff --git a/src/collections/componentSetBuilder.ts b/src/collections/componentSetBuilder.ts
@@ -14,7 +14,7 @@ import { SourceComponent } from '../resolve/sourceComponent';
 import { ComponentSet } from '../collections/componentSet';
 import { RegistryAccess } from '../registry/registryAccess';
 import type { FileProperties } from '../client/types';
-import { MetadataType } from '../registry/types';
+import type { MetadataType } from '../registry/types';
 import { MetadataResolver } from '../resolve';
 import { DestructiveChangesType, FromConnectionOptions } from './types';
 
@@ -91,15 +91,15 @@ export class ComponentSetBuilder {
    */
 
   public static async build(options: ComponentSetOptions): Promise<ComponentSet> {
-    let componentSet: ComponentSet | undefined;
-
     const { sourcepath, manifest, metadata, packagenames, org } = options;
     const registry = new RegistryAccess(undefined, options.projectDir);
+    let componentSetToReturn = new ComponentSet(undefined, registry);
 
     if (sourcepath) {
       getLogger().debug(`Building ComponentSet from sourcepath: ${sourcepath.join(', ')}`);
       const fsPaths = sourcepath.map(validateAndResolvePath);
-      componentSet = ComponentSet.fromSource({
+      // first possible option, so we can just set it, next CSB options, must add to this componentSet
+      componentSetToReturn = ComponentSet.fromSource({
         fsPaths,
         registry,
       });
@@ -108,7 +108,6 @@ export class ComponentSetBuilder {
     // Return empty ComponentSet and use packageNames in the connection via `.retrieve` options
     if (packagenames) {
       getLogger().debug(`Building ComponentSet for packagenames: ${packagenames.toString()}`);
-      componentSet ??= new ComponentSet(undefined, registry);
     }
 
     // Resolve manifest with source in package directories.
@@ -117,29 +116,47 @@ export class ComponentSetBuilder {
       assertFileExists(manifest.manifestPath);
 
       getLogger().debug(`Searching in packageDir: ${manifest.directoryPaths.join(', ')} for matching metadata`);
-      componentSet = await ComponentSet.fromManifest({
+      const constructiveCS = await ComponentSet.fromManifest({
         manifestPath: manifest.manifestPath,
         resolveSourcePaths: manifest.directoryPaths,
         forceAddWildcards: true,
-        destructivePre: manifest.destructiveChangesPre,
-        destructivePost: manifest.destructiveChangesPost,
         registry,
       });
+      constructiveCS.toArray().map(addToComponentSet(componentSetToReturn));
+
+      if (manifest.destructiveChangesPre) {
+        // build this up as if it were constructive, to satisfy fromManifest parameter types
+        const destructivePre = await ComponentSet.fromManifest({
+          resolveSourcePaths: manifest.directoryPaths,
+          manifestPath: manifest.destructiveChangesPre,
+          registry,
+        });
+        destructivePre.toArray().map(addToComponentSet(componentSetToReturn, DestructiveChangesType.PRE));
+      }
+
+      if (manifest.destructiveChangesPost) {
+        const destrutivePost = await ComponentSet.fromManifest({
+          manifestPath: manifest.destructiveChangesPost,
+          resolveSourcePaths: manifest.directoryPaths,
+          registry,
+        });
+        destrutivePost.toArray().map(addToComponentSet(componentSetToReturn, DestructiveChangesType.POST));
+      }
+      componentSetToReturn.sourceApiVersion ??= constructiveCS.sourceApiVersion;
+      componentSetToReturn.apiVersion ??= constructiveCS.apiVersion;
     }
 
-    // Resolve metadata entries with source in package directories, unless we are building a ComponentSet
-    // from metadata in an org.
-    if (metadata && !org) {
+    // Resolve metadata entries with source in package directories
+    if (metadata) {
       getLogger().debug(`Building ComponentSet from metadata: ${metadata.metadataEntries.toString()}`);
       const directoryPaths = metadata.directoryPaths;
-      componentSet ??= new ComponentSet(undefined, registry);
       const componentSetFilter = new ComponentSet(undefined, registry);
 
       // Build a Set of metadata entries
-      metadata.metadataEntries
-        .map(entryToTypeAndName(registry))
+      const l = metadata.metadataEntries.filter(filterPsuedoTypes);
+      l.map(entryToTypeAndName(registry))
         .flatMap(typeAndNameToMetadataComponents({ directoryPaths, registry }))
-        .map(addToComponentSet(componentSet))
+        .map(addToComponentSet(componentSetToReturn))
         .map(addToComponentSet(componentSetFilter));
 
       getLogger().debug(`Searching for matching metadata in directories: ${directoryPaths.join(', ')}`);
@@ -148,19 +165,21 @@ export class ComponentSetBuilder {
       // are resolved to SourceComponents
       if (metadata.destructiveEntriesPre) {
         metadata.destructiveEntriesPre
+          .filter(filterPsuedoTypes)
           .map(entryToTypeAndName(registry))
           .map(assertNoWildcardInDestructiveEntries)
           .flatMap(typeAndNameToMetadataComponents({ directoryPaths, registry }))
           .map((mdComponent) => new SourceComponent({ type: mdComponent.type, name: mdComponent.fullName }))
-          .map(addToComponentSet(componentSet, DestructiveChangesType.PRE));
+          .map(addToComponentSet(componentSetToReturn, DestructiveChangesType.PRE));
       }
       if (metadata.destructiveEntriesPost) {
         metadata.destructiveEntriesPost
+          .filter(filterPsuedoTypes)
           .map(entryToTypeAndName(registry))
           .map(assertNoWildcardInDestructiveEntries)
           .flatMap(typeAndNameToMetadataComponents({ directoryPaths, registry }))
           .map((mdComponent) => new SourceComponent({ type: mdComponent.type, name: mdComponent.fullName }))
-          .map(addToComponentSet(componentSet, DestructiveChangesType.POST));
+          .map(addToComponentSet(componentSetToReturn, DestructiveChangesType.POST));
       }
 
       const resolvedComponents = ComponentSet.fromSource({
@@ -169,39 +188,38 @@ export class ComponentSetBuilder {
         registry,
       });
 
-      if (resolvedComponents.forceIgnoredPaths) {
+      if (resolvedComponents?.forceIgnoredPaths) {
         // if useFsForceIgnore = true, then we won't be able to resolve a forceignored path,
         // which we need to do to get the ignored source component
         const resolver = new MetadataResolver(registry, undefined, false);
 
         for (const ignoredPath of resolvedComponents.forceIgnoredPaths ?? []) {
           resolver.getComponentsFromPath(ignoredPath).map((ignored) => {
-            componentSet = componentSet?.filter(
+            componentSetToReturn = componentSetToReturn?.filter(
               (resolved) => !(resolved.fullName === ignored.name && resolved.type === ignored.type)
             );
           });
         }
-        componentSet.forceIgnoredPaths = resolvedComponents.forceIgnoredPaths;
+        componentSetToReturn.forceIgnoredPaths = resolvedComponents.forceIgnoredPaths;
       }
 
-      resolvedComponents.toArray().map(addToComponentSet(componentSet));
+      resolvedComponents?.toArray().map(addToComponentSet(componentSetToReturn));
     }
 
     // Resolve metadata entries with an org connection
     if (org) {
-      componentSet ??= new ComponentSet(undefined, registry);
       const orgComponentSet = await this.resolveOrgComponents(registry, options);
-      orgComponentSet.toArray().map(addToComponentSet(componentSet));
+      orgComponentSet.toArray().map(addToComponentSet(componentSetToReturn));
     }
 
     // there should have been a componentSet created by this point.
-    componentSet = assertComponentSetIsNotUndefined(componentSet);
-    componentSet.apiVersion ??= options.apiversion;
-    componentSet.sourceApiVersion ??= options.sourceapiversion;
-    componentSet.projectDirectory = options.projectDir;
+    componentSetToReturn = assertComponentSetIsNotUndefined(componentSetToReturn);
+    componentSetToReturn.apiVersion ??= options.apiversion;
+    componentSetToReturn.sourceApiVersion ??= options.sourceapiversion;
+    componentSetToReturn.projectDirectory = options.projectDir;
 
-    logComponents(componentSet);
-    return componentSet;
+    logComponents(componentSetToReturn);
+    return componentSetToReturn;
   }
 
   private static async resolveOrgComponents(
@@ -331,6 +349,12 @@ export const entryToTypeAndName =
     return { type, metadataName: name.length ? name.join(':').trim() : '*' };
   };
 
+const filterPsuedoTypes = (value: string): boolean => {
+  const x = Object.values(PSEUDO_TYPES).map((p) => p.toLowerCase());
+  const [typeName] = value.split(':');
+  return !x.includes(typeName.toLowerCase());
+};
+
 const typeAndNameToMetadataComponents =
   (context: { directoryPaths: ManifestOption['directoryPaths']; registry: RegistryAccess }) =>
   ({ type, metadataName }: MetadataTypeAndMetadataName): MetadataComponent[] =>
diff --git a/test/collections/componentSet.test.ts b/test/collections/componentSet.test.ts
@@ -34,7 +34,6 @@ import {
 import { decomposedtoplevel, digitalExperienceBundle, matchingContentFile, mixedContentSingleFile } from '../mock';
 import { MATCHING_RULES_COMPONENT } from '../mock/type-constants/customlabelsConstant';
 import * as manifestFiles from '../mock/manifestConstants';
-import { testApiVersion, testApiVersionAsString } from '../mock/manifestConstants';
 import * as coverage from '../../src/registry/coverage';
 
 const registryAccess = new RegistryAccess();
@@ -436,7 +435,7 @@ describe('ComponentSet', () => {
         ];
         const resolveStub = $$.SANDBOX.stub(ManifestResolver.prototype, 'resolve').resolves({
           components: expected,
-          apiVersion: testApiVersionAsString,
+          apiVersion: manifestFiles.testApiVersionAsString,
         });
         $$.SANDBOX.stub(RegistryAccess.prototype, 'getTypeByName').returns(registry.types.apexclass);
         const manifest = manifestFiles.ONE_FOLDER_MEMBER;
@@ -581,7 +580,7 @@ describe('ComponentSet', () => {
         ];
         const resolveStub = $$.SANDBOX.stub(ConnectionResolver.prototype, 'resolve').resolves({
           components: expected,
-          apiVersion: testApiVersionAsString,
+          apiVersion: manifestFiles.testApiVersionAsString,
         });
         $$.SANDBOX.stub(RegistryAccess.prototype, 'getTypeByName').returns(registry.types.apexclass);
         const set = await ComponentSet.fromConnection({ usernameOrConnection: connection });
@@ -684,7 +683,9 @@ describe('ComponentSet', () => {
     let getCurrentApiVersionStub: SinonStub;
 
     beforeEach(() => {
-      getCurrentApiVersionStub = $$.SANDBOX.stub(coverage, 'getCurrentApiVersion').resolves(testApiVersion);
+      getCurrentApiVersionStub = $$.SANDBOX.stub(coverage, 'getCurrentApiVersion').resolves(
+        manifestFiles.testApiVersion
+      );
     });
 
     afterEach(() => {
@@ -712,7 +713,7 @@ describe('ComponentSet', () => {
               members: ['b', 'c'],
             },
           ],
-          version: testApiVersionAsString,
+          version: manifestFiles.testApiVersionAsString,
         },
       });
       expect(getCurrentApiVersionStub.calledOnce).to.be.true;
@@ -725,7 +726,7 @@ describe('ComponentSet', () => {
         registry: registryAccess,
         tree: manifestFiles.TREE,
       });
-      set.apiVersion = testApiVersionAsString;
+      set.apiVersion = manifestFiles.testApiVersionAsString;
       expect(await set.getObject()).to.deep.equal({
         Package: {
           types: [
@@ -738,7 +739,7 @@ describe('ComponentSet', () => {
               members: ['b', 'c'],
             },
           ],
-          version: testApiVersionAsString,
+          version: manifestFiles.testApiVersionAsString,
         },
       });
       expect(resolveSpy.called).to.be.false;
@@ -778,7 +779,7 @@ describe('ComponentSet', () => {
         registry: registryAccess,
         tree: manifestFiles.TREE,
       });
-      process.env.SF_ORG_API_VERSION = testApiVersionAsString;
+      process.env.SF_ORG_API_VERSION = manifestFiles.testApiVersionAsString;
       expect(await set.getObject()).to.deep.equal({
         Package: {
           types: [
@@ -791,7 +792,7 @@ describe('ComponentSet', () => {
               members: ['b', 'c'],
             },
           ],
-          version: testApiVersionAsString,
+          version: manifestFiles.testApiVersionAsString,
         },
       });
       expect(getCurrentApiVersionStub.called).to.be.false;
@@ -843,7 +844,7 @@ describe('ComponentSet', () => {
               members: ['b', 'c'],
             },
           ],
-          version: testApiVersionAsString,
+          version: manifestFiles.testApiVersionAsString,
         },
       });
     });
@@ -868,7 +869,7 @@ describe('ComponentSet', () => {
               members: ['b', 'c'],
             },
           ],
-          version: testApiVersionAsString,
+          version: manifestFiles.testApiVersionAsString,
         },
       });
     });
@@ -1003,7 +1004,7 @@ describe('ComponentSet', () => {
 
   describe('getPackageXml', () => {
     beforeEach(() => {
-      $$.SANDBOX.stub(coverage, 'getCurrentApiVersion').resolves(testApiVersion);
+      $$.SANDBOX.stub(coverage, 'getCurrentApiVersion').resolves(manifestFiles.testApiVersion);
     });
     it('should return manifest string when initialized from manifest file', async () => {
       const manifest = manifestFiles.ONE_OF_EACH;
diff --git a/test/collections/componentSetBuilder.test.ts b/test/collections/componentSetBuilder.test.ts
@@ -13,9 +13,13 @@ import { assert, expect, config } from 'chai';
 import { Connection, SfError } from '@salesforce/core';
 import { instantiateContext, MockTestOrgData, restoreContext, stubContext } from '@salesforce/core/testSetup';
 import { RegistryAccess } from '../../src/registry/registryAccess';
-import { ComponentSetBuilder, entryToTypeAndName } from '../../src/collections/componentSetBuilder';
+import {
+  ComponentSetBuilder,
+  ComponentSetOptions,
+  entryToTypeAndName,
+} from '../../src/collections/componentSetBuilder';
 import { ComponentSet } from '../../src/collections/componentSet';
-import { FromSourceOptions } from '../../src/collections/types';
+import type { FromSourceOptions } from '../../src/collections/types';
 import { MetadataResolver, SourceComponent } from '../../src';
 
 config.truncateThreshold = 0;
@@ -434,8 +438,6 @@ describe('ComponentSetBuilder', () => {
         forceAddWildcards: true,
         manifestPath: options.manifest.manifestPath,
         resolveSourcePaths: [packageDir1],
-        destructivePre: undefined,
-        destructivePost: undefined,
       });
       expect(compSet.size).to.equal(1);
       expect(compSet.has(apexClassComponent)).to.equal(true);
@@ -467,8 +469,6 @@ describe('ComponentSetBuilder', () => {
         forceAddWildcards: true,
         manifestPath: options.manifest.manifestPath,
         resolveSourcePaths: [packageDir1, packageDir2],
-        destructivePre: undefined,
-        destructivePost: undefined,
       });
       expect(compSet.size).to.equal(2);
       expect(compSet.has(apexClassComponent)).to.equal(true);
@@ -491,6 +491,39 @@ describe('ComponentSetBuilder', () => {
         restoreContext($$);
       });
 
+      it('should create a CS from every option possible', async () => {
+        fileExistsSyncStub.returns(true);
+        fromSourceStub.returns(new ComponentSet([customObjectComponent]));
+        fromManifestStub.resolves(new ComponentSet([apexClassWildcardMatch]));
+        fromConnectionStub.resolves(new ComponentSet([apexClassWildcardNoMatch]));
+
+        const packageDir1 = path.resolve('force-app');
+        const sourcepath = ['force-app', 'my-app'];
+
+        const options: ComponentSetOptions = {
+          sourcepath,
+          org: {
+            username: testOrg.username,
+            exclude: [],
+          },
+          metadata: { directoryPaths: [packageDir1], metadataEntries: ['ApexClass:MyClass'] },
+          manifest: {
+            manifestPath: 'apex-package.xml',
+            directoryPaths: [packageDir1],
+          },
+        };
+
+        const compSet = await ComponentSetBuilder.build(options);
+        expect(fromManifestStub.callCount).to.equal(1);
+        expect(fromSourceStub.callCount).to.equal(2);
+
+        expect(compSet.size).to.equal(4);
+        expect(compSet.has(apexClassComponent)).to.equal(true);
+        expect(compSet.has(customObjectComponent)).to.equal(true);
+        expect(compSet.has(apexClassWildcardNoMatch)).to.equal(true);
+        expect(compSet.has(apexClassWildcardMatch)).to.equal(true);
+      });
+
       it('should create ComponentSet from org connection', async () => {
         componentSet.add(apexClassComponent);
         fromConnectionStub.resolves(componentSet);
@@ -538,10 +571,10 @@ describe('ComponentSetBuilder', () => {
         };
 
         const compSet = await ComponentSetBuilder.build(options);
-        expect(fromSourceStub.callCount).to.equal(0);
+        expect(fromSourceStub.callCount).to.equal(2);
         expect(fromConnectionStub.callCount).to.equal(1);
-        expect(compSet.size).to.equal(1);
-        expect(compSet.has(apexClassComponent)).to.equal(false);
+        expect(compSet.size).to.equal(2);
+        expect(compSet.has(apexClassComponent)).to.equal(true);
         expect(compSet.has(apexClassWildcardMatch)).to.equal(true);
       });
 
