@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.0

package/lib/rules/{enforce-assertSafe-object-key.js → enforce-assert-safe-object-key.js}

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceAssertSafeObjectKey = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const DEFAULT_IMPORT_PATH = 'functions/src/util/assertSafe';
 exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
-    name: 'enforce-assertSafe-object-key',
+    name: 'enforce-assert-safe-object-key',
     meta: {
         type: 'problem',
         docs: {
@@ -12,13 +13,22 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         fixable: 'code',
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    assertSafeImportPath: { type: 'string' },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
-            useAssertSafe: 'Use assertSafe() for object key access to ensure safe property access. Replace `obj[String(id)]` or `obj[`${id}`]` with `obj[assertSafe(id)]`.',
+            useAssertSafe: 'Dynamic object key "{{key}}" is used without assertSafe() validation. Unvalidated keys can resolve to unexpected properties (including prototype fields) and make lookups fragile or unsafe. Wrap the key with assertSafe({{key}}) before accessing the object.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const importPath = options?.assertSafeImportPath || DEFAULT_IMPORT_PATH;
         let hasAssertSafeImport = false;
         /**
          * Helper function to add assertSafe import if needed
@@ -26,7 +36,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
         const addAssertSafeImport = (fixer) => {
             const program = context.getSourceCode().ast;
             const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-            const importStatement = "import { assertSafe } from 'functions/src/util/assertSafe';\n";
+            const importStatement = `import { assertSafe } from '${importPath}';\n`;
             if (firstImport) {
                 return fixer.insertTextBefore(firstImport, importStatement);
             }
@@ -48,6 +58,14 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             fixes.push(fixer.replaceText(node, `assertSafe(${argText})`));
             return fixes;
         };
+        const reportUseAssertSafe = (node, expressionText) => context.report({
+            node,
+            messageId: 'useAssertSafe',
+            data: { key: expressionText },
+            fix(fixer) {
+                return createFixes(fixer, node, expressionText);
+            },
+        });
         return {
             ImportDeclaration(node) {
                 // Check if assertSafe is already imported
@@ -64,15 +82,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     if (key.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         key.callee.name === 'String') {
-                        context.report({
-                            node: key,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const arg = key.arguments[0];
-                                const argText = context.getSourceCode().getText(arg);
-                                return createFixes(fixer, key, argText);
-                            },
-                        });
+                        const arg = key.arguments[0];
+                        const argText = context.getSourceCode().getText(arg);
+                        reportUseAssertSafe(key, argText);
                     }
                     // Check for template literals like `${id}`
                     if (key.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
@@ -80,15 +92,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         key.quasis.length === 2 &&
                         key.quasis[0].value.raw === '' &&
                         key.quasis[1].value.raw === '') {
-                        context.report({
-                            node: key,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const expr = key.expressions[0];
-                                const exprText = context.getSourceCode().getText(expr);
-                                return createFixes(fixer, key, exprText);
-                            },
-                        });
+                        const expr = key.expressions[0];
+                        const exprText = context.getSourceCode().getText(expr);
+                        reportUseAssertSafe(key, exprText);
                     }
                 }
             },
@@ -100,15 +106,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     if (left.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         left.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         left.callee.name === 'String') {
-                        context.report({
-                            node: left,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const arg = left.arguments[0];
-                                const argText = context.getSourceCode().getText(arg);
-                                return createFixes(fixer, left, argText);
-                            },
-                        });
+                        const arg = left.arguments[0];
+                        const argText = context.getSourceCode().getText(arg);
+                        reportUseAssertSafe(left, argText);
                     }
                     // Check for template literals like `${id}`
                     if (left.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
@@ -116,15 +116,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         left.quasis.length === 2 &&
                         left.quasis[0].value.raw === '' &&
                         left.quasis[1].value.raw === '') {
-                        context.report({
-                            node: left,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const expr = left.expressions[0];
-                                const exprText = context.getSourceCode().getText(expr);
-                                return createFixes(fixer, left, exprText);
-                            },
-                        });
+                        const expr = left.expressions[0];
+                        const exprText = context.getSourceCode().getText(expr);
+                        reportUseAssertSafe(left, exprText);
                     }
                 }
             },
@@ -163,15 +157,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     if (property.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         property.callee.name === 'String') {
-                        context.report({
-                            node: property,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const arg = property.arguments[0];
-                                const argText = context.getSourceCode().getText(arg);
-                                return createFixes(fixer, property, argText);
-                            },
-                        });
+                        const arg = property.arguments[0];
+                        const argText = context.getSourceCode().getText(arg);
+                        reportUseAssertSafe(property, argText);
                         return;
                     }
                     // Check for template literals
@@ -190,16 +178,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                             // Complex template literals with additional text are fine
                             return;
                         }
-                        context.report({
-                            node: property,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                // Extract the expression from the template literal
-                                const expr = property.expressions[0];
-                                const exprText = context.getSourceCode().getText(expr);
-                                return createFixes(fixer, property, exprText);
-                            },
-                        });
+                        const expr = property.expressions[0];
+                        const exprText = context.getSourceCode().getText(expr);
+                        reportUseAssertSafe(property, exprText);
                         return;
                     }
                     // Check for direct variable usage (identifiers)
@@ -212,15 +193,8 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        context.report({
-                            node: property,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                // For direct variable use, just use the variable name
-                                const propText = context.getSourceCode().getText(property);
-                                return createFixes(fixer, property, propText);
-                            },
-                        });
+                        const propText = context.getSourceCode().getText(property);
+                        reportUseAssertSafe(property, propText);
                         return;
                     }
                     // Check for binary expressions (like index + 1)
@@ -229,14 +203,8 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        context.report({
-                            node: property,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const propText = context.getSourceCode().getText(property);
-                                return createFixes(fixer, property, propText);
-                            },
-                        });
+                        const propText = context.getSourceCode().getText(property);
+                        reportUseAssertSafe(property, propText);
                         return;
                     }
                     // Check for boolean expressions and other literals
@@ -247,14 +215,8 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        context.report({
-                            node: property,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const propText = context.getSourceCode().getText(property);
-                                return createFixes(fixer, property, propText);
-                            },
-                        });
+                        const propText = context.getSourceCode().getText(property);
+                        reportUseAssertSafe(property, propText);
                         return;
                     }
                     // Check for function calls (anything that isn't handled above)
@@ -266,14 +228,8 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        context.report({
-                            node: property,
-                            messageId: 'useAssertSafe',
-                            fix(fixer) {
-                                const propText = context.getSourceCode().getText(property);
-                                return createFixes(fixer, property, propText);
-                            },
-                        });
+                        const propText = context.getSourceCode().getText(property);
+                        reportUseAssertSafe(property, propText);
                         return;
                     }
                 }
@@ -281,4 +237,4 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=enforce-assertSafe-object-key.js.map
+//# sourceMappingURL=enforce-assert-safe-object-key.js.map

package/lib/rules/enforce-assert-throws.d.ts

@@ -1 +1,3 @@
-export declare const enforceAssertThrows: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"assertShouldThrow", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+type MessageIds = 'assertShouldThrow' | 'shouldBeAssertPrefixed';
+export declare const enforceAssertThrows: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};