@craft-ng/dev-tools 0.1.9 → 0.4.0-beta.1

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

@@ -15,11 +15,41 @@ import {
   TypeNode,
   ts,
 } from 'ts-morph';
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { basename, extname, isAbsolute, join, resolve } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  resolve,
+} from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export type AngularKind = 'component' | 'directive' | 'pipe' | 'injectable';
+export type AngularBrandMetadataContext = 'imports' | 'hostDirectives';
+
+export type AngularBrandConfigEntry = {
+  key: string;
+  symbol: string;
+  typeText?: string;
+  module?: string;
+};
+
+export type AngularBrandImportAugmentationRule = {
+  match: {
+    module: string;
+    symbols?: readonly string[];
+    metadata?: readonly AngularBrandMetadataContext[];
+  };
+  deps?: readonly AngularBrandConfigEntry[];
+  missingProvider?: readonly AngularBrandConfigEntry[];
+};
+
+export type AngularBrandConfig = {
+  importAugmentations?: readonly AngularBrandImportAugmentationRule[];
+};
 
 export type TransformResult = {
   changed: boolean;
@@ -38,6 +68,8 @@ export type AngularBrandCodemodOptions = {
   transformOnlyStandaloneDeclarables?: boolean;
   includeProviders?: boolean;
   includeViewProviders?: boolean;
+  config?: AngularBrandConfig;
+  configFilePath?: string;
 };
 
 export type AngularClassSearchResult = {
@@ -70,10 +102,17 @@ export type GeneratedDependencyEntry = {
 
 export type GeneratedDependencyGroups = {
   deps: GeneratedDependencyEntry[];
+  propertiesDeps: GeneratedDependencyEntry[];
   provided: GeneratedDependencyEntry[];
   missingProvider: GeneratedDependencyEntry[];
 };
 
+type GeneratedDependencyGroupAugmentation = {
+  deps: GeneratedDependencyDescriptor[];
+  missingProvider: GeneratedDependencyDescriptor[];
+  legacyInjectedDependencies: GeneratedDependencyDescriptor[];
+};
+
 export type DependencyAnalysisResult = Omit<TransformResult, 'changed'> & {
   classDeclaration?: ClassDeclaration;
 };
@@ -92,6 +131,7 @@ type MetadataDependencyGroups = {
   hostDirectives: string[];
   providers: string[];
   viewProviders: string[];
+  occurrences: MetadataDependencyOccurrence[];
   warnings: string[];
 };
 
@@ -105,14 +145,25 @@ type InjectedDependencyDescriptor = {
   entry: GeneratedDependencyEntry;
 };
 
+type GeneratedDependencyDescriptor = {
+  dependencyText: string;
+  entry: GeneratedDependencyEntry;
+};
+
 type InjectCallDependencyExtractionResult = DependencyExtractionResult & {
   generatedDependencies: InjectedDependencyDescriptor[];
 };
 
+type PropertyDependencyExtractionResult = DependencyExtractionResult & {
+  entries: GeneratedDependencyEntry[];
+  missingProvider: GeneratedDependencyEntry[];
+};
+
 type DependencyReferenceResolution = {
   kind: 'class' | 'enum' | 'function' | 'variable' | 'namespace' | 'unknown';
   classDeclaration?: ClassDeclaration;
   moduleSpecifier?: string;
+  importedName?: string;
 };
 
 type TrackedHelperResolution = {
@@ -133,7 +184,35 @@ type HelperExposureTracking = {
   }>;
 };
 
-type NormalizedOptions = Required<AngularBrandCodemodOptions>;
+type MetadataDependencyOccurrence = {
+  dependencyText: string;
+  symbolName: string;
+  moduleSpecifier?: string;
+  metadataContext: AngularBrandMetadataContext;
+};
+
+type NormalizedAngularBrandImportAugmentationRule = {
+  match: {
+    module: string;
+    symbols?: string[];
+    metadata: AngularBrandMetadataContext[];
+  };
+  deps: AngularBrandConfigEntry[];
+  missingProvider: AngularBrandConfigEntry[];
+};
+
+type NormalizedAngularBrandConfig = {
+  importAugmentations: NormalizedAngularBrandImportAugmentationRule[];
+};
+
+type NormalizedOptions = {
+  helperImportPath: string;
+  transformOnlyStandaloneDeclarables: boolean;
+  includeProviders: boolean;
+  includeViewProviders: boolean;
+  config?: AngularBrandConfig;
+  configFilePath?: string;
+};
 
 type InjectDecoratorTokenResult =
   | { found: false }
@@ -163,8 +242,55 @@ const DEFAULT_OPTIONS: NormalizedOptions = {
   transformOnlyStandaloneDeclarables: false,
   includeProviders: true,
   includeViewProviders: true,
+  config: undefined,
+  configFilePath: undefined,
 };
 
+const ANGULAR_BRAND_CONFIG_FILE_NAME = 'craft-brand.config.ts';
+const DEFAULT_ANGULAR_BRAND_METADATA_CONTEXTS: AngularBrandMetadataContext[] = [
+  'imports',
+  'hostDirectives',
+];
+const DEFAULT_ANGULAR_BRAND_CONFIG = defineAngularBrandConfig({
+  importAugmentations: [
+    {
+      match: {
+        module: '@angular/router',
+      },
+      deps: [
+        {
+          key: 'Router',
+          symbol: 'Router',
+          module: '@angular/router',
+        },
+      ],
+      missingProvider: [
+        {
+          key: 'Router',
+          symbol: 'Router',
+          module: '@angular/router',
+        },
+      ],
+    },
+    {
+      match: {
+        module: '@angular/forms/signals',
+        symbols: ['FormField'],
+        metadata: ['imports'],
+      },
+      deps: [
+        {
+          key: 'FormField',
+          symbol: 'FormField',
+          typeText: 'FormField<any>',
+          module: '@angular/forms/signals',
+        },
+      ],
+    },
+  ],
+});
+const angularBrandConfigCache = new Map<string, AngularBrandConfig>();
+
 const PRIMITIVE_TYPE_TEXTS = new Set([
   'any',
   'bigint',
@@ -209,6 +335,386 @@ const IGNORED_DIRECTORIES = new Set([
   'tmp',
 ]);
 
+export function defineAngularBrandConfig<Config extends AngularBrandConfig>(
+  config: Config,
+): Config {
+  return config;
+}
+
+export function discoverAngularBrandConfigFilePath(
+  searchFromDir: string,
+  stopDir?: string,
+): string | undefined {
+  const resolvedStopDir = stopDir ? resolve(stopDir) : undefined;
+  let currentDir = resolve(searchFromDir);
+
+  while (true) {
+    const candidatePath = join(currentDir, ANGULAR_BRAND_CONFIG_FILE_NAME);
+    if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+      return candidatePath;
+    }
+
+    if (resolvedStopDir && currentDir === resolvedStopDir) {
+      return undefined;
+    }
+
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return undefined;
+    }
+
+    currentDir = parentDir;
+  }
+}
+
+export function loadAngularBrandConfigFromFile(
+  configFilePath: string,
+): AngularBrandConfig {
+  const resolvedConfigFilePath = resolve(configFilePath);
+  const cachedConfig = angularBrandConfigCache.get(resolvedConfigFilePath);
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+
+  if (
+    !existsSync(resolvedConfigFilePath) ||
+    !statSync(resolvedConfigFilePath).isFile()
+  ) {
+    throw new Error(
+      `Angular brand config file not found at "${resolvedConfigFilePath}".`,
+    );
+  }
+
+  try {
+    const sourceText = readFileSync(resolvedConfigFilePath, 'utf8');
+    const transpiled = ts.transpileModule(sourceText, {
+      compilerOptions: {
+        module: ts.ModuleKind.CommonJS,
+        target: ts.ScriptTarget.ES2022,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+      },
+      fileName: resolvedConfigFilePath,
+    });
+    const module = { exports: {} as Record<string, unknown> };
+    const moduleRequire = createRequire(resolvedConfigFilePath);
+    const compiledModule = new Function(
+      'exports',
+      'require',
+      'module',
+      '__filename',
+      '__dirname',
+      transpiled.outputText,
+    ) as (
+      exports: Record<string, unknown>,
+      require: (specifier: string) => unknown,
+      module: { exports: Record<string, unknown> },
+      __filename: string,
+      __dirname: string,
+    ) => void;
+
+    compiledModule(
+      module.exports,
+      (specifier: string) => {
+        if (specifier === '@craft-ng/dev-tools') {
+          return { defineAngularBrandConfig };
+        }
+
+        return moduleRequire(specifier);
+      },
+      module,
+      resolvedConfigFilePath,
+      dirname(resolvedConfigFilePath),
+    );
+
+    const exportedConfig =
+      module.exports['default'] ??
+      (module.exports['__esModule']
+        ? module.exports['default']
+        : module.exports);
+    const validatedConfig = validateAngularBrandConfig(
+      exportedConfig,
+      resolvedConfigFilePath,
+    );
+
+    angularBrandConfigCache.set(resolvedConfigFilePath, validatedConfig);
+    return validatedConfig;
+  } catch (error: unknown) {
+    throw new Error(
+      `Invalid Angular brand config at "${resolvedConfigFilePath}": ${getErrorMessage(error)}`,
+    );
+  }
+}
+
+function resolveAngularBrandConfig(
+  sourceFile: SourceFile,
+  options: NormalizedOptions,
+): NormalizedAngularBrandConfig {
+  const explicitConfig =
+    options.config ??
+    (options.configFilePath
+      ? loadAngularBrandConfigFromFile(options.configFilePath)
+      : loadDiscoveredAngularBrandConfig(dirname(sourceFile.getFilePath())));
+
+  return normalizeAngularBrandConfig(explicitConfig);
+}
+
+function loadDiscoveredAngularBrandConfig(
+  searchFromDir: string,
+  stopDir?: string,
+): AngularBrandConfig | undefined {
+  const discoveredConfigPath = discoverAngularBrandConfigFilePath(
+    searchFromDir,
+    stopDir,
+  );
+
+  return discoveredConfigPath
+    ? loadAngularBrandConfigFromFile(discoveredConfigPath)
+    : undefined;
+}
+
+function normalizeAngularBrandConfig(
+  config?: AngularBrandConfig,
+): NormalizedAngularBrandConfig {
+  const builtInRules = (
+    DEFAULT_ANGULAR_BRAND_CONFIG.importAugmentations ?? []
+  ).map(normalizeAngularBrandImportAugmentationRule);
+  const configuredRules = (config?.importAugmentations ?? []).map(
+    normalizeAngularBrandImportAugmentationRule,
+  );
+
+  return {
+    importAugmentations: [...builtInRules, ...configuredRules],
+  };
+}
+
+function normalizeAngularBrandImportAugmentationRule(
+  rule: AngularBrandImportAugmentationRule,
+): NormalizedAngularBrandImportAugmentationRule {
+  return {
+    match: {
+      module: rule.match.module,
+      symbols: rule.match.symbols ? [...rule.match.symbols] : undefined,
+      metadata: rule.match.metadata
+        ? [...rule.match.metadata]
+        : [...DEFAULT_ANGULAR_BRAND_METADATA_CONTEXTS],
+    },
+    deps: rule.deps ? [...rule.deps] : [],
+    missingProvider: rule.missingProvider ? [...rule.missingProvider] : [],
+  };
+}
+
+function validateAngularBrandConfig(
+  value: unknown,
+  configFilePath: string,
+): AngularBrandConfig {
+  if (!isPlainObject(value)) {
+    throw new Error('Expected the default export to be an object.');
+  }
+
+  const importAugmentations = readOptionalArray(
+    value['importAugmentations'],
+    'importAugmentations',
+    configFilePath,
+  )?.map((entry, index) =>
+    validateAngularBrandImportAugmentationRule(
+      entry,
+      `importAugmentations[${index}]`,
+      configFilePath,
+    ),
+  );
+
+  return {
+    importAugmentations: importAugmentations ?? [],
+  };
+}
+
+function validateAngularBrandImportAugmentationRule(
+  value: unknown,
+  pathLabel: string,
+  configFilePath: string,
+): AngularBrandImportAugmentationRule {
+  if (!isPlainObject(value)) {
+    throw new Error(`${pathLabel} must be an object.`);
+  }
+
+  if (!isPlainObject(value['match'])) {
+    throw new Error(`${pathLabel}.match must be an object.`);
+  }
+
+  const match = value['match'];
+
+  const moduleSpecifier = readRequiredString(
+    match['module'],
+    `${pathLabel}.match.module`,
+    configFilePath,
+  );
+  const symbols = readOptionalStringArray(
+    match['symbols'],
+    `${pathLabel}.match.symbols`,
+    configFilePath,
+  );
+  const metadata =
+    readOptionalStringArray(
+      match['metadata'],
+      `${pathLabel}.match.metadata`,
+      configFilePath,
+    )?.map((context) =>
+      validateAngularBrandMetadataContext(context, pathLabel),
+    ) ?? undefined;
+
+  return {
+    match: {
+      module: moduleSpecifier,
+      symbols,
+      metadata,
+    },
+    deps:
+      readOptionalArray(
+        value['deps'],
+        `${pathLabel}.deps`,
+        configFilePath,
+      )?.map((entry, index) =>
+        validateAngularBrandConfigEntry(
+          entry,
+          `${pathLabel}.deps[${index}]`,
+          configFilePath,
+        ),
+      ) ?? [],
+    missingProvider:
+      readOptionalArray(
+        value['missingProvider'],
+        `${pathLabel}.missingProvider`,
+        configFilePath,
+      )?.map((entry, index) =>
+        validateAngularBrandConfigEntry(
+          entry,
+          `${pathLabel}.missingProvider[${index}]`,
+          configFilePath,
+        ),
+      ) ?? [],
+  };
+}
+
+function validateAngularBrandConfigEntry(
+  value: unknown,
+  pathLabel: string,
+  configFilePath: string,
+): AngularBrandConfigEntry {
+  if (!isPlainObject(value)) {
+    throw new Error(`${pathLabel} must be an object.`);
+  }
+
+  const key = readRequiredString(
+    value['key'],
+    `${pathLabel}.key`,
+    configFilePath,
+  );
+  const symbol = readRequiredString(
+    value['symbol'],
+    `${pathLabel}.symbol`,
+    configFilePath,
+  );
+  const typeText = readOptionalString(
+    value['typeText'],
+    `${pathLabel}.typeText`,
+    configFilePath,
+  );
+  const moduleSpecifier = readOptionalString(
+    value['module'],
+    `${pathLabel}.module`,
+    configFilePath,
+  );
+
+  return {
+    key,
+    symbol,
+    typeText,
+    module: moduleSpecifier,
+  };
+}
+
+function validateAngularBrandMetadataContext(
+  value: string,
+  pathLabel: string,
+): AngularBrandMetadataContext {
+  if (value === 'imports' || value === 'hostDirectives') {
+    return value;
+  }
+
+  throw new Error(
+    `${pathLabel}.match.metadata must contain only "imports" or "hostDirectives".`,
+  );
+}
+
+function readOptionalArray(
+  value: unknown,
+  pathLabel: string,
+  configFilePath: string,
+): unknown[] | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (!Array.isArray(value)) {
+    throw new Error(`${pathLabel} in "${configFilePath}" must be an array.`);
+  }
+
+  return value;
+}
+
+function readRequiredString(
+  value: unknown,
+  pathLabel: string,
+  configFilePath: string,
+): string {
+  const stringValue = readOptionalString(value, pathLabel, configFilePath);
+  if (!stringValue) {
+    throw new Error(`${pathLabel} in "${configFilePath}" must be a string.`);
+  }
+
+  return stringValue;
+}
+
+function readOptionalString(
+  value: unknown,
+  pathLabel: string,
+  configFilePath: string,
+): string | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (typeof value !== 'string') {
+    throw new Error(`${pathLabel} in "${configFilePath}" must be a string.`);
+  }
+
+  return value;
+}
+
+function readOptionalStringArray(
+  value: unknown,
+  pathLabel: string,
+  configFilePath: string,
+): string[] | undefined {
+  const arrayValue = readOptionalArray(value, pathLabel, configFilePath);
+  if (!arrayValue) {
+    return undefined;
+  }
+
+  return arrayValue.map((entry, index) =>
+    readRequiredString(entry, `${pathLabel}[${index}]`, configFilePath),
+  );
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export function transformSourceFile(
   sourceFile: SourceFile,
   options: AngularBrandCodemodOptions = {},
@@ -259,6 +765,10 @@ export function analyzeSourceFileDependencies(
   options: AngularBrandCodemodOptions = {},
 ): DependencyAnalysisResult {
   const normalizedOptions = normalizeOptions(options);
+  const angularBrandConfig = resolveAngularBrandConfig(
+    sourceFile,
+    normalizedOptions,
+  );
   const result: DependencyAnalysisResult = {
     skipped: false,
     warnings: [],
@@ -320,26 +830,47 @@ export function analyzeSourceFileDependencies(
         )
       : { entries: [], warnings: [] };
   const constructorDeps = extractConstructorDeps(classDeclaration);
-  const injectCallDeps = extractInjectCallDeps(classDeclaration);
-
+  const propertyDeps = extractPropertyDependencies(
+    sourceFile,
+    classDeclaration,
+    className,
+  );
+  const generatedDependencyAugmentation =
+    createGeneratedDependencyGroupAugmentation(
+      sourceFile,
+      metadataDeps.occurrences,
+      angularBrandConfig,
+    );
+  const syntheticDependencyTexts = mergeDeps(
+    generatedDependencyAugmentation.deps.map(
+      (dependency) => dependency.dependencyText,
+    ),
+    generatedDependencyAugmentation.legacyInjectedDependencies.map(
+      (dependency) => dependency.dependencyText,
+    ),
+  );
   result.warnings.push(
     ...metadataDeps.warnings,
     ...providedDeps.warnings,
     ...constructorDeps.warnings,
-    ...injectCallDeps.warnings,
+    ...propertyDeps.warnings,
   );
   result.dependencies = mergeDeps(
     constructorDeps.dependencies,
-    injectCallDeps.dependencies,
+    propertyDeps.dependencies,
     metadataDeps.imports,
     metadataDeps.hostDirectives,
     metadataDeps.providers,
     metadataDeps.viewProviders,
+    syntheticDependencyTexts,
   );
   result.dependencyGroups = {
     injected: mergeDeps(
       constructorDeps.dependencies,
-      injectCallDeps.dependencies,
+      propertyDeps.dependencies,
+      generatedDependencyAugmentation.legacyInjectedDependencies.map(
+        (dependency) => dependency.dependencyText,
+      ),
     ),
     importDeps: mergeDeps(metadataDeps.imports, metadataDeps.hostDirectives),
     providers: mergeDeps(metadataDeps.providers, metadataDeps.viewProviders),
@@ -347,19 +878,12 @@ export function analyzeSourceFileDependencies(
   result.generatedTypeName = getGeneratedDepsTypeName(className);
   result.generatedDependencyGroups = createGeneratedDependencyGroups(
     sourceFile,
+    className,
     result.dependencyGroups.importDeps,
-    [
-      ...constructorDeps.dependencies.map((dependencyText) => ({
-        dependencyText,
-        entry: createGeneratedDependencyEntry(
-          sourceFile,
-          dependencyText,
-          'inject',
-        ),
-      })),
-      ...injectCallDeps.generatedDependencies,
-    ],
+    constructorDeps.dependencies,
+    propertyDeps,
     providedDeps.entries,
+    generatedDependencyAugmentation,
   );
 
   return result;
@@ -572,6 +1096,99 @@ export function extractInjectCallDeps(
   };
 }
 
+function extractPropertyDependencies(
+  sourceFile: SourceFile,
+  classDeclaration: ClassDeclaration,
+  className: string,
+): PropertyDependencyExtractionResult {
+  const warnings: string[] = [];
+  const dependencies: string[] = [];
+  const entries: GeneratedDependencyEntry[] = [];
+  const missingProvider: GeneratedDependencyEntry[] = [];
+
+  for (const property of classDeclaration.getProperties()) {
+    if (property.isStatic()) {
+      continue;
+    }
+
+    const propertyName = getStaticPropertyName(property.getNameNode());
+    if (!propertyName) {
+      warnings.push(
+        `Skipped property dependency tracking for ${property.getText()} because the property name is not static.`,
+      );
+      continue;
+    }
+
+    const initializer = property.getInitializer();
+    if (Node.isCallExpression(initializer)) {
+      const expression = initializer.getExpression();
+      const injectMethodName = getInjectMethodName(expression);
+
+      if (injectMethodName?.startsWith('inject')) {
+        const dependencyText =
+          injectMethodName === 'inject'
+            ? getAngularInjectCallDependency(initializer)
+            : getInjectionHelperDependency(expression);
+
+        if (!dependencyText) {
+          warnings.push(
+            `Skipped ${injectMethodName}() property dependency tracking for "${propertyName}" because the dependency is not static.`,
+          );
+        } else {
+          dependencies.push(dependencyText);
+
+          const dependencyEntry =
+            injectMethodName === 'inject'
+              ? createGeneratedDependencyEntry(
+                  sourceFile,
+                  dependencyText,
+                  'inject',
+                )
+              : createGeneratedInjectHelperDependencyEntry(
+                  sourceFile,
+                  initializer,
+                  expression,
+                  dependencyText,
+                );
+
+          entries.push(
+            createGeneratedPropertyDependencyEntry(
+              propertyName,
+              createSingleDependencyMapTypeText(dependencyEntry),
+            ),
+          );
+
+          if (shouldGenerateLocalMissingProvider(sourceFile, dependencyText)) {
+            missingProvider.push(
+              createGeneratedDependencyEntry(
+                sourceFile,
+                dependencyText,
+                'inject',
+              ),
+            );
+          }
+
+          continue;
+        }
+      }
+    }
+
+    entries.push(
+      createGeneratedPropertyDependencyEntry(
+        propertyName,
+        createExtractDepsTypeText(className, propertyName),
+      ),
+    );
+  }
+
+  return {
+    dependencies: mergeDeps(dependencies),
+    warnings,
+    entries,
+    missingProvider: mergeGeneratedDependencyEntries(missingProvider),
+  };
+}
+
 export function mergeDeps(...dependencyGroups: readonly string[][]): string[] {
   const seen = new Set<string>();
   const dependencies: string[] = [];
@@ -601,65 +1218,154 @@ function emptyDependencyGroups(): DependencyGroups {
 function emptyGeneratedDependencyGroups(): GeneratedDependencyGroups {
   return {
     deps: [],
+    propertiesDeps: [],
     provided: [],
     missingProvider: [],
   };
 }
 
+function emptyGeneratedDependencyGroupAugmentation(): GeneratedDependencyGroupAugmentation {
+  return {
+    deps: [],
+    missingProvider: [],
+    legacyInjectedDependencies: [],
+  };
+}
+
 function getGeneratedDepsTypeName(className: string): string {
   return `GenDeps_${className}`;
 }
 
 function createGeneratedDependencyGroups(
   sourceFile: SourceFile,
+  className: string,
   importDependencies: string[],
-  injectedDependencies: InjectedDependencyDescriptor[],
+  constructorDependencies: string[],
+  propertyDependencies: PropertyDependencyExtractionResult,
   providedEntries: GeneratedDependencyEntry[],
+  augmentation: GeneratedDependencyGroupAugmentation,
 ): GeneratedDependencyGroups {
+  const constructorEntries = constructorDependencies.map((dependency) =>
+    createGeneratedDependencyEntry(sourceFile, dependency, 'inject'),
+  );
   const deps = mergeGeneratedDependencyEntries(
     importDependencies.map((dependency) =>
       createGeneratedDependencyEntry(sourceFile, dependency, 'import'),
     ),
-    injectedDependencies.map((dependency) => dependency.entry),
+    constructorEntries,
+    augmentation.deps.map((dependency) => dependency.entry),
+  );
+  const propertiesDeps = mergeGeneratedDependencyEntries(
+    propertyDependencies.entries,
   );
   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 = dependency.entry.key;
-        return (
-          !providedKeys.has(dependencyKey) &&
-          shouldGenerateLocalMissingProvider(
-            sourceFile,
-            dependency.dependencyText,
-          )
-        );
-      })
-      .map(
-        (dependency) =>
-          injectedEntriesByKey.get(dependency.entry.key) ??
-          createGeneratedDependencyEntry(
-            sourceFile,
-            dependency.dependencyText,
-            'inject',
-          ),
+    constructorDependencies
+      .filter((dependencyText) =>
+        shouldGenerateLocalMissingProvider(sourceFile, dependencyText),
+      )
+      .map((dependencyText) =>
+        createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject'),
       ),
+    propertyDependencies.missingProvider,
+    augmentation.missingProvider
+      .map((dependency) => dependency.entry)
+      .filter((entry) => !providedKeys.has(entry.key)),
   );
 
   return {
     deps,
+    propertiesDeps,
     provided,
     missingProvider,
   };
 }
 
+function createGeneratedDependencyGroupAugmentation(
+  sourceFile: SourceFile,
+  metadataOccurrences: MetadataDependencyOccurrence[],
+  config: NormalizedAngularBrandConfig,
+): GeneratedDependencyGroupAugmentation {
+  if (metadataOccurrences.length === 0) {
+    return emptyGeneratedDependencyGroupAugmentation();
+  }
+
+  const deps: GeneratedDependencyDescriptor[] = [];
+  const missingProvider: GeneratedDependencyDescriptor[] = [];
+  const legacyInjectedDependencies: GeneratedDependencyDescriptor[] = [];
+
+  for (const rule of config.importAugmentations) {
+    if (
+      !metadataOccurrences.some((occurrence) =>
+        ruleMatchesMetadataOccurrence(rule, occurrence),
+      )
+    ) {
+      continue;
+    }
+
+    const generatedDeps = rule.deps.map((entry) =>
+      createConfiguredGeneratedDependencyDescriptor(
+        sourceFile,
+        entry,
+        rule.match.module,
+      ),
+    );
+    const generatedMissingProviders = rule.missingProvider.map((entry) =>
+      createConfiguredGeneratedDependencyDescriptor(
+        sourceFile,
+        entry,
+        rule.match.module,
+      ),
+    );
+
+    deps.push(...generatedDeps);
+    missingProvider.push(...generatedMissingProviders);
+    legacyInjectedDependencies.push(...generatedMissingProviders);
+  }
+
+  return {
+    deps,
+    missingProvider,
+    legacyInjectedDependencies,
+  };
+}
+
+function ruleMatchesMetadataOccurrence(
+  rule: NormalizedAngularBrandImportAugmentationRule,
+  occurrence: MetadataDependencyOccurrence,
+): boolean {
+  if (occurrence.moduleSpecifier !== rule.match.module) {
+    return false;
+  }
+
+  if (!rule.match.metadata.includes(occurrence.metadataContext)) {
+    return false;
+  }
+
+  return (
+    !rule.match.symbols || rule.match.symbols.includes(occurrence.symbolName)
+  );
+}
+
+function createConfiguredGeneratedDependencyDescriptor(
+  sourceFile: SourceFile,
+  entry: AngularBrandConfigEntry,
+  defaultModuleSpecifier: string,
+): GeneratedDependencyDescriptor {
+  return {
+    dependencyText: entry.symbol,
+    entry: createSyntheticGeneratedDependencyEntry(
+      sourceFile,
+      entry.symbol,
+      'inject',
+      entry.module ?? defaultModuleSpecifier,
+      entry.key,
+      entry.typeText,
+    ),
+  };
+}
+
 function mergeGeneratedDependencyEntries(
   ...groups: readonly GeneratedDependencyEntry[][]
 ): GeneratedDependencyEntry[] {
@@ -667,9 +1373,7 @@ function mergeGeneratedDependencyEntries(
 
   for (const group of groups) {
     for (const entry of group) {
-      if (!entries.has(entry.key)) {
-        entries.set(entry.key, entry);
-      }
+      entries.set(entry.key, entry);
     }
   }
 
@@ -709,6 +1413,26 @@ function createGeneratedDependencyEntry(
   };
 }
 
+function createSyntheticGeneratedDependencyEntry(
+  sourceFile: SourceFile,
+  dependencyText: string,
+  context: 'import' | 'inject',
+  moduleSpecifier: string,
+  key = createGeneratedDependencyKey(dependencyText),
+  typeText?: string,
+): GeneratedDependencyEntry {
+  return {
+    ...createGeneratedDependencyEntry(sourceFile, dependencyText, context),
+    key,
+    typeText:
+      typeText ?? createGeneratedDependencyTypeText(sourceFile, dependencyText),
+    typeImport: {
+      moduleSpecifier,
+      name: dependencyText,
+    },
+  };
+}
+
 function createGeneratedInjectHelperDependencyEntry(
   sourceFile: SourceFile,
   callExpression: import('ts-morph').CallExpression,
@@ -726,6 +1450,7 @@ function createGeneratedInjectHelperDependencyEntry(
     key: trackedHelper.serviceName,
     typeText: createTrackedInjectHelperTypeText(
       dependencyText,
+      trackedHelper.serviceName,
       exposureTracking,
     ),
   };
@@ -733,9 +1458,10 @@ function createGeneratedInjectHelperDependencyEntry(
 
 function createTrackedInjectHelperTypeText(
   dependencyText: string,
+  serviceName: string,
   exposureTracking: HelperExposureTracking | undefined,
 ): string {
-  const baseType = `GetInjectedServiceDependencies<typeof ${dependencyText}>`;
+  const baseType = `ExtractDeps<typeof ${dependencyText}>[${JSON.stringify(serviceName)}]`;
   if (!exposureTracking) {
     return baseType;
   }
@@ -760,6 +1486,29 @@ function createTrackedInjectHelperTypeText(
   ].join('\n');
 }
 
+function createGeneratedPropertyDependencyEntry(
+  propertyName: string,
+  typeText: string,
+): GeneratedDependencyEntry {
+  return {
+    key: propertyName,
+    typeText,
+  };
+}
+
+function createExtractDepsTypeText(
+  className: string,
+  propertyName: string,
+): string {
+  return `ExtractDeps<${className}[${JSON.stringify(propertyName)}]>`;
+}
+
+function createSingleDependencyMapTypeText(
+  entry: GeneratedDependencyEntry,
+): string {
+  return formatGeneratedDependencyObject([entry]);
+}
+
 function formatHelperExposurePropertiesType(
   dependencyText: string,
   properties: Array<{ propertyKey: string; sourceKey: string }>,
@@ -1146,7 +1895,10 @@ function ensureGeneratedDependencyTypeImports(
 ): void {
   const importsToAdd = new Map<string, Set<string>>();
 
-  for (const entry of generatedDependencyGroups.deps) {
+  for (const entry of [
+    ...generatedDependencyGroups.deps,
+    ...generatedDependencyGroups.missingProvider,
+  ]) {
     if (!entry.typeImport) {
       continue;
     }
@@ -1162,12 +1914,28 @@ function ensureGeneratedDependencyTypeImports(
       .getImportDeclarations()
       .find(
         (importDeclaration) =>
-          importDeclaration.getModuleSpecifierValue() === moduleSpecifier,
+          importDeclaration.getModuleSpecifierValue() === moduleSpecifier &&
+          !importDeclaration.getNamespaceImport(),
       );
 
     if (existingImport) {
+      const existingImportNames = new Set(
+        existingImport.getNamedImports().map((namedImport) => {
+          return (
+            namedImport.getAliasNode()?.getText() ??
+            namedImport.getNameNode().getText()
+          );
+        }),
+      );
+      const namesToAdd = [...importNames].filter(
+        (name) => !existingImportNames.has(name),
+      );
+      if (namesToAdd.length === 0) {
+        continue;
+      }
+
       existingImport.addNamedImports(
-        [...importNames].map((name) => ({ name, isTypeOnly: true })),
+        namesToAdd.map((name) => ({ name, isTypeOnly: true })),
       );
       continue;
     }
@@ -1190,6 +1958,11 @@ function formatGeneratedDependencyType(
   return [
     '{',
     `  deps: ${formatGeneratedDependencyObject(generatedDependencyGroups.deps)};`,
+    ...(angularKind === 'component'
+      ? [
+          `  propertiesDeps: ${formatGeneratedDependencyObject(generatedDependencyGroups.propertiesDeps)};`,
+        ]
+      : []),
     `  provided: ${formatGeneratedDependencyObject(generatedDependencyGroups.provided)};`,
     ...(angularKind === 'component'
       ? [`  publicProperties: GetPublicComponentProperties<${className}>;`]
@@ -1376,8 +2149,8 @@ export function ensureHelperImports(
 ): void {
   const missingImports = [
     'DerivedService',
+    'ExtractDeps',
     'GetDeps',
-    'GetInjectedServiceDependencies',
     'GetPublicComponentProperties',
     'GetServiceOutput',
   ].filter(
@@ -1538,6 +2311,11 @@ export async function runAngularBrandCodemod(
   } = {},
 ): Promise<RunSummary> {
   const rootDir = resolve(options.rootDir ?? process.cwd());
+  const config =
+    options.config ??
+    (options.configFilePath
+      ? loadAngularBrandConfigFromFile(options.configFilePath)
+      : loadDiscoveredAngularBrandConfig(rootDir));
   const tsConfigFilePath = options.tsConfigFilePath
     ? resolve(options.tsConfigFilePath)
     : getDefaultTsConfigPath(rootDir);
@@ -1565,7 +2343,10 @@ export async function runAngularBrandCodemod(
       continue;
     }
 
-    const result = transformSourceFile(sourceFile, options);
+    const result = transformSourceFile(sourceFile, {
+      ...options,
+      config,
+    });
     const report: RunFileReport = {
       ...result,
       filePath: sourceFile.getFilePath(),
@@ -1612,6 +2393,8 @@ function normalizeOptions(
       options.includeProviders ?? DEFAULT_OPTIONS.includeProviders,
     includeViewProviders:
       options.includeViewProviders ?? DEFAULT_OPTIONS.includeViewProviders,
+    config: options.config,
+    configFilePath: options.configFilePath,
   };
 }
 
@@ -1707,6 +2490,7 @@ function extractDecoratorMetadataDepGroups(
   angularKind: AngularKind,
   options: NormalizedOptions,
 ): MetadataDependencyGroups {
+  const sourceFile = classDeclaration.getSourceFile();
   const metadata = getDecoratorMetadataObject(classDeclaration);
   const groups = emptyMetadataDependencyGroups();
 
@@ -1745,6 +2529,19 @@ function extractDecoratorMetadataDepGroups(
     );
   }
 
+  groups.occurrences = [
+    ...groups.imports.map((dependencyText) =>
+      createMetadataDependencyOccurrence(sourceFile, dependencyText, 'imports'),
+    ),
+    ...groups.hostDirectives.map((dependencyText) =>
+      createMetadataDependencyOccurrence(
+        sourceFile,
+        dependencyText,
+        'hostDirectives',
+      ),
+    ),
+  ];
+
   return groups;
 }
 
@@ -1754,10 +2551,29 @@ function emptyMetadataDependencyGroups(): MetadataDependencyGroups {
     hostDirectives: [],
     providers: [],
     viewProviders: [],
+    occurrences: [],
     warnings: [],
   };
 }
 
+function createMetadataDependencyOccurrence(
+  sourceFile: SourceFile,
+  dependencyText: string,
+  metadataContext: AngularBrandMetadataContext,
+): MetadataDependencyOccurrence {
+  const resolution = resolveDependencyReference(sourceFile, dependencyText);
+
+  return {
+    dependencyText,
+    symbolName:
+      resolution.importedName ??
+      dependencyText.split('.').pop() ??
+      dependencyText,
+    moduleSpecifier: resolution.moduleSpecifier,
+    metadataContext,
+  };
+}
+
 function extractProvidedDependencies(
   sourceFile: SourceFile,
   classDeclaration: ClassDeclaration,
@@ -2182,11 +2998,12 @@ function resolveImportedDependencyReference(
         return {
           kind: 'class',
           classDeclaration: declaration,
+          importedName: rootIdentifier,
           moduleSpecifier,
         };
       }
 
-      return { kind: 'unknown', moduleSpecifier };
+      return { kind: 'unknown', importedName: rootIdentifier, moduleSpecifier };
     }
 
     if (importDeclaration.getNamespaceImport()?.getText() === rootIdentifier) {
@@ -2198,11 +3015,16 @@ function resolveImportedDependencyReference(
         return {
           kind: 'class',
           classDeclaration: declaration,
+          importedName: dependencyText.split('.').pop(),
           moduleSpecifier,
         };
       }
 
-      return { kind: 'namespace', moduleSpecifier };
+      return {
+        kind: 'namespace',
+        importedName: dependencyText.split('.').pop(),
+        moduleSpecifier,
+      };
     }
 
     const namedImport = importDeclaration
@@ -2232,6 +3054,7 @@ function resolveImportedDependencyReference(
       return {
         kind: 'class',
         classDeclaration,
+        importedName: namedImport.getNameNode().getText(),
         moduleSpecifier,
       };
     }
@@ -2239,7 +3062,11 @@ function resolveImportedDependencyReference(
     if (
       declarations.some((declaration) => Node.isEnumDeclaration(declaration))
     ) {
-      return { kind: 'enum', moduleSpecifier };
+      return {
+        kind: 'enum',
+        importedName: namedImport.getNameNode().getText(),
+        moduleSpecifier,
+      };
     }
 
     if (
@@ -2247,7 +3074,11 @@ function resolveImportedDependencyReference(
         Node.isFunctionDeclaration(declaration),
       )
     ) {
-      return { kind: 'function', moduleSpecifier };
+      return {
+        kind: 'function',
+        importedName: namedImport.getNameNode().getText(),
+        moduleSpecifier,
+      };
     }
 
     if (
@@ -2255,10 +3086,18 @@ function resolveImportedDependencyReference(
         Node.isVariableDeclaration(declaration),
       )
     ) {
-      return { kind: 'variable', moduleSpecifier };
+      return {
+        kind: 'variable',
+        importedName: namedImport.getNameNode().getText(),
+        moduleSpecifier,
+      };
     }
 
-    return { kind: 'unknown', moduleSpecifier };
+    return {
+      kind: 'unknown',
+      importedName: namedImport.getNameNode().getText(),
+      moduleSpecifier,
+    };
   }
 
   return undefined;
@@ -2957,6 +3796,9 @@ function parseCliArgs(argv: string[]): AngularBrandCodemodOptions & {
       case '--tsconfig':
         options.tsConfigFilePath = argv[++index];
         break;
+      case '--config':
+        options.configFilePath = argv[++index];
+        break;
       case '--helper-import':
         options.helperImportPath = argv[++index];
         break;
@@ -2989,6 +3831,7 @@ function printHelpAndExit(): never {
 Options:
   --root <dir>                                  Project root. Defaults to cwd.
   --tsconfig <path>                            tsconfig path. Defaults to <root>/tsconfig.json.
+  --config <path>                              Explicit angular brand config file path.
   --helper-import <path>                       Import path for GetDeps.
   --transform-only-standalone-declarables      Only transform standalone components/directives.
   --no-providers                               Do not include metadata providers in generated types.