feat: add --ignored-only flag to 'project deploy preview'

Author: WillieRuemmele

command-snapshot.json

@@ -14,7 +14,7 @@
   {
     "command": "project:deploy:preview",
     "plugin": "@salesforce/plugin-deploy-retrieve",
-    "flags": ["ignore-conflicts", "json", "manifest", "metadata", "source-dir", "target-org"],
+    "flags": ["ignore-conflicts", "json", "manifest", "metadata", "only-ignored", "source-dir", "target-org"],
     "alias": ["deploy:metadata:preview"]
   },
   {

dreamhouse-lwc

@@ -36,6 +36,10 @@ To preview the deployment of multiple metadata components, either set multiple -
 
 Login username or alias for the target org.
 
+# flags.only-ignored.summary
+
+Preview files to be ignored in a deployment.
+
 # flags.target-org.description
 
 Overrides your default org.

messages/deploy.metadata.preview.md

@@ -4,12 +4,21 @@
  * 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 fs from 'fs';
+import * as path from 'path';
 import { Messages } from '@salesforce/core';
 import { SfCommand, Flags } from '@salesforce/sf-plugins-core';
 import { SourceTracking } from '@salesforce/source-tracking';
-import { ForceIgnore } from '@salesforce/source-deploy-retrieve';
+import { ForceIgnore, MetadataResolver, NodeFSTreeContainer, RegistryAccess } from '@salesforce/source-deploy-retrieve';
 import { buildComponentSet } from '../../../utils/deploy';
-import { PreviewResult, printTables, compileResults, getConflictFiles } from '../../../utils/previewOutput';
+import {
+  PreviewResult,
+  printTables,
+  compileResults,
+  getConflictFiles,
+  printIgnoredTable,
+  PreviewFile,
+} from '../../../utils/previewOutput';
 
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@salesforce/plugin-deploy-retrieve', 'deploy.metadata.preview');
@@ -32,6 +41,11 @@ export default class DeployMetadataPreview extends SfCommand<PreviewResult> {
       description: messages.getMessage('flags.ignore-conflicts.description'),
       default: false,
     }),
+    'only-ignored': Flags.boolean({
+      char: 'i',
+      summary: messages.getMessage('flags.only-ignored.summary'),
+      exclusive: ['manifest', 'metadata', 'ignore-conflicts'],
+    }),
     manifest: Flags.file({
       char: 'x',
       description: messages.getMessage('flags.manifest.description'),
@@ -60,9 +74,17 @@ export default class DeployMetadataPreview extends SfCommand<PreviewResult> {
     }),
   };
 
+  public forceIgnore!: ForceIgnore;
+
   public async run(): Promise<PreviewResult> {
     const { flags } = await this.parse(DeployMetadataPreview);
     const deploySpecified = [flags.manifest, flags.metadata, flags['source-dir']].some((f) => f !== undefined);
+    const defaultPackagePath = this.project.getDefaultPackage().path;
+    this.forceIgnore = ForceIgnore.findAndCreate(defaultPackagePath);
+
+    if (flags['only-ignored']) {
+      return this.calculateAndPrintForceIgnoredFiles({ sourceDir: flags['source-dir'], defaultPackagePath });
+    }
 
     // we'll need STL both to check conflicts and to get the list of local changes if no flags are provided
     const stl =
@@ -73,8 +95,6 @@ export default class DeployMetadataPreview extends SfCommand<PreviewResult> {
             project: this.project,
           });
 
-    const forceIgnore = ForceIgnore.findAndCreate(this.project.getDefaultPackage().path);
-
     const [componentSet, filesWithConflicts] = await Promise.all([
       buildComponentSet({ ...flags, 'target-org': flags['target-org'].getUsername() }, stl),
       getConflictFiles(stl, flags['ignore-conflicts']),
@@ -84,7 +104,7 @@ export default class DeployMetadataPreview extends SfCommand<PreviewResult> {
       componentSet,
       projectPath: this.project.getPath(),
       filesWithConflicts,
-      forceIgnore,
+      forceIgnore: this.forceIgnore,
       baseOperation: 'deploy',
     });
 
@@ -93,4 +113,49 @@ export default class DeployMetadataPreview extends SfCommand<PreviewResult> {
     }
     return output;
   }
