批量修改typescript代码:使用ts-morph实现版本无缝升级

背景

相信很多小伙伴与我一样,可能会碰到这样的问题,公司有统一使用一个通用的工具库或者框架,并且已经迭代了多个大版本,但是大版本之间有破坏性更新,现在为了降低维护成本与使用难度,决定只维护最新的一个大版本,但是有很多项目一直还在使用低版本,没有跟随工具库或者框架迭代升级,这个时候如果强行推动让使用方自己升级,会发现有很大的困难,使用方会找各种理由来推脱不进行升级,那么作为库或者框架的维护者,我们一般会这么做

  • 不升就不升,出了问题不要再来找我
  • 手动帮助使用方升级
  • 提供一个工具,使用方通过工具来完成自动升级

第一种不可取,第二种适用于项目较少的情况,第三种则是适用项目较多的情况,我们公司目前恰好属于第三种,为了降低升级成本,决定通过开发一个cli工具来进行项目自动升级,通过工具来自动增、删、改项目中有变化的代码

工具处理过程中碰到最有挑战的问题如下所示

低版本中方法调用示例

// 这部分是grpc方法,由脚本自动生成
GetAllGrey(
  request: types.backstage.GetAllGreyRequest,
  metadata: MetadataMap,
  options?: { timeout?: number; flags?: number; host?: string; }
): Promise<types.backstage.GetAllGreyResponse>;


// 然后在service中调用改方法
const { data, code } = await this.xxxService.GetAllGrey({id: 1}, {token: 'xxxx'})

高版本中方法调用示例

// 这部分是grpc方法,由脚本自动生成
GetAllGrey(option: {
  request: types.backstage.GetAllGreyRequest,
  metadata: MetadataMap,
  options?: { timeout?: number; flags?: number; host?: string; }
}): Promise<{ response:types.backstage.GetAllGreyResponse, metadata: Metadata }>;

// 然后在service中调用改方法
const { response: { data, code } } = await this.xxxService.GetAllGrey({
  request: {id: 1}, 
  metadata: {token: 'xxxx'}
})

高版本相对于低版本,主要的变化在于传参方式发生了改变,及返回值包裹了一层response,至于为什么发生这些变化不做讨论,工具主要要做的就是怎么自动实现这个变化,将低版本的写法转换成高版本的写法

最开始想到的思路是通过replace + 正则的方式来匹配与替换,但是实际上项目内的写法有多种,replace + 正则的方式不够用,随后想到ast操作,由于项目代码都是使用typescript编写,找了一圈之后,发现ts-morph这个工具库,这个工具库在typescript compiler api的基础上做了一层封装,更利于我们操作typescript中的ast,所以决定使用ts-morph来完成我们的目标

在实现具体的功能之前,先一起了解下ts-morph是怎样操作ast的

ts-morph

ts-morph是一个针对 Typescrpit/Javascript的AST处理库,可用于浏览、修改TS/JS的AST。
在 TypeScript 中引入了 TS Compiler API,开发人员可以通过编程的方式访问和操作 TypeScript 抽象语法树(AST)。TS Compiler API 提供了一系列的 API 接口,可以帮助我们分析、修改和生成 TypeScript 代码。不过 TS Compiler API 的使用门槛较高,需要比较深厚的 TypeScript 知识储备。
为了简化这个过程,社区出现了一些基于 TS Compiler API 的工具, ts-morph 就是其中之一,它提供了更加友好的 API 接口,并且可以轻松地访问 AST,完成各种类型的代码操作,例如重构、生成、检查和分析等。

安装依赖

pnpm install --save-dev ts-morph

本文书写时,使用的版本为ts-morph@20.0.0

项目初始化

通过Project初始化一个typescript项目

import { Project } from 'ts-morph';
const project = new Project({
  compilerOptions: {
    target: ScriptTarget.ES3,
  },
});

通过tsConfigFilePath指定tsconfig.json,根据tsconfig.json获取源文件

