@mimik/eslint-plugin-logger 1.0.2 → 1.0.3

package/README.md

@@ -81,166 +81,41 @@ 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 string literal, the value must be a recognized 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 2 arguments are passed and the 2nd is an object or array 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)`
 
 ## API Reference
 
-## Constants
-
-<dl>
-<dt><a href="#plugin">plugin</a> : <code>Object</code></dt>
-<dd><p>ESLint plugin for validating logger call arguments.</p>
-</dd>
-</dl>
-
-## Functions
-
-<dl>
-<dt><a href="#isNonStringLiteral">isNonStringLiteral(node)</a> ⇒ <code>boolean</code></dt>
-<dd><p>Check whether an AST node is a non-string literal (number, boolean, null).</p>
-</dd>
-<dt><a href="#isObjectNode">isObjectNode(node)</a> ⇒ <code>boolean</code></dt>
-<dd><p>Check whether an AST node is an object expression.</p>
-</dd>
-<dt><a href="#isTypeKey">isTypeKey(prop)</a> ⇒ <code>boolean</code></dt>
-<dd><p>Check whether a property node has the key <code>type</code> (identifier or string literal).</p>
-</dd>
-<dt><a href="#findTypeProperty">findTypeProperty(node)</a> ⇒ <code>Object</code> | <code>undefined</code></dt>
-<dd><p>Find the <code>type</code> property node inside an ObjectExpression.
-Handles both identifier keys (<code>{ type: ... }</code>) and string-literal keys (<code>{ &quot;type&quot;: ... }</code>).</p>
-</dd>
-<dt><a href="#validateOptions">validateOptions(context, optionsArg, level)</a></dt>
-<dd><p>Validate the options argument of a logger call.
-Reports an error when the options object is missing a <code>type</code> property or when the
-<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
-runtime type cannot be determined statically.</p>
-</dd>
-</dl>
-
-<a name="plugin"></a>
-
-## plugin : <code>Object</code>
-ESLint plugin for validating logger call arguments.
-
-**Kind**: global constant  
-<a name="isNonStringLiteral"></a>
-
-## isNonStringLiteral(node) ⇒ <code>boolean</code>
-Check whether an AST node is a non-string literal (number, boolean, null).
-
-**Kind**: global function  
-**Returns**: <code>boolean</code> - True when the node is a literal whose value is not a string.  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| node | <code>Object</code> | The AST node to check. |
-
-<a name="isObjectNode"></a>
-
-## isObjectNode(node) ⇒ <code>boolean</code>
-Check whether an AST node is an object expression.
-
-**Kind**: global function  
-**Returns**: <code>boolean</code> - True when the node is an ObjectExpression.  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| node | <code>Object</code> | The AST node to check. |
-
-<a name="isTypeKey"></a>
-
-## isTypeKey(prop) ⇒ <code>boolean</code>
-Check whether a property node has the key `type` (identifier or string literal).
-
-**Kind**: global function  
-**Returns**: <code>boolean</code> - True when the key is `type`.  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| prop | <code>Object</code> | The property node. |
-
-<a name="findTypeProperty"></a>
-
-## findTypeProperty(node) ⇒ <code>Object</code> \| <code>undefined</code>
-Find the `type` property node inside an ObjectExpression.
-Handles both identifier keys (`{ type: ... }`) and string-literal keys (`{ "type": ... }`).
-
-**Kind**: global function  
-**Returns**: <code>Object</code> \| <code>undefined</code> - The property node, or undefined if not found.  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| node | <code>Object</code> | The object expression node. |
-
-<a name="validateOptions"></a>
-
-## validateOptions(context, optionsArg, level)
-Validate the options argument of a logger call.
-Reports an error when the options object is missing a `type` property or when the
-`type` value is a non-string literal. Variable references (e.g. `{ type: someVar }`)
-are allowed because their runtime type cannot be determined statically.
-
-**Kind**: global function  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| context | <code>Object</code> | The ESLint rule context. |
-| 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.
+The plugin exports a single object with the following shape:
 
-**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)
-Validate that a logger argument is a string when it is a literal.
-Non-literal nodes (identifiers, call expressions) are skipped because their
-runtime type cannot be determined statically.
-
-**Kind**: global function  
-
-| Param | Type | Description |
-| --- | --- | --- |
-| context | <code>Object</code> | The ESLint rule context. |
-| argNode | <code>Object</code> | The argument AST node. |
-| level | <code>string</code> | The logger level (e.g. 'info', 'error'). |
-| messageId | <code>string</code> | The ESLint message ID to report on failure. |
+```js
+{
+  rules: {
+    'validate-logger-args': { meta, create(context) }
+  }
+}
+```
 
+### Error Messages
+
+| Message ID | Description |
+|---|---|
+| `tooFewArguments` | Fewer than 2 arguments passed |
+| `tooManyArguments` | More than 4 arguments passed |
+| `messageNotString` | First argument is a non-string literal |
+| `correlationIdNotString` | correlationId argument is a non-string literal |
+| `missingCorrelationId` | 2nd argument is an object or array — correlationId is missing |
+| `optionsNotObject` | Options argument is a literal instead of an object |
+| `optionsMissingType` | Options object does not contain a `type` property |
+| `optionsTypeNotString` | Options `type` property is a non-string literal |
 
 ## License
 

package/index.js

@@ -3,49 +3,39 @@ const MIN_ARGS = 2;
 const THREE_ARGS = 3;
 const MAX_ARGS = 4;
 
-/**
- * Check whether an AST node is a non-string literal (number, boolean, null).
- * @param {Object} node - The AST node to check.
- * @returns {boolean} True when the node is a literal whose value is not a string.
- */
+/** @private True when node is a literal whose value is not a string. */
 const isNonStringLiteral = node => node.type === 'Literal' && typeof node.value !== 'string';
 
-/**
- * Check whether an AST node is an object expression.
- * @param {Object} node - The AST node to check.
- * @returns {boolean} True when the node is an ObjectExpression.
- */
+/** @private True when node is an ObjectExpression. */
 const isObjectNode = node => node.type === 'ObjectExpression';
 
-/**
- * Check whether a property node has the key `type` (identifier or string literal).
- * @param {Object} prop - The property node.
- * @returns {boolean} True when the key is `type`.
- */
+/** @private True when the property key is `type` (identifier or string literal). */
 const isTypeKey = prop => prop.type === 'Property'
   && !prop.computed
   && ((prop.key.type === 'Identifier' && prop.key.name === 'type')
     || (prop.key.type === 'Literal' && prop.key.value === 'type'));
 
-/**
- * Find the `type` property node inside an ObjectExpression.
- * Handles both identifier keys (`{ type: ... }`) and string-literal keys (`{ "type": ... }`).
- * @param {Object} node - The object expression node.
- * @returns {Object|undefined} The property node, or undefined if not found.
- */
+/** @private Find the `type` property inside an ObjectExpression. */
 const findTypeProperty = node => node.properties.find(isTypeKey);
 
 /**
  * Validate the options argument of a logger call.
- * Reports an error when the options object is missing a `type` property or when the
- * `type` value is a non-string literal. Variable references (e.g. `{ type: someVar }`)
- * are allowed because their runtime type cannot be determined statically.
- * @param {Object} context - The ESLint rule context.
- * @param {Object} optionsArg - The options argument AST node.
- * @param {string} level - The logger level (e.g. 'info', 'error').
+ * Reports when options is any literal (not an object), when the object is missing
+ * a `type` property, or when `type` is a non-string literal.
+ * Identifiers and other expressions are skipped (runtime type unknown).
+ * @private
  */
 const validateOptions = (context, optionsArg, level) => {
-  if (!isObjectNode(optionsArg)) return;
+  if (!isObjectNode(optionsArg)) {
+    if (optionsArg.type === 'Literal') {
+      context.report({
+        node: optionsArg,
+        messageId: 'optionsNotObject',
+        data: { level, actualType: typeof optionsArg.value },
+      });
+    }
+    return;
+  }
   const typeProp = findTypeProperty(optionsArg);
   if (!typeProp) {
     context.report({
@@ -65,12 +55,8 @@ 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.
+ * Returns the level name for dot/bracket notation, or null to skip.
+ * @private
  */
 const resolveLevel = (callee) => {
   if (!callee.computed) {
@@ -89,13 +75,9 @@ const resolveLevel = (callee) => {
 };
 
 /**
- * Validate that a logger argument is a string when it is a literal.
- * Non-literal nodes (identifiers, call expressions) are skipped because their
- * runtime type cannot be determined statically.
- * @param {Object} context - The ESLint rule context.
- * @param {Object} argNode - The argument AST node.
- * @param {string} level - The logger level (e.g. 'info', 'error').
- * @param {string} messageId - The ESLint message ID to report on failure.
+ * Report when a literal argument is not a string.
+ * Non-literal nodes are skipped (runtime type unknown).
+ * @private
  */
 const validateStringArg = (context, argNode, level, messageId) => {
   if (isNonStringLiteral(argNode)) {
@@ -108,10 +90,14 @@ const validateStringArg = (context, argNode, level, messageId) => {
 };
 
 /**
- * ESLint plugin for validating logger call arguments.
- * @type {Object}
+ * ESLint plugin that validates logger call argument signatures.
+ * Only tracks default imports (`import logger from '...'`).
  */
 const plugin = {
+  meta: {
+    name: '@mimik/eslint-plugin-logger',
+    version: '2.0.8',
+  },
   rules: {
     'validate-logger-args': {
       meta: {
@@ -126,7 +112,8 @@ 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).',
+          missingCorrelationId: 'logger.{{ level }}() 2nd argument is an object or array — missing required correlationId. Expected (message, meta, correlationId).',
+          optionsNotObject: 'logger.{{ level }}() options argument must be an object. Found {{ actualType }}.',
           optionsMissingType: 'logger.{{ level }}() options object must contain a "type" property.',
           optionsTypeNotString: 'logger.{{ level }}() options "type" property must be a string.',
         },

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@mimik/eslint-plugin-logger",
-  "version": "1.0.2",
-  "description": "validation of the logger parameters for mimik",
+  "version": "1.0.3",
+  "description": "Validation of logger call parameters for mimik services",
   "main": "./index.js",
   "type": "module",
+  "exports": "./index.js",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "scripts": {
-    "lint": "eslint . --no-error-on-unmatched-pattern",
     "docs": "jsdoc2md --template docs/README.hbs index.js > README.md",
-    "test": "mocha --reporter mochawesome test/ --recursive",
+    "lint": "eslint . --no-error-on-unmatched-pattern",
+    "test": "mocha --reporter mochawesome --bail --exit --check-leaks test/",
     "test-ci": "c8 --reporter=lcov --reporter=text npm test",
     "prepublishOnly": "npm run docs && npm run lint && npm run test-ci",
     "commit-ready": "npm run docs && npm run lint && npm run test-ci"
@@ -17,22 +21,20 @@
     "eslint",
     "eslint-plugin",
     "eslintplugin",
-    "logger"
+    "logger",
+    "@mimik/sumologic-winston-logger"
   ],
   "author": "mimik technology inc <support@mimik.com> (https://developer.mimik.com/)",
   "license": "MIT",
-  "engines": {
-    "node": ">=24"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://bitbucket.org/mimiktech/eslint-plugin-logger.git"
   },
   "devDependencies": {
-    "@eslint/js": "9.39.3",
+    "@eslint/js": "9.39.4",
     "@stylistic/eslint-plugin": "5.10.0",
     "c8": "11.0.0",
-    "eslint": "9.39.3",
+    "eslint": "9.39.4",
     "eslint-plugin-import": "2.32.0",
     "globals": "17.4.0",
     "husky": "9.1.7",