fix: metadata isn't refreshed in the correct path and is missing -meta.xml. Also fix refresh of metadata doesn't include -meta.xml

Codeneos · Codeneos · commit fa1589b11381 · 2025-07-27T22:17:49.000+02:00
diff --git a/packages/salesforce/src/deploy/metadataExpander.ts b/packages/salesforce/src/deploy/metadataExpander.ts
@@ -0,0 +1,47 @@
+import path from 'path';
+import { SalesforcePackageComponentFile } from './package';
+import { outputFile } from 'fs-extra';
+
+interface MetadataFile extends SalesforcePackageComponentFile {
+    read(): Promise<Buffer>;
+}
+
+interface OutputFile {
+    ( name: string, data: Buffer ): Promise<void>;
+}
+
+export class MetadataExpander {
+    public constructor() {
+    }
+
+    public async expandMetadata(metadata: MetadataFile): Promise<Record<string, Buffer>> {
+        const expandedMetadata: Record<string, Buffer> = {};
+
+        const metadataContent = await metadata.read();
+        const basename = decodeURIComponent(path.basename(metadata.packagePath));
+
+        const appendMetaXml = this.shouldAppendMetaXml(metadata.packagePath, metadataContent);        
+        const expandedName = appendMetaXml ? `${basename}-meta.xml` : basename;
+
+        expandedMetadata[expandedName] = metadataContent;
+        
+        return expandedMetadata;
+    }
+
+    public async saveExpandedMetadata(metadata: MetadataFile, destinationPath: string, options?: { outputFile?: OutputFile }): Promise<void> {
+        const expandedMetadata = await this.expandMetadata(metadata);
+        for (const [fileName, content] of Object.entries(expandedMetadata)) {
+            const filePath = path.join(destinationPath, fileName);
+            (options?.outputFile ?? outputFile)(filePath, content)
+        }
+    }
+
+    private shouldAppendMetaXml(fileName: string, body: Buffer) {
+        if (fileName.endsWith('.xml')) {
+            return false;
+        }
+        // Check if the body starts with XML declaration
+        const bodyString = body.toString('utf8', 0, Math.min(100, body.length));
+        return bodyString.includes('<?xml');
+    }
+}
diff --git a/packages/salesforce/src/deploy/retrieveResultPackage.ts b/packages/salesforce/src/deploy/retrieveResultPackage.ts
@@ -2,10 +2,11 @@
 import * as path from 'path';
 import * as fs from 'fs-extra';
 import ZipArchive from 'jszip';
-import { directoryName, fileName as baseName , groupBy } from '@vlocode/util';
+import { groupBy } from '@vlocode/util';
 import { FileProperties, RetrieveResult } from '../connection';
 import { PackageManifest } from './maifest';
 import { SalesforcePackageComponentFile } from './package';
+import { MetadataExpander } from './metadataExpander';
 
 /**
  * Extends typings on the JSZipObject with internal _data object
@@ -93,12 +94,6 @@ export class RetrieveResultFile implements SalesforceRetrievedComponentFile {
      */
     public readonly archivePath: string;
 
-    /**
-     * If this file has an associated metadata XML file this is path to that file. 
-     * Undefined if no meta file exists that matches the source file.
-     */
-    public readonly metaFilePath?: string;
-
     /**
      * Uncompressed size of the file in bytes.
      */
@@ -120,6 +115,32 @@ export class RetrieveResultFile implements SalesforceRetrievedComponentFile {
         return this.file?._data?.crc32
     }
 
+    /**
+     * Gets the base name of the archive file path, excluding any directory components.
+     * 
+     * @returns The file name portion of the archive path.
+     */
+    public get fileName() {
+        return path.basename(this.archivePath);
+    }
+
+    /**
+     * Gets the relative path of the archive file.
+     * 
+     * @returns The directory name of the archive path specified by `this.archivePath`.
+     */
+    public get folderName() {
+        return path.dirname(this.archivePath);
+    }
+
+    /**
+     * Gets the full path of the file in the zip archive.
+     * @see {@link archivePath}
+     */
+    public get fullPath() {
+        return this.archivePath
+    }
+
     constructor(
         properties: FileProperties,
         private readonly file?: ZipArchive.JSZipObject)
