FilesExpand file tree

 master

/

genCodeByYapi.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

173 lines (167 loc) · 5.06 KB

 master

/

genCodeByYapi.ts

Copy path

Top

File metadata and controls

• Code
• Blame

173 lines (167 loc) · 5.06 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

import { window } from 'vscode';

import { compile } from 'json-schema-to-typescript';

import { compile as compileEjs, Model } from '../utils/ejs';

import { getSnippets } from '../utils/materials';

import { fetchApiDetailInfo } from '../utils/request';

import { getFuncNameAndTypeName, pasteToEditor } from '../utils/editor';

import { mockFromSchema } from '../utils/json';

import { getConfig } from '../utils/config';

const strip = require('strip-comments');

const stripJsonComments = require('strip-json-comments');

const GenerateSchema = require('generate-schema');

export const genCodeByYapi = async (

yapiId: string,

rawClipboardText: string,

) => {

const domain = getConfig().yapi?.domain || '';

if (!domain.trim()) {

window.showErrorMessage('请配置yapi域名');

return;

}

const projectList = getConfig().yapi?.projects || [];

if (projectList.length === 0) {

window.showErrorMessage('请配置项目');

return;

}

const templateList = getSnippets().filter((s) => !s.preview.notShowInCommand);

if (templateList.length === 0) {

window.showErrorMessage('请配置模板');

return;

}

const selectInfo = getFuncNameAndTypeName();

const requestBodyTypeName =

selectInfo.funcName.slice(0, 1).toUpperCase() +

selectInfo.funcName.slice(1);

const result = await window.showQuickPick(

projectList.map((s) => s.name),

{ placeHolder: '请选择项目' },

);

if (!result) {

return;

}

const templateResult = await window.showQuickPick(

templateList.map((s) => s.name),

{ placeHolder: '请选择YAPI相关模板' },

);

if (!templateResult) {

return;

}

const project = projectList.find((s) => s.name === result);

const template = templateList.find((s) => s.name === templateResult);

try {

const model = await genTemplateModelByYapi(

project?.domain || domain,

yapiId,

project!.token,

selectInfo.typeName,

selectInfo.funcName,

);

model.inputValues = selectInfo.inputValues;

model.rawSelectedText = selectInfo.rawSelectedText;

model.rawClipboardText = rawClipboardText;

const code = compileEjs(template!.template, model);

pasteToEditor(code);

} catch (e: any) {

window.showErrorMessage(e.toString());

}

};

export const genTemplateModelByYapi = async (

domain: string,

yapiId: string,

token: string,

typeName: string = 'IYapiRequestResult',

funcName: string = 'fetch',

) => {

const res = await fetchApiDetailInfo(domain, yapiId, token);

const requestBodyTypeName =

funcName.slice(0, 1).toUpperCase() + funcName.slice(1);

if (res.data.data.res_body_type === 'json') {

const schema = JSON.parse(stripJsonComments(res.data.data.res_body));

fixSchema(schema);

delete schema.title;

let ts = await compile(schema, typeName, {

bannerComment: '',

});

ts = ts.replace(/(\[k: string\]: unknown;)|\?/g, '');

const { mockCode, mockData } = mockFromSchema(schema);

let requestBodyType = '';

if (res.data.data.req_body_other) {

const reqBodyScheme = JSON.parse(

stripJsonComments(res.data.data.req_body_other),

);

delete reqBodyScheme.title;

requestBodyType = await compile(

reqBodyScheme,

`I${requestBodyTypeName}Data`,

{

bannerComment: '',

},

);

}

const model: Model = {

type: ts,

requestBodyType: requestBodyType.replace(/\[k: string\]: unknown;/g, ''),

funcName,

typeName,

api: res.data.data,

inputValues: [],

mockCode,

mockData,

jsonData: {},

rawSelectedText: '',

rawClipboardText: '',

};

return model;

}

// const ts = await jsonToTs(selectInfo.typeName, res.data.data.res_body);

const resBodyJson = JSON.parse(stripJsonComments(res.data.data.res_body));

const schema = GenerateSchema.json(typeName || 'Schema', resBodyJson);

let ts = await compile(schema, typeName, {

bannerComment: '',

});

ts = strip(ts.replace(/(\[k: string\]: unknown;)|\?/g, ''));

const { mockCode, mockData } = mockFromSchema(schema);

let requestBodyType = '';

if (res.data.data.req_body_other) {

const reqBodyScheme = JSON.parse(

stripJsonComments(res.data.data.req_body_other),

);

delete reqBodyScheme.title;

requestBodyType = await compile(

reqBodyScheme,

`I${requestBodyTypeName}Data`,

{

bannerComment: '',

},

);

}

const model: Model = {

type: ts,

requestBodyType: requestBodyType.replace(/\[k: string\]: unknown;/g, ''),

funcName,

typeName,

api: res.data.data,

inputValues: [],

mockCode,

mockData,

jsonData: resBodyJson,

rawClipboardText: '',

rawSelectedText: '',

};

return model;

};

const fixSchema = (obj: object) => {

// eslint-disable-next-line no-restricted-syntax

for (const key in obj) {

// @ts-ignore

if (typeof obj[key] === 'object' && obj[key] !== null) {

// @ts-ignore

if (obj[key].type === 'object' && !obj[key].properties) {

// @ts-ignore

delete obj[key];

}

// @ts-ignore

fixSchema(obj[key]); // 递归处理

}

}

};