@blumintinc/eslint-plugin-blumint 1.5.5 → 1.6.0

package/lib/index.js

@@ -56,10 +56,16 @@ const no_firestore_object_arrays_1 = require("./rules/no-firestore-object-arrays
 const no_memoize_on_static_1 = require("./rules/no-memoize-on-static");
 const no_unsafe_firestore_spread_1 = require("./rules/no-unsafe-firestore-spread");
 const no_jsx_in_hooks_1 = require("./rules/no-jsx-in-hooks");
+const enforce_assert_throws_1 = require("./rules/enforce-assert-throws");
+const prefer_batch_operations_1 = require("./rules/prefer-batch-operations");
+const no_complex_cloud_params_1 = require("./rules/no-complex-cloud-params");
+const no_mixed_firestore_transactions_1 = require("./rules/no-mixed-firestore-transactions");
+const enforce_firestore_facade_1 = require("./rules/enforce-firestore-facade");
+const sync_onwrite_name_func_1 = require("./rules/sync-onwrite-name-func");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.5.5',
+        version: '1.6.0',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -121,6 +127,12 @@ module.exports = {
                 '@blumintinc/blumint/no-memoize-on-static': 'error',
                 '@blumintinc/blumint/no-unsafe-firestore-spread': 'error',
                 '@blumintinc/blumint/no-jsx-in-hooks': 'error',
+                '@blumintinc/blumint/enforce-assert-throws': 'error',
+                '@blumintinc/blumint/prefer-batch-operations': 'error',
+                '@blumintinc/blumint/no-complex-cloud-params': 'error',
+                '@blumintinc/blumint/no-mixed-firestore-transactions': 'error',
+                '@blumintinc/blumint/enforce-firestore-facade': 'error',
+                '@blumintinc/blumint/sync-onwrite-name-func': 'error',
             },
         },
     },
@@ -178,6 +190,12 @@ module.exports = {
         'no-memoize-on-static': no_memoize_on_static_1.noMemoizeOnStatic,
         'no-unsafe-firestore-spread': no_unsafe_firestore_spread_1.noUnsafeFirestoreSpread,
         'no-jsx-in-hooks': no_jsx_in_hooks_1.noJsxInHooks,
+        'enforce-assert-throws': enforce_assert_throws_1.enforceAssertThrows,
+        'prefer-batch-operations': prefer_batch_operations_1.preferBatchOperations,
+        'no-complex-cloud-params': no_complex_cloud_params_1.noComplexCloudParams,
+        'no-mixed-firestore-transactions': no_mixed_firestore_transactions_1.noMixedFirestoreTransactions,
+        'enforce-firestore-facade': enforce_firestore_facade_1.enforceFirestoreFacade,
+        'sync-onwrite-name-func': sync_onwrite_name_func_1.syncOnwriteNameFunc,
     },
 };
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+export declare const enforceAssertThrows: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"assertShouldThrow", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-assert-throws.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceAssertThrows = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceAssertThrows = (0, createRule_1.createRule)({
+    name: 'enforce-assert-throws',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that functions with assert- prefix must throw an error',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            assertShouldThrow: 'Functions with assert- prefix must throw an error. Either rename the function or add a throw statement.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function hasThrowStatement(node) {
+            let hasThrow = false;
+            function walk(node) {
+                if (node.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+                    hasThrow = true;
+                    return;
+                }
+                // Don't check throw statements in nested functions
+                if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    if (node !== currentFunction) {
+                        return;
+                    }
+                }
+                // Don't count throws in catch blocks that are just re-throwing
+                if (node.type === utils_1.AST_NODE_TYPES.CatchClause) {
+                    return;
+                }
+                // Handle BlockStatement specially
+                if (node.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    node.body.forEach(stmt => walk(stmt));
+                    return;
+                }
+                // Handle IfStatement specially
+                if (node.type === utils_1.AST_NODE_TYPES.IfStatement) {
+                    walk(node.consequent);
+                    if (node.alternate) {
+                        walk(node.alternate);
+                    }
+                    return;
+                }
+                // Handle other node types
+                for (const key of Object.keys(node)) {
+                    const value = node[key];
+                    if (Array.isArray(value)) {
+                        value.forEach(item => {
+                            if (item && typeof item === 'object' && !('parent' in item)) {
+                                walk(item);
+                            }
+                        });
+                    }
+                    else if (value && typeof value === 'object' && !('parent' in value)) {
+                        walk(value);
+                    }
+                }
+            }
+            walk(node);
+            return hasThrow;
+        }
+        let currentFunction = null;
+        function checkFunction(node) {
+            let functionName = '';
+            if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                functionName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : '';
+            }
+            else if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+                functionName = node.id.name;
+            }
+            else if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    functionName = parent.id.name;
+                }
+            }
+            if (functionName.toLowerCase().startsWith('assert')) {
+                currentFunction = node;
+                const functionBody = node.type === utils_1.AST_NODE_TYPES.MethodDefinition ? node.value.body : node.body;
+                if (functionBody && !hasThrowStatement(functionBody)) {
+                    context.report({
+                        node,
+                        messageId: 'assertShouldThrow',
+                    });
+                }
+                currentFunction = null;
+            }
+        }
+        return {
+            FunctionDeclaration: checkFunction,
+            FunctionExpression: checkFunction,
+            ArrowFunctionExpression: checkFunction,
+            MethodDefinition: checkFunction,
+        };
+    },
+});
+//# sourceMappingURL=enforce-assert-throws.js.map

