Source: client/typed-message.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 base64 from 'base64-js';
  31. import {
  32.   BoolValue,
  33.   DoubleValue,
  34.   FloatValue,
  35.   Int32Value,
  36.   Int64Value,
  37.   StringValue,
  38.   UInt32Value,
  39.   UInt64Value,
  40. } from '../proto/google/protobuf/wrappers_pb';
  41. import {convertDateToTimestamp} from './time-utils';
  42. import KnownTypes from './known-types';
  44. /**
  45.  * Checks if the object extends {@link Message}.
  46.  *
  47.  * <p>The implementation doesn't use `instanceof` check and check on prototypes
  48.  * since they may fail if different versions of the file are used at the same time
  49.  * (e.g. bundled and the original one).
  50.  *
  51.  * @param object the object to check
  52.  */
  53. export function isProtobufMessage(object) {
  54.   return typeof object.constructor.typeUrl === 'function';
  55. }
  57. /**
  58.  * A URL of a Protobuf type.
  59.  *
  60.  * Consists of the two parts separated with a slash. The first part is
  61.  * the type URL prefix (for example, `type.googleapis.com`).
  62.  * The second part is a fully-qualified Protobuf type name.
  63.  *
  64.  * @template <T>
  65.  */
  66. export class TypeUrl {
  68.   /**
  69.    * Creates a new instance of TypeUrl from the given string value.
  70.    *
  71.    * The value should be a valid type URL of format:
  72.    * (typeUrlPrefix)/(typeName)
  73.    *
  74.    * @param {!string} value the type URL value
  75.    */
  76.   constructor(value) {
  77.     const urlParts = value.split('/');
  78.     this._value = value;
  79.     this._prefix = urlParts[0];
  80.     this._name = urlParts[1];
  81.   }
  83.   /**
  84.    * @return {string} part of the type URL before `/` specifying a namespace
  85.    */
  86.   prefix() {
  87.     return this._prefix;
  88.   }
  90.   /**
  91.    * @return {string} part of the type URL after `/` specifying the type name
  92.    */
  93.   name() {
  94.     return this._name;
  95.   }
  97.   /**
  98.    * @return {!string} full type URL value formatted as `<prefix>/<name>` string
  99.    */
  100.   value() {
  101.     return this._value;
  102.   }
  103. }
  105. /**
  106.  * A type of the Protobuf message represented by its JavaScript class and type URL.
  107.  *
  108.  * @template <T>
  109.  */
  110. export class Type {
  112.   /**
  113.    * @param {!Class<T>} cls a class of the `Message` type is for
  114.    * @param {!TypeUrl<T>} typeUrl a type URL of the `Message` type is for
  115.    */
  116.   constructor(cls, typeUrl) {
  117.     this._cls = cls;
  118.     this._typeUrl = typeUrl;
  119.   }
  121.   /**
  122.    * @return {!TypeUrl<T>} a type URL of a defined type
  123.    */
  124.   url() {
  125.     return this._typeUrl;
  126.   }
  128.   /**
  129.    * @return {!Class<T>} a JS class of a defined type
  130.    */
  131.   class() {
  132.     return this._cls;
  133.   }
  135.   /**
  136.    * A static factory for creating Type instances from `Message` class and type URL.
  137.    *
  138.    * @param {!Class<T>} cls a class of the `Message` type is for
  139.    * @param {!string|TypeUrl<T>} typeUrl a type URL of the `Message` type is for
  140.    *
  141.    * @return {Type<T>} new Type instance
  142.    */
  143.   static of(cls, typeUrl) {
  144.     if (!(typeUrl instanceof TypeUrl)) {
  145.       typeUrl = new TypeUrl(typeUrl);
  146.     }
  147.     return new Type(cls, typeUrl);
  148.   }
  150.   /**
  151.    * Creates a new `Type` for the passed `Message` class.
  152.    *
  153.    * @param cls {!Class<T>} cls a class of the `Message`
  154.    */
  155.   static forClass(cls) {
  156.     const typeUrl = KnownTypes.typeUrlFor(cls);
  157.     return this.of(cls, typeUrl);
  158.   }
  160.   /**
  161.    * Creates a new `Type` for the passed `Message`.
  162.    *
  163.    * @param {!Message} message a Protobuf message
  164.    */
  165.   static forMessage(message) {
  166.     return this.forClass(message.constructor);
  167.   }
  168. }
  170. // PRIMITIVE WRAPPERS
  171. Type.STRING = Type.forClass(StringValue);
  172. Type.INT32 = Type.forClass(Int32Value);
  173. Type.UINT32 = Type.forClass(UInt32Value);
  174. Type.INT64 = Type.forClass(Int64Value);
  175. Type.UINT64 = Type.forClass(UInt64Value);
  176. Type.BOOL = Type.forClass(BoolValue);
  177. Type.DOUBLE = Type.forClass(DoubleValue);
  178. Type.FLOAT = Type.forClass(FloatValue);
  180. /**
  181.  * A Protobuf message with a {@link TypeUrl}.
  182.  *
  183.  * The type URL specifies the type of the associated message.
  184.  *
  185.  * @template <T>
  186.  */
  187. export class TypedMessage {
  189.   /**
  190.    * Creates a new instance of TypedMessage from the given Protobuf message and
  191.    * type URL.
  192.    *
  193.    * @param {!Message} message a Protobuf message
  194.    * @param {!Type<T>} type a Protobuf type of the message
  195.    */
  196.   constructor(message, type) {
  197.     this.message = message;
  198.     this.type = type;
  199.   }
  201.   /**
  202.    * Creates a new instance of TypedMessage from the given Protobuf message.
  203.    *
  204.    * @param {!Message} message a Protobuf message
  205.    * @returns {!TypedMessage} the created typed message
  206.    */
  207.   static of(message) {
  208.     const type = Type.forMessage(message);
  209.     return new TypedMessage(message, type);
  210.   }
  212.   /**
  213.    * Converts this message into a Base64-encoded byte string.
  214.    *
  215.    * @return the string representing this message
  216.    */
  217.   toBase64() {
  218.     const bytes = this.message.serializeBinary();
  219.     return base64.fromByteArray(bytes);
  220.   }
  222.   /**
  223.    * Creates a new `TypedMessage` wrapping a string.
  224.    *
  225.    * @param {!String} value a string value for `TypedMessage`
  226.    * @return {TypedMessage<StringValue>} a new `TypedMessage` instance with provided value
  227.    */
  228.   static string(value) {
  229.     const message = new StringValue([value.toString()]);
  230.     return TypedMessage.of(message);
  231.   }
  233.   /**
  234.    * Creates a new `TypedMessage` with a 32-bit integer value.
  235.    *
  236.    * The number gets floored if the provided value contains a floating point.
  237.    *
  238.    * @param {!number|Number} value a number value for `TypedMessage`
  239.    * @return {TypedMessage<Int32Value>} a new `TypedMessage` instance with provided value
  240.    */
  241.   static int32(value) {
  242.     const message = new Int32Value([Math.floor(value.valueOf())]);
  243.     return TypedMessage.of(message);
  244.   }
  246.   /**
  247.    * Creates a new `TypedMessage` with an unsigned 32-bit integer value.
  248.    *
  249.    * The number gets floored if the provided value contains a floating point.
  250.    *
  251.    * @param {!number|Number} value a number value for `TypedMessage`
  252.    * @return {TypedMessage<UInt32Value>} a new `TypedMessage` instance with provided value
  253.    */
  254.   static uint32(value) {
  255.     const message = new UInt32Value([Math.floor(value.valueOf())]);
  256.     return TypedMessage.of(message);
  257.   }
  259.   /**
  260.    * Creates a new `TypedMessage` with a 64-bit integer value.
  261.    *
  262.    * The number gets floored if the provided value contains a floating point.
  263.    *
  264.    * @param {!number|Number} value a number value for `TypedMessage`
  265.    * @return {TypedMessage<Int64Value>} a new `TypedMessage` instance with provided value
  266.    */
  267.   static int64(value) {
  268.     const message = new Int64Value([Math.floor(value.valueOf())]);
  269.     return TypedMessage.of(message);
  270.   }
  272.   /**
  273.    * Creates a new `TypedMessage` with an unsigned 64-bit integer value.
  274.    *
  275.    * The number gets floored if the provided value contains a floating point.
  276.    *
  277.    * @param {!number|Number} value a number value for `TypedMessage`
  278.    * @return {TypedMessage<UInt64Value>} a new `TypedMessage` instance with provided value
  279.    */
  280.   static uint64(value) {
  281.     const message = new UInt64Value([Math.floor(value.valueOf())]);
  282.     return TypedMessage.of(message);
  283.   }
  285.   /**
  286.    * Creates a new `TypedMessage` with a float value.
  287.    *
  288.    * @param {!number|Number} value a number value for `TypedMessage`
  289.    * @return {TypedMessage<FloatValue>} a new `TypedMessage` instance with provided value
  290.    */
  291.   static float(value) {
  292.     const message = new FloatValue([value.valueOf()]);
  293.     return TypedMessage.of(message);
  294.   }
  296.   /**
  297.    * Creates a new `TypedMessage` with a double value.
  298.    *
  299.    * @param {!number|Number} value a number value for `TypedMessage`
  300.    * @return {TypedMessage<DoubleValue>} a new `TypedMessage` instance with provided value
  301.    */
  302.   static double(value) {
  303.     const message = new DoubleValue([value.valueOf()]);
  304.     return TypedMessage.of(message);
  305.   }
  307.   /**
  308.    * Creates a new `TypedMessage` with a boolean value.
  309.    *
  310.    * @param {!boolean|Boolean} value `true` or `false` value for the `TypedMessage`
  311.    * @return {TypedMessage<BoolValue>} a new `TypedMessage` instance with provided value
  312.    */
  313.   static bool(value) {
  314.     const message = new BoolValue([value]);
  315.     return TypedMessage.of(message);
  316.   }
  318.   /**
  319.    * Creates a new `TypedMessage` with a timestamp value composed from the given JavaScript date.
  320.    *
  321.    * @param {!Date} date a JavaScript `Date` value
  322.    * @return {TypedMessage<Timestamp>} a new `TypedMessage` instance with provided value
  323.    */
  324.   static timestamp(date) {
  325.     const message = convertDateToTimestamp(date);
  326.     return TypedMessage.of(message);
  327.   }
  328. }