@ekhein/lamda-node-sdk 2.1.7 → 2.1.8

package/dist/main.d.ts

@@ -34,14 +34,14 @@ export declare class Device {
     }): Promise<any>;
 }
 export declare class Storage {
-    private readonly container;
     private readonly $;
-    constructor(container: string, $: Device);
+    private readonly container;
+    constructor($: Device, container: string);
     set(key: string, data: any): Promise<boolean>;
     setex(key: string, data: any, ttl: number): Promise<boolean>;
     setnx(key: string, data: any): Promise<boolean>;
     expire(key: string, ttl: number): Promise<boolean>;
-    get<T = any>(key: string, defaultValue?: any): Promise<T>;
+    get<T = any>(key: string, defaultValue?: T): Promise<T>;
     ttl(key: string): Promise<number>;
     exists(key: string): Promise<boolean>;
     delete(key: string): Promise<boolean>;

package/dist/main.js

@@ -155,63 +155,70 @@ __decorate([
     __metadata("design:type", Object)
 ], Device.prototype, "Settings", void 0);
 class Storage {
-    container;
     $;
-    constructor(container, $) {
-        this.container = container;
+    container;
+    constructor($, container) {
         this.$ = $;
+        this.container = container;
+        for (const method in $.Storage) {
+            if (method != "clearAll") {
+                const origin = $.Storage[method];
+                $.Storage[method] = function (params) {
+                    Object.assign(params, { container });
+                    return origin.call(this, params);
+                };
+            }
+        }
     }
     async set(key, data) {
         const value = (0, msgpackr_1.pack)(data);
-        return this.$.Storage
-            .set({ container: this.container, key, value })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .set({ key, value });
+        return result.value;
     }
     async setex(key, data, ttl) {
         const value = (0, msgpackr_1.pack)(data);
-        return this.$.Storage
-            .setex({ container: this.container, key, value, ttl })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .setex({ key, value, ttl });
+        return result.value;
     }
     async setnx(key, data) {
         const value = (0, msgpackr_1.pack)(data);
-        return this.$.Storage
-            .setnx({ container: this.container, key, value })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .setnx({ key, value });
+        return result.value;
     }
     async expire(key, ttl) {
-        return this.$.Storage
-            .expire({ container: this.container, key, ttl })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .expire({ key, ttl });
+        return result.value;
     }
     async get(key, defaultValue) {
-        return this.$.Storage
-            .get({ container: this.container, key })
-            .then(async (r) => {
-            if (r.value.length)
-                return (0, msgpackr_1.unpack)(r.value);
+        const result = await this.$.Storage
+            .get({ key });
+        if (result.value.length == 0)
             return defaultValue;
-        });
+        return (0, msgpackr_1.unpack)(result.value);
     }
     async ttl(key) {
-        return this.$.Storage
-            .ttl({ container: this.container, key })
-            .then(r => r.value);
+        const result = await this.$.Storage
+            .ttl({ key });
+        return result.value;
     }
     async exists(key) {
-        return this.$.Storage
-            .exists({ container: this.container, key })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .exists({ key });
+        return result.value;
     }
     async delete(key) {
-        return this.$.Storage
-            .delete({ container: this.container, key })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .delete({ key });
+        return result.value;
     }
     async clear() {
-        return this.$.Storage
-            .clearContainer({ container: this.container })
-            .then(async (r) => r.value);
+        const result = await this.$.Storage
+            .clearContainer({ container: this.container });
+        return result.value;
     }
 }
 exports.Storage = Storage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekhein/lamda-node-sdk",
-  "version": "2.1.7",
+  "version": "2.1.8",
   "author": "ekhein",
   "license": "MIT",
   "main": "./dist/main.js",