Source: client/any-packer.js

  1. /*
  2.  * Copyright 2023, TeamDev. All rights reserved.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Redistribution and use in source and/or binary forms, with or without
  11.  * modification, must retain the above copyright notice and the following
  12.  * disclaimer.
  13.  *
  14.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  15.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  16.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  17.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  18.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  19.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  20.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25.  */
  27. "use strict";
  29. import {Message} from 'google-protobuf';
  30. import {isProtobufMessage, Type, TypedMessage} from './typed-message';
  31. import {Any} from '../proto/google/protobuf/any_pb';
  33. /**
  34.  * An packer of string, number, boolean, and message values from Protobuf `Any`.
  35.  */
  36. class Unpack {
  37.   /**
  38.    * @param {Any} any a Protobuf `Any` value to be unpacked to message or primitive
  39.    */
  40.   constructor(any) {
  41.     /**
  42.      * @type {Any}
  43.      * @private
  44.      */
  45.     this._any = any;
  46.   }
  48.   /**
  49.    * Unpacks a Protobuf `Any` assuming it contains a string value.
  50.    *
  51.    * @return {String}
  52.    */
  53.   asString() {
  54.     return this.as(Type.STRING).getValue();
  55.   }
  57.   /**
  58.    * Unpacks a Protobuf `Any` assuming it contains an int32 value.
  59.    *
  60.    * @return {Number}
  61.    */
  62.   asInt32() {
  63.     return this.as(Type.INT32).getValue();
  64.   }
  66.   /**
  67.    * Unpacks a Protobuf `Any` assuming it contains an unsigned int32 value.
  68.    *
  69.    * @return {Number}
  70.    */
  71.   asUInt32() {
  72.     return this.as(Type.UINT32).getValue();
  73.   }
  75.   /**
  76.    * Unpacks a Protobuf `Any` assuming it contains an int64 value.
  77.    *
  78.    * @return {Number}
  79.    */
  80.   asInt64() {
  81.     return this.as(Type.INT64).getValue();
  82.   }
  84.   /**
  85.    * Unpacks a Protobuf `Any` assuming it contains an unsigned int64 value.
  86.    *
  87.    * @return {Number}
  88.    */
  89.   asUInt64() {
  90.     return this.as(Type.UINT64).getValue();
  91.   }
  93.   /**
  94.    * Unpacks a Protobuf `Any` assuming it contains a boolean value.
  95.    *
  96.    * @return {boolean}
  97.    */
  98.   asBool() {
  99.     return this.as(Type.BOOL).getValue();
  100.   }
  102.   /**
  103.    * Unpacks a Protobuf `Any` assuming it contains a double value.
  104.    *
  105.    * @return {number}
  106.    */
  107.   asDouble() {
  108.     return this.as(Type.DOUBLE).getValue();
  109.   }
  111.   /**
  112.    * Unpacks a Protobuf `Any` assuming it contains a float value.
  113.    *
  114.    * @return {number}
  115.    */
  116.   asFloat() {
  117.     return this.as(Type.FLOAT).getValue();
  118.   }
  120.   /**
  121.    * Unpacks a Protobuf `Any` assuming it a message of the provided type.
  122.    *
  123.    * @param {!Type} type a type used to deserialize `Any` encompassed in this unpacker
  124.    *
  125.    * @return {Message} a protobuf message wrapped in `Any` deserialized using the provided type
  126.    */
  127.   as(type) {
  128.     return this._any.unpack(type.class().deserializeBinary, type.url().name());
  129.   }
  130. }
  132. /**
  133.  * A packer of string, number, boolean, and message values to Protobuf `Any`.
  134.  */
  135. class Pack {
  136.   /**
  137.    * @param {*} value
  138.    */
  139.   constructor(value) {
  140.     this._value = value;
  141.   }
  143.   /**
  144.    * Packs the encompassed value assuming its of a string type.
  145.    *
  146.    * @return {Any} a new any instance with this packers value
  147.    */
  148.   asString() {
  149.     return Pack._primitive(this._value.toString(), Type.STRING);
  150.   }
  152.   /**
  153.    * Packs the encompassed value assuming its of an int32 type.
  154.    *
  155.    * @return {Any} a new any instance with this packers value
  156.    */
  157.   asInt32() {
  158.     const value = Number(this._value);
  159.     if (isNaN(value)) {
  160.       throw new Error('The value could not be coerced to a number');
  161.     }
  162.     return Pack._primitive(Math.floor(value.valueOf()), Type.INT32);
  163.   }
  165.   /**
  166.    * Packs the encompassed value assuming its of an unsigned int32 type.
  167.    *
  168.    * @return {Any} a new any instance with this packers value
  169.    */
  170.   asUInt32() {
  171.     const value = Number(this._value);
  172.     if (isNaN(value)) {
  173.       throw new Error('The value could not be coerced to a number');
  174.     }
  175.     return Pack._primitive(Math.floor(value.valueOf()), Type.UINT32);
  176.   }
  178.   /**
  179.    * Packs the encompassed value assuming its of an int64 type.
  180.    *
  181.    * @return {Any} a new any instance with this packers value
  182.    */
  183.   asInt64() {
  184.     const value = Number(this._value);
  185.     if (isNaN(value)) {
  186.       throw new Error('The value could not be coerced to a number');
  187.     }
  188.     return Pack._primitive(Math.floor(value.valueOf()), Type.INT64);
  189.   }
  191.   /**
  192.    * Packs the encompassed value assuming its of an unsigned int64 type.
  193.    *
  194.    * @return {Any} a new any instance with this packers value
  195.    */
  196.   asUInt64() {
  197.     const value = Number(this._value);
  198.     if (isNaN(value)) {
  199.       throw new Error('The value could not be coerced to a number');
  200.     }
  201.     return Pack._primitive(Math.floor(value.valueOf()), Type.UINT64);
  202.   }
  204.   /**
  205.    * Packs the encompassed value assuming its of a float type.
  206.    *
  207.    * @return {Any} a new any instance with this packers value
  208.    */
  209.   asFloat() {
  210.     const value = Number(this._value);
  211.     if (isNaN(value)) {
  212.       throw new Error('The value could not be coerced to a number');
  213.     }
  214.     return Pack._primitive(value.valueOf(), Type.FLOAT);
  215.   }
  217.   /**
  218.    * Packs the encompassed value assuming its of a double type.
  219.    *
  220.    * @return {Any} a new any instance with this packers value
  221.    */
  222.   asDouble() {
  223.     const value = Number(this._value);
  224.     if (isNaN(value)) {
  225.       throw new Error('The value could not be coerced to a number');
  226.     }
  227.     return Pack._primitive(value.valueOf(), Type.DOUBLE);
  228.   }
  230.   /**
  231.    * Packs the encompassed value assuming its of a boolean type.
  232.    *
  233.    * @return {Any} a new any instance with this packers value
  234.    */
  235.   asBool() {
  236.     return Pack._primitive(!!this._value, Type.BOOL);
  237.   }
  239.   /**
  240.    * @param {!Type} type a type to pack the value encompassed in this packer to
  241.    *
  242.    * @return {Any} a new any instance with this packers value
  243.    */
  244.   as(type) {
  245.     return Pack._message(this._value, type);
  246.   }
  248.   /**
  249.    * Packs a primitive (number, string, boolean) value to Protobuf `Any`.
  250.    *
  251.    * @param {!number|string|boolean} value a primitive value to pack
  252.    * @param {!Type} type definition of the type to wrap the value
  253.    *
  254.    * @return {Any} a new `Any`
  255.    *
  256.    * @private
  257.    */
  258.   static _primitive(value, type) {
  259.     const wrapper = type.class();
  260.     const message = new wrapper([value]);
  261.     return Pack._message(message, type);
  262.   }
  264.   /**
  265.    * Packs a Protobuf message to Protobuf `Any`.
  266.    *
  267.    * @param {!Message} message a message to be packed into `Any`
  268.    * @param {!Type} type definition of the Message type
  269.    *
  270.    * @return {Any} a new `Any`
  271.    *
  272.    * @private
  273.    */
  274.   static _message(message, type) {
  275.     const typeUrl = type.url();
  276.     const result = new Any();
  277.     const bytes = message.serializeBinary();
  278.     result.pack(bytes, typeUrl.name(), typeUrl.prefix());
  279.     return result;
  280.   }
  281. }
  283. /**
  284.  * Utilities for packing messages into {@link Any} and unpacking them.
  285.  *
  286.  * @example
  287.  * // Packing `TypedMessage` instance:
  288.  * const task = new Task(message, TASK_TYPE);
  289.  * const anyWithTask = AnyPacker.packTyped(task);
  290.  *
  291.  * @example
  292.  * // Packing Protobuf messages:
  293.  * const anyWithTask = AnyPacker.pack(message).as(TASK_TYPE);
  294.  * const task = AnyPacker.unpack(anyWithTask).as(TASK_TYPE);
  295.  *
  296.  * @example
  297.  * // Packing strings:
  298.  * const anyWithString = AnyPacker.pack('Presents get packed too!').asString();
  299.  * console.log(AnyPacker.unpack(anyWithString).asString());
  300.  * // Out: Presents get packed too!
  301.  */
  302. export class AnyPacker {
  304.   /**
  305.    * Instantiation not allowed and will throw an error.
  306.    */
  307.   constructor() {
  308.     throw new Error('Tried instantiating a utility class.');
  309.   }
  311.   /**
  312.    * Creates a new packer for the provided `Any` instance.
  313.    *
  314.    * @example
  315.    * // Unpacking messages:
  316.    * AnyPacker.unpack(anyWithTask).as(TASK_TYPE);
  317.    *
  318.    * @example
  319.    * // Unpacking primitive values:
  320.    * AnyPacker.pack('Presents get packed too!').asString();
  321.    *
  322.    * @param {!Any} any a Protobuf `Any` message to unpack
  323.    *
  324.    * @return {Unpack} an unpacker for the provided `Any` instance
  325.    */
  326.   static unpack(any) {
  327.     return new Unpack(any);
  328.   }
  330.   /**
  331.    * Creates a new packer for the provided value.
  332.    *
  333.    * @example
  334.    * // Packing primitive values:
  335.    * AnyPacker.pack('Presents get packed too!').asString();
  336.    *
  337.    * @example
  338.    * // Packing Protobuf messages:
  339.    * const anyWithTask = AnyPacker.pack(message).as(TASK_TYPE);
  340.    *
  341.    * @param {!*} value a value of
  342.    *
  343.    * @return {Pack}
  344.    */
  345.   static pack(value) {
  346.     return new Pack(value);
  347.   }
  349.   /**
  350.    * Packs a `Message` into a Protobuf `Any`.
  351.    *
  352.    * @param {!Message} message a message to be packed
  353.    *
  354.    * @return {Any} a new Any with the provided message inside
  355.    */
  356.   static packMessage(message) {
  357.     if (!isProtobufMessage(message)) {
  358.       throw new Error('The `Message` type was expected by AnyPacker#packMessage().');
  359.     }
  360.     const typedMessage = TypedMessage.of(message);
  361.     return this.packTyped(typedMessage);
  362.   }
  364.   /**
  365.    * Packs a `TypedMessage` into a Protobuf `Any`.
  366.    *
  367.    * @param {!TypedMessage} message a message to be packed
  368.    *
  369.    * @return {Any} a new Any with the provided typed message inside
  370.    */
  371.   static packTyped(message) {
  372.     if (!(message instanceof TypedMessage)) {
  373.       throw new Error('Only TypedMessage instance can be packed using AnyPacker#packTyped().');
  374.     }
  375.     return new Pack(message.message).as(message.type);
  376.   }
  377. }