eslint-plugin-nextfriday 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eslint-plugin-nextfriday
 
+## 1.5.0
+
+### Minor Changes
+
+- [#28](https://github.com/next-friday/eslint-plugin-nextfriday/pull/28) [`387c2b8`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/387c2b8a6d0e4668daa035ab3bc3ad2f41e5d8f3) Thanks [@nextfridaydeveloper](https://github.com/nextfridaydeveloper)! - Add new `no-env-fallback` rule to prevent dangerous fallback values for environment variables. This rule disallows using `||`, `??`, or ternary operators with `process.env` to ensure applications fail explicitly when required environment variables are missing rather than silently using default values.
+
 ## 1.4.0
 
 ### Minor Changes

package/README.md

@@ -69,6 +69,7 @@ export default [
       "nextfriday/prefer-react-import-types": "error",
       "nextfriday/no-complex-inline-return": "error",
       "nextfriday/no-logic-in-params": "error",
+      "nextfriday/no-env-fallback": "error",
       "nextfriday/jsx-pascal-case": "error",
       "nextfriday/prefer-interface-over-inline-types": "error",
       "nextfriday/react-props-destructure": "error",
@@ -125,6 +126,7 @@ module.exports = {
 | [enforce-readonly-component-props](docs/rules/ENFORCE_READONLY_COMPONENT_PROPS.md)     | Enforce Readonly wrapper for React component props                            | ✅      |
 | [no-complex-inline-return](docs/rules/NO_COMPLEX_INLINE_RETURN.md)                     | Disallow complex inline expressions in return statements - prefer const first | ❌      |
 | [no-logic-in-params](docs/rules/NO_LOGIC_IN_PARAMS.md)                                 | Disallow logic or conditions in function parameters - extract to const first  | ❌      |
+| [no-env-fallback](docs/rules/NO_ENV_FALLBACK.md)                                       | Disallow fallback values for environment variables as they can be dangerous   | ❌      |
 
 ## Configurations
 
@@ -144,6 +146,7 @@ Basic configuration without JSX-specific rules:
 - `nextfriday/prefer-react-import-types`: `"error"`
 - `nextfriday/no-complex-inline-return`: `"error"`
 - `nextfriday/no-logic-in-params`: `"error"`
+- `nextfriday/no-env-fallback`: `"error"`
 
 #### `base/recommended`
 

package/docs/rules/NO_ENV_FALLBACK.md

@@ -0,0 +1,53 @@
+# no-env-fallback
+
+Disallow fallback values for environment variables as they can be dangerous in production.
+
+## Rule Details
+
+This rule prevents using fallback values with `process.env` environment variables. When environment variables have fallback values (using `||`, `??`, or ternary operators), applications can silently run with default values instead of failing when required configuration is missing. This can lead to security issues, incorrect behavior in production, or hard-to-debug problems.
+
+It's safer to let the application fail explicitly when required environment variables are missing, rather than continuing with potentially incorrect default values.
+
+## Examples
+
+**Incorrect** code for this rule:
+
+```js
+const apiKey = process.env.API_KEY || "default-key";
+const dbUrl = process.env.DATABASE_URL ?? "localhost";
+const port = process.env.PORT ? "8080" : "3000";
+
+const config = {
+  secret: process.env.SECRET_KEY || "unsafe-default",
+  region: process.env.AWS_REGION ?? "us-east-1",
+};
+
+function getToken() {
+  return process.env.AUTH_TOKEN || "abc123";
+}
+```
+
+**Correct** code for this rule:
+
+```js
+const apiKey = process.env.API_KEY;
+const dbUrl = process.env.DATABASE_URL;
+const port = process.env.PORT;
+
+const config = {
+  secret: process.env.SECRET_KEY,
+  region: process.env.AWS_REGION,
+};
+
+function getToken() {
+  return process.env.AUTH_TOKEN;
+}
+
+if (!process.env.API_KEY) {
+  throw new Error("API_KEY environment variable is required");
+}
+```
+
+## When Not To Use It
+
+If your application intentionally uses default values for optional configuration and you have explicit handling for required vs optional environment variables, you may want to disable this rule. However, it's generally safer to validate required environment variables at application startup rather than using fallback values.

package/lib/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.4.0",
+  version: "1.5.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -90,8 +90,8 @@ var package_default = {
     "changeset:publish": "npm publish --provenance --access public",
     "changeset:version": "changeset version",
     clear: "rm -rf lib node_modules/.cache .eslintcache",
-    eslint: "eslint src --ext .js,.ts,.mjs --fix",
-    "eslint:check": "eslint src --ext .js,.ts,.mjs",
+    eslint: "eslint src --ext .js,.ts --fix",
+    "eslint:check": "eslint src --ext .js,.ts",
     preinstall: "npx only-allow pnpm",
     prepare: "husky",
     prepublishOnly: "pnpm run build",
@@ -465,12 +465,65 @@ var noEmoji = createRule6({
 });
 var no_emoji_default = noEmoji;
 
-// src/rules/no-explicit-return-type.ts
+// src/rules/no-env-fallback.ts
 var import_utils7 = require("@typescript-eslint/utils");
 var createRule7 = import_utils7.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var noExplicitReturnType = createRule7({
+var noEnvFallback = createRule7({
+  name: "no-env-fallback",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow fallback values for environment variables as they can be dangerous in production"
+    },
+    messages: {
+      noEnvFallback: "Avoid using fallback values with process.env. Environment variables should fail explicitly when missing rather than silently using a default value."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isProcessEnvAccess = (node) => {
+      if (node.type !== import_utils7.AST_NODE_TYPES.MemberExpression) {
+        return false;
+      }
+      const { object } = node;
+      if (object.type !== import_utils7.AST_NODE_TYPES.MemberExpression) {
+        return false;
+      }
+      const processNode = object.object;
+      const envNode = object.property;
+      return processNode.type === import_utils7.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils7.AST_NODE_TYPES.Identifier && envNode.name === "env";
+    };
+    return {
+      LogicalExpression(node) {
+        if ((node.operator === "||" || node.operator === "??") && isProcessEnvAccess(node.left)) {
+          context.report({
+            node,
+            messageId: "noEnvFallback"
+          });
+        }
+      },
+      ConditionalExpression(node) {
+        if (isProcessEnvAccess(node.test)) {
+          context.report({
+            node,
+            messageId: "noEnvFallback"
+          });
+        }
+      }
+    };
+  }
+});
+var no_env_fallback_default = noEnvFallback;
+
+// src/rules/no-explicit-return-type.ts
+var import_utils8 = require("@typescript-eslint/utils");
+var createRule8 = import_utils8.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+);
+var noExplicitReturnType = createRule8({
   name: "no-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -510,11 +563,11 @@ var noExplicitReturnType = createRule7({
 var no_explicit_return_type_default = noExplicitReturnType;
 
 // src/rules/no-logic-in-params.ts
-var import_utils8 = require("@typescript-eslint/utils");
-var createRule8 = import_utils8.ESLintUtils.RuleCreator(
+var import_utils9 = require("@typescript-eslint/utils");
+var createRule9 = import_utils9.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule8({
+var noLogicInParams = createRule9({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -529,20 +582,20 @@ var noLogicInParams = createRule8({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === import_utils8.AST_NODE_TYPES.SpreadElement) {
+      if (node.type === import_utils9.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
-      if (node.type === import_utils8.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils9.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils8.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils9.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils8.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils9.AST_NODE_TYPES.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === import_utils8.AST_NODE_TYPES.UnaryExpression) {
+      if (node.type === import_utils9.AST_NODE_TYPES.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -574,11 +627,11 @@ var noLogicInParams = createRule8({
 var no_logic_in_params_default = noLogicInParams;
 
 // src/rules/prefer-destructuring-params.ts
-var import_utils9 = require("@typescript-eslint/utils");
-var createRule9 = import_utils9.ESLintUtils.RuleCreator(
+var import_utils10 = require("@typescript-eslint/utils");
+var createRule10 = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule9({
+var preferDestructuringParams = createRule10({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -594,18 +647,18 @@ var preferDestructuringParams = createRule9({
   create(context) {
     const isCallbackFunction = (node) => {
       const { parent } = node;
-      return parent?.type === import_utils9.AST_NODE_TYPES.CallExpression;
+      return parent?.type === import_utils10.AST_NODE_TYPES.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration) {
+      if (node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) {
         return true;
       }
-      if (node.type === import_utils9.AST_NODE_TYPES.FunctionExpression || node.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression) {
         if (isCallbackFunction(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === import_utils9.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils9.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils9.AST_NODE_TYPES.Property || parent?.type === import_utils9.AST_NODE_TYPES.MethodDefinition;
+        return parent?.type === import_utils10.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils10.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils10.AST_NODE_TYPES.Property || parent?.type === import_utils10.AST_NODE_TYPES.MethodDefinition;
       }
       return false;
     };
@@ -617,7 +670,7 @@ var preferDestructuringParams = createRule9({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      if (node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -627,7 +680,7 @@ var preferDestructuringParams = createRule9({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils9.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils9.AST_NODE_TYPES.RestElement
+        (param) => param.type !== import_utils10.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils10.AST_NODE_TYPES.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -646,11 +699,11 @@ var preferDestructuringParams = createRule9({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-import-type.ts
-var import_utils10 = require("@typescript-eslint/utils");
-var createRule10 = import_utils10.ESLintUtils.RuleCreator(
+var import_utils11 = require("@typescript-eslint/utils");
+var createRule11 = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferImportType = createRule10({
+var preferImportType = createRule11({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -681,14 +734,14 @@ var preferImportType = createRule10({
         return;
       }
       const isTypeOnlyImport = node.specifiers.every((specifier) => {
-        if (specifier.type === import_utils10.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils10.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils10.AST_NODE_TYPES.ImportSpecifier) {
-          const importedName = specifier.imported.type === import_utils10.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportSpecifier) {
+          const importedName = specifier.imported.type === import_utils11.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
           const isKnownTypeOnly = node.source.value === "@typescript-eslint/utils" && ["TSESTree", "RuleContext"].includes(importedName) || node.source.value === "react" && ["Component", "ComponentProps", "ReactNode", "FC", "JSX", "ReactElement", "PropsWithChildren"].includes(
             importedName
           ) || importedName.endsWith("Type") || importedName.endsWith("Interface") || importedName.endsWith("Props");
@@ -716,11 +769,11 @@ var preferImportType = createRule10({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-interface-over-inline-types.ts
-var import_utils11 = require("@typescript-eslint/utils");
-var createRule11 = import_utils11.ESLintUtils.RuleCreator(
+var import_utils12 = require("@typescript-eslint/utils");
+var createRule12 = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule11({
+var preferInterfaceOverInlineTypes = createRule12({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -736,54 +789,54 @@ var preferInterfaceOverInlineTypes = createRule11({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils11.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils11.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils11.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils11.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils12.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils12.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils11.AST_NODE_TYPES.JSXElement || node.right.type === import_utils11.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils12.AST_NODE_TYPES.JSXElement || node.right.type === import_utils12.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils11.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils11.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils11.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils11.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils11.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils12.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils12.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils12.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils11.AST_NODE_TYPES.JSXElement || node.body.type === import_utils11.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils12.AST_NODE_TYPES.JSXElement || node.body.type === import_utils12.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils11.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils11.AST_NODE_TYPES.FunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils11.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils12.AST_NODE_TYPES.FunctionExpression || node.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils11.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils11.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils11.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils11.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === import_utils11.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils11.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils11.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils11.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -796,7 +849,7 @@ var preferInterfaceOverInlineTypes = createRule11({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils11.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils12.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -816,11 +869,11 @@ var preferInterfaceOverInlineTypes = createRule11({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-named-param-types.ts
-var import_utils12 = require("@typescript-eslint/utils");
-var createRule12 = import_utils12.ESLintUtils.RuleCreator(
+var import_utils13 = require("@typescript-eslint/utils");
+var createRule13 = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferNamedParamTypes = createRule12({
+var preferNamedParamTypes = createRule13({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -835,16 +888,16 @@ var preferNamedParamTypes = createRule12({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === import_utils12.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.type === import_utils13.AST_NODE_TYPES.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === import_utils12.AST_NODE_TYPES.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils13.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils13.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === import_utils12.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils13.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils13.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
@@ -878,11 +931,11 @@ var preferNamedParamTypes = createRule12({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-react-import-types.ts
-var import_utils13 = require("@typescript-eslint/utils");
-var createRule13 = import_utils13.ESLintUtils.RuleCreator(
+var import_utils14 = require("@typescript-eslint/utils");
+var createRule14 = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule13({
+var preferReactImportTypes = createRule14({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -958,7 +1011,7 @@ var preferReactImportTypes = createRule13({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === import_utils13.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils13.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === import_utils14.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils14.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
         const typeName = node.property.name;
         const isType = reactTypes.has(typeName);
         const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -975,7 +1028,7 @@ var preferReactImportTypes = createRule13({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === import_utils13.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils13.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === import_utils14.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils14.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
           const typeName = node.right.name;
           const isType = reactTypes.has(typeName);
           const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -995,11 +1048,11 @@ var preferReactImportTypes = createRule13({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-var import_utils14 = require("@typescript-eslint/utils");
-var createRule14 = import_utils14.ESLintUtils.RuleCreator(
+var import_utils15 = require("@typescript-eslint/utils");
+var createRule15 = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule14({
+var reactPropsDestructure = createRule15({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -1015,29 +1068,29 @@ var reactPropsDestructure = createRule14({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils14.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils14.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils14.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils14.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils15.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils15.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils15.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils15.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils14.AST_NODE_TYPES.JSXElement || node.right.type === import_utils14.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils15.AST_NODE_TYPES.JSXElement || node.right.type === import_utils15.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils14.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils14.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils14.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils14.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils14.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils15.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils15.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils15.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils15.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils15.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === import_utils14.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils14.AST_NODE_TYPES.JSXElement || node.body.type === import_utils14.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils15.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils15.AST_NODE_TYPES.JSXElement || node.body.type === import_utils15.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils14.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils15.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils14.AST_NODE_TYPES.FunctionExpression || node.type === import_utils14.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils14.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils15.AST_NODE_TYPES.FunctionExpression || node.type === import_utils15.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils15.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -1051,9 +1104,9 @@ var reactPropsDestructure = createRule14({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils14.AST_NODE_TYPES.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === import_utils14.AST_NODE_TYPES.Property).map((prop) => {
-          if (prop.key.type === import_utils14.AST_NODE_TYPES.Identifier) {
+      if (param.type === import_utils15.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils15.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils15.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -1091,6 +1144,7 @@ var rules = {
   "md-filename-case-restriction": md_filename_case_restriction_default,
   "no-complex-inline-return": no_complex_inline_return_default,
   "no-emoji": no_emoji_default,
+  "no-env-fallback": no_env_fallback_default,
   "no-explicit-return-type": no_explicit_return_type_default,
   "no-logic-in-params": no_logic_in_params_default,
   "prefer-destructuring-params": prefer_destructuring_params_default,
@@ -1114,7 +1168,8 @@ var baseRules = {
   "nextfriday/prefer-named-param-types": "warn",
   "nextfriday/prefer-react-import-types": "warn",
   "nextfriday/no-complex-inline-return": "warn",
-  "nextfriday/no-logic-in-params": "warn"
+  "nextfriday/no-logic-in-params": "warn",
+  "nextfriday/no-env-fallback": "warn"
 };
 var baseRecommendedRules = {
   "nextfriday/no-emoji": "error",
@@ -1126,7 +1181,8 @@ var baseRecommendedRules = {
   "nextfriday/prefer-named-param-types": "error",
   "nextfriday/prefer-react-import-types": "error",
   "nextfriday/no-complex-inline-return": "error",
-  "nextfriday/no-logic-in-params": "error"
+  "nextfriday/no-logic-in-params": "error",
+  "nextfriday/no-env-fallback": "error"
 };
 var jsxRules = {
   "nextfriday/jsx-pascal-case": "warn",