feat: add --no-overwrite and --ignore flags to webapp retrieve command

Author: lesya7

command-snapshot.json

@@ -27,8 +27,8 @@
     "alias": [],
     "command": "webapp:retrieve",
     "flagAliases": [],
-    "flagChars": ["n"],
-    "flags": ["flags-dir", "json", "name"],
+    "flagChars": ["i", "n"],
+    "flags": ["flags-dir", "ignore", "json", "name", "no-overwrite"],
     "plugin": "@salesforce/plugin-webapp"
   },
   {

messages/webapp.retrieve.md

@@ -10,8 +10,28 @@ This command retrieves your web app, its assets, and associated metadata from yo
 
 Name of your web app to retrieve
 
+# flags.no-overwrite.summary
+
+Prevent overwriting existing local files
+
+# flags.ignore.summary
+
+File pattern to ignore during retrieval (e.g., "dist/\*\*")
+
 # examples
 
 - Retrieve a web app:
 
   <%= config.bin %> <%= command.id %> --name myWebApp
+
+- Retrieve a web app with overwrite protection:
+
+  <%= config.bin %> <%= command.id %> --name myWebApp --no-overwrite
+
+- Retrieve a web app while ignoring specific files:
+
+  <%= config.bin %> <%= command.id %> --name myWebApp --ignore "dist/\*\*"
+
+- Retrieve with both options:
+
+  <%= config.bin %> <%= command.id %> --name "myWebApp" --no-overwrite --ignore "dist/\*\*"

schemas/webapp-retrieve.json

@@ -8,11 +8,17 @@
         "name": {
           "type": "string"
         },
+        "noOverwrite": {
+          "type": "boolean"
+        },
+        "ignore": {
+          "type": "string"
+        },
         "success": {
           "type": "boolean"
         }
       },
-      "required": ["name", "success"],
+      "required": ["name", "noOverwrite", "success"],
       "additionalProperties": false
     }
   }

src/commands/webapp/retrieve.ts

@@ -22,6 +22,8 @@ const messages = Messages.loadMessages('@salesforce/plugin-webapp', 'webapp.retr
 
 export type WebappRetrieveResult = {
   name: string;
+  noOverwrite: boolean;
+  ignore?: string;
   success: boolean;
 };
 
@@ -36,25 +38,47 @@ export default class WebappRetrieve extends SfCommand<WebappRetrieveResult> {
       char: 'n',
       required: true,
     }),
+    'no-overwrite': Flags.boolean({
+      summary: messages.getMessage('flags.no-overwrite.summary'),
+      default: false,
+    }),
+    ignore: Flags.string({
+      summary: messages.getMessage('flags.ignore.summary'),
+      char: 'i',
+      required: false,
+    }),
   };
 
   public async run(): Promise<WebappRetrieveResult> {
     const { flags } = await this.parse(WebappRetrieve);
 
     this.log(`Retrieving web app: ${flags.name}`);
+
+    if (flags['no-overwrite']) {
+      this.log('Overwrite protection enabled - existing files will not be replaced');
+    }
+
+    if (flags.ignore) {
+      this.log(`Ignoring pattern: ${flags.ignore}`);
+    }
+
     this.log('Retrieving your web app, its assets and associated metadata from your org...');
 
     // TODO: Implement web app retrieval logic
     // This would typically involve:
     // 1. Connecting to the Salesforce org
     // 2. Retrieving web app metadata
     // 3. Downloading assets and bundle
-    // 4. Saving locally with proper structure
+    // 4. Applying ignore patterns if specified
+    // 5. Checking for existing files if no-overwrite is set
+    // 6. Saving locally with proper structure
 
     this.log(`Successfully retrieved ${flags.name}`);
 
     return {
       name: flags.name,
+      noOverwrite: flags['no-overwrite'],
+      ignore: flags.ignore,
       success: true,
     };
   }

test/commands/webapp/retrieve.nut.ts

