@cicctencent/tars2node-cli 0.0.1

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

@@ -0,0 +1,483 @@
+'use strict';
+
+const BaseDef = require('./base');
+
+const VERSION_CHECK = 'version === TarsStream.Tup.TUP_SIMPLE || version === TarsStream.Tup.TUP_COMPLEX';
+
+class ProxyEnum 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[]} methods */
+    this._methods = [];
+    this._prxy = '';
+    this._underscoreName = '';
+  }
+
+  /**
+   * @param {string} name
+   * @param {TarsInterfNode} node
+   */
+  reset(name, node) {
+    this.setModuleName(name);
+    this.setNode(node);
+
+    return this;
+  }
+
+  /**
+   * @param {TarsInterfNode} node
+   */
+  setNode({ id, methods }) {
+    this._id = id;
+    this._methods = methods;
+    this._prxy = `${id}Proxy`;
+    this._underscoreName = `__${this._moduleName}_${id}`;
+  }
+
+  /**
+   * @param {string} name
+   */
+  setModuleName(name) {
+    super.setModuleName(name);
+    this._underscoreName = `__${this._moduleName}_${this._id}`;
+  }
+
+  build() {
+    this._methods.forEach(this._consts.bind(this));
+    this._methods.forEach(this._interface.bind(this));
+    this._class();
+  }
+
+  _class() {
+    this._printer
+      .newline()
+      .word('export', 'R')
+      .word('class', 'R')
+      .word(this._prxy, 'R')
+      .scope(() => {
+        this._classCommon();
+        this._methods.forEach(this._method.bind(this));
+      });
+  }
+
+  _classCommon() {
+    this._printer.classProps({
+      name: '_name',
+      valueType: 'string',
+      value: "''",
+      type: 'protected',
+    });
+
+    // _worker member
+    this._printer
+      .line('protected _worker: ')
+      .scope(() => {
+        this._printer
+          .word('timeout: number;')
+          .line('version: number;')
+          .line('tup_invoke: Function;')
+          .line('taf_invoke: Function;');
+      })
+      .word('=', 'LR')
+      .scope(() => {
+        this._printer
+          .line('timeout: 0,')
+          .line('version: 0,')
+          .line('tup_invoke: () => {},')
+          .line('taf_invoke: () => {},');
+      })
+      .semicolon();
+
+    this._printer
+      .classMethod({
+        name: 'setTimeout',
+        params: [['iTimeout', 'number']],
+        returnType: 'void',
+        callback: () => {
+          this._printer
+            .line('this._worker.timeout = iTimeout;');
+        },
+      })
+      .classMethod({
+        name: 'getTimeout',
+        params: [],
+        returnType: 'number',
+        callback: () => {
+          this._printer
+            .line('return this._worker.timeout;');
+        },
+      })
+      .classMethod({
+        name: 'setVersion',
+        params: [['iVersion', 'number']],
+        returnType: 'void',
+        callback: () => {
+          this._printer
+            .line('this._worker.version = iVersion;');
+        },
+      })
+      .classMethod({
+        name: 'getVersion',
+        params: [],
+        returnType: 'number',
+        callback: () => {
+          this._printer
+            .line('return this._worker.version;');
+        },
+      });
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _interface({ id, params, output }) {
+    params = params || [];// 测试函数允许没有参数
+    this._printer
+      .line(`export interface ${this._methodConsts(id, 'DE')} `)
+      .scope(() => {
+        this._printer
+          .line('request: object;')
+          .line('response: ')
+          .scope(() => {
+            this._printer
+              .line('costtime: number;')
+              .line(`return: ${this._typing.toTSType(output, this._moduleName)};`)
+              .line('arguments: ')
+              .scope(() => {
+                params.filter(({ io }) => io === 'out').forEach(({ id: pid, type: ptype }) => {
+                  this._printer
+                    .line(`${pid}: ${this._typing.toTSType(ptype, this._moduleName)};`);
+                });
+              })
+              .semicolon();
+          })
+          .semicolon();
+      });
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _method({ id, params }) {
+    params = params || [];// 测试函数允许没有参数
+    const name = `${this._underscoreName}$${id}`;
+
+    const inputParams = params.filter(({ io }) => io === 'in');
+    const ps = inputParams
+      .map(({ id: pid, type: ptype }) => [pid, this._typing.toTSType(ptype, this._moduleName)]);
+    const inputPsToString = inputParams.map(({ id: pid }) => pid).join(', ');
+
+    ps.push(['_property?', 'TarsRpc.InvokeProperty']);
+
+    this._printer
+      .classMethod({
+        name: id,
+        params: /** @type {Array<[string, string]>} */ (ps),
+        returnType: `Promise<${this._methodConsts(id, 'DE')}>`,
+        callback: () => {
+          this._printer
+            .line('const version = this._worker.version;')
+            .line(`if(${VERSION_CHECK}) {`)
+            .indent()
+            .line(`return this._worker.tup_invoke("${id}", ${name}$PE(${inputPsToString.length > 0 ? `${inputPsToString}, ` : ''}version), arguments[arguments.length - 1], ${name}$IF).then(${name}$PD, ${name}$ER);`)
+            .dedent()
+            .line('} else {')
+            .indent()
+            .line(`return this._worker.taf_invoke("${id}", ${name}$IE(${inputPsToString}), arguments[arguments.length - 1], ${name}$IF).then(${name}$ID, ${name}$ER);`)
+            .dedent()
+            .line('}');
+        },
+      })
+      .classProps({
+        name: id,
+        valueType: 'SharedFunctionInfo',
+        value: `<SharedFunctionInfo>${name}$IF`,
+        type: 'static',
+      });
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts(method) {
+    this._consts$if(method);
+    this._consts$ie(method);
+    this._consts$id(method);
+    this._consts$pe(method);
+    this._consts$pd(method);
+    this._consts$er(method);
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts$if({ id, output, params }) {
+    params = params || [];// 测试函数允许没有参数
+    const name = `${this._underscoreName}$${id}`;
+    this._printer
+      .line(`export const ${name}$IF = `)
+      .scope(() => {
+        this._printer
+          .newline()
+          .word(`name: "${id}",`)
+          .line(`return: "${this._typing.toString(output, this._moduleName)}",`)
+          .line('arguments: [')
+          .indent();
+        params.forEach(({ id: pid, type: ptype, io }) => { 
+          this._printer
+            .newline()
+            .scope(() => {
+              this._printer
+                .word(`name: "${pid}",`)
+                .line(`class: "${this._typing.toString(ptype, this._moduleName)}",`)
+                .line(`direction: "${io}"`);
+            })
+            .word(',');
+        });
+        this._printer.dedent().line(']');
+      })
+      .semicolon();
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts$ie({ id, params }) {
+    params = params || [];// 测试函数允许没有参数
+    const name = `${this._underscoreName}$${id}`;
+    const inputParams = params.filter(({ io }) => io === 'in');
+    this._printer
+      .line(`const ${name}$IE = function(${inputParams.map(({ id: pid }) => `${pid}: any`).join(', ')})`)
+      .space(1)
+      .scope(() => {
+        this._printer.line('const os = new TarsStream.TarsOutputStream();');
+        inputParams.forEach(({ id: pid, type: ptype }) => {
+          const ioType = this._typing.toIOType(ptype, this._moduleName);
+          const index = params.findIndex(({ id: iid }) => pid === iid) + 1;
+          this._printer.line(`os.write${ioType}(${index}, ${pid}${this._needGenerateTrueForLong(ptype)})`);
+        });
+
+        this._printer.line('return os.getBinBuffer();');
+      })
+      .semicolon();
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts$id({ id, params, output }) {
+    params = params || [];// 测试函数允许没有参数
+    const name = `${this._underscoreName}$${id}`;
+    this._printer
+      .line(`const ${name}$ID = function(data: any)`)
+      .space(1)
+      .scope(() => {
+        this._printer
+          .newline()
+          .word('try', 'R')
+          .scope(() => {
+            this._printer
+              .line('const is = new TarsStream.TarsInputStream(data.response.sBuffer);')
+              .newline()
+              .word('return', 'R')
+              .scope(() => {
+                this._printer
+                  .line('request: data.request,')
+                  .newline()
+                  .word('response: ')
+                  .scope(() => {
+                    this._printer.line('costtime: data.request.costtime,');
+                    if (output !== 'void') {
+                      this._printer
+                        .line(`return: is.read${this._typing.toIOType(output, this._moduleName)}(0, true, ${this._typing.toTarsValue(output, this._moduleName)}${this._needGenerateTrueForLong(output)}),`);
+                    }
+                    this._printer
+                      .line('arguments: ')
+                      .scope(() => {
+                        params.filter(({ io }) => io === 'out').forEach(({ id: pid, type: ptype }) => {
+                          const ioType = this._typing.toIOType(ptype, this._moduleName);
+                          const index = params.findIndex(({ id: iid }) => iid === pid) + 1;
+                          this._printer
+                            .line(`${pid}: is.read${ioType}(${index}, true, ${this._typing.toTarsValue(ptype, this._moduleName)}${this._needGenerateTrueForLong(ptype)}),`);
+                        });
+                      });
+                  });
+              })
+              .semicolon();
+          })
+          .word('catch (e)', 'LR')
+          .scope(() => {
+            this._printer
+              .line('throw _makeError(data, e.message, TarsRpc.error.CLIENT.DECODE_ERROR);')
+              .semicolon();
+          });
+      })
+      .semicolon();
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts$pe({ id, params }) {
+    params = params || [];// 测试函数允许没有参数
+    const name = `${this._underscoreName}$${id}`;
+    const inputParams = params.filter(({ io }) => io === 'in');
+    const ps = inputParams.map(({ id: pid }) => [pid, 'any']).concat([['__$PROTOCOL$VERSION', 'number']]);
+
+    this._printer
+      .line(`const ${name}$PE = function(${ps.map(([k, t]) => `${k}: ${t}`).join(', ')})`)
+      .space(1)
+      .scope(() => {
+        this._printer
+          .line('const tup = new TarsStream.UniAttribute();')
+          .line('tup.tupVersion = __$PROTOCOL$VERSION;');
+        inputParams.forEach(({ id: pid, type: ptype }) => {
+          this._printer
+            .line(`tup.write${this._typing.toIOType(ptype, this._moduleName)}("${pid}", ${pid}${this._needGenerateTrueForLong(ptype)})`);
+        });
+        this._printer.line('return tup;');
+      })
+      .semicolon();
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts$pd({ id, output, params }) {
+    params = params || [];// 测试函数允许没有参数
+    const name = `${this._underscoreName}$${id}`;
+    this._printer
+      .line(`const ${name}$PD = function(data: any)`)
+      .space(1)
+      .scope(() => {
+        this._printer
+          .newline()
+          .word('try', 'R')
+          .scope(() => {
+            this._printer
+              .line('const tup = data.response.tup;')
+              .line('return ')
+              .scope(() => {
+                this._printer
+                  .line('request: data.request,')
+                  .line('response: ')
+                  .scope(() => {
+                    const retType = this._typing.toTarsValue(output, this._moduleName, true);
+                    this._printer
+                      .line('consttime: data.request.costtime,');
+                    if (output !== 'void') {
+                      this._printer
+                        .line(`return: tup.read${this._typing.toIOType(output, this._moduleName)}("", ${retType}${this._needGenerateTrueForLong(output)}),`);
+                    }
+                    this._printer
+                      .line('arguments: ')
+                      .scope(() => {
+                        params.filter(({ io }) => io === 'out').forEach(({ id: pid, type: ptype }) => {
+                          const needTypeConstructor = this._typing
+                            .isNotObjectType(ptype, this._moduleName)
+                            ? ''
+                            : `, ${this._typing.toTarsStreamType(ptype, this._moduleName).tafType}`;
+                          this._printer
+                            .line(`${pid}: tup.read${this._typing.toIOType(ptype, this._moduleName)}("${pid}"${needTypeConstructor}),`);
+                        });
+                      });
+                  });
+              })
+              .semicolon();
+          })
+          .word('catch (e)', 'LR')
+          .scope(() => {
+            this._printer
+              .line('throw _makeError(data, e.message, TarsRpc.error.CLIENT.DECODE_ERROR);');
+          });
+      })
+      .semicolon();
+  }
+
+  /**
+   * @param {TarsInterfMethod} method
+   */
+  _consts$er({ id }) {
+    const name = `${this._underscoreName}$${id}`;
+    this._printer
+      .line(`const ${name}$ER = function(data: any)`)
+      .space(1)
+      .scope(() => {
+        this._printer.line(`throw _makeError(data, "Call ${this._id}::${id} failed");`);
+      })
+      .semicolon();
+  }
+
+  /**
+   * @param {string} name
+   * @param {string} type
+   * @return {string}
+   */
+  _methodConsts(name, type) {
+    return `${this._id}$${name}$${type}`;
+  }
+
+  /**
+   * @param {tarsType} type
+   * @return {string}
+   */
+  _needGenerateTrueForLong(type) {
+    const longLastParam = type === 'long' && this.generateLastParamForLong();
+    return longLastParam ? `, ${longLastParam}` : '';
+  }
+}
+
+module.exports = ProxyEnum;