fix(service-parser): ignore inject() calls for non-TranslateService types

Addresses the issue where calling methods like `inject(HttpClient).get(...)`
incorrectly extracted strings as if they were translation keys.

Closes #116

Author: pmpak

src/parsers/service.parser.ts

@@ -17,6 +17,7 @@ import {
 	getImportPath,
 	findFunctionExpressions,
 	findVariableNameByInjectType,
+	findInlineInjectCallExpressions,
 	getAST,
 	getNamedImport
 } from '../utils/ast-helpers.js';
@@ -43,7 +44,8 @@ export class ServiceParser implements ParserInterface {
 		functionDeclarations.forEach((fnDeclaration) => {
 			const translateServiceVariableName = findVariableNameByInjectType(fnDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE);
 			const callExpressions = findMethodCallExpressions(sourceFile, translateServiceVariableName, TRANSLATE_SERVICE_METHOD_NAMES);
-			translateServiceCallExpressions.push(...callExpressions);
+			const inlineInjectCallExpressions = findInlineInjectCallExpressions(sourceFile, TRANSLATE_SERVICE_TYPE_REFERENCE, TRANSLATE_SERVICE_METHOD_NAMES);
+			translateServiceCallExpressions.push(...callExpressions, ...inlineInjectCallExpressions);
 		});
 
 		classDeclarations.forEach((classDeclaration) => {
@@ -74,14 +76,14 @@ export class ServiceParser implements ParserInterface {
 		}
 		const paramName = findMethodParameterByType(constructorDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE);
 		const methodCallExpressions = findMethodCallExpressions(constructorDeclaration, paramName, TRANSLATE_SERVICE_METHOD_NAMES);
-
+		const inlineInjectCallExpressions = findInlineInjectCallExpressions(constructorDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE, TRANSLATE_SERVICE_METHOD_NAMES)
 		// Calls of the TranslateService when injected using the inject function within the constructor
 		const translateServiceLocalVariableName = findVariableNameByInjectType(constructorDeclaration, TRANSLATE_SERVICE_TYPE_REFERENCE);
 		const localVariableCallExpressions = translateServiceLocalVariableName
 			? findMethodCallExpressions(constructorDeclaration, translateServiceLocalVariableName, TRANSLATE_SERVICE_METHOD_NAMES)
 			: [];
 
-		return [...methodCallExpressions, ...localVariableCallExpressions];
+		return [...methodCallExpressions, ...localVariableCallExpressions, ...inlineInjectCallExpressions];
 	}
 
 	protected findPropertyCallExpressions(classDeclaration: ClassDeclaration, sourceFile: SourceFile): CallExpression[] {

src/utils/ast-helpers.ts

@@ -142,7 +142,19 @@ export function findMethodCallExpressions(node: Node, propName: string, fnName:
 
 	const fnNameRegex = functionNames.join('|');
 
-	const query = `CallExpression > PropertyAccessExpression:has(Identifier[name=/^(${fnNameRegex})$/]):has(PropertyAccessExpression:has(Identifier[name="${propName}"]):not(:has(ThisKeyword)), CallExpression:has(Identifier[name="inject"]))`;
+	const query = `CallExpression > PropertyAccessExpression:has(Identifier[name=/^(${fnNameRegex})$/]):has(PropertyAccessExpression:has(Identifier[name="${propName}"]):not(:has(ThisKeyword)))`;
+
+	return tsquery(node, query)
+		.filter((n) => functionNames.includes(n.getLastToken().getText()))
+		.map((n) => n.parent as CallExpression);
+}
+
+export function findInlineInjectCallExpressions(node: Node, injectType: string, fnName: string | string[]): CallExpression[] {
+	const functionNames = typeof fnName === 'string' ? [fnName] : fnName;
+
+	const fnNameRegex = functionNames.join('|');
+
+	const query = `CallExpression > PropertyAccessExpression:has(Identifier[name=/^(${fnNameRegex})$/]):has(CallExpression:has(Identifier[name="inject"]):has(Identifier[name="${injectType}"]))`;
 
 	return tsquery(node, query)
 		.filter((n) => functionNames.includes(n.getLastToken().getText()))

tests/parsers/service.parser.spec.ts

@@ -383,6 +383,24 @@ describe('ServiceParser', () => {
 		expect(keys).to.deep.equal(['key.instant', 'key.stream', 'key.get']);
 	});
 
+	it('should extract strings when TranslateService is injected using the inject function inline within the constructor', () => {
+		const contents = `
+			export class MyComponent {
+				readonly propInstant: string;
+				readonly propStream: string;
+				readonly propGet: string;
+
+				constructor() {
+					this.propInstant = inject(TranslateService).instant('key.instant');
+					this.propStream = inject(TranslateService).stream('key.stream');
+					this.propGet = inject(TranslateService).get('key.get');
+				}
+			}
+		`;
+		const keys = parser.extract(contents, componentFilename)?.keys();
+		expect(keys).to.deep.equal(['key.instant', 'key.stream', 'key.get']);
+	});
+
 	it('should locate TranslateService when it is a JavaScript native private property', () => {
 		const contents = `
 			@Component({})
@@ -836,5 +854,20 @@ describe('ServiceParser', () => {
 			const keys = parser.extract(contents, componentFilename)?.keys();
 			expect(keys).to.deep.equal(['translation.key']);
 		});
+
+		it('should ignore injected services that are not TranslateService type', () => {
+			const contents = `
+				import {inject} from '@angular/core';
+				import {HttpClient} from '@angular/common/http';
+
+				export const getResource = (): string => {
+					const someService = inject(SomeService).instant('property');
+					const someStream = inject(SomeStreamService).stream('property');
+					return inject(HttpClient).get('/path/to/resource/');
+				}
+			`;
+			const keys = parser.extract(contents, componentFilename)?.keys();
+			expect(keys).to.deep.equal([]);
+		});
 	});
 });