@cicctencent/tars2node-cli 0.0.1

package/lib/generator/ts/generator.js

@@ -0,0 +1,645 @@
+// @ts-nocheck
+/* eslint-disable*/
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const ts = require('typescript');
+const pkg = require('../../../package.json');
+
+const ConstDef = require('./def/const');
+const EnumDef = require('./def/enum');
+const InterfDef = require('./def/interf');
+const ProxyDef = require('./def/proxy');
+const StructDef = require('./def/struct');
+
+const Printer = require('./printer');
+const Typing = require('./typing');
+const Finder = require('../finder');
+const fse = require('fs-extra');
+
+/**
+ *
+ * 声明JCE-Struct节点类型
+ * @typedef { refType | vecType | string | mapType } tarsType
+ *
+ * @typedef {object} refType
+ * @property {string} target
+ * @property {string[]} nested
+ *
+ * @typedef {object} vecType
+ * @property {'vector'} type
+ * @property {tarsType} target
+ *
+ * @typedef {object} mapType
+ * @property {'map'} type
+ * @property {tarsType} key
+ * @property {tarsType} value
+ *
+ * @typedef {object} constValue
+ * @property {tarsType} type
+ * @property {*} init
+ *
+ * @typedef {object} TarsConstNode
+ * @property {string} id
+ * @property {'const'} type
+ * @property {constValue} value
+ *
+ * @typedef {object} enumValue
+ * @property {string} id
+ * @property {number} value
+ *
+ * @typedef {object} TarsEnumNode
+ * @property {string} id
+ * @property {'enum'} type
+ * @property {enumValue[]} value
+ *
+ * @typedef {object} param
+ * @property {string} id
+ * @property {'in'|'out'} io
+ * @property {tarsType} type
+ *
+ * @typedef {object} TarsInterfMethod
+ * @property {string} id
+ * @property {'func'} type
+ * @property {tarsType} output
+ * @property {param[]} params
+ *
+ * @typedef {object} TarsInterfNode
+ * @property {string} id
+ * @property {'interface'} type
+ * @property {TarsInterfMethod[]} methods
+ *
+ * @typedef {object} member
+ * @property {number} index
+ * @property {string} id
+ * @property {boolean} require
+ * @property {tarsType} type
+ * @property {null|string} init
+ *
+ * @typedef {object} TarsStructNode
+ * @property {string} id
+ * @property {'struct'} type
+ * @property {member[]} members
+ *
+ * @typedef {TarsStructNode|TarsInterfNode|TarsEnumNode|TarsConstNode} TarsNode
+ *
+ * @typedef {object} TarsModule
+ * @property {string} pathname
+ * @property {TarsNode[]} value
+ *
+ * @typedef {Object.<string, TarsModule>} TarsTree
+ *
+ * 工具类类型
+ * @typedef {import("./printer")} Printer
+ * @typedef {import("./typing")} Typing
+ *
+ * @typedef {object} CompilerOptions
+ * @property {'all'|'client'|'service'} mode
+ * @property {'es5'|'all'} type
+ * @property {'string'|'number'|'bigint'} long
+ * @property {boolean} withReturn
+ * @property {boolean} gather
+ * @property {boolean} interface
+ * @property {string} [output]
+ *
+ */
+
+class Generator {
+  /**
+   * @constructor
+   * @param {TarsTree} tree
+   * @param {string} entryPath
+   * @param {CompilerOptions} options - 编译配置选项
+   */
+  constructor(tree, entryPath, options) {
+    const { dir } = path.parse(entryPath);
+    this._validOptions(options);
+
+    /** @type {string[]} */
+    this._modulesToImport = [];
+    this._printer = new Printer();
+    this._finder = new Finder(tree);
+    this._typing = new Typing(this._finder, options);
+    this._tree = tree;
+    this._options = options;
+
+    this._entryPath = entryPath;
+    this._entryDir = path.dirname(entryPath);
+    this._dir = options.output || dir;
+
+    this.fixRecurAndMerge = options.fixRecurAndMerge || false
+    this.useNameSpace = options.useNameSpace
+
+    this._hasInterf = false;
+    this._hasStruct = false;
+
+    this._gConst = new ConstDef(this._printer, this._typing, options);
+    this._gEnum = new EnumDef(this._printer, this._typing, options);
+    this._gInterf = new InterfDef(this._printer, this._typing, options);
+    this._gProxy = new ProxyDef(this._printer, this._typing, options);
+    this._gStruct = new StructDef(this._printer, this._typing, options);
+
+    /** @type {string[]} */
+    this._mappingMembers = [];
+    this._unitDict = {}; //避免重复声明
+  }
+
+  async build() {
+    this._finder.refresh();
+    this._typing.refresh();
+    await Promise.all(Object.keys(this._tree)
+      .map(async (key) => {
+        await this._generateModule(key, this._tree[key]);
+      }));
+  }
+
+  async memo() {
+    this._finder.refresh();
+    this._typing.refresh();
+    const output = await Promise.all(Object.keys(this._tree)
+      .map(key => this._generateModuleInMemo(key, this._tree[key])));
+    return output;
+  }
+
+  getTree() {
+    return this._tree;
+  }
+
+  /**
+   * @param {CompilerOptions} options
+   */
+  _validOptions(options) {
+    if (!['string', 'number', 'bigint'].includes(options.long)) {
+      throw new Error('options.long should be one of string|number|bigint');
+    }
+  }
+
+  /**
+   * @param {string} moduleName
+   */
+  _importRelatedModules(moduleName) {
+    this._hasInterf = false;
+    this._hasStruct = false;
+    this._modulesToImport = [];
+    this._mappingMembers = [];
+    const { value } = this._tree[moduleName];
+    value.forEach((m) => {
+      if (m.type === 'interface') {
+        this._hasInterf = true;
+        m.methods.forEach(({ params, output }) => {
+          this._checkIsTypeNeedImport(output, moduleName, this.fixRecurAndMerge);
+          params && params.forEach(({ type }) => { // 测试函数允许没有参数
+            this._checkIsTypeNeedImport(type, moduleName, this.fixRecurAndMerge);
+          });
+        });
+      } else if (m.type === 'struct') {
+        this._hasStruct = true;
+        m.members.forEach(({ type }) => {
+          this._checkIsTypeNeedImport(type, moduleName, this.fixRecurAndMerge);
+        });
+      }
+    });
+  }
+  // 重置所有存在nestid的module name
+  resetModuleImport(moduleName) {
+    this._tree[moduleName].value.forEach((m, index1) => {
+      if (m.type === 'interface') {
+        // m.methods.map(({ params, output }) => {
+        //     // this._tree[moduleName].value[index]
+        //     if (this._checkIsTypeNeedImport(output, moduleName)) { 
+        //         this._tree[moduleName].value[index]
+        //     }
+        //     params && params.forEach(({ type }) => { // 测试函数允许没有参数
+        //         this._checkIsTypeNeedImport(type, moduleName);
+        //     });
+        // });
+      } else if (m.type === 'struct') {
+        m.members.forEach((member, index2) => {
+          if (this._checkIsTypeNeedImport(this._tree[moduleName].value[index1].members[index2].type, moduleName, true)) {
+            // this._tree[moduleName].value[index].members[index2].type.nested.
+          }
+        });
+      }
+    });
+  }
+
+  /**
+   * @description 判断类型是否需要导入对应文件
+   * @param {tarsType} t - 需要检查的类型
+   * @param {string} current
+   */
+  _checkIsTypeNeedImport(t, current, removeOther = false) {
+    /** @type {(name: string) => string} */
+    const checkIsCurrent = name => /** @type {string} */ {
+      return (name && name !== current && !this._modulesToImport.includes(name) && this._modulesToImport.push(name))
+    }
+    if (typeof t === 'string') return;
+    if (this._typing.isRefType(t)) {
+      const [moduleName] = t.nested;
+      if (removeOther && moduleName && moduleName != current) {
+        return t.nested = [current]
+      }
+      checkIsCurrent(moduleName);
+    } else if (this._typing.isVector(t)) {
+      if (this._typing.isRefType(t.target)) {
+        const [moduleName] = t.target.nested;
+        if (removeOther && moduleName && moduleName != current) {
+          return t.target.nested = [current]
+        }
+        checkIsCurrent(moduleName);
+      } else {
+        this._checkIsTypeNeedImport(t.target, current, removeOther)
+      }
+    } else if (this._typing.isMap(t)) {
+      if (this._typing.isRefType(t.key)) {
+        const [moduleName] = t.key.nested;
+        if (removeOther && moduleName && moduleName != current) {
+          return t.key.nested = [current]
+        }
+        checkIsCurrent(moduleName);
+      }
+
+      if (this._typing.isRefType(t.value)) {
+        const [moduleName] = t.value.nested;
+        if (removeOther && moduleName && moduleName != current) {
+          return t.value.nested = [current]
+        }
+        checkIsCurrent(moduleName);
+      } else {
+        this._checkIsTypeNeedImport(t.value, current, removeOther)
+      }
+    }
+  }
+
+  /**
+   * @param {string} moduleName
+   * @param {TarsNode} node
+   * @param {'client'|'service'|'web'} type
+   */
+  _generateNode(moduleName, node, type) {
+    if(node.type === 'key') return;
+    
+    let unitDict = this._unitDict[moduleName];
+    if (!unitDict) {
+      unitDict = this._unitDict[moduleName] = {};
+    }
+    if (unitDict[node.id]) {
+      return;
+    } else {
+      unitDict[node.id] = 1;
+    }
+
+    switch (node.type) {
+      case 'struct': {
+        this._gStruct.reset(moduleName, node).build();
+        break;
+      }
+      case 'interface': {
+        if (this._options.mode === 'web') {
+          // TODO 前端用http调用，没有实现Buffer的方式
+          return;
+        }
+        if (type === 'client') this._gProxy.reset(moduleName, node).build();
+        else {
+          this._gInterf.reset(moduleName, node).build();
+          this._mappingMembers.push(node.id);
+        }
+        break;
+      }
+      case 'enum': {
+        this._gEnum.reset(moduleName, node).build();
+        break;
+      }
+      case 'const': {
+        this._gConst.reset(moduleName, node).build();
+        break;
+      }
+      default:
+        throw new Error(`Type: ##${node || 'key'}## is not support yet`);
+    }
+  }
+
+  async _generateModuleInMemo(moduleName, targetModule) {
+    const { pathname } = targetModule;
+    const { name } = path.parse(pathname);
+
+    const output = {};
+
+    if (pathname !== this._entryPath) {
+      output[`${name}`] = await this._generateModuleAsString(moduleName, targetModule);
+    } else if (this._options.mode === 'all') {
+      output[name] = await this._generateModuleAsString(moduleName, targetModule);
+      output[`${name}Proxy`] = await this._generateModuleAsString(moduleName, targetModule, 'client');
+    } else if (this._options.mode === 'client') {
+      output[`${name}Proxy`] = await this._generateModuleAsString(moduleName, targetModule, 'client');
+    } else {
+      output[name] = await this._generateModuleAsString(moduleName, targetModule);
+    }
+
+    return output;
+  }
+
+  /**
+   * @param {string} moduleName
+   * @param {TarsModule} targetModule
+   * @param {'client'|'service'} [type='service']
+   */
+  async _generateModuleAsString(
+    moduleName,
+    { value },
+    type = 'service',
+  ) {
+    this._importRelatedModules(moduleName);
+    this._printer.resetIndent();
+    this._copyRight(type);
+    this._prepare(type);
+
+    this._printer
+      .line('export namespace ')
+      .word(moduleName, 'R')
+      .scope(() => {
+        if (this._hasInterf && type === 'client') {
+          this._commonInterface();
+        }
+        value.forEach((node) => {
+          this._generateNode(moduleName, node, type);
+          this._printer.newline();
+        });
+        if (this._mappingMembers.length > 0) {
+          this._printer
+            .line('export interface Mapping ')
+            .scope(() => {
+              this._mappingMembers.forEach((name) => {
+                this._printer.line(`${name}: typeof ${name}Imp;`);
+              });
+              this._printer.line('[index: string]: new() => unknown;');
+            })
+            .semicolon();
+          this._printer
+            .line('export const mapping: Mapping = ')
+            .scope(() => {
+              this._mappingMembers.forEach((name) => {
+                this._printer.line(`${name}: ${name}Imp,`);
+              });
+            })
+            .semicolon();
+        }
+      });
+    const buf = this._printer.print();
+    return this._writeToString(buf.trim());
+  }
+
+  /**
+   * @param {string} buf
+   * @return {string}
+   */
+  _writeToString(buf) {
+    let content = buf;
+    if (this._options.type !== 'ts') {
+      content = ts.transpileModule(buf, {
+        compilerOptions: {
+          module: 'commonjs',
+          target: 'es6',
+          sourceMap: true,
+
+          moduleResolution: 'node',
+          esModuleInterop: true,
+          allowJs: false,
+          allowUnreachableCode: true,
+          allowUnusedLabels: true,
+          noStrictGenericChecks: true,
+          skipLibCheck: true,
+        },
+      }).outputText;
+    }
+    return content;
+  }
+
+  /**
+   * @param {string} moduleName
+   * @param {TarsModule} targetModule
+   */
+  async _generateModule(moduleName, targetModule) {
+    const { pathname, aimFile } = targetModule;
+    const { name } = path.parse(pathname);
+    const ext = this._options.type !== 'ts' ? 'js' : 'ts';
+
+    if (aimFile) {
+      // 把引用文件放在相对位置
+      await this._generateModuleAndWrite(moduleName, targetModule, `${aimFile}.${ext}`);
+    } else if (pathname !== this._entryPath) {
+      await this._generateModuleAndWrite(moduleName, targetModule, `${name}.${ext}`);
+    } else if (this._options.mode === 'all') {
+      await this._generateModuleAndWrite(moduleName, targetModule, `${name}.${ext}`);
+      await this._generateModuleAndWrite(moduleName, targetModule, `${name}Proxy.${ext}`, 'client');
+    } else if (this._options.mode === 'client') {
+      await this._generateModuleAndWrite(moduleName, targetModule, `${name}Proxy.${ext}`, 'client');
+    } else {
+      await this._generateModuleAndWrite(moduleName, targetModule, `${name}.${ext}`);
+    }
+  }
+
+  /**
+   * @param {string} moduleName
+   * @param {TarsModule} targetModule
+   * @param {string} fileName
+   * @param {'client'|'service'} [type='service']
+   */
+  async _generateModuleAndWrite(
+    moduleName,
+    { value },
+    fileName,
+    type = 'service',
+  ) {
+    if (this.fixRecurAndMerge) {
+      this.resetModuleImport(moduleName)
+      // return fse.writeFileSync('/home/wlq/workstation_1/jv-awesome/node_modules/@jv/tars2node-cli/test/hhhhhh.json', JSON.stringify(this._tree[moduleName].value ,"","\t"), );
+    }
+    this._importRelatedModules(moduleName);
+    this._printer.resetIndent();
+    // todo: 在window和mac的路径不一样导致变化，先注释掉
+    // this._copyRight(type);
+    this._prepare(type);
+    const commonCode = () => {
+      if (this._hasInterf && type === "client") {
+        this._commonInterface();
+      }
+      value.forEach((node) => {
+        this._generateNode(moduleName, node, type);
+        this._printer.newline();
+      });
+      if (this._mappingMembers.length > 0) {
+        this._printer
+          .line("export interface Mapping ")
+          .scope(() => {
+            this._mappingMembers.forEach((name) => {
+              this._printer.line(`${name}: typeof ${name}Imp;`);
+            });
+            this._printer.line("[index: string]: new() => unknown;");
+          })
+          .semicolon();
+        this._printer
+          .line("export const mapping: Mapping = ")
+          .scope(() => {
+            this._mappingMembers.forEach((name) => {
+              this._printer.line(`${name}: ${name}Imp,`);
+            });
+          })
+          .semicolon();
+      }
+    }
+    if (this.useNameSpace) {
+      this._printer
+        .line('export namespace ')
+        .word(moduleName, 'R')
+        .scope(() => {
+          commonCode()
+        });
+    } else {
+      commonCode()
+    }
+    const buf = this._printer.print();
+    await this._writeToFile(fileName, buf.trim());
+  }
+
+  _commonInterface() {
+    this._printer
+      .newline()
+      .word('export interface SharedArgumentInfo', 'R')
+      .scope(() => {
+        this._printer
+          .line('name: string;')
+          .line('class: string;')
+          .line("direction: 'in' | 'out';");
+      })
+      .line('export interface SharedFunctionInfo ')
+      .scope(() => {
+        this._printer
+          .line('name: string;')
+          .line('return: string;')
+          .line('arguments: SharedArgumentInfo[];');
+      });
+  }
+
+  /**
+   * @param {string} pathname
+   * @param {string} buf
+   * @return {Promise<string>}
+   */
+  _writeToFile(pathname, buf) {
+    let content = buf;
+    const filename = path.resolve(this._dir, pathname);
+    if (this._options.type !== 'ts') {
+      content = ts.transpileModule(buf, {
+        compilerOptions: {
+          module: 'commonjs',
+          target: 'es6',
+          sourceMap: false,
+
+          moduleResolution: 'node',
+          esModuleInterop: true,
+          allowJs: false,
+          allowUnreachableCode: true,
+          allowUnusedLabels: true,
+          noStrictGenericChecks: true,
+          skipLibCheck: true,
+        },
+      }).outputText;
+    }
+    return new Promise((res, rej) => {
+      fs.outputFile(filename, content, (err) => {
+        if (err) rej(err);
+        // console.info('\x1b[34m', `👻 Write to ${filename} success`);
+        res(filename);
+      });
+    });
+  }
+
+  _copyRight(type) {
+    this._printer
+      .line('// **********************************************************************')
+      .line(`// Parsed And Generated By ${pkg.name}@${pkg.version}`)
+      .line('// Maintained By <liquidliang>')
+      .line(`// Generated from "${path.relative(process.cwd(), this._entryPath)}" by ${this._options.mode} Mode.`)
+      .line(`// This type is ${type}`)
+      .line('// **********************************************************************');
+  }
+
+  /**
+   * @param {'client'|'service'} [type='service']
+   */
+  _prepare(type) {
+    if (this._options.mode !== 'web') {
+      this._printer
+        .newline()
+        .line('/* tslint:disable */')
+        .newline()
+        .line(`/// <reference types="node" />`)
+    }
+    this._modulesToImport.forEach((mod) => {
+      const { pathname } = this._tree[mod];
+      const { name } = path.parse(pathname);
+      let aimFile = `./${name}`;
+      if (this._options.useModuleName) {
+        aimFile = path.relative(this._entryDir, pathname).replace(/\.\w+$/, '').replace(/\\/g, '/');
+        if (!/^[\.\\\/]/.test(aimFile)) {
+          aimFile = `./${aimFile}`;
+        }
+        this._tree[mod].aimFile = aimFile;
+      }
+      this._printer.line(`import * as $${mod} from '${aimFile}';`);
+    });
+    if (this._options.mode === 'web') {
+      return;
+    }
+    this._printer
+      .line("import * as TarsStream from '@tars/stream';");
+    if (this._hasInterf) {
+      this._printer.line("import * as TarsRpc from '@tars/rpc';");
+      if (type !== 'client') this._printer.line("import assert from 'assert';");
+      else {
+        this._printer
+          .line('const _makeError = function (data: any, message: string, type?: number): any ')
+          .scope(() => {
+            this._printer
+              .line('const error: any = new Error(message || "");')
+              .line('error.request = data.request;')
+              .line('error.response = ')
+              .scope(() => {
+                this._printer.line('costtime: data.request.costtime');
+              })
+              .semicolon();
+            this._printer
+              .line('if (type === TarsRpc.error.CLIENT.DECODE_ERROR) ')
+              .scope(() => {
+                this._printer
+                  .line('error.name = "DECODE_ERROR";')
+                  .line('error.response.error = ')
+                  .scope(() => {
+                    this._printer
+                      .line('code: type,')
+                      .line('message: message');
+                  }).semicolon();
+              }).word('else', 'LR').scope(() => {
+                this._printer
+                  .line('error.name = "RPC_ERROR";')
+                  .line('error.response.error = data.error;');
+              })
+              .line('return error;');
+          }).semicolon();
+      }
+    }
+
+
+    this._printer.newline();
+    if (this._hasStruct) this._printer.line('const _hasOwnProperty = Object.prototype.hasOwnProperty;').newline();
+  }
+}
+
+/**
+ * @param {TarsTree} tree
+ * @param {string} entryPath
+ * @param {CompilerOptions} options - 编译配置选项
+ */
+module.exports = Generator;

