@blumintinc/eslint-plugin-blumint 1.20.57 → 1.20.58

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.57',
+        version: '1.20.58',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-memoize-async.js

@@ -42,6 +42,39 @@ function bindsMemoize(variable) {
                 ALLOWED_MEMOIZE_MODULES.has(String(declaration.source.value)));
         }));
 }
+/**
+ * Whether a declared return type annotation promises no value: `void` or
+ * `Promise<void>`.
+ *
+ * Memoizing such a method caches nothing — there is no result to hand back —
+ * while changing runtime behaviour: the side effects run once per instance and
+ * every later call silently no-ops. Because the decision comes from the
+ * annotation node, spacing and line breaks inside the type are irrelevant.
+ *
+ * The check stays keyed to a plain `void`: a union (`Promise<void | undefined>`)
+ * or a type parameter (`Promise<T>`) can resolve to a value, so those still
+ * warrant caching. Absent annotations are likewise not exempt — this rule is
+ * syntactic (no `parserOptions.project`), so an unannotated body carries no
+ * declaration of intent to honour, and exempting inferred void would silently
+ * drop methods the author never marked value-less.
+ */
+function declaresVoidResult(returnType) {
+    const annotation = returnType?.typeAnnotation;
+    if (!annotation) {
+        return false;
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+        return true;
+    }
+    if (annotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+        annotation.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        annotation.typeName.name !== 'Promise') {
+        return false;
+    }
+    const typeArguments = annotation.typeParameters?.params;
+    return (typeArguments?.length === 1 &&
+        typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -148,6 +181,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (node.value.params.length > 1) {
                     return;
                 }
+                // A method declared to produce no value has no result to cache, so the
+                // decorator's benefit is unobtainable while its cost is real: the
+                // fixer would convert a repeatable side effect into a
+                // once-per-instance one, unattended, under `--fix`.
+                if (declaresVoidResult(node.value.returnType)) {
+                    return;
+                }
                 const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
                 const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.57",
+  "version": "1.20.58",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.58",
+    "date": "2026-08-01T04:26:49.434Z",
+    "rules": [
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1548
+        ],
+        "summary": "skip methods declared Promise<void> (closes #1548)"
+      }
+    ]
+  },
   {
     "version": "1.20.57",
     "date": "2026-08-01T03:42:42.343Z",