// 可以通过compilerOptions覆盖tsconfig.json参数
const project = new Project({
11    tsConfigFilePath: '<替换成tsconfig.json文件路径>'
12  })

也可以通过tsConfigFilePath指定tsconfig.json

const project = new Project({
  tsConfigFilePath: "path/to/tsconfig.json",
  skipAddingFilesFromTsConfig: true, // 可以通过这个参数跳过解析tsconfig中指定的源文件
});

// 也可以通过addSourceFilesFromTsConfig方法指定tsconfig.json
project.addSourceFilesFromTsConfig("path/to/tsconfig.json");

还可以通过project.compilerOptions设置ts配置参数

const oldCompilerOptions = project.getCompilerOptions()
  project.compilerOptions.set({
    ...oldCompilerOptions,
    noImplicitReturns: true // 在内存中打开 noImplicitReturns 选项,使得所有 no-implicit-returns 的情况都会有一个TS错误,错误代号为 TS7030
  })

也可以不指定tsconfig.json文件,通过addSourceFilesAtPaths、addSourceFileAtPath方法添加源文件

import { Project } from 'ts-morph'

const project = new Project()

// glob语法添加多个源文件
project.addSourceFilesAtPaths('src/**/*{.js,.jsx}');

// 添加单个文件
project.addSourceFileAtPath("path/to/file.ts")

通过ast的方式创建源文件

const sourceFile = project.createSourceFile("path/to/myStructureFile.ts", {
  statements: [{
    kind: StructureKind.Enum,
    name: "MyEnum",
    members: [{
      name: "member",
    }],
  }, {
    kind: StructureKind.Class,
    name: "MyClass",
    // etc...
  }],
  // etc...
});

通过字符串的方式创建源文件

const fileText = "enum MyEnum {\n}\n";
const sourceFile = project.createSourceFile("path/to/myNewFile.ts", fileText);

获取源文件

当我们完成项目初始化之后,那么就是要进一步操作,比如获取源文件列表,获取类型错误等

// 获取项目内所有文件的编译错误
const diagnostics = project.getPreEmitDiagnostics()

// 获取某个文件的编译错误
const sourceFileDiagnostics = sourceFile.getPreEmitDiagnostics();

// 格式化输出编译错误
console.log(project.formatDiagnosticsWithColorAndContext(diagnostics));

// 获取源文件列表
const files = project.getSourceFiles()

files.forEach(file => {
  // TODO
})

每个编译信息包含的内容

// 获取错误信息
const message = diagnostic.getMessageText();

// 获取错误码
const code = diagnostic.getCode(); // returns: number

// 获取错误文件
const sourceFile = diagnostic.getSourceFile(); // returns: SourceFile | undefined

// 获取文件中的位置、行号、长度
const start = diagnostic.getStart(); // returns: number
const lineNumber = diagnostic.getLineNumber(); // returns: number
const length = diagnostic.getLength(); // returns: number

// 获取信息类别
const category = diagnostic.getCategory(); // returns: DiagnosticCategory

遍历错误信息

for (const item of diagnostics) {
    const file = item.getSourceFile()
    if (file !== undefined) {
      const start = item.getStart() ?? 0
      const length = item.getLength() ?? 0
      if (start > 0 && length > 0) {
        // 先根据 start 位置定位到具体的Node,再获取Parent得到所属 Function 的Node
        const node = file.getDescendantAtPos(start)?.getParent()
        if (
          (node instanceof FunctionExpression) ||
          (node instanceof MethodDeclaration) ||
          (node instanceof ArrowFunction) ||
          (node instanceof FunctionDeclaration)) {
          toModify.push(node)
        }
      }
    }
  }

操作源文件

接下来怎么操作具体的ast,对内容如何进行增、删、改呢?这里以文件为例
首先获取项目中的某个源文件

// 通过getSourceFile获取指定名称的源文件
const sourceFile = project.getSourceFile(filename);

针对语句进行操作

