背景
相信很多小伙伴与我一样，可能会碰到这样的问题，公司有统一使用一个通用的工具库或者框架，并且已经迭代了多个大版本，但是大版本之间有破坏性更新，现在为了降低维护成本与使用难度，决定只维护最新的一个大版本，但是有很多项目一直还在使用低版本，没有跟随工具库或者框架迭代升级，这个时候如果强行推动让使用方自己升级，会发现有很大的困难，使用方会找各种理由来推脱不进行升级，那么作为库或者框架的维护者，我们一般会这么做
- 不升就不升，出了问题不要再来找我
- 手动帮助使用方升级
- 提供一个工具，使用方通过工具来完成自动升级
第一种不可取，第二种适用于项目较少的情况，第三种则是适用项目较多的情况，我们公司目前恰好属于第三种，为了降低升级成本，决定通过开发一个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，帮助我们查找节点的信息，如下图所示
选择数的展示模式
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面板，先查看下对应的节点信息，如下图所示
变量节点如下图所示
代码实现
这里有两个思路
- 思路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();
}
最终处理结果如下图所示
总结
ts-morph操作ast的步骤主要是
- 初始化项目
- 获取源文件
- 操作源文件
- 操作ast节点
- 保存项目or源文件
借助ts-morph完成ts代码的批量转换，帮助我们加速cli工具的发布，截止到现在已经完成10多个项目的无缝升级。
本篇只是描述了其中一个场景，更多的是给大家提供一个思路，希望对各位小伙伴所有帮助
参考链接
原文链接：https://juejin.cn/post/7339085241174704178 作者：wks