+
+  private async calculateAndPrintForceIgnoredFiles(options: {
+    sourceDir?: string[];
+    defaultPackagePath: string;
+  }): Promise<PreviewResult> {
+    // the third parameter makes the resolver use the default ForceIgnore entries, which will allow us to .getComponentsFromPath of a .forceignored path
+    const mdr = new MetadataResolver(new RegistryAccess(), new NodeFSTreeContainer(), false);
+
+    const ignoredFiles: PreviewFile[] = (
+      await Promise.all((options.sourceDir ?? [options.defaultPackagePath]).map((sp) => this.statIgnored(sp.trim())))
+    )
+      .flat()
+      .map((entry) => {
+        try {
+          const component = mdr.getComponentsFromPath(path.resolve(entry))[0];
+          return {
+            projectRelativePath: entry,
+            fullName: component?.fullName,
+            type: component?.type.name,
+            ignored: true,
+            conflict: false,
+          };
+        } catch (e) {
+          // some file paths, such as aura/.eslintrc.json will cause issues when getComponentsFromPath(), so catch the error and continue without type information
+          return { projectRelativePath: entry, ignored: true, conflict: false } as PreviewFile;
+        }
+      });
+    if (!this.jsonEnabled()) printIgnoredTable(ignoredFiles, 'deploy');
+    return { ignored: ignoredFiles, conflicts: [], toDeploy: [], toDelete: [], toRetrieve: [] };
+  }
+
+  // Stat the filepath. Test if a file, recurse if a directory.
+  private async statIgnored(filepath: string): Promise<string[]> {
+    const stats = await fs.promises.stat(filepath);
+    if (stats.isDirectory()) {
+      return (await Promise.all(await this.findIgnored(filepath))).flat();
+    } else {
+      return this.forceIgnore.denies(filepath) ? [filepath] : [];
+    }
+  }
+
+  // Recursively search a directory for source files to test.
+  private async findIgnored(dir: string): Promise<Array<Promise<string[]>>> {
+    return (await fs.promises.readdir(dir)).map((filename) => this.statIgnored(path.join(dir, filename)));
+  }
 }

src/commands/project/deploy/preview.ts

@@ -243,7 +243,7 @@ const printConflictsTable = (files: PreviewFile[]): void => {
   }
 };
 
-const printIgnoredTable = (files: PreviewFile[], baseOperation: BaseOperation): void => {
+export const printIgnoredTable = (files: PreviewFile[], baseOperation: BaseOperation): void => {
   ux.log();
   if (files.length === 0) {
     ux.log(dim(messages.getMessage('ignored.none')));

src/utils/previewOutput.ts

@@ -60,7 +60,7 @@ describe('forceignore changes', () => {
     await session?.clean();
   });
 
-  describe('local', () => {
+  describe.only('local', () => {
     it('will not push a file that was created, then ignored', async () => {
       // setup a forceIgnore with some file.  forceignore uses posix style paths
       const newForceIgnore = originalForceIgnore + '\n' + `${classdir}/IgnoreTest.cls*`;
@@ -72,6 +72,54 @@ describe('forceignore changes', () => {
       expect(output?.message).to.equal(deployMessages.getMessage('error.nothingToDeploy'));
     });
 
+    it('will list the forceignored files in a certain path', () => {
+      const classDir = path.join('force-app', 'main', 'default', 'classes');
+      const output = execCmd<PreviewResult>(`deploy:metadata:preview --only-ignored --source-dir ${classdir} --json`, {
+        ensureExitCode: 0,
+      }).jsonOutput?.result;
+
+      expect(output?.conflicts).to.deep.equal([]);
+      expect(output?.toDeploy).to.deep.equal([]);
+      expect(output?.toRetrieve).to.deep.equal([]);
+      expect(output?.toDelete).to.deep.equal([]);
+      expect(output?.ignored?.length).to.equal(2);
+      expect(output?.ignored).to.be.deep.equal([
+        {
+          projectRelativePath: `${path.join(classDir, 'IgnoreTest.cls')}`,
+          fullName: 'IgnoreTest',
+          type: 'ApexClass',
+          ignored: true,
+          conflict: false,
+        },
+        {
+          projectRelativePath: `${path.join(classDir, 'IgnoreTest.cls-meta.xml')}`,
+          fullName: 'IgnoreTest',
+          type: 'ApexClass',
+          ignored: true,
+          conflict: false,
+        },
+      ]);
+    });
+
+    it('will list the forceignored files', () => {
+      const output = execCmd<PreviewResult>('deploy:metadata:preview --only-ignored --json', {
+        ensureExitCode: 0,
+      }).jsonOutput?.result;
+
+      expect(output?.conflicts).to.deep.equal([]);
+      expect(output?.toDeploy).to.deep.equal([]);
+      expect(output?.toRetrieve).to.deep.equal([]);
+      expect(output?.toDelete).to.deep.equal([]);
+      expect(output?.ignored?.length).to.equal(4);
+      expect(
+        output?.ignored.find((entry) => entry.projectRelativePath?.includes(path.join('aura', '.eslintrc.json')))
+      ).to.deep.equal({
+        projectRelativePath: path.join('force-app', 'main', 'default', 'aura', '.eslintrc.json'),
+        ignored: true,
+        conflict: false,
+      });
+    });
+
     it('shows the file in status as ignored', () => {
       const output = execCmd<StatusResult>('force:source:status --json', {
         ensureExitCode: 0,
@@ -169,7 +217,7 @@ describe('forceignore changes', () => {
         ensureExitCode: 0,
       }).jsonOutput?.result;
       expect(
-        response?.ignored.some((c) => c.fullName === 'CreatedClass' && c.type === 'ApexClass' && c.ignored === true),
+        response?.ignored.some((c) => c.fullName === 'CreatedClass' && c.type === 'ApexClass' && c.ignored),
         JSON.stringify(response)
       ).to.equal(true);
     });