@nest-boot/eslint-plugin 7.0.5 → 7.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-boot/eslint-plugin",
-  "version": "7.0.5",
+  "version": "7.0.7",
   "repository": {
     "type": "git",
     "url": "https://github.com/nest-boot/nest-boot.git",
@@ -10,7 +10,7 @@
   "main": "./dist/index.js",
   "exports": "./dist/index.js",
   "dependencies": {
-    "@typescript-eslint/utils": "^8.51.0"
+    "@typescript-eslint/utils": "^8.56.1"
   },
   "peerDependencies": {
     "@typescript-eslint/parser": "^8.0.0",
@@ -21,17 +21,17 @@
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.39.2",
     "@jest/globals": "^30.2.0",
-    "@types/node": "^22.18.6",
-    "@typescript-eslint/parser": "^8.51.0",
-    "@typescript-eslint/rule-tester": "^8.51.0",
-    "eslint": "^9.39.2",
+    "@types/node": "^24.12.4",
+    "@typescript-eslint/parser": "^8.56.1",
+    "@typescript-eslint/rule-tester": "^8.56.1",
+    "eslint": "^9.39.3",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.4.4",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2",
-    "@nest-boot/tsconfig": "^7.0.1"
+    "typescript-eslint": "^8.56.1",
+    "@nest-boot/tsconfig": "^7.0.3"
   },
   "publishConfig": {
     "access": "public"

package/src/index.spec.ts

@@ -0,0 +1,8 @@
+import plugin from ".";
+
+describe("plugin public API", () => {
+  it("should export the rule map through the plugin entrypoint", () => {
+    expect(plugin.rules).toBeDefined();
+    expect(plugin.rules?.["graphql-field-config-from-types"]).toBeDefined();
+  });
+});

package/src/rules/graphql/graphql-field-config-from-types.spec.ts

@@ -75,6 +75,24 @@ tester.run("graphql-field-config-from-types", rule, {
         password!: string;
       }
     `,
+    // Configured decorators can be ignored
+    {
+      code: /* typescript */ `
+        @ObjectType()
+        class User {
+          @Internal()
+          @Field(() => String)
+          token!: string;
+        }
+      `,
+      options: [
+        {
+          decorators: {
+            Internal: "ignore" as const,
+          },
+        },
+      ],
+    },
     // Non-GraphQL model class is not checked
     /* typescript */ `
       class NotAGraphQLModel {
@@ -96,6 +114,31 @@ tester.run("graphql-field-config-from-types", rule, {
         query?: string;
       }
     `,
+    // Methods are ignored
+    /* typescript */ `
+      @ObjectType()
+      class User {
+        method() {
+          return "value";
+        }
+      }
+    `,
+    // Properties with no usable type information are skipped
+    /* typescript */ `
+      @ObjectType()
+      class User {
+        @Field(() => String)
+        settings = {};
+      }
+    `,
+    // Computed property names fall back to normal type inference
+    /* typescript */ `
+      @ObjectType()
+      class User {
+        @Field(() => String)
+        ["name"]!: string;
+      }
+    `,
   ],
   invalid: [
     // @Field type mismatch
@@ -238,5 +281,211 @@ tester.run("graphql-field-config-from-types", rule, {
       `,
       errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
     },
+    // Missing @Field decorator should infer scalar type from the property type
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  name!: string;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => String)
+  name!: string;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Missing @Field decorator should add required ID import
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  id!: string;
+}`,
+      output: /* typescript */ `import { ID } from "@nestjs/graphql";
+@ObjectType()
+class User {
+  @Field(() => ID)
+  id!: string;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Existing scalar imports should be reused
+    {
+      code: /* typescript */ `import { ID } from "@nestjs/graphql";
+@ObjectType()
+class User {
+  ownerID!: string;
+}`,
+      output: /* typescript */ `import { ID } from "@nestjs/graphql";
+@ObjectType()
+class User {
+  @Field(() => ID)
+  ownerID!: string;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Record types should use GraphQLJSONObject and add its import
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => String)
+  metadata!: Record<string, unknown>;
+}`,
+      output: /* typescript */ `import { GraphQLJSONObject } from "graphql-type-json";
+@ObjectType()
+class User {
+  @Field(() => GraphQLJSONObject)
+  metadata!: Record<string, unknown>;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Existing GraphQLJSONObject imports should be reused
+    {
+      code: /* typescript */ `import { GraphQLJSONObject } from "graphql-type-json";
+@ObjectType()
+class User {
+  metadata!: Record<string, unknown>;
+}`,
+      output: /* typescript */ `import { GraphQLJSONObject } from "graphql-type-json";
+@ObjectType()
+class User {
+  @Field(() => GraphQLJSONObject)
+  metadata!: Record<string, unknown>;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Ref<T | null> should unwrap the type and mark the field nullable
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  friend!: Ref<User | null>;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => User, { nullable: true })
+  friend!: Ref<User | null>;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Ref<T | undefined> should also mark the field nullable
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  friend!: Ref<User | undefined>;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => User, { nullable: true })
+  friend!: Ref<User | undefined>;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Union types without nullish members use the first concrete type
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  value!: string | number;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => String)
+  value!: string | number;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Undefined unions should be nullable
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  nickname!: string | undefined;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => String, { nullable: true })
+  nickname!: string | undefined;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Array<T> should be emitted as a GraphQL array type
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  tags!: Array<string>;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => [String])
+  tags!: Array<string>;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Bare Array references should still be handled as identifier types
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  values!: Array;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => Array)
+  values!: Array;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Literal initializers should be used when no type annotation exists
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  published = true;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => Boolean)
+  published = true;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Number literal initializers should infer Float
+    {
+      code: /* typescript */ `import { Float } from "@nestjs/graphql";
+@ObjectType()
+class User {
+  score = 1;
+}`,
+      output: /* typescript */ `import { Float } from "@nestjs/graphql";
+@ObjectType()
+class User {
+  @Field(() => Float)
+  score = 1;
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // String literal initializers should infer String
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  title = "hello";
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @Field(() => String)
+  title = "hello";
+}`,
+      errors: [{ messageId: "alignFieldDecoratorWithTsType" }],
+    },
+    // Relation decorators configured for removal should remove @Field
+    {
+      code: /* typescript */ `@ObjectType()
+class User {
+  @HideField()
+  @Field(() => String)
+  password!: string;
+}`,
+      output: /* typescript */ `@ObjectType()
+class User {
+  @HideField()
+  password!: string;
+}`,
+      errors: [{ messageId: "removeFieldDecorator" }],
+    },
   ],
 });