@@ -131,25 +152,25 @@ export class RetrieveResultFile implements SalesforceRetrievedComponentFile {
     }
 
     /**
-     * Extracts the file to the target folder and optionally the meta file.
-     * @param {string} targetFolder Target folder to extract the file to.
-     * @param {object} [options] Additional options.
-     * @param {boolean} [options.fileOnly] If true only the file will be extracted, otherwise the full path will be used.
-     * @returns 
+     * Extracts and writes expanded metadata files to the specified target folder.
+     *
+     * This method uses the `MetadataExpander` to expand the current metadata object,
+     * then writes each expanded file to the given target directory. The method returns
+     * a list of the relative file paths that were written.
+     *
+     * @param targetFolder - The absolute or relative path to the folder where the expanded files will be written.
+     * @returns A promise that resolves to an array of file paths representing the files that were written.
      */
-    public writeFile(targetFolder: string, options?: { fileOnly?: boolean }): Promise<void> {
-        const targetPath = path.join(targetFolder,
-            options?.fileOnly 
-                ? path.basename(this.packagePath) 
-                : this.packagePath
-        );
-        return new Promise((resolve, reject) => {
-            fs.ensureDir(path.dirname(targetPath)).then(() => {
-                this.getFile().nodeStream().pipe(fs.createWriteStream(targetPath, { flags: 'w' }))
-                    .on('finish', () => resolve())
-                    .on('error', reject);
-            }).catch(reject);
-        });
+    public async extractTo(targetFolder: string) {
+        const expander = new MetadataExpander();
+        const result = await expander.expandMetadata(this);
+        const filesWritten: string[] = []
+        for (const [expandedFile, data] of Object.entries(result)) {
+            const expandedFilePath = path.join(targetFolder, expandedFile);
+            await fs.outputFile(expandedFilePath, data);
+            filesWritten.push(expandedFilePath);
+        }
+        return filesWritten;
     }
 
     /**
@@ -168,6 +189,15 @@ export class RetrieveResultFile implements SalesforceRetrievedComponentFile {
         return this.getFile().nodeStream();
     }
 
+    /**
+     * Reads and returns the contents as a Buffer.
+     * 
+     * @returns A promise that resolves to a Buffer containing the data.
+     */
+    public read(): Promise<Buffer> {
+        return this.getBuffer();
+    }
+
     private getFile() {
         const file = this.file;
         if (!file) {
@@ -270,7 +300,7 @@ export class RetrieveResultPackage {
      * Gets all files in the retrieve result package.
      * @returns A list of all files in the retrieve result package.
      */
-    public getFiles(): Array<RetrieveResultFile> {
+    public getFiles(predicate?: (file: RetrieveResultFile, index: number) => boolean): Array<RetrieveResultFile> {
         if (this.files) {
             return this.files;
         }
@@ -299,7 +329,7 @@ export class RetrieveResultPackage {
                 return files;
             }
         );
-        return this.files;
+        return predicate ? this.files.filter(predicate) : this.files;
     }
 
     /**
@@ -317,31 +347,40 @@ export class RetrieveResultPackage {
         return manifests.reduce((manifest, current) => manifest.merge(current));
     }
 
-    public async unpackFolder(packageFolder: string, targetPath: string) : Promise<void> {
-        const files = this.filterFiles(file => directoryName(file).endsWith(packageFolder.toLowerCase()));
-        if (!files) {
-            throw new Error(`The specified folder ${packageFolder} was not found in retrieved package or is empty`);
-        }
-        for (const file of files) {
-            await this.streamFileToDisk(file, path.join(targetPath, baseName(file.name)));
-        }
-    }
-
-    public unpackFile(packageFile: string, targetPath: string) : Promise<void> {
-        const file = this.file(file => file.toLowerCase().endsWith(packageFile.toLowerCase()));
-        if (!file) {
-            throw new Error(`The specified file ${packageFile} was not found in retrieved package`);
-        }
-        return this.streamFileToDisk(file, targetPath);
-    }
-
-    public unpackFileToFolder(packageFile: string, targetPath: string) : Promise<void> {
-        const file = this.file(file => file.toLowerCase().endsWith(packageFile.toLowerCase()));
-        if (!file) {
-            throw new Error(`The specified file ${packageFile} was not found in retrieved package`);
-        }
-        return this.streamFileToDisk(file, path.join(targetPath, baseName(file.name)));
-    }
+    // /**
+    //  * @deprecated Use {@link RetrieveResultFile.extractTo} instead.
+    //  */
+    // public async unpackFolder(packageFolder: string, targetPath: string) : Promise<void> {
+    //     const files = await this.getFiles(file => file.folderName.endsWith(packageFolder.toLowerCase()));
+    //     if (!files) {
+    //         throw new Error(`The specified folder ${packageFolder} was not found in retrieved package or is empty`);
+    //     }
+    //     for (const file of files) {
+    //         await file.extractTo(targetPath);
+    //     }
+    // }
+
+    // /**
+    //  * @deprecated Use {@link RetrieveResultFile.extractTo} instead.
+    //  */
+    // public unpackFile(packageFile: string, targetPath: string) : Promise<void> {
+    //     const file = this.file(file => file.toLowerCase().endsWith(packageFile.toLowerCase()));
+    //     if (!file) {
+    //         throw new Error(`The specified file ${packageFile} was not found in retrieved package`);
+    //     }
+    //     return this.streamFileToDisk(file, targetPath);
+    // }
+
+    // /**
+    //  * @deprecated Use {@link RetrieveResultFile.extractTo} instead.
+    //  */
+    // public unpackFileToFolder(packageFile: string, targetPath: string) : Promise<void> {
+    //     const file = this.file(file => file.toLowerCase().endsWith(packageFile.toLowerCase()));
+    //     if (!file) {
+    //         throw new Error(`The specified file ${packageFile} was not found in retrieved package`);
+    //     }
+    //     return this.streamFileToDisk(file, path.join(targetPath, baseName(file.name)));
+    // }
 
     private file(filter: string | ((file: string) => any)) : ZipArchive.JSZipObject | undefined {
         for (const archive of this.archives ?? []) {
@@ -354,7 +393,7 @@ export class RetrieveResultPackage {
         }
     }
 
-    private filterFiles(filter: (file: string) => any) : Array<ZipArchive.JSZipObject> {
+    private filterFiles(filter: (file: string) => any) {
         const files = new Array<ZipArchive.JSZipObject>();
         for (const archive of this.archives ?? []) {
             files.push(...archive.filter(filter));
diff --git a/packages/salesforce/src/metadataRegistry.ts b/packages/salesforce/src/metadataRegistry.ts
@@ -27,6 +27,11 @@ export interface MetadataType extends RegistryMetadataType {
      * Array with the list of child XML fragments that match this metadata type
      */
     childXmlNames: string[];
+    /**
+     * Human readable label for the metadata type, used in UI and commands
+     * This is derived from the name of the metadata type and formatted to be more readable.
+     */
+    label: string;
 }
 
 @singletonMixin
@@ -44,6 +49,7 @@ export class MetadataRegistry {
             const metadataObject = registryEntry as MetadataType;
 
             metadataObject.xmlName = metadataObject.name;
+            metadataObject.label = this.formatLabel(metadataObject.name);
             metadataObject.childXmlNames = Object.values(metadataObject.children?.types ?? []).map(({ name }) => name);
             metadataObject.isBundle = metadataObject.strategies?.adapter == 'bundle' ||  metadataObject.name.endsWith('Bundle');
             metadataObject.hasContent = metadataObject.strategies?.adapter == 'matchingContentFile' ||
@@ -73,6 +79,28 @@ export class MetadataRegistry {
         }
     }
 
+    /**
+     * Converts a camelCase or PascalCase string to a proper label format
+     * @param name The name to format
+     * @returns The formatted label
+     */
+    private formatLabel(name: string): string {
+        if (!name) {
+            return '';
+        }
+
+        // Insert spaces before uppercase letters (except the first one)
+        // Handle sequences of uppercase letters properly (e.g., "XMLParser" -> "XML Parser")
+        const result = name
+            .replace(/([a-z])([A-Z])/g, '$1 $2') // Insert space between lowercase and uppercase
+            .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2') // Insert space between uppercase sequences and following lowercase
+            .replace(/([0-9])([A-Z])/g, '$1 $2') // Insert space between numbers and uppercase letters
+            .replace(/([a-zA-Z])([0-9])/g, '$1 $2'); // Insert space between letters and numbers
+
+        // Capitalize first letter and return
+        return result.charAt(0).toUpperCase() + result.slice(1);
+    }
+
     public getUrlFormat(type: string) {
         return { ...urlFormats.$default, ...(urlFormats[type] ?? {}) };
     }
diff --git a/packages/vscode-extension/src/commands/metadata/refreshMetadataCommand.ts b/packages/vscode-extension/src/commands/metadata/refreshMetadataCommand.ts
@@ -69,7 +69,7 @@ export default class RefreshMetadataCommand extends MetadataCommand {
 
                 // Extract each file into the appropriate source folder
                 for (const file of component.files) {
-                    await file.writeFile(sourceFolder);
+                    await file.extractTo(sourceFolder);
                 }
             }
 
diff --git a/packages/vscode-extension/src/commands/metadata/retrieveMetadataCommand.ts b/packages/vscode-extension/src/commands/metadata/retrieveMetadataCommand.ts
@@ -13,10 +13,10 @@ import { VlocodeCommand } from '../../constants';
 export default class RetrieveMetadataCommand extends MetadataCommand {
 
     public async execute() : Promise<void>  {
-        return this.exportWizard();
+        return this.retrieve();
     }
 
-    protected async exportWizard() : Promise<void>  {
+    protected async retrieve() : Promise<void>  {
         const metadataType = await this.showMetadataTypeSelection();
         if (!metadataType) {
             return; // selection cancelled;
@@ -71,8 +71,8 @@ export default class RetrieveMetadataCommand extends MetadataCommand {
     protected async showMetadataTypeSelection() : Promise<MetadataType | undefined> {
         const metadataTypes = this.salesforce.getMetadataTypes()
             .map(type => ({
-                label: type.xmlName,
-                description: type.xmlName,
+                label: type.label,
+                description: type.name,
                 type: type
             })).sort((a,b) => a.label.localeCompare(b.label));
 
@@ -129,31 +129,42 @@ export default class RetrieveMetadataCommand extends MetadataCommand {
                 void vscode.window.showWarningMessage('Decomposing metadata into SFDX format is currently not supported.');
             }
 
-            const unpackedFiles = new Array<string>();
+            const retrievedMetadata = new Array<{
+                    type: string;
+                    path: string;
+                }>();
+            const outputPaths = new Array<string>();
+                
             for (const file of result.getFiles()) {
                 try {
-                    const unpackTarget = path.join(vscode.workspace.workspaceFolders?.[0].uri.fsPath ?? '.', this.vlocode.config.salesforce.exportFolder);
-                    await file.writeFile(unpackTarget);
-                    this.logger.log(`Exported ${file.archivePath}`);
-                    unpackedFiles.push(path.join(unpackTarget, file.archivePath));
+                    const unpackTarget = path.join(
+                        vscode.workspace.workspaceFolders?.[0].uri.fsPath ?? '.', 
+                        this.vlocode.config.salesforce.exportFolder
+                    );
+                    const writtenFiles = await file.extractTo(path.join(unpackTarget, file.folderName));
+                    outputPaths.push(...writtenFiles);
+                    retrievedMetadata.push(
+                        ...writtenFiles.map(outputFile => ({
+                            type: file.componentType,
+                            path: path.relative(unpackTarget, outputFile)
+                        }))
+                    );
                 } catch(err) {
                     this.logger.error(`${file.componentName} -- ${err.message || err}`);
                 }
             }
 
-            const successMessage = `Successfully retrieved ${unpackedFiles.length} components`;
-            if (unpackedFiles.length == 1) {
-                void vscode.window.showInformationMessage(successMessage, 'Open')
-                    .then(value => value ? void vscode.window.showTextDocument(vscode.Uri.file(unpackedFiles[0])) : undefined);
-            } else {
-                void vscode.window.showInformationMessage(successMessage);
-            }
+            const successMessage = `Successfully retrieved ${outputPaths.length} components`;
+            void vscode.window.showInformationMessage(successMessage, 'Open')
+                .then(value => value ? void vscode.window.showTextDocument(vscode.Uri.file(outputPaths[0])) : undefined);
+
+            this.output.table(retrievedMetadata, { appendEmptyLine: true, focus: true });
         });
     }
 
     protected async showComponentSelection<T extends FileProperties>(records: T[]) : Promise<Array<T> | undefined> {
         const objectOptions =  records.map(record => ({
-            label: record.fullName,
+            label: decodeURIComponent(record.fullName),
             description: `last modified: ${record.lastModifiedByName} (${record.lastModifiedDate})`,
             record
         })).sort((a, b) => a.label.localeCompare(b.label));

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ export default class RefreshMetadataCommand extends MetadataCommand {`
`69`	`69`
`70`	`70`	`// Extract each file into the appropriate source folder`
`71`	`71`	`for (const file of component.files) {`
`72`		`- await file.writeFile(sourceFolder);`
	`72`	`+ await file.extractTo(sourceFolder);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`