// 新增语句
const statements = sourceFile.addStatements("console.log(5);\nconsole.log(6);");
// 插入语句
const statements = sourceFile.insertStatements(3, "console.log(5);\nconsole.log(6);");
// 删除语句
sourceFile.removeStatements([1, 3]); // removes statements from index 1 to 3
sourceFile.removeStatement(1); // removes statement at index 1

针对文本进行操作

// 插入文本内容
sourceFile.insertText(0, writer => writer.writeLine("// some comment")); // or provide a string
// 替换文本内容
sourceFile.replaceText([3, 7], "a"); // "// a comment\n"
// 删除文本内容
sourceFile.removeText(sourceFile.getPos(), sourceFile.getEnd());

针对枚举的操作

enum MyEnum {
  myMember,
}
const myVar = MyEnum.myMember;

const myEnum = sourceFile.getEnum("MyEnum")!;

// 重命名
myEnum.rename("NewEnum");

const member = sourceFile.getEnum("MyEnum")!.getMember("myMember")!;
// 删除枚举
member.remove();

针对类的操作

export class MyClass {
  myProp = 5;
}

const classStructure = classDeclaration.getStructure(); // returns: ClassDeclarationStructure

{
    isAbstract: false,
    isExported: true,
    name: "MyClass",
    typeParameters: [],
    constructors: [],
    properties: [{
        name: "myProp",
        initializer: "5",
        type: undefined,
        isReadonly: false,
        isStatic: false
    }],
    methods: []
}

classDeclaration.set({ name: "NewName" });

classDeclaration.set({ properties: [{ name: "newProperty" }] });

// 往源文件中添加类
sourceFile.addClass({ name: "NewClass", ...classDeclaration.getStructure() });

格式化源文件

var myVariable     :      string |    number;
function myFunction(param    : string){
return "";
}


sourceFile.formatText();

sourceFile.formatText({
  placeOpenBraceOnNewLineForFunctions: true,
});

源文件本身的增删改查操作

// 删除源文件
await sourceFile.deleteImmediately();
sourceFile.deleteImmediatelySync();

// 复制源文件
const newSourceFile = sourceFile.copy("newFileName.ts");

const otherSourceFile = sourceFile.copy("other.ts", { overwrite: true });

sourceFile.copyToDirectory("/some/dir");
sourceFile.copyToDirectory(someDirectoryObject);
await sourceFile.copyImmediately("NewFile.ts");
sourceFile.copyImmediatelySync("NewFile2.ts");

// 移动源文件
sourceFile.move("newFileName.ts");
sourceFile.move("other.ts", { overwrite: true });
sourceFile.moveToDirectory("/some/dir");
sourceFile.moveToDirectory(someDirectoryObject);
await sourceFile.moveImmediately("NewFile.ts");
sourceFile.moveImmediatelySync("NewFile2.ts");

// 移除文件,与删除有区别,这个不会真正的删除文件
sourceFile.forget();
project.removeSourceFile(sourceFile); 

操作ast节点

上面包含了对源文件中部分操作,下面是针对源文件中本来就有的Class、Docorators、Enums、Functions、Imports、Params、Variable等操作,到这里我们需要借助辅助工具TypeScript AST Viewer,帮助我们查找节点的信息,如下图所示

批量修改typescript代码:使用ts-morph实现版本无缝升级

选择数的展示模式

批量修改typescript代码:使用ts-morph实现版本无缝升级

forEachChild:只包含真实子节点

getChildren:除了真实子节点,还包括一些token信息

通过getChildren、forEachChild方法操作一级子节点

const allChildren = node.getChildren();

// 遍历当前节点的一级子节点,常用的方法
node.forEachChild(node => {
  console.log(node.getText());
});

const classDec = node.forEachChild(node => {
  if (Node.isClassDeclaration(node))
    return node; 
  return undefined;
});

通过forEachDescendant遍历所有一级子节点

node.forEachDescendant(node => console.log(node.getText()));

