@nest-boot/eslint-plugin 7.0.0-beta.1 → 7.0.0-beta.2

package/src/rules/entity-property-nullable.ts

@@ -1,112 +0,0 @@
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-import { createRule } from "../utils/createRule";
-
-export default createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "实体字段可为空时属性类型",
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      entityPropertyNullable:
-        "@Property({ nullable: true }) 属性类型需包含 null。",
-    },
-  },
-  defaultOptions: [{}],
-  create(context) {
-    return {
-      ClassDeclaration(node) {
-        // 检查是否有 @Entity 装饰器
-        if (
-          node.decorators.some((decorator) => {
-            return (
-              decorator.expression.type === AST_NODE_TYPES.CallExpression &&
-              decorator.expression.callee.type === AST_NODE_TYPES.Identifier &&
-              decorator.expression.callee.name === "Entity"
-            );
-          })
-        ) {
-          // 遍历类属性
-          node.body.body.forEach((property) => {
-            // 检查是否有 @Property() 装饰器
-            if (property.type === AST_NODE_TYPES.PropertyDefinition) {
-              const propertyDecorator = property.decorators.find(
-                (decorator) => {
-                  return (
-                    decorator.expression.type ===
-                      AST_NODE_TYPES.CallExpression &&
-                    decorator.expression.callee.type ===
-                      AST_NODE_TYPES.Identifier &&
-                    decorator.expression.callee.name === "Property"
-                  );
-                },
-              );
-
-              if (typeof propertyDecorator === "undefined") {
-                return;
-              }
-
-              // 检查 @Property() 装饰器 nullable 参数是否为 true
-              if (
-                propertyDecorator.expression.type ===
-                  AST_NODE_TYPES.CallExpression &&
-                propertyDecorator.expression.arguments[0]?.type ===
-                  AST_NODE_TYPES.ObjectExpression &&
-                propertyDecorator.expression.arguments[0]?.properties?.some(
-                  (prop) => {
-                    return (
-                      prop.type === AST_NODE_TYPES.Property &&
-                      prop.key.type === AST_NODE_TYPES.Identifier &&
-                      prop.key.name === "nullable" &&
-                      prop.value.type === AST_NODE_TYPES.Literal &&
-                      prop.value.value === true
-                    );
-                  },
-                )
-              ) {
-                const typeAnnotation = property.typeAnnotation;
-
-                if (typeof typeAnnotation === "undefined") {
-                  return;
-                }
-
-                // 检查属性类型是否包含 null
-                if (
-                  !(
-                    typeAnnotation.type === AST_NODE_TYPES.TSTypeAnnotation &&
-                    typeAnnotation.typeAnnotation.type ===
-                      AST_NODE_TYPES.TSUnionType &&
-                    typeAnnotation.typeAnnotation.types.some(
-                      (type) => type.type === AST_NODE_TYPES.TSNullKeyword,
-                    )
-                  )
-                ) {
-                  context.report({
-                    node: property,
-                    messageId: "entityPropertyNullable",
-                    fix: (fixer) => {
-                      const typeAnnotationStart = typeAnnotation.range[0];
-                      const typeAnnotationEnd = typeAnnotation.range[1];
-                      const originalType =
-                        context.sourceCode.getText(typeAnnotation);
-
-                      return fixer.replaceTextRange(
-                        [typeAnnotationStart, typeAnnotationEnd],
-                        `${originalType} | null${
-                          property.value ? "" : " = null"
-                        }`,
-                      );
-                    },
-                  });
-                }
-              }
-            }
-          });
-        }
-      },
-    };
-  },
-});

package/src/rules/graphql-field-arguments-match-property-type.ts