package/lib/rules/enforce-exported-function-types.js

@@ -45,9 +45,10 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             const typeParams = new Set();
             let current = node;
             while (current) {
-                // Handle type parameters in function declarations
+                // Handle type parameters in function declarations, arrow functions, and variable declarations
                 if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                    current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
                     if ('typeParameters' in current && current.typeParameters) {
                         current.typeParameters.params.forEach((param) => {
                             if (param.type === utils_1.AST_NODE_TYPES.TSTypeParameter) {

package/lib/rules/enforce-firestore-facade.d.ts

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

package/lib/rules/enforce-firestore-facade.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFirestoreFacade = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const FIRESTORE_METHODS = new Set(['get', 'set', 'update', 'delete']);
+const isMemberExpression = (node) => {
+    return node.type === utils_1.AST_NODE_TYPES.MemberExpression;
+};
+const isFirestoreMethodCall = (node) => {
+    if (!isMemberExpression(node.callee))
+        return false;
+    const property = node.callee.property;
+    if (!isIdentifier(property) || !FIRESTORE_METHODS.has(property.name)) {
+        return false;
+    }
+    // Check if the method is called on a facade instance
+    const object = node.callee.object;
+    if (isIdentifier(object)) {
+        const name = object.name;
+        // Skip if it's a facade instance
+        if (name.includes('Fetcher') || name.includes('Setter') || name.includes('Tx')) {
+            return false;
+        }
+        // Check for batch or transaction
+        if (/batch|transaction/i.test(name)) {
+            return true;
+        }
+    }
+    // Check if it's a Firestore reference
+    let current = object;
+    let foundDocOrCollection = false;
+    while (current) {
+        if (isCallExpression(current)) {
+            const callee = current.callee;
+            if (isMemberExpression(callee)) {
+                const property = callee.property;
+                if (isIdentifier(property) && (property.name === 'doc' || property.name === 'collection')) {
+                    foundDocOrCollection = true;
+                    break;
+                }
+            }
+        }
+        if (isMemberExpression(current)) {
+            current = current.object;
+        }
+        else {
+            break;
+        }
+    }
+    // If we haven't found a doc/collection call yet, check if the object is a variable
+    if (!foundDocOrCollection && isIdentifier(object)) {
+        const name = object.name;
+        // If the variable name contains 'doc' or 'ref', it's likely a Firestore reference
+        if (name.toLowerCase().includes('doc') || name.toLowerCase().includes('ref')) {
+            return true;
+        }
+    }
+    return foundDocOrCollection;
+};
+const isCallExpression = (node) => {
+    return node.type === utils_1.AST_NODE_TYPES.CallExpression;
+};
+const isIdentifier = (node) => {
+    return node.type === utils_1.AST_NODE_TYPES.Identifier;
+};
+exports.enforceFirestoreFacade = (0, createRule_1.createRule)({
+    name: 'enforce-firestore-facade',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce usage of Firestore facades instead of direct Firestore methods',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noDirectGet: 'Use FirestoreFetcher or FirestoreDocFetcher instead of direct .get() calls',
+            noDirectSet: 'Use DocSetter or DocSetterTransaction instead of direct .set() calls',
+            noDirectUpdate: 'Use DocSetter or DocSetterTransaction instead of direct .update() calls',
+            noDirectDelete: 'Use DocSetter or DocSetterTransaction instead of direct .delete() calls',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isFirestoreMethodCall(node))
+                    return;
+                const callee = node.callee;
+                if (!isMemberExpression(callee))
+                    return;
+                const property = callee.property;
+                if (!isIdentifier(property))
+                    return;
+                // Report appropriate error based on method
+                switch (property.name) {
+                    case 'get':
+                        context.report({
+                            node,
+                            messageId: 'noDirectGet',
+                        });
+                        break;
+                    case 'set':
+                        context.report({
+                            node,
+                            messageId: 'noDirectSet',
+                        });
+                        break;
+                    case 'update':
+                        context.report({
+                            node,
+                            messageId: 'noDirectUpdate',
+                        });
+                        break;
+                    case 'delete':
+                        context.report({
+                            node,
+                            messageId: 'noDirectDelete',
+                        });
+                        break;
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-firestore-facade.js.map

package/lib/rules/enforce-firestore-set-merge.js

@@ -41,8 +41,80 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                             }
                         }
                     }
-                    // Only flag update() calls
-                    return property.name === 'update';
+                    // Only flag update() calls that are Firestore operations
+                    if (property.name === 'update') {
+                        const object = node.callee.object;
+                        // Check for BatchManager update calls
+                        if (object.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            object.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            object.property.name === 'batchManager') {
+                            return true;
+                        }
+                        if (object.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                            // Check if it's a createHash().update() call
+                            if (object.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                object.callee.name === 'createHash') {
+                                return false;
+                            }
+                        }
+                        // Check if it's a Firestore document reference or transaction
+                        let current = node;
+                        while (current?.parent) {
+                            current = current.parent;
+                            if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                                const obj = current.object;
+                                if (obj.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    // Check for common Firestore variable names
+                                    if (obj.name === 'db' ||
+                                        obj.name === 'firestore' ||
+                                        obj.name === 'transaction' ||
+                                        obj.name === 'docRef' ||
+                                        obj.name === 'userRef' ||
+                                        obj.name.endsWith('Ref')) {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                        // Check if it's a Firestore document reference method chain
+                        let currentObj = object;
+                        while (currentObj.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                            if (currentObj.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                const methodName = currentObj.property.name;
+                                if (methodName === 'collection' || methodName === 'doc') {
+                                    return true;
+                                }
+                            }
+                            currentObj = currentObj.object;
+                        }
+                        // Check if it's a transaction.update() call
+                        if (object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            object.name === 'transaction') {
+                            return true;
+                        }
+                        // Check if it's a Firestore document reference by looking at imports
+                        const program = context
+                            .getAncestors()
+                            .find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
+                        if (program) {
+                            for (const node of program.body) {
+                                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                                    for (const decl of node.declarations) {
+                                        if (decl.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                                            decl.init.callee.type ===
+                                                utils_1.AST_NODE_TYPES.MemberExpression &&
+                                            decl.init.callee.property.type ===
+                                                utils_1.AST_NODE_TYPES.Identifier &&
+                                            decl.init.callee.property.name === 'firestore') {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        return false;
+                    }
+                    return false;
                 }
             }
             if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -75,6 +147,15 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                     const data = sourceCode.getText(args[1]);
                     return `${object}.set(${docRef}, ${data}, { merge: true })`;
                 }
+                if (object.includes('batchManager')) {
+                    const docRef = sourceCode.getText(args[0]);
+                    const data = sourceCode.getText(args[1]);
+                    return `${object}.set({
+          ref: ${docRef},
+          data: ${data},
+          merge: true,
+        })`;
+                }
                 const data = sourceCode.getText(args[0]);
                 return `${object}.set(${data}, { merge: true })`;
             }

package/lib/rules/enforce-verb-noun-naming.js

@@ -432,6 +432,7 @@ const VERBS_SET = new Set([
     'include',
     'includes',
     'increase',
+    'increment',
     'index',
     'influence',
     'inform',

package/lib/rules/no-complex-cloud-params.d.ts

@@ -0,0 +1 @@
+export declare const noComplexCloudParams: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noComplexObjects", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;