// 通过forEachDescendant遍历所有一级子节点
const result = node.forEachDescendant((node, traversal) => {
  switch (node.getKind()) {
    case SyntaxKind.ClassDeclaration:
      // skips traversal of the current node's descendants
      traversal.skip();
      break;
    case SyntaxKind.Parameter:
      // skips traversal of the current node's descendants and its siblings and all their descendants
      traversal.up();
      break;
    case SyntaxKind.FunctionDeclaration:
      // stops traversal completely
      traversal.stop();
      break;
    case SyntaxKind.InterfaceDeclaration:
      // stops traversal completely and returns this value
      return node;
  }

  return undefined;
});

即forEachDescendant会比forEachChild包含更多的子节点,在实际使用中,我们使用forEachChild即可

针对源文件中存在的函数进行增删改操作

// 获取某个文件的所有函数
const functions = sourceFile.getFunctions();

const functions = sourceFile?.getFunctions();

functions?.forEach((node) => {
  // 获取函数名称
  console.log('node', node.getName())

  // 添加参数
  node.addParameter({
      name: 'name'
  })
})

// 获取函数名为Function1的函数
const function1 = sourceFile.getFunction("Function1");

// 获取嵌套的第一个函数
const firstFunctionWithChildFunction = sourceFile.getFunction(f => f.getFunctions().length > 0);


// 添加函数
const functionDeclaration = sourceFile.addFunction({
  name: "FunctionName",
});

// 删除函数
functionDeclaration.remove();

// 设置函数内容
functionDeclaration.setBodyText("const myNumber = 5;");

// 获取函数内容
console.log(functionDeclaration.getBodyText());

针对源文件中存在的变量进行增删改操作

// 获取所有变量声明语句
const variableStatements = sourceFile.getVariableStatements();

variableStatements?.forEach((node) => {
  // 获取声明语句的内容
  console.log(node.getText());// 返回 const name = 'jack';
})

// 获取第一个export的的变量声明语句
const firstExportedVariableStatement = sourceFile.getVariableStatement(s => s.hasExportKeyword());

// 插入变量
const variableStatement = sourceFile.addVariableStatement({
  declarationKind: VariableDeclarationKind.Const, // defaults to "let"
  declarations: [{
    name: "myNumber",
    initializer: "5",
  }, {
    name: "myString",
    type: "string",
    initializer: `'my string'`,
  }],
});

// 删除变量
variableStatement.remove();

// 获取
const variableDeclarations = variableStatement.getDeclarations();
variableDeclarations?.forEach((node) => {
  // 获取声明语句的内容
  console.log(node.getText());// 返回 name = 'jack'; 不包含声明关键词
})

sourceFile?.getVariableDeclarations().forEach((n) => {
  console.log('variableDeclarations', n.getText()) // 返回 name = 'jack';
})

// 查找指定变量
const variableDeclaration = sourceFile.getVariableDeclaration("myVar");

// 获取string类型的变量
const firstStringTypedVariableDeclaration = sourceFile.getVariableDeclaration(v => v.getType().getText() === "string");

// 添加变量
const declaration = variableStatement.addDeclaration({ name: "num", type: "number" });

// 删除变量声明语句
variableDeclaration.remove();

针对源文件中的表达式进行操作

// 获取所有的函数调用表达式
const descendantCallExpressions = sourceFile?.getDescendantsOfKind(SyntaxKind.CallExpression);
  
descendantCallExpressions?.forEach((callExpression) => {
  const value = callExpression.getText()

  // 替换表达式内容
  callExpression.replaceWithText(`${value}.then((res) => res.response || res)`);

  // 获取传入的参数
  const args = callExpression.getArguments();

  args.forEach((node) => {
    // 删除参数
    callExpression.removeArgument(node);
  })

  // 添加参数
  callExpression.addArgument(`{
    request: '{}',
  }`);

  const returnType = callExpression.getReturnType();
})

