Fix file provider cache name & removed useless await

src/Consumers/Cache.ts

@@ -8,7 +8,7 @@ class Cache implements CacheInterface {
 
   public async get(name: string): Promise<any> {
     if (name) {
-      return await this.cacheService.get(name)
+      return this.cacheService.get(name)
     }
     throw new Error('Specify a name')
   }
@@ -20,7 +20,7 @@ class Cache implements CacheInterface {
 
   public async set(name: string, data: any, minutes: number): Promise<any> {
     if (name && data) {
-      return await this.cacheService.set(name, data, minutes)
+      return this.cacheService.set(name, data, minutes)
     }
     throw new Error('Specify a name and data to cache')
   }
@@ -36,13 +36,13 @@ class Cache implements CacheInterface {
   public async update(name: string, data: any, minutes: number = 0): Promise<any> {
     if (await this.has(name)) {
       await this.delete(name)
-      return await this.set(name, data, minutes)
-    } else return await this.set(name, data, minutes)
+      return this.set(name, data, minutes)
+    } else return this.set(name, data, minutes)
   }
 
   public async remember(name: string, minutes: number, callback: Function): Promise<any> {
     if (await this.has(name)) {
-      return await this.get(name)
+      return this.get(name)
     } else {
       const data = await callback()
       await this.set(name, data, minutes)
@@ -52,7 +52,7 @@ class Cache implements CacheInterface {
 
   public async rememberForever(name: string, callback: Function): Promise<any> {
     if (await this.has(name)) {
-      return await this.get(name)
+      return this.get(name)
     } else {
       const data = await callback()
       await this.cacheService.set(name, data)
@@ -77,12 +77,12 @@ class Cache implements CacheInterface {
   }
 
   public async flush(): Promise<void> {
-    return await this.cacheService.flush()
+    return this.cacheService.flush()
   }
 
   public async forever(key: string, values: any): Promise<any> {
     if (key && values) {
-      return await this.cacheService.set(key, values)
+      return this.cacheService.set(key, values)
     }
     throw new Error('Specify a name and data to cache')
   }

src/Engines/FileCache.ts

@@ -33,13 +33,13 @@ class FileCache implements EngineInterface {
     !fs.existsSync(path) && fs.mkdirSync(path, { recursive: true })
   }
 
-  private write(key: string, data: any) {
+  private async write(key: string, data: any) {
     this.ensureCacheDirectoryExists(this.path())
 
-    fs.writeFileSync(this.path() + '/' + '_' + this.hashKey(key), data, 'binary')
+    fs.writeFileSync(this.path() + '/' + '_' + (await this.hashKey(key) ), data, 'binary')
   }
 
-  private writeWithTime(key: string, data: any, duration: number) {
+  private async writeWithTime(key: string, data: any, duration: number) {
     this.ensureCacheDirectoryExists(this.path())
     const currentDate = new Date()
     const futureDate = new Date(currentDate.getTime() + duration * 60000)
@@ -52,15 +52,15 @@ class FileCache implements EngineInterface {
     newArr['data'] = data
 
     fs.writeFileSync(
-      this.path() + '/' + this.hashKey(key) + '.cache',
+      this.path() + '/' + (await this.hashKey(key) ) + '.cache',
       JSON.stringify(newArr),
       'binary'
     )
   }
 
-  private read(key: string): any {
+  private async read(key: string): any {
     const data = JSON.parse(
-      fs.readFileSync(this.path() + '/' + this.hashKey(key) + '.cache', 'binary')
+      fs.readFileSync(this.path() + '/' + (await this.hashKey(key) ) + '.cache', 'binary')
     )
 
     if (data['meta']) {
@@ -107,20 +107,20 @@ class FileCache implements EngineInterface {
     return this.deleteFIle(key)
   }
 
-  private hashKey(key: string) {
+  private async hashKey(key: string) {
     return this.hash.make(key + '')
   }
 
   private async isCacheExist(key: string): Promise<Boolean> {
     const path = this.path()
-    return fs.existsSync(path + '/' + this.hashKey(key) + '.cache')
+    return fs.existsSync(path + '/' + ( await this.hashKey(key) ) + '.cache')
   }
 
   private async deleteFIle(key: string): Promise<Boolean> {
     try {
       if (await this.isCacheExist(key)) {
         const path = this.path()
-        fs.unlinkSync(path + '/' + this.hashKey(key) + '.cache')
+        fs.unlinkSync(path + '/' + ( await this.hashKey(key) ) + '.cache')
         return true
       }
       return false

src/Engines/RedisCache.ts

@@ -69,9 +69,9 @@ class RedisCache implements EngineInterface {
   public async set(name: string, data: any, duration: number): Promise<any> {
     if (name && data) {
       if (duration === 0) {
-        return await this._addCache(name, data)
+        return this._addCache(name, data)
       }
-      return await this._addExpiredCache(name, data, duration)
+      return this._addExpiredCache(name, data, duration)
     }
   }
 

src/Services/DatabaseCacheService.ts

@@ -26,7 +26,7 @@ class DatabaseCacheService extends DatabaseCache implements ServiceInterface {
   public async set(name: string, data: any, duration: number): Promise<any> {
     if (name && data) {
       data = JSON.stringify(data)
-      return await super.set(name, data, duration)
+      return super.set(name, data, duration)
       //   if (duration == null) {
       //     return await this._addCache(name, data);
       //   }
@@ -44,13 +44,13 @@ class DatabaseCacheService extends DatabaseCache implements ServiceInterface {
 
   public async update(name: string, data: any, duration: number): Promise<any> {
     if (await this.delete(name)) {
-      return await this.set(name, data, duration)
-    } else return await this.set(name, data, duration)
+      return this.set(name, data, duration)
+    } else return this.set(name, data, duration)
   }
 
   public async remember(name: string, duration: number, callback: Function): Promise<any> {
     if (await this.has(name)) {
-      return await this.get(name)
+      return this.get(name)
     } else {
       const data = await callback()
       await this.set(name, data, duration)
@@ -60,7 +60,7 @@ class DatabaseCacheService extends DatabaseCache implements ServiceInterface {
 
   public async rememberForever(name: string, callback: Function): Promise<any> {
     if (await this.has(name)) {
-      return await this.get(name)
+      return this.get(name)
     } else {
       const data = await callback()
       await this.set(name, data, 50000000000000)

src/Services/FileCacheService.ts

@@ -23,7 +23,7 @@ class FileCacheService extends FileCache implements ServiceInterface {
 
   public async set(name: string, data: any, duration: number = 0): Promise<any> {
     if (name && data) {
-      return await super.set(name, this.serialize(data), duration)
+      return super.set(name, this.serialize(data), duration)
     }
   }
 
@@ -36,13 +36,13 @@ class FileCacheService extends FileCache implements ServiceInterface {
   }
 
   public async flush(): Promise<void> {
-    return await super.flush()
+    return super.flush()
   }
 
   public async update(name: string, data: any, duration: number): Promise<any> {
     if (await this.delete(name)) {
-      return await this.set(name, data, duration)
-    } else return await this.set(name, data, duration)
+      return this.set(name, data, duration)
+    } else return this.set(name, data, duration)
   }
 
   private serialize(data: any): any {

src/Services/MemCacheService.ts

@@ -26,7 +26,7 @@ class MemCacheService extends MemCache implements ServiceInterface {
   public async set(name: string, data: any, duration: number): Promise<any> {
     if (name && data) {
       data = JSON.stringify(data)
-      return await super.set(name, data, duration)
+      return super.set(name, data, duration)
       //   if (duration == null) {
       //     return await this._addCache(name, data);
       //   }
@@ -44,13 +44,13 @@ class MemCacheService extends MemCache implements ServiceInterface {
 
   public async update(name: string, data: any, duration: number): Promise<any> {
     if (await this.delete(name)) {
-      return await this.set(name, data, duration)
-    } else return await this.set(name, data, duration)
+      return this.set(name, data, duration)
+    } else return this.set(name, data, duration)
   }
 
   public async remember(name: string, duration: number, callback: Function): Promise<any> {
     if (await this.has(name)) {
-      return await this.get(name)
+      return this.get(name)
     } else {
       const data = await callback()
       await this.set(name, data, duration)
@@ -60,7 +60,7 @@ class MemCacheService extends MemCache implements ServiceInterface {
 
   public async rememberForever(name: string, callback: Function): Promise<any> {
     if (await this.has(name)) {
-      return await this.get(name)
+      return this.get(name)
     } else {
       const data = await callback()
       await this.set(name, data, 50000000000000)

src/Services/RedisCacheService.ts

@@ -22,18 +22,18 @@ class RedisCacheService extends RedisCache implements ServiceInterface {
 
   public async set(name: string, data: any, duration: number = 0): Promise<any> {
     if (name && data) {
-      return await super.set(name, this.serialize(data), duration)
+      return super.set(name, this.serialize(data), duration)
     }
   }
 
   public async delete(name: string): Promise<Boolean> {
-    return await super.delete(name)
+    return super.delete(name)
   }
 
   public async update(name: string, data: any, duration: number): Promise<any> {
     if (await this.delete(name)) {
-      return await this.set(name, data, duration)
-    } else return await this.set(name, data, duration)
+      return this.set(name, data, duration)
+    } else return this.set(name, data, duration)
   }
 
   public async flush(): Promise<void> {