Sm/strictFolders-match-suffixes (#477)

* fix: strictDir is pickier about its matches

* refactor: filter instead of continue

* Update src/resolve/metadataResolver.ts

Co-authored-by: peternhale <[email protected]>

* refactor: pr feedback from pete

* test: mock repo typos

* test: the mock registry should be valid, too

* style: no manual debugs

* chore: linter changes

* chore: remove comments

Co-authored-by: peternhale <[email protected]>

Author: mshanemc

src/resolve/metadataResolver.ts

@@ -148,22 +148,38 @@ export class MetadataResolver {
     return !!parseMetadataXml(fsPath);
   }
 
-  private resolveType(fsPath: string): MetadataType | undefined {
-    let resolvedType: MetadataType;
+  private resolveTypeFromStrictFolder(fsPath: string): MetadataType | undefined {
+    const pathParts = fsPath.split(sep);
+    // first, filter out types that don't appear in the path
+    // then iterate using for/of to allow for early break
+    return this.registry
+      .getStrictFolderTypes()
+      .filter(
+        (type) =>
+          // the type's directory is in the path, AND
+          pathParts.includes(type.directoryName) &&
+          // types with folders only have folder components living at the top level.
+          // if the fsPath is a folder component, let a future strategy deal with it
+          (!type.inFolder || parentName(fsPath) !== type.directoryName)
+      )
+      .find(
+        (type) =>
+          // any of the following 3 options is considered a good match
+          // mixedContent and bundles don't have a suffix to match
+          ['mixedContent', 'bundle'].includes(type.strategies?.adapter) ||
+          // the suffix matches the type we think it is
+          (type.suffix && fsPath.endsWith(`${type.suffix}`)) ||
+          // the type has children and the path also includes THAT directory
+          (type.children?.types &&
+            Object.values(type.children?.types)
+              .map((childType) => childType.directoryName)
+              .some((dirName) => pathParts.includes(dirName)))
+      );
+  }
 
+  private resolveType(fsPath: string): MetadataType | undefined {
     // attempt 1 - check if the file is part of a component that requires a strict type folder
-    const pathParts = new Set(fsPath.split(sep));
-    for (const type of this.registry.getStrictFolderTypes()) {
-      if (pathParts.has(type.directoryName)) {
-        // types with folders only have folder components living at the top level.
-        // if the fsPath is a folder component, let a future strategy deal with it
-        // const isFolderType = this.getTypeFromName(typeId).inFolder;
-        if (!type.inFolder || parentName(fsPath) !== type.directoryName) {
-          resolvedType = type;
-        }
-        break;
-      }
-    }
+    let resolvedType = this.resolveTypeFromStrictFolder(fsPath);
 
     // attempt 2 - check if it's a metadata xml file
     if (!resolvedType) {

test/mock/registry/mockRegistry.ts

@@ -284,11 +284,15 @@ export const mockRegistryData = {
     mixedSingleFile: 'mixedcontentsinglefile',
     dtl: 'decomposedtoplevel',
     ms: 'missingstrategies',
+    nestedParent: 'nestedparent',
+    nestedChild: 'nestedchild',
+    document: 'document',
+    nondecomposed: 'nondecomposedchild',
   },
   strictDirectoryNames: {
-    mixedContentDirectories: 'mixedcontentdirectory',
+    mixedcontentdirectories: 'mixedcontentdirectory',
     bundles: 'bundle',
-    decomposed: 'decomposed',
+    decomposeds: 'decomposed',
     mixedSingleFiles: 'mixedcontentsinglefile',
     mixedContentInFolders: 'mixedcontentinfolder',
     decomposedTopLevels: 'decomposedtoplevel',
@@ -298,6 +302,7 @@ export const mockRegistryData = {
     y: 'decomposed',
     g: 'decomposedtoplevel',
     badchildtype: 'mixedcontentsinglefile',
+    nondecomposedchild: 'nondecomposedparent',
   },
   apiVersion: '48.0',
 };

test/registry/mockRegistryValidation.test.ts

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+import { expect } from 'chai';
+import { MetadataRegistry } from '../../src';
+import { mockRegistryData as defaultRegistry } from '../mock/registry/mockRegistry';
+import { MetadataType } from '../../src/registry/types';
+
+describe('Mock Registry Validation', () => {
+  const registry = defaultRegistry as MetadataRegistry;
+  const typesWithChildren = Object.values(registry.types).filter((type) => type.children);
+
+  describe('every child type has an entry in children', () => {
+    const childMapping = new Map<string, string>();
+
+    typesWithChildren.map((parentType) =>
+      Object.values(parentType.children.types).map((childType) => {
+        childMapping.set(childType.id, parentType.id);
+      })
+    );
+
+    childMapping.forEach((parentId, childId) => {
+      it(`has a childType for ${childId} : ${parentId}`, () => {
+        expect(parentId).to.be.a('string');
+        expect(childId).to.be.a('string');
+        expect(registry.childTypes[childId]).to.equal(parentId);
+      });
+    });
+  });
+
+  describe('suffix object is complete', () => {
+    const knownExceptions: string[] = [];
+
+    const suffixMap = new Map<string, string>();
+    Object.values(registry.types)
+      .filter((type) => type.suffix && !type.strictDirectoryName && !knownExceptions.includes(type.name))
+      .map((type) => {
+        // mapping for the type's suffix
+        suffixMap.set(type.suffix, type.id);
+        if (type.children) {
+          Object.values(type.children.types).map((childType) => {
+            // mapping for the child's suffix
+            suffixMap.set(childType.suffix, childType.id);
+          });
+        }
+      });
+    suffixMap.forEach((typeid, suffix) => {
+      it(`has a suffix entry for "${suffix}" : "${typeid}"`, () => {
+        expect(typeid).to.be.a('string');
+        expect(suffix).to.be.a('string');
+        expect(registry.suffixes[suffix]).to.equal(typeid);
+      });
+    });
+  });
+
+  describe('suffixes must be unique on non-strict types', () => {
+    const suffixMap = new Map<string, MetadataType[]>();
+    Object.values(registry.types).map((type) => {
+      if (type.suffix) {
+        // some bundle types have no suffix
+        suffixMap.set(type.suffix, suffixMap.has(type.suffix) ? [...suffixMap.get(type.suffix), type] : [type]);
+      }
+    });
+    suffixMap.forEach((types, suffix) => {
+      if (types.length > 1) {
+        // identify when a single suffix is used in multiple metadata types.
+        // when the happens, there can only be one who is not marked as strictDirectoryName
+        it(`Suffix "${suffix}" used by types (${types
+          .map((type) => type.name)
+          .join(',')}) should have only 1 non-strict directory`, () => {
+          const nonStrictTypes = types.filter((type) => !type.strictDirectoryName);
+          expect(nonStrictTypes.length, nonStrictTypes.map((type) => type.name).join(',')).lessThan(2);
+        });
+      }
+    });
+  });
+
+  describe('strict types are all in strictDirectoryNames', () => {
+    const strictTypeMap = new Map<string, string>();
+    Object.values(registry.types)
+      .filter((type) => type.strictDirectoryName)
+      .map((type) => {
+        // the type's suffix
+        strictTypeMap.set(type.directoryName, type.id);
+      });
+    strictTypeMap.forEach((typeid, strictDirectoryName) => {
+      it(`has a strictDirectoryNames entry for "${strictDirectoryName}" : "${typeid}"`, () => {
+        expect(typeid).to.be.a('string');
+        expect(strictDirectoryName).to.be.a('string');
+        expect(registry.strictDirectoryNames[strictDirectoryName]).to.equal(typeid);
+      });
+    });
+  });
+});

test/resolve/metadataResolverRealRegistry.test.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import { join } from 'path';
+import { expect } from 'chai';
+
+import { MetadataResolver, SourceComponent, VirtualTreeContainer } from '../../src/resolve';
+import { META_XML_SUFFIX } from '../../src/common';
+import { registry, RegistryAccess } from '../../src';
+
+describe('MetadataResolver', () => {
+  const registryAccess = new RegistryAccess(registry);
+  describe('Should not resolve using strictDir when suffixes do not match', () => {
+    const type = registryAccess.getTypeByName('ApexClass');
+    const COMPONENT_NAMES = ['myClass'];
+    // real scenario: classes/foo/objects/myCls.cls (where objects is the strictDir of another type)
+    const TYPE_DIRECTORY = join('classes', 'subfolder', 'subfolder2', 'objects');
+    const XML_NAMES = COMPONENT_NAMES.map((name) => `${name}.${type.suffix}${META_XML_SUFFIX}`);
+    const XML_PATHS = XML_NAMES.map((name) => join(TYPE_DIRECTORY, name));
+    const CONTENT_NAMES = COMPONENT_NAMES.map((name) => `${name}.${type.suffix}`);
+    const CONTENT_PATHS = CONTENT_NAMES.map((name) => join(TYPE_DIRECTORY, name));
+    const TREE = new VirtualTreeContainer([
+      {
+        dirPath: TYPE_DIRECTORY,
+        children: XML_NAMES.concat(CONTENT_NAMES),
+      },
+    ]);
+    const COMPONENTS = COMPONENT_NAMES.map(
+      (name, index) =>
+        new SourceComponent(
+          {
+            name,
+            type,
+            xml: XML_PATHS[index],
+            content: CONTENT_PATHS[index],
+          },
+          TREE
+        )
+    );
+    it('metadata file', () => {
+      const resolver = new MetadataResolver(registryAccess, TREE);
+      const sourceComponent = resolver.getComponentsFromPath(XML_PATHS[0])[0];
+      expect(sourceComponent.type).to.deep.equal(type);
+      expect(sourceComponent).to.deep.equal(COMPONENTS[0]);
+    });
+    it('content file', () => {
+      const resolver = new MetadataResolver(registryAccess, TREE);
+      expect(resolver.getComponentsFromPath(CONTENT_PATHS[0])).to.deep.equal([COMPONENTS[0]]);
+    });
+  });
+});