// 获取某个节点下面的函数调用表达式,获取其它表达式也是类似的方法
const childCallExpressions = node.getChildrenOfKind(SyntaxKind.CallExpression);

针对源文件中的属性表达式进行操作

// 获取到所有的字面量对象表达式
const objectLiteralExpressions = sourceFile?.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)

objectLiteralExpressions?.forEach((objectLiteralExpression) => {
  // 获取字面量表达式的内容
  const content = objectLiteralExpression.getText()

  // 遍历字面量表示的每个属性
  objectLiteralExpression.getProperties().forEach((p) => {
    // console.log('p', p.getText())
  })

  // 根据属性名,获取对象字面量中的对应的属性key与value
  const property = objectLiteralExpression.getProperty("approver_uuid");

  console.log('property', property?.getText());

  // 给字面量对象添加属性
  const propertyAssignment = objectLiteralExpression.addPropertyAssignment({
    name: "propertyAssignment",
    initializer: "5",
  });
  
  // 给字面量对象添加简写属性
  const shorthandPropertyAssignment = objectLiteralExpression.addShorthandPropertyAssignment({
    name: "shorthandPropertyAssignment",
  });
  
  // 给字面量对象添加解构属性
  const spreadAssignment = objectLiteralExpression.addSpreadAssignment({ expression: "spreadAssignment" });
  
  // 给字面量对象添加get、set属性
  const getAccessor = objectLiteralExpression.addGetAccessor({
    name: "someNumber",
    returnType: "number",
    statements: ["return someNumber;"],
  });
  const setAccessor = objectLiteralExpression.addSetAccessor({
    name: "someNumber",
    parameters: [{ name: "value", type: "number" }],
    statements: ["someNumber = value;"],
  });
  
  // 给字面量对象添加方法
  const method = objectLiteralExpression.addMethod({
    name: "method",
    statements: [`return "some string";`],
  });

  // 根据属性名移除属性
  objectLiteralExpression.getPropertyOrThrow("prop1").remove();
})

针对标识符的操作

// 获取某个源文件中的所有标识符
const descendantIdentifiers = sourceFile?.getDescendantsOfKind(SyntaxKind.Identifier);

// 获取某个节点下的子节点中的标识符
const childIdentifiers = node.getChildrenOfKind(SyntaxKind.Identifier);

// 获取某个节点下的所有子节点中的标识符
const descendantIdentifiers = node.getDescendantsOfKind(SyntaxKind.Identifier);

descendantIdentifiers?.forEach((identifier) => {
  // 获取标识符内容
  const text = identifier.getText();

  // 标识符改名
  identifier.rename("someNewName");

  // 获取标识符引用节点
  const references = identifier.findReferences();

  // 获取查找变量的定义
  const definitions = identifier.getDefinitions();

  // 查找变量的定义节点
  const nodes = identifier.getDefinitionNodes();
})

到这里我们已经了解应该怎么去增删改源文件的内容,总结起来就是

  • 首先获取到对应的源文件
  • 其次根据源文件获取源文件内的函数、类、函数调用、对象等
  • 最后就是根据获取到的函数、类进行增删改

项目实践

已经学会了怎么去增删改源文件中内容,下面要做的就是穷举样例、分析样例,最后通过ts-morph修改代码

分析样例

样例1:

const ret = await this.xzxCommonCstService.CommRecommendedCsts({
    proj_id,
    pager: { page, page_size } },
  metadata);

// 传参与返回值修改
const { response: ret } = await this.xzxCommonCstService.CommRecommendedCsts({
  request: {
    pager: { page, page_size } 
  },
  metadata: metadata
});

样例2:

const { comm_cst_item: list = [], pager } = await this.xzxCommonCstService.AssignCommonCsts({
  cst_uuids,
  user_ids,
  operator_id: user_id,
  operator_type: 'admin',
}, metadata, { timeout: API_TIMEOUT });

