@checkdigit/eslint-plugin 7.17.1 → 8.0.0-PR.141-7ea9

package/src/aws/require-consistent-read.ts

@@ -6,12 +6,18 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESTree,
+} from '@typescript-eslint/utils';
 import getDocumentationUrl from '../get-documentation-url.ts';
 
 export const ruleId = 'require-consistent-read';
-export const MESSAGE_ID_CONSISTENT_READ_TRUE = 'MESSAGE_ID_CONSISTENT_READ_TRUE';
-export const MESSAGE_ID_CONSISTENT_READ_FALSE = 'MESSAGE_ID_CONSISTENT_READ_FALSE';
+export const MESSAGE_ID_CONSISTENT_READ_TRUE =
+  'MESSAGE_ID_CONSISTENT_READ_TRUE';
+export const MESSAGE_ID_CONSISTENT_READ_FALSE =
+  'MESSAGE_ID_CONSISTENT_READ_FALSE';
 
 interface ReadCommandInfo {
   type: 'Get' | 'Query' | 'BatchGet';
@@ -27,12 +33,15 @@ function getPropertyName(property: TSESTree.Property): string | undefined {
   // eslint-disable-next-line no-nested-ternary
   return propertyKey.type === AST_NODE_TYPES.Identifier
     ? propertyKey.name
-    : typeof propertyKey.value === 'string'
+    : // eslint-disable-next-line sonarjs/no-nested-conditional
+      typeof propertyKey.value === 'string'
       ? propertyKey.value
       : undefined;
 }
 
-function extractObjectProperties(objectExpression: TSESTree.ObjectExpression): Record<string, TSESTree.Property> {
+function extractObjectProperties(
+  objectExpression: TSESTree.ObjectExpression,
+): Record<string, TSESTree.Property> {
   const objectProperties: Record<string, TSESTree.Property> = {};
   for (const property of objectExpression.properties) {
     if (property.type !== AST_NODE_TYPES.Property || property.computed) {
@@ -46,7 +55,9 @@ function extractObjectProperties(objectExpression: TSESTree.ObjectExpression): R
   return objectProperties;
 }
 
-function existsRequestItemsProperty(extractedObjectProperties: Record<string, TSESTree.Property>): boolean {
+function existsRequestItemsProperty(
+  extractedObjectProperties: Record<string, TSESTree.Property>,
+): boolean {
   const requestItemProperty = extractedObjectProperties['RequestItems'];
   if (requestItemProperty?.type !== AST_NODE_TYPES.Property) {
     return false;
@@ -60,17 +71,25 @@ function existsRequestItemsProperty(extractedObjectProperties: Record<string, TS
     (property) =>
       property.type === AST_NODE_TYPES.Property &&
       property.value.type === AST_NODE_TYPES.ObjectExpression &&
-      extractObjectProperties(property.value)['Keys']?.value.type === AST_NODE_TYPES.ArrayExpression,
+      extractObjectProperties(property.value)['Keys']?.value.type ===
+        AST_NODE_TYPES.ArrayExpression,
   );
 }
 
-function existsKeyProperty(extractedObjectProperties: Record<string, TSESTree.Property>): boolean {
+function existsKeyProperty(
+  extractedObjectProperties: Record<string, TSESTree.Property>,
+): boolean {
   const keyProperty = extractedObjectProperties['Key'];
   // Relaxed: just ensure it's an object (works for both low-level and DocumentClient)
-  return keyProperty?.type === AST_NODE_TYPES.Property && keyProperty.value.type === AST_NODE_TYPES.ObjectExpression;
+  return (
+    keyProperty?.type === AST_NODE_TYPES.Property &&
+    keyProperty.value.type === AST_NODE_TYPES.ObjectExpression
+  );
 }
 
-export function getReadCommandInfo(objectExpression: TSESTree.ObjectExpression): ReadCommandInfo | undefined {
+export function getReadCommandInfo(
+  objectExpression: TSESTree.ObjectExpression,
+): ReadCommandInfo | undefined {
   const extractedProperties = extractObjectProperties(objectExpression);
   let readCommandInfo: ReadCommandInfo | undefined;
 
@@ -82,13 +101,19 @@ export function getReadCommandInfo(objectExpression: TSESTree.ObjectExpression):
     if (hasTableName && hasKey) {
       // make sure it is not an update or conditional write;
       // we can't really tell if it's a delete, but we simply ignore that case assuming they'll never be used
-      if (!('UpdateExpression' in extractedProperties) && !('ConditionExpression' in extractedProperties)) {
+      if (
+        !('UpdateExpression' in extractedProperties) &&
+        !('ConditionExpression' in extractedProperties)
+      ) {
         readCommandInfo = { type: 'Get' };
       }
     } else {
-      const hasKeyCondExpr = extractedProperties['KeyConditionExpression']?.value.type === AST_NODE_TYPES.Literal;
+      const hasKeyCondExpr =
+        extractedProperties['KeyConditionExpression']?.value.type ===
+        AST_NODE_TYPES.Literal;
       const hasLegacyKeyConditions =
-        extractedProperties['KeyConditions']?.value.type === AST_NODE_TYPES.ObjectExpression;
+        extractedProperties['KeyConditions']?.value.type ===
+        AST_NODE_TYPES.ObjectExpression;
       if (hasTableName && (hasKeyCondExpr || hasLegacyKeyConditions)) {
         readCommandInfo = { type: 'Query' };
       }
@@ -122,54 +147,66 @@ export function getReadCommandInfo(objectExpression: TSESTree.ObjectExpression):
 
 const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
 
-const rule: ESLintUtils.RuleModule<typeof MESSAGE_ID_CONSISTENT_READ_TRUE | typeof MESSAGE_ID_CONSISTENT_READ_FALSE> =
-  createRule({
-    name: ruleId,
-    meta: {
-      type: 'problem',
-      docs: {
-        description:
-          'For AWS dynamodb commands Query/Get/BatchGet, ConsistentRead option should always be set as true unless global index is used. This will make the service more robust at the ignorable cost of RCU.',
-      },
-      messages: {
-        [MESSAGE_ID_CONSISTENT_READ_TRUE]:
-          'ConsistentRead option should always be set as true for {{readCommandType}} command.',
-        [MESSAGE_ID_CONSISTENT_READ_FALSE]:
-          'ConsistentRead option should not be set as true for {{readCommandType}} command when using a global secondary index.',
-      },
-      schema: [],
+const rule: ESLintUtils.RuleModule<
+  | typeof MESSAGE_ID_CONSISTENT_READ_TRUE
+  | typeof MESSAGE_ID_CONSISTENT_READ_FALSE
+> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'For AWS dynamodb commands Query/Get/BatchGet, ConsistentRead option should always be set as true unless global index is used. This will make the service more robust at the ignorable cost of RCU.',
     },
-    defaultOptions: [],
-    create(context) {
-      const sourceCode = context.sourceCode;
-
-      return {
-        ObjectExpression(node) {
-          // Quick prefilter: only look at objects that mention table/read-ish keys
-          const text = sourceCode.getText(node);
-          if (!/TableName|RequestItems|KeyConditionExpression|KeyConditions/u.test(text)) {
-            return;
-          }
-
-          const readCommandInfo = getReadCommandInfo(node);
-          if (readCommandInfo !== undefined) {
-            if (readCommandInfo.usedIndex !== true && readCommandInfo.consistentRead !== true) {
-              context.report({
-                node,
-                messageId: MESSAGE_ID_CONSISTENT_READ_TRUE,
-                data: { readCommandType: readCommandInfo.type },
-              });
-            } else if (readCommandInfo.usedIndex === true && readCommandInfo.consistentRead !== false) {
-              context.report({
-                node,
-                messageId: MESSAGE_ID_CONSISTENT_READ_FALSE,
-                data: { readCommandType: readCommandInfo.type },
-              });
-            }
-          }
-        },
-      };
+    messages: {
+      [MESSAGE_ID_CONSISTENT_READ_TRUE]:
+        'ConsistentRead option should always be set as true for {{readCommandType}} command.',
+      [MESSAGE_ID_CONSISTENT_READ_FALSE]:
+        'ConsistentRead option should not be set as true for {{readCommandType}} command when using a global secondary index.',
     },
-  });
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ObjectExpression(node) {
+        // Quick prefilter: only look at objects that mention table/read-ish keys
+        const text = sourceCode.getText(node);
+        if (
+          !/TableName|RequestItems|KeyConditionExpression|KeyConditions/u.test(
+            text,
+          )
+        ) {
+          return;
+        }
+
+        const readCommandInfo = getReadCommandInfo(node);
+        if (readCommandInfo !== undefined) {
+          if (
+            readCommandInfo.usedIndex !== true &&
+            readCommandInfo.consistentRead !== true
+          ) {
+            context.report({
+              node,
+              messageId: MESSAGE_ID_CONSISTENT_READ_TRUE,
+              data: { readCommandType: readCommandInfo.type },
+            });
+          } else if (
+            readCommandInfo.usedIndex === true &&
+            readCommandInfo.consistentRead !== false
+          ) {
+            context.report({
+              node,
+              messageId: MESSAGE_ID_CONSISTENT_READ_FALSE,
+              data: { readCommandType: readCommandInfo.type },
+            });
+          }
+        }
+      },
+    };
+  },
+});
 
 export default rule;

package/src/file-path-comment.ts

@@ -40,7 +40,10 @@ export default {
           },
           message: 'first line cannot be a block comment',
           fix(fixer: Rule.RuleFixer) {
-            return fixer.insertTextBeforeRange([0, 0], `// ${expectedPath}\n\n`);
+            return fixer.insertTextBeforeRange(
+              [0, 0],
+              `// ${expectedPath}\n\n`,
+            );
           },
         });
       } else {
@@ -57,7 +60,10 @@ export default {
           },
           message: 'first line is not a comment with the file path',
           fix(fixer: Rule.RuleFixer) {
-            return fixer.insertTextBeforeRange([0, 0], `// ${expectedPath}\n\n`);
+            return fixer.insertTextBeforeRange(
+              [0, 0],
+              `// ${expectedPath}\n\n`,
+            );
           },
         });
       }
@@ -77,7 +83,10 @@ export default {
           },
           message: 'first line is a comment but is not a path to the file',
           fix(fixer: Rule.RuleFixer) {
-            return fixer.replaceTextRange([0, firstLine.length], `// ${expectedPath}`);
+            return fixer.replaceTextRange(
+              [0, firstLine.length],
+              `// ${expectedPath}`,
+            );
           },
         });
       }