@@ -1,186 +0,0 @@
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-import { createRule } from "../utils/createRule";
-
-const scalarTypeAlias: Record<string, string> = {
-  Boolean: "boolean",
-  Int: "number",
-  Float: "number",
-  String: "string",
-};
-
-const astTypeAlias: Record<string, string> = {
-  TSBooleanKeyword: "boolean",
-  TSNumberKeyword: "number",
-  TSStringKeyword: "string",
-};
-
-export default createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "@Field() 装饰器参数需要和字段类型相符。",
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      fieldArgumentsMatchPropertyType:
-        "@Field() 装饰器类型需要和字段类型声明相符。",
-      propertyNoExplicitTypeDeclaration:
-        "属性未显式类型声明时 @Field() 装饰器需要提供类型。",
-    },
-  },
-  defaultOptions: [{}],
-  create(context) {
-    return {
-      ClassDeclaration(node) {
-        // 检查是否有 @ObjectType 或者 @InputType 装饰器
-        if (
-          node.decorators.some((decorator) => {
-            return (
-              decorator.expression.type === AST_NODE_TYPES.CallExpression &&
-              decorator.expression.callee.type === AST_NODE_TYPES.Identifier &&
-              ["ObjectType", "InputType"].includes(
-                decorator.expression.callee.name,
-              )
-            );
-          })
-        ) {
-          // 遍历类属性
-          node.body.body.forEach((property) => {
-            // 检查是否有 @Field() 装饰器
-            if (property.type === AST_NODE_TYPES.PropertyDefinition) {
-              const propertyDecorator = property.decorators.find(
-                (decorator) => {
-                  return (
-                    decorator.expression.type ===
-                      AST_NODE_TYPES.CallExpression &&
-                    decorator.expression.callee.type ===
-                      AST_NODE_TYPES.Identifier &&
-                    decorator.expression.callee.name === "Field"
-                  );
-                },
-              );
-
-              if (typeof propertyDecorator === "undefined") {
-                return;
-              }
-
-              // 检查 @Field 装饰器是否声明类型
-              if (
-                propertyDecorator.expression.type ===
-                  AST_NODE_TYPES.CallExpression &&
-                propertyDecorator.expression.arguments[0]?.type !==
-                  AST_NODE_TYPES.ArrowFunctionExpression
-              ) {
-                if (
-                  typeof property.typeAnnotation === "undefined" &&
-                  property.value !== null &&
-                  property.value.type === AST_NODE_TYPES.Literal
-                ) {
-                  const propertyTypeName = typeof property.value.value;
-
-                  const expectedScalarType =
-                    Object.entries(scalarTypeAlias).find(
-                      ([, value]) => value === propertyTypeName,
-                    )?.[0] ?? propertyTypeName;
-
-                  if (typeof expectedScalarType !== "undefined") {
-                    context.report({
-                      node: property,
-                      messageId: "propertyNoExplicitTypeDeclaration",
-                      fix: (fixer) => {
-                        const fixes = [];
-
-                        if (["Int", "Float"].includes(expectedScalarType)) {
-                          fixes.push(
-                            fixer.insertTextBeforeRange(
-                              [0, 0],
-                              `import { ${expectedScalarType} } from "@nestjs/graphql";\n`,
-                            ),
-                          );
-                        }
-
-                        fixes.push(
-                          fixer.replaceText(
-                            propertyDecorator,
-                            `@Field(() => ${expectedScalarType})`,
-                          ),
-                        );
-
-                        return fixes;
-                      },
-                    });
-                  }
-                } else if (
-                  property.typeAnnotation?.type ===
-                    AST_NODE_TYPES.TSTypeAnnotation &&
-                  property.typeAnnotation.typeAnnotation.type ===
-                    AST_NODE_TYPES.TSUnionType
-                ) {
-                  const typeAnnotation =
-                    property.typeAnnotation.typeAnnotation.types.find(
-                      (item) =>
-                        ![
-                          AST_NODE_TYPES.TSNullKeyword,
-                          AST_NODE_TYPES.TSUndefinedKeyword,
-                        ].includes(item.type),
-                    );
-
-                  if (typeof typeAnnotation !== "undefined") {
-                    const propertyTypeAnnotationHasNullType =
-                      property.typeAnnotation.typeAnnotation.types.some(
-                        (item) => item.type === AST_NODE_TYPES.TSNullKeyword,
-                      );
-
-                    const propertyTypeName =
-                      astTypeAlias[typeAnnotation.type] ??
-                      (typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
-                      typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier
-                        ? typeAnnotation.typeName.name
-                        : typeAnnotation.type);
-
-                    const expectedScalarType =
-                      Object.entries(scalarTypeAlias).find(
-                        ([, value]) => value === propertyTypeName,
-                      )?.[0] ?? propertyTypeName;
-
-                    context.report({
-                      node: property,
-                      messageId: "fieldArgumentsMatchPropertyType",
-                      fix: (fixer) => {
-                        const fixes = [];
-
-                        if (["Int", "Float"].includes(expectedScalarType)) {
-                          fixes.push(
-                            fixer.insertTextBeforeRange(
-                              [0, 0],
-                              `import { ${expectedScalarType} } from "@nestjs/graphql";\n`,
-                            ),
-                          );
-                        }
-
-                        fixes.push(
-                          fixer.replaceText(
-                            propertyDecorator,
-                            `@Field(() => ${expectedScalarType}${
-                              propertyTypeAnnotationHasNullType
-                                ? ", { nullable: true }"
-                                : ""
-                            })`,
-                          ),
-                        );
-
-                        return fixes;
-                      },
-                    });
-                  }
-                }
-              }
-            }
-          });
-        }
-      },
-    };
-  },
-});

