Removing static and fixing bugs

Kaperskyguru · Mar 21, 2020 · 1f40602 · 1f40602
1 parent e323b48
commit 1f40602
Show file tree

Hide file tree

Showing 4 changed files with 21 additions and 30 deletions.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "kap-adonis-cache",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Adonis Cache Package",
   "main": "build/providers/CacheProvider",
   "scripts": {

diff --git a/providers/CacheProvider.ts b/providers/CacheProvider.ts
@@ -7,7 +7,7 @@ class CacheProvider extends ServiceProvider {
     this.app.singleton("Kaperskyguru/Adonis-Cache", app => {
       // const Config = app.use("Adonis/Src/Config");
       const CacheLoader = require("../src/CacheLoader");
-      return new CacheLoader(app);
+      return new CacheLoader(app).createCache();
     });
 
     this.app.alias("Kaperskyguru/Adonis-Cache", "Cache");

diff --git a/src/CacheLoader.ts b/src/CacheLoader.ts
@@ -11,7 +11,6 @@ class CacheLoader {
   constructor(App: any) {
     this.app = App;
     this._setConfig("driver", this.cacheDriver);
-    this.initialize(this._getConfig("driver"));
   }
   _getConfig(name: String) {
     return this.app.use("Adonis/Src/Config").get(`cache.${name}`);
@@ -23,28 +22,31 @@ class CacheLoader {
     }
     this.app.use("Adonis/Src/Config").set(`cache.${name}`, value);
   }
-  initialize(driver: String) {
+  createCache() {
+    const driver: string = this._getConfig("driver");
+    let cache: any;
     switch (driver.toLowerCase()) {
       case "memcache":
         // Load MemCacheService
-        new Cache(new MemCacheService(this.app));
+        cache = new Cache(new MemCacheService(this.app));
         break;
 
       case "redis":
         // Load RedisCacheService
-        new Cache(new RedisCacheService(this.app));
+        cache = new Cache(new RedisCacheService(this.app));
         break;
 
       case "database":
         // Load DatabaseCacheService
-        new Cache(new DatabaseCacheService(this.app));
+        cache = new Cache(new DatabaseCacheService(this.app));
         break;
 
       default:
         // Load FileCacheService
-        new Cache(new FileCacheService(this.app));
+        cache = new Cache(new FileCacheService(this.app));
         break;
     }
+    return cache;
   }
 }
 

diff --git a/src/Consumers/Cache.ts b/src/Consumers/Cache.ts
@@ -2,12 +2,12 @@ import ServiceInterface from "../Contracts/ServiceInterface";
 
 // @Implements<CacheInterface>()
 class Cache {
-  private static CacheService: ServiceInterface;
+  private CacheService: ServiceInterface;
   constructor(cacheService: ServiceInterface) {
-    Cache.CacheService = cacheService;
+    this.CacheService = cacheService;
   }
 
-  public static async get(name: String): Promise<any> {
+  public async get(name: string): Promise<any> {
     if (name) {
       const value = await this.CacheService.get(name);
       if (value) {
@@ -16,45 +16,37 @@ class Cache {
     }
   }
 
-  public static async has(name: String): Promise<Boolean> {
+  public async has(name: string): Promise<Boolean> {
     const value = await this.CacheService.get(name);
     if (value == null) {
       return false;
     }
     return true;
   }
 
-  public static async set(
-    name: String,
-    data: any,
-    duration: Number
-  ): Promise<any> {
+  public async set(name: string, data: any, duration: number): Promise<any> {
     if (name && data) {
       data = JSON.stringify(data);
       return await this.CacheService.set(name, data, duration);
     }
   }
 
-  public static async delete(name: String): Promise<Boolean> {
+  public async delete(name: string): Promise<Boolean> {
     if (await this.has(name)) {
       await this.CacheService.delete(name);
       return true;
     }
     return false;
   }
 
-  public static async update(
-    name: String,
-    data: any,
-    duration: number
-  ): Promise<any> {
+  public async update(name: string, data: any, duration: number): Promise<any> {
     if (await this.has(name)) {
       await this.delete(name);
       return await this.set(name, data, duration);
     } else return await this.set(name, data, duration);
   }
 
-  public static async remember(
+  public async remember(
     name: string,
     duration: number,
     callback: Function
@@ -68,10 +60,7 @@ class Cache {
     }
   }
 
-  public static async rememberForever(
-    name: string,
-    callback: Function
-  ): Promise<any> {
+  public async rememberForever(name: string, callback: Function): Promise<any> {
     if (await this.has(name)) {
       return await this.get(name);
     } else {
@@ -81,7 +70,7 @@ class Cache {
     }
   }
 
-  public static async many(keys: Array<string>): Promise<object> {
+  public async many(keys: Array<string>): Promise<object> {
     let values = Promise.all(keys.map((key: string) => this.get(key)));
     let mappedValues: object = {};
     for (let index: number = 0; index < keys.length; index++) {
@@ -90,7 +79,7 @@ class Cache {
     return mappedValues;
   }
 
-  public static async setMany(data: object, minutes: number) {
+  public async setMany(data: object, minutes: number) {
     for (let prop in data) {
       await this.set(prop, data[prop], minutes);
     }