package/lib/generator/ts/printer.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const SuperPrinter = require('../printer');
+
+class Printer extends SuperPrinter {
+  /**
+   * @typedef {object} classMethodInfo
+   * @property {string} name
+   * @property {[string, string][]} params
+   * @property {string} [type]
+   * @property {string} [returnType]
+   * @property {() => void} [callback]
+   *
+   * @param {classMethodInfo} info
+   * @return {this}
+   */
+  classMethod({
+    name,
+    params,
+    type,
+    returnType,
+    callback,
+  }) {
+    this.newline();
+    if (type) this.word(type, 'R');
+    this.word(name).word('(');
+    params.forEach(([p, t], i) => {
+      this.word(`${p}: ${t}`);
+      if (i + 1 < params.length) {
+        this.word(',').space(1);
+      }
+    });
+    this.word(')');
+    if (returnType) this.word(`: ${returnType}`);
+    this.space(1).scope(callback);
+
+    return this;
+  }
+
+  /**
+   * @typedef {object} classPropsInfo
+   * @property {string} name
+   * @property {string} valueType
+   * @property {string} [type]
+   * @property {string} [value]
+   *
+   * @param {classPropsInfo} info
+   * @return {this}
+   */
+  classProps({
+    name,
+    valueType,
+    value,
+    type,
+  }) {
+    this.newline();
+    if (type) this.word(type, 'R');
+    this.word(`${name}: ${valueType}`);
+    if (value) this.word('=', 'LR').word(value);
+    this.semicolon();
+
+    return this;
+  }
+}
+
+module.exports = Printer;