@darraghor/eslint-plugin-nestjs-typed 6.10.2 → 6.12.0

package/dist/configs/recommended.js

@@ -23,9 +23,10 @@ export const rules = {
     "@darraghor/nestjs-typed/sort-module-metadata-arrays": "off",
     "@darraghor/nestjs-typed/no-duplicate-decorators": "error",
     "@darraghor/nestjs-typed/use-injectable-provided-token": "error",
+    "@darraghor/nestjs-typed/api-property-should-have-api-extra-models": "error",
 };
 export default {
     extends: ["./configs/base"],
     rules,
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb21tZW5kZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlncy9yZWNvbW1lbmRlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQWdDO0lBQzlDLDJFQUEyRSxFQUN2RSxPQUFPO0lBQ1gsdURBQXVELEVBQUU7UUFDckQsT0FBTztRQUNQO1lBQ0ksR0FBRyxFQUFFLENBQUMsYUFBYSxDQUFDO1lBQ3BCLGVBQWUsRUFBRSxDQUFDLGNBQWMsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDO1NBQ3hEO0tBQ0o7SUFDRCxtRUFBbUUsRUFDL0QsT0FBTztJQUNYLGdFQUFnRSxFQUFFLE9BQU87SUFDekUsNERBQTRELEVBQUUsT0FBTztJQUNyRSwwREFBMEQsRUFBRSxPQUFPO0lBQ25FLHVFQUF1RSxFQUNuRSxPQUFPO0lBQ1gsOERBQThELEVBQUUsT0FBTztJQUN2RSxrRUFBa0UsRUFBRSxPQUFPO0lBQzNFLCtFQUErRSxFQUMzRSxPQUFPO0lBQ1gsa0VBQWtFLEVBQUUsT0FBTztJQUMzRSx3REFBd0QsRUFBRSxPQUFPO0lBQ2pFLDhEQUE4RCxFQUFFLE9BQU87SUFDdkUsdURBQXVELEVBQUUsS0FBSztJQUM5RCxpRUFBaUUsRUFBRSxLQUFLO0lBQ3hFLHFEQUFxRCxFQUFFLEtBQUs7SUFDNUQsaURBQWlELEVBQUUsT0FBTztJQUMxRCx1REFBdUQsRUFBRSxPQUFPO0NBQ25FLENBQUM7QUFDRixlQUFlO0lBQ1gsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7SUFDM0IsS0FBSztDQUNSLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb21tZW5kZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlncy9yZWNvbW1lbmRlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQWdDO0lBQzlDLDJFQUEyRSxFQUN2RSxPQUFPO0lBQ1gsdURBQXVELEVBQUU7UUFDckQsT0FBTztRQUNQO1lBQ0ksR0FBRyxFQUFFLENBQUMsYUFBYSxDQUFDO1lBQ3BCLGVBQWUsRUFBRSxDQUFDLGNBQWMsRUFBRSxRQUFRLEVBQUUsUUFBUSxDQUFDO1NBQ3hEO0tBQ0o7SUFDRCxtRUFBbUUsRUFDL0QsT0FBTztJQUNYLGdFQUFnRSxFQUFFLE9BQU87SUFDekUsNERBQTRELEVBQUUsT0FBTztJQUNyRSwwREFBMEQsRUFBRSxPQUFPO0lBQ25FLHVFQUF1RSxFQUNuRSxPQUFPO0lBQ1gsOERBQThELEVBQUUsT0FBTztJQUN2RSxrRUFBa0UsRUFBRSxPQUFPO0lBQzNFLCtFQUErRSxFQUMzRSxPQUFPO0lBQ1gsa0VBQWtFLEVBQUUsT0FBTztJQUMzRSx3REFBd0QsRUFBRSxPQUFPO0lBQ2pFLDhEQUE4RCxFQUFFLE9BQU87SUFDdkUsdURBQXVELEVBQUUsS0FBSztJQUM5RCxpRUFBaUUsRUFBRSxLQUFLO0lBQ3hFLHFEQUFxRCxFQUFFLEtBQUs7SUFDNUQsaURBQWlELEVBQUUsT0FBTztJQUMxRCx1REFBdUQsRUFBRSxPQUFPO0lBQ2hFLG1FQUFtRSxFQUMvRCxPQUFPO0NBQ2QsQ0FBQztBQUNGLGVBQWU7SUFDWCxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztJQUMzQixLQUFLO0NBQ1IsQ0FBQyJ9

package/dist/rules/apiPropertyShouldHaveApiExtraModels/apiPropertyShouldHaveApiExtraModels.d.ts

@@ -0,0 +1,2 @@
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseApiExtraModels", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/apiPropertyShouldHaveApiExtraModels/apiPropertyShouldHaveApiExtraModels.js

@@ -0,0 +1,129 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../../utils/createRule.js";
+import { typedTokenHelpers } from "../../utils/typedTokenHelpers.js";
+/**
+ * Extracts model names from getSchemaPath() calls within oneOf/allOf/anyOf arrays
+ */
+const extractModelsFromSchemaReferences = (arrayExpression) => {
+    const models = [];
+    for (const element of arrayExpression.elements) {
+        if (element?.type === AST_NODE_TYPES.ObjectExpression) {
+            // Look for { $ref: getSchemaPath(ModelName) }
+            const referenceProperty = element.properties.find((property) => property.type === AST_NODE_TYPES.Property &&
+                property.key.type === AST_NODE_TYPES.Identifier &&
+                property.key.name === "$ref");
+            if (referenceProperty &&
+                referenceProperty.value.type === AST_NODE_TYPES.CallExpression) {
+                const callExpression = referenceProperty.value;
+                // Check if it's a getSchemaPath call
+                if (callExpression.callee.type === AST_NODE_TYPES.Identifier &&
+                    callExpression.callee.name === "getSchemaPath" &&
+                    callExpression.arguments.length > 0) {
+                    const firstArgument = callExpression.arguments[0];
+                    if (firstArgument.type === AST_NODE_TYPES.Identifier) {
+                        models.push({
+                            modelName: firstArgument.name,
+                            node: firstArgument,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return models;
+};
+/**
+ * Checks if a property definition uses oneOf/allOf/anyOf with model references
+ */
+const getModelsFromApiPropertyDecorator = (node) => {
+    const decorators = typedTokenHelpers.getDecoratorsNamed(node, [
+        "ApiProperty",
+        "ApiPropertyOptional",
+    ]);
+    if (decorators.length === 0) {
+        return [];
+    }
+    if (decorators[0].expression.type !== AST_NODE_TYPES.CallExpression) {
+        return [];
+    }
+    const firstArgument = decorators[0].expression.arguments[0];
+    // Only process object expressions
+    if (!firstArgument ||
+        firstArgument.type !== AST_NODE_TYPES.ObjectExpression) {
+        return [];
+    }
+    const models = [];
+    // Check for oneOf, allOf, anyOf properties
+    for (const property of firstArgument.properties) {
+        if (property.type === AST_NODE_TYPES.Property &&
+            property.key.type === AST_NODE_TYPES.Identifier &&
+            ["oneOf", "allOf", "anyOf"].includes(property.key.name)) {
+            // The value should be an array expression
+            if (property.value.type === AST_NODE_TYPES.ArrayExpression) {
+                const extractedModels = extractModelsFromSchemaReferences(property.value);
+                models.push(...extractedModels);
+            }
+        }
+    }
+    return models;
+};
+const rule = createRule({
+    name: "api-property-should-have-api-extra-models",
+    meta: {
+        docs: {
+            description: "Ensures models referenced in oneOf, allOf, or anyOf within ApiProperty decorators are declared in ApiExtraModels",
+        },
+        messages: {
+            shouldUseApiExtraModels: `Model '{{modelName}}' is referenced in {{schemaType}} but may not be included in @ApiExtraModels(). Ensure it is added to @ApiExtraModels() on a controller or included directly in an endpoint response type.`,
+        },
+        schema: [],
+        hasSuggestions: false,
+        type: "suggestion",
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            PropertyDefinition(node) {
+                const models = getModelsFromApiPropertyDecorator(node);
+                if (models.length > 0) {
+                    // Determine which schema type is being used
+                    const decorators = typedTokenHelpers.getDecoratorsNamed(node, ["ApiProperty", "ApiPropertyOptional"]);
+                    let schemaType = "oneOf/allOf/anyOf";
+                    if (decorators.length > 0 &&
+                        decorators[0].expression.type ===
+                            AST_NODE_TYPES.CallExpression) {
+                        const firstArgument = decorators[0].expression.arguments[0];
+                        if (firstArgument &&
+                            firstArgument.type ===
+                                AST_NODE_TYPES.ObjectExpression) {
+                            for (const property of firstArgument.properties) {
+                                if (property.type === AST_NODE_TYPES.Property &&
+                                    property.key.type ===
+                                        AST_NODE_TYPES.Identifier) {
+                                    const key = property.key.name;
+                                    if (["oneOf", "allOf", "anyOf"].includes(key)) {
+                                        schemaType = key;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Report each model
+                    for (const model of models) {
+                        context.report({
+                            node: model.node,
+                            messageId: "shouldUseApiExtraModels",
+                            data: {
+                                modelName: model.modelName,
+                                schemaType: schemaType,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+export default rule;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpUHJvcGVydHlTaG91bGRIYXZlQXBpRXh0cmFNb2RlbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcnVsZXMvYXBpUHJvcGVydHlTaG91bGRIYXZlQXBpRXh0cmFNb2RlbHMvYXBpUHJvcGVydHlTaG91bGRIYXZlQXBpRXh0cmFNb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGNBQWMsRUFBVyxNQUFNLDBCQUEwQixDQUFDO0FBQ2xFLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQztBQUNyRCxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxrQ0FBa0MsQ0FBQztBQU9uRTs7R0FFRztBQUNILE1BQU0saUNBQWlDLEdBQUcsQ0FDdEMsZUFBeUMsRUFDeEIsRUFBRTtJQUNuQixNQUFNLE1BQU0sR0FBc0IsRUFBRSxDQUFDO0lBRXJDLEtBQUssTUFBTSxPQUFPLElBQUksZUFBZSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQzdDLElBQUksT0FBTyxFQUFFLElBQUksS0FBSyxjQUFjLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQztZQUNwRCw4Q0FBOEM7WUFDOUMsTUFBTSxpQkFBaUIsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLElBQUksQ0FDN0MsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUNULFFBQVEsQ0FBQyxJQUFJLEtBQUssY0FBYyxDQUFDLFFBQVE7Z0JBQ3pDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxVQUFVO2dCQUMvQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksS0FBSyxNQUFNLENBQ0YsQ0FBQztZQUVuQyxJQUNJLGlCQUFpQjtnQkFDakIsaUJBQWlCLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxjQUFjLENBQUMsY0FBYyxFQUNoRSxDQUFDO2dCQUNDLE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLEtBQUssQ0FBQztnQkFDL0MscUNBQXFDO2dCQUNyQyxJQUNJLGNBQWMsQ0FBQyxNQUFNLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxVQUFVO29CQUN4RCxjQUFjLENBQUMsTUFBTSxDQUFDLElBQUksS0FBSyxlQUFlO29CQUM5QyxjQUFjLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQ3JDLENBQUM7b0JBQ0MsTUFBTSxhQUFhLEdBQUcsY0FBYyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQztvQkFDbEQsSUFBSSxhQUFhLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQzt3QkFDbkQsTUFBTSxDQUFDLElBQUksQ0FBQzs0QkFDUixTQUFTLEVBQUUsYUFBYSxDQUFDLElBQUk7NEJBQzdCLElBQUksRUFBRSxhQUFhO3lCQUN0QixDQUFDLENBQUM7b0JBQ1AsQ0FBQztnQkFDTCxDQUFDO1lBQ0wsQ0FBQztRQUNMLENBQUM7SUFDTCxDQUFDO0lBRUQsT0FBTyxNQUFNLENBQUM7QUFDbEIsQ0FBQyxDQUFDO0FBRUY7O0dBRUc7QUFDSCxNQUFNLGlDQUFpQyxHQUFHLENBQ3RDLElBQWlDLEVBQ2hCLEVBQUU7SUFDbkIsTUFBTSxVQUFVLEdBQUcsaUJBQWlCLENBQUMsa0JBQWtCLENBQUMsSUFBSSxFQUFFO1FBQzFELGFBQWE7UUFDYixxQkFBcUI7S0FDeEIsQ0FBQyxDQUFDO0lBRUgsSUFBSSxVQUFVLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQzFCLE9BQU8sRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVELElBQUksVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxJQUFJLEtBQUssY0FBYyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ2xFLE9BQU8sRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVELE1BQU0sYUFBYSxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRTVELGtDQUFrQztJQUNsQyxJQUNJLENBQUMsYUFBYTtRQUNkLGFBQWEsQ0FBQyxJQUFJLEtBQUssY0FBYyxDQUFDLGdCQUFnQixFQUN4RCxDQUFDO1FBQ0MsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQXNCLEVBQUUsQ0FBQztJQUVyQywyQ0FBMkM7SUFDM0MsS0FBSyxNQUFNLFFBQVEsSUFBSSxhQUFhLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDOUMsSUFDSSxRQUFRLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxRQUFRO1lBQ3pDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxVQUFVO1lBQy9DLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFDekQsQ0FBQztZQUNDLDBDQUEwQztZQUMxQyxJQUFJLFFBQVEsQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxlQUFlLEVBQUUsQ0FBQztnQkFDekQsTUFBTSxlQUFlLEdBQUcsaUNBQWlDLENBQ3JELFFBQVEsQ0FBQyxLQUFLLENBQ2pCLENBQUM7Z0JBQ0YsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLGVBQWUsQ0FBQyxDQUFDO1lBQ3BDLENBQUM7UUFDTCxDQUFDO0lBQ0wsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2xCLENBQUMsQ0FBQztBQUVGLE1BQU0sSUFBSSxHQUFHLFVBQVUsQ0FBZ0M7SUFDbkQsSUFBSSxFQUFFLDJDQUEyQztJQUNqRCxJQUFJLEVBQUU7UUFDRixJQUFJLEVBQUU7WUFDRixXQUFXLEVBQ1Asa0hBQWtIO1NBQ3pIO1FBQ0QsUUFBUSxFQUFFO1lBQ04sdUJBQXVCLEVBQUUsZ05BQWdOO1NBQzVPO1FBQ0QsTUFBTSxFQUFFLEVBQUU7UUFDVixjQUFjLEVBQUUsS0FBSztRQUNyQixJQUFJLEVBQUUsWUFBWTtLQUNyQjtJQUNELGNBQWMsRUFBRSxFQUFFO0lBRWxCLE1BQU0sQ0FBQyxPQUFPO1FBQ1YsT0FBTztZQUNILGtCQUFrQixDQUFDLElBQWlDO2dCQUNoRCxNQUFNLE1BQU0sR0FBRyxpQ0FBaUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFFdkQsSUFBSSxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO29CQUNwQiw0Q0FBNEM7b0JBQzVDLE1BQU0sVUFBVSxHQUFHLGlCQUFpQixDQUFDLGtCQUFrQixDQUNuRCxJQUFJLEVBQ0osQ0FBQyxhQUFhLEVBQUUscUJBQXFCLENBQUMsQ0FDekMsQ0FBQztvQkFFRixJQUFJLFVBQVUsR0FBRyxtQkFBbUIsQ0FBQztvQkFDckMsSUFDSSxVQUFVLENBQUMsTUFBTSxHQUFHLENBQUM7d0JBQ3JCLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsSUFBSTs0QkFDekIsY0FBYyxDQUFDLGNBQWMsRUFDbkMsQ0FBQzt3QkFDQyxNQUFNLGFBQWEsR0FDZixVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQzt3QkFDMUMsSUFDSSxhQUFhOzRCQUNiLGFBQWEsQ0FBQyxJQUFJO2dDQUNkLGNBQWMsQ0FBQyxnQkFBZ0IsRUFDckMsQ0FBQzs0QkFDQyxLQUFLLE1BQU0sUUFBUSxJQUFJLGFBQWEsQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQ0FDOUMsSUFDSSxRQUFRLENBQUMsSUFBSSxLQUFLLGNBQWMsQ0FBQyxRQUFRO29DQUN6QyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUk7d0NBQ2IsY0FBYyxDQUFDLFVBQVUsRUFDL0IsQ0FBQztvQ0FDQyxNQUFNLEdBQUcsR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQztvQ0FDOUIsSUFDSSxDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUMsUUFBUSxDQUNoQyxHQUFHLENBQ04sRUFDSCxDQUFDO3dDQUNDLFVBQVUsR0FBRyxHQUFHLENBQUM7d0NBQ2pCLE1BQU07b0NBQ1YsQ0FBQztnQ0FDTCxDQUFDOzRCQUNMLENBQUM7d0JBQ0wsQ0FBQztvQkFDTCxDQUFDO29CQUVELG9CQUFvQjtvQkFDcEIsS0FBSyxNQUFNLEtBQUssSUFBSSxNQUFNLEVBQUUsQ0FBQzt3QkFDekIsT0FBTyxDQUFDLE1BQU0sQ0FBQzs0QkFDWCxJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7NEJBQ2hCLFNBQVMsRUFBRSx5QkFBeUI7NEJBQ3BDLElBQUksRUFBRTtnQ0FDRixTQUFTLEVBQUUsS0FBSyxDQUFDLFNBQVM7Z0NBQzFCLFVBQVUsRUFBRSxVQUFVOzZCQUN6Qjt5QkFDSixDQUFDLENBQUM7b0JBQ1AsQ0FBQztnQkFDTCxDQUFDO1lBQ0wsQ0FBQztTQUNKLENBQUM7SUFDTixDQUFDO0NBQ0osQ0FBQyxDQUFDO0FBRUgsZUFBZSxJQUFJLENBQUMifQ==

package/dist/rules/index.d.ts

@@ -21,6 +21,11 @@ declare const allRules: {
     "all-properties-are-whitelisted": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missing-property-decorator", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "api-methods-should-be-guarded": import("@typescript-eslint/utils/ts-eslint").RuleModule<"apiMethodsShouldBeGuarded", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "sort-module-metadata-arrays": import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleMetadataArraysAreSorted", import("./sortModuleMetadataArrays/sortModuleMetadataArrays.js").RuleOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "use-correct-endpoint-naming-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"controllerPathShouldBePlural" | "controllerPathShouldBeKebabCase" | "routePathShouldBeKebabCase", [{
+        checkPluralization: boolean;
+        caseFormat: "kebab-case" | "snake_case" | "camelCase";
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "use-injectable-provided-token": import("@typescript-eslint/utils/ts-eslint").RuleModule<"useInjectableProvidedToken", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "api-property-should-have-api-extra-models": import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldUseApiExtraModels", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 };
 export default allRules;

package/dist/rules/index.js

@@ -15,7 +15,9 @@ import apiMethodsShouldBeGuarded from "./apiMethodsShouldBeGuarded/apiMethodsSho
 import apiMethodsShouldSpecifyApiOperation from "./apiMethodsShouldSpecifyApiOperation/apiMethodsShouldSpecifyApiOperation.js";
 import sortModuleMetadataArrays from "./sortModuleMetadataArrays/sortModuleMetadataArrays.js";
 import noDuplicateDecorators from "./noDuplicateDecorators/noDuplicateDecorators.js";
+import useCorrectEndpointNamingConvention from "./useCorrectEndpointNamingConvention/useCorrectEndpointNamingConvention.js";
 import useInjectableProvidedToken from "./useInjectableProvidedToken/useInjectableProvidedToken.js";
+import apiPropertyShouldHaveApiExtraModels from "./apiPropertyShouldHaveApiExtraModels/apiPropertyShouldHaveApiExtraModels.js";
 const allRules = {
     "all-properties-have-explicit-defined": allPropertiesHaveExplicitDefined,
     "api-property-matches-property-optionality": apiPropertyMatchesPropertyOptionality,
@@ -34,7 +36,9 @@ const allRules = {
     "all-properties-are-whitelisted": allPropertiesAreWhitelisted,
     "api-methods-should-be-guarded": apiMethodsShouldBeGuarded,
     "sort-module-metadata-arrays": sortModuleMetadataArrays,
+    "use-correct-endpoint-naming-convention": useCorrectEndpointNamingConvention,
     "use-injectable-provided-token": useInjectableProvidedToken,
+    "api-property-should-have-api-extra-models": apiPropertyShouldHaveApiExtraModels,
 };
 export default allRules;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVsZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywwQkFBMEIsTUFBTSw2REFBNkQsQ0FBQztBQUNyRyxPQUFPLDRDQUE0QyxNQUFNLDRFQUE0RSxDQUFDO0FBQ3RJLE9BQU8scUNBQXFDLE1BQU0sa0ZBQWtGLENBQUM7QUFDckksT0FBTyw2QkFBNkIsTUFBTSxrRUFBa0UsQ0FBQztBQUM3RyxPQUFPLGtDQUFrQyxNQUFNLDRFQUE0RSxDQUFDO0FBQzVILE9BQU8sNEJBQTRCLE1BQU0sZ0VBQWdFLENBQUM7QUFDMUcsT0FBTyx1Q0FBdUMsTUFBTSxzRkFBc0YsQ0FBQztBQUMzSSxPQUFPLGdDQUFnQyxNQUFNLDRFQUE0RSxDQUFDO0FBQzFILE9BQU8sdUNBQXVDLE1BQU0sOEVBQThFLENBQUM7QUFDbkksT0FBTyxtQ0FBbUMsTUFBTSxpRkFBaUYsQ0FBQztBQUNsSSxPQUFPLGtDQUFrQyxNQUFNLDRFQUE0RSxDQUFDO0FBQzVILE9BQU8sMkJBQTJCLE1BQU0sOERBQThELENBQUM7QUFDdkcsT0FBTyxnQ0FBZ0MsTUFBTSx3RUFBd0UsQ0FBQztBQUN0SCxPQUFPLHlCQUF5QixNQUFNLDBEQUEwRCxDQUFDO0FBQ2pHLE9BQU8sbUNBQW1DLE1BQU0sOEVBQThFLENBQUM7QUFDL0gsT0FBTyx3QkFBd0IsTUFBTSx3REFBd0QsQ0FBQztBQUM5RixPQUFPLHFCQUFxQixNQUFNLGtEQUFrRCxDQUFDO0FBQ3JGLE9BQU8sMEJBQTBCLE1BQU0sNERBQTRELENBQUM7QUFDcEcsTUFBTSxRQUFRLEdBQUc7SUFDYixzQ0FBc0MsRUFBRSxnQ0FBZ0M7SUFDeEUsMkNBQTJDLEVBQ3ZDLHFDQUFxQztJQUN6QywrQkFBK0IsRUFBRSwwQkFBMEI7SUFDM0QseUJBQXlCLEVBQUUscUJBQXFCO0lBQ2hELG1EQUFtRCxFQUMvQyw0Q0FBNEM7SUFDaEQsb0NBQW9DLEVBQUUsNkJBQTZCO0lBQ25FLHdDQUF3QyxFQUNwQyxrQ0FBa0M7SUFDdEMseUNBQXlDLEVBQ3JDLG1DQUFtQztJQUN2QyxrQ0FBa0MsRUFBRSw0QkFBNEI7SUFDaEUsK0NBQStDLEVBQzNDLHVDQUF1QztJQUMzQyxzQ0FBc0MsRUFBRSxnQ0FBZ0M7SUFDeEUsMENBQTBDLEVBQ3RDLHVDQUF1QztJQUMzQyx1REFBdUQsRUFDbkQsbUNBQW1DO0lBQ3ZDLDBDQUEwQyxFQUN0QyxrQ0FBa0M7SUFDdEMsZ0NBQWdDLEVBQUUsMkJBQTJCO0lBQzdELCtCQUErQixFQUFFLHlCQUF5QjtJQUMxRCw2QkFBNkIsRUFBRSx3QkFBd0I7SUFDdkQsK0JBQStCLEVBQUUsMEJBQTBCO0NBQzlELENBQUM7QUFFRixlQUFlLFFBQVEsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVsZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywwQkFBMEIsTUFBTSw2REFBNkQsQ0FBQztBQUNyRyxPQUFPLDRDQUE0QyxNQUFNLDRFQUE0RSxDQUFDO0FBQ3RJLE9BQU8scUNBQXFDLE1BQU0sa0ZBQWtGLENBQUM7QUFDckksT0FBTyw2QkFBNkIsTUFBTSxrRUFBa0UsQ0FBQztBQUM3RyxPQUFPLGtDQUFrQyxNQUFNLDRFQUE0RSxDQUFDO0FBQzVILE9BQU8sNEJBQTRCLE1BQU0sZ0VBQWdFLENBQUM7QUFDMUcsT0FBTyx1Q0FBdUMsTUFBTSxzRkFBc0YsQ0FBQztBQUMzSSxPQUFPLGdDQUFnQyxNQUFNLDRFQUE0RSxDQUFDO0FBQzFILE9BQU8sdUNBQXVDLE1BQU0sOEVBQThFLENBQUM7QUFDbkksT0FBTyxtQ0FBbUMsTUFBTSxpRkFBaUYsQ0FBQztBQUNsSSxPQUFPLGtDQUFrQyxNQUFNLDRFQUE0RSxDQUFDO0FBQzVILE9BQU8sMkJBQTJCLE1BQU0sOERBQThELENBQUM7QUFDdkcsT0FBTyxnQ0FBZ0MsTUFBTSx3RUFBd0UsQ0FBQztBQUN0SCxPQUFPLHlCQUF5QixNQUFNLDBEQUEwRCxDQUFDO0FBQ2pHLE9BQU8sbUNBQW1DLE1BQU0sOEVBQThFLENBQUM7QUFDL0gsT0FBTyx3QkFBd0IsTUFBTSx3REFBd0QsQ0FBQztBQUM5RixPQUFPLHFCQUFxQixNQUFNLGtEQUFrRCxDQUFDO0FBQ3JGLE9BQU8sa0NBQWtDLE1BQU0sNEVBQTRFLENBQUM7QUFDNUgsT0FBTywwQkFBMEIsTUFBTSw0REFBNEQsQ0FBQztBQUNwRyxPQUFPLG1DQUFtQyxNQUFNLDhFQUE4RSxDQUFDO0FBQy9ILE1BQU0sUUFBUSxHQUFHO0lBQ2Isc0NBQXNDLEVBQUUsZ0NBQWdDO0lBQ3hFLDJDQUEyQyxFQUN2QyxxQ0FBcUM7SUFDekMsK0JBQStCLEVBQUUsMEJBQTBCO0lBQzNELHlCQUF5QixFQUFFLHFCQUFxQjtJQUNoRCxtREFBbUQsRUFDL0MsNENBQTRDO0lBQ2hELG9DQUFvQyxFQUFFLDZCQUE2QjtJQUNuRSx3Q0FBd0MsRUFDcEMsa0NBQWtDO0lBQ3RDLHlDQUF5QyxFQUNyQyxtQ0FBbUM7SUFDdkMsa0NBQWtDLEVBQUUsNEJBQTRCO0lBQ2hFLCtDQUErQyxFQUMzQyx1Q0FBdUM7SUFDM0Msc0NBQXNDLEVBQUUsZ0NBQWdDO0lBQ3hFLDBDQUEwQyxFQUN0Qyx1Q0FBdUM7SUFDM0MsdURBQXVELEVBQ25ELG1DQUFtQztJQUN2QywwQ0FBMEMsRUFDdEMsa0NBQWtDO0lBQ3RDLGdDQUFnQyxFQUFFLDJCQUEyQjtJQUM3RCwrQkFBK0IsRUFBRSx5QkFBeUI7SUFDMUQsNkJBQTZCLEVBQUUsd0JBQXdCO0lBQ3ZELHdDQUF3QyxFQUNwQyxrQ0FBa0M7SUFDdEMsK0JBQStCLEVBQUUsMEJBQTBCO0lBQzNELDJDQUEyQyxFQUN2QyxtQ0FBbUM7Q0FDMUMsQ0FBQztBQUVGLGVBQWUsUUFBUSxDQUFDIn0=

package/dist/rules/useCorrectEndpointNamingConvention/useCorrectEndpointNamingConvention.d.ts

@@ -0,0 +1,9 @@
+type RuleMessageIds = "controllerPathShouldBePlural" | "controllerPathShouldBeKebabCase" | "routePathShouldBeKebabCase";
+type RuleOptions = [
+    {
+        checkPluralization: boolean;
+        caseFormat: "kebab-case" | "snake_case" | "camelCase";
+    }
+];
+declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<RuleMessageIds, RuleOptions, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default rule;

package/dist/rules/useCorrectEndpointNamingConvention/useCorrectEndpointNamingConvention.js

@@ -0,0 +1,211 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { createRule } from "../../utils/createRule.js";
+import { typedTokenHelpers } from "../../utils/typedTokenHelpers.js";
+const nestRequestMethodDecoratorNames = [
+    "Get",
+    "Post",
+    "Put",
+    "Delete",
+    "Patch",
+    "Options",
+    "Head",
+    "All",
+];
+/**
+ * Checks if a path segment is in kebab-case format
+ */
+const isKebabCase = (segment) => {
+    return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(segment);
+};
+/**
+ * Checks if a path segment is in snake_case format
+ */
+const isSnakeCase = (segment) => {
+    return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(segment);
+};
+/**
+ * Checks if a path segment is in camelCase format
+ */
+const isCamelCase = (segment) => {
+    return /^[a-z][a-zA-Z0-9]*$/.test(segment);
+};
+/**
+ * Simple pluralization check - checks if word ends with 's'
+ * This is a basic implementation. For more complex pluralization,
+ * users can disable this check.
+ */
+const isPlural = (word) => {
+    // Basic check: ends with 's' and not just 's'
+    return word.length > 1 && word.endsWith("s");
+};
+/**
+ * Extracts the path string from a decorator
+ */
+const getDecoratorPath = (decorator) => {
+    const decoratorArgument = decorator?.expression
+        ?.arguments[0];
+    if (!decoratorArgument) {
+        return null;
+    }
+    // Skip template literals and identifiers (dynamic paths)
+    if (decoratorArgument.type === TSESTree.AST_NODE_TYPES.TemplateLiteral ||
+        decoratorArgument.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        return undefined;
+    }
+    if (decoratorArgument.type === TSESTree.AST_NODE_TYPES.Literal) {
+        return decoratorArgument.value;
+    }
+    return null;
+};
+/**
+ * Extracts path segments from a path, excluding route parameters
+ */
+const getPathSegments = (path) => {
+    return path
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .filter((segment) => !segment.startsWith(":"))
+        .filter((segment) => segment !== "*");
+};
+/**
+ * Checks if a path matches the expected case format
+ */
+const matchesCaseFormat = (path, format) => {
+    const segments = getPathSegments(path);
+    if (segments.length === 0) {
+        return true;
+    }
+    for (const segment of segments) {
+        let isValid = false;
+        switch (format) {
+            case "kebab-case":
+                isValid = isKebabCase(segment);
+                break;
+            case "snake_case":
+                isValid = isSnakeCase(segment);
+                break;
+            case "camelCase":
+                isValid = isCamelCase(segment);
+                break;
+        }
+        if (!isValid) {
+            return false;
+        }
+    }
+    return true;
+};
+const defaultRuleOptions = [
+    {
+        checkPluralization: true,
+        caseFormat: "kebab-case",
+    },
+];
+const rule = createRule({
+    name: "use-correct-endpoint-naming-convention",
+    meta: {
+        docs: {
+            description: "Enforces REST API naming conventions for controller and route paths",
+        },
+        messages: {
+            controllerPathShouldBePlural: 'Controller path "{{path}}" should be plural (e.g., "{{path}}s"). You can disable this check by setting checkPluralization to false.',
+            controllerPathShouldBeKebabCase: 'Controller path "{{path}}" should be in {{format}} format.',
+            routePathShouldBeKebabCase: 'Route path "{{path}}" should be in {{format}} format.',
+        },
+        schema: [
+            {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    checkPluralization: {
+                        description: "Check that controller paths use plural resource names",
+                        type: "boolean",
+                    },
+                    caseFormat: {
+                        description: "The case format to enforce for paths. Options: kebab-case, snake_case, camelCase",
+                        type: "string",
+                        enum: ["kebab-case", "snake_case", "camelCase"],
+                    },
+                },
+            },
+        ],
+        hasSuggestions: false,
+        type: "suggestion",
+    },
+    defaultOptions: defaultRuleOptions,
+    create(context) {
+        const options = context.options && context.options.length > 0
+            ? context.options[0]
+            : defaultRuleOptions[0];
+        return {
+            ClassDeclaration(node) {
+                const hasControllerDecorator = typedTokenHelpers.nodeHasDecoratorsNamed(node, [
+                    "Controller",
+                ]);
+                if (!hasControllerDecorator) {
+                    return;
+                }
+                const controllerDecorator = typedTokenHelpers.getDecoratorsNamed(node, ["Controller"]);
+                if (controllerDecorator.length === 0) {
+                    return;
+                }
+                const path = getDecoratorPath(controllerDecorator[0]);
+                // Skip if no path, dynamic path, or empty string
+                if (path === null || path === undefined || path === "") {
+                    return;
+                }
+                const segments = getPathSegments(path);
+                // Check pluralization for the main resource (first segment)
+                if (options.checkPluralization && segments.length > 0) {
+                    const mainResource = segments[0];
+                    if (!isPlural(mainResource)) {
+                        context.report({
+                            node: controllerDecorator[0],
+                            messageId: "controllerPathShouldBePlural",
+                            data: {
+                                path: mainResource,
+                            },
+                        });
+                    }
+                }
+                // Check case format
+                if (!matchesCaseFormat(path, options.caseFormat)) {
+                    context.report({
+                        node: controllerDecorator[0],
+                        messageId: "controllerPathShouldBeKebabCase",
+                        data: {
+                            path: path,
+                            format: options.caseFormat,
+                        },
+                    });
+                }
+            },
+            MethodDefinition(node) {
+                const hasApiMethodDecorator = typedTokenHelpers.nodeHasDecoratorsNamed(node, nestRequestMethodDecoratorNames);
+                if (!hasApiMethodDecorator) {
+                    return;
+                }
+                const methodDecorators = typedTokenHelpers.getDecoratorsNamed(node, nestRequestMethodDecoratorNames);
+                for (const decorator of methodDecorators) {
+                    const path = getDecoratorPath(decorator);
+                    // Skip if no path, dynamic path, or empty string
+                    if (path === null || path === undefined || path === "") {
+                        continue;
+                    }
+                    // Check case format
+                    if (!matchesCaseFormat(path, options.caseFormat)) {
+                        context.report({
+                            node: decorator,
+                            messageId: "routePathShouldBeKebabCase",
+                            data: {
+                                path: path,
+                                format: options.caseFormat,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+export default rule;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/rules/validateNonPrimitiveNeedsTypeDecorator/validateNonPrimitiveNeedsDecorators.js

@@ -160,7 +160,8 @@ const rule = createRule({
                                         AST_NODE_TYPES.TSTypeReference &&
                                         firstParam.typeName?.type ===
                                             AST_NODE_TYPES.Identifier) {
-                                        typeIdentifier = firstParam.typeName.name;
+                                        typeIdentifier =
+                                            firstParam.typeName.name;
                                     }
                                 }
                             }
@@ -203,4 +204,4 @@ const rule = createRule({
     },
 });
 export default rule;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@darraghor/eslint-plugin-nestjs-typed",
-    "version": "6.10.2",
+    "version": "6.12.0",
     "description": "Eslint rules for nestjs projects",
     "scripts": {
         "clean": "rm -Rf ./dist/",