@nest-boot/eslint-plugin 7.0.4 → 7.0.5

package/dist/rules/mikro-orm/entity-property-config-from-types.js

@@ -42,16 +42,16 @@ exports.default = (0, createRule_1.createRule)({
     meta: {
         type: "problem",
         docs: {
-            description: "根据 TypeScript 类型自动生成或修正 @Property 装饰器的类型与 nullable 配置（支持数组）,以及 @Enum 装饰器的 nullable 配置。检查有初始化值的属性是否使用 Opt<T> 类型。",
+            description: "Automatically generate or fix @Property decorator type and nullable configuration based on TypeScript types (with array support), as well as @Enum decorator nullable configuration. Checks whether properties with initializers use the Opt<T> type.",
         },
         fixable: "code",
         schema: [],
         messages: {
-            alignPropertyDecoratorWithTsType: "@Property 装饰器应与 TypeScript 类型保持一致（类型与 nullable）。",
-            removePropertyDecorator: "属性带有 @{{decoratorName}} 装饰器，应移除 @Property 装饰器。",
-            useEnumDecorator: "枚举类型应使用 @Enum 装饰器而不是 @Property 装饰器。",
-            useOptTypeForInitializedProperty: "有非 null 初始化值的属性应使用 Opt<T> 类型包装。",
-            removeOptTypeForNonInitializedProperty: "没有初始化值或初始化为 null 的属性不应使用 Opt<T> 类型包装。",
+            alignPropertyDecoratorWithTsType: "@Property decorator should align with the TypeScript type (type and nullable).",
+            removePropertyDecorator: "Property has a @{{decoratorName}} decorator, @Property decorator should be removed.",
+            useEnumDecorator: "Enum types should use @Enum decorator instead of @Property decorator.",
+            useOptTypeForInitializedProperty: "Properties with non-null initializers should use the Opt<T> type wrapper.",
+            removeOptTypeForNonInitializedProperty: "Properties without initializers or initialized to null should not use the Opt<T> type wrapper.",
         },
     },
     defaultOptions: [],
@@ -59,16 +59,16 @@ exports.default = (0, createRule_1.createRule)({
         const source = context.sourceCode;
         const parserServices = utils_1.ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
-        // 检查是否为枚举类型
+        // Check if the type is an enum
         const isEnumType = (node) => {
             try {
                 const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
                 const type = checker.getTypeAtLocation(tsNode);
-                // 检查是否是枚举类型
+                // Check if it is an enum type
                 if (type.symbol.flags & ts.SymbolFlags.Enum) {
                     return true;
                 }
-                // 检查联合类型中的每个成员
+                // Check each member in a union type
                 if (type.isUnion()) {
                     return type.types.some((t) => t.symbol.flags & ts.SymbolFlags.EnumMember ||
                         t.symbol.flags & ts.SymbolFlags.Enum);
@@ -85,15 +85,15 @@ exports.default = (0, createRule_1.createRule)({
             switch (typeName) {
                 case "String":
                 case "string":
-                    return "t.string"; // 默认使用 t.string
+                    return "t.string"; // Default to t.string
                 case "Number":
                 case "number":
-                    return "t.float"; // 默认使用 t.float
+                    return "t.float"; // Default to t.float
                 case "Boolean":
                 case "boolean":
-                    return "t.boolean"; // 默认使用 t.boolean
+                    return "t.boolean"; // Default to t.boolean
                 case "Date":
-                    return "t.datetime"; // 默认使用 t.datetime
+                    return "t.datetime"; // Default to t.datetime
                 case "GraphQLJSONObject":
                 case "Record":
                     return "t.json";
@@ -104,7 +104,7 @@ exports.default = (0, createRule_1.createRule)({
         const isValidStringType = (typeConfig) => {
             if (!typeConfig)
                 return false;
-            // 接受 t.string, t.text, t.uuid, t.decimal, t.bigint
+            // Accept t.string, t.text, t.uuid, t.decimal, t.bigint
             if (typeConfig === "t.string" ||
                 typeConfig === "t.text" ||
                 typeConfig === "t.uuid" ||
@@ -112,20 +112,20 @@ exports.default = (0, createRule_1.createRule)({
                 typeConfig === "t.bigint") {
                 return true;
             }
-            // 接受 DecimalType（类引用，不带参数）
+            // Accept DecimalType (class reference, without arguments)
             if (typeConfig === "DecimalType") {
                 return true;
             }
-            // 接受 new DecimalType('string') 和 new BigIntType('string')
-            // 但排除 new BigIntType('number')
+            // Accept new DecimalType('string') and new BigIntType('string')
+            // but exclude new BigIntType('number')
             if (typeConfig.includes("DecimalType") ||
                 typeConfig.includes("BigIntType")) {
-                // 如果是 new BigIntType('number')，则无效
+                // If it's new BigIntType('number'), it's invalid
                 if (typeConfig.includes("BigIntType") &&
                     (typeConfig.includes("'number'") || typeConfig.includes('"number"'))) {
                     return false;
                 }
-                // 其他情况（包括 new XXXType('string') 和 DecimalType）都有效
+                // Other cases (including new XXXType('string') and DecimalType) are valid
                 return true;
             }
             return false;
@@ -133,27 +133,27 @@ exports.default = (0, createRule_1.createRule)({
         const isValidNumberType = (typeConfig) => {
             if (!typeConfig)
                 return false;
-            // 接受 t.integer, t.float, t.double, t.decimal
+            // Accept t.integer, t.float, t.double, t.decimal
             if (typeConfig === "t.integer" ||
                 typeConfig === "t.float" ||
                 typeConfig === "t.double" ||
                 typeConfig === "t.decimal") {
                 return true;
             }
-            // 接受 BigIntType 和 DecimalType（类引用，不带参数）
+            // Accept BigIntType and DecimalType (class reference, without arguments)
             if (typeConfig === "BigIntType" || typeConfig === "DecimalType") {
                 return true;
             }
-            // 接受 new DecimalType('number') 和 new BigIntType('number')
-            // 但排除 new XXXType('string')
+            // Accept new DecimalType('number') and new BigIntType('number')
+            // but exclude new XXXType('string')
             if (typeConfig.includes("DecimalType") ||
                 typeConfig.includes("BigIntType")) {
-                // 如果包含 'string'，则对 number 类型无效
+                // If it contains 'string', it's invalid for number type
                 if (typeConfig.includes("'string'") ||
                     typeConfig.includes('"string"')) {
                     return false;
                 }
-                // 其他情况（包括 new XXXType('number')）都有效
+                // Other cases (including new XXXType('number')) are valid
                 return true;
             }
             return false;
@@ -161,15 +161,15 @@ exports.default = (0, createRule_1.createRule)({
         const isValidNumberArrayType = (typeConfig) => {
             if (!typeConfig)
                 return false;
-            // 接受 t.array（默认）
+            // Accept t.array (default)
             if (typeConfig === "t.array") {
                 return true;
             }
-            // 接受 VectorType（类引用）
+            // Accept VectorType (class reference)
             if (typeConfig === "VectorType") {
                 return true;
             }
-            // 接受 new VectorType(...)
+            // Accept new VectorType(...)
             if (typeConfig.includes("VectorType")) {
                 return true;
             }
@@ -178,7 +178,7 @@ exports.default = (0, createRule_1.createRule)({
         const isValidDateType = (typeConfig) => {
             if (!typeConfig)
                 return false;
-            // 接受 t.datetime, t.date, t.time
+            // Accept t.datetime, t.date, t.time
             if (typeConfig === "t.datetime" ||
                 typeConfig === "t.date" ||
                 typeConfig === "t.time") {
@@ -209,7 +209,7 @@ exports.default = (0, createRule_1.createRule)({
                 node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.typeName.name === "Collection");
         };
-        // 检查类型是否被 Opt<T> 包装
+        // Check if the type is wrapped with Opt<T>
         const isWrappedWithOpt = (property) => {
             const typeAnnotation = property.typeAnnotation;
             if (typeAnnotation?.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
@@ -220,13 +220,13 @@ exports.default = (0, createRule_1.createRule)({
                 typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                 typeNode.typeName.name === "Opt");
         };
-        // 检查是否已导入 Opt
+        // Check if Opt is imported
         const hasOptImport = () => {
             const program = context.sourceCode.ast;
             for (const statement of program.body) {
                 if (statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
                     const importSource = statement.source.value;
-                    // 检查从 @mikro-orm/* 导入的语句
+                    // Check imports from @mikro-orm/*
                     if (typeof importSource === "string" &&
                         importSource.startsWith("@mikro-orm/")) {
                         const hasOpt = statement.specifiers.some((spec) => {
@@ -241,10 +241,10 @@ exports.default = (0, createRule_1.createRule)({
             }
             return false;
         };
-        // 添加 Opt 到 @mikro-orm/core 的导入
+        // Add Opt to the @mikro-orm/core import
         const addOptImport = (fixer) => {
             const program = context.sourceCode.ast;
-            // 查找 @mikro-orm/core 的导入语句
+            // Find the @mikro-orm/core import statement
             let coreImport = null;
             for (const statement of program.body) {
                 if (statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
@@ -256,23 +256,23 @@ exports.default = (0, createRule_1.createRule)({
                 }
             }
             if (coreImport) {
-                // 已有 @mikro-orm/core 导入,添加 Opt 到导入列表
+                // Already has @mikro-orm/core import, add Opt to the import list
                 const lastSpecifier = coreImport.specifiers[coreImport.specifiers.length - 1];
-                // 检查是否是多行导入
+                // Check if it's a multiline import
                 const importText = source.getText(coreImport);
                 const isMultiline = importText.includes("\n");
                 if (isMultiline) {
-                    // 多行导入:在最后一个导入项后添加,保持缩进
-                    const indent = "  "; // 假设使用 2 个空格缩进
+                    // Multiline import: add after the last import item, keeping indentation
+                    const indent = "  "; // Assuming 2-space indentation
                     return fixer.insertTextAfter(lastSpecifier, `,\n${indent}Opt`);
                 }
                 else {
-                    // 单行导入:直接添加
+                    // Single-line import: add directly
                     return fixer.insertTextAfter(lastSpecifier, ", Opt");
                 }
             }
             else {
-                // 没有 @mikro-orm/core 导入,在文件开头添加新的导入语句
+                // No @mikro-orm/core import, add a new import statement at the top
                 const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
                 if (firstImport) {
                     return fixer.insertTextBefore(firstImport, "import { Opt } from '@mikro-orm/core';\n");
@@ -287,11 +287,11 @@ exports.default = (0, createRule_1.createRule)({
             let baseTypeNode = property.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation
                 ? property.typeAnnotation.typeAnnotation
                 : null;
-            // 可选属性（?）视为可空
+            // Optional property (?) is treated as nullable
             if (property.optional) {
                 isNullable = true;
             }
-            // 处理联合类型中的 null/undefined
+            // Handle null/undefined in union types
             if (baseTypeNode?.type === utils_1.AST_NODE_TYPES.TSUnionType) {
                 const hasNullish = baseTypeNode.types.some((t) => {
                     return (t.type === utils_1.AST_NODE_TYPES.TSNullKeyword ||
@@ -305,7 +305,7 @@ exports.default = (0, createRule_1.createRule)({
                             t.type !== utils_1.AST_NODE_TYPES.TSUndefinedKeyword);
                     }) ?? null;
             }
-            // 先解包 Ref<T> 和 Opt<T> → T，并在内部再次处理 null/undefined
+            // First unwrap Ref<T> and Opt<T> → T, and handle null/undefined within
             if (baseTypeNode?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                 baseTypeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                 (baseTypeNode.typeName.name === "Ref" ||
@@ -326,11 +326,11 @@ exports.default = (0, createRule_1.createRule)({
                 }
                 baseTypeNode = inner ?? baseTypeNode;
             }
-            // 跳过 Collection<T> 类型（这些应该由 OneToMany 等装饰器处理）
+            // Skip Collection<T> types (these should be handled by OneToMany etc. decorators)
             if (baseTypeNode && isCollectionType(baseTypeNode)) {
                 return null;
             }
-            // 数组类型（T[] 或 Array<T>）- 在解包 Opt/Ref 之后检查
+            // Array type (T[] or Array<T>) - checked after unwrapping Opt/Ref
             const elementTypeNode = baseTypeNode
                 ? extractArrayElementType(baseTypeNode)
                 : null;
@@ -338,11 +338,11 @@ exports.default = (0, createRule_1.createRule)({
                 isArray = true;
             }
             const targetTypeNode = elementTypeNode ?? baseTypeNode;
-            // 检查目标类型是否为枚举
+            // Check if target type is an enum
             if (targetTypeNode) {
                 isEnum = isEnumType(targetTypeNode);
             }
-            // 无显式类型时，尝试从字面量初始值推断
+            // When no explicit type, try to infer from literal initializer
             if (!targetTypeNode) {
                 if (property.value?.type === utils_1.AST_NODE_TYPES.Literal) {
                     const value = property.value.value;
@@ -390,7 +390,7 @@ exports.default = (0, createRule_1.createRule)({
                     arrayElementTypeName: isArray ? "Record" : undefined,
                 };
             }
-            // 关键字类型
+            // Keyword types
             if (targetTypeNode.type === utils_1.AST_NODE_TYPES.TSStringKeyword) {
                 return {
                     typeName: "string",
@@ -421,10 +421,10 @@ exports.default = (0, createRule_1.createRule)({
                     arrayElementTypeName: isArray ? "boolean" : undefined,
                 };
             }
-            // 标识符（类/自定义类型）
+            // Identifier (class/custom type)
             const ident = getIdentifierName(targetTypeNode);
             if (ident) {
-                // 如果是数组，自定义类型数组使用 t.json
+                // For arrays, custom type arrays use t.json
                 if (isArray) {
                     return {
                         typeName: ident,
@@ -446,7 +446,7 @@ exports.default = (0, createRule_1.createRule)({
             }
             return null;
         };
-        // 将类型包装为 Opt<T>
+        // Wrap type with Opt<T>
         const wrapWithOpt = (typeString) => {
             return `Opt<${typeString}>`;
         };
@@ -465,11 +465,11 @@ exports.default = (0, createRule_1.createRule)({
         };
         const buildPropertyDecorator = (info, otherProps = [], decoratorName = "Property") => {
             const options = [];
-            // 如果有 propertyType 配置，添加 type
+            // If there is a propertyType configuration, add type
             if (info.propertyType) {
                 options.push(`type: ${info.propertyType}`);
             }
-            // 添加其他属性（保持原有顺序）
+            // Add other properties (keeping original order)
             for (const prop of otherProps) {
                 options.push(`${prop.key}: ${prop.value}`);
             }
@@ -493,36 +493,36 @@ exports.default = (0, createRule_1.createRule)({
         };
         const fixWithTypeInfo = (property, propertyDecorator, info, currentConfig, decoratorName = "Property") => {
             const fixes = [];
-            // 如果当前已经有有效的配置，保留它而不是替换成默认值
+            // If current config already has a valid value, keep it instead of replacing with default
             const finalInfo = { ...info };
-            // PrimaryKey 的 number 类型默认使用 t.integer
+            // PrimaryKey number type defaults to t.integer
             if (decoratorName === "PrimaryKey" &&
                 finalInfo.propertyType === "t.float") {
                 finalInfo.propertyType = "t.integer";
             }
             if (info.propertyType === "t.string" &&
                 isValidStringType(currentConfig.type)) {
-                // 保留有效的 string 类型配置
+                // Keep valid string type config
                 finalInfo.propertyType = currentConfig.type;
             }
             else if ((info.propertyType === "t.float" ||
                 info.propertyType === "t.integer") &&
                 isValidNumberType(currentConfig.type)) {
-                // 保留有效的 number 类型配置
+                // Keep valid number type config
                 finalInfo.propertyType = currentConfig.type;
             }
             else if (info.propertyType === "t.datetime" &&
                 isValidDateType(currentConfig.type)) {
-                // 保留有效的 Date 类型配置
+                // Keep valid Date type config
                 finalInfo.propertyType = currentConfig.type;
             }
             else if (info.isArray &&
                 info.arrayElementTypeName === "number" &&
                 isValidNumberArrayType(currentConfig.type)) {
-                // 保留有效的 number[] 类型配置（VectorType）
+                // Keep valid number[] type config (VectorType)
                 finalInfo.propertyType = currentConfig.type;
             }
-            // 保留其他属性配置
+            // Keep other property configs
             const newDecoratorText = buildPropertyDecorator(finalInfo, currentConfig.otherProps, decoratorName);
             fixes.push({
                 type: "replace",
@@ -572,7 +572,7 @@ exports.default = (0, createRule_1.createRule)({
                     }
                 }
                 else {
-                    // 保留其他所有属性
+                    // Keep all other properties
                     otherProps.push({
                         key: prop.key.name,
                         value: source.getText(prop.value),
@@ -610,38 +610,38 @@ exports.default = (0, createRule_1.createRule)({
             }
             return { items, nullable };
         };
-        // 检查文件中是否使用了 Opt 类型但没有导入
+        // Check if the file uses the Opt type but hasn't imported it
         const checkOptUsageWithoutImport = (node) => {
             let usesOpt = false;
-            // 遍历所有成员，检查是否有使用 Opt<T> 的类型注解
+            // Iterate through all members to check for Opt<T> type annotations
             node.body.body.forEach((member) => {
                 if (member.type !== utils_1.AST_NODE_TYPES.PropertyDefinition)
                     return;
                 const typeAnnotation = member.typeAnnotation?.typeAnnotation;
                 if (!typeAnnotation)
                     return;
-                // 递归检查类型节点中是否包含 Opt
+                // Recursively check if the type node contains Opt
                 const containsOpt = (typeNode) => {
                     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                     if (!typeNode)
                         return false;
-                    // 检查是否是 Opt<T>
+                    // Check if it's Opt<T>
                     if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                         typeNode.typeName?.type === utils_1.AST_NODE_TYPES.Identifier &&
                         typeNode.typeName.name === "Opt") {
                         return true;
                     }
-                    // 递归检查联合类型
+                    // Recursively check union types
                     if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) {
                         return typeNode.types.some((t) => containsOpt(t));
                     }
-                    // 递归检查类型参数
+                    // Recursively check type parameters
                     if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                         typeNode.typeArguments?.params) {
                         return typeNode.typeArguments.params.some((param) => containsOpt(param));
                     }
-                    // 递归检查数组元素类型
+                    // Recursively check array element type
                     if (typeNode.type === utils_1.AST_NODE_TYPES.TSArrayType) {
                         return containsOpt(typeNode.elementType);
                     }
@@ -651,7 +651,7 @@ exports.default = (0, createRule_1.createRule)({
                     usesOpt = true;
                 }
             });
-            // 如果使用了 Opt 但没有导入，报告错误
+            // If Opt is used but not imported, report an error
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             if (usesOpt && !hasOptImport()) {
                 context.report({
@@ -668,12 +668,12 @@ exports.default = (0, createRule_1.createRule)({
             ClassDeclaration(node) {
                 if (!isEntityClass(node))
                     return;
-                // 首先检查是否使用了 Opt 但没有导入
+                // First check if Opt is used but not imported
                 checkOptUsageWithoutImport(node);
                 node.body.body.forEach((member) => {
                     if (member.type !== utils_1.AST_NODE_TYPES.PropertyDefinition)
                         return;
-                    // 检查关系装饰器（OneToOne, OneToMany, ManyToOne, ManyToMany）
+                    // Check relation decorators (OneToOne, OneToMany, ManyToOne, ManyToMany)
                     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                     const hasRelationDecorator = member.decorators?.some((decorator) => {
                         if (decorator.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -688,17 +688,17 @@ exports.default = (0, createRule_1.createRule)({
                         }
                         return false;
                     });
-                    // 如果有关系装饰器，跳过检查（这些属性不需要 @Property 装饰器）
+                    // If there are relation decorators, skip checking (these properties don't need @Property)
                     if (hasRelationDecorator)
                         return;
-                    // 类 Property 装饰器列表（需要类型检查的装饰器）
+                    // Property-like decorators (decorators that need type checking)
                     const propertyLikeDecorators = [
                         "Property",
                         "PrimaryKey",
                         "EncryptedProperty",
                         "HashedProperty",
                     ];
-                    // 查找类 Property 装饰器
+                    // Find property-like decorator
                     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                     const propertyLikeDecorator = member.decorators?.find((decorator) => {
                         if (decorator.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -707,7 +707,7 @@ exports.default = (0, createRule_1.createRule)({
                         }
                         return false;
                     });
-                    // 获取装饰器名称
+                    // Get decorator name
                     const getDecoratorName = (decorator) => {
                         if (decorator.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
                             decorator.expression.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -715,7 +715,7 @@ exports.default = (0, createRule_1.createRule)({
                         }
                         return null;
                     };
-                    // 检查 @Enum 装饰器
+                    // Check @Enum decorator
                     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                     const enumDecorator = member.decorators?.find((decorator) => {
                         return (decorator.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -723,7 +723,7 @@ exports.default = (0, createRule_1.createRule)({
                                 utils_1.AST_NODE_TYPES.Identifier &&
                             decorator.expression.callee.name === "Enum");
                     });
-                    // 使用类 Property 装饰器
+                    // Use property-like decorator
                     const propertyDecorator = propertyLikeDecorator;
                     const currentDecoratorName = propertyDecorator
                         ? getDecoratorName(propertyDecorator)
@@ -731,20 +731,20 @@ exports.default = (0, createRule_1.createRule)({
                     const typeInfo = computeTypeInfo(member);
                     if (!typeInfo?.typeName)
                         return;
-                    // 检查初始化值和 Opt<T> 类型的匹配
+                    // Check initializer and Opt<T> type match
                     const hasInitializer = member.value !== null;
                     const isOptWrapped = isWrappedWithOpt(member);
-                    // 检查初始化值是否为 null
+                    // Check if the initializer is null
                     const isInitializedToNull = hasInitializer &&
                         member.value?.type === utils_1.AST_NODE_TYPES.Literal &&
                         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                         member.value?.value === null;
-                    // 情况 1：有非 null 初始化值但没有使用 Opt<T>
+                    // Case 1: Has non-null initializer but not wrapped with Opt<T>
                     if (hasInitializer &&
                         !isInitializedToNull &&
                         !isOptWrapped &&
                         !member.optional) {
-                        // 有初始化值但没有使用 Opt<T> 包装，需要报错
+                        // Has initializer but not wrapped with Opt<T>, needs to report error
                         const typeAnnotation = member.typeAnnotation?.typeAnnotation;
                         const needsImport = !hasOptImport();
                         if (typeAnnotation) {
@@ -757,7 +757,7 @@ exports.default = (0, createRule_1.createRule)({
                                     const fixes = [
                                         fixer.replaceText(typeAnnotation, wrappedType),
                                     ];
-                                    // 如果需要，添加 Opt 导入
+                                    // If needed, add Opt import
                                     if (needsImport) {
                                         const importFix = addOptImport(fixer);
                                         if (importFix)
@@ -768,7 +768,7 @@ exports.default = (0, createRule_1.createRule)({
                             });
                         }
                         else if (member.value) {
-                            // 没有类型注解，从初始化值推断类型
+                            // No type annotation, infer type from initializer
                             let inferredType = null;
                             if (member.value.type === utils_1.AST_NODE_TYPES.Literal) {
                                 const valueType = typeof member.value.value;
@@ -780,11 +780,11 @@ exports.default = (0, createRule_1.createRule)({
                                     inferredType = "string";
                             }
                             else if (member.value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                                // 空数组 [] 的情况,需要从 @Property 装饰器推断类型
+                                // Empty array [] case, need to infer type from @Property decorator
                                 inferredType = "unknown[]";
                             }
                             else if (member.value.type === utils_1.AST_NODE_TYPES.NewExpression) {
-                                // new Date() 的情况
+                                // new Date() case
                                 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                                 if (member.value.callee?.type === utils_1.AST_NODE_TYPES.Identifier) {
                                     inferredType = member.value.callee.name;
@@ -800,7 +800,7 @@ exports.default = (0, createRule_1.createRule)({
                                         const fixes = [
                                             fixer.insertTextAfter(propertyName, `: ${wrappedType}`),
                                         ];
-                                        // 如果需要，添加 Opt 导入
+                                        // If needed, add Opt import
                                         if (needsImport) {
                                             const importFix = addOptImport(fixer);
                                             if (importFix)
@@ -812,10 +812,10 @@ exports.default = (0, createRule_1.createRule)({
                             }
                         }
                     }
-                    // 如果有 @Enum 装饰器，无论是否识别为枚举类型，都检查其配置
+                    // If there is an @Enum decorator, check its configuration regardless of whether the type is recognized as enum
                     if (enumDecorator) {
                         const enumConfig = parseEnumDecorator(enumDecorator);
-                        // 检查 nullable 配置是否与 TypeScript 类型匹配
+                        // Check if nullable configuration matches the TypeScript type
                         if (enumConfig.nullable !== typeInfo.isNullable) {
                             const expectedEnumText = buildEnumDecorator(typeInfo);
                             context.report({
@@ -826,12 +826,12 @@ exports.default = (0, createRule_1.createRule)({
                                 },
                             });
                         }
-                        // 有 @Enum 装饰器的属性，不需要 @Property 装饰器
+                        // Properties with @Enum decorator do not need @Property decorator
                         return;
                     }
-                    // 如果是枚举类型但没有 @Enum 装饰器
+                    // If it's an enum type but doesn't have @Enum decorator
                     if (typeInfo.isEnum) {
-                        // 如果有 @Property 装饰器，建议替换为 @Enum
+                        // If it has @Property decorator, suggest replacing with @Enum
                         if (propertyDecorator) {
                             context.report({
                                 node: propertyDecorator,
@@ -843,7 +843,7 @@ exports.default = (0, createRule_1.createRule)({
                             });
                             return;
                         }
-                        // 如果没有 @Enum 装饰器，添加它
+                        // If it doesn't have @Enum decorator, add one
                         context.report({
                             node: member,
                             messageId: "useEnumDecorator",
@@ -854,7 +854,7 @@ exports.default = (0, createRule_1.createRule)({
                         });
                         return;
                     }
-                    // 非枚举类型：如果没有 @Property 装饰器，添加它
+                    // Non-enum type: if no @Property decorator, add one
                     if (!propertyDecorator) {
                         context.report({
                             node: member,
@@ -866,39 +866,39 @@ exports.default = (0, createRule_1.createRule)({
                         });
                         return;
                     }
-                    // 检查现有装饰器是否与类型匹配
+                    // Check if existing decorator matches the type
                     const currentConfig = parsePropertyDecorator(propertyDecorator);
                     let expectedType = typeInfo.propertyType;
-                    // PrimaryKey 的 number 类型期望 t.integer
+                    // PrimaryKey number type expects t.integer
                     if (currentDecoratorName === "PrimaryKey" &&
                         expectedType === "t.float") {
                         expectedType = "t.integer";
                     }
                     let needReport = false;
-                    // 检查 type 配置
+                    // Check type configuration
                     if (expectedType && currentConfig.type !== expectedType) {
-                        // 对于 string 类型，接受多种有效配置
+                        // For string type, accept multiple valid configurations
                         if (expectedType === "t.string" &&
                             isValidStringType(currentConfig.type)) {
-                            // 当前配置是有效的 string 类型配置，不需要修改
+                            // Current config is a valid string type configuration, no modification needed
                         }
                         else if ((expectedType === "t.float" || expectedType === "t.integer") &&
                             isValidNumberType(currentConfig.type)) {
-                            // 当前配置是有效的 number 类型配置，不需要修改
+                            // Current config is a valid number type configuration, no modification needed
                         }
                         else if (expectedType === "t.datetime" &&
                             isValidDateType(currentConfig.type)) {
-                            // 当前配置是有效的 Date 类型配置，不需要修改
+                            // Current config is a valid Date type configuration, no modification needed
                         }
                         else if (expectedType === "t.array" &&
                             typeInfo.arrayElementTypeName === "number" &&
                             isValidNumberArrayType(currentConfig.type)) {
-                            // 当前配置是有效的 number[] 类型配置（t.array 或 VectorType），不需要修改
+                            // Current config is a valid number[] type configuration (t.array or VectorType), no modification needed
                         }
                         else if (expectedType === "t.json") {
-                            // 对于 t.json 类型（Record 或自定义类型数组）
+                            // For t.json type (Record or custom type arrays)
                             if (currentConfig.type === "t.json") {
-                                // t.json 配置正确，不需要修改
+                                // t.json config is correct, no modification needed
                             }
                             else {
                                 needReport = true;
@@ -909,10 +909,10 @@ exports.default = (0, createRule_1.createRule)({
                         }
                     }
                     else if (!expectedType && currentConfig.type) {
-                        // 如果不需要 type 但当前有 type，也需要修正
+                        // If type is not needed but currently has one, needs correction
                         needReport = true;
                     }
-                    // 检查 nullable 配置
+                    // Check nullable configuration
                     if (currentConfig.nullable !== typeInfo.isNullable) {
                         needReport = true;
                     }