@nest-boot/eslint-plugin 7.0.6 → 7.0.7

package/src/rules/mikro-orm/entity-property-config-from-types.ts

@@ -274,8 +274,11 @@ export default createRule<
       );
     };
 
-    // Check if Opt is imported
-    const hasOptImport = (): boolean => {
+    // Check if a named MikroORM helper is imported
+    const hasMikroOrmImport = (
+      importName: string,
+      options: { valueOnly?: boolean } = {},
+    ): boolean => {
       const program = context.sourceCode.ast;
       for (const statement of program.body) {
         if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
@@ -285,25 +288,46 @@ export default createRule<
             typeof importSource === "string" &&
             importSource.startsWith("@mikro-orm/")
           ) {
-            const hasOpt = statement.specifiers.some(
+            if (options.valueOnly && statement.importKind === "type") {
+              continue;
+            }
+
+            const hasImport = statement.specifiers.some(
               (spec: TSESTree.ImportClause) => {
                 return (
                   spec.type === AST_NODE_TYPES.ImportSpecifier &&
-                  spec.imported.type === AST_NODE_TYPES.Identifier &&
-                  spec.imported.name === "Opt"
+                  (!options.valueOnly || spec.importKind !== "type") &&
+                  spec.local.name === importName
                 );
               },
             );
-            if (hasOpt) return true;
+            if (hasImport) return true;
           }
         }
       }
       return false;
     };
 
-    // Add Opt to the @mikro-orm/core import
-    const addOptImport = (fixer: RuleFixer): RuleFix | null => {
+    const hasOptImport = (): boolean => hasMikroOrmImport("Opt");
+    const hasEnumImport = (): boolean =>
+      hasMikroOrmImport("Enum", { valueOnly: true });
+    const hasPropertyImport = (): boolean =>
+      hasMikroOrmImport("Property", { valueOnly: true });
+    const hasTImport = (): boolean =>
+      hasMikroOrmImport("t", { valueOnly: true });
+
+    // Add named helpers to the @mikro-orm/core import
+    const addMikroOrmImports = (
+      fixer: RuleFixer,
+      importNames: string[],
+      options: { valueImport?: boolean } = {},
+    ): RuleFix | null => {
       const program = context.sourceCode.ast;
+      const uniqueImportNames = [...new Set(importNames)];
+
+      if (uniqueImportNames.length === 0) {
+        return null;
+      }
 
       // Find the @mikro-orm/core import statement
       let coreImport: TSESTree.ImportDeclaration | null = null;
@@ -311,7 +335,10 @@ export default createRule<
       for (const statement of program.body) {
         if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
           const importSource = statement.source.value;
-          if (importSource === "@mikro-orm/core") {
+          if (
+            importSource === "@mikro-orm/core" &&
+            (!options.valueImport || statement.importKind !== "type")
+          ) {
             coreImport = statement;
             break;
           }
@@ -319,7 +346,7 @@ export default createRule<
       }
 
       if (coreImport) {
-        // Already has @mikro-orm/core import, add Opt to the import list
+        // Already has @mikro-orm/core import, add the helper to the import list
         const lastSpecifier =
           coreImport.specifiers[coreImport.specifiers.length - 1];
 
@@ -330,10 +357,16 @@ export default createRule<
         if (isMultiline) {
           // Multiline import: add after the last import item, keeping indentation
           const indent = "  "; // Assuming 2-space indentation
-          return fixer.insertTextAfter(lastSpecifier, `,\n${indent}Opt`);
+          return fixer.insertTextAfter(
+            lastSpecifier,
+            uniqueImportNames.map((name) => `,\n${indent}${name}`).join(""),
+          );
         } else {
           // Single-line import: add directly
-          return fixer.insertTextAfter(lastSpecifier, ", Opt");
+          return fixer.insertTextAfter(
+            lastSpecifier,
+            `, ${uniqueImportNames.join(", ")}`,
+          );
         }
       } else {
         // No @mikro-orm/core import, add a new import statement at the top
@@ -345,13 +378,42 @@ export default createRule<
         if (firstImport) {
           return fixer.insertTextBefore(
             firstImport,
-            "import { Opt } from '@mikro-orm/core';\n",
+            `import { ${uniqueImportNames.join(", ")} } from '@mikro-orm/core';\n`,
           );
         }
       }
       return null;
     };
 
+    const addMikroOrmImport = (
+      fixer: RuleFixer,
+      importName: string,
+      options: { valueImport?: boolean } = {},
+    ): RuleFix | null => addMikroOrmImports(fixer, [importName], options);
+
+    const addOptImport = (fixer: RuleFixer): RuleFix | null =>
+      addMikroOrmImport(fixer, "Opt");
+
+    const addEnumImport = (fixer: RuleFixer): RuleFix | null =>
+      addMikroOrmImport(fixer, "Enum", { valueImport: true });
+
+    const addPropertyDecoratorImports = (
+      fixer: RuleFixer,
+      info: TypeInfo,
+    ): RuleFix | null => {
+      const importNames: string[] = [];
+
+      if (!hasPropertyImport()) {
+        importNames.push("Property");
+      }
+
+      if (info.propertyType?.startsWith("t.") && !hasTImport()) {
+        importNames.push("t");
+      }
+
+      return addMikroOrmImports(fixer, importNames, { valueImport: true });
+    };
+
     const computeTypeInfo = (
       property: TSESTree.PropertyDefinition,
     ): TypeInfo | null => {
@@ -1073,10 +1135,15 @@ export default createRule<
                 messageId: "useEnumDecorator",
                 fix: (fixer) => {
                   const newDecoratorText = buildEnumDecorator(typeInfo);
-                  return fixer.replaceTextRange(
+                  const decoratorFix = fixer.replaceTextRange(
                     propertyDecorator.range,
                     newDecoratorText,
                   );
+                  const importFix = hasEnumImport()
+                    ? null
+                    : addEnumImport(fixer);
+
+                  return importFix ? [importFix, decoratorFix] : decoratorFix;
                 },
               });
               return;
@@ -1088,10 +1155,13 @@ export default createRule<
               messageId: "useEnumDecorator",
               fix: (fixer) => {
                 const newDecoratorText = buildEnumDecorator(typeInfo);
-                return fixer.insertTextBeforeRange(
+                const decoratorFix = fixer.insertTextBeforeRange(
                   member.range,
                   newDecoratorText + "\n  ",
                 );
+                const importFix = hasEnumImport() ? null : addEnumImport(fixer);
+
+                return importFix ? [importFix, decoratorFix] : decoratorFix;
               },
             });
             return;
@@ -1103,8 +1173,15 @@ export default createRule<
               node: member,
               messageId: "alignPropertyDecoratorWithTsType",
               fix: (fixer) => {
-                const fixes = addPropertyDecorator(member, typeInfo);
-                return applyFixes(fixer, fixes);
+                const decoratorFixes = applyFixes(
+                  fixer,
+                  addPropertyDecorator(member, typeInfo),
+                );
+                const importFix = addPropertyDecoratorImports(fixer, typeInfo);
+
+                return importFix
+                  ? [importFix, ...decoratorFixes]
+                  : decoratorFixes;
               },
             });
             return;

