Add new rule no-implicit-injections

README.md

@@ -102,6 +102,7 @@ module.exports = {
 | [new-module-imports](docs/rules/new-module-imports.md)                             | enforce using "New Module Imports" from Ember RFC #176    | ✅  |    |    |
 | [no-array-prototype-extensions](docs/rules/no-array-prototype-extensions.md)       | disallow usage of Ember's `Array` prototype extensions    |    | 🔧 |    |
 | [no-function-prototype-extensions](docs/rules/no-function-prototype-extensions.md) | disallow usage of Ember's `function` prototype extensions | ✅  |    |    |
+| [no-implicit-injections](docs/rules/no-implicit-injections.md)                     | enforce usage of implicit service injections              |    | 🔧 |    |
 | [no-mixins](docs/rules/no-mixins.md)                                               | disallow the usage of mixins                              | ✅  |    |    |
 | [no-new-mixins](docs/rules/no-new-mixins.md)                                       | disallow the creation of new mixins                       | ✅  |    |    |
 | [no-observers](docs/rules/no-observers.md)                                         | disallow usage of observers                               | ✅  |    |    |

docs/rules/no-implicit-injections.md

@@ -0,0 +1,113 @@
+# ember/no-implicit-injections
+
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+Ember 3.26 introduced a deprecation for relying on implicit service injections or allowing addons to implicitly inject services into all classes of certain types. Support for this is dropped in Ember 4.0.
+
+In many applications, `this.store` from Ember Data is often used without injecting the `store` service in Controllers or Routes. Other addons may also have included implicit service injections via initializers and the `application.inject` API.
+
+To resolve this deprecation, a service should be explicitly declared and injected using the [service injection decorator](https://api.emberjs.com/ember/3.28/functions/@ember%2Fservice/inject).
+
+## Rule Details
+
+This rule checks for a configured list of previously auto injected services and warns if they are used in classes without explicit injected service properties.
+
+## Examples
+
+Examples of **incorrect** code for this rule:
+
+```js
+// routes/index.js
+import Route from '@ember/routing/route';
+
+export default class IndexRoute extends Route {
+  model() {
+    return this.store.findAll('rental');
+  }
+}
+
+```
+
+```js
+// controllers/index.js
+import Controller from '@ember/controller';
+import { action } from '@ember/object';
+
+export default class IndexController extends Controller {
+  @action
+  loadUsers() {
+    return this.store.findAll('user');
+  }
+}
+```
+
+Examples of **correct** code for this rule:
+
+```js
+// routes/index.js
+import Route from '@ember/routing/route';
+import { inject as service } from '@ember/service';
+
+export default class IndexRoute extends Route {
+  @service('store') store;
+
+  model() {
+    return this.store.findAll('rental');
+  }
+}
+```
+
+```js
+// controller/index.js
+import Route from '@ember/routing/route';
+import { action } from '@ember/object';
+import { inject as service } from '@ember/service';
+
+export default class IndexController extends Controller {
+  @service('store') store;
+
+  @action
+  loadUsers() {
+    return this.store.findAll('user');
+  }
+}
+```
+
+## Migration
+
+The autofixer for this rule will update classes and add injections for the configured services.
+
+## Configuration
+
+This lint rule will search for instances of `store` used in routes or controllers by default. If you have other services that you would like to check for uses of, the configuration can be overridden.
+
+- object -- containing the following properties:
+  - array -- `services` -- Array of configuration objects configuring the lint rule to check for use of implicit injected services
+    - string -- `serviceName` -- The name of the service that is implicitly injected
+    - array -- `moduleNames` -- Array of string listing the types of classes (controller, route, component, etc) to check for implicit injections. If an array is declared only those class types will be checked for implicit injection. (Defaults to checking all class files/types)
+
+Example config:
+
+```js
+module.exports = {
+  rules: {
+    'ember/no-implicit-injections': ['error', {
+      services: [
+        // Ember Responsive Used to Auto Inject the media service in Components/Controllers
+        { serviceName: 'media', moduleNames: ['Component', 'Controller'] },
+        // Ember CLI Flash Used to Auto Inject the flashMessages service in all modules
+        { serviceName: 'flashMessages' },
+        // Check for uses of the store in Routes or Controllers
+        { serviceName: 'store', moduleNames: ['Route', 'Controller'] },
+      ]
+    }]
+  }
+}
+```
+
+## References
+
+- [Deprecation](https://deprecations.emberjs.com/v3.x/#toc_implicit-injections)
+- [Ember Data Store Service](https://api.emberjs.com/ember-data/release/classes/Store)

lib/rules/no-implicit-injections.js

@@ -0,0 +1,198 @@
+'use strict';
+
+const emberUtils = require('../utils/ember');
+const { getImportIdentifier } = require('../utils/import');
+const Stack = require('../utils/stack');
+const types = require('../utils/types');
+const kebabCase = require('lodash.kebabcase');
+const camelCase = require('lodash.camelcase');
+
+const defaultServiceConfig = { serviceName: 'store', moduleNames: ['Route', 'Controller'] };
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+function fixService(fixer, currentClass, serviceInjectImportName, servicePropertyName) {
+  const serviceInjectPath = kebabCase(servicePropertyName);
+
+  return fixer.insertTextBefore(
+    currentClass.node.body.body[0],
+    `@${serviceInjectImportName}('${serviceInjectPath}') ${servicePropertyName};\n`
+  );
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce usage of implicit service injections',
+      category: 'Deprecations',
+      recommended: false,
+      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/no-implicit-injections.md',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          services: {
+            minItems: 1,
+            type: 'array',
+            items: {
+              type: 'object',
+              default: [defaultServiceConfig],
+              properties: {
+                serviceName: {
+                  type: 'string',
+                  required: true,
+                  minLength: 1,
+                },
+                moduleNames: {
+                  type: 'array',
+                  required: false,
+                  items: {
+                    enum: [
+                      'Component',
+                      'GlimmerComponent',
+                      'Controller',
+                      'Mixin',
+                      'Route',
+                      'Service',
+                      'ArrayProxy',
+                      'ObjectProxy',
+                      'EmberObject',
+                      'Helper',
+                    ],
+                  },
+                },
+              },
+              additionalProperties: false,
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      main: 'Do not rely on implicit service injections for the "{{serviceName}}" service. Implicit service injections were deprecated in Ember 3.26 and will not work in 4.0.',
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {
+      services: [defaultServiceConfig],
+    };
+    const servicesConfig = options.services || [defaultServiceConfig];
+
+    // State being tracked for this file.
+    let serviceInjectImportName = undefined;
+    let serviceNamesWithImplicitInjection = servicesConfig;
+
+    // State being tracked for the current class we're inside.
+    const classStack = new Stack();
+
+    function onClassEnter(node) {
+      if (emberUtils.isAnyEmberCoreModule(context, node)) {
+        // Get the name of services for the current module type
+        const serviceNames = servicesConfig
+          .filter((serviceConfig) => {
+            return (
+              serviceConfig.moduleNames === undefined ||
+              serviceConfig.moduleNames.some((moduleName) =>
+                emberUtils.isEmberCoreModule(context, node, moduleName)
+              )
+            );
+          })
+          .map((a) => camelCase(a.serviceName));
+
+        // Get Services that don't have properties/service injections declared
+        serviceNamesWithImplicitInjection = node.body.body.reduce((accum, n) => {
+          if (types.isClassPropertyOrPropertyDefinition(n)) {
+            return accum.filter((serviceName) => !(serviceName === n.key.name));
+          }
+          return accum;
+        }, serviceNames);
+
+        classStack.push({
+          node,
+          isEmberModule: true,
+          serviceNamesWithImplicitInjection,
+        });
+      } else {
+        classStack.push({
+          node,
+          isEmberModule: false,
+        });
+      }
+    }
+
+    function onClassExit(node) {
+      // Leaving current (native) class.
+      if (classStack.size() > 0 && classStack.peek().node === node) {
+        classStack.pop();
+      }
+    }
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === '@ember/service') {
+          serviceInjectImportName =
+            serviceInjectImportName || getImportIdentifier(node, '@ember/service', 'inject');
+        }
+      },
+
+      ClassDeclaration: onClassEnter,
+      ClassExpression: onClassEnter,
+
+      'ClassDeclaration:exit': onClassExit,
+      'ClassExpression:exit': onClassExit,
+
+      MemberExpression(node) {
+        const currentClass = classStack.peek();
+
+        if (!currentClass || !currentClass.isEmberModule) {
+          return;
+        }
+
+        if (types.isThisExpression(node.object) && types.isIdentifier(node.property)) {
+          const serviceMissingInjection = serviceNamesWithImplicitInjection.find(
+            (s) => s === node.property.name
+          );
+
+          if (serviceMissingInjection) {
+            context.report({
+              node,
+              messageId: 'main',
+              data: {
+                serviceName: serviceMissingInjection,
+              },
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+
+                // service inject is already declared
+                if (serviceInjectImportName) {
+                  return fixService(
+                    fixer,
+                    currentClass,
+                    serviceInjectImportName,
+                    serviceMissingInjection
+                  );
+                }
+
+                return [
+                  fixer.insertTextBefore(
+                    sourceCode.ast,
+                    "import { inject as service } from '@ember/service';\n"
+                  ),
+                  fixService(fixer, currentClass, 'service', serviceMissingInjection),
+                ];
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};

lib/utils/ember.js

@@ -222,7 +222,7 @@ function isEmberCoreModule(context, node, moduleName) {
   if (types.isCallExpression(node)) {
     // "classic" class pattern
     return isClassicEmberCoreModule(node, moduleName, context.getFilename());
-  } else if (types.isClassDeclaration(node)) {
+  } else if (types.isClassDeclaration(node) || types.isClassExpression(node)) {
     // native classes
     if (
       // class Foo extends Component
@@ -251,7 +251,7 @@ function isEmberCoreModule(context, node, moduleName) {
   } else {
     assert(
       false,
-      'Function should only be called on a `CallExpression` (classic class) or `ClassDeclaration` (native class)'
+      'Function should only be called on a `CallExpression` (classic class) or `ClassDeclaration`/`ClassExpression` (native class)'
     );
   }
   return false;

lib/utils/types.js

@@ -9,6 +9,7 @@ module.exports = {
   isCallExpression,
   isCallWithFunctionExpression,
   isClassDeclaration,
+  isClassExpression,
   isClassPropertyOrPropertyDefinition,
   isCommaToken,
   isConciseArrowFunctionWithCallExpression,
@@ -130,6 +131,16 @@ function isClassDeclaration(node) {
   return node !== undefined && node.type === 'ClassDeclaration';
 }
 
+/**
+ * Check whether or not a node is a ClassExpression.
+ *
+ * @param {Object} node The node to check.
+ * @returns {boolean} Whether or not the node is a ClassExpression.
+ */
+function isClassExpression(node) {
+  return node !== undefined && node.type === 'ClassExpression';
+}
+
 /**
  * Check whether or not a node is a ClassProperty (ESLint v7) or PropertyDefinition (ESLint v8).
  *

package.json

@@ -71,6 +71,7 @@
     "ember-template-imports": "^3.1.1",
     "eslint-utils": "^3.0.0",
     "estraverse": "^5.2.0",
+    "lodash.camelcase": "^4.1.1",
     "lodash.kebabcase": "^4.1.1",
     "magic-string": "^0.27.0",
     "requireindex": "^1.2.0",