feat: did you mean when types aren't in Registry

Author: mshanemc

messages/sdr.md

@@ -190,3 +190,16 @@ If the type is available via Metadata API but not in the registry
 
 - Open an issue <https://github.com/forcedotcom/cli/issues>
 - Add the type via PR. Instructions: <https://github.com/forcedotcom/source-deploy-retrieve/blob/main/contributing/metadata.md>
+
+# type_name_suggestions
+
+Confirm the metadata type name is correct. Validate against the registry at:
+<https://github.com/forcedotcom/source-deploy-retrieve/blob/main/src/registry/metadataRegistry.json>
+
+If the type is not listed in the registry, check that it has Metadata API support via the Metadata Coverage Report:
+<https://developer.salesforce.com/docs/metadata-coverage>
+
+If the type is available via Metadata API but not in the registry
+
+- Open an issue <https://github.com/forcedotcom/cli/issues>
+- Add the type via PR. Instructions: <https://github.com/forcedotcom/source-deploy-retrieve/blob/main/contributing/metadata.md>

src/registry/levenshtein.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023, 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 { Messages } from '@salesforce/core/messages';
+import * as Levenshtein from 'fast-levenshtein';
+import { MetadataRegistry } from './types';
+
+Messages.importMessagesDirectory(__dirname);
+const messages = Messages.loadMessages('@salesforce/source-deploy-retrieve', 'sdr');
+
+/** "did you mean" for Metadata type names */
+export const getTypeSuggestions = (registry: MetadataRegistry, typeName: string): string[] => {
+  const scores = getScores(
+    Object.values(registry.types).map((t) => t.name),
+    typeName
+  );
+
+  const guesses = getLowestScores(scores);
+  return guesses.length
+    ? [
+        'Did you mean one of the following types?',
+        ...guesses.map((guess) => guess.registryKey),
+        ...messages.getMessages('type_name_suggestions'),
+      ]
+    : messages.getMessages('type_name_suggestions');
+};
+
+export const getSuffixGuesses = (suffixes: string[], input: string): string[] => {
+  const scores = getScores(suffixes, input);
+  return getLowestScores(scores).map((g) => g.registryKey);
+};
+
+type LevenshteinScore = {
+  registryKey: string;
+  score: number;
+};
+
+const getScores = (choices: string[], input: string): LevenshteinScore[] =>
+  choices.map((registryKey) => ({
+    registryKey,
+    score: Levenshtein.get(input, registryKey, { useCollator: true }),
+  }));
+
+/** Levenshtein uses positive integers for scores, find all scores that match the lowest score */
+const getLowestScores = (scores: LevenshteinScore[]): LevenshteinScore[] => {
+  const sortedScores = scores.sort(levenshteinSorter);
+  const lowestScore = scores[0].score;
+  return sortedScores.filter((score) => score.score === lowestScore);
+};
+
+const levenshteinSorter = (a: LevenshteinScore, b: LevenshteinScore): number => a.score - b.score;

src/registry/registryAccess.ts

@@ -5,9 +5,9 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 import { Messages, SfError } from '@salesforce/core';
-import * as Levenshtein from 'fast-levenshtein';
 import { MetadataRegistry, MetadataType } from './types';
 import { getEffectiveRegistry } from './variants';
+import { getSuffixGuesses, getTypeSuggestions } from './levenshtein';
 
 /**
  * Container for querying metadata registry data.
@@ -50,7 +50,11 @@ export class RegistryAccess {
       );
     }
     if (!this.registry.types[lower]) {
-      throw new SfError(messages.getMessage('error_missing_type_definition', [lower]), 'RegistryError');
+      throw SfError.create({
+        message: messages.getMessage('error_missing_type_definition', [lower]),
+        name: 'RegistryError',
+        actions: getTypeSuggestions(this.registry, lower),
+      });
     }
     const alias = this.registry.types[lower].aliasFor;
     // redirect via alias
@@ -79,27 +83,13 @@ export class RegistryAccess {
   public guessTypeBySuffix(
     suffix: string
   ): Array<{ suffixGuess: string; metadataTypeGuess: MetadataType }> | undefined {
-    const registryKeys = Object.keys(this.registry.suffixes);
-
-    const scores = registryKeys.map((registryKey) => ({
-      registryKey,
-      score: Levenshtein.get(suffix, registryKey, { useCollator: true }),
-    }));
-    const sortedScores = scores.sort((a, b) => a.score - b.score);
-    const lowestScore = sortedScores[0].score;
-    // Levenshtein uses positive integers for scores, find all scores that match the lowest score
-    const guesses = sortedScores.filter((score) => score.score === lowestScore);
-
-    if (guesses.length > 0) {
-      return guesses.map((guess) => {
-        const typeId = this.registry.suffixes[guess.registryKey];
-        const metadataType = this.getTypeByName(typeId);
-        return {
-          suffixGuess: guess.registryKey,
-          metadataTypeGuess: metadataType,
-        };
-      });
-    }
+    const guesses = getSuffixGuesses(Object.keys(this.registry.suffixes), suffix);
+    return guesses.length
+      ? guesses.map((guess) => ({
+          suffixGuess: guess,
+          metadataTypeGuess: this.getTypeByName(this.registry.suffixes[guess]),
+        }))
+      : undefined;
   }
 
   /**

test/registry/registryAccess.test.ts

@@ -43,6 +43,26 @@ describe('RegistryAccess', () => {
         messages.getMessage('error_missing_type_definition', ['typewithoutdef'])
       );
     });
+
+    describe('suggestions for type name', () => {
+      it('should provide suggestions for unresolvable types that are close', () => {
+        try {
+          registryAccess.getTypeByName('Worflow');
+        } catch (e) {
+          assert(e instanceof SfError);
+          expect(e.actions).to.have.length.greaterThan(0);
+          expect(e.actions).to.deep.include('Workflow');
+        }
+      });
+      it('should provide several suggestions for unresolvable types that are nowhere', () => {
+        try {
+          registryAccess.getTypeByName('&&&&&&');
+        } catch (e) {
+          assert(e instanceof SfError);
+          expect(e.actions).to.have.length.greaterThan(1);
+        }
+      });
+    });
   });
 
   describe('getTypeBySuffix', () => {