new appolo

lib/store.ts

@@ -124,8 +124,16 @@ export class Store<T extends { [index: string]: any }> {
         return this._client.stateAt(index);
     }
 
+    public async set<K extends string & keyof T>(key: K, value: T[K], options?: SetStateOptions): Promise<T> {
 
-    public async setState(value: Partial<T> | T, options?: SetStateOptions) {
+        let dto: Partial<T> = {};
+
+        dto[key] = value;
+
+        return this.setState(dto, options);
+    }
+
+    public async setState(value: Partial<T> | T, options?: SetStateOptions): Promise<T> {
 
         if (!options) {
             options = SetStateDefaults
@@ -147,6 +155,8 @@ export class Store<T extends { [index: string]: any }> {
 
         this._isLocked = false;
 
+        return state
+
     }
 
     public async increment(path: string, inc: number): Promise<void> {
@@ -209,9 +219,6 @@ export class Store<T extends { [index: string]: any }> {
 
     }
 
-    public async publish(name: string, data: any) {
-        await this._client.publish(name, data)
-    }
 
     public async quit() {
         clearTimeout(this._lockedInterval);

package.json

@@ -18,7 +18,7 @@
     "test": "mocha test  --timeout 5000 --exit"
   },
   "main": "./index.js",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "license": "MIT",
   "repository": {
     "type": "git",

test/unit.ts

@@ -1,5 +1,5 @@
 import chai = require("chai");
-import { IOptions, Store} from "../index"
+import {IOptions, Store} from "../index"
 import {transaction} from "../lib/decorators";
 
 let should = chai.should();
@@ -56,6 +56,15 @@ describe("State", () => {
 
     });
 
+    it.only("Should  set state with set", async () => {
+
+
+        await store.set("counter", 1);
+
+        (await store.getState()).counter.should.be.eq(1);
+
+    });
+
 
     it("Should  set state multi store", async () => {
 
@@ -332,15 +341,15 @@ describe("State", () => {
 
     it("Should merge state", async () => {
 
-        class TempStore extends Store<{item: {item3?: number,item2?: number}}> {
+        class TempStore extends Store<{ item: { item3?: number, item2?: number } }> {
 
             constructor(options: IOptions) {
                 super();
                 this.setInitialState({item: {item2: 1}})
-                this.setOptions({...options,...{name:"TempStore"}})
+                this.setOptions({...options, ...{name: "TempStore"}})
             }
 
-            async setCounter(value:number) {
+            async setCounter(value: number) {
                 await this.setState({item: {item3: value}});
             }
         }
@@ -351,16 +360,15 @@ describe("State", () => {
         await store.reset()
 
 
-       await store.setCounter(5);
+        await store.setCounter(5);
 
-         store.setCounter(5);
+        store.setCounter(5);
 
         let {state} = await store.once("item")
 
         state.item.item3.should.be.eq(5);
 
 
-
     });
 
     it("Should setState concurrent", async () => {
@@ -387,9 +395,9 @@ describe("State", () => {
     it("Should lock concurrent", async () => {
 
         let store2 = await new Store<{ counter: number }>().setInitialState({counter: 0}).setOptions(RedisParams).initialize();
-        let store3 = await new Store<{ counter: number }>().setInitialState({counter: 0}).setOptions( RedisParams).initialize();
+        let store3 = await new Store<{ counter: number }>().setInitialState({counter: 0}).setOptions(RedisParams).initialize();
 
-        function inc(store: Store<{ counter: number }>):Promise<void> {
+        function inc(store: Store<{ counter: number }>): Promise<void> {
             return new Promise(async (resolve, reject) => {
 
                 let state = await store.lock();
@@ -418,7 +426,7 @@ describe("State", () => {
 
     it("Should multi lock concurrent", async () => {
 
-        function inc(store: Store<{ counter: number }>):Promise<void> {
+        function inc(store: Store<{ counter: number }>): Promise<void> {
             return new Promise(async (resolve, reject) => {
 
                 let state = await store.lock();
@@ -448,7 +456,6 @@ describe("State", () => {
         let store3 = await new Store<{ counter: number }>().setInitialState({counter: 0}).setOptions(RedisParams).initialize();
 
 
-
         await Promise.all([
             store.increment("counter", 1), store3.increment("counter", 2), store2.increment("counter", 3)]);