package/src/utils/decorators.spec.ts

@@ -84,6 +84,32 @@ describe("decorators", () => {
 
       expect(hasClassDecorator(classDeclaration, "Entity")).toBe(false);
     });
+
+    it("should return false for non-call and non-identifier class decorators", () => {
+      const classDeclaration = {
+        type: AST_NODE_TYPES.ClassDeclaration,
+        decorators: [
+          {
+            type: AST_NODE_TYPES.Decorator,
+            expression: {
+              type: AST_NODE_TYPES.Identifier,
+              name: "Entity",
+            },
+          },
+          {
+            type: AST_NODE_TYPES.Decorator,
+            expression: {
+              type: AST_NODE_TYPES.CallExpression,
+              callee: {
+                type: AST_NODE_TYPES.MemberExpression,
+              },
+            },
+          },
+        ],
+      } as unknown as TSESTree.ClassDeclaration;
+
+      expect(hasClassDecorator(classDeclaration, "Entity")).toBe(false);
+    });
   });
 
   describe("hasPropertyDecorator", () => {
@@ -148,6 +174,32 @@ describe("decorators", () => {
 
       expect(hasPropertyDecorator(propertyDefinition, "Field")).toBe(false);
     });
+
+    it("should return false for non-call and non-identifier property decorators", () => {
+      const propertyDefinition = {
+        type: AST_NODE_TYPES.PropertyDefinition,
+        decorators: [
+          {
+            type: AST_NODE_TYPES.Decorator,
+            expression: {
+              type: AST_NODE_TYPES.Identifier,
+              name: "Field",
+            },
+          },
+          {
+            type: AST_NODE_TYPES.Decorator,
+            expression: {
+              type: AST_NODE_TYPES.CallExpression,
+              callee: {
+                type: AST_NODE_TYPES.MemberExpression,
+              },
+            },
+          },
+        ],
+      } as unknown as TSESTree.PropertyDefinition;
+
+      expect(hasPropertyDecorator(propertyDefinition, "Field")).toBe(false);
+    });
   });
 
   describe("getClassDecorator", () => {