feat: update hash computation for web_app files @W-20287706

- Add computeWebAppHashedName function with SHA256 hash generation
- Implement correct content type detection (image/asset/manifest)
- Use posix paths for cross-platform compatibility
- Update deploy and retrieve responses with hashed fullNames
- Fix webapp.json classification as webApplicationManifest
- Match server-side naming convention exactly

Author: pyelchurisf

src/client/deployMessages.ts

@@ -17,9 +17,11 @@
 import { basename, dirname, extname, join, posix, sep } from 'node:path';
 import { SfError } from '@salesforce/core/sfError';
 import { ensureArray } from '@salesforce/kit';
-import { SourceComponentWithContent, SourceComponent } from '../resolve/sourceComponent';
+import { computeWebAppHashedName } from '../resolve/adapters/digitalExperienceSourceAdapter';
+import { SourceComponent } from '../resolve/sourceComponent';
 import { ComponentLike } from '../resolve';
 import { registry } from '../registry/registry';
+import { isWebAppBundle } from './utils';
 import {
   BooleanString,
   ComponentStatus,
@@ -30,7 +32,6 @@ import {
   MetadataApiDeployStatus,
 } from './types';
 import { parseDeployDiagnostic } from './diagnosticUtil';
-import { isWebAppBundle } from './utils';
 
 type DeployMessageWithComponentType = DeployMessage & { componentType: string };
 /**
@@ -101,7 +102,7 @@ export const createResponses =
                 filePath: component.content,
               },
               ...component.walkContent().map((filePath) => ({
-                fullName: getWebAppBundleContentFullName(component)(filePath),
+                fullName: computeWebAppHashedName(filePath, component.content),
                 type: 'DigitalExperience',
                 state,
                 filePath,
@@ -124,16 +125,6 @@ export const createResponses =
       })) satisfies FileResponseSuccess[];
     });
 
-const getWebAppBundleContentFullName =
-  (component: SourceComponentWithContent) =>
-  (filePath: string): string => {
-    // Normalize paths to ensure relative() works correctly on Windows
-    const normalizedContent = component.content.split(sep).join(posix.sep);
-    const normalizedFilePath = filePath.split(sep).join(posix.sep);
-    const relPath = posix.relative(normalizedContent, normalizedFilePath);
-    return posix.join(component.fullName, relPath);
-  };
-
 /**
  * Groups messages from the deploy result by component fullName and type
  */

src/client/metadataApiRetrieve.ts

@@ -23,6 +23,7 @@ import { Lifecycle } from '@salesforce/core/lifecycle';
 import { ensureArray } from '@salesforce/kit';
 import { RegistryAccess } from '../registry/registryAccess';
 import { ComponentSet } from '../collections/componentSet';
+import { computeWebAppHashedName } from '../resolve/adapters/digitalExperienceSourceAdapter';
 import { MetadataTransfer } from './metadataTransfer';
 import {
   AsyncResult,
@@ -102,21 +103,24 @@ export class RetrieveResult implements MetadataTransferResult {
 
     // construct successes
     for (const retrievedComponent of this.components.getSourceComponents()) {
-      const { fullName, type, xml } = retrievedComponent;
+      const { fullName, type, xml, content } = retrievedComponent;
       const baseResponse = {
         fullName,
         type: type.name,
         state: this.localComponents.has(retrievedComponent) ? ComponentStatus.Changed : ComponentStatus.Created,
       } as const;
 
-      // Special handling for web_app bundles - they need to walk content and report individual files
       if (isWebAppBundle(retrievedComponent)) {
-        // Add the bundle directory itself
-        this.fileResponses.push(
-          ...[retrievedComponent.content, ...retrievedComponent.walkContent()].map(
-            (filePath) => ({ ...baseResponse, filePath } satisfies FileResponseSuccess)
-          )
-        );
+        this.fileResponses.push({ ...baseResponse, filePath: content! } satisfies FileResponseSuccess);
+        for (const filePath of retrievedComponent.walkContent()) {
+          const hashedFullName = computeWebAppHashedName(filePath, content!);
+          this.fileResponses.push({
+            fullName: hashedFullName,
+            type: 'DigitalExperience',
+            state: this.localComponents.has(retrievedComponent) ? ComponentStatus.Changed : ComponentStatus.Created,
+            filePath,
+          } satisfies FileResponseSuccess);
+        }
       } else if (!type.children || Object.values(type.children.types).some((t) => t.unaddressableWithoutParent)) {
         this.fileResponses.push(
           ...retrievedComponent

src/resolve/adapters/digitalExperienceSourceAdapter.ts

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { dirname, join, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+import { basename, dirname, extname, join, posix, sep } from 'node:path';
 import { Messages } from '@salesforce/core/messages';
 import { ensureString } from '@salesforce/ts-types';
 import { META_XML_SUFFIX } from '../../common/constants';
@@ -86,13 +87,15 @@ const WEB_APP_BASE_TYPE = 'web_app';
  */
 export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
   public getComponent(path: SourcePath, isResolvingSource = true): SourceComponent | undefined {
+    // Handle web_app bundle directory
     if (this.isBundleType() && isWebAppBaseType(path) && this.tree.isDirectory(path)) {
       const pathParts = path.split(sep);
       const bundleNameIndex = getDigitalExperiencesIndex(path) + 2;
       if (bundleNameIndex === pathParts.length - 1) {
         return this.populate(path, undefined);
       }
     }
+    
     return super.getComponent(path, isResolvingSource);
   }
 
@@ -146,7 +149,7 @@ export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
     return pathToContent;
   }
 
-  protected populate(trigger: string, component?: SourceComponent): SourceComponent {
+  protected populate(trigger: string, component?: SourceComponent): SourceComponent | undefined {
     if (this.isBundleType() && component) {
       // for top level types we don't need to resolve parent
       return component;
@@ -305,3 +308,50 @@ const getWebAppBundleDir = (path: string): string => {
   }
   return path;
 };
+
+/**
+ * Determines the content type for web_app bundle files based on file extension and name.
+ * Matches server-side FileType classification logic.
+ */
+const getContentTypeFromExtension = (filePath: string): string => {
+  const ext = extname(filePath).toLowerCase();
+  const fileName = basename(filePath).toLowerCase();
+  
+  // Image types: BMP, GIF, PNG, JPG, JPEG
+  const imageExtensions = ['.bmp', '.gif', '.png', '.jpg', '.jpeg'];
+  if (imageExtensions.includes(ext)) {
+    return 'sfdc_cms__image';
+  }
+  
+  // Special case: webapp.json is a manifest file
+  if (ext === '.json' && fileName === 'webapp.json') {
+    return 'sfdc_cms__webApplicationManifest';
+  }
+  
+  return 'sfdc_cms__webApplicationAsset';
+};
+
+/**
+ * Computes the hashed fullName for a web_app bundle file.
+ * Format: baseType/spaceApiName.contentType/mHash
+ * 
+ * @param filePath - Full file system path to the file
+ * @param bundleDir - Bundle directory path
+ * @returns Hashed fullName matching server-side naming convention
+ */
+export const computeWebAppHashedName = (filePath: string, bundleDir: string): string => {
+  const pathParts = filePath.split(sep);
+  const bundleParts = bundleDir.split(sep);
+  const digitalExperiencesIndex = bundleParts.indexOf('digitalExperiences');
+  
+  const baseType = bundleParts[digitalExperiencesIndex + 1];
+  const spaceApiName = bundleParts[digitalExperiencesIndex + 2];
+  const baseTypeIndex = digitalExperiencesIndex + 1;
+  
+  // Build full path with forward slashes for cross-platform consistency
+  const fullPath = pathParts.slice(baseTypeIndex).join(posix.sep);
+  const hash = createHash('sha256').update(fullPath, 'utf8').digest('hex').substring(0, 39);
+  const contentType = getContentTypeFromExtension(filePath);
+  
+  return `${baseType}${posix.sep}${spaceApiName}.${contentType}${posix.sep}m${hash}`;
+};

test/resolve/adapters/digitalExperienceSourceAdapter.test.ts

@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { assert, expect } from 'chai';
 import { RegistryAccess, registry, VirtualTreeContainer, ForceIgnore, SourceComponent } from '../../../src';
-import { DigitalExperienceSourceAdapter } from '../../../src/resolve/adapters/digitalExperienceSourceAdapter';
+import {
+  DigitalExperienceSourceAdapter,
+  computeWebAppHashedName,
+} from '../../../src/resolve/adapters/digitalExperienceSourceAdapter';
 import { META_XML_SUFFIX } from '../../../src/common';
 import { DE_METAFILE } from '../../mock/type-constants/digitalExperienceBundleConstants';
 
@@ -214,4 +218,129 @@ describe('DigitalExperienceSourceAdapter', () => {
       expect(component?.content).to.equal(WEBAPP_BUNDLE_PATH);
     });
   });
+
+  describe('computeWebAppHashedName', () => {
+    it('should compute hash for nested file', () => {
+      const filePath = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'assets', 'icon.png');
+      const bundleDir = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2');
+      const hashedName = computeWebAppHashedName(filePath, bundleDir);
+
+      // Verify format: web_app/dist2.sfdc_cms__image/m<hash>
+      expect(hashedName).to.match(/^web_app\/dist2\.sfdc_cms__image\/m[0-9a-f]{39}$/);
+
+      // Verify the hash is computed from the FULL path: 'web_app/dist2/assets/icon.png'
+      const expectedHash = createHash('sha256').update('web_app/dist2/assets/icon.png', 'utf8').digest('hex').substring(0, 39);
+      expect(hashedName).to.equal(`web_app/dist2.sfdc_cms__image/m${expectedHash}`);
+    });
+
+    it('should compute hash for root-level file', () => {
+      const filePath = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', '404.html');
+      const bundleDir = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2');
+      const hashedName = computeWebAppHashedName(filePath, bundleDir);
+
+      // Verify format: web_app/dist2.sfdc_cms__webApplicationAsset/m<hash>
+      expect(hashedName).to.match(/^web_app\/dist2\.sfdc_cms__webApplicationAsset\/m[0-9a-f]{39}$/);
+
+      // Verify the hash is computed from the FULL path: 'web_app/dist2/404.html'
+      const expectedHash = createHash('sha256').update('web_app/dist2/404.html', 'utf8').digest('hex').substring(0, 39);
+      expect(hashedName).to.equal(`web_app/dist2.sfdc_cms__webApplicationAsset/m${expectedHash}`);
+    });
+
+    it('should use correct content type for images (BMP, GIF, PNG, JPG, JPEG only)', () => {
+      const pngFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'icon.png');
+      const jpgFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'photo.jpg');
+      const gifFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'animation.gif');
+      const bmpFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'image.bmp');
+      const bundleDir = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2');
+
+      expect(computeWebAppHashedName(pngFile, bundleDir)).to.include('sfdc_cms__image');
+      expect(computeWebAppHashedName(jpgFile, bundleDir)).to.include('sfdc_cms__image');
+      expect(computeWebAppHashedName(gifFile, bundleDir)).to.include('sfdc_cms__image');
+      expect(computeWebAppHashedName(bmpFile, bundleDir)).to.include('sfdc_cms__image');
+    });
+
+    it('should use correct content type for web assets (including SVG, WebP, ICO)', () => {
+      const jsFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'main.js');
+      const cssFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'styles.css');
+      const htmlFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'index.html');
+      const jsonFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'data.json');
+      const svgFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'icon.svg');
+      const webpFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'photo.webp');
+      const icoFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'favicon.ico');
+      const bundleDir = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2');
+
+      expect(computeWebAppHashedName(jsFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+      expect(computeWebAppHashedName(cssFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+      expect(computeWebAppHashedName(htmlFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+      expect(computeWebAppHashedName(jsonFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+      expect(computeWebAppHashedName(svgFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+      expect(computeWebAppHashedName(webpFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+      expect(computeWebAppHashedName(icoFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+    });
+
+    it('should use correct content type for webapp.json only', () => {
+      const webappFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'webapp.json');
+      const manifestFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'manifest.json');
+      const bundleDir = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2');
+
+      // webapp.json is special
+      expect(computeWebAppHashedName(webappFile, bundleDir)).to.include('sfdc_cms__webApplicationManifest');
+      
+      // manifest.json is treated as regular web asset
+      expect(computeWebAppHashedName(manifestFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+    });
+
+    it('should use correct content type for manifest.json', () => {
+      const manifestFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'manifest.json');
+      const otherJsonFile = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2', 'config.json');
+      const bundleDir = join('path', 'to', 'digitalExperiences', 'web_app', 'dist2');
+
+      expect(computeWebAppHashedName(manifestFile, bundleDir)).to.include('sfdc_cms__webApplicationManifest');
+      expect(computeWebAppHashedName(otherJsonFile, bundleDir)).to.include('sfdc_cms__webApplicationAsset');
+    });
+  });
+
+  describe('DigitalExperienceSourceAdapter for web_app child files', () => {
+    const WEBAPP_BUNDLE_PATH = join(BASE_PATH, 'web_app', 'dist2');
+    const WEBAPP_ICON_FILE = join(WEBAPP_BUNDLE_PATH, 'assets', 'icon.png');
+    const WEBAPP_404_FILE = join(WEBAPP_BUNDLE_PATH, '404.html');
+
+    const webappTree = VirtualTreeContainer.fromFilePaths([WEBAPP_ICON_FILE, WEBAPP_404_FILE]);
+
+    assert(registry.types.digitalexperiencebundle.children?.types.digitalexperience);
+    const webappChildAdapter = new DigitalExperienceSourceAdapter(
+      registry.types.digitalexperiencebundle.children.types.digitalexperience,
+      registryAccess,
+      forceIgnore,
+      webappTree
+    );
+
+    it('should create child component with hashed name for nested file', () => {
+      const component = webappChildAdapter.getComponent(WEBAPP_ICON_FILE);
+      expect(component).to.not.be.undefined;
+      expect(component?.type.name).to.equal('DigitalExperience');
+
+      // Verify hashed name format - hash is computed from FULL path 'web_app/dist2/assets/icon.png'
+      const expectedHash = createHash('sha256').update('web_app/dist2/assets/icon.png', 'utf8').digest('hex').substring(0, 39);
+      expect(component?.fullName).to.equal(`web_app/dist2.sfdc_cms__image/m${expectedHash}`);
+
+      // Verify parent
+      expect(component?.parent?.type.name).to.equal('DigitalExperienceBundle');
+      expect(component?.parent?.fullName).to.equal('web_app/dist2');
+    });
+
+    it('should create child component with hashed name for root file', () => {
+      const component = webappChildAdapter.getComponent(WEBAPP_404_FILE);
+      expect(component).to.not.be.undefined;
+      expect(component?.type.name).to.equal('DigitalExperience');
+
+      // Verify hashed name format - hash is computed from FULL path 'web_app/dist2/404.html'
+      const expectedHash = createHash('sha256').update('web_app/dist2/404.html', 'utf8').digest('hex').substring(0, 39);
+      expect(component?.fullName).to.equal(`web_app/dist2.sfdc_cms__webApplicationAsset/m${expectedHash}`);
+
+      // Verify parent
+      expect(component?.parent?.type.name).to.equal('DigitalExperienceBundle');
+      expect(component?.parent?.fullName).to.equal('web_app/dist2');
+    });
+  });
 });