// 传参与返回值修改
const { response: { comm_cst_item: list = [], pager } } = await this.xzxCommonCstService.AssignCommonCsts({
  request: {
    cst_uuids,
    user_ids,
    operator_id: user_id,
    operator_type: 'admin',
  }, 
  metadata,
  options: { timeout: API_TIMEOUT }
});

样例3:

const result = await Promise.all([
  memberUuIds.length && this.memberService.GetMembersByUUIDs({ member_uuids: memberUuIds, with_team: true }, metadata) as any,
  clueRelatedIds.length && this.saleService.GetSalesByClueRelatedIDs({ clue_related_ids: _.uniq(clueRelatedIds) }, metadata) as any,
  this.yxxExtApiService.getRecommendSourceTexts(metadata.orgcode, recomSourceList),
]).then((res:any) => {
  const memberInfoList = memberUuIds.length ? res[0].members || [] : [];
  const clueRelatedRet = clueRelatedIds.length ? res[1]?.items || [] : [];
  const recomSourceRet = res[2] || [];
  return { xxxx };
});

// 传参修改
const result = await Promise.all([
  memberUuIds.length && this.memberService.GetMembersByUUIDs({
    request: { member_uuids: memberUuIds, with_team: true },
    metadata
  }).then((res) => res.response || res) as any,
  clueRelatedIds.length && this.saleService.GetSalesByClueRelatedIDs({
    request: { clue_related_ids: _.uniq(clueRelatedIds) }, 
    metadata
  }).then((res) => res.response || res) as any,
  this.yxxExtApiService.getRecommendSourceTexts(metadata.orgcode, recomSourceList).then((res) => res.response || res),
]).then((res) => {
  const memberInfoMap:any = {};
  const clueRelatedMap:any = {};
  const recomSourceMap:any = {};
  // 参数取值修改
  const memberInfoList = memberUuIds.length ? res[0].reponse.members || [] : [];
  const clueRelatedRet = clueRelatedIds.length ? res[1]?.reponse.items || [] : [];
  const recomSourceRet = res[2] || [];
  return { list, pager };
});

从样例可以看到,修改主要围绕在

  • 函数调用时传入参数的变化,之前是多个参数,之后是一个对象参数
  • 返回值的取值变化,多了一层response

在修改之前,可以借助ast面板,先查看下对应的节点信息,如下图所示
批量修改typescript代码:使用ts-morph实现版本无缝升级

变量节点如下图所示
批量修改typescript代码:使用ts-morph实现版本无缝升级

代码实现

这里有两个思路

  • 思路1: 通过sourceFIle找到所有的CallExpression,然后过滤出需要修改的CallExpression,在修改传入的参数,与返回值
  • 思路2: 通过ts类型错误,根据错误信息找到对应的CallExpression,然后在修改传入的参数与返回值

这里采用第二种思路

通过 const diagnostics = project.getPreEmitDiagnostics(); 获取项目内所有的类型错误信息,如下所示

src/controller/TeamController.ts:69:151 - error TS2554: Expected 1 arguments, but got 2.

69       await this.unimemberService.UpdateMemberInfo({ member_id: id, name, mobile_tel, id_card_number, job_number, identity_value, empty_job_number }, metadata);
                                                                                                                                                         ~~~~~~~~
src/controller/TeamController.ts:96:9 - error TS2554: Expected 1 arguments, but got 2.

96         metadata,
           ~~~~~~~~
src/controller/TeamController.ts:207:9 - error TS2554: Expected 1 arguments, but got 2.

207         metadata,
            ~~~~~~~~
src/controller/TeamController.ts:210:14 - error TS2339: Property 'member_id' does not exist on type '{ response: CheckTelExistedResponse; metadata: Metadata; }'.

