@tianjos/eslint-plugin-elegant 0.7.0 → 0.7.1

package/README.md

@@ -189,12 +189,36 @@ Public state should be `readonly` so callers cannot break an aggregate's
 invariants. A declared `private`/`protected` field is allowed, and so is any
 `readonly` member.
 
+A **decorated** property is allowed by default. `@Column`, `@IsString` and
+friends assign the field from outside the class, so `readonly` would be a lie
+and the property is framework shape rather than state the class chose to carry
+— a NestJS DTO or a TypeORM entity is a wall of them. Pass
+`{ ignoreDecorated: false }` to hold them to the same standard.
+
+```ts
+// passes — the framework populates these
+class BankDto {
+  @IsString() code: string;
+  @IsOptional() ispb_code?: string;
+}
+
+// reported — state the class chose to expose
+class Money {
+  amount = 0;
+}
+```
+
 Constructor parameter properties are covered at **every** visibility by
 default, which declared fields are not: a `private repo: Repository<Proposal>`
 that nobody marked `readonly` can still be swapped from inside, and unlike a
 declared field it is a collaborator the container handed you. Set
 `{ parameterProperties: 'public' }` to keep the rule to what its name says.
 
+`ignoreDecorated` deliberately does not reach parameter properties either. A
+decorator on a parameter is injection (`@Inject(TOKEN)`), which supplies a
+collaborator rather than populating a field, so it still has no business being
+reassignable. `max-class-fields` draws the same line for the same reason.
+
 This rule asks whether a field is *declared* changeable. Its behavioural
 counterpart is `no-self-mutation`, which asks whether anything actually
 changes it.

package/dist/index.d.ts

@@ -28,6 +28,7 @@ declare const rules: {
     };
     'no-public-mutable-props': TSESLint.RuleModule<"mutableProp", [{
         parameterProperties: "public" | "all";
+        ignoreDecorated: boolean;
     }], unknown, TSESLint.RuleListener> & {
         name: string;
     };

package/dist/rules/no-public-mutable-props.d.ts

@@ -1,6 +1,9 @@
-type Options = [{
-    parameterProperties: 'public' | 'all';
-}];
+type Options = [
+    {
+        parameterProperties: 'public' | 'all';
+        ignoreDecorated: boolean;
+    }
+];
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"mutableProp", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-public-mutable-props.js

@@ -21,6 +21,17 @@ const keyName = (key) => {
 const isMutable = (node, scope) => !node.readonly &&
     node.accessibility !== undefined &&
     (scope === 'all' || node.accessibility === 'public');
+/**
+ * A property a decorator maps to a table or a payload. `@Column`, `@IsString`
+ * and friends assign it from outside the class, so `readonly` would be a lie
+ * and the field is framework shape rather than state the class chose to carry.
+ *
+ * Deliberately does not reach parameter properties: a decorator on a parameter
+ * is injection (`@Inject(TOKEN)`), so the field is a genuine collaborator and
+ * still has no business being reassignable. `max-class-fields` draws the same
+ * line for the same reason.
+ */
+const isMapped = (node) => node.decorators.length > 0;
 exports.default = (0, createRule_1.createRule)({
     name: 'no-public-mutable-props',
     meta: {
@@ -36,18 +47,22 @@ exports.default = (0, createRule_1.createRule)({
                 type: 'object',
                 properties: {
                     parameterProperties: { type: 'string', enum: ['public', 'all'] },
+                    ignoreDecorated: { type: 'boolean' },
                 },
                 additionalProperties: false,
             },
         ],
     },
-    defaultOptions: [{ parameterProperties: 'all' }],
-    create(context, [{ parameterProperties }]) {
+    defaultOptions: [{ parameterProperties: 'all', ignoreDecorated: true }],
+    create(context, [{ parameterProperties, ignoreDecorated }]) {
         return {
             PropertyDefinition(node) {
                 if (node.readonly || isHidden(node.accessibility)) {
                     return;
                 }
+                if (ignoreDecorated && isMapped(node)) {
+                    return;
+                }
                 context.report({
                     node: node.key,
                     messageId: 'mutableProp',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tianjos/eslint-plugin-elegant",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Opinionated ESLint rules for elegant, behavior-rich TypeScript: honest types, encapsulated state, small uncoupled classes, guard-clause flow, and structured logging. Built for NestJS and DDD codebases.",
   "keywords": [
     "eslint",