wip

src/utils/server-up.ts

@@ -6,24 +6,24 @@ import * as https from 'https';
 import { configService, SslConf } from '../config/env.config';
 
 export class ServerUP {
-  static #app: Express;
+    static #app: Express;
 
-  static set app(e: Express) {
-    this.#app = e;
-  }
+    static set app(e: Express) {
+        this.#app = e;
+    }
 
-  static get https() {
-    const { FULLCHAIN, PRIVKEY } = configService.get<SslConf>('SSL_CONF');
-    return https.createServer(
-      {
-        cert: readFileSync(FULLCHAIN),
-        key: readFileSync(PRIVKEY),
-      },
-      ServerUP.#app,
-    );
-  }
+    static get https() {
+        const { FULLCHAIN, PRIVKEY } = configService.get<SslConf>('SSL_CONF');
+        return https.createServer(
+            {
+                cert: readFileSync(FULLCHAIN),
+                key: readFileSync(PRIVKEY),
+            },
+            ServerUP.#app,
+        );
+    }
 
-  static get http() {
-    return http.createServer(ServerUP.#app);
-  }
+    static get http() {
+        return http.createServer(ServerUP.#app);
+    }
 }

src/utils/use-multi-file-auth-state-db.ts

@@ -1,10 +1,10 @@
 import {
-  AuthenticationCreds,
-  AuthenticationState,
-  BufferJSON,
-  initAuthCreds,
-  proto,
-  SignalDataTypeMap,
+    AuthenticationCreds,
+    AuthenticationState,
+    BufferJSON,
+    initAuthCreds,
+    proto,
+    SignalDataTypeMap,
 } from '@whiskeysockets/baileys';
 
 import { configService, Database } from '../config/env.config';
@@ -12,88 +12,86 @@ import { Logger } from '../config/logger.config';
 import { dbserver } from '../db/db.connect';
 
 export async function useMultiFileAuthStateDb(
-  coll: string,
+    coll: string,
 ): Promise<{ state: AuthenticationState; saveCreds: () => Promise<void> }> {
-  const logger = new Logger(useMultiFileAuthStateDb.name);
+    const logger = new Logger(useMultiFileAuthStateDb.name);
 
-  const client = dbserver.getClient();
+    const client = dbserver.getClient();
 
-  const collection = client
-    .db(configService.get<Database>('DATABASE').CONNECTION.DB_PREFIX_NAME + '-instances')
-    .collection(coll);
+    const collection = client
+        .db(configService.get<Database>('DATABASE').CONNECTION.DB_PREFIX_NAME + '-instances')
+        .collection(coll);
 
-  const writeData = async (data: any, key: string): Promise<any> => {
-    try {
-      await client.connect();
-      return await collection.replaceOne(
-        { _id: key },
-        JSON.parse(JSON.stringify(data, BufferJSON.replacer)),
-        { upsert: true },
-      );
-    } catch (error) {
-      logger.error(error);
-    }
-  };
+    const writeData = async (data: any, key: string): Promise<any> => {
+        try {
+            await client.connect();
+            return await collection.replaceOne({ _id: key }, JSON.parse(JSON.stringify(data, BufferJSON.replacer)), {
+                upsert: true,
+            });
+        } catch (error) {
+            logger.error(error);
+        }
+    };
 
-  const readData = async (key: string): Promise<any> => {
-    try {
-      await client.connect();
-      const data = await collection.findOne({ _id: key });
-      const creds = JSON.stringify(data);
-      return JSON.parse(creds, BufferJSON.reviver);
-    } catch (error) {
-      logger.error(error);
-    }
-  };
+    const readData = async (key: string): Promise<any> => {
+        try {
+            await client.connect();
+            const data = await collection.findOne({ _id: key });
+            const creds = JSON.stringify(data);
+            return JSON.parse(creds, BufferJSON.reviver);
+        } catch (error) {
+            logger.error(error);
+        }
+    };
 
-  const removeData = async (key: string) => {
-    try {
-      await client.connect();
-      return await collection.deleteOne({ _id: key });
-    } catch (error) {
-      logger.error(error);
-    }
-  };
+    const removeData = async (key: string) => {
+        try {
+            await client.connect();
+            return await collection.deleteOne({ _id: key });
+        } catch (error) {
+            logger.error(error);
+        }
+    };
 
-  const creds: AuthenticationCreds = (await readData('creds')) || initAuthCreds();
+    const creds: AuthenticationCreds = (await readData('creds')) || initAuthCreds();
 
-  return {
-    state: {
-      creds,
-      keys: {
-        get: async (type, ids: string[]) => {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          const data: { [_: string]: SignalDataTypeMap[type] } = {};
-          await Promise.all(
-            ids.map(async (id) => {
-              let value = await readData(`${type}-${id}`);
-              if (type === 'app-state-sync-key' && value) {
-                value = proto.Message.AppStateSyncKeyData.fromObject(value);
-              }
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids: string[]) => {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    const data: { [_: string]: SignalDataTypeMap[type] } = {};
+                    await Promise.all(
+                        ids.map(async (id) => {
+                            let value = await readData(`${type}-${id}`);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
 
-              data[id] = value;
-            }),
-          );
+                            data[id] = value;
+                        }),
+                    );
 
-          return data;
+                    return data;
+                },
+                set: async (data: any) => {
+                    const tasks: Promise<void>[] = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? writeData(value, key) : removeData(key));
+                        }
+                    }
+
+                    await Promise.all(tasks);
+                },
+            },
         },
-        set: async (data: any) => {
-          const tasks: Promise<void>[] = [];
-          for (const category in data) {
-            for (const id in data[category]) {
-              const value = data[category][id];
-              const key = `${category}-${id}`;
-              tasks.push(value ? writeData(value, key) : removeData(key));
-            }
-          }
-
-          await Promise.all(tasks);
+        saveCreds: async () => {
+            return writeData(creds, 'creds');
         },
-      },
-    },
-    saveCreds: async () => {
-      return writeData(creds, 'creds');
-    },
-  };
+    };
 }

src/utils/use-multi-file-auth-state-redis-db.ts

@@ -1,85 +1,84 @@
 import {
-  AuthenticationCreds,
-  AuthenticationState,
-  initAuthCreds,
-  proto,
-  SignalDataTypeMap,
+    AuthenticationCreds,
+    AuthenticationState,
+    initAuthCreds,
+    proto,
+    SignalDataTypeMap,
 } from '@whiskeysockets/baileys';
 
-import { Redis } from '../config/env.config';
 import { Logger } from '../config/logger.config';
 import { RedisCache } from '../db/redis.client';
 
 export async function useMultiFileAuthStateRedisDb(cache: RedisCache): Promise<{
-  state: AuthenticationState;
-  saveCreds: () => Promise<void>;
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
 }> {
-  const logger = new Logger(useMultiFileAuthStateRedisDb.name);
+    const logger = new Logger(useMultiFileAuthStateRedisDb.name);
 
-  const writeData = async (data: any, key: string): Promise<any> => {
-    try {
-      return await cache.writeData(key, data);
-    } catch (error) {
-      return logger.error({ localError: 'writeData', error });
-    }
-  };
+    const writeData = async (data: any, key: string): Promise<any> => {
+        try {
+            return await cache.writeData(key, data);
+        } catch (error) {
+            return logger.error({ localError: 'writeData', error });
+        }
+    };
 
-  const readData = async (key: string): Promise<any> => {
-    try {
-      return await cache.readData(key);
-    } catch (error) {
-      logger.error({ readData: 'writeData', error });
-      return;
-    }
-  };
+    const readData = async (key: string): Promise<any> => {
+        try {
+            return await cache.readData(key);
+        } catch (error) {
+            logger.error({ readData: 'writeData', error });
+            return;
+        }
+    };
 
-  const removeData = async (key: string) => {
-    try {
-      return await cache.removeData(key);
-    } catch (error) {
-      logger.error({ readData: 'removeData', error });
-    }
-  };
+    const removeData = async (key: string) => {
+        try {
+            return await cache.removeData(key);
+        } catch (error) {
+            logger.error({ readData: 'removeData', error });
+        }
+    };
 
-  const creds: AuthenticationCreds = (await readData('creds')) || initAuthCreds();
+    const creds: AuthenticationCreds = (await readData('creds')) || initAuthCreds();
 
-  return {
-    state: {
-      creds,
-      keys: {
-        get: async (type, ids: string[]) => {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          const data: { [_: string]: SignalDataTypeMap[type] } = {};
-          await Promise.all(
-            ids.map(async (id) => {
-              let value = await readData(`${type}-${id}`);
-              if (type === 'app-state-sync-key' && value) {
-                value = proto.Message.AppStateSyncKeyData.fromObject(value);
-              }
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids: string[]) => {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    const data: { [_: string]: SignalDataTypeMap[type] } = {};
+                    await Promise.all(
+                        ids.map(async (id) => {
+                            let value = await readData(`${type}-${id}`);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
 
-              data[id] = value;
-            }),
-          );
+                            data[id] = value;
+                        }),
+                    );
 
-          return data;
+                    return data;
+                },
+                set: async (data: any) => {
+                    const tasks: Promise<void>[] = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const key = `${category}-${id}`;
+                            tasks.push(value ? await writeData(value, key) : await removeData(key));
+                        }
+                    }
+
+                    await Promise.all(tasks);
+                },
+            },
         },
-        set: async (data: any) => {
-          const tasks: Promise<void>[] = [];
-          for (const category in data) {
-            for (const id in data[category]) {
-              const value = data[category][id];
-              const key = `${category}-${id}`;
-              tasks.push(value ? await writeData(value, key) : await removeData(key));
-            }
-          }
-
-          await Promise.all(tasks);
+        saveCreds: async () => {
+            return await writeData(creds, 'creds');
         },
-      },
-    },
-    saveCreds: async () => {
-      return await writeData(creds, 'creds');
-    },
-  };
+    };
 }