@craft-ng/dev-tools 0.1.5 → 0.1.7

package/src/scripts/angular-brand-codemod.ts

@@ -100,12 +100,39 @@ type ProvidedDependencyExtractionResult = {
   warnings: string[];
 };
 
+type InjectedDependencyDescriptor = {
+  dependencyText: string;
+  entry: GeneratedDependencyEntry;
+};
+
+type InjectCallDependencyExtractionResult = DependencyExtractionResult & {
+  generatedDependencies: InjectedDependencyDescriptor[];
+};
+
 type DependencyReferenceResolution = {
   kind: 'class' | 'enum' | 'function' | 'variable' | 'namespace' | 'unknown';
   classDeclaration?: ClassDeclaration;
   moduleSpecifier?: string;
 };
 
+type TrackedHelperResolution = {
+  serviceName: string;
+  scope: string;
+};
+
+type HelperExposureBinding = {
+  localName: string;
+  sourceKey: string;
+};
+
+type HelperExposureTracking = {
+  usedProperties: string[];
+  exposedProperties: Array<{
+    exposedKey: string;
+    sourceKey: string;
+  }>;
+};
+
 type NormalizedOptions = Required<AngularBrandCodemodOptions>;
 
 type InjectDecoratorTokenResult =
@@ -320,7 +347,13 @@ export function analyzeSourceFileDependencies(
   result.generatedDependencyGroups = createGeneratedDependencyGroups(
     sourceFile,
     result.dependencyGroups.importDeps,
-    result.dependencyGroups.injected,
+    [
+      ...constructorDeps.dependencies.map((dependencyText) => ({
+        dependencyText,
+        entry: createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject'),
+      })),
+      ...injectCallDeps.generatedDependencies,
+    ],
     providedDeps.entries,
   );
 
@@ -485,9 +518,11 @@ export function extractConstructorDeps(
 
 export function extractInjectCallDeps(
   classDeclaration: ClassDeclaration,
-): DependencyExtractionResult {
+): InjectCallDependencyExtractionResult {
   const warnings: string[] = [];
   const dependencies: string[] = [];
+  const generatedDependencies: InjectedDependencyDescriptor[] = [];
+  const sourceFile = classDeclaration.getSourceFile();
 
   for (const callExpression of classDeclaration.getDescendantsOfKind(
     SyntaxKind.CallExpression,
@@ -511,9 +546,25 @@ export function extractInjectCallDeps(
     }
 
     dependencies.push(dependency);
+    generatedDependencies.push({
+      dependencyText: dependency,
+      entry:
+        injectMethodName === 'inject'
+          ? createGeneratedDependencyEntry(sourceFile, dependency, 'inject')
+          : createGeneratedInjectHelperDependencyEntry(
+              sourceFile,
+              callExpression,
+              expression,
+              dependency,
+            ),
+    });
   }
 
-  return { dependencies: mergeDeps(dependencies), warnings };
+  return {
+    dependencies: mergeDeps(dependencies),
+    warnings,
+    generatedDependencies,
+  };
 }
 
 export function mergeDeps(...dependencyGroups: readonly string[][]): string[] {
@@ -557,30 +608,39 @@ function getGeneratedDepsTypeName(className: string): string {
 function createGeneratedDependencyGroups(
   sourceFile: SourceFile,
   importDependencies: string[],
-  injectedDependencies: string[],
+  injectedDependencies: InjectedDependencyDescriptor[],
   providedEntries: GeneratedDependencyEntry[],
 ): GeneratedDependencyGroups {
   const deps = mergeGeneratedDependencyEntries(
     importDependencies.map((dependency) =>
       createGeneratedDependencyEntry(sourceFile, dependency, 'import'),
     ),
-    injectedDependencies.map((dependency) =>
-      createGeneratedDependencyEntry(sourceFile, dependency, 'inject'),
-    ),
+    injectedDependencies.map((dependency) => dependency.entry),
   );
   const provided = mergeGeneratedDependencyEntries(providedEntries);
   const providedKeys = new Set(provided.map((entry) => entry.key));
+  const injectedEntriesByKey = new Map(
+    injectedDependencies.map((dependency) => [dependency.entry.key, dependency.entry]),
+  );
   const missingProvider = mergeGeneratedDependencyEntries(
     injectedDependencies
       .filter((dependency) => {
-        const dependencyKey = createGeneratedDependencyKey(dependency);
+        const dependencyKey = dependency.entry.key;
         return (
           !providedKeys.has(dependencyKey) &&
-          !isProvidedInInjectableTree(sourceFile, dependency)
+          shouldGenerateLocalMissingProvider(
+            sourceFile,
+            dependency.dependencyText,
+          )
         );
       })
       .map((dependency) =>
-        createGeneratedDependencyEntry(sourceFile, dependency, 'inject'),
+        injectedEntriesByKey.get(dependency.entry.key) ??
+        createGeneratedDependencyEntry(
+          sourceFile,
+          dependency.dependencyText,
+          'inject',
+        ),
       ),
   );
 
@@ -640,6 +700,342 @@ function createGeneratedDependencyEntry(
   };
 }
 
+function createGeneratedInjectHelperDependencyEntry(
+  sourceFile: SourceFile,
+  callExpression: import('ts-morph').CallExpression,
+  expression: Node,
+  dependencyText: string,
+): GeneratedDependencyEntry {
+  const trackedHelper = resolveTrackedInjectHelper(expression);
+  if (!trackedHelper) {
+    return createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject');
+  }
+
+  const exposureTracking = extractHelperExposureTracking(callExpression);
+
+  return {
+    key: trackedHelper.serviceName,
+    typeText: createTrackedInjectHelperTypeText(
+      dependencyText,
+      exposureTracking,
+    ),
+  };
+}
+
+function createTrackedInjectHelperTypeText(
+  dependencyText: string,
+  exposureTracking: HelperExposureTracking | undefined,
+): string {
+  const baseType = `GetInjectedServiceDependencies<typeof ${dependencyText}>`;
+  if (!exposureTracking) {
+    return baseType;
+  }
+
+  return [
+    `DerivedService<${baseType}, {`,
+    `  derivedPropertiesUsed: ${formatHelperExposurePropertiesType(
+      dependencyText,
+      exposureTracking.usedProperties.map((sourceKey) => ({
+        propertyKey: sourceKey,
+        sourceKey,
+      })),
+    )};`,
+    `  derivedPropertiesExposed: ${formatHelperExposurePropertiesType(
+      dependencyText,
+      exposureTracking.exposedProperties.map(
+        ({ exposedKey, sourceKey }) => ({
+          propertyKey: exposedKey,
+          sourceKey,
+        }),
+      ),
+    )};`,
+    '}>',
+  ].join('\n');
+}
+
+function formatHelperExposurePropertiesType(
+  dependencyText: string,
+  properties: Array<{ propertyKey: string; sourceKey: string }>,
+): string {
+  if (properties.length === 0) {
+    return '{}';
+  }
+
+  return [
+    '{',
+    ...properties.map(
+      ({ propertyKey, sourceKey }) =>
+        `    ${formatObjectKey(propertyKey)}: ${createTrackedHelperOutputTypeText(
+          dependencyText,
+          sourceKey,
+        )};`,
+    ),
+    '  }',
+  ].join('\n');
+}
+
+function createTrackedHelperOutputTypeText(
+  dependencyText: string,
+  sourceKey: string,
+): string {
+  if (sourceKey === '$self') {
+    return `GetServiceOutput<typeof ${dependencyText}>`;
+  }
+
+  return `GetServiceOutput<typeof ${dependencyText}>[${JSON.stringify(sourceKey)}]`;
+}
+
+function resolveTrackedInjectHelper(
+  expression: Node,
+): TrackedHelperResolution | undefined {
+  const symbol = expression.getSymbol() ?? expression.getType().getSymbol();
+  const declarations =
+    symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
+
+  for (const declaration of declarations) {
+    const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+    if (helper) {
+      return helper;
+    }
+  }
+
+  return undefined;
+}
+
+function resolveTrackedInjectHelperFromDeclaration(
+  declaration: Node,
+): TrackedHelperResolution | undefined {
+  if (!Node.isBindingElement(declaration)) {
+    return undefined;
+  }
+
+  const objectBindingPattern = declaration.getFirstAncestorByKind(
+    SyntaxKind.ObjectBindingPattern,
+  );
+  const variableDeclaration =
+    objectBindingPattern?.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+  const initializer = variableDeclaration?.getInitializer();
+  if (!Node.isCallExpression(initializer) || !isServiceFactoryCall(initializer)) {
+    return undefined;
+  }
+
+  const [optionsArgument] = initializer.getArguments();
+  if (!Node.isObjectLiteralExpression(optionsArgument)) {
+    return undefined;
+  }
+
+  const nameInitializer = getObjectPropertyAssignment(
+    optionsArgument,
+    'name',
+  )?.getInitializer();
+  const scopeInitializer = getObjectPropertyAssignment(
+    optionsArgument,
+    'scope',
+  )?.getInitializer();
+
+  if (
+    !Node.isStringLiteral(nameInitializer) ||
+    !Node.isStringLiteral(scopeInitializer)
+  ) {
+    return undefined;
+  }
+
+  return {
+    serviceName: nameInitializer.getLiteralText(),
+    scope: scopeInitializer.getLiteralText(),
+  };
+}
+
+function isServiceFactoryCall(
+  callExpression: import('ts-morph').CallExpression,
+): boolean {
+  const expression = callExpression.getExpression();
+  if (Node.isIdentifier(expression)) {
+    return expression.getText() === 'craftService' || expression.getText() === 'toCraftService';
+  }
+
+  if (Node.isPropertyAccessExpression(expression)) {
+    const methodName = expression.getName();
+    return methodName === 'craftService' || methodName === 'toCraftService';
+  }
+
+  return false;
+}
+
+function extractHelperExposureTracking(
+  callExpression: import('ts-morph').CallExpression,
+): HelperExposureTracking | undefined {
+  const exposeArgument = [...callExpression.getArguments()]
+    .reverse()
+    .find(
+      (argument) =>
+        Node.isArrowFunction(argument) || Node.isFunctionExpression(argument),
+    );
+
+  if (
+    !exposeArgument ||
+    (!Node.isArrowFunction(exposeArgument) &&
+      !Node.isFunctionExpression(exposeArgument))
+  ) {
+    return undefined;
+  }
+
+  const parameter = exposeArgument.getParameters()[0];
+  const nameNode = parameter?.getNameNode();
+  if (!nameNode || !Node.isObjectBindingPattern(nameNode)) {
+    return undefined;
+  }
+
+  const bindings = extractHelperExposureBindings(nameNode);
+  if (bindings.length === 0) {
+    return undefined;
+  }
+
+  const returnObjectLiteral = getExposureReturnObjectLiteral(exposeArgument);
+  if (!returnObjectLiteral) {
+    return undefined;
+  }
+
+  const exposedProperties = extractHelperExposedProperties(
+    returnObjectLiteral,
+    bindings,
+  );
+  const usedProperties = mergeDeps(
+    exposedProperties.map(({ sourceKey }) => sourceKey),
+    extractHelperYieldedProperties(exposeArgument, bindings),
+  );
+
+  return {
+    usedProperties,
+    exposedProperties,
+  };
+}
+
+function extractHelperExposureBindings(
+  bindingPattern: import('ts-morph').ObjectBindingPattern,
+): HelperExposureBinding[] {
+  const bindings: HelperExposureBinding[] = [];
+
+  for (const element of bindingPattern.getElements()) {
+    const nameNode = element.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      continue;
+    }
+
+    const propertyNameNode = element.getPropertyNameNode();
+    const sourceKey =
+      getStaticPropertyName(propertyNameNode ?? nameNode) ?? nameNode.getText();
+
+    bindings.push({
+      localName: nameNode.getText(),
+      sourceKey,
+    });
+  }
+
+  return bindings;
+}
+
+function getExposureReturnObjectLiteral(
+  exposeArgument: import('ts-morph').ArrowFunction | import('ts-morph').FunctionExpression,
+): ObjectLiteralExpression | undefined {
+  const body = exposeArgument.getBody();
+  if (Node.isObjectLiteralExpression(body)) {
+    return body;
+  }
+
+  if (Node.isParenthesizedExpression(body)) {
+    const expression = body.getExpression();
+    return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+  }
+
+  if (!Node.isBlock(body)) {
+    return undefined;
+  }
+
+  const returnStatement = [...body.getDescendantsOfKind(SyntaxKind.ReturnStatement)]
+    .reverse()
+    .find((statement) => Node.isObjectLiteralExpression(statement.getExpression()));
+
+  const expression = returnStatement?.getExpression();
+  return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+}
+
+function extractHelperExposedProperties(
+  objectLiteral: ObjectLiteralExpression,
+  bindings: HelperExposureBinding[],
+): Array<{ exposedKey: string; sourceKey: string }> {
+  const bindingMap = new Map(
+    bindings.map((binding) => [binding.localName, binding.sourceKey]),
+  );
+  const exposedProperties: Array<{ exposedKey: string; sourceKey: string }> = [];
+
+  for (const property of objectLiteral.getProperties()) {
+    if (Node.isShorthandPropertyAssignment(property)) {
+      const sourceKey = bindingMap.get(property.getName());
+      if (sourceKey) {
+        exposedProperties.push({
+          exposedKey: property.getName(),
+          sourceKey,
+        });
+      }
+      continue;
+    }
+
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+
+    const exposedKey = getStaticPropertyName(property.getNameNode());
+    const initializer = property.getInitializer();
+    if (!exposedKey || !Node.isIdentifier(initializer)) {
+      continue;
+    }
+
+    const sourceKey = bindingMap.get(initializer.getText());
+    if (!sourceKey) {
+      continue;
+    }
+
+    exposedProperties.push({
+      exposedKey,
+      sourceKey,
+    });
+  }
+
+  return exposedProperties;
+}
+
+function extractHelperYieldedProperties(
+  exposeArgument: import('ts-morph').ArrowFunction | import('ts-morph').FunctionExpression,
+  bindings: HelperExposureBinding[],
+): string[] {
+  const bindingMap = new Map(
+    bindings.map((binding) => [binding.localName, binding.sourceKey]),
+  );
+  const yieldedProperties: string[] = [];
+
+  for (const yieldExpression of exposeArgument.getDescendantsOfKind(
+    SyntaxKind.YieldExpression,
+  )) {
+    const expression = yieldExpression.getExpression();
+    if (!Node.isCallExpression(expression)) {
+      continue;
+    }
+
+    const target = expression.getExpression();
+    if (!Node.isIdentifier(target)) {
+      continue;
+    }
+
+    const sourceKey = bindingMap.get(target.getText());
+    if (sourceKey) {
+      yieldedProperties.push(sourceKey);
+    }
+  }
+
+  return yieldedProperties;
+}
+
 function createGeneratedDependencyKey(dependencyText: string): string {
   const lastSegment = dependencyText.split('.').pop() ?? dependencyText;
   const helperMatch = /^(inject|provide)([A-Z].*)$/.exec(lastSegment);
@@ -768,7 +1164,13 @@ function formatGeneratedDependencyType(
     '{',
     `  deps: ${formatGeneratedDependencyObject(generatedDependencyGroups.deps)};`,
     `  provided: ${formatGeneratedDependencyObject(generatedDependencyGroups.provided)};`,
-    `  missingProvider: ${formatGeneratedDependencyObject(generatedDependencyGroups.missingProvider)};`,
+    ...(generatedDependencyGroups.missingProvider.length > 0
+      ? [
+          `  missingProvider: ${formatGeneratedDependencyObject(
+            generatedDependencyGroups.missingProvider,
+          )};`,
+        ]
+      : []),
     '}',
   ].join('\n');
 }
@@ -782,13 +1184,21 @@ function formatGeneratedDependencyObject(
 
   return [
     '{',
-    ...entries.map(
-      (entry) => `    ${formatObjectKey(entry.key)}: ${entry.typeText};`,
-    ),
+    ...entries.map((entry) => formatGeneratedDependencyEntry(entry)),
     '  }',
   ].join('\n');
 }
 
+function formatGeneratedDependencyEntry(entry: GeneratedDependencyEntry): string {
+  const typeLines = entry.typeText.split('\n');
+  const lines = [
+    `    ${formatObjectKey(entry.key)}: ${typeLines[0]}`,
+    ...typeLines.slice(1).map((line) => `    ${line}`),
+  ];
+  lines[lines.length - 1] += ';';
+  return lines.join('\n');
+}
+
 function formatObjectKey(key: string): string {
   return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : `'${key}'`;
 }
@@ -927,7 +1337,12 @@ export function ensureHelperImports(
   sourceFile: SourceFile,
   helperImportPath: string,
 ): void {
-  const missingImports = ['GetDeps'].filter(
+  const missingImports = [
+    'DerivedService',
+    'GetDeps',
+    'GetInjectedServiceDependencies',
+    'GetServiceOutput',
+  ].filter(
     (importName) =>
       !hasLocalNamedImport(sourceFile, helperImportPath, importName),
   );
@@ -1875,6 +2290,64 @@ function isProvidedInInjectableTree(
   );
 }
 
+function shouldGenerateLocalMissingProvider(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): boolean {
+  return (
+    !resolveTrackedInjectHelperByName(sourceFile, dependencyText) &&
+    !isProvidedInInjectableTree(sourceFile, dependencyText)
+  );
+}
+
+function resolveTrackedInjectHelperByName(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): TrackedHelperResolution | undefined {
+  const [rootIdentifier] = dependencyText.split('.');
+  if (!rootIdentifier) {
+    return undefined;
+  }
+
+  for (const declaration of resolveDependencyIdentifierDeclarations(
+    sourceFile,
+    rootIdentifier,
+  )) {
+    const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+    if (helper) {
+      return helper;
+    }
+  }
+
+  return undefined;
+}
+
+function resolveDependencyIdentifierDeclarations(
+  sourceFile: SourceFile,
+  rootIdentifier: string,
+): Node[] {
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    const namedImport = importDeclaration.getNamedImports().find((specifier) => {
+      const localName =
+        specifier.getAliasNode()?.getText() ?? specifier.getNameNode().getText();
+      return localName === rootIdentifier;
+    });
+
+    if (!namedImport) {
+      continue;
+    }
+
+    const identifier = namedImport.getAliasNode() ?? namedImport.getNameNode();
+    const symbol = identifier.getSymbol() ?? identifier.getType().getSymbol();
+    const aliasedSymbol = symbol?.getAliasedSymbol() ?? symbol;
+    return aliasedSymbol?.getDeclarations() ?? [namedImport];
+  }
+
+  return sourceFile
+    .getDescendantsOfKind(SyntaxKind.BindingElement)
+    .filter((bindingElement) => bindingElement.getName() === rootIdentifier);
+}
+
 function getDependencyTextFromTypeNode(typeNode: TypeNode): string | undefined {
   if (isPrimitiveTypeNode(typeNode)) {
     return undefined;
@@ -2124,7 +2597,12 @@ function getHelperImportSafety(
   sourceFile: SourceFile,
   helperImportPath: string,
 ): { safe: true; warnings: [] } | { safe: false; warnings: string[] } {
-  const warnings = ['GetDeps']
+  const warnings = [
+    'DerivedService',
+    'GetDeps',
+    'GetInjectedServiceDependencies',
+    'GetServiceOutput',
+  ]
     .filter((helperName) =>
       hasConflictingTopLevelBinding(sourceFile, helperImportPath, helperName),
     )