@mimik/eslint-plugin-logger 1.0.0 → 1.0.2

package/README.md

@@ -31,9 +31,25 @@ Validates that logger calls (on default-imported modules) use the correct argume
 
 ### Valid Signatures
 
+All three access patterns are supported:
+
 ```js
 import logger from '@mimik/sumologic-winston-logger';
 
+// Dot notation
+logger.info('User logged in', correlationId);
+
+// Bracket notation with string literal
+logger['info']('User logged in', correlationId);
+
+// Bracket notation with variable (any variable name)
+logger[level]('User logged in', correlationId);
+logger[severity]('User logged in', correlationId);
+```
+
+The four argument signatures:
+
+```js
 // (message, correlationId)
 logger.info('User logged in', correlationId);
 
@@ -64,10 +80,14 @@ logger.info('User logged in', { userId: 123 }, correlationId, { type: 'audit' })
 
 - The rule only applies to **default imports** (e.g. `import logger from '...'`)
 - Named imports (`import { logger } from '...'`) are ignored
+- Supports dot notation (`logger.info`), bracket notation with a string literal (`logger['info']`), and bracket notation with a variable (`logger[level]`)
+- For bracket notation with a string literal, the value must be a recognised log level
+- For bracket notation with a variable, the call is always validated (the variable is assumed to hold a valid level)
 - Minimum 2 arguments, maximum 4
 - `message` must be a string (when passed as a literal)
 - `correlationId` must be a string (when passed as a literal)
 - `options` object must contain a `type` property with a string value
+- When 2 arguments are passed and the 2nd is an object literal, it is treated as `(message, meta)` with a missing `correlationId`
 - When 3 arguments are passed, the 2nd argument type determines the signature:
   - Object literal → `(message, meta, correlationId)`
   - Otherwise → `(message, correlationId, options)`
@@ -104,6 +124,13 @@ Reports an error when the options object is missing a <code>type</code> property
 <code>type</code> value is a non-string literal. Variable references (e.g. <code>{ type: someVar }</code>)
 are allowed because their runtime type cannot be determined statically.</p>
 </dd>
+<dt><a href="#resolveLevel">resolveLevel(callee)</a> ⇒ <code>string</code> | <code>null</code></dt>
+<dd><p>Resolve the log level from a MemberExpression callee.
+Supports dot notation (<code>logger.info</code>), bracket notation with a string literal
+(<code>logger[&#39;info&#39;]</code>), and bracket notation with a variable (<code>logger[level]</code>).
+For string literals the value must be a recognised level; variables are assumed
+to hold a valid level and the variable name is returned for error messages.</p>
+</dd>
 <dt><a href="#validateStringArg">validateStringArg(context, argNode, level, messageId)</a></dt>
 <dd><p>Validate that a logger argument is a string when it is a literal.
 Non-literal nodes (identifiers, call expressions) are skipped because their
@@ -182,6 +209,22 @@ are allowed because their runtime type cannot be determined statically.
 | optionsArg | <code>Object</code> | The options argument AST node. |
 | level | <code>string</code> | The logger level (e.g. 'info', 'error'). |
 
+<a name="resolveLevel"></a>
+
+## resolveLevel(callee) ⇒ <code>string</code> \| <code>null</code>
+Resolve the log level from a MemberExpression callee.
+Supports dot notation (`logger.info`), bracket notation with a string literal
+(`logger['info']`), and bracket notation with a variable (`logger[level]`).
+For string literals the value must be a recognised level; variables are assumed
+to hold a valid level and the variable name is returned for error messages.
+
+**Kind**: global function  
+**Returns**: <code>string</code> \| <code>null</code> - The resolved level name, or null when the call should be skipped.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| callee | <code>Object</code> | The MemberExpression callee node. |
+
 <a name="validateStringArg"></a>
 
 ## validateStringArg(context, argNode, level, messageId)

package/index.js

@@ -63,6 +63,31 @@ const validateOptions = (context, optionsArg, level) => {
   }
 };
 
+/**
+ * Resolve the log level from a MemberExpression callee.
+ * Supports dot notation (`logger.info`), bracket notation with a string literal
+ * (`logger['info']`), and bracket notation with a variable (`logger[level]`).
+ * For string literals the value must be a recognised level; variables are assumed
+ * to hold a valid level and the variable name is returned for error messages.
+ * @param {Object} callee - The MemberExpression callee node.
+ * @returns {string|null} The resolved level name, or null when the call should be skipped.
+ */
+const resolveLevel = (callee) => {
+  if (!callee.computed) {
+    const level = callee.property.name;
+    return LEVELS.has(level) ? level : null;
+  }
+
+  const prop = callee.property;
+  if (prop.type === 'Literal' && typeof prop.value === 'string') {
+    return LEVELS.has(prop.value) ? prop.value : null;
+  }
+  if (prop.type === 'Identifier') {
+    return prop.name;
+  }
+  return null;
+};
+
 /**
  * Validate that a logger argument is a string when it is a literal.
  * Non-literal nodes (identifiers, call expressions) are skipped because their
@@ -101,6 +126,7 @@ const plugin = {
           tooManyArguments: 'logger.{{ level }}() accepts at most 4 arguments: (message, meta, correlationId, options). Found {{ count }}.',
           messageNotString: 'logger.{{ level }}() message (1st argument) must be a string. Found {{ actualType }}.',
           correlationIdNotString: 'logger.{{ level }}() correlationId must be a string. Found {{ actualType }}.',
+          missingCorrelationId: 'logger.{{ level }}() called with (message, meta) but missing required correlationId. Expected (message, meta, correlationId).',
           optionsMissingType: 'logger.{{ level }}() options object must contain a "type" property.',
           optionsTypeNotString: 'logger.{{ level }}() options "type" property must be a string.',
         },
@@ -117,10 +143,9 @@ const plugin = {
             if (node.callee.type !== 'MemberExpression') return;
             if (node.callee.object.type !== 'Identifier') return;
             if (!defaultImports.has(node.callee.object.name)) return;
-            if (node.callee.computed) return;
 
-            const level = node.callee.property.name;
-            if (!LEVELS.has(level)) return;
+            const level = resolveLevel(node.callee);
+            if (!level) return;
 
             const args = node.arguments;
 
@@ -146,8 +171,18 @@ const plugin = {
             validateStringArg(context, args[0], level, 'messageNotString');
 
             if (args.length === MIN_ARGS) {
-              // (message, correlationId)
-              validateStringArg(context, args[1], level, 'correlationIdNotString');
+              if (isObjectNode(args[1]) || args[1].type === 'ArrayExpression') {
+                // (message, {object}) or (message, [array]) — missing correlationId
+                context.report({
+                  node,
+                  messageId: 'missingCorrelationId',
+                  data: { level },
+                });
+              }
+              else {
+                // (message, correlationId)
+                validateStringArg(context, args[1], level, 'correlationIdNotString');
+              }
             }
             else if (args.length === THREE_ARGS) {
               // Disambiguate: (message, meta, correlationId) vs (message, correlationId, options)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimik/eslint-plugin-logger",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "validation of the logger parameters for mimik",
   "main": "./index.js",
   "type": "module",