feat(eslint-plugin): add new rule enforce type call (#4809)

Closes #4797

Author: wolfmanfx

modules/eslint-plugin/spec/rules/signals/enforce-type-call.spec.ts

@@ -0,0 +1,74 @@
+import type { ESLintUtils } from '@typescript-eslint/utils';
+import { ruleTester } from '../../utils';
+import type {
+  InvalidTestCase,
+  ValidTestCase,
+} from '@typescript-eslint/rule-tester';
+import * as path from 'path';
+import rule, {
+  enforceTypeCall,
+} from '../../../src/rules/signals/enforce-type-call';
+
+type MessageIds = ESLintUtils.InferMessageIdsTypeFromRule<typeof rule>;
+type Options = readonly ESLintUtils.InferOptionsTypeFromRule<typeof rule>[];
+
+const valid: () => (string | ValidTestCase<Options>)[] = () => [
+  {
+    code: `
+      import { type } from '@ngrx/signals';
+      const stateType = type<{ count: number }>();
+    `,
+  },
+  {
+    code: `
+      import { type as typeFn } from '@ngrx/signals';
+      const stateType = typeFn<{ count: number; name: string }>();
+    `,
+  },
+  {
+    code: `
+      import { type } from '@none/of/business';
+      const stateType = type<{ count: number }>;
+    `,
+  },
+];
+
+const invalid: () => InvalidTestCase<MessageIds, Options>[] = () => [
+  {
+    code: `
+      import { type } from '@ngrx/signals';
+      const stateType = type<{ count: number }>;
+    `,
+    output: `
+      import { type } from '@ngrx/signals';
+      const stateType = type<{ count: number }>();
+    `,
+    errors: [
+      {
+        messageId: enforceTypeCall,
+        data: { name: 'type' },
+      },
+    ],
+  },
+  {
+    code: `
+      import { type as typeFn } from '@ngrx/signals';
+      const stateType = typeFn<{ count: number }>;
+    `,
+    output: `
+      import { type as typeFn } from '@ngrx/signals';
+      const stateType = typeFn<{ count: number }>();
+    `,
+    errors: [
+      {
+        messageId: enforceTypeCall,
+        data: { name: 'typeFn' },
+      },
+    ],
+  },
+];
+
+ruleTester().run(path.parse(__filename).name, rule, {
+  valid: valid(),
+  invalid: invalid(),
+});

modules/eslint-plugin/src/configs/all.json

@@ -18,6 +18,7 @@
     "@ngrx/signal-state-no-arrays-at-root-level": "error",
     "@ngrx/signal-store-feature-should-use-generic-type": "error",
     "@ngrx/with-state-no-arrays-at-root-level": "error",
+    "@ngrx/enforce-type-call": "error",
     "@ngrx/avoid-combining-selectors": "error",
     "@ngrx/avoid-dispatching-multiple-actions-sequentially": "error",
     "@ngrx/avoid-duplicate-actions-in-reducer": "error",

modules/eslint-plugin/src/configs/all.ts

@@ -64,6 +64,7 @@ export default (
       '@ngrx/prefix-selectors-with-select': 'error',
       '@ngrx/select-style': 'error',
       '@ngrx/use-consistent-global-store-name': 'error',
+      '@ngrx/enforce-type-call': 'error',
     },
   },
 ];

modules/eslint-plugin/src/configs/signals.json

@@ -5,7 +5,8 @@
     "@ngrx/prefer-protected-state": "error",
     "@ngrx/signal-state-no-arrays-at-root-level": "error",
     "@ngrx/signal-store-feature-should-use-generic-type": "error",
-    "@ngrx/with-state-no-arrays-at-root-level": "error"
+    "@ngrx/with-state-no-arrays-at-root-level": "error",
+    "@ngrx/enforce-type-call": "error"
   },
   "parserOptions": {
     "ecmaVersion": 2020,

modules/eslint-plugin/src/rules/index.ts

@@ -37,6 +37,7 @@ import signalStateNoArraysAtRootLevel from './signals/signal-state-no-arrays-at-
 import signalStoreFeatureShouldUseGenericType from './signals/signal-store-feature-should-use-generic-type';
 import withStateNoArraysAtRootLevel from './signals/with-state-no-arrays-at-root-level';
 import preferProtectedState from './signals/prefer-protected-state';
+import enforceTypeCall from './signals/enforce-type-call';
 
 export const rules = {
   // component-store
@@ -84,4 +85,5 @@ export const rules = {
     signalStoreFeatureShouldUseGenericType,
   'prefer-protected-state': preferProtectedState,
   'with-state-no-arrays-at-root-level': withStateNoArraysAtRootLevel,
+  'enforce-type-call': enforceTypeCall,
 };

modules/eslint-plugin/src/rules/signals/enforce-type-call.ts

@@ -0,0 +1,54 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+import * as path from 'path';
+import { createRule } from '../../rule-creator';
+import { isCallExpression, isIdentifier } from '../../utils';
+
+export const enforceTypeCall = 'enforceTypeCall';
+
+type MessageIds = typeof enforceTypeCall;
+type Options = readonly [];
+
+export default createRule<Options, MessageIds>({
+  name: path.parse(__filename).name,
+  meta: {
+    type: 'problem',
+    ngrxModule: 'signals',
+    docs: {
+      description: 'The `type` function must be called.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      [enforceTypeCall]: 'The `{{name}}` function must be called.',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => {
+    // It's possible that we have multiple type import aliases, so we need to track them all.
+    const typeNames = new Set<string>();
+
+    return {
+      [`ImportDeclaration[source.value='@ngrx/signals'] ImportSpecifier[imported.name='type']`](
+        node: TSESTree.ImportSpecifier
+      ) {
+        typeNames.add(node.local.name);
+      },
+
+      TSInstantiationExpression(node: TSESTree.TSInstantiationExpression) {
+        const expression = node.expression;
+        if (
+          isIdentifier(expression) &&
+          typeNames.has(expression.name) &&
+          !isCallExpression(node.parent)
+        ) {
+          context.report({
+            node: expression,
+            messageId: enforceTypeCall,
+            data: { name: expression.name },
+            fix: (fixer) => fixer.insertTextAfter(node, '()'),
+          });
+        }
+      },
+    };
+  },
+});

projects/ngrx.io/content/guide/eslint-plugin/rules/enforce-type-call.md

@@ -0,0 +1,44 @@
+# enforce-type-call
+
+The `type` function from `@ngrx/signals` must be called.
+
+- **Type**: problem
+- **Fixable**: Yes
+- **Suggestion**: Yes
+- **Requires type checking**: No
+- **Configurable**: No
+
+<!-- Everything above this generated, do not edit -->
+<!-- MANUAL-DOC:START -->
+
+## Rule Details
+
+This rule ensures that the `type` function from `@ngrx/signals` is properly called when used to define types. The function must be invoked with parentheses `()` after the generic type parameter.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { type } from '@ngrx/signals';
+const stateType = type<{ count: number }>;
+```
+
+```ts
+import { type as typeFn } from '@ngrx/signals';
+const stateType = typeFn<{ count: number }>;
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { type } from '@ngrx/signals';
+const stateType = type<{ count: number }>();
+```
+
+```ts
+import { type as typeFn } from '@ngrx/signals';
+const stateType = typeFn<{ count: number; name: string }>();
+```
+
+## Further reading
+
+- [Signal Store Documentation](guide/signals/signal-store)