@lark-apaas/fullstack-presets 1.1.25 → 1.1.26-alpha.20261002143152

package/lib/custom-eslint-rules/index.d.ts

@@ -11,4 +11,5 @@ export declare const customRules: {
     'no-welcome-index-route': import("eslint").Rule.RuleModule;
     'require-index-route': import("eslint").Rule.RuleModule;
     'no-duplicate-route-component': import("eslint").Rule.RuleModule;
+    'validated-non-primitive-needs-element-type': import("eslint").Rule.RuleModule;
 };

package/lib/custom-eslint-rules/index.js

@@ -16,6 +16,7 @@ const require_shared_request_type_1 = __importDefault(require("./require-shared-
 const no_welcome_index_route_1 = __importDefault(require("./no-welcome-index-route"));
 const require_index_route_1 = __importDefault(require("./require-index-route"));
 const no_duplicate_route_component_1 = __importDefault(require("./no-duplicate-route-component"));
+const validated_non_primitive_needs_element_type_1 = __importDefault(require("./validated-non-primitive-needs-element-type"));
 exports.customRules = {
     'no-nested-styled-jsx': no_nested_styled_jsx_1.default,
     'no-styled-jsx-data-uri-url-ref': no_styled_jsx_data_uri_url_ref_1.default,
@@ -29,4 +30,5 @@ exports.customRules = {
     'no-welcome-index-route': no_welcome_index_route_1.default,
     'require-index-route': require_index_route_1.default,
     'no-duplicate-route-component': no_duplicate_route_component_1.default,
+    'validated-non-primitive-needs-element-type': validated_non_primitive_needs_element_type_1.default,
 };

package/lib/custom-eslint-rules/validated-non-primitive-needs-element-type.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/lib/custom-eslint-rules/validated-non-primitive-needs-element-type.js

@@ -0,0 +1,330 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = __importDefault(require("typescript"));
+const primitiveTypeNodes = new Set([
+    'TSStringKeyword',
+    'TSBooleanKeyword',
+    'TSNumberKeyword',
+    'TSLiteralType',
+    'TSNullKeyword',
+    'TSUnknownKeyword',
+    'TSAnyKeyword',
+    'TSObjectKeyword',
+    'TSTypeLiteral',
+]);
+const semanticPrimitiveFlags = typescript_1.default.TypeFlags.StringLike |
+    typescript_1.default.TypeFlags.NumberLike |
+    typescript_1.default.TypeFlags.BooleanLike |
+    typescript_1.default.TypeFlags.BigIntLike |
+    typescript_1.default.TypeFlags.ESSymbolLike |
+    typescript_1.default.TypeFlags.Null |
+    typescript_1.default.TypeFlags.Undefined |
+    typescript_1.default.TypeFlags.Void |
+    typescript_1.default.TypeFlags.Never |
+    typescript_1.default.TypeFlags.Any |
+    typescript_1.default.TypeFlags.Unknown;
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require validated non-primitive DTO properties to declare a usable class-transformer Type',
+            category: 'Possible Errors',
+            recommended: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    additionalTypeDecorators: {
+                        type: 'array',
+                        items: { type: 'string', minLength: 1 },
+                    },
+                    additionalCustomValidatorDecorators: {
+                        type: 'array',
+                        items: { type: 'string', minLength: 1 },
+                    },
+                },
+            },
+        ],
+        messages: {
+            missingElementType: 'This validated object array needs an element transformer. Add @Type(() => Object) for ordinary objects, or introduce a runtime DTO class and use @Type(() => ChildDto). @IsObject({ each: true }) and @ValidateNested({ each: true }) validate elements but do not transform them.',
+            missingRuntimeElementType: 'This validated DTO array needs @Type(() => {{typeName}}) so class-transformer can construct each element. Add @ValidateNested({ each: true }) separately only when child fields must also be validated.',
+            missingAliasedRuntimeElementType: 'This validated DTO array needs @Type using the actual in-scope runtime DTO class value for its elements. Do not pass a TypeScript-only alias. Add @ValidateNested({ each: true }) separately only when child fields must also be validated.',
+            invalidElementType: 'The @Type decorator does not describe this ordinary object array. Use @Type(() => Object); TypeScript interfaces cannot be used as runtime constructors.',
+            invalidRuntimeElementType: 'The @Type decorator does not describe this nested DTO array. Use @Type(() => {{typeName}}) with the runtime DTO class.',
+            invalidAliasedRuntimeElementType: 'The @Type decorator does not describe this nested DTO array. Pass the actual in-scope runtime DTO class value, not a TypeScript-only alias.',
+            missingType: 'A validated non-primitive property needs a class-transformer @Type decorator with a runtime constructor. TypeScript interfaces cannot be used as runtime constructors.',
+        },
+    },
+    create(context) {
+        const parserServices = context.sourceCode.parserServices;
+        if (!parserServices?.program || !parserServices.esTreeNodeToTSNodeMap) {
+            throw new Error('@lark-apaas/validated-non-primitive-needs-element-type requires type information. Configure parserOptions.project for the server files.');
+        }
+        const checker = parserServices.program.getTypeChecker();
+        const nodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const classValidatorDecoratorNames = new Set();
+        const options = (context.options[0] ?? {});
+        const customValidatorNames = new Set(options.additionalCustomValidatorDecorators ?? []);
+        const customTypeDecoratorNames = new Set(options.additionalTypeDecorators ?? []);
+        return {
+            // Match the upstream rule's import-aware class-validator detection.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ImportDeclaration(node) {
+                if (typeof node.source.value !== 'string' ||
+                    !node.source.value.startsWith('class-validator')) {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === 'ImportSpecifier') {
+                        classValidatorDecoratorNames.add(specifier.local.name);
+                    }
+                }
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            PropertyDefinition(node) {
+                const annotation = node.typeAnnotation?.typeAnnotation;
+                if (!annotation)
+                    return;
+                const validationDecorators = node.decorators.filter((decorator) => {
+                    const name = getDecoratorName(decorator);
+                    return (name !== null &&
+                        (classValidatorDecoratorNames.has(name) ||
+                            customValidatorNames.has(name)));
+                });
+                if (validationDecorators.length === 0)
+                    return;
+                const validationNames = new Set(validationDecorators.map(getDecoratorName));
+                if (validationNames.has('IsEnum'))
+                    return;
+                const annotationType = getSemanticType(annotation, nodeMap, checker);
+                const arrayElementTypes = annotationType
+                    ? getArrayElementTypes(annotationType, checker)
+                    : null;
+                const syntacticElementType = getSyntacticArrayElementType(annotation);
+                const isArray = arrayElementTypes !== null || syntacticElementType !== null;
+                if (isArray) {
+                    if (arrayElementTypes?.every(elementType => isSemanticPrimitiveType(elementType, checker))) {
+                        return;
+                    }
+                    if (arrayElementTypes?.every(elementType => isSemanticEnumType(elementType, checker))) {
+                        return;
+                    }
+                }
+                else {
+                    if (isSyntacticPrimitiveType(annotation))
+                        return;
+                    if (annotationType && isSemanticEnumType(annotationType, checker)) {
+                        return;
+                    }
+                }
+                // A scalar plain object intentionally needs only runtime object validation.
+                // Semantic array resolution ensures aliases and nullable arrays never take this exemption.
+                if (!isArray && validationNames.has('IsObject'))
+                    return;
+                const typeDecorators = node.decorators.filter((decorator) => {
+                    const name = getDecoratorName(decorator);
+                    return (name === 'Type' ||
+                        (name !== null && customTypeDecoratorNames.has(name)));
+                });
+                if (!isArray) {
+                    if (typeDecorators.length === 0) {
+                        context.report({ node: node.key, messageId: 'missingType' });
+                    }
+                    return;
+                }
+                const runtimeConstructor = arrayElementTypes
+                    ? getSharedRuntimeConstructor(arrayElementTypes, syntacticElementType, nodeMap, checker)
+                    : null;
+                const expectedTypeName = runtimeConstructor?.name ?? 'Object';
+                const hasValidType = typeDecorators.some((decorator) => {
+                    const name = getDecoratorName(decorator);
+                    if (name !== 'Type')
+                        return true;
+                    return runtimeConstructor
+                        ? typeDecoratorTargetsConstructor(decorator, runtimeConstructor.symbol, nodeMap, checker)
+                        : getTypeDecoratorTargetName(decorator) === 'Object';
+                });
+                if (hasValidType)
+                    return;
+                if (typeDecorators.length > 0) {
+                    context.report({
+                        node: node.key,
+                        messageId: runtimeConstructor
+                            ? runtimeConstructor.name
+                                ? 'invalidRuntimeElementType'
+                                : 'invalidAliasedRuntimeElementType'
+                            : 'invalidElementType',
+                        data: { typeName: expectedTypeName },
+                    });
+                    return;
+                }
+                context.report({
+                    node: node.key,
+                    messageId: runtimeConstructor
+                        ? runtimeConstructor.name
+                            ? 'missingRuntimeElementType'
+                            : 'missingAliasedRuntimeElementType'
+                        : 'missingElementType',
+                    data: { typeName: expectedTypeName },
+                });
+            },
+        };
+    },
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getDecoratorName(decorator) {
+    const expression = decorator?.expression;
+    if (expression?.type !== 'CallExpression' ||
+        expression.callee?.type !== 'Identifier') {
+        return null;
+    }
+    return expression.callee.name;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getTypeDecoratorTarget(decorator) {
+    const factory = decorator.expression?.arguments?.[0];
+    if (factory?.type !== 'ArrowFunctionExpression')
+        return null;
+    if (factory.body?.type !== 'BlockStatement')
+        return factory.body ?? null;
+    if (factory.body.body?.length === 1 &&
+        factory.body.body[0].type === 'ReturnStatement') {
+        return factory.body.body[0].argument ?? null;
+    }
+    return null;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getTypeDecoratorTargetName(decorator) {
+    const target = getTypeDecoratorTarget(decorator);
+    return target?.type === 'Identifier' ? target.name : null;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getSyntacticArrayElementType(annotation) {
+    if (annotation.type === 'TSArrayType')
+        return annotation.elementType;
+    if (annotation.type === 'TSTypeReference' &&
+        annotation.typeName?.type === 'Identifier' &&
+        (annotation.typeName.name === 'Array' ||
+            annotation.typeName.name === 'ReadonlyArray') &&
+        annotation.typeArguments?.params?.length === 1) {
+        return annotation.typeArguments.params[0];
+    }
+    return null;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isSyntacticPrimitiveType(typeNode) {
+    if (primitiveTypeNodes.has(typeNode.type))
+        return true;
+    return (typeNode.type === 'TSUnionType' &&
+        typeNode.types.some((member) => primitiveTypeNodes.has(member.type)));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getSemanticType(node, nodeMap, checker) {
+    const tsNode = nodeMap.get(node);
+    return tsNode ? checker.getTypeAtLocation(tsNode) : null;
+}
+function getArrayElementTypes(annotationType, checker) {
+    const nonNullable = checker.getNonNullableType(annotationType);
+    // Nullable arrays collapse to one non-nullable array. Other heterogeneous unions
+    // remain outside this rule because there is no single safe element transformer.
+    if (nonNullable.isUnion() || !checker.isArrayType(nonNullable))
+        return null;
+    const typeArguments = checker.getTypeArguments(nonNullable);
+    const elementType = typeArguments[0] ??
+        checker.getIndexTypeOfType(nonNullable, typescript_1.default.IndexKind.Number);
+    return elementType ? [elementType] : null;
+}
+function isSemanticPrimitiveType(type, checker) {
+    if ((type.flags & semanticPrimitiveFlags) !== 0)
+        return true;
+    const nonNullable = checker.getNonNullableType(type);
+    if (nonNullable.isUnion()) {
+        return nonNullable.types.every(member => isSemanticPrimitiveType(member, checker));
+    }
+    return (nonNullable.flags & semanticPrimitiveFlags) !== 0;
+}
+function isSemanticEnumType(type, checker) {
+    const nonNullable = checker.getNonNullableType(type);
+    if ((nonNullable.flags & typescript_1.default.TypeFlags.EnumLike) !== 0)
+        return true;
+    const symbol = nonNullable.aliasSymbol ?? nonNullable.getSymbol();
+    if (symbol?.declarations?.some(declaration => typescript_1.default.isEnumDeclaration(declaration))) {
+        return true;
+    }
+    return (nonNullable.isUnion() &&
+        nonNullable.types.length > 0 &&
+        nonNullable.types.every(member => member.symbol?.declarations?.some(declaration => typescript_1.default.isEnumMember(declaration) &&
+            typescript_1.default.isEnumDeclaration(declaration.parent))));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getSharedRuntimeConstructor(elementTypes, syntacticElementType, nodeMap, checker) {
+    const candidates = elementTypes.flatMap(elementType => {
+        const nonNullable = checker.getNonNullableType(elementType);
+        return nonNullable.isUnion() ? nonNullable.types : [nonNullable];
+    });
+    if (candidates.length === 0)
+        return null;
+    const symbols = candidates.map(type => getRuntimeConstructorSymbol(type, checker));
+    const symbol = symbols[0];
+    if (!symbol || symbols.some(candidate => candidate !== symbol))
+        return null;
+    return {
+        symbol,
+        name: getUsableRuntimeConstructorName(syntacticElementType, symbol, nodeMap, checker),
+    };
+}
+function getRuntimeConstructorSymbol(instanceType, checker) {
+    const symbol = instanceType.getSymbol();
+    if (!symbol?.valueDeclaration)
+        return null;
+    const valueType = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
+    return valueType.getConstructSignatures().length > 0 ? symbol : null;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getUsableRuntimeConstructorName(typeNode, expectedSymbol, nodeMap, checker) {
+    if (typeNode?.type !== 'TSTypeReference' ||
+        typeNode.typeName?.type !== 'Identifier') {
+        return null;
+    }
+    const tsTypeName = nodeMap.get(typeNode.typeName);
+    if (!tsTypeName)
+        return null;
+    const localSymbol = checker.getSymbolAtLocation(tsTypeName);
+    if (!localSymbol ||
+        isTypeOnlyImport(localSymbol) ||
+        resolveAlias(localSymbol, checker) !== expectedSymbol) {
+        return null;
+    }
+    return typeNode.typeName.name;
+}
+function isTypeOnlyImport(symbol) {
+    return (symbol.declarations?.some(declaration => {
+        if (typescript_1.default.isImportSpecifier(declaration)) {
+            return declaration.isTypeOnly || declaration.parent.parent.isTypeOnly;
+        }
+        return typescript_1.default.isImportClause(declaration) && declaration.isTypeOnly;
+    }) ?? false);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function typeDecoratorTargetsConstructor(decorator, expectedSymbol, nodeMap, checker) {
+    const target = getTypeDecoratorTarget(decorator);
+    const tsTarget = target ? nodeMap.get(target) : undefined;
+    if (!tsTarget)
+        return false;
+    const localSymbol = checker.getSymbolAtLocation(tsTarget);
+    return (localSymbol !== undefined &&
+        !isTypeOnlyImport(localSymbol) &&
+        resolveAlias(localSymbol, checker) === expectedSymbol);
+}
+function resolveAlias(symbol, checker) {
+    if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias) !== 0) {
+        return checker.getAliasedSymbol(symbol);
+    }
+    return symbol;
+}
+exports.default = rule;

package/lib/recommend/eslint/eslint-client.d.ts

@@ -27,6 +27,7 @@ declare const _default: {
                 'no-welcome-index-route': import("eslint").Rule.RuleModule;
                 'require-index-route': import("eslint").Rule.RuleModule;
                 'no-duplicate-route-component': import("eslint").Rule.RuleModule;
+                'validated-non-primitive-needs-element-type': import("eslint").Rule.RuleModule;
             };
         };
     };

package/lib/recommend/eslint/index.d.ts

@@ -30,6 +30,7 @@ export declare const eslintPresets: {
                     'no-welcome-index-route': import("eslint").Rule.RuleModule;
                     'require-index-route': import("eslint").Rule.RuleModule;
                     'no-duplicate-route-component': import("eslint").Rule.RuleModule;
+                    'validated-non-primitive-needs-element-type': import("eslint").Rule.RuleModule;
                 };
             };
         };

package/lib/simple/recommend/eslint/eslint-server.d.ts

@@ -48,6 +48,8 @@ declare const _default: {
         '@darraghor/nestjs-typed/api-property-returning-array-should-set-array': string;
         '@darraghor/nestjs-typed/api-property-matches-property-optionality': string;
         '@darraghor/nestjs-typed/all-properties-have-explicit-defined': string;
+        '@darraghor/nestjs-typed/validated-non-primitive-property-needs-type-decorator': string;
+        '@lark-apaas/validated-non-primitive-needs-element-type': string;
         '@darraghor/nestjs-typed/controllers-should-supply-api-tags': string;
         '@darraghor/nestjs-typed/api-method-should-specify-api-response': string;
         '@darraghor/nestjs-typed/api-method-should-specify-api-operation': string;

package/lib/simple/recommend/eslint/eslint-server.js

@@ -69,6 +69,9 @@ exports.default = {
         '@darraghor/nestjs-typed/api-property-returning-array-should-set-array': 'off',
         '@darraghor/nestjs-typed/api-property-matches-property-optionality': 'off',
         '@darraghor/nestjs-typed/all-properties-have-explicit-defined': 'off',
+        // 本地兼容规则保留上游的非原始类型检查，并修复对象数组的 IsObject(each) 豁免与 interface 建议。
+        '@darraghor/nestjs-typed/validated-non-primitive-property-needs-type-decorator': 'off',
+        '@lark-apaas/validated-non-primitive-needs-element-type': 'error',
         // 关闭 Swagger 相关规则
         '@darraghor/nestjs-typed/controllers-should-supply-api-tags': 'off',
         '@darraghor/nestjs-typed/api-method-should-specify-api-response': 'off',

package/lib/simple/recommend/eslint/index.d.ts

@@ -57,6 +57,7 @@ export declare const eslintPresets: {
                     'no-welcome-index-route': import("eslint").Rule.RuleModule;
                     'require-index-route': import("eslint").Rule.RuleModule;
                     'no-duplicate-route-component': import("eslint").Rule.RuleModule;
+                    'validated-non-primitive-needs-element-type': import("eslint").Rule.RuleModule;
                 };
             };
         };
@@ -82,6 +83,7 @@ export declare const eslintPresets: {
                     'no-welcome-index-route': import("eslint").Rule.RuleModule;
                     'require-index-route': import("eslint").Rule.RuleModule;
                     'no-duplicate-route-component': import("eslint").Rule.RuleModule;
+                    'validated-non-primitive-needs-element-type': import("eslint").Rule.RuleModule;
                 };
             };
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-presets",
-  "version": "1.1.25",
+  "version": "1.1.26-alpha.20261002143152",
   "files": [
     "lib"
   ],