feat: Support web app bundle @W-20091482

Author: pyelchurisf

src/client/deployMessages.ts

@@ -87,6 +87,30 @@ export const createResponses = (component: SourceComponent, responseMessages: De
     if (state === ComponentStatus.Failed) {
       return [{ ...base, state, ...parseDeployDiagnostic(component, message) } satisfies FileResponseFailure];
     } else {
+      const isWebAppBundle = component.type.name === 'DigitalExperienceBundle' && 
+                             component.fullName.startsWith('web_app/') &&
+                             component.content;
+      
+      if (isWebAppBundle) {
+        const walkedPaths = component.walkContent();
+        const bundleResponse: FileResponseSuccess = {
+          fullName: component.fullName,
+          type: component.type.name,
+          state,
+          filePath: component.content!,
+        };
+        const fileResponses: FileResponseSuccess[] = walkedPaths.map((filePath) => {
+          const relPath = filePath.replace(component.content! + '/', '');
+          return {
+            fullName: `${component.fullName}/${relPath}`,
+            type: 'DigitalExperience',
+            state,
+            filePath,
+          };
+        });
+        return [bundleResponse, ...fileResponses];
+      }
+      
       return [
         ...(shouldWalkContent(component)
           ? component.walkContent().map((filePath): FileResponseSuccess => ({ ...base, state, filePath }))

src/resolve/adapters/digitalExperienceSourceAdapter.ts

@@ -25,6 +25,10 @@ import { BundleSourceAdapter } from './bundleSourceAdapter';
 
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@salesforce/source-deploy-retrieve', 'sdr');
+
+// Constants for DigitalExperience base types
+const WEB_APP_BASE_TYPE = 'web_app';
+
 /**
  * Source Adapter for DigitalExperience metadata types. This metadata type is a bundled type of the format
  *
@@ -58,18 +62,57 @@ const messages = Messages.loadMessages('@salesforce/source-deploy-retrieve', 'sd
  * content/
  * ├── bars/
  * |   ├── bars.digitalExperience-meta.xml
+ * web_app/
+ * ├── zenith/
+ * |   ├── css/
+ * |   |   ├── header/
+ * |   |   |   ├── header.css
+ * |   |   ├── home.css
+ * |   ├── js/
+ * |   |   ├── home.js
+ * |   ├── html/
+ * |   |   ├── home.html
+ * |   ├── images/
+ * |   |   ├── logos/
+ * |   |   |   ├── logo.png
  * ```
  *
  * In the above structure the metadata xml file ending with "digitalExperience-meta.xml" belongs to DigitalExperienceBundle MD type.
  * The "_meta.json" files are child metadata files of DigitalExperienceBundle belonging to DigitalExperience MD type. The rest of the files in the
  * corresponding folder are the contents to the DigitalExperience metadata. So, incase of DigitalExperience the metadata file is a JSON file
- * and not an XML file
+ * and not an XML file.
+ *
+ * For web_app base type, the bundle is identified by directory structure alone without metadata XML files.
  */
 export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
+  public getComponent(path: SourcePath, isResolvingSource = true): SourceComponent | undefined {
+    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);
+  }
+
+  protected parseAsRootMetadataXml(path: string): MetadataXml | undefined {
+    if (isWebAppBaseType(path)) {
+      return undefined;
+    }
+    if (!this.isBundleType() && !path.endsWith(this.type.metaFileSuffix ?? '_meta.json')) {
+      return undefined;
+    }
+    return super.parseAsRootMetadataXml(path);
+  }
+
   protected getRootMetadataXmlPath(trigger: string): string {
     if (this.isBundleType()) {
       return this.getBundleMetadataXmlPath(trigger);
     }
+    if (isWebAppBaseType(trigger)) {
+      return '';
+    }
     // metafile name = metaFileSuffix for DigitalExperience.
     if (!this.type.metaFileSuffix) {
       throw messages.createError('missingMetaFileSuffix', [this.type.name]);
@@ -81,6 +124,9 @@ export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
     if (this.isBundleType()) {
       return path;
     }
+    if (isWebAppBaseType(path)) {
+      return path;
+    }
     const pathToContent = dirname(path);
     const parts = pathToContent.split(sep);
     /* Handle mobile or tablet variants.Eg- digitalExperiences/site/lwr11/sfdc_cms__view/home/mobile/mobile.json
@@ -104,6 +150,9 @@ export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
       // for top level types we don't need to resolve parent
       return component;
     }
+    if (isWebAppBaseType(trigger)) {
+      return this.populateWebAppBundle(trigger, component);
+    }
     const source = super.populate(trigger, component);
     const parentType = this.registry.getParentType(this.type.id);
     // we expect source, parentType and content to be defined.
@@ -142,9 +191,45 @@ export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
         path: xml.path,
       };
     }
+    if (xml && isWebAppBaseType(path)) {
+      return {
+        fullName: this.getBundleName(path),
+        suffix: xml.suffix,
+        path: xml.path,
+      };
+    }
+  }
+
+  private populateWebAppBundle(trigger: string, component?: SourceComponent): SourceComponent {
+    if (component) {
+      return component;
+    }
+    const bundleName = this.getBundleName(trigger);
+    const pathParts = trigger.split(sep);
+    const bundleDir = pathParts.slice(0, getDigitalExperiencesIndex(trigger) + 3).join(sep);
+    const parentType = this.isBundleType() ? this.type : this.registry.getParentType(this.type.id);
+    if (!parentType) {
+      throw messages.createError('error_failed_convert', [bundleName]);
+    }
+    return new SourceComponent(
+      {
+        name: bundleName,
+        type: parentType,
+        content: bundleDir,
+      },
+      this.tree,
+      this.forceIgnore
+    );
   }
 
   private getBundleName(contentPath: string): string {
+    if (isWebAppBaseType(contentPath)) {
+      const pathParts = contentPath.split(sep);
+      const digitalExperiencesIndex = getDigitalExperiencesIndex(contentPath);
+      const baseType = pathParts[digitalExperiencesIndex + 1];
+      const spaceApiName = pathParts[digitalExperiencesIndex + 2];
+      return `${baseType}/${spaceApiName}`;
+    }
     const bundlePath = this.getBundleMetadataXmlPath(contentPath);
     return `${parentName(dirname(bundlePath))}/${parentName(bundlePath)}`;
   }
@@ -154,6 +239,9 @@ export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
       // if this is the bundle type and it ends with -meta.xml, then this is the bundle metadata xml path
       return path;
     }
+    if (isWebAppBaseType(path)) {
+      return '';
+    }
     const pathParts = path.split(sep);
     const typeFolderIndex = pathParts.lastIndexOf(this.type.directoryName);
     // 3 because we want 'digitalExperiences' directory, 'baseType' directory and 'bundleName' directory
@@ -177,3 +265,28 @@ export class DigitalExperienceSourceAdapter extends BundleSourceAdapter {
 const calculateNameFromPath = (contentPath: string): string => `${parentName(contentPath)}/${baseName(contentPath)}`;
 const digitalExperienceStructure = join('BaseType', 'SpaceApiName', 'ContentType', 'ContentApiName');
 const contentParts = digitalExperienceStructure.split(sep);
+
+/**
+ * Checks if the given path belongs to the web_app base type.
+ * web_app base type has a simpler structure without ContentType folders.
+ * Structure: digitalExperiences/web_app/spaceApiName/...files...
+ */
+const isWebAppBaseType = (path: string): boolean => {
+  const pathParts = path.split(sep);
+  const digitalExperiencesIndex = pathParts.indexOf('digitalExperiences');
+  // Check if the base type (folder after digitalExperiences) is WEB_APP_BASE_TYPE
+  return (
+    digitalExperiencesIndex > -1 &&
+    pathParts.length > digitalExperiencesIndex + 1 &&
+    pathParts[digitalExperiencesIndex + 1] === WEB_APP_BASE_TYPE
+  );
+};
+
+/**
+ * Gets the digitalExperiences index from a path.
+ * Returns -1 if not found.
+ */
+const getDigitalExperiencesIndex = (path: string): number => {
+  const pathParts = path.split(sep);
+  return pathParts.indexOf('digitalExperiences');
+};

src/resolve/metadataResolver.ts

@@ -31,6 +31,20 @@ import { NodeFSTreeContainer, TreeContainer } from './treeContainers';
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@salesforce/source-deploy-retrieve', 'sdr');
 
+/**
+ * Checks if the given path is a web_app bundle directory.
+ * web_app bundles don't have metadata XML files and are identified by directory structure.
+ */
+const isWebAppBundlePath = (path: string): boolean => {
+  const pathParts = path.split(sep);
+  const digitalExperiencesIndex = pathParts.indexOf('digitalExperiences');
+  return (
+    digitalExperiencesIndex > -1 &&
+    pathParts.length > digitalExperiencesIndex + 2 &&
+    pathParts[digitalExperiencesIndex + 1] === 'web_app'
+  );
+};
+
 /**
  * Resolver for metadata type and component objects.
  *
@@ -224,6 +238,10 @@ const resolveDirectoryAsComponent =
   (registry: RegistryAccess) =>
   (tree: TreeContainer) =>
   (dirPath: string): boolean => {
+    if (isWebAppBundlePath(dirPath)) {
+      return true;
+    }
+
     const type = resolveType(registry)(tree)(dirPath);
     if (type) {
       const { directoryName, inFolder } = type;
@@ -335,6 +353,10 @@ const resolveType =
   (registry: RegistryAccess) =>
   (tree: TreeContainer) =>
   (fsPath: string): MetadataType | undefined => {
+    if (isWebAppBundlePath(fsPath)) {
+      return registry.getTypeByName('DigitalExperienceBundle');
+    }
+
     // attempt 1 - check if the file is part of a component that requires a strict type folder
     let resolvedType = resolveTypeFromStrictFolder(registry)(fsPath);
 

test/client/metadataApiDeploy.test.ts

@@ -1218,6 +1218,57 @@ describe('MetadataApiDeploy', () => {
         expect(responses).to.deep.equal(expected);
       });
 
+      it('should return FileResponses for web_app DigitalExperienceBundle with child files', () => {
+        const bundlePath = join('path', 'to', 'digitalExperiences', 'web_app', 'zenith');
+        const props = {
+          name: 'web_app/zenith',
+          type: registry.types.digitalexperiencebundle,
+          content: bundlePath,
+        };
+        const component = SourceComponent.createVirtualComponent(props, [
+          {
+            dirPath: bundlePath,
+            children: ['index.html', 'app.js', 'style.css'],
+          },
+        ]);
+        const deployedSet = new ComponentSet([component]);
+        const { fullName, type } = component;
+        const apiStatus: Partial<MetadataApiDeployStatus> = {
+          details: {
+            componentSuccesses: {
+              changed: 'false',
+              created: 'true',
+              deleted: 'false',
+              success: 'true',
+              fullName,
+              componentType: type.name,
+            } as DeployMessage,
+          },
+        };
+        const result = new DeployResult(apiStatus as MetadataApiDeployStatus, deployedSet);
+
+        const responses = result.getFileResponses();
+
+        // Should have 1 bundle response + 3 file responses
+        expect(responses).to.have.lengthOf(4);
+
+        // First response should be the bundle
+        expect(responses[0]).to.deep.include({
+          fullName: 'web_app/zenith',
+          type: 'DigitalExperienceBundle',
+          state: ComponentStatus.Created,
+          filePath: bundlePath,
+        });
+
+        // Remaining responses should be DigitalExperience child files
+        const childResponses = responses.slice(1);
+        childResponses.forEach((response) => {
+          expect(response.type).to.equal('DigitalExperience');
+          expect(response.fullName).to.match(/^web_app\/zenith\//);
+          expect(response.state).to.equal(ComponentStatus.Created);
+        });
+      });
+
       it('should cache fileResponses', () => {
         const component = COMPONENT;
         const deployedSet = new ComponentSet([component]);

test/resolve/adapters/digitalExperienceSourceAdapter.test.ts

@@ -192,4 +192,26 @@ describe('DigitalExperienceSourceAdapter', () => {
       });
     });
   });
+
+  describe('DigitalExperienceSourceAdapter for web_app base type', () => {
+    const WEBAPP_BUNDLE_PATH = join(BASE_PATH, 'web_app', 'zenith');
+    const WEBAPP_CSS_FILE = join(WEBAPP_BUNDLE_PATH, 'css', 'home.css');
+
+    const webappTree = VirtualTreeContainer.fromFilePaths([WEBAPP_CSS_FILE]);
+
+    const webappBundleAdapter = new DigitalExperienceSourceAdapter(
+      registry.types.digitalexperiencebundle,
+      registryAccess,
+      forceIgnore,
+      webappTree
+    );
+
+    it('should return a SourceComponent for web_app bundle directory (no meta.xml required)', () => {
+      const component = webappBundleAdapter.getComponent(WEBAPP_BUNDLE_PATH);
+      expect(component).to.not.be.undefined;
+      expect(component?.type.name).to.equal('DigitalExperienceBundle');
+      expect(component?.fullName).to.equal('web_app/zenith');
+      expect(component?.content).to.equal(WEBAPP_BUNDLE_PATH);
+    });
+  });
 });

test/resolve/metadataResolver.test.ts

@@ -266,6 +266,22 @@ describe('MetadataResolver', () => {
         expect(mdResolver.getComponentsFromPath(path)).to.deep.equal([expectedComponent]);
       });
 
+      it('Should determine type for web_app DigitalExperienceBundle (no meta.xml required)', () => {
+        const bundlePath = join('unpackaged', 'digitalExperiences', 'web_app', 'zenith');
+        const filePath = join(bundlePath, 'index.html');
+        const treeContainer = VirtualTreeContainer.fromFilePaths([filePath]);
+        const mdResolver = new MetadataResolver(undefined, treeContainer);
+        const expectedComponent = new SourceComponent(
+          {
+            name: 'web_app/zenith',
+            type: registry.types.digitalexperiencebundle,
+            content: bundlePath,
+          },
+          treeContainer
+        );
+        expect(mdResolver.getComponentsFromPath(bundlePath)).to.deep.equal([expectedComponent]);
+      });
+
       it('Should determine type for path of mixed content type', () => {
         const path = mixedContentDirectory.MIXED_CONTENT_DIRECTORY_SOURCE_PATHS[1];
         const access = testUtil.createMetadataResolver([