Don't run codemod on files that don't match the available types

Author: gitKrystan

.vscode/settings.json

@@ -1,6 +1,10 @@
 {
   "editor.formatOnSave": true,
   "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.codeActionsOnSave": {
+    "source.fixAll": true,
+    "source.organizeImports": true
+  },
   "typescript.preferences.importModuleSpecifierEnding": "index",
   "typescript.suggest.autoImports": true
 }

README.md

@@ -180,7 +180,7 @@ describe('options', () => {
           new RegExp(
             makeMultilineMatcher(
               'test Config Error',
-              "[type] Expected 'services', 'routes', 'components', or 'controllers', received 'oops"
+              "[type] Expected 'adapters', 'components', 'controllers', 'helpers', 'routes', or 'services', received 'oops'"
             )
           )
         );

test/options.test.ts

@@ -27,7 +27,7 @@ const transformer: Transform = function (
     }
 
     if (isTestFile(filePath)) {
-      logger.info({ filePath, info: 'SKIPPED: test file' });
+      logger.debug({ filePath, info: 'SKIPPED: test file' });
       return; // status: 'skipped'
     }
 

transforms/ember-object/index.ts

@@ -7,6 +7,7 @@ import {
   StringBooleanSchema,
   StringFalseSchema,
 } from './schema-helper';
+import { defined, twoOrMoreMap } from './util/types';
 
 const DEFAULT_DECORATOR_CONFIG = {
   inObjectLiterals: [],
@@ -49,20 +50,30 @@ const QuoteSchema = z.union([z.literal('single'), z.literal('double')], {
   },
 });
 
+export const TYPES = [
+  'adapters',
+  'components',
+  'controllers',
+  'helpers',
+  'routes',
+  'services',
+] as const;
+
+export type Type = (typeof TYPES)[number];
+
 const TypeSchema = z.union(
-  [
-    z.literal('services'),
-    z.literal('routes'),
-    z.literal('components'),
-    z.literal('controllers'),
-  ],
+  twoOrMoreMap(TYPES, (type) => z.literal(type)),
   {
     errorMap: (issue, ctx) => {
       if (issue.code === z.ZodIssueCode.invalid_union) {
+        const formattedTypes = TYPES.map((type) => `'${type}'`);
+        const expected = `${formattedTypes
+          .slice(0, -1)
+          .join(', ')}, or ${defined(
+          formattedTypes[formattedTypes.length - 1]
+        )}`;
         return {
-          message: `Expected 'services', 'routes', 'components', or 'controllers', received ${inspect(
-            ctx.data
-          )}`,
+          message: `Expected ${expected}, received ${inspect(ctx.data)}`,
         };
       }
       return { message: ctx.defaultError };

transforms/helpers/options.ts

@@ -40,3 +40,14 @@ export function defined<T>(
   assert(value !== undefined, message);
   return value;
 }
+
+/**
+ * Wraps Array.map in a type-check that the initial array has at least two
+ * items, then returns an array asserting that it has the same number of items.
+ */
+export function twoOrMoreMap<T, U>(
+  array: readonly [T, T, ...T[]],
+  callbackfn: (value: T, index: number, array: readonly T[]) => U
+): [U, U, ...U[]] {
+  return array.map(callbackfn) as unknown as [U, U, ...U[]];
+}

transforms/helpers/util/types.ts

@@ -1,16 +1,9 @@
 import { minimatch } from 'minimatch';
-import type { Options } from './options';
+import { TYPES, type Type } from './options';
 
-const TYPE_PATTERNS = {
-  service: '**/services/**/*.js',
-  services: '**/services/**/*.js',
-  controller: '**/controllers/**/*.js',
-  controllers: '**/controllers/**/*.js',
-  component: '**/components/**/*.js',
-  components: '**/components/**/*.js',
-  route: '**/routes/**/*.js',
-  routes: '**/routes/**/*.js',
-} as const;
+const TYPE_PATTERNS = Object.fromEntries(
+  TYPES.map((type) => [type, `**/${type}/**/*.js`] as const)
+) as Record<Type, string>;
 
 const TEST_FILE_PATTERN = '**/*-test.js' as const;
 
@@ -23,10 +16,6 @@ export function isTestFile(file: string): boolean {
  * Returns true if the given path matches the type of ember object
  * The glob patterns are specified by `TYPE_PATTERNS`
  */
-export function isFileOfType(file: string, type: Options['type']): boolean {
-  return (
-    // False positive
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    !!type && !!TYPE_PATTERNS[type] && minimatch(file, TYPE_PATTERNS[type])
-  );
+export function isFileOfType(file: string, type: Type): boolean {
+  return minimatch(file, TYPE_PATTERNS[type]);
 }