feat: add required child type entries to manifest

src/collections/componentSet.ts

@@ -288,8 +288,15 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
       // Add children
       const componentMap = components.get(key);
       for (const comp of componentMap.values()) {
-        for (const child of comp.getChildren()) {
-          addToTypeMap(child.type.name, child.fullName);
+        if (comp.requiresChildren()) {
+          const childTypes = comp.type.children.types;
+          for (const childTypeId of Object.keys(childTypes)) {
+            addToTypeMap(childTypes[childTypeId].name, '*');
+          }
+        } else {
+          for (const child of comp.getChildren()) {
+            addToTypeMap(child.type.name, child.fullName);
+          }
         }
       }
     }

src/resolve/sourceComponent.ts

@@ -135,6 +135,21 @@ export class SourceComponent implements MetadataComponent {
     this.markedForDelete = asDeletion;
   }
 
+  /**
+   * When deploying certain parent metadata types to orgs for packaging,
+   * the child type entries must also be included within the manifest or
+   * the deployment will fail.
+   *
+   * @returns Whether this component requires its child types in a manifest.
+   */
+  public requiresChildren(): boolean {
+    // If the registry defines this type to have children and there
+    // isn't an adapter strategy then the child types need to be included.
+    // When the component has an adapter strategy we don't need to do this
+    // because the strategy handles it for us.
+    return !this.parent && this.type.children && !this.type.strategies?.adapter;
+  }
+
   private calculateRelativePath(fsPath: string): string {
     const { directoryName, suffix, inFolder, folderType } = this.type;
     // if there isn't a suffix, assume this is a mixed content component that must

test/collections/componentSet.test.ts

@@ -15,6 +15,7 @@ import {
   MetadataApiRetrieve,
   MetadataComponent,
   MetadataResolver,
+  MetadataType,
   RegistryAccess,
 } from '../../src';
 import { ComponentSetError } from '../../src/errors';
@@ -418,6 +419,47 @@ describe('ComponentSet', () => {
       ]);
     });
 
+    it('should include required child types as defined in the registry', () => {
+      // The key for this test type is that is has children but does not define
+      // a strategies section for adapters and transformers. Note this does not
+      // exactly match the Workflow type in the registry but it doesn't have to.
+      const type: MetadataType = {
+        id: 'workflow',
+        name: 'Workflow',
+        suffix: 'workflow',
+        directoryName: 'workflows',
+        inFolder: false,
+        strictDirectoryName: false,
+        children: {
+          types: {
+            workflowfieldupdate: {
+              id: 'workflowfieldupdate',
+              name: 'WorkflowFieldUpdate',
+              directoryName: 'workflowFieldUpdates',
+              suffix: 'workflowFieldUpdate',
+            },
+            workflowrule: {
+              id: 'workflowrule',
+              name: 'WorkflowRule',
+              directoryName: 'workflowRules',
+              suffix: 'workflowRule',
+            },
+          },
+          suffixes: {
+            workflowFieldUpdate: 'workflowfieldupdate',
+            workflowRule: 'workflowrule',
+          },
+        },
+      };
+      const set = new ComponentSet();
+      set.add(new SourceComponent({ name: type.name, type }));
+      expect(set.getObject().Package.types).to.deep.equal([
+        { name: type.name, members: [type.name] },
+        { name: 'WorkflowFieldUpdate', members: ['*'] },
+        { name: 'WorkflowRule', members: ['*'] },
+      ]);
+    });
+
     /**
      * If component set keys are incorrectly handled, child component names may not be returned properly.
      */

test/resolve/sourceComponent.test.ts

@@ -30,6 +30,7 @@ import { join } from 'path';
 import { DecomposedSourceAdapter } from '../../src/resolve/adapters';
 import { TypeInferenceError } from '../../src/errors';
 import { nls } from '../../src/i18n';
+import { MetadataType } from '../../src';
 
 const env = createSandbox();
 
@@ -49,6 +50,40 @@ describe('SourceComponent', () => {
     }
   });
 
+  it('should return correct requiresChildren() boolean', () => {
+    // See comments for SourceComponent.requireChildren. This applies
+    // to most Rules types and Workflows, but for a complete list search
+    // the registry for types with children without strategies defined.
+    const type: MetadataType = {
+      id: 'assignmentrules',
+      name: 'AssignmentRules',
+      suffix: 'assignmentRules',
+      directoryName: 'assignmentRules',
+      inFolder: false,
+      strictDirectoryName: false,
+      children: {
+        types: {
+          assignmentrule: {
+            id: 'assignmentrule',
+            name: 'AssignmentRule',
+            directoryName: 'assignmentRules',
+            suffix: 'assignmentRule',
+          },
+        },
+        suffixes: {
+          assignmentRule: 'assignmentrule',
+        },
+      },
+    };
+    expect(new SourceComponent({ name: type.name, type }).requiresChildren()).to.equal(true);
+    type.strategies = {
+      adapter: 'decomposed',
+      transformer: 'decomposed',
+      decomposition: 'folderPerType',
+    };
+    expect(new SourceComponent({ name: type.name, type }).requiresChildren()).to.equal(false);
+  });
+
   describe('parseXml', () => {
     afterEach(() => env.restore());