@@ -28,9 +28,31 @@ describe('webapp retrieve NUTs', () => {
   });
 
   it('should display provided name', () => {
-    const name = 'World';
+    const name = 'myWebApp';
     const command = `webapp retrieve --name ${name}`;
     const output = execCmd(command, { ensureExitCode: 0 }).shellOutput.stdout;
     expect(output).to.contain(name);
   });
+
+  it('should retrieve with no-overwrite flag', () => {
+    const command = 'webapp retrieve --name myWebApp --no-overwrite';
+    const output = execCmd(command, { ensureExitCode: 0 }).shellOutput.stdout;
+    expect(output).to.contain('Overwrite protection enabled');
+    expect(output).to.contain('Successfully retrieved myWebApp');
+  });
+
+  it('should retrieve with ignore pattern', () => {
+    const command = 'webapp retrieve --name myWebApp --ignore "dist/**"';
+    const output = execCmd(command, { ensureExitCode: 0 }).shellOutput.stdout;
+    expect(output).to.contain('Ignoring pattern: dist/**');
+    expect(output).to.contain('Successfully retrieved myWebApp');
+  });
+
+  it('should retrieve with both no-overwrite and ignore', () => {
+    const command = 'webapp retrieve --name myWebApp --no-overwrite --ignore "dist/**"';
+    const output = execCmd(command, { ensureExitCode: 0 }).shellOutput.stdout;
+    expect(output).to.contain('Overwrite protection enabled');
+    expect(output).to.contain('Ignoring pattern: dist/**');
+    expect(output).to.contain('Successfully retrieved myWebApp');
+  });
 });

test/commands/webapp/retrieve.test.ts

@@ -33,6 +33,30 @@ describe('webapp retrieve', () => {
   it('retrieves webapp with required name flag', async () => {
     const result = await WebappRetrieve.run(['--name', 'myWebApp']);
     expect(result.name).to.equal('myWebApp');
+    expect(result.noOverwrite).to.be.false;
+    expect(result.ignore).to.be.undefined;
+    expect(result.success).to.be.true;
+  });
+
+  it('retrieves webapp with no-overwrite flag', async () => {
+    const result = await WebappRetrieve.run(['--name', 'myWebApp', '--no-overwrite']);
+    expect(result.name).to.equal('myWebApp');
+    expect(result.noOverwrite).to.be.true;
+    expect(result.success).to.be.true;
+  });
+
+  it('retrieves webapp with ignore pattern', async () => {
+    const result = await WebappRetrieve.run(['--name', 'myWebApp', '--ignore', 'dist/**']);
+    expect(result.name).to.equal('myWebApp');
+    expect(result.ignore).to.equal('dist/**');
+    expect(result.success).to.be.true;
+  });
+
+  it('retrieves webapp with both no-overwrite and ignore flags', async () => {
+    const result = await WebappRetrieve.run(['--name', 'myWebApp', '--no-overwrite', '--ignore', 'dist/**']);
+    expect(result.name).to.equal('myWebApp');
+    expect(result.noOverwrite).to.be.true;
+    expect(result.ignore).to.equal('dist/**');
     expect(result.success).to.be.true;
   });
 
@@ -51,4 +75,22 @@ describe('webapp retrieve', () => {
     expect(output).to.include('Retrieving web app: myWebApp');
     expect(output).to.include('Successfully retrieved myWebApp');
   });
+
+  it('outputs overwrite protection message', async () => {
+    await WebappRetrieve.run(['--name', 'myWebApp', '--no-overwrite']);
+    const output = sfCommandStubs.log
+      .getCalls()
+      .flatMap((c) => c.args)
+      .join('\n');
+    expect(output).to.include('Overwrite protection enabled');
+  });
+
+  it('outputs ignore pattern message', async () => {
+    await WebappRetrieve.run(['--name', 'myWebApp', '--ignore', 'dist/**']);
+    const output = sfCommandStubs.log
+      .getCalls()
+      .flatMap((c) => c.args)
+      .join('\n');
+    expect(output).to.include('Ignoring pattern: dist/**');
+  });
 });