@blumintinc/eslint-plugin-blumint 1.20.112 → 1.20.113

package/lib/index.js

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

package/lib/rules/enforce-serializable-params.d.ts

@@ -5,5 +5,6 @@ declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").R
 }[], {
     TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
     TSTypeReference(node: TSESTree.TSTypeReference): void;
+    'Program:exit'(): void;
 }>;
 export default _default;

package/lib/rules/enforce-serializable-params.js

@@ -100,6 +100,13 @@ exports.default = (0, createRule_1.createRule)({
                     break;
             }
         }
+        /**
+         * TypeScript hoists type aliases, so a request type may be declared below
+         * the function that consumes it. Collecting the wrapper references and
+         * resolving them once traversal is finished decouples the check from
+         * declaration order, which `typeAliasMap` alone cannot do.
+         */
+        const wrapperReferences = [];
         return {
             TSTypeAliasDeclaration(node) {
                 typeAliasMap.set(node.id.name, node);
@@ -108,13 +115,25 @@ exports.default = (0, createRule_1.createRule)({
                 const typeName = node.typeName.name;
                 if (options.functionTypes.includes(typeName) &&
                     node.typeParameters?.params[0]) {
-                    const typeParam = node.typeParameters.params[0];
+                    wrapperReferences.push(node);
+                }
+            },
+            'Program:exit'() {
+                for (const node of wrapperReferences) {
+                    const typeParam = node.typeParameters?.params[0];
+                    if (!typeParam)
+                        continue;
                     if (typeParam.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                         const referencedTypeName = typeParam.typeName.name;
                         const typeAlias = typeAliasMap.get(referencedTypeName);
-                        if (typeAlias) {
-                            checkTypeNode(typeAlias.typeAnnotation);
-                        }
+                        /**
+                         * A reference that names no local alias is still a type in its own
+                         * right — `CallableRequest<Timestamp>` is the plainest form of the
+                         * violation. Checking the node itself lets the non-serializable
+                         * lookup and the generic descent apply; an unrecognized name simply
+                         * yields no report, so an imported request type stays silent.
+                         */
+                        checkTypeNode(typeAlias ? typeAlias.typeAnnotation : typeParam);
                     }
                     else {
                         checkTypeNode(typeParam);

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.113",
+    "date": "2026-08-05T17:37:08.020Z",
+    "rules": [
+      {
+        "name": "enforce-serializable-params",
+        "changeType": "fix",
+        "issues": [
+          1750
+        ],
+        "summary": "report a non-JSON-safe type used directly as the request type parameter (closes #1750)"
+      }
+    ]
+  },
   {
     "version": "1.20.112",
     "date": "2026-08-05T16:17:08.283Z",