210       if(ret.member_id) {
                 ~~~~~~~~~

             ~~~~~~~~

然后遍历所有的错误节点信息,在根据对应的错误编码TS2554过滤错误信息,找到对应的CallExpression,然后在修改对应的传参与返回值,示例代码如下所示

const codeMap = {
2554: 'modifyCallFunParamsBy2554',
2345: 'modifyCallFunParamsBy2345',
} as const;
class AST {
varActions: Function[];
paramsActions: Function[];
constructor() {
this.varActions = [];
this.paramsActions = [];
}
init({
diagnostics,
indent,
project,
}: {
diagnostics: Diagnostic<ts.Diagnostic>[];
indent: number;
project?: Project;
}) {
this.traverseAst({ diagnostics, indent });
}
traverseAst({ diagnostics, indent }: { diagnostics: Diagnostic<ts.Diagnostic>[]; indent: number }) {
// 每次遍历ast之前先清空数组
this.varActions.length = 0;
this.paramsActions.length = 0;
for (const item of diagnostics) {
const result = item.getMessageText();
const lastText = typeof result !== 'string' ? (result as DiagnosticMessageChain).getMessageText() : result;
const info = {
code: item.getCode(),
text: lastText,
source: item.getSource(),
start: item.getStart() || 0,
length: item.getLength() || 0,
sourceFile: item.getSourceFile(),
};
this[codeMap[info.code as 2554]] && this[codeMap[info.code as 2554]](info, indent);
}
// 注意变量修改要在前,传参修改要在后,避免await this.memberService.GetMembersInfo({ member_ids: [ret.member_id], with_team: false }, metadata); 这种直接在传参的时候,使用上一个请求的返回值来作为参数的场景
this.varActions.forEach((act) => act()); // 遍历执行
this.paramsActions.forEach((act) => act()); // 遍历执行
}
modifyCallFunParamsBy2554(info: Info, indent?: number) {
this.modifyCallFunParams(info, indent);
}
modifyCallFunParamsBy2345(info: Info, indent?: number) {
if (!/request:.*metadata/.test(info.text)) return;
this.modifyCallFunParams(info, indent);
}
modifyCallFunParams(info: Info, indent?: number) {
// console.log(info, typeof info.text !== 'string' ? info.text.getMessageText() : info.text)
// 处理error TS2554: Expected 1 arguments, but got 2.
// 处理error TS2345: Argument of type '{ scene_code: any; type: string; file_name: any; file_type: string; file_content: any; }' is not assignable to parameter of type '{ request: UploadFileRequest; metadata?: MetadataMap | undefined; options?: { timeout?: number | undefined; flags?: number | undefined; host?: string | undefined; type?: string | undefined; } | undefined; }'.Object literal may only specify known properties, and 'scene_code' does not exist in type '{ request: UploadFileRequest; metadata?: MetadataMap | undefined; options?: { timeout?: number | undefined; flags?: number | undefined; host?: string | undefined; type?: string | undefined; } | undefined; }'.
const currentNode = info.sourceFile!.getDescendantAtPos(info.start);
const callExpression =
currentNode?.getParentIfKind(SyntaxKind.CallExpression) ||
currentNode?.getFirstAncestorByKind(SyntaxKind.CallExpression);
if (callExpression) {
// await this.xzxMemberService.SearchUserIDsByName({ name: keyword }, metadata);
// await this.teamService.GetProjTeamList({ proj_ids }, ctx.state.metadata);
const args = callExpression.getArguments();
// const returnStatement = callExpression.getParentIfKind(SyntaxKind.ReturnStatement);
const parentNode = callExpression.getParent();
switch (parentNode?.getKind()) {
case SyntaxKind.AwaitExpression:
const pp = parentNode?.getParent();
if (pp?.isKind(SyntaxKind.VariableDeclaration)) {
const leftVars = pp.getFirstChildByKind(SyntaxKind.Identifier);
if (leftVars) {
// const ret = await this.xzxCommonCstService.AssignCommonCsts({})
const oldText = leftVars?.getText() || '';
this.varActions.unshift(() => {
if (!leftVars.wasForgotten()) {
// 不能使用rename,使用rename会将 const { pager } = ret; 这里的ret也修改了
// realVarNode?.rename(`{response: ${oldText}}`);
leftVars?.replaceWithText(`{response: ${oldText}}`);
}
});
} else {
// const { user_ids = [] } = await this.xzxMemberService.SearchUserIDsByName({ name: keyword }, metadata);
// const { items } = await this.xzxDownlineService.GetMemberBindDownlineCountList({})
const objectBindingPattern = pp.getFirstChildByKind(SyntaxKind.ObjectBindingPattern);
const oldText = objectBindingPattern?.getText();
this.varActions.unshift(() => {
objectBindingPattern?.replaceWithText(`{response: ${oldText}}`);
});
}
} else if (pp?.isKind(SyntaxKind.BinaryExpression)) {
// let result: customTypes.commonResponse
// result = await this.memberInfo.EditStatus(params)
this.paramsActions.unshift(() => {
const newValue = callExpression.getText();
callExpression.replaceWithText(`${newValue}.then((res) => res.response || res)`);
callExpression.formatText({
indentSize: indent,
});
});
}
break;
case SyntaxKind.ArrayLiteralExpression:
case SyntaxKind.PropertyAccessExpression:
// 不带then场景
// Promise.all([
//   bProduct.GetProductList({
//     ...params,
//     issue_project_id: authProject,
// }),
// 带then场景
// bProduct.GetProductList({
//     ...params,
//     issue_project_id: authProject,
// }).then((res) => res),
this.paramsActions.unshift(() => {
const newValue = callExpression.getText();
callExpression.replaceWithText(`${newValue}.then((res) => res.response || res)`);
callExpression.formatText({
indentSize: indent,
});
});
break;
}
this.paramsActions.unshift(() => {
const values = args.reduce((prev, node, idx) => {
prev.push(node.getText());
callExpression.removeArgument(node);
return prev;
}, [] as string[]);
// console.log('values', values);
callExpression.addArgument(
(() => {
if (values.length === 1) {
return `{
request: ${values[0] || '{}'},
}`;
} else if (values.length === 2) {
return `{
request: ${values[0] || '{}'},
metadata: ${values[1] || '{}'},
}`;
}
return `{
request: ${values[0] || '{}'},
metadata: ${values[1] || '{}'},
options: ${values[2] || '{}'},
}`;
})(),
);
// 处理controller直接调用rpc服务,且没有处理response的场景,需要解析一次response才行
// @Get('/')
// getTag(@QueryParams() params: TagListDto) {
//   return this.tagService.memberService.GetLabelList(params)
// }
// if (parentNode?.isKind(SyntaxKind.ReturnStatement) && /{\srequest:.*metadata.*options/.test(info.text)) {
if (parentNode?.isKind(SyntaxKind.ReturnStatement)) {
const newValue = callExpression.getText();
callExpression.replaceWithText(`${newValue}.then((res) => res.response || res)`);
}
callExpression.formatText({
indentSize: indent,
});
});
}
}
}
export async function modifyGrpcParams({ tsConfigFilePath, indent }: { tsConfigFilePath: string; indent: number }) {
const project = new Project({
tsConfigFilePath,
});
// 获取编译错误
const diagnostics = project.getPreEmitDiagnostics();
const ast = new AST();
await ast.init({ diagnostics, indent, project });
await project.save();
}

最终处理结果如下图所示
批量修改typescript代码:使用ts-morph实现版本无缝升级

总结

ts-morph操作ast的步骤主要是

  • 初始化项目
  • 获取源文件
  • 操作源文件
  • 操作ast节点
  • 保存项目or源文件

借助ts-morph完成ts代码的批量转换,帮助我们加速cli工具的发布,截止到现在已经完成10多个项目的无缝升级。

本篇只是描述了其中一个场景,更多的是给大家提供一个思路,希望对各位小伙伴所有帮助

参考链接

ts-morph

原文链接:https://juejin.cn/post/7339085241174704178 作者:wks

(0)
上一篇 2024年2月26日 上午10:59
下一篇 2024年2月26日 上午11:10

相关推荐

发表回复

登录后才能评论