feat: default serializer and validator

Author: mopsicus

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.0] - 2024-10-20
+
+### Added
+- Default serializer and validator
+
+### Сhanged
+- Demo updated
+
 ## [1.0.0] - 2023-10-10
 
 ### First release of Shardy

Documentation~/welcome.md

@@ -40,6 +40,9 @@ If your implementation does not need to do a two-step handshake, you can set "st
 
 Your handshake [validator](./reference.md#-ivalidator) class is passed to the [`Client`](./reference.md#-client) constructor as the first parameter, the next is the serializer.
 
+> [!NOTE]
+> You can use the simple built-in `DefaultValidator` validator.
+
 # 🧱 Serializer
 
 Shardy uses a custom serializer for all transmitted data. You can use JSON, MessagePack, Protobuf, FlatBuffers, etc. or your own serializer. You have to create your own serializer class by inheriting the [`Serializer`](./reference.md#-iserializer) class, implement encode/decode methods and pass it to your service and client. The main goal – encode [`PayloadData`](./reference.md#payloaddata) to byte array before sending and back after receiving.
@@ -59,6 +62,9 @@ class MyJsonSerializer : ISerializer {
 }
 ```
 
+> [!NOTE]
+> You can use the simple built-in `DefaultSerializer` serializer.
+
 I have plans to do some tutorials on the most popular serializers for Unity and their use with Shardy. Stay tuned.
 
 > [!IMPORTANT] 

Plugins.meta

@@ -156,6 +156,9 @@ class MyHandshake : IValidator {
 }
 ```
 
+> [!NOTE]
+> You can use the simple built-in `DefaultValidator` validator.
+
 ### Serialization
 
 Shardy supports custom serialization of transmitted data. You can use JSON, MessagePack, Protobuf, FlatBuffers, etc. or your own serializer.
@@ -177,6 +180,9 @@ class MyJsonSerializer : ISerializer {
 }
 ```
 
+> [!NOTE]
+> You can use the simple built-in `DefaultSerializer` serializer.
+
 See [documentation](./Documentation~/index.md) for information on all classes and methods.
 
 # 🧩 Modules

README.md

@@ -156,6 +156,9 @@ class MyHandshake : IValidator {
 }
 ```
 
+> [!NOTE]
+> Вы можете использовать простой встроенный валидатор `DefaultValidator`.
+
 ### Сериализация
 
 Shardy поддерживает пользовательскую сериализацию передаваемых данных. Вы можете использовать JSON, MessagePack, Protobuf, FlatBuffers и т.д. или свой собственный сериализатор.
@@ -177,6 +180,9 @@ class MyJsonSerializer : ISerializer {
 }
 ```
 
+> [!NOTE]
+> Вы можете использовать простой встроенный сериализатор `DefaultSerializer`.
+
 Смотрите [документацию](./Documentation~/index.md) с информацией о всех классах и методах.
 
 # 🧩 Модули

README.ru.md

@@ -73,20 +73,20 @@ public bool IsConnected {
         /// <param name="serializer">Serializer</param>
         /// <param name="options">Client options (optional)</param>
         /// <param name="handshake">Handshake after connect (optional)</param>
-        public Client(IValidator validator, ISerializer serializer, ClientOptions options = null, byte[] handshake = null) {
+        public Client(IValidator validator = null, ISerializer serializer = null, ClientOptions options = null, byte[] handshake = null) {
 #if UNITY_WEBGL && !UNITY_EDITOR
             WebSocketManager.Init();
 #if SHARDY_DEBUG_RAW
             WebSocketManager.SetDebug(true);
 #endif
 #endif
-            _validator = validator;
-            _serializer = serializer;
+            _validator = validator ?? new DefaultValidator();
+            _serializer = serializer ?? new DefaultSerializer();
             _options = options ?? new ClientOptions();
             _handshake = handshake;
 #if UNITY_WEBGL && !UNITY_EDITOR
             if (_options.Type == TransportType.Tcp) {
-                Logger.Error($"Unable to use TCP transport for WebGL", TAG);
+                Logger.Error($"unable to use TCP transport for WebGL", TAG);
                 return;
             }
 #endif
@@ -231,4 +231,4 @@ public void Destroy() {
             _commander.Destroy();
         }
     }
-}
+}

Runtime/Client.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Text;
+using UnityEngine;
+
+namespace Shardy {
+
+    /// <summary>
+    /// Default serializer
+    /// </summary>
+    public class DefaultSerializer : ISerializer {
+
+        /// <summary>
+        /// DTO for serialization
+        /// </summary>
+        [Serializable]
+        class PayloadDTO {
+
+            /// <summary>
+            /// Type of data
+            /// </summary>        
+            public int Type;
+
+            /// <summary>
+            /// Command or request name
+            /// </summary>        
+            public string Name;
+
+            /// <summary>
+            /// Request id
+            /// </summary>        
+            public int Id;
+
+            /// <summary>
+            /// Data
+            /// </summary>
+            public string Data;
+
+            /// <summary>
+            /// Error message or code
+            /// </summary>        
+            public string Error;
+        }
+
+        /// <summary>
+        /// Serialize data to byte array
+        /// </summary>
+        /// <param name="body">Target data</param>
+        /// <returns>Encoded data</returns>    
+        public byte[] Encode(PayloadData body) {
+            var dto = new PayloadDTO { Type = (int)body.Type, Name = body.Name, Id = body.Id, Data = body.Data != null ? Convert.ToBase64String(body.Data) : null, Error = body.Error };
+            var json = JsonUtility.ToJson(dto);
+            return Encoding.UTF8.GetBytes(Utils.ChangeKeysCase(json, false));
+        }
+
+        /// <summary>
+        /// Deserialize data
+        /// </summary>
+        /// <param name="body">Encoded data</param>
+        /// <returns>Data to use</returns>
+        public PayloadData Decode(byte[] body) {
+            var json = Encoding.UTF8.GetString(body);
+            var dto = JsonUtility.FromJson<PayloadDTO>(Utils.ChangeKeysCase(json, true));
+            return new PayloadData((PayloadType)dto.Type, dto.Name, dto.Id, string.IsNullOrEmpty(dto.Data) ? null : Convert.FromBase64String(dto.Data), dto.Error);
+        }
+    }
+}

Runtime/DefaultSerializer.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Text;
+using UnityEngine;
+
+namespace Shardy {
+
+    /// <summary>
+    /// Default serializer
+    /// </summary>
+    public class DefaultValidator : IValidator {
+
+        /// <summary>
+        /// DTO for handshake
+        /// </summary>
+        [Serializable]
+        class HandshakeDTO {
+
+            /// <summary>
+            /// Handshake version
+            /// </summary>
+            public int Version;
+
+            /// <summary>
+            /// Timestamp of handshake
+            /// </summary>
+            public long Timestamp;
+
+            /// <summary>
+            /// Nonce for handshake
+            /// </summary>
+            public string Nonce;
+
+            /// <summary>
+            /// Custom data for handshake
+            /// </summary>
+            public string Payload;
+        }
+
+        /// <summary>
+        /// DTO for acknowledgement
+        /// </summary>
+        [Serializable]
+        class AcknowledgementDTO {
+
+            /// <summary>
+            /// Received flag
+            /// </summary>
+            public bool Received;
+
+            /// <summary>
+            /// Nonce for acknowledgement
+            /// </summary>
+            public string Nonce;
+        }
+
+        /// <summary>
+        /// Get handshake data for send
+        /// </summary>
+        /// <param name="body">Data for handshake</param>
+        /// <returns>Data for handshake</returns>
+        public byte[] Handshake(byte[] body = null) {
+            var handshake = new HandshakeDTO { Version = 1, Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), Nonce = Guid.NewGuid().ToString("N"), Payload = body != null ? Encoding.UTF8.GetString(body) : null };
+            var json = JsonUtility.ToJson(handshake);
+            return Encoding.UTF8.GetBytes(Utils.ChangeKeysCase(json, false));
+        }
+
+        /// <summary>
+        /// Get acknowledgement data for send
+        /// </summary>
+        /// <param name="body">Data from handshake</param>
+        /// <returns>Data for acknowledge</returns>
+        public byte[] Acknowledgement(byte[] body) {
+            var json = Encoding.UTF8.GetString(body);
+            var handshake = JsonUtility.FromJson<HandshakeDTO>(Utils.ChangeKeysCase(json, true));
+            var ack = new AcknowledgementDTO { Received = true, Nonce = handshake.Nonce };
+            return Encoding.UTF8.GetBytes(Utils.ChangeKeysCase(JsonUtility.ToJson(ack), false));
+        }
+
+        /// <summary>
+        /// Validate acknowledgement data
+        /// </summary>
+        /// <param name="body">Data for validate</param>
+        /// <returns>Validation result</returns>
+        public ValidatorState VerifyAcknowledgement(byte[] body) {
+            var json = Encoding.UTF8.GetString(body);
+            var ack = JsonUtility.FromJson<AcknowledgementDTO>(Utils.ChangeKeysCase(json, true));
+            if (!string.IsNullOrEmpty(ack.Nonce)) {
+                return ValidatorState.Success;
+            }
+            return ValidatorState.Failed;
+        }
+    }
+}