package/src/rules/graphql-resolver-method-return-type.ts

@@ -1,207 +0,0 @@
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-import { createRule } from "../utils/createRule";
-
-const scalarTypeAlias: Record<string, string> = {
-  Boolean: "boolean",
-  Int: "number",
-  Float: "number",
-  String: "string",
-};
-
-const astTypeAlias: Record<string, string> = {
-  TSBooleanKeyword: "boolean",
-  TSNumberKeyword: "number",
-  TSStringKeyword: "string",
-};
-
-export default createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "GraphQL 解决器的方法装饰器类型需要和返回类型需要一致",
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      resolveMethodReturnType: "解决器的方法装饰器类型需要和返回类型需要一致",
-    },
-  },
-  defaultOptions: [{}],
-  create(context) {
-    return {
-      ClassDeclaration(node) {
-        // 检查是否有 @Resolver 装饰器
-        if (
-          node.decorators.some((decorator) => {
-            return (
-              decorator.expression.type === AST_NODE_TYPES.CallExpression &&
-              decorator.expression.callee.type === AST_NODE_TYPES.Identifier &&
-              decorator.expression.callee.name === "Resolver"
-            );
-          })
-        ) {
-          // 遍历类属性
-          node.body.body.forEach((method) => {
-            // 仅检查方法
-            if (method.type === AST_NODE_TYPES.MethodDefinition) {
-              const isAsync = method.value.async;
-
-              const methodDecorator = method.decorators.find((decorator) => {
-                return (
-                  decorator.expression.type === AST_NODE_TYPES.CallExpression &&
-                  decorator.expression.callee.type ===
-                    AST_NODE_TYPES.Identifier &&
-                  ["Query", "Mutation", "ResolveField"].includes(
-                    decorator.expression.callee.name,
-                  )
-                );
-              });
-
-              // 检查是否有 @Query, @Mutation, @ResolveField 装饰器
-              if (typeof methodDecorator === "undefined") {
-                return;
-              }
-
-              const methodDecoratorExpression = methodDecorator.expression;
-
-              if (
-                methodDecoratorExpression.type ===
-                  AST_NODE_TYPES.CallExpression &&
-                methodDecoratorExpression.arguments[0]?.type ===
-                  AST_NODE_TYPES.ArrowFunctionExpression
-              ) {
-                let actualReturnTypeAnnotation =
-                  method.value.returnType?.typeAnnotation ?? null;
-                const expectedReturnTypeFunctionBody =
-                  methodDecoratorExpression.arguments[0].body;
-
-                const isNullable =
-                  methodDecoratorExpression.arguments[1]?.type ===
-                    AST_NODE_TYPES.ObjectExpression &&
-                  methodDecoratorExpression.arguments[1]?.properties?.some(
-                    (prop) => {
-                      return (
-                        prop.type === AST_NODE_TYPES.Property &&
-                        prop.key.type === AST_NODE_TYPES.Identifier &&
-                        prop.key.name === "nullable" &&
-                        prop.value.type === AST_NODE_TYPES.Literal &&
-                        prop.value.value === true
-                      );
-                    },
-                  );
-
-                // 如果没有定义返回类型，或者返回类型不是标识符，跳过检查
-                if (
-                  typeof expectedReturnTypeFunctionBody === "undefined" ||
-                  expectedReturnTypeFunctionBody.type !==
-                    AST_NODE_TYPES.Identifier
-                ) {
-                  return;
-                }
-
-                // 获取期望返回类型
-                const expectedReturnType =
-                  scalarTypeAlias[expectedReturnTypeFunctionBody.name] ??
-                  expectedReturnTypeFunctionBody.name;
-
-                // 获取实际返回类型
-                let actualReturnType: string | null = null;
-                let actualHasPromise = false;
-                let actualHasNullable = false;
-
-                if (
-                  actualReturnTypeAnnotation?.type ===
-                    AST_NODE_TYPES.TSTypeReference &&
-                  actualReturnTypeAnnotation.typeName.type ===
-                    AST_NODE_TYPES.Identifier &&
-                  actualReturnTypeAnnotation.typeName.name === "Promise"
-                ) {
-                  actualHasPromise = true;
-                  actualReturnTypeAnnotation =
-                    actualReturnTypeAnnotation.typeArguments?.params[0] ?? null;
-                }
-
-                if (
-                  actualReturnTypeAnnotation?.type ===
-                  AST_NODE_TYPES.TSUnionType
-                ) {
-                  actualHasNullable = actualReturnTypeAnnotation.types.some(
-                    ({ type }) => type === AST_NODE_TYPES.TSNullKeyword,
-                  );
-
-                  actualReturnTypeAnnotation =
-                    actualReturnTypeAnnotation.types.find(
-                      ({ type }) => type !== AST_NODE_TYPES.TSNullKeyword,
-                    ) ?? null;
-                }
-
-                if (actualReturnTypeAnnotation !== null) {
-                  actualReturnType =
-                    astTypeAlias[actualReturnTypeAnnotation.type] ??
-                    (actualReturnTypeAnnotation.type ===
-                      AST_NODE_TYPES.TSTypeReference &&
-                    actualReturnTypeAnnotation.typeName.type ===
-                      AST_NODE_TYPES.Identifier
-                      ? actualReturnTypeAnnotation.typeName.name
-                      : actualReturnTypeAnnotation.type);
-                }
-
-                // 如果期望返回类型和实际返回类型不一致，则报告错误。
-                if (
-                  expectedReturnType !== actualReturnType ||
-                  isNullable !== actualHasNullable ||
-                  isAsync !== actualHasPromise
-                ) {
-                  context.report({
-                    node: method,
-                    messageId: "resolveMethodReturnType",
-                    fix: (fixer) => {
-                      const fixes = [];
-
-                      let returnTypeString = expectedReturnType;
-
-                      if (isNullable) {
-                        returnTypeString += " | null";
-                      }
-
-                      if (isAsync) {
-                        returnTypeString = `Promise<${returnTypeString}>`;
-                      }
-
-                      if (
-                        typeof method.value.returnType === "undefined" ||
-                        actualReturnType === null
-                      ) {
-                        if (
-                          method.value.type ===
-                          AST_NODE_TYPES.FunctionExpression
-                        ) {
-                          fixes.push(
-                            fixer.insertTextBefore(
-                              method.value.body,
-                              `: ${returnTypeString} `,
-                            ),
-                          );
-                        }
-                      } else {
-                        fixes.push(
-                          fixer.replaceText(
-                            method.value.returnType.typeAnnotation,
-                            returnTypeString,
-                          ),
-                        );
-                      }
-
-                      return fixes;
-                    },
-                  });
-                }
-              }
-            }
-          });
-        }
-      },
-    };
-  },
-});