@cicctencent/tars2node-cli 0.0.1

package/lib/generator/ts/def/interf.js

@@ -0,0 +1,508 @@
+'use strict';
+
+const BaseDef = require('./base');
+
+const TUP_INIT = 'const tup = new TarsStream.UniAttribute();';
+const TUP_VER = 'tup.tupVersion = this.getRequestVersion();';
+const TUP_VER_CUR = 'tup.tupVersion = current.getRequestVersion();';
+const VERSION_CHECK = 'this.getRequestVersion() === TarsStream.Tup.TUP_SIMPLE || this.getRequestVersion() === TarsStream.Tup.TUP_COMPLEX';
+const VERSION_CHECK_CUR = 'current.getRequestVersion() === TarsStream.Tup.TUP_SIMPLE || current.getRequestVersion() === TarsStream.Tup.TUP_COMPLEX';
+
+const OS_INIT = 'const os = new TarsStream.TarsOutputStream();';
+const IS_INIT = 'const is = new TarsStream.TarsInputStream(binBuffer);';
+
+class InterfDef extends BaseDef {
+  /**
+   *
+   * 声明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} 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 {import("../printer")} Printer
+   * @typedef {import("../typing")} Typing
+   *
+   * @typedef {object} CompilerOptions
+   * @property {'all'|'client'|'service'} mode
+   * @property {'string'|'number'|'bigint'} long
+   * @property {boolean} withReturn
+   * @property {boolean} gather
+   * @property {boolean} interface
+   * @property {string} [output]
+   *
+   * 创建Struct解析实例
+   * @constructor
+   * @param {Printer} printer - print类实例
+   * @param {Typing} typing - Typing类实例
+   * @param {CompilerOptions} options - 编译配置选项
+   */
+  constructor(printer, typing, options) {
+    super('', printer, typing, options);
+    this._id = '';
+    /** @type {TarsInterfMethod[]} */
+    this._methods = [];
+    this._imp = '';
+    this._beforeComment = '';
+  }
+
+  /**
+   * @param {string} name
+   * @param {TarsInterfNode} node
+   */
+  reset(name, node) {
+    this.setModuleName(name);
+    this.setNode(node);
+
+    return this;
+  }
+
+  /**
+   * @param {TarsInterfNode} node
+   */
+  setNode({ id, methods, beforeComment = '' }) {
+    this._id = id;
+    this._methods = methods;
+    this._imp = `${id}Imp`;
+    this._beforeComment = beforeComment;
+  }
+
+  build() {
+    this._interface();
+    this._class();
+  }
+
+  _interface() {
+    this._methods.forEach(this._methodParamsGatherInterface.bind(this));
+    this._methods.forEach(this._interfaceForMethod.bind(this));
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _interfaceForMethod({ params, output, id }) {
+    const ps = [];
+    if (output !== 'void') ps.push(['ret', this._typing.toTSType(output, this._moduleName)]);
+    params.filter(({ io }) => io === 'out')
+      .forEach(({ id: pid, type: ptype }) => {
+        ps.push([pid, this._typing.toTSType(ptype, this._moduleName)]);
+      });
+    this._printer
+      .word(this._beforeComment)
+      .newline()
+      .word('export', 'R')
+      .word('interface', 'R')
+      .word(this._methodConsts(id, 'CUR'), 'R')
+      .word('extends', 'R')
+      .word('TarsRpc.TarsCurrent', 'R')
+      .word('{')
+      .indent()
+      .line(`sendResponse(${ps.map(([k, t]) => `${k}: ${t}`).join(', ')}): void;`)
+      .dedent()
+      .line('}');
+  }
+
+  _class() {
+    this
+      ._printer
+      .newline()
+      .word('export', 'R')
+      .word('class', 'R')
+      .word(this._imp, 'R')
+      .scope(() => {
+        this._classCommon();
+        this._methods.forEach(this._method.bind(this));
+      });
+  }
+
+  _classCommon() {
+    this._printer
+      .classMethod({
+        name: 'initialize',
+        params: [],
+        returnType: 'Promise<any> | void',
+        type: 'protected',
+        callback: () => {},
+      })
+      .classMethod({
+        name: 'onDispatch',
+        params: [['current', 'TarsRpc.TarsCurrent'], ['funcName', 'string'], ['binBuffer', 'TarsStream.BinBuffer']],
+        returnType: 'number',
+        type: 'protected',
+        callback: () => {
+          this._printer
+            .line('if ("__" + funcName in this) ')
+            .scope(() => {
+              this._printer.line('return (<{[index: string]: Function}><unknown>this)["__" + funcName](current, binBuffer);');
+            })
+            .word('else', 'LR')
+            .scope(() => {
+              this._printer.line('return TarsRpc.error.SERVER.FUNC_NOT_FOUND;');
+            });
+        },
+      })
+      .classMethod({
+        name: '__taf_ping',
+        params: [['current', 'TarsRpc.TarsCurrent']],
+        returnType: 'number',
+        type: 'protected',
+        callback: () => {
+          this._tafPingRe();
+        },
+      });
+  }
+
+  _tafPingRe() {
+    this._printer
+      .line(`const ${this._methodReName('taf_ping')}`)
+      .word('= function (this: TarsRpc.TarsCurrent, _ret: number) {')
+      .indent()
+      .line('if (');
+    this._printer.word(VERSION_CHECK);
+    this._printer
+      .word(') {')
+      .indent().line(TUP_INIT).line(TUP_VER)
+      .line('tup.writeInt32("", _ret);')
+      .line('this.doResponse(tup.encode());')
+      .dedent()
+      .line('} else {')
+      .indent()
+      .line(OS_INIT)
+      .line('os.writeInt32(0, _ret);')
+      .line('this.doResponse(os.getBinBuffer());')
+      .dedent()
+      .line('}')
+      .dedent()
+      .line('}')
+      .semicolon()
+      .line(`${this._methodReName('taf_ping')}.call(current, 0);`)
+      .line('return TarsRpc.error.SUCCESS;');
+  }
+
+  /**
+   * @param {string} name
+   * @param {string} type
+   * @return {string}
+   */
+  _methodConsts(name, type) {
+    return `${this._id}$${name}$${type}`;
+  }
+
+  /**
+   * @param {string} name
+   * @return {string}
+   */
+  _methodReName(name) {
+    return `__${this._moduleName}_${this._id}$${name}$RE`;
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _method(method) {
+    const { id, output } = method;
+    this._printer
+      .classMethod({
+        name: id,
+        params: this._methodParams(method),
+        returnType: 'void',
+        callback: () => {
+          this._printer.line(`assert.fail("${id} function not implemented");`);
+        },
+      })
+      .classMethod({
+        name: `__${id}`,
+        type: 'protected',
+        params: [['current', this._methodConsts(id, 'CUR')], ['binBuffer', 'TarsStream.BinBuffer']],
+        returnType: 'number',
+        callback: () => {
+          method.params.forEach(({ id: pid }) => { this._printer.line(`let ${pid}: any = null;`); });
+          if (this._options.withReturn) {
+            const ret = this._typing.isNotObjectType(output, this._moduleName)
+              ? this._typing.toDefaultValue(output)
+              : `new ${this._typing.toTSType(output, this._moduleName)}`;
+            this._printer.line(`const ret = ${ret};`);
+          }
+          this._methodRe(method);
+          this._methodLogic(method);
+        },
+      });
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _methodRe({ id, output, params }) {
+    const outputParams = params.filter(param => param.io === 'out');
+    const ps = [['this', this._methodConsts(id, 'CUR')]];
+    if (output !== 'void') {
+      ps.push(['_ret', this._typing.toTSType(output, this._moduleName)]);
+    }
+    outputParams.forEach(({ id: pid, type: ptype }) => {
+      ps.push([pid, this._typing.toTSType(ptype, this._moduleName)]);
+    });
+    this
+      . _printer
+      .newline()
+      .word('const', 'R')
+      .word(this._methodReName(id), 'R')
+      .word('=', 'R')
+      .word(`function(${ps.map(([pid, ptype]) => `${pid}: ${ptype}`).join(', ')})`, 'R')
+      .word('{')
+      .indent();
+    this._printer.line('if (');
+    this._printer.word(VERSION_CHECK);
+    this._printer
+      .word(') {')
+      .indent().line(TUP_INIT).line(TUP_VER);
+    if (output !== 'void') {
+      this._printer
+        .line(this._tupWrite(output, '_ret'));
+    }
+    outputParams.forEach(({ id: pid, type: ptype }) => {
+      this._printer.line(this._tupWrite(ptype, pid, pid));
+    });
+    this._printer
+      .line('this.doResponse(tup.encode());')
+      .dedent()
+      .line('} else {')
+      .indent()
+      .line(OS_INIT);
+    if (output !== 'void') {
+      this._printer
+        .line(`os.write${this._typing.toIOType(output, this._moduleName)}(0, _ret${this._needGenerateParamForLong(output)})`);
+    }
+    outputParams.forEach(({ id: pid, type: ptype }) => {
+      const index = params.findIndex(({ id: mid }) => mid === pid) + 1;
+      this._printer
+        .line(`os.write${this._typing.toIOType(ptype, this._moduleName)}(${index}, ${pid}${this._needGenerateParamForLong(ptype)});`);
+    });
+    this._printer
+      .line('this.doResponse(os.getBinBuffer());')
+      .dedent().line('}').dedent()
+      .line('};');
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _methodLogic({ id, params }) {
+    this._printer.line('if (');
+    this._printer.word(VERSION_CHECK_CUR);
+    this._printer.word(')', 'R')
+      .scope(() => {
+        this._printer
+          .line(TUP_INIT).line(TUP_VER_CUR)
+          .line('tup.decode(binBuffer);');
+        params.forEach(({ type: ptype, id: pid, io }) => {
+          this._printer.line(this._tupRead(ptype, pid, io));
+        });
+      })
+      .word('else', 'LR')
+      .scope(() => {
+        this._printer.line(IS_INIT);
+        params.forEach(({ type: ptype, id: pid, io }) => {
+          let value;
+          if (this._typing.isNotObjectType(ptype, this._moduleName)) {
+            value = this._typing.toIOValue(ptype);
+          } else {
+            const { source, tafType } = this._typing.toTarsStreamType(ptype, this._moduleName);
+            if (source && source.type === 'enum') {
+              value = `${tafType}.${source.value[0].id}`;
+            } else {
+              value = tafType;
+            }
+          }
+
+          const index = params.findIndex(({ id: mid }) => mid === pid) + 1;
+
+          const result = `${pid} = is.read${this._typing.toIOType(ptype, this._moduleName)}(${index}, ${io === 'in'}, ${value}${this._needGenerateParamForLong(ptype)})`;
+
+          this._printer.line(result);
+        });
+      })
+      .line(`current.sendResponse = ${this._methodReName(id)};`);
+
+    const ps = ['current'];
+
+    if (this._options.withReturn) {
+      ps.push('ret');
+    }
+
+    if (this._options.gather) {
+      /** @type {(type: string, name: string) => void} */
+      const gatherParams = (type, name) => {
+        const p = params
+          .filter(({ io }) => io === type)
+          .map(({ id: pid }) => pid)
+          .join(', ');
+        this._printer.line(`const ${name} = { ${p} };`);
+      };
+
+      gatherParams('in', 'input');
+      gatherParams('out', 'output');
+
+      ps.push('input', 'output');
+    } else {
+      params.forEach(({ id: pid }) => {
+        ps.push(pid);
+      });
+    }
+
+    this._printer
+      .line(`this.${id}(${ps.join(', ')});`)
+      .line('return TarsRpc.error.SUCCESS;');
+  }
+
+  /**
+   * @param {tarsType} type
+   * @return {string}
+   */
+  _needGenerateParamForLong(type) {
+    const longLastParam = type === 'long' && this.generateLastParamForLong();
+    return longLastParam ? `, ${longLastParam}` : '';
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} id
+   * @param {string} [name = '']
+   * @return {string}
+   */
+  _tupWrite(type, id, name = '') {
+    return `tup.write${this._typing.toIOType(type, this._moduleName)}("${name}", ${id}${this._needGenerateParamForLong(type)});`;
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} id
+   * @param {'in'|'out'} io
+   * @return {string}
+   */
+  _tupRead(type, id, io) {
+    const ioType = this._typing.toIOType(type, this._moduleName);
+    const params = [`"${id}"`];
+    if (io === 'out') {
+      if (this._typing.isNotObjectType(type, this._moduleName)) {
+        params.push(/** @type string */ (this._typing.toIOValue(type)));
+        const longLastParam = type === 'long' && this.generateLastParamForLong();
+        if (longLastParam) {
+          params.push(`${longLastParam}`);
+        }
+      } else {
+        const { tafType } = this._typing.toTarsStreamType(type, this._moduleName);
+        params.push(tafType, `new ${tafType}`);
+      }
+    } else if (!this._typing.isNotObjectType(type, this._moduleName)) {
+      const { tafType } = this._typing.toTarsStreamType(type, this._moduleName);
+      params.push(tafType);
+    }
+
+    return `${id} = tup.read${ioType}(${params.join(', ')});`;
+  }
+
+  /**
+   *
+   * @typedef {{input: Array<[string, string]>, output: Array<[string, string]>}} Params
+   *
+   * @param {TarsInterfMethod} method
+   * @return {Array<[string, string]>}
+   */
+  _methodParams({ id, output, params }) {
+    /** @type {Array<[string, string]>} */
+    const ps = [['_current', this._methodConsts(id, 'CUR')]];
+    if (this._options.withReturn) ps.push(['_ret', this._typing.toTSType(output, this._moduleName)]);
+    if (this._options.gather) {
+      ps.push(['_input', this._methodConsts(id, 'Input')], ['_output', this._methodConsts(id, 'Output')]);
+    } else {
+      params.forEach(({ id: pid, type: ptype }) => {
+        ps.push([`_${pid}`, this._typing.toTSType(ptype, this._moduleName)]);
+      });
+    }
+
+    return ps;
+  }
+
+  /**
+   * @description: 生成method对应的input和output的interface
+   * @param {TarsInterfMethod} method
+   */
+  _methodParamsGatherInterface({ id, params, output: ret }) {
+    const inputInterfaceId = this._methodConsts(id, 'Input');
+    const outputInterfaceId = this._methodConsts(id, 'Output');
+    const curInterfaceId = this._methodConsts(id, 'CUR');
+    const cpsInterfaceId = this._methodConsts(id, 'CPS');
+    const { input, output } = params.reduce(
+      (acc, { id: pid, io, type: ptype }) => {
+        const t = [pid, this._typing.toTSObjectType(ptype, this._moduleName)];
+        if (io === 'out') {
+          return {
+            input: acc.input,
+            output: /** @type {Array<[string, string]>} */ ([...acc.output, t]),
+          };
+        }
+        return {
+          input: /** @type {Array<[string, string]>} */ ([...acc.input, t]),
+          output: acc.output,
+        };
+      },
+      /** @type {Params} */ ({ input: [], output: [] }),
+    );
+
+    const retType = this._typing.toTSObjectType(ret, this._moduleName);
+    /** @type {Array<[string, string]>} */
+    const cps = [
+      ['req', inputInterfaceId],
+      ['res', outputInterfaceId],
+      ['ret', retType],
+      ['cur', curInterfaceId],
+      [`send(ret?: ${retType}, res?: ${outputInterfaceId})`, 'void'],
+    ];
+
+    /**
+     * @type {(i: string, ps: Array<[string, string]>) => void}
+     */
+    const generateInterface = (i, ps) => {
+      this._printer.newline()
+        .word('export', 'R').word('interface', 'R').word(i, 'R')
+        .scope(() => {
+          ps.forEach(([pid, ptype]) => {
+            this._printer.line(`${pid}: ${ptype}`).semicolon();
+          });
+        });
+    };
+
+    generateInterface(inputInterfaceId, input);
+    generateInterface(outputInterfaceId, output);
+    generateInterface(cpsInterfaceId, cps);
+  }
+}
+
+module.exports = InterfDef;