package/src/rules/graphql/graphql-field-config-from-types.ts

@@ -161,7 +161,7 @@ export default createRule<
           baseTypeNode.typeName.name === "Opt")
       ) {
         let inner = baseTypeNode.typeArguments?.params[0] ?? null;
-        if (inner && inner.type === AST_NODE_TYPES.TSUnionType) {
+        if (inner?.type === AST_NODE_TYPES.TSUnionType) {
           const hasNullish = inner.types.some((t: TSESTree.TypeNode) => {
             return (
               t.type === AST_NODE_TYPES.TSNullKeyword ||
@@ -324,16 +324,12 @@ export default createRule<
         callExpr.arguments.length > 0
       ) {
         // If the first argument is an object expression (no type function)
-        if (
-          callExpr.arguments[0] &&
-          callExpr.arguments[0].type === AST_NODE_TYPES.ObjectExpression
-        ) {
+        if (callExpr.arguments[0]?.type === AST_NODE_TYPES.ObjectExpression) {
           optionsArg = callExpr.arguments[0];
         }
         // If the second argument is an object expression (has type function)
         else if (
-          callExpr.arguments[1] &&
-          callExpr.arguments[1].type === AST_NODE_TYPES.ObjectExpression
+          callExpr.arguments[1]?.type === AST_NODE_TYPES.ObjectExpression
         ) {
           optionsArg = callExpr.arguments[1];
         }

package/src/rules/graphql/graphql-field-definite-assignment.spec.ts

@@ -57,6 +57,23 @@ tester.run("graphql-field-definite-assignment", rule, {
         field: string;
       }
     `,
+    // Methods are ignored
+    /* typescript */ `
+      @ObjectType()
+      class User {
+        method() {
+          return "value";
+        }
+      }
+    `,
+    // Computed property names are skipped
+    /* typescript */ `
+      @ObjectType()
+      class User {
+        @Field()
+        ["name"]: string;
+      }
+    `,
   ],
   invalid: [
     // No initializer and no !

package/src/rules/index.spec.ts

@@ -0,0 +1,15 @@
+import { rules } from ".";
+
+describe("rules", () => {
+  it("should expose all packaged rules", () => {
+    expect(Object.keys(rules).sort()).toEqual([
+      "entity-field-definite-assignment",
+      "entity-property-config-from-types",
+      "graphql-field-config-from-types",
+      "graphql-field-definite-assignment",
+      "import-bullmq",
+      "import-graphql",
+      "import-mikro-orm",
+    ]);
+  });
+});

package/src/rules/mikro-orm/entity-field-definite-assignment.spec.ts

@@ -49,6 +49,23 @@ tester.run("entity-field-definite-assignment", rule, {
         field: string;
       }
     `,
+    // Methods are ignored
+    /* typescript */ `
+      @Entity()
+      class User {
+        method() {
+          return "value";
+        }
+      }
+    `,
+    // Computed property names are skipped
+    /* typescript */ `
+      @Entity()
+      class User {
+        @Property()
+        ["name"]: string;
+      }
+    `,
     // @Enum decorator - with !
     /* typescript */ `
       @Entity()