@fluojs/cli 2.0.1 → 3.0.0

package/dist/transforms/nestjs-migrate.js

@@ -14,7 +14,7 @@ export const MIGRATION_TRANSFORMS = ['imports', 'injectable', 'scope', 'bootstra
 /**
  * Provides the warning categories value.
  */
-export const WARNING_CATEGORIES = ['inject-token', 'request-dto', 'pipe-converter', 'bootstrap-unsupported', 'testing-unsupported', 'import-unsupported', 'injectable-options', 'tsconfig-parse', 'bootstrap-port'];
+export const WARNING_CATEGORIES = ['inject-token', 'inject-token-unsupported', 'request-dto', 'pipe-converter', 'bootstrap-unsupported', 'testing-unsupported', 'import-unsupported', 'injectable-options', 'tsconfig-parse', 'bootstrap-port'];
 
 /**
  * Defines the warning category type.
@@ -26,6 +26,7 @@ export const WARNING_CATEGORIES = ['inject-token', 'request-dto', 'pipe-converte
 
 const WARNING_CATEGORY_LABEL = {
   'inject-token': 'DI token migration (@Inject)',
+  'inject-token-unsupported': 'Unsupported constructor injection',
   'request-dto': 'Request DTO migration (handler parameter decorators)',
   'pipe-converter': 'Pipe/converter migration',
   'bootstrap-unsupported': 'Unsupported bootstrap variant',
@@ -106,8 +107,8 @@ const NEST_COMMON_TO_FLUO = {
 const REQUEST_DTO_DECORATORS = new Set(['Body', 'Param', 'Query']);
 const TRANSFORM_KIND_LABEL = {
   bootstrap: 'bootstrap rewrite',
-  imports: 'import rewriting',
   injectable: '@Injectable removal',
+  imports: 'import rewriting',
   scope: 'scope mapping',
   testing: 'testing rewrite',
   tsconfig: 'tsconfig rewrite'
@@ -131,14 +132,15 @@ function getImportBindings(importDeclaration) {
   }
   return importClause.namedBindings.elements.map(element => ({
     imported: (element.propertyName ?? element.name).text,
+    isTypeOnly: importClause.isTypeOnly || element.isTypeOnly,
     local: element.name.text
   }));
 }
 function createImportSpecifier(binding) {
   if (binding.imported === binding.local) {
-    return ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(binding.local));
+    return ts.factory.createImportSpecifier(binding.isTypeOnly, undefined, ts.factory.createIdentifier(binding.local));
   }
-  return ts.factory.createImportSpecifier(false, ts.factory.createIdentifier(binding.imported), ts.factory.createIdentifier(binding.local));
+  return ts.factory.createImportSpecifier(binding.isTypeOnly, ts.factory.createIdentifier(binding.imported), ts.factory.createIdentifier(binding.local));
 }
 function toBindingKey(binding) {
   return `${binding.imported}::${binding.local}`;
@@ -151,34 +153,48 @@ function updateNamedImports(importDeclaration, bindings) {
   if (bindings.length === 0 && !importClause.name) {
     return undefined;
   }
-  const updatedClause = ts.factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, bindings.length > 0 ? ts.factory.createNamedImports(bindings.map(createImportSpecifier)) : undefined);
+  const isTypeOnlyClause = !importClause.name && bindings.length > 0 && bindings.every(binding => binding.isTypeOnly);
+  const updatedClause = ts.factory.updateImportClause(importClause, isTypeOnlyClause, importClause.name, bindings.length > 0 ? ts.factory.createNamedImports(bindings.map(binding => createImportSpecifier({
+    ...binding,
+    isTypeOnly: isTypeOnlyClause ? false : binding.isTypeOnly
+  }))) : undefined);
   return ts.factory.updateImportDeclaration(importDeclaration, importDeclaration.modifiers, updatedClause, importDeclaration.moduleSpecifier, importDeclaration.attributes);
 }
-function mergeNamedImport(statements, moduleSpecifier, newBindings) {
+function mergeNamedImport(statements, moduleSpecifier, newBindings, preserveTypeOnlyImport = false) {
   if (newBindings.length === 0) {
     return statements;
   }
-  const deduped = new Map();
-  for (const binding of newBindings) {
-    deduped.set(toBindingKey(binding), binding);
-  }
   let merged = false;
   const updated = statements.map(statement => {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== moduleSpecifier) {
+    if (merged || !ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== moduleSpecifier || preserveTypeOnlyImport && statement.importClause?.isTypeOnly) {
       return statement;
     }
-    const existingBindings = getImportBindings(statement);
-    for (const binding of existingBindings) {
-      deduped.set(toBindingKey(binding), binding);
+    if (!statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
+      return statement;
+    }
+    const bindings = new Map();
+    for (const binding of getImportBindings(statement)) {
+      bindings.set(toBindingKey(binding), binding);
+    }
+    for (const binding of newBindings) {
+      const existing = bindings.get(toBindingKey(binding));
+      if (!existing || !binding.isTypeOnly) {
+        bindings.set(toBindingKey(binding), binding);
+      }
     }
     merged = true;
-    const mergedBindings = [...deduped.values()].sort((left, right) => left.local.localeCompare(right.local));
+    const mergedBindings = [...bindings.values()].sort((left, right) => left.local.localeCompare(right.local));
     return updateNamedImports(statement, mergedBindings) ?? statement;
   });
   if (merged) {
     return updated;
   }
-  const importDeclaration = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([...deduped.values()].sort((left, right) => left.local.localeCompare(right.local)).map(createImportSpecifier))), ts.factory.createStringLiteral(moduleSpecifier));
+  const bindings = [...newBindings].sort((left, right) => left.local.localeCompare(right.local));
+  const isTypeOnlyClause = bindings.every(binding => binding.isTypeOnly);
+  const importDeclaration = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(isTypeOnlyClause, undefined, ts.factory.createNamedImports(bindings.map(binding => createImportSpecifier({
+    ...binding,
+    isTypeOnly: isTypeOnlyClause ? false : binding.isTypeOnly
+  })))), ts.factory.createStringLiteral(moduleSpecifier));
   const importIndexes = updated.map((statement, index) => ({
     index,
     isImport: ts.isImportDeclaration(statement)
@@ -227,11 +243,42 @@ function removeImportBinding(source, sourceFilePath, moduleSpecifier, importedNa
     source: printSourceFile(sourceFile, statements)
   };
 }
-function rewriteImports(source, filePath) {
+function removeNestFactoryValueImports(source, sourceFilePath) {
+  const sourceFile = parseSource(source, sourceFilePath);
+  let changed = false;
+  const statements = [];
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== '@nestjs/core') {
+      statements.push(statement);
+      continue;
+    }
+    const bindings = getImportBindings(statement);
+    const filtered = bindings.filter(binding => binding.imported !== 'NestFactory' || binding.isTypeOnly);
+    if (filtered.length !== bindings.length) {
+      changed = true;
+    }
+    const updated = updateNamedImports(statement, filtered);
+    if (updated) {
+      statements.push(updated);
+    }
+  }
+  if (!changed) {
+    return {
+      changed: false,
+      source
+    };
+  }
+  return {
+    changed: true,
+    source: printSourceFile(sourceFile, statements)
+  };
+}
+function rewriteImports(source, filePath, allowedNestImports) {
   const sourceFile = parseSource(source, filePath);
   const warnings = [];
   const additions = new Map();
   const statements = [];
+  const hasNestInjectParameter = hasNestInjectParameterDecorator(sourceFile, getNestInjectLocalNames(sourceFile));
   let touched = false;
   for (const statement of sourceFile.statements) {
     if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -250,6 +297,18 @@ function rewriteImports(source, filePath) {
     }
     const remaining = [];
     for (const binding of getImportBindings(statement)) {
+      if (binding.isTypeOnly && allowedNestImports) {
+        remaining.push(binding);
+        continue;
+      }
+      if (allowedNestImports && !allowedNestImports.has(binding.imported)) {
+        remaining.push(binding);
+        continue;
+      }
+      if (binding.imported === 'Inject' && hasNestInjectParameter) {
+        remaining.push(binding);
+        continue;
+      }
       const targetModule = NEST_COMMON_TO_FLUO[binding.imported];
       if (!targetModule) {
         remaining.push(binding);
@@ -259,6 +318,7 @@ function rewriteImports(source, filePath) {
       const moduleBindings = additions.get(targetModule) ?? [];
       moduleBindings.push({
         imported: binding.imported,
+        isTypeOnly: binding.isTypeOnly,
         local: binding.local
       });
       additions.set(targetModule, moduleBindings);
@@ -277,7 +337,7 @@ function rewriteImports(source, filePath) {
   }
   let nextStatements = statements;
   for (const [moduleSpecifier, bindings] of additions.entries()) {
-    nextStatements = mergeNamedImport(nextStatements, moduleSpecifier, bindings);
+    nextStatements = mergeNamedImport(nextStatements, moduleSpecifier, bindings, !!allowedNestImports);
   }
   const nextSource = printSourceFile(sourceFile, nextStatements);
   return {
@@ -304,6 +364,331 @@ function hasDecoratorNamed(modifiers, name) {
   }
   return modifiers.some(modifier => ts.isDecorator(modifier) && isDecoratorNamed(modifier, name));
 }
+function getNestInjectLocalNames(sourceFile) {
+  const localNames = new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== '@nestjs/common' || statement.importClause?.isTypeOnly || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
+      continue;
+    }
+    for (const element of statement.importClause.namedBindings.elements) {
+      if (!element.isTypeOnly && (element.propertyName ?? element.name).text === 'Inject') {
+        localNames.add(element.name.text);
+      }
+    }
+  }
+  return localNames;
+}
+function getFluoInjectLocalNames(sourceFile) {
+  const localNames = new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== '@fluojs/core' || statement.importClause?.isTypeOnly || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
+      continue;
+    }
+    for (const element of statement.importClause.namedBindings.elements) {
+      if (!element.isTypeOnly && (element.propertyName ?? element.name).text === 'Inject') {
+        localNames.add(element.name.text);
+      }
+    }
+  }
+  return localNames;
+}
+function getFluoInjectNamespaceLocalNames(sourceFile) {
+  const localNames = new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== '@fluojs/core' || statement.importClause?.isTypeOnly || !statement.importClause?.namedBindings || !ts.isNamespaceImport(statement.importClause.namedBindings)) {
+      continue;
+    }
+    localNames.add(statement.importClause.namedBindings.name.text);
+  }
+  return localNames;
+}
+function getNestInjectDecoratorLocalName(decorator, localNames) {
+  if (!ts.isCallExpression(decorator.expression) || !ts.isIdentifier(decorator.expression.expression)) {
+    return undefined;
+  }
+  const localName = decorator.expression.expression.text;
+  return localNames.has(localName) ? localName : undefined;
+}
+function hasNestInjectDecorator(modifiers, localNames) {
+  if (!modifiers) {
+    return false;
+  }
+  return modifiers.some(modifier => ts.isDecorator(modifier) && !!getNestInjectDecoratorLocalName(modifier, localNames));
+}
+function getFluoInjectClassDecorator(modifiers, localNames, namespaceLocalNames) {
+  if (!modifiers) {
+    return undefined;
+  }
+  for (const modifier of modifiers) {
+    if (!ts.isDecorator(modifier) || !ts.isCallExpression(modifier.expression)) {
+      continue;
+    }
+    const decoratorTarget = modifier.expression.expression;
+    if (ts.isIdentifier(decoratorTarget) && localNames.has(decoratorTarget.text) || ts.isPropertyAccessExpression(decoratorTarget) && ts.isIdentifier(decoratorTarget.expression) && namespaceLocalNames.has(decoratorTarget.expression.text) && decoratorTarget.name.text === 'Inject') {
+      return {
+        decorator: modifier,
+        expression: modifier.expression
+      };
+    }
+  }
+  return undefined;
+}
+function hasNestInjectParameterDecorator(sourceFile, localNames) {
+  let found = false;
+  const visit = node => {
+    if (found) {
+      return;
+    }
+    if (ts.isParameter(node) && hasNestInjectDecorator(node.modifiers, localNames)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+function getRuntimeValueNames(sourceFile) {
+  const names = new Set();
+  for (const statement of sourceFile.statements) {
+    if ((ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isFunctionDeclaration(statement)) && statement.name) {
+      names.add(statement.name.text);
+      continue;
+    }
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+          names.add(declaration.name.text);
+        }
+      }
+    }
+  }
+  return names;
+}
+function getCollidingTypeValueNames(sourceFile, runtimeValueNames) {
+  const names = new Set();
+  for (const statement of sourceFile.statements) {
+    if ((ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) && runtimeValueNames.has(statement.name.text)) {
+      names.add(statement.name.text);
+    }
+  }
+  return names;
+}
+function getTypeOnlyImportNames(sourceFile) {
+  const names = new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !statement.importClause) {
+      continue;
+    }
+    if (statement.importClause.name && statement.importClause.isTypeOnly) {
+      names.add(statement.importClause.name.text);
+    }
+    if (!statement.importClause.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
+      continue;
+    }
+    for (const element of statement.importClause.namedBindings.elements) {
+      if (statement.importClause.isTypeOnly || element.isTypeOnly) {
+        names.add(element.name.text);
+      }
+    }
+  }
+  return names;
+}
+function getInScopeTypeParameterNames(node) {
+  const names = new Set();
+  for (let current = node; current; current = current.parent) {
+    if (!ts.isClassDeclaration(current) && !ts.isFunctionLike(current)) {
+      continue;
+    }
+    for (const typeParameter of current.typeParameters ?? []) {
+      names.add(typeParameter.name.text);
+    }
+  }
+  return names;
+}
+function createInjectionTokenFromType(type, runtimeValueNames, collidingTypeValueNames, typeOnlyImportNames, inScopeTypeParameterNames) {
+  if (!type || !ts.isTypeReferenceNode(type) || !ts.isIdentifier(type.typeName) || !runtimeValueNames.has(type.typeName.text) || collidingTypeValueNames.has(type.typeName.text) || typeOnlyImportNames.has(type.typeName.text) || inScopeTypeParameterNames.has(type.typeName.text)) {
+    return undefined;
+  }
+  return ts.factory.createIdentifier(type.typeName.text);
+}
+function getExistingInjectTokens(expression) {
+  if (expression.arguments.length !== 1 || !ts.isArrayLiteralExpression(expression.arguments[0])) {
+    return expression.arguments;
+  }
+  if (expression.arguments[0].elements.some(element => !ts.isExpression(element))) {
+    return undefined;
+  }
+  return expression.arguments[0].elements.filter(ts.isExpression);
+}
+function getConstructorInjectionTokens(classDeclaration, nestInjectLocalNames, runtimeValueNames, collidingTypeValueNames, typeOnlyImportNames, existingInjectTokens, hasExistingInjectDecorator) {
+  const constructorDeclaration = classDeclaration.members.find(member => ts.isConstructorDeclaration(member) && member.body !== undefined);
+  if (!constructorDeclaration) {
+    return {
+      kind: 'none'
+    };
+  }
+  const parameters = constructorDeclaration.parameters;
+  const hasInjectParameter = parameters.some(parameter => hasNestInjectDecorator(parameter.modifiers, nestInjectLocalNames));
+  if (!hasInjectParameter) {
+    return {
+      kind: 'none'
+    };
+  }
+  if (hasNestInjectDecorator(classDeclaration.modifiers, nestInjectLocalNames)) {
+    return {
+      kind: 'unsafe',
+      node: classDeclaration
+    };
+  }
+  if (hasExistingInjectDecorator && !existingInjectTokens) {
+    return {
+      kind: 'unsafe',
+      node: classDeclaration
+    };
+  }
+  const tokens = [];
+  const inScopeTypeParameterNames = getInScopeTypeParameterNames(classDeclaration);
+  let decoratorLocalName;
+  for (const [index, parameter] of parameters.entries()) {
+    if (parameter.dotDotDotToken || parameter.questionToken || parameter.initializer || !ts.isIdentifier(parameter.name)) {
+      return {
+        kind: 'unsafe',
+        node: parameter
+      };
+    }
+    const decorators = parameter.modifiers?.filter(ts.isDecorator) ?? [];
+    const injectDecorators = decorators.map(decorator => ({
+      decorator,
+      localName: getNestInjectDecoratorLocalName(decorator, nestInjectLocalNames)
+    })).filter(entry => !!entry.localName);
+    if (decorators.length !== injectDecorators.length || injectDecorators.length > 1) {
+      return {
+        kind: 'unsafe',
+        node: parameter
+      };
+    }
+    const [injectDecorator] = injectDecorators;
+    if (injectDecorator) {
+      const expression = injectDecorator.decorator.expression;
+      if (!ts.isCallExpression(expression) || expression.arguments.length !== 1) {
+        return {
+          kind: 'unsafe',
+          node: parameter
+        };
+      }
+      const [token] = expression.arguments;
+      if (!token) {
+        return {
+          kind: 'unsafe',
+          node: parameter
+        };
+      }
+      tokens.push(token);
+      decoratorLocalName ??= injectDecorator.localName;
+      continue;
+    }
+    const existingToken = existingInjectTokens?.[index];
+    if (existingToken) {
+      tokens.push(existingToken);
+      continue;
+    }
+    const token = createInjectionTokenFromType(parameter.type, runtimeValueNames, collidingTypeValueNames, typeOnlyImportNames, inScopeTypeParameterNames);
+    if (!token) {
+      return {
+        kind: 'unsafe',
+        node: parameter
+      };
+    }
+    tokens.push(token);
+  }
+  if (!decoratorLocalName) {
+    return {
+      kind: 'unsafe',
+      node: constructorDeclaration
+    };
+  }
+  return {
+    decoratorLocalName,
+    kind: 'safe',
+    tokens
+  };
+}
+function rewriteConstructorInjectTokens(source, filePath) {
+  const sourceFile = parseSource(source, filePath);
+  const warnings = [];
+  const nestInjectLocalNames = getNestInjectLocalNames(sourceFile);
+  const fluoInjectLocalNames = getFluoInjectLocalNames(sourceFile);
+  const fluoInjectNamespaceLocalNames = getFluoInjectNamespaceLocalNames(sourceFile);
+  const runtimeValueNames = getRuntimeValueNames(sourceFile);
+  const collidingTypeValueNames = getCollidingTypeValueNames(sourceFile, runtimeValueNames);
+  const typeOnlyImportNames = getTypeOnlyImportNames(sourceFile);
+  const safeClasses = new Map();
+  let hasUnsafeConstructor = false;
+  const inspect = node => {
+    if (ts.isClassDeclaration(node)) {
+      const existingInjectDecorator = getFluoInjectClassDecorator(node.modifiers, fluoInjectLocalNames, fluoInjectNamespaceLocalNames);
+      const existingInjectTokens = existingInjectDecorator ? getExistingInjectTokens(existingInjectDecorator.expression) : undefined;
+      const result = getConstructorInjectionTokens(node, nestInjectLocalNames, runtimeValueNames, collidingTypeValueNames, typeOnlyImportNames, existingInjectTokens, !!existingInjectDecorator);
+      if (result.kind === 'safe') {
+        safeClasses.set(node, result);
+      }
+      if (result.kind === 'unsafe') {
+        hasUnsafeConstructor = true;
+        warnings.push(buildWarning(filePath, sourceFile, result.node, 'inject-token-unsupported', 'Unable to safely convert constructor injection. Keep the NestJS constructor unchanged and manually add class-level @Inject(...) tokens in constructor parameter order.'));
+      }
+    }
+    ts.forEachChild(node, inspect);
+  };
+  inspect(sourceFile);
+  if (safeClasses.size === 0) {
+    return {
+      changed: false,
+      source,
+      warnings
+    };
+  }
+  const generatedFluoInjectLocalName = hasUnsafeConstructor ? [...fluoInjectLocalNames][0] ?? 'FluoInject' : undefined;
+  const transformer = context => {
+    const visit = node => {
+      if (ts.isClassDeclaration(node)) {
+        const injection = safeClasses.get(node);
+        if (injection) {
+          const members = node.members.map(member => {
+            if (!ts.isConstructorDeclaration(member)) {
+              return member;
+            }
+            const parameters = member.parameters.map(parameter => {
+              const modifiers = parameter.modifiers?.filter(modifier => !ts.isDecorator(modifier) || !getNestInjectDecoratorLocalName(modifier, nestInjectLocalNames));
+              return ts.factory.updateParameterDeclaration(parameter, modifiers, parameter.dotDotDotToken, parameter.name, parameter.questionToken, parameter.type, parameter.initializer);
+            });
+            return ts.factory.updateConstructorDeclaration(member, member.modifiers, parameters, member.body);
+          });
+          const existingInjectDecorator = getFluoInjectClassDecorator(node.modifiers, fluoInjectLocalNames, fluoInjectNamespaceLocalNames);
+          const modifiers = existingInjectDecorator ? node.modifiers?.map(modifier => modifier === existingInjectDecorator.decorator ? ts.factory.updateDecorator(existingInjectDecorator.decorator, ts.factory.updateCallExpression(existingInjectDecorator.expression, existingInjectDecorator.expression.expression, existingInjectDecorator.expression.typeArguments, injection.tokens)) : modifier) : [ts.factory.createDecorator(ts.factory.createCallExpression(ts.factory.createIdentifier(generatedFluoInjectLocalName ?? injection.decoratorLocalName), undefined, injection.tokens)), ...(node.modifiers ?? [])];
+          return ts.factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, members);
+        }
+      }
+      return ts.visitEachChild(node, visit, context);
+    };
+    return node => ts.visitNode(node, visit);
+  };
+  const transformed = ts.transform(sourceFile, [transformer]).transformed[0];
+  let nextSource = printer.printFile(transformed);
+  if (generatedFluoInjectLocalName && fluoInjectLocalNames.size === 0) {
+    const nextSourceFile = parseSource(nextSource, filePath);
+    nextSource = printSourceFile(nextSourceFile, mergeNamedImport([...nextSourceFile.statements], '@fluojs/core', [{
+      imported: 'Inject',
+      isTypeOnly: false,
+      local: generatedFluoInjectLocalName
+    }], true));
+  }
+  return {
+    changed: true,
+    source: nextSource,
+    warnings
+  };
+}
 function hasConflictingScopeImport(sourceFile) {
   for (const statement of sourceFile.statements) {
     if (!ts.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts.isNamedImports(statement.importClause.namedBindings)) {
@@ -420,6 +805,7 @@ function rewriteInjectableAndScope(source, filePath, options) {
     const nextSourceFile = parseSource(nextSource, filePath);
     nextSource = printSourceFile(nextSourceFile, mergeNamedImport([...nextSourceFile.statements], '@fluojs/core', [{
       imported: 'Scope',
+      isTypeOnly: false,
       local: scopeDecoratorName
     }]));
   }
@@ -433,14 +819,25 @@ function rewriteInjectableAndScope(source, filePath, options) {
     warnings
   };
 }
-function rewriteBootstrap(source, filePath) {
-  const sourceFile = parseSource(source, filePath);
+function rewriteBootstrap(source, filePath, bootstrapPlatform) {
+  const compilerOptions = {
+    module: ts.ModuleKind.ESNext,
+    noLib: true,
+    noResolve: true,
+    target: ts.ScriptTarget.ES2022
+  };
+  const compilerHost = ts.createCompilerHost(compilerOptions, true);
+  const getSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+  compilerHost.getSourceFile = (path, languageVersion, onError, shouldCreateNewSourceFile) => path === filePath ? parseSource(source, filePath) : getSourceFile(path, languageVersion, onError, shouldCreateNewSourceFile);
+  const program = ts.createProgram([filePath], compilerOptions, compilerHost);
+  const sourceFile = program.getSourceFile(filePath) ?? parseSource(source, filePath);
+  const checker = program.getTypeChecker();
   const warnings = [];
-  const createCalls = new Map();
-  const listenCalls = new Map();
-  const portFoldedApps = new Set();
+  const bootstrapBindings = new Map();
+  const portFoldedListenCallKeys = new Set();
   const rewrittenCreateCallKeys = new Set();
   const warnedCreateCallKeys = new Set();
+  let usesExpressAdapter = false;
   function toCallKey(callExpression) {
     return `${callExpression.pos}:${callExpression.end}`;
   }
@@ -452,6 +849,77 @@ function rewriteBootstrap(source, filePath) {
     warnedCreateCallKeys.add(key);
     warnings.push(buildWarning(filePath, sourceFile, callExpression, 'bootstrap-unsupported', `${reason} Keep this Nest bootstrap path and migrate manually.`));
   }
+  function getSupportedListenCall(binding, createCall) {
+    const appListenCalls = binding.listenCalls;
+    if (appListenCalls.length === 0) {
+      return {
+        category: 'bootstrap-unsupported',
+        node: createCall,
+        reason: 'Unable to find an app.listen(...) call for this NestFactory.create result.'
+      };
+    }
+    const [listenCall] = appListenCalls;
+    if (!listenCall) {
+      return {
+        category: 'bootstrap-unsupported',
+        node: createCall,
+        reason: 'Unable to resolve an app.listen(...) call for this NestFactory.create result.'
+      };
+    }
+    if (appListenCalls.length > 1) {
+      return {
+        category: 'bootstrap-unsupported',
+        node: listenCall,
+        reason: 'Multiple app.listen(...) calls are associated with this NestFactory.create result.'
+      };
+    }
+    if (hasEscapedBindingUse(binding)) {
+      return {
+        category: 'bootstrap-unsupported',
+        node: createCall,
+        reason: 'Unable to prove that this NestFactory.create result owns the app.listen(...) call.'
+      };
+    }
+    const [portExpression] = listenCall.arguments;
+    if (listenCall.arguments.length !== 1 || !portExpression || !ts.isNumericLiteral(portExpression)) {
+      return {
+        category: 'bootstrap-port',
+        node: listenCall,
+        reason: 'Expected exactly one numeric port argument for app.listen(...).'
+      };
+    }
+    return {
+      listenCall,
+      portExpression
+    };
+  }
+  function enclosingFunction(node) {
+    let current = node.parent;
+    while (current) {
+      if (ts.isFunctionLike(current)) {
+        return current;
+      }
+      current = current.parent;
+    }
+    return undefined;
+  }
+  function hasEscapedBindingUse(binding) {
+    let escaped = false;
+    const [listenCall] = binding.listenCalls;
+    const listenReceiver = listenCall && ts.isPropertyAccessExpression(listenCall.expression) ? listenCall.expression.expression : undefined;
+    const inspectBindingUse = node => {
+      if (ts.isIdentifier(node) && checker.getSymbolAtLocation(node) === binding.symbol && node !== binding.declaration.name && node !== listenReceiver) {
+        escaped = true;
+        return;
+      }
+      ts.forEachChild(node, inspectBindingUse);
+    };
+    inspectBindingUse(binding.functionOwner);
+    return escaped;
+  }
+  function warnUnsupportedListen(node, category, reason) {
+    warnings.push(buildWarning(filePath, sourceFile, node, category, `${reason} Keep this Nest bootstrap path and migrate manually.`));
+  }
   function isSupportedCreateCall(callExpression) {
     if (callExpression.typeArguments && callExpression.typeArguments.length > 0) {
       return {
@@ -465,9 +933,21 @@ function rewriteBootstrap(source, filePath) {
         supported: false
       };
     }
-    if (callExpression.arguments.length === 2 && !ts.isObjectLiteralExpression(callExpression.arguments[1])) {
+    if (callExpression.arguments.length === 2) {
+      if (ts.isObjectLiteralExpression(callExpression.arguments[1])) {
+        return {
+          reason: 'NestFactory.create options object has no documented Fluo mapping.',
+          supported: false
+        };
+      }
+      return {
+        reason: 'NestFactory.create uses an adapter-specific startup form. Run adapter-independent transforms with --skip bootstrap, then replace the NestJS adapter with a Fluo platform adapter passed to FluoFactory.create(..., { adapter }) before calling listen().',
+        supported: false
+      };
+    }
+    if (bootstrapPlatform !== 'express') {
       return {
-        reason: 'Unsupported NestFactory.create adapter-specific startup form.',
+        reason: 'Select a Fluo platform adapter before rewriting this bootstrap. For Express, rerun with --platform express.',
         supported: false
       };
     }
@@ -475,56 +955,115 @@ function rewriteBootstrap(source, filePath) {
       supported: true
     };
   }
-  const inspect = node => {
+  function createExpressAdapter(options) {
+    usesExpressAdapter = true;
+    return ts.factory.createCallExpression(ts.factory.createIdentifier('createExpressAdapter'), undefined, options ? [options] : []);
+  }
+  function isNestFactoryValueImportReference(identifier) {
+    const symbol = checker.getSymbolAtLocation(identifier);
+    return Boolean(symbol?.declarations?.some(declaration => {
+      if (!ts.isImportSpecifier(declaration) || declaration.isTypeOnly) {
+        return false;
+      }
+      const importClause = declaration.parent.parent;
+      const importDeclaration = importClause.parent;
+      return !importClause.isTypeOnly && ts.isImportDeclaration(importDeclaration) && ts.isStringLiteral(importDeclaration.moduleSpecifier) && importDeclaration.moduleSpecifier.text === '@nestjs/core' && (declaration.propertyName ?? declaration.name).text === 'NestFactory';
+    }));
+  }
+  function nestFactoryCreateCall(node) {
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.expression) || node.expression.name.text !== 'create') {
+      return undefined;
+    }
+    return {
+      call: node,
+      receiver: node.expression.expression
+    };
+  }
+  function hasUnconvertedNestFactoryValueReference() {
+    let found = false;
+    const inspect = node => {
+      if (ts.isIdentifier(node) && isNestFactoryValueImportReference(node) && !ts.isImportSpecifier(node.parent)) {
+        const createCall = nestFactoryCreateCall(node.parent.parent);
+        const isRewrittenCreateReceiver = createCall && createCall.receiver === node && rewrittenCreateCallKeys.has(toCallKey(createCall.call));
+        if (!isRewrittenCreateReceiver) {
+          found = true;
+          return;
+        }
+      }
+      ts.forEachChild(node, inspect);
+    };
+    inspect(sourceFile);
+    return found;
+  }
+  const inspectCreates = node => {
     if (ts.isVariableDeclaration(node) && node.initializer) {
       const initializer = ts.isAwaitExpression(node.initializer) ? node.initializer.expression : node.initializer;
-      if (ts.isIdentifier(node.name) && ts.isCallExpression(initializer) && ts.isPropertyAccessExpression(initializer.expression) && ts.isIdentifier(initializer.expression.expression) && initializer.expression.expression.text === 'NestFactory' && initializer.expression.name.text === 'create') {
-        createCalls.set(node.name.text, initializer);
+      const createCall = nestFactoryCreateCall(initializer);
+      if (ts.isIdentifier(node.name) && createCall && isNestFactoryValueImportReference(createCall.receiver) && ts.isVariableDeclarationList(node.parent) && (node.parent.flags & ts.NodeFlags.Const) !== 0) {
+        const functionOwner = enclosingFunction(node);
+        const symbol = checker.getSymbolAtLocation(node.name);
+        if (functionOwner && symbol) {
+          bootstrapBindings.set(toCallKey(createCall.call), {
+            declaration: node,
+            functionOwner,
+            listenCalls: [],
+            name: node.name.text,
+            symbol
+          });
+        }
       }
     }
+    ts.forEachChild(node, inspectCreates);
+  };
+  const inspectListens = node => {
     if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.name.text === 'listen') {
-      listenCalls.set(node.expression.expression.text, node);
+      const functionOwner = enclosingFunction(node);
+      const symbol = checker.getSymbolAtLocation(node.expression.expression);
+      for (const binding of bootstrapBindings.values()) {
+        if (binding.symbol === symbol && binding.functionOwner === functionOwner) {
+          binding.listenCalls.push(node);
+        }
+      }
     }
-    ts.forEachChild(node, inspect);
+    ts.forEachChild(node, inspectListens);
   };
-  inspect(sourceFile);
+  inspectCreates(sourceFile);
+  inspectListens(sourceFile);
   const transformer = context => {
     const visit = node => {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-        if (ts.isIdentifier(node.expression.expression) && node.expression.expression.text === 'NestFactory' && node.expression.name.text === 'create') {
+        const createCall = nestFactoryCreateCall(node);
+        if (createCall) {
+          if (!isNestFactoryValueImportReference(createCall.receiver)) {
+            return node;
+          }
           const support = isSupportedCreateCall(node);
           if (!support.supported) {
             warnUnsupportedCreate(node, support.reason);
             return node;
           }
-          let nextArgs = [...node.arguments];
-          const ownerEntry = [...createCalls.entries()].find(([, callExpression]) => callExpression.pos === node.pos && callExpression.end === node.end);
-          if (ownerEntry) {
-            const [appVariable] = ownerEntry;
-            const listenCall = listenCalls.get(appVariable);
-            if (listenCall && listenCall.arguments.length === 1) {
-              const [portExpression] = listenCall.arguments;
-              if (nextArgs.length === 1) {
-                nextArgs = [nextArgs[0], ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment('port', portExpression)], true)];
-                portFoldedApps.add(appVariable);
-              } else if (nextArgs.length === 2 && ts.isObjectLiteralExpression(nextArgs[1])) {
-                const hasPort = nextArgs[1].properties.some(property => ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'port');
-                if (!hasPort) {
-                  nextArgs = [nextArgs[0], ts.factory.updateObjectLiteralExpression(nextArgs[1], [...nextArgs[1].properties, ts.factory.createPropertyAssignment('port', portExpression)])];
-                  portFoldedApps.add(appVariable);
-                }
-              }
-              if (!portFoldedApps.has(appVariable)) {
-                warnings.push(buildWarning(filePath, sourceFile, node, 'bootstrap-port', 'Unable to move listen() port argument into FluoFactory.create options. Review bootstrap manually.'));
-              }
-            }
+          const binding = bootstrapBindings.get(toCallKey(node));
+          if (!binding) {
+            warnUnsupportedCreate(node, 'Unable to associate this NestFactory.create call with a named application variable and app.listen(...) call.');
+            return node;
+          }
+          const supportedListenCall = getSupportedListenCall(binding, node);
+          if ('reason' in supportedListenCall) {
+            warnUnsupportedListen(supportedListenCall.node, supportedListenCall.category, supportedListenCall.reason);
+            return node;
           }
+          const [rootModule] = node.arguments;
+          if (!rootModule) {
+            warnUnsupportedCreate(node, 'NestFactory.create requires a root module argument.');
+            return node;
+          }
+          const nextArgs = [rootModule, ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment('adapter', createExpressAdapter(ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment('port', supportedListenCall.portExpression)], true)))], true)];
+          portFoldedListenCallKeys.add(toCallKey(supportedListenCall.listenCall));
           rewrittenCreateCallKeys.add(toCallKey(node));
           return ts.factory.updateCallExpression(node, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('FluoFactory'), ts.factory.createIdentifier('create')), undefined, nextArgs);
         }
         if (ts.isIdentifier(node.expression.expression) && node.expression.name.text === 'listen') {
-          const appVariable = node.expression.expression.text;
-          if (createCalls.has(appVariable) && node.arguments.length > 0 && portFoldedApps.has(appVariable)) {
+          if (node.arguments.length > 0 && portFoldedListenCallKeys.has(toCallKey(node))) {
             return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, []);
           }
         }
@@ -542,16 +1081,24 @@ function rewriteBootstrap(source, filePath) {
     };
   }
   let nextSource = printer.printFile(transformed);
-  const removed = removeImportBinding(nextSource, filePath, '@nestjs/core', 'NestFactory');
-  nextSource = removed.source;
+  if (!hasUnconvertedNestFactoryValueReference()) {
+    const removed = removeNestFactoryValueImports(nextSource, filePath);
+    nextSource = removed.source;
+  }
   const nextSourceFile = parseSource(nextSource, filePath);
   const withRuntimeImport = printSourceFile(nextSourceFile, mergeNamedImport([...nextSourceFile.statements], '@fluojs/runtime', [{
     imported: 'FluoFactory',
+    isTypeOnly: false,
     local: 'FluoFactory'
   }]));
+  const withPlatformImport = usesExpressAdapter ? printSourceFile(parseSource(withRuntimeImport, filePath), mergeNamedImport([...parseSource(withRuntimeImport, filePath).statements], '@fluojs/platform-express', [{
+    imported: 'createExpressAdapter',
+    isTypeOnly: false,
+    local: 'createExpressAdapter'
+  }])) : withRuntimeImport;
   return {
-    changed: withRuntimeImport !== source,
-    source: withRuntimeImport,
+    changed: withPlatformImport !== source,
+    source: withPlatformImport,
     warnings
   };
 }
@@ -663,6 +1210,7 @@ function rewriteTesting(source, filePath) {
   const nextSourceFile = parseSource(nextSource, filePath);
   nextSource = printSourceFile(nextSourceFile, mergeNamedImport([...nextSourceFile.statements], '@fluojs/testing', [{
     imported: 'createTestingModule',
+    isTypeOnly: false,
     local: 'createTestingModule'
   }]));
   const withFluoImportSourceFile = parseSource(nextSource, filePath);
@@ -760,8 +1308,9 @@ function rewriteBaseUrlPaths(paths, baseUrl) {
   });
   return Object.fromEntries(rewrittenEntries);
 }
-function detectManualFollowUps(source, filePath) {
+function detectManualFollowUps(source, filePath, includeInjectTokenWarning) {
   const sourceFile = parseSource(source, filePath);
+  const nestInjectLocalNames = getNestInjectLocalNames(sourceFile);
   const warnings = [];
   let hasRequestDecoratorWarning = false;
   let hasInjectParameterWarning = false;
@@ -773,7 +1322,7 @@ function detectManualFollowUps(source, filePath) {
           continue;
         }
         const decoratorName = modifier.expression.expression.text;
-        if (!hasInjectParameterWarning && decoratorName === 'Inject') {
+        if (includeInjectTokenWarning && !hasInjectParameterWarning && nestInjectLocalNames.has(decoratorName)) {
           hasInjectParameterWarning = true;
           warnings.push(buildWarning(filePath, sourceFile, modifier, 'inject-token', 'Constructor @Inject(TOKEN) parameter decorators need manual migration to class-level @Inject(TOKEN, ...) syntax.'));
         }
@@ -838,10 +1387,21 @@ function gatherTargetFiles(targetPath, includeTsconfig) {
   }
   return collected.sort((left, right) => left.localeCompare(right));
 }
-function runTypeScriptTransforms(source, filePath, enabledTransforms) {
+function runTypeScriptTransforms(source, filePath, enabledTransforms, bootstrapPlatform) {
   let nextSource = source;
   const appliedTransforms = [];
   const warnings = [];
+  if (enabledTransforms.has('injectable')) {
+    const rewritten = rewriteConstructorInjectTokens(nextSource, filePath);
+    nextSource = rewritten.source;
+    warnings.push(...rewritten.warnings);
+    if (rewritten.changed) {
+      appliedTransforms.push('injectable');
+      const rewrittenImports = rewriteImports(nextSource, filePath, new Set(['Inject']));
+      nextSource = rewrittenImports.source;
+      warnings.push(...rewrittenImports.warnings);
+    }
+  }
   if (enabledTransforms.has('imports')) {
     const rewritten = rewriteImports(nextSource, filePath);
     nextSource = rewritten.source;
@@ -867,7 +1427,7 @@ function runTypeScriptTransforms(source, filePath, enabledTransforms) {
     }
   }
   if (enabledTransforms.has('bootstrap')) {
-    const rewritten = rewriteBootstrap(nextSource, filePath);
+    const rewritten = rewriteBootstrap(nextSource, filePath, bootstrapPlatform);
     nextSource = rewritten.source;
     warnings.push(...rewritten.warnings);
     if (rewritten.changed) {
@@ -882,7 +1442,7 @@ function runTypeScriptTransforms(source, filePath, enabledTransforms) {
       appliedTransforms.push('testing');
     }
   }
-  warnings.push(...detectManualFollowUps(source, filePath));
+  warnings.push(...detectManualFollowUps(source, filePath, !enabledTransforms.has('injectable')));
   return {
     appliedTransforms: [...new Set(appliedTransforms)],
     source: nextSource,
@@ -921,7 +1481,7 @@ export function runNestJsMigration(options) {
       });
       continue;
     }
-    const rewritten = runTypeScriptTransforms(source, filePath, options.enabledTransforms);
+    const rewritten = runTypeScriptTransforms(source, filePath, options.enabledTransforms, options.bootstrapPlatform);
     const changed = rewritten.source !== source;
     if (changed && options.apply) {
       writeFileSync(filePath, rewritten.source, 'utf8');