package/src/index.ts

@@ -8,10 +8,18 @@
 
 import type { TSESLint } from '@typescript-eslint/utils';
 
-import invalidJsonStringify, { ruleId as invalidJsonStringifyRuleId } from './invalid-json-stringify.ts';
-import noDuplicatedImports, { ruleId as noDuplicatedImportsRuleId } from './no-duplicated-imports.ts';
-import noLegacyServiceTyping, { ruleId as noLegacyServiceTypingRuleId } from './no-legacy-service-typing.ts';
-import noPromiseInstanceMethod, { ruleId as noPromiseInstanceMethodRuleId } from './no-promise-instance-method.ts';
+import invalidJsonStringify, {
+  ruleId as invalidJsonStringifyRuleId,
+} from './invalid-json-stringify.ts';
+import noDuplicatedImports, {
+  ruleId as noDuplicatedImportsRuleId,
+} from './no-duplicated-imports.ts';
+import noLegacyServiceTyping, {
+  ruleId as noLegacyServiceTypingRuleId,
+} from './no-legacy-service-typing.ts';
+import noPromiseInstanceMethod, {
+  ruleId as noPromiseInstanceMethodRuleId,
+} from './no-promise-instance-method.ts';
 import noStatusCodeAssert from './no-status-code-assert.ts';
 import requireFixedServicesImport, {
   ruleId as requireFixedServicesImportRuleId,
@@ -22,13 +30,21 @@ import requireResolveFullResponse, {
 import requireTypeOutOfTypeOnlyImports, {
   ruleId as requireTypeOutOfTypeOnlyImportsRuleId,
 } from './require-type-out-of-type-only-imports.ts';
-import noServeRuntime, { ruleId as noServeRuntimeRuleId } from './no-serve-runtime.ts';
+import noServeRuntime, {
+  ruleId as noServeRuntimeRuleId,
+} from './no-serve-runtime.ts';
 import requireServiceCallResponseDeclaration, {
   ruleId as requireServiceCallResponseDeclarationRuleId,
 } from './require-service-call-response-declaration.ts';
-import requireAwsConfig, { ruleId as requireAwsConfigRuleId } from './aws/require-aws-config.ts';
-import requireAWSBareBones, { ruleId as requireAWSBareBonesRuleId } from './aws/require-aws-bare-bones.ts';
-import requireConsistentRead, { ruleId as requireConsistentReadRuleId } from './aws/require-consistent-read.ts';
+import requireAwsConfig, {
+  ruleId as requireAwsConfigRuleId,
+} from './aws/require-aws-config.ts';
+import requireAWSBareBones, {
+  ruleId as requireAWSBareBonesRuleId,
+} from './aws/require-aws-bare-bones.ts';
+import requireConsistentRead, {
+  ruleId as requireConsistentReadRuleId,
+} from './aws/require-consistent-read.ts';
 import filePathComment from './file-path-comment.ts';
 import noCardNumbers from './no-card-numbers.ts';
 import noEnum from './no-enum.ts';
@@ -62,7 +78,8 @@ const rules: Record<string, TSESLint.LooseRuleDefinition> = {
   'no-wallaby-comment': noWallabyComment,
   'no-side-effects': noSideEffects,
   'regular-expression-comment': regexComment,
-  'require-assert-predicate-rejects-throws': requireAssertPredicateRejectsThrows,
+  'require-assert-predicate-rejects-throws':
+    requireAssertPredicateRejectsThrows,
   'object-literal-response': objectLiteralResponse,
   [invalidJsonStringifyRuleId]: invalidJsonStringify,
   [noPromiseInstanceMethodRuleId]: noPromiseInstanceMethod,
@@ -70,7 +87,8 @@ const rules: Record<string, TSESLint.LooseRuleDefinition> = {
   [requireResolveFullResponseRuleId]: requireResolveFullResponse,
   [noDuplicatedImportsRuleId]: noDuplicatedImports,
   [noServeRuntimeRuleId]: noServeRuntime,
-  [requireServiceCallResponseDeclarationRuleId]: requireServiceCallResponseDeclaration,
+  [requireServiceCallResponseDeclarationRuleId]:
+    requireServiceCallResponseDeclaration,
   [requireAwsConfigRuleId]: requireAwsConfig,
   [requireFixedServicesImportRuleId]: requireFixedServicesImport,
   [requireTypeOutOfTypeOnlyImportsRuleId]: requireTypeOutOfTypeOnlyImports,

package/src/invalid-json-stringify.ts

@@ -25,7 +25,8 @@ export default {
       {
         type: 'array',
         items: {
-          description: 'Regular expression pattern to match the name of the first parameter of JSON.stringify().',
+          description:
+            'Regular expression pattern to match the name of the first parameter of JSON.stringify().',
           type: 'string',
           minItems: 1,
         },
@@ -39,7 +40,9 @@ export default {
   },
   create(context) {
     const options = (context.options[0] ?? DEFAULT_OPTIONS) as string[];
-    const invalidParameterNamePatterns = options.map((option) => new RegExp(option, 'u'));
+    const invalidParameterNamePatterns = options.map(
+      (option) => new RegExp(option, 'u'),
+    );
 
     return {
       CallExpression(node) {
@@ -67,7 +70,10 @@ export default {
                         parameterName: argument.name,
                       },
                       fix(fixer) {
-                        return fixer.replaceText(node, `String(${argument.name})`);
+                        return fixer.replaceText(
+                          node,
+                          `String(${argument.name})`,
+                        );
                       },
                     },
                   ],

package/src/library/format.ts

@@ -11,7 +11,10 @@ import { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import type { Node } from 'estree';
 import type { SourceCode } from 'eslint';
 
-export function getIndentation(node: Node | TSESTree.Node, sourceCode: SourceCode | TSESLint.SourceCode): string {
+export function getIndentation(
+  node: Node | TSESTree.Node,
+  sourceCode: SourceCode | TSESLint.SourceCode,
+): string {
   assert.ok(node.loc);
   const line = sourceCode.lines[node.loc.start.line - 1];
   assert.ok(line !== undefined);

package/src/library/tree.ts

@@ -48,7 +48,12 @@ export function getEnclosingStatement(node: Node): Node | undefined {
 
 export function getEnclosingScopeNode(node: Node): Node | undefined {
   return getAncestor(node, (parentNode) =>
-    ['FunctionExpression', 'FunctionDeclaration', 'ArrowFunctionExpression', 'Program'].includes(parentNode.type),
+    [
+      'FunctionExpression',
+      'FunctionDeclaration',
+      'ArrowFunctionExpression',
+      'Program',
+    ].includes(parentNode.type),
   );
 }
 
@@ -65,7 +70,8 @@ export function isUsedInArrayOrAsArgument(node: Node): boolean {
   if (
     parent.type === 'ArrayExpression' ||
     parent.type === 'ArrowFunctionExpression' ||
-    (parent.type === 'CallExpression' && parent.arguments.includes(node as Expression))
+    (parent.type === 'CallExpression' &&
+      parent.arguments.includes(node as Expression))
   ) {
     return true;
   }

package/src/library/ts-tree.ts

@@ -14,7 +14,9 @@ interface NodeParentExtension {
   parent: NodeParent;
 }
 
-export function getParent(node: TSESTree.Node): TSESTree.Node | undefined | null {
+export function getParent(
+  node: TSESTree.Node,
+): TSESTree.Node | undefined | null {
   return (node as unknown as NodeParentExtension).parent;
 }
 
@@ -42,13 +44,22 @@ export function isBlockStatement(node: TSESTree.Node): boolean {
   return node.type.endsWith('Statement') || node.type.endsWith('Declaration');
 }
 
-export function getEnclosingStatement(node: TSESTree.Node): TSESTree.Node | undefined {
+export function getEnclosingStatement(
+  node: TSESTree.Node,
+): TSESTree.Node | undefined {
   return getAncestor(node, isBlockStatement);
 }
 
-export function getEnclosingScopeNode(node: TSESTree.Node): TSESTree.Node | undefined {
+export function getEnclosingScopeNode(
+  node: TSESTree.Node,
+): TSESTree.Node | undefined {
   return getAncestor(node, (parentNode) =>
-    ['FunctionExpression', 'FunctionDeclaration', 'ArrowFunctionExpression', 'Program'].includes(parentNode.type),
+    [
+      'FunctionExpression',
+      'FunctionDeclaration',
+      'ArrowFunctionExpression',
+      'Program',
+    ].includes(parentNode.type),
   );
 }
 
@@ -64,7 +75,8 @@ export function isUsedInArrayOrAsArgument(node: TSESTree.Node): boolean {
 
   if (
     parent.type === AST_NODE_TYPES.ArrayExpression ||
-    (parent.type === AST_NODE_TYPES.CallExpression && parent.arguments.includes(node as TSESTree.Expression))
+    (parent.type === AST_NODE_TYPES.CallExpression &&
+      parent.arguments.includes(node as TSESTree.Expression))
   ) {
     return true;
   }
@@ -75,7 +87,11 @@ export function isUsedInArrayOrAsArgument(node: TSESTree.Node): boolean {
 
 export function getEnclosingFunction(
   node: TSESTree.Node,
-): TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | undefined {
+):
+  | TSESTree.ArrowFunctionExpression
+  | TSESTree.FunctionDeclaration
+  | TSESTree.FunctionExpression
+  | undefined {
   if (
     node.type === AST_NODE_TYPES.FunctionDeclaration ||
     node.type === AST_NODE_TYPES.FunctionExpression ||
@@ -97,7 +113,8 @@ export function getTypeParentNode(
   if (!node) {
     return undefined;
   }
-  return node.type === AST_NODE_TYPES.TSTypeAnnotation || node.type === AST_NODE_TYPES.TSAsExpression
+  return node.type === AST_NODE_TYPES.TSTypeAnnotation ||
+    node.type === AST_NODE_TYPES.TSAsExpression
     ? node
     : getTypeParentNode(node.parent);
 }

package/src/no-card-numbers.ts

@@ -44,7 +44,12 @@ function luhnCheck(cardNumber: string) {
   );
 }
 
-function checkForCardNumbers(value: string, context: Rule.RuleContext, node?: Node, loc?: SourceLocation) {
+function checkForCardNumbers(
+  value: string,
+  context: Rule.RuleContext,
+  node?: Node,
+  loc?: SourceLocation,
+) {
   const matches = value.match(cardNumberRegex);
   if (matches === null) {
     return;

package/src/no-duplicated-imports.ts

@@ -24,7 +24,8 @@ const rule: ESLintUtils.RuleModule<'mergeDuplicatedImports'> = createRule({
       description: 'Merge duplicated import statements with the same "from".',
     },
     messages: {
-      mergeDuplicatedImports: 'Merge duplicated import statements with the same "from".',
+      mergeDuplicatedImports:
+        'Merge duplicated import statements with the same "from".',
     },
     fixable: 'code',
     schema: [],
@@ -45,11 +46,16 @@ const rule: ESLintUtils.RuleModule<'mergeDuplicatedImports'> = createRule({
         declarations.push(node);
       },
       'Program:exit'() {
-        for (const [moduleName, allDeclarations] of importDeclarations.entries()) {
+        for (const [
+          moduleName,
+          allDeclarations,
+        ] of importDeclarations.entries()) {
           const declarations = allDeclarations.filter(
             (declaration) =>
               !declaration.specifiers.some(
-                (specifier) => specifier.type === TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier,
+                (specifier) =>
+                  specifier.type ===
+                  TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier,
               ),
           );
           if (declarations.length <= 1) {
@@ -64,7 +70,8 @@ const rule: ESLintUtils.RuleModule<'mergeDuplicatedImports'> = createRule({
               declaration.importKind === 'type' ||
               declaration.specifiers.every(
                 (specifier) =>
-                  specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === 'type',
+                  specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
+                  specifier.importKind === 'type',
               ),
           );
 
@@ -76,30 +83,48 @@ const rule: ESLintUtils.RuleModule<'mergeDuplicatedImports'> = createRule({
 
               const defaultSpecifier = declarations
                 .flatMap((declaration) =>
+                  // eslint-disable-next-line sonarjs/no-nested-functions
                   declaration.specifiers.map((specifier) =>
-                    specifier.type === TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier ? specifier : undefined,
+                    specifier.type ===
+                    TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier
+                      ? specifier
+                      : undefined,
                   ),
                 )
                 .filter(Boolean);
-              const defaultSpecifierText = defaultSpecifier[0] ? sourceCode.getText(defaultSpecifier[0]) : undefined;
+              const defaultSpecifierText = defaultSpecifier[0]
+                ? sourceCode.getText(defaultSpecifier[0])
+                : undefined;
 
               const mergedSpecifiers = declarations.flatMap((declaration) => {
                 const isCurrentDeclarationTypeOnly =
                   declaration.importKind === 'type' ||
                   declaration.specifiers.every(
+                    // eslint-disable-next-line sonarjs/no-nested-functions
                     (specifier) =>
-                      specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === 'type',
-                  );
-                return declaration.specifiers
-                  .filter((specifier) => specifier.type !== TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier)
-                  .map((specifier) =>
-                    // eslint-disable-next-line no-nested-ternary
-                    isAllTypeOnly
-                      ? sourceCode.getText(specifier).replace('type ', '')
-                      : isCurrentDeclarationTypeOnly
-                        ? `type ${sourceCode.getText(specifier)}`
-                        : sourceCode.getText(specifier),
+                      specifier.type ===
+                        TSESTree.AST_NODE_TYPES.ImportSpecifier &&
+                      specifier.importKind === 'type',
                   );
+                return (
+                  declaration.specifiers
+                    .filter(
+                      // eslint-disable-next-line sonarjs/no-nested-functions
+                      (specifier) =>
+                        specifier.type !==
+                        TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier,
+                    )
+                    // eslint-disable-next-line sonarjs/no-nested-functions
+                    .map((specifier) =>
+                      // eslint-disable-next-line no-nested-ternary
+                      isAllTypeOnly
+                        ? sourceCode.getText(specifier).replace('type ', '')
+                        : // eslint-disable-next-line sonarjs/no-nested-conditional
+                          isCurrentDeclarationTypeOnly
+                          ? `type ${sourceCode.getText(specifier)}`
+                          : sourceCode.getText(specifier),
+                    )
+                );
               });
               const mergedSpecifiersText = `${isAllTypeOnly ? 'type ' : ''}{ ${mergedSpecifiers.join(', ')} }`;
 
@@ -109,7 +134,12 @@ const rule: ESLintUtils.RuleModule<'mergeDuplicatedImports'> = createRule({
 
               // Remove the remaining imports
               declarations.slice(1).forEach((declaration) => {
-                fixes.push(fixer.removeRange([declaration.range[0], declaration.range[1] + 1]));
+                fixes.push(
+                  fixer.removeRange([
+                    declaration.range[0],
+                    declaration.range[1] + 1,
+                  ]),
+                );
               });
 
               return fixes;

package/src/no-legacy-service-typing.ts

@@ -6,16 +6,26 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESTree,
+} from '@typescript-eslint/utils';
 import getDocumentationUrl from './get-documentation-url.ts';
 
 export const ruleId = 'no-legacy-service-typing';
 
 const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
 
-const DISALLOWED_SERVICE_TYPINGS: string[] | undefined = ['FullResponse', 'Endpoint'];
+const DISALLOWED_SERVICE_TYPINGS: string[] | undefined = [
+  'FullResponse',
+  'Endpoint',
+];
 
-const rule: ESLintUtils.RuleModule<'noLegacyServiceTyping', [typeof DISALLOWED_SERVICE_TYPINGS]> = createRule({
+const rule: ESLintUtils.RuleModule<
+  'noLegacyServiceTyping',
+  [typeof DISALLOWED_SERVICE_TYPINGS]
+> = createRule({
   name: ruleId,
   meta: {
     type: 'problem',
@@ -23,18 +33,25 @@ const rule: ESLintUtils.RuleModule<'noLegacyServiceTyping', [typeof DISALLOWED_S
       description: 'Legacy service typings should not be used.',
     },
     messages: {
-      noLegacyServiceTyping: 'Please remove the usage of legacy service typings.',
+      noLegacyServiceTyping:
+        'Please remove the usage of legacy service typings.',
     },
-    schema: [{ type: 'array', items: { type: 'string' } }],
+
+    schema: [
+      {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Legacy service typings should not be used.',
+      },
+    ],
+    defaultOptions: [DISALLOWED_SERVICE_TYPINGS],
   },
-  defaultOptions: [DISALLOWED_SERVICE_TYPINGS],
   create(context) {
     return {
       TSTypeReference: (typeReference: TSESTree.TSTypeReference) => {
         if (
           typeReference.typeName.type === AST_NODE_TYPES.Identifier &&
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          (context.options[0] ?? DISALLOWED_SERVICE_TYPINGS).includes(typeReference.typeName.name)
+          context.options[0].includes(typeReference.typeName.name)
         ) {
           context.report({
             messageId: 'noLegacyServiceTyping',