@tianjos/eslint-plugin-elegant 0.3.2 → 0.5.0

package/dist/rules/no-interpolated-log-message.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const OBJECTS = ['log', 'logger'];
+const METHODS = [
+    'debug',
+    'error',
+    'fatal',
+    'info',
+    'log',
+    'trace',
+    'verbose',
+    'warn',
+];
+/**
+ * The name a call hangs off, as written. `logger.info` yields `logger`, and
+ * `this.logger.info` yields `logger` too, so a field and a local read alike.
+ */
+const receiver = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !node.computed &&
+        node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    return undefined;
+};
+/**
+ * The message is the first argument that is not an object literal, which lands
+ * on the message under either convention: `info(msg, data)` as in Nest and
+ * winston, and `info(data, msg)` as in pino.
+ */
+const message = (args) => args.find((arg) => arg.type !== utils_1.AST_NODE_TYPES.ObjectExpression);
+const computed = (node) => (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+    node.expressions.length > 0) ||
+    (node.type === utils_1.AST_NODE_TYPES.BinaryExpression && node.operator === '+');
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-interpolated-log-message',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require log messages to be constant, with the varying parts passed as structured data.',
+        },
+        messages: {
+            interpolatedMessage: 'A computed log message cannot be grouped or searched. Keep the message constant and pass the varying parts as structured data.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    objects: { type: 'array', items: { type: 'string' } },
+                    methods: { type: 'array', items: { type: 'string' } },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ objects: [], methods: [] }],
+    create(context, [{ objects, methods }]) {
+        const logging = new Set([...OBJECTS, ...objects]);
+        const levels = new Set([...METHODS, ...methods]);
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                    node.callee.computed ||
+                    node.callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !levels.has(node.callee.property.name)) {
+                    return;
+                }
+                const name = receiver(node.callee.object);
+                if (name === undefined || !logging.has(name)) {
+                    return;
+                }
+                const argument = message(node.arguments);
+                if (argument !== undefined && computed(argument)) {
+                    context.report({
+                        node: argument,
+                        messageId: 'interpolatedMessage',
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-logic-in-constructor.js

@@ -49,19 +49,18 @@ exports.default = (0, createRule_1.createRule)({
                     context.report({ node: statement, messageId: 'statement' });
                     continue;
                 }
-                const { expression } = statement;
-                if (isSuperCall(expression)) {
+                if (isSuperCall(statement.expression)) {
                     continue;
                 }
-                if (expression.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
-                    expression.operator !== '=' ||
-                    !isThisMember(expression.left)) {
+                if (statement.expression.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                    statement.expression.operator !== '=' ||
+                    !isThisMember(statement.expression.left)) {
                     context.report({ node: statement, messageId: 'statement' });
                     continue;
                 }
-                if (!isPlainValue(expression.right)) {
+                if (!isPlainValue(statement.expression.right)) {
                     context.report({
-                        node: expression.right,
+                        node: statement.expression.right,
                         messageId: 'computation',
                     });
                 }

package/dist/rules/no-null-return.js

@@ -18,10 +18,9 @@ exports.default = (0, createRule_1.createRule)({
     create(context) {
         return {
             ReturnStatement(node) {
-                const { argument } = node;
-                if (argument?.type === utils_1.AST_NODE_TYPES.Literal &&
-                    argument.value === null &&
-                    argument.raw === 'null') {
+                if (node.argument?.type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.argument.value === null &&
+                    node.argument.raw === 'null') {
                     context.report({ node, messageId: 'noNullReturn' });
                 }
             },

package/dist/rules/no-null.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * A `null` sitting directly in a `return`. That shape is the domain of
+ * `no-null-return`, which reports it with its own message; reporting it here
+ * too would double up on one line of code.
+ */
+const isDirectReturn = (node) => node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+    node.parent.argument === node;
 exports.default = (0, createRule_1.createRule)({
     name: 'no-null',
     meta: {
@@ -21,10 +28,7 @@ exports.default = (0, createRule_1.createRule)({
                 if (node.value !== null || node.raw !== 'null') {
                     return;
                 }
-                // Direct `return null;` is the domain of `no-null-return`.
-                const { parent } = node;
-                if (parent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                    parent.argument === node) {
+                if (isDirectReturn(node)) {
                     return;
                 }
                 context.report({ node, messageId: 'noNull' });

package/dist/rules/no-property-alias.d.ts

@@ -0,0 +1,7 @@
+type Options = [{
+    allowEnv: boolean;
+}];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"aliasesProperty", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-property-alias.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const locals_1 = require("../utils/locals");
+const memberChain_1 = require("../utils/memberChain");
+const DEFAULT_ALLOW_ENV = true;
+/** Whether the chain reads `process.env.SOMETHING`. */
+const isEnvRead = (node) => node.object.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+    !node.object.computed &&
+    node.object.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+    node.object.object.name === 'process' &&
+    node.object.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+    node.object.property.name === 'env';
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-property-alias',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow locals that only rename a property of an object already in hand. Ask the object where the value is needed instead.',
+        },
+        messages: {
+            aliasesProperty: "'{{name}}' only renames '{{path}}'. Ask the object where you need the value instead of copying its state into a local.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowEnv: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ allowEnv: DEFAULT_ALLOW_ENV }],
+    create(context, [{ allowEnv }]) {
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                if (node.init === null ||
+                    node.init.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                    !(0, memberChain_1.isObjectInHand)(node.init)) {
+                    return;
+                }
+                if (allowEnv && isEnvRead(node.init)) {
+                    return;
+                }
+                const [variable] = context.sourceCode.getDeclaredVariables(node);
+                if (variable === undefined ||
+                    (0, locals_1.isReassigned)(variable) ||
+                    (0, locals_1.escapesIntoFunction)(variable)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'aliasesProperty',
+                    data: {
+                        name: node.id.name,
+                        path: context.sourceCode.getText(node.init),
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-property-destructuring.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"destructuresObject", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-property-destructuring.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const locals_1 = require("../utils/locals");
+const memberChain_1 = require("../utils/memberChain");
+/**
+ * Whether the pattern collects the properties it does not name into a rest
+ * object. That is construction by omission, not a copy of state anyone can
+ * replace with a member access.
+ */
+const hasRestElement = (node) => node.properties.some((property) => property.type === utils_1.AST_NODE_TYPES.RestElement);
+/**
+ * Whether any property carries a default. `options.max ?? 3` repeats the
+ * fallback at every use site, so the pattern is holding a decision rather than
+ * just a copy.
+ */
+const hasDefault = (node) => node.properties.some((property) => property.type === utils_1.AST_NODE_TYPES.Property &&
+    property.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern);
+exports.default = (0, createRule_1.createRule)({
+    name: 'no-property-destructuring',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow destructuring an object already in hand. Ask the object where each value is needed instead.',
+        },
+        messages: {
+            destructuresObject: "Destructuring '{{name}}' copies its state into {{count}} locals. Ask the object where you need each value instead.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ObjectPattern(node) {
+                if (node.parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    node.parent.init === null ||
+                    !(0, memberChain_1.isObjectInHand)(node.parent.init)) {
+                    return;
+                }
+                if (hasRestElement(node) || hasDefault(node)) {
+                    return;
+                }
+                const variables = context.sourceCode.getDeclaredVariables(node.parent);
+                if (variables.some((variable) => (0, locals_1.isReassigned)(variable) || (0, locals_1.escapesIntoFunction)(variable))) {
+                    return;
+                }
+                context.report({
+                    node: node.parent,
+                    messageId: 'destructuresObject',
+                    data: {
+                        name: context.sourceCode.getText(node.parent.init),
+                        count: node.properties.length,
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -12,6 +12,12 @@ const keyName = (key) => {
     }
     return 'property';
 };
+/**
+ * A constructor parameter property the outside world can write to. Only
+ * constructor parameter properties carry an accessibility modifier, so reading
+ * one is enough to know the field is public.
+ */
+const isPublicMutable = (node) => node.accessibility === 'public' && !node.readonly;
 exports.default = (0, createRule_1.createRule)({
     name: 'no-public-mutable-props',
     meta: {
@@ -38,9 +44,7 @@ exports.default = (0, createRule_1.createRule)({
                 });
             },
             TSParameterProperty(node) {
-                // Only constructor parameter properties carry an accessibility modifier.
-                if (node.accessibility !== 'public' ||
-                    node.readonly) {
+                if (!isPublicMutable(node)) {
                     return;
                 }
                 const target = node.parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern

package/dist/utils/locals.d.ts

@@ -0,0 +1,13 @@
+import { TSESLint } from '@typescript-eslint/utils';
+/**
+ * Whether anything writes to the variable after its declaration. Such a local
+ * holds mutable state that no member access stands in for, so it is not a copy
+ * of the object's state to begin with.
+ */
+export declare const isReassigned: (variable: TSESLint.Scope.Variable) => boolean;
+/**
+ * Whether the variable is read from inside a nested function. TypeScript drops
+ * a narrowing of `obj.prop` at the callback boundary but keeps it on a local,
+ * so such a declaration is load-bearing: inlining it stops compiling.
+ */
+export declare const escapesIntoFunction: (variable: TSESLint.Scope.Variable) => boolean;

package/dist/utils/locals.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapesIntoFunction = exports.isReassigned = void 0;
+/**
+ * Whether anything writes to the variable after its declaration. Such a local
+ * holds mutable state that no member access stands in for, so it is not a copy
+ * of the object's state to begin with.
+ */
+const isReassigned = (variable) => variable.references.some((reference) => reference.isWrite() && !reference.init);
+exports.isReassigned = isReassigned;
+/**
+ * Whether the variable is read from inside a nested function. TypeScript drops
+ * a narrowing of `obj.prop` at the callback boundary but keeps it on a local,
+ * so such a declaration is load-bearing: inlining it stops compiling.
+ */
+const escapesIntoFunction = (variable) => variable.references.some((reference) => {
+    let scope = reference.from;
+    while (scope !== null && scope !== variable.scope) {
+        if (scope.type === 'function') {
+            return true;
+        }
+        scope = scope.upper;
+    }
+    return false;
+});
+exports.escapesIntoFunction = escapesIntoFunction;

package/dist/utils/memberChain.d.ts

@@ -0,0 +1,8 @@
+import { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Whether the expression denotes an object the reader already holds: a name,
+ * `this`, or a run of plain `.prop` accesses rooted at one of those. A computed
+ * link (`calls[1][0].metadata`) or a call in the middle
+ * (`resolveDates(query).startDate`) fails — nobody gains by inlining those.
+ */
+export declare const isObjectInHand: (node: TSESTree.Node) => boolean;

package/dist/utils/memberChain.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectInHand = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Whether the expression denotes an object the reader already holds: a name,
+ * `this`, or a run of plain `.prop` accesses rooted at one of those. A computed
+ * link (`calls[1][0].metadata`) or a call in the middle
+ * (`resolveDates(query).startDate`) fails — nobody gains by inlining those.
+ */
+const isObjectInHand = (node) => {
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        if (current.computed) {
+            return false;
+        }
+        current = current.object;
+    }
+    return (current.type === utils_1.AST_NODE_TYPES.Identifier ||
+        current.type === utils_1.AST_NODE_TYPES.ThisExpression);
+};
+exports.isObjectInHand = isObjectInHand;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tianjos/eslint-plugin-elegant",
-  "version": "0.3.2",
-  "description": "Opinionated ESLint rules for elegant, behavior-rich TypeScript: no flag arguments, no type assertions, no null returns, no public mutable state, and small focused classes.",
+  "version": "0.5.0",
+  "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",
     "eslint-plugin",
@@ -41,6 +41,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "lint": "npm run build && eslint .",
     "typecheck": "tsc -p tsconfig.test.json",
     "test": "jest",
     "release": "standard-version",