Prettier formatting

rushabhhere · Jul 28, 2024 · 00d3df2 · 00d3df2
1 parent bc49897
commit 00d3df2
Show file tree

Hide file tree

Showing 9 changed files with 215 additions and 186 deletions.
diff --git a/index.ts b/index.ts
@@ -35,7 +35,7 @@ class OTPManager {
     await this.store.set(
       `${this._config.purpose}:${userId}`,
       otp,
-      this._config.expirationTime,
+      this._config.expirationTime
     );
 
     return otp;

diff --git a/otp_store/map_store.ts b/otp_store/map_store.ts
@@ -1,40 +1,38 @@
-import OTPStore from "./otp_store";
+import OTPStore from './otp_store';
 
 class MapStore extends OTPStore {
-    private _otpMap: Map<string, [number, Date]>;
+  private _otpMap: Map<string, [number, Date]>;
 
-    constructor() {
-        super()
-        this._otpMap = new Map<string, [number, Date]>();
-    }
+  constructor() {
+    super();
+    this._otpMap = new Map<string, [number, Date]>();
+  }
 
-    async get(key: string): Promise<number> {
-        return (this._otpMap.get(key) ?? [0])[0];
-    }
+  async get(key: string): Promise<number> {
+    return (this._otpMap.get(key) ?? [0])[0];
+  }
 
-    async set(key: string, value: number, ttl?: number): Promise<string | null> {
-        try {
-            this._otpMap.set(key, [value, new Date(Date.now() + (ttl ?? 0))]);
+  async set(key: string, value: number, ttl?: number): Promise<string | null> {
+    try {
+      this._otpMap.set(key, [value, new Date(Date.now() + (ttl ?? 0))]);
 
-            setTimeout(() => {
-                this.del(key);
-            }, (ttl ?? 60) * 1000);
-            return "OK"
-        }
-        catch (e) {
-            return String(e);
-        }
+      setTimeout(() => {
+        this.del(key);
+      }, (ttl ?? 60) * 1000);
+      return 'OK';
+    } catch (e) {
+      return String(e);
     }
+  }
 
-    async del(key: string): Promise<number | null> {
-        try {
-            this._otpMap.delete(key);
-            return 1;
-        }
-        catch (e) {
-            return -1
-        }
+  async del(key: string): Promise<number | null> {
+    try {
+      this._otpMap.delete(key);
+      return 1;
+    } catch (e) {
+      return -1;
     }
+  }
 }
 
-export default MapStore;
+export default MapStore;
diff --git a/otp_store/memcached_store.ts b/otp_store/memcached_store.ts
@@ -1,59 +1,53 @@
-import OTPStore from './otp_store'
-import Memcached from 'memcached'
+import OTPStore from './otp_store';
+import Memcached from 'memcached';
 
-type MemcachedClient = Memcached
+type MemcachedClient = Memcached;
 
 class MemcachedStore extends OTPStore {
-    private client: MemcachedClient;
+  private client: MemcachedClient;
 
-    constructor(client: MemcachedClient) {
-        super()
-        this.client = client
-    }
+  constructor(client: MemcachedClient) {
+    super();
+    this.client = client;
+  }
 
-    async get(key: string): Promise<number> {
-        var value = 0;
-        await new Promise<void>(
-            (resolve, reject) => {
-                this.client.get(key, (err, data) => {
-                    if (err) {
-                        reject()
-                    }
-                    value = data
-                    resolve()
-                })
-            }
-        )
-        return value ?? 0
-    }
+  async get(key: string): Promise<number> {
+    var value = 0;
+    await new Promise<void>((resolve, reject) => {
+      this.client.get(key, (err, data) => {
+        if (err) {
+          reject();
+        }
+        value = data;
+        resolve();
+      });
+    });
+    return value ?? 0;
+  }
 
-    async set(key: string, value: number, ttl = 60): Promise<string | null> {
-        await new Promise<void>(
-            (resolve, reject) => {
-                this.client.set(key, value, ttl, (err) => {
-                    if (err) {
-                        reject()
-                    }
-                    resolve()
-                })
-            }
-        )
-        return null
-    }
+  async set(key: string, value: number, ttl = 60): Promise<string | null> {
+    await new Promise<void>((resolve, reject) => {
+      this.client.set(key, value, ttl, err => {
+        if (err) {
+          reject();
+        }
+        resolve();
+      });
+    });
+    return null;
+  }
 
-    async del(key: string): Promise<number | null> {
-        await new Promise<void>(
-            (resolve, reject) => {
-                this.client.del(key, (err) => {
-                    if (err) {
-                        reject()
-                    }
-                    resolve()
-                })
-            }
-        )
-        return null
-    }
+  async del(key: string): Promise<number | null> {
+    await new Promise<void>((resolve, reject) => {
+      this.client.del(key, err => {
+        if (err) {
+          reject();
+        }
+        resolve();
+      });
+    });
+    return null;
+  }
 }
 
-export default MemcachedStore
+export default MemcachedStore;
diff --git a/otp_store/otp_store.ts b/otp_store/otp_store.ts
@@ -1,7 +1,13 @@
 abstract class OTPStore {
-    abstract get(key: string): Promise<number>;
-    abstract set(key: string, value: number, ttl?: number): Promise<string | null>;
-    abstract del(key: string): Promise<number | null>;
+  abstract get(key: string): Promise<number>;
+
+  abstract set(
+    key: string,
+    value: number,
+    ttl?: number
+  ): Promise<string | null>;
+
+  abstract del(key: string): Promise<number | null>;
 }
 
-export default OTPStore;
+export default OTPStore;
diff --git a/otp_store/redis_store.ts b/otp_store/redis_store.ts
@@ -1,28 +1,33 @@
-import OTPStore from './otp_store'
-import { RedisClientType, RedisFunctions, RedisModules, RedisScripts } from '@redis/client';
+import OTPStore from './otp_store';
+import {
+  RedisClientType,
+  RedisFunctions,
+  RedisModules,
+  RedisScripts,
+} from '@redis/client';
 
-type RedisClient = RedisClientType<RedisFunctions, RedisModules, RedisScripts>
+type RedisClient = RedisClientType<RedisFunctions, RedisModules, RedisScripts>;
 
 class RedisStore extends OTPStore {
-    private client: RedisClient;
+  private client: RedisClient;
 
-    constructor(client: RedisClient) {
-        super()
-        this.client = client
-    }
+  constructor(client: RedisClient) {
+    super();
+    this.client = client;
+  }
 
-    async get(key: string): Promise<number> {
-        const value = await this.client.get(key)
-        return value ? parseInt(value) : 0
-    }
+  async get(key: string): Promise<number> {
+    const value = await this.client.get(key);
+    return value ? parseInt(value) : 0;
+  }
 
-    async set(key: string, value: number, ttl = 60): Promise<string | null> {
-        return await this.client.set(key, value.toString(), { EX: ttl })
-    }
+  async set(key: string, value: number, ttl = 60): Promise<string | null> {
+    return await this.client.set(key, value.toString(), { EX: ttl });
+  }
 
-    async del(key: string): Promise<number | null> {
-        return await this.client.del(key)
-    }
+  async del(key: string): Promise<number | null> {
+    return await this.client.del(key);
+  }
 }
 
-export default RedisStore
+export default RedisStore;