fix: can retrive COFT with COT automatically (#517)

* fix: can retrive COFT with COT automatically

* refactor: requiresParents -> unadressableWithoutParent

Co-authored-by: Shane McLaughlin <[email protected]>

Author: WillieRuemmele

src/convert/transformers/decomposedMetadataTransformer.ts

@@ -13,6 +13,7 @@ import { META_XML_SUFFIX, SourcePath, XML_NS_KEY, XML_NS_URL } from '../../commo
 import { ComponentSet } from '../../collections';
 import { DecompositionState } from '../convertContext';
 import { DecompositionStrategy } from '../../registry';
+import { normalizeToArray } from '../../utils';
 import { BaseMetadataTransformer } from './baseMetadataTransformer';
 
 export class DecomposedMetadataTransformer extends BaseMetadataTransformer {
@@ -61,7 +62,7 @@ export class DecomposedMetadataTransformer extends BaseMetadataTransformer {
       const childTypeId = type.children?.directories[tagKey];
       if (childTypeId) {
         const childType = type.children.types[childTypeId];
-        const tagValues = Array.isArray(tagValue) ? tagValue : [tagValue];
+        const tagValues = normalizeToArray(tagValue);
         for (const value of tagValues as [{ fullName: string; name: string }]) {
           const entryName = value.fullName || value.name;
           const childComponent: MetadataComponent = {
@@ -74,6 +75,30 @@ export class DecomposedMetadataTransformer extends BaseMetadataTransformer {
             const source = new JsToXml({
               [childType.name]: Object.assign({ [XML_NS_KEY]: XML_NS_URL }, value),
             });
+
+            /*
+             composedMetadata is a representation of the parent's xml
+             if there is no CustomObjectTranslation in the org, the composedMetadata will be 2 entries
+             the xml declaration, and a fields attribute, which points to the child CustomObjectFieldTranslation
+             because CustomObjectFieldTranslation is the only metadata type with 'requiresParent' = true we can
+             calculate if a CustomObjectTranslation was retrieved from the org (composedMetadata.length > 2), or,
+             if we'll have to write an empty CustomObjectTranslation file (composedMetadata.length <=2).
+             CustomObjectFieldTranslations are only addressable through their parent, and require a
+             CustomObjectTranslation file to be present
+             */
+            if (childType.unaddressableWithoutParent && composedMetadata.length <= 2) {
+              parentXmlObject = {
+                [component.type.name]: '',
+              };
+              this.setDecomposedState(childComponent, {
+                foundMerge: false,
+                writeInfo: {
+                  source: new JsToXml(parentXmlObject),
+                  output: this.getDefaultOutput(component),
+                },
+              });
+            }
+
             // if there's nothing to merge with, push write operation now to default location
             if (!mergeWith) {
               writeInfos.push({

src/registry/metadataRegistry.json

@@ -850,6 +850,7 @@
             "directoryName": "fields",
             "suffix": "fieldTranslation",
             "isAddressable": false,
+            "unaddressableWithoutParent": true,
             "uniqueIdElement": "name"
           }
         },

src/registry/types.ts

@@ -91,6 +91,10 @@ export interface MetadataType {
    * Whether the component is supported by the Metadata API and therefore should be included within a manifest.
    */
   isAddressable?: boolean;
+  /**
+   * Whether the component requires the parent to be present when deploying/retrieving
+   */
+  unaddressableWithoutParent?: boolean;
 
   /**
    * Whether or not components of the same type can be can be specified with the wildcard character, and by name in a manifest

test/convert/transformers/decomposedMetadataTransformer.ts

@@ -336,6 +336,68 @@ describe('DecomposedMetadataTransformer', () => {
         },
       ]);
     });
+    it('should create a parent xml when requiresParent = true on the child type', async () => {
+      component.type.children.types.y.unaddressableWithoutParent = true;
+      component.type.children.types.x.unaddressableWithoutParent = true;
+      const { type, fullName } = component;
+      const transformer = new DecomposedMetadataTransformer(mockRegistry);
+      const root = join('main', 'default', type.directoryName, fullName);
+      env.stub(component, 'parseXml').resolves({
+        Decomposed: {
+          ys: { fullName: 'child', test: 'testVal' },
+          xs: [
+            { fullName: 'child2', test: 'testVal2' },
+            { fullName: 'child3', test: 'testVal3' },
+          ],
+        },
+      });
+
+      const result = await transformer.toSourceFormat(component);
+
+      expect(result).to.deep.equal([
+        {
+          source: new JsToXml({
+            Y: {
+              [XML_NS_KEY]: XML_NS_URL,
+              fullName: 'child',
+              test: 'testVal',
+            },
+          }),
+          output: join(root, type.children.types.y.directoryName, 'child.y-meta.xml'),
+        },
+        {
+          source: new JsToXml({
+            X: {
+              [XML_NS_KEY]: XML_NS_URL,
+              fullName: 'child2',
+              test: 'testVal2',
+            },
+          }),
+          output: join(root, type.children.types.x.directoryName, 'child2.x-meta.xml'),
+        },
+        {
+          source: new JsToXml({
+            X: {
+              [XML_NS_KEY]: XML_NS_URL,
+              fullName: 'child3',
+              test: 'testVal3',
+            },
+          }),
+          output: join(root, type.children.types.x.directoryName, 'child3.x-meta.xml'),
+        },
+        // the new parent was written
+        {
+          source: new JsToXml({
+            [type.name]: '',
+          }),
+          output: join(root, 'a.decomposed-meta.xml'),
+        },
+      ]);
+
+      // reset to avoid interfering with other tests
+      component.type.children.types.y.unaddressableWithoutParent = false;
+      component.type.children.types.x.unaddressableWithoutParent = false;
+    });
 
     it('should handle decomposed parents with no files', async () => {
       const transformer = new DecomposedMetadataTransformer(mockRegistry);