Creating CommandBuilders (#42)

* Creating ExecuteInTransaction function

* test cpmmit

* Add SerializedCommands & BloomSerializer

* Creating ExecuteInTransaction function

* test cpmmit

* Add SerializedCommands & BloomSerializer

* Fix SerializedCommand

* Add CmsCommandBuilder

* Naming

* Add CuckooCommndBuilder

* Add TdigestCommndBuilder

* Add TopKCommandBuilder

* Add JsonCommandBuilder

* Add SearchCommandBuilder

* Fix Tests

* Add TimeSeriesCommandBuilder

* Remove Unessesary using

* Connecting GraphCommands to the documentation of the interface

* Add GraphCommandBuilder

* Update Version to 0.4.0

* Writing README

* update words to ignore

Author: shacharPash

Diff for: .github/wordlist.txt

@@ -4,3 +4,8 @@ github
 yml
 Codecov
 pre
+OSS
+Json
+json
+TimeSeries
+NuGet

Diff for: README.md

@@ -14,3 +14,52 @@ This project builds on [StackExchange.Redis](https://github.com/StackExchange/St
 ## API
 
 The complete documentation for Redis  module commands can be found at the [Redis commands website](https://redis.io/commands/).
+
+### Redis OSS commands
+You can use Redis OSS commands in the same way as you use them in [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis).
+
+### Modules Commands
+Each module has a command class with its own commands.
+The supported modules are: [Search](https://redis.io/commands/?group=search), [Json](https://redis.io/commands/?group=json), [Graph](https://redis.io/commands/?group=graph), [TimeSeries](https://redis.io/commands/?group=timeseries), [Bloom Filter](https://redis.io/commands/?group=bf), [Cuckoo Filter](https://redis.io/commands/?group=cf), [T-Digest](https://redis.io/commands/?group=tdigest), [Count-min Sketch](https://redis.io/commands/?group=cms) and [Top-K](https://redis.io/commands/?group=topk).
+
+# Usage
+
+First, you need to connect to Redis, exactly the same way you do it in [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis):
+```csharp
+using StackExchange.Redis;
+...
+ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
+```
+Now you can create a variable from any type of module in the following way:
+```csharp
+IBloomCommands bf = db.BF();
+ICuckooCommands cf = db.CF();
+ICmsCommands cms = db.CMS();
+IGraphCommands graph = db.GRAPH();
+ITopKCommands topk = db.TOPK();
+ITdigestCommands tdigest = db.TDIGEST();
+ISearchCommands ft = db.FT();
+IJsonCommands json = db.JSON();
+ITimeSeriesCommands ts = db.TS();
+```
+Then, that variable will allow you to call all the commands of that module.
+## Basic Example
+Set a json object to Redis:
+```csharp
+ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
+IDatabase db = redis.GetDatabase();
+
+IJsonCommands json = db.JSON();
+var key = "myKey";
+json.Set(key, "$", new Person() { Age = 35, Name = "Alice" });
+```
+
+------
+
+### Author
+
+NRedisStack is developed and maintained by [Redis Inc](https://redis.com). It can be found [here](
+https://github.com/redis/NRedisStack), or downloaded from [NuGet](https://www.nuget.org/packages/NRedisStack).
+
+[![Redis](./docs/logo-redis.png)](https://www.redis.com)
+

Diff for: src/NRedisStack/Auxiliary.cs

@@ -1,3 +1,4 @@
+using NRedisStack.RedisStackCommands;
 using StackExchange.Redis;
 
 namespace NRedisStack
@@ -24,5 +25,15 @@ public static object[] AssembleNonNullArguments(params object?[] arguments)
 
             return args.ToArray();
         }
+
+        public static RedisResult Execute(this IDatabase db, SerializedCommand command)
+        {
+            return db.Execute(command.Command, command.Args);
+        }
+
+        public async static Task<RedisResult> ExecuteAsync(this IDatabase db, SerializedCommand command)
+        {
+            return await db.ExecuteAsync(command.Command, command.Args);
+        }
     }
 }

Diff for: src/NRedisStack/Bloom/BloomCommandBuilder.cs

@@ -0,0 +1,95 @@
+using NRedisStack.Literals;
+using NRedisStack.RedisStackCommands;
+using StackExchange.Redis;
+namespace NRedisStack
+{
+
+    public static class BloomCommandBuilder
+    {
+        public static SerializedCommand Add(RedisKey key, RedisValue item)
+        {
+            return new SerializedCommand(BF.ADD, key, item);
+        }
+
+        public static SerializedCommand Exists(RedisKey key, RedisValue item)
+        {
+            return new SerializedCommand(BF.EXISTS, key, item);
+        }
+
+        public static SerializedCommand Info(RedisKey key)
+        {
+            return new SerializedCommand(BF.INFO, key);
+        }
+
+        public static SerializedCommand Insert(RedisKey key, RedisValue[] items, int? capacity = null,
+                                               double? error = null, int? expansion = null,
+                                               bool nocreate = false, bool nonscaling = false)
+        {
+            if (items.Length < 1)
+                throw new ArgumentOutOfRangeException(nameof(items));
+
+            var args = BloomAux.BuildInsertArgs(key, items, capacity, error, expansion, nocreate, nonscaling);
+
+            return new SerializedCommand(BF.INSERT, args);
+        }
+
+        public static SerializedCommand LoadChunk(RedisKey key, long iterator, Byte[] data)
+        {
+            return new SerializedCommand(BF.LOADCHUNK, key, iterator, data);
+        }
+
+        public static SerializedCommand MAdd(RedisKey key, params RedisValue[] items)
+        {
+            if (items.Length < 1)
+                throw new ArgumentOutOfRangeException(nameof(items));
+
+            List<object> args = new List<object> { key };
+
+            foreach (var item in items)
+            {
+                args.Add(item);
+            }
+
+            return new SerializedCommand(BF.MADD, args);
+        }
+
+        public static SerializedCommand MExists(RedisKey key, RedisValue[] items)
+        {
+            if (items.Length < 1)
+                throw new ArgumentOutOfRangeException(nameof(items));
+
+            List<object> args = new List<object> { key };
+
+            foreach (var item in items)
+            {
+                args.Add(item);
+            }
+
+            return new SerializedCommand(BF.MEXISTS, args);
+
+        }
+
+        public static SerializedCommand Reserve(RedisKey key, double errorRate, long capacity,
+                                                int? expansion = null, bool nonscaling = false)
+        {
+            List<object> args = new List<object> { key, errorRate, capacity };
+
+            if (expansion != null)
+            {
+                args.Add(expansion);
+            }
+
+            if (nonscaling)
+            {
+                args.Add(BloomArgs.NONSCALING);
+            }
+
+            return new SerializedCommand(BF.RESERVE, args);
+        }
+
+        public static SerializedCommand ScanDump(RedisKey key, long iterator)
+        {
+            return new SerializedCommand(BF.SCANDUMP, key, iterator);
+        }
+    }
+}