chore: add no mixed nullish coalescing rule

Author: Miodec

backend/__tests__/__testData__/connections.ts

@@ -5,14 +5,15 @@ export async function createConnection(
   data: Partial<ConnectionsDal.DBConnection>,
   maxPerUser = 25,
 ): Promise<ConnectionsDal.DBConnection> {
+  const defaultName = "user" + new ObjectId().toHexString();
   const result = await ConnectionsDal.create(
     {
       uid: data.initiatorUid ?? new ObjectId().toHexString(),
-      name: data.initiatorName ?? "user" + new ObjectId().toHexString(),
+      name: data.initiatorName ?? defaultName,
     },
     {
       uid: data.receiverUid ?? new ObjectId().toHexString(),
-      name: data.receiverName ?? "user" + new ObjectId().toHexString(),
+      name: data.receiverName ?? defaultName,
     },
     maxPerUser,
   );

packages/oxlint-config/plugin.jsonc

@@ -13,6 +13,7 @@
   "rules": {
     "all": "off",
     "monkeytype-rules/no-testing-access": "error",
+    "monkeytype-rules/no-mixed-nullish-coalescing": "error",
   },
   "overrides": [
     {

packages/oxlint-config/plugins/monkeytype-rules.js

@@ -198,6 +198,56 @@ const plugin = {
         };
       },
     }),
+    "no-mixed-nullish-coalescing": defineRule({
+      createOnce(context) {
+        /**
+         * Returns true for expression node types that, when combined with ??
+         * without explicit parentheses, create confusing/ambiguous precedence.
+         * Excluded: UnaryExpression (clearly bound to its operand),
+         *           LogicalExpression with ?? (same operator, unambiguous).
+         */
+        const isParenthesized = (node, source) => {
+          // OXC strips ParenthesizedExpression from the AST before visiting,
+          // so check the raw source surrounding the node's range instead.
+          const start = node.range?.[0] ?? node.start;
+          const end = node.range?.[1] ?? node.end;
+          return source[start - 1] === "(" && source[end] === ")";
+        };
+
+        const isMixedOperatorNode = (node, source) => {
+          if (isParenthesized(node, source)) return false;
+          return (
+            node.type === "BinaryExpression" ||
+            (node.type === "LogicalExpression" && node.operator !== "??") ||
+            node.type === "ConditionalExpression"
+          );
+        };
+
+        return {
+          LogicalExpression(node) {
+            if (node.operator !== "??") return;
+
+            const source = context.sourceCode.getText();
+
+            if (isMixedOperatorNode(node.left, source)) {
+              context.report({
+                node: node.left,
+                message:
+                  "Nullish coalescing (`??`) mixed with other operators without explicit parentheses. Extract to a helper variable or wrap in parentheses for clarity.",
+              });
+            }
+
+            if (isMixedOperatorNode(node.right, source)) {
+              context.report({
+                node: node.right,
+                message:
+                  "Nullish coalescing (`??`) mixed with other operators without explicit parentheses. Extract to a helper variable or wrap in parentheses for clarity.",
+              });
+            }
+          },
+        };
+      },
+    }),
     "component-pascal-case": defineRule({
       createOnce(context) {
         const isPascalCase = (name) => /^[A-Z][a-zA-Z0-9]*$/.test(name);