Sh/scope component sets (#43)

* feat: fix merge issues

* test: adds unit tests for SourceCommand.createComponentSet()

* fix: use latest core lib and use default package dir for retrieve output

* refactor: remove commented import

* test: adds more unit tests and small bug fixes

* refactor: update typings

* fix: use version 1.1.21 of the SDR lib

* test: fix unit tests for updates

Author: shetzel

messages/deploy.json

@@ -14,19 +14,17 @@
     "$ sfdx force:source:deploy -q 0Af9A00000FTM6pSAH`"
   ],
   "flags": {
-    "sourcePath": "comma-separated list of source file paths to retrieve",
-    "manifest": "file path for manifest (package.xml) of components to retrieve",
+    "sourcePath": "comma-separated list of source file paths to deploy",
+    "manifest": "file path for manifest (package.xml) of components to deploy",
     "metadata": "comma-separated list of metadata component names",
     "wait": "wait time for command to finish in minutes",
-    "packagename": "a comma-separated list of packages to retrieve",
-    "verbose": "verbose output of retrieve result",
+    "verbose": "verbose output of deploy result",
     "checkonly": "validate deploy but don’t save to the org",
     "testLevel": "deployment testing level",
     "runTests": "tests to run if --testlevel RunSpecifiedTests",
     "ignoreErrors": "ignore any errors and do not roll back deployment",
     "ignoreWarnings": "whether a warning will allow a deployment to complete successfully",
     "validateDeployRequestId": "request ID of the validated deployment to run a Quick Deploy"
   },
-  "SourceRetrieveError": "Could not retrieve files in the sourcepath%s",
   "checkOnlySuccess": "\nSuccessfully validated the deployment"
 }

package.json

@@ -7,8 +7,8 @@
   "dependencies": {
     "@oclif/config": "^1",
     "@salesforce/command": "^3.1.0",
-    "@salesforce/core": "^2.19.1",
-    "@salesforce/source-deploy-retrieve": "^1.1.19",
+    "@salesforce/core": "^2.20.5",
+    "@salesforce/source-deploy-retrieve": "1.1.21",
     "chalk": "^4.1.0",
     "tslib": "^2"
   },

src/commands/force/source/deploy.ts

@@ -4,13 +4,14 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
+
 import * as os from 'os';
 import * as path from 'path';
 import { flags, FlagsConfig } from '@salesforce/command';
 import { Lifecycle, Messages } from '@salesforce/core';
 import { DeployResult } from '@salesforce/source-deploy-retrieve';
 import { Duration } from '@salesforce/kit';
-import { asString, asArray } from '@salesforce/ts-types';
+import { asString, asArray, getBoolean } from '@salesforce/ts-types';
 import * as chalk from 'chalk';
 import { SourceCommand } from '../../../sourceCommand';
 
@@ -30,7 +31,7 @@ export class Deploy extends SourceCommand {
     wait: flags.minutes({
       char: 'w',
       default: Duration.minutes(SourceCommand.DEFAULT_SRC_WAIT_MINUTES),
-      min: Duration.minutes(SourceCommand.MINIMUM_SRC_WAIT_MINUTES),
+      min: Duration.minutes(0), // wait=0 means deploy is asynchronous
       description: messages.getMessage('flags.wait'),
     }),
     testlevel: flags.enum({
@@ -90,20 +91,30 @@ export class Deploy extends SourceCommand {
   public async run(): Promise<DeployResult> {
     if (this.flags.validatedeployrequestid) {
       // TODO: return this.doDeployRecentValidation();
+      throw Error('NOT IMPLEMENTED YET');
     }
     const hookEmitter = Lifecycle.getInstance();
 
     const cs = await this.createComponentSet({
       sourcepath: asArray<string>(this.flags.sourcepath),
       manifest: asString(this.flags.manifest),
       metadata: asArray<string>(this.flags.metadata),
+      apiversion: asString(this.flags.apiversion),
     });
 
     await hookEmitter.emit('predeploy', { packageXmlPath: cs.getPackageXml() });
 
     const results = await cs
       .deploy({
         usernameOrConnection: this.org.getUsername(),
+        apiOptions: {
+          ignoreWarnings: getBoolean(this.flags, 'ignorewarnings', false),
+          rollbackOnError: !getBoolean(this.flags, 'ignoreerrors', false),
+          checkOnly: getBoolean(this.flags, 'checkonly', false),
+          runTests: asArray<string>(this.flags.runtests),
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          testLevel: this.flags.testlevel,
+        },
       })
       .start();
     await hookEmitter.emit('postdeploy', results);
@@ -121,7 +132,7 @@ export class Deploy extends SourceCommand {
       // sort by filename then fullname
       const failures = result.getFileResponses().sort((i, j) => {
         if (i.filePath === j.filePath) {
-          // if the have the same directoryName then sort by fullName
+          // if they have the same directoryName then sort by fullName
           return i.fullName < j.fullName ? 1 : -1;
         }
         return i.filePath < j.filePath ? 1 : -1;
@@ -177,7 +188,7 @@ export class Deploy extends SourceCommand {
     this.printComponentFailures(result);
     // TODO: this.printTestResults(result); <- this has WI @W-8903671@
     if (result.response.success && this.flags.checkonly) {
-      this.log(messages.getMessage('checkOnlySuccess'));
+      this.ux.log(messages.getMessage('checkOnlySuccess'));
     }
 
     return result;

src/commands/force/source/retrieve.ts

@@ -7,18 +7,18 @@
 import * as os from 'os';
 
 import { flags, FlagsConfig } from '@salesforce/command';
-import { Lifecycle, Messages, SfdxError, SfdxProjectJson } from '@salesforce/core';
+import { Lifecycle, Messages, SfdxError } from '@salesforce/core';
 import { Duration } from '@salesforce/kit';
 import { asArray, asString } from '@salesforce/ts-types';
 import { blue } from 'chalk';
-import { MetadataApiRetrieveStatus } from '@salesforce/source-deploy-retrieve';
+import { MetadataApiRetrieveStatus, RetrieveResult } from '@salesforce/source-deploy-retrieve';
 import { FileProperties } from '@salesforce/source-deploy-retrieve/lib/src/client/types';
 import { SourceCommand } from '../../../sourceCommand';
 
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@salesforce/plugin-source', 'retrieve');
 
-export class retrieve extends SourceCommand {
+export class Retrieve extends SourceCommand {
   public static readonly description = messages.getMessage('description');
   public static readonly examples = messages.getMessage('examples').split(os.EOL);
   public static readonly requiresProject = true;
@@ -32,7 +32,7 @@ export class retrieve extends SourceCommand {
     wait: flags.minutes({
       char: 'w',
       default: Duration.minutes(SourceCommand.DEFAULT_SRC_WAIT_MINUTES),
-      min: SourceCommand.MINIMUM_SRC_WAIT_MINUTES,
+      min: Duration.minutes(1),
       description: messages.getMessage('flags.wait'),
     }),
     manifest: flags.filepath({
@@ -53,30 +53,27 @@ export class retrieve extends SourceCommand {
   protected readonly lifecycleEventNames = ['preretrieve', 'postretrieve'];
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public async run(): Promise<any> {
+  public async run(): Promise<RetrieveResult> {
     const hookEmitter = Lifecycle.getInstance();
 
-    const proj = await SfdxProjectJson.create({});
-    const packages = await proj.getPackageDirectories();
-    const defaultPackage = packages.find((pkg) => pkg.default);
+    const defaultPackagePath = this.project.getDefaultPackage().fullPath;
 
     const cs = await this.createComponentSet({
-      // safe to cast from the flags as an array of strings
       packagenames: asArray<string>(this.flags.packagenames),
       sourcepath: asArray<string>(this.flags.sourcepath),
       manifest: asString(this.flags.manifest),
       metadata: asArray<string>(this.flags.metadata),
+      apiversion: asString(this.flags.apiversion),
     });
 
-    // emit pre retrieve event
-    // needs to be a path to the temp dir package.xml
+    // Emit the preretrieve event, which needs the package.xml from the ComponentSet
     await hookEmitter.emit('preretrieve', { packageXmlPath: cs.getPackageXml() });
 
     const mdapiResult = await cs
       .retrieve({
         usernameOrConnection: this.org.getUsername(),
         merge: true,
-        output: (this.flags.sourcepath as string) ?? defaultPackage.path,
+        output: defaultPackagePath,
         packageNames: asArray<string>(this.flags.packagenames),
       })
       .start();
@@ -94,7 +91,7 @@ export class retrieve extends SourceCommand {
       this.printTable(results, true);
     }
 
-    return results;
+    return mdapiResult;
   }
 
   /**

src/sourceCommand.ts

@@ -7,18 +7,18 @@
 import * as path from 'path';
 import { SfdxCommand } from '@salesforce/command';
 import { ComponentSet } from '@salesforce/source-deploy-retrieve';
-import { fs, SfdxError } from '@salesforce/core';
+import { fs, SfdxError, Logger } from '@salesforce/core';
 import { ComponentLike } from '@salesforce/source-deploy-retrieve/lib/src/common';
 
 export type FlagOptions = {
   packagenames?: string[];
   sourcepath: string[];
   manifest: string;
   metadata: string[];
+  apiversion?: string;
 };
 
 export abstract class SourceCommand extends SfdxCommand {
-  public static MINIMUM_SRC_WAIT_MINUTES = 1;
   public static DEFAULT_SRC_WAIT_MINUTES = 33;
   /**
    * will create one ComponentSet to be deployed/retrieved
@@ -27,11 +27,13 @@ export abstract class SourceCommand extends SfdxCommand {
    * @param options: FlagOptions where to create ComponentSets from
    */
   protected async createComponentSet(options: FlagOptions): Promise<ComponentSet> {
+    const logger = Logger.childFromRoot(this.constructor.name);
     const setAggregator: ComponentLike[] = [];
 
     // go through options to create a list of ComponentSets
     // we'll then combine all of those to deploy/retrieve
     if (options.sourcepath) {
+      logger.debug(`Building ComponentSet from sourcepath: ${options.sourcepath.toString()}`);
       options.sourcepath.forEach((filepath) => {
         if (fs.fileExistsSync(filepath)) {
           setAggregator.push(...ComponentSet.fromSource(path.resolve(filepath)));
@@ -41,38 +43,69 @@ export abstract class SourceCommand extends SfdxCommand {
       });
     }
 
+    // Return empty ComponentSet and use packageNames in the library via `.retrieve` options
     if (options.packagenames) {
-      // return ComponentSet and use packageNames in the library via `.retrieve` options
+      logger.debug(`Building ComponentSet for packagenames: ${options.packagenames.toString()}`);
       setAggregator.push(...new ComponentSet([]));
     }
 
+    // Resolve manifest with source in package directories.
     if (options.manifest) {
-      setAggregator.push(
-        ...(await ComponentSet.fromManifestFile(options.manifest, {
-          // to create a link to the actual source component we need to have it resolve through all packages
-          // to find the matching source metadata
-          // this allows us to deploy after
-          resolve: process.cwd(),
-        }))
-      );
+      logger.debug(`Building ComponentSet from manifest: ${options.manifest}`);
+      const packageDirs = this.project.getUniquePackageDirectories().map((pDir) => pDir.fullPath);
+      for (const packageDir of packageDirs) {
+        logger.debug(`Searching in packageDir: ${packageDir} for matching metadata`);
+        const compSet = await ComponentSet.fromManifestFile(options.manifest, { resolve: packageDir });
+        setAggregator.push(...compSet);
+      }
     }
 
+    // Resolve metadata entries with source in package directories.
     if (options.metadata) {
+      logger.debug(`Building ComponentSet from metadata: ${options.metadata.toString()}`);
+
+      // Build a Set of metadata entries
+      const filter = new ComponentSet();
       options.metadata.forEach((entry) => {
         const splitEntry = entry.split(':');
-        const metadata: ComponentLike = {
+        filter.add({
           type: splitEntry[0],
-          // either -m ApexClass or -m ApexClass:MyApexClass
           fullName: splitEntry.length === 1 ? '*' : splitEntry[1],
-        };
-        const cs = new ComponentSet([metadata]);
-        // we need to search the entire project for the matching metadata component
-        // no better way than to have it search than process.cwd()
-        cs.resolveSourceComponents(process.cwd(), { filter: cs });
-        setAggregator.push(...cs);
+        });
       });
+
+      // Search the packages directories for matching metadata
+      const packageDirs = this.project.getUniquePackageDirectories().map((pDir) => pDir.fullPath);
+      logger.debug(`Searching for matching metadata in packageDirs: ${packageDirs.toString()}`);
+      setAggregator.push(...ComponentSet.fromSource({ inclusiveFilter: filter, fsPaths: packageDirs }));
+    }
+
+    const componentSet = new ComponentSet(setAggregator);
+
+    // This is only for debug output of matched files based on the command flags.
+    // It will log up to 20 file matches.
+    // TODO: add logger.debugEnabled
+    if (componentSet.size) {
+      logger.debug(`Matching metadata files (${componentSet.size}):`);
+      const components = componentSet.getSourceComponents().toArray();
+      for (let i = 0; i < componentSet.size; i++) {
+        if (components[i]?.content) {
+          logger.debug(components[i].content);
+        } else if (components[i]?.xml) {
+          logger.debug(components[i].xml);
+        }
+
+        if (i > 18) {
+          logger.debug(`(showing 20 of ${componentSet.size} matches)`);
+          break;
+        }
+      }
+    }
+
+    if (options.apiversion) {
+      componentSet.apiVersion = options.apiversion;
     }
 
-    return new ComponentSet(setAggregator);
+    return componentSet;
   }
 }