init project evolution api

src/utils/server-up.ts

@@ -0,0 +1,28 @@
+import { Express } from 'express';
+import { readFileSync } from 'fs';
+import { configService, SslConf } from '../config/env.config';
+import * as https from 'https';
+import * as http from 'http';
+
+export class ServerUP {
+  static #app: Express;
+
+  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 http() {
+    return http.createServer(ServerUP.#app);
+  }
+}

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

@@ -0,0 +1,92 @@
+import {
+  AuthenticationCreds,
+  AuthenticationState,
+  BufferJSON,
+  initAuthCreds,
+  proto,
+  SignalDataTypeMap,
+} from '@evolution/base';
+import { configService, Database } from '../config/env.config';
+import { Logger } from '../config/logger.config';
+import { dbserver } from '../db/db.connect';
+
+export async function useMultiFileAuthStateDb(
+  coll: string,
+): Promise<{ state: AuthenticationState; saveCreds: () => Promise<void> }> {
+  const logger = new Logger(useMultiFileAuthStateDb.name);
+
+  const client = dbserver.getClient();
+
+  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 {}
+  };
+
+  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 {}
+  };
+
+  const removeData = async (key: string) => {
+    try {
+      await client.connect();
+      return await collection.deleteOne({ _id: key });
+    } catch {}
+  };
+
+  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);
+              }
+
+              data[id] = value;
+            }),
+          );
+
+          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);
+        },
+      },
+    },
+    saveCreds: async () => {
+      return writeData(creds, 'creds');
+    },
+  };
+}

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

@@ -0,0 +1,89 @@
+import {
+  AuthenticationCreds,
+  AuthenticationState,
+  initAuthCreds,
+  proto,
+  SignalDataTypeMap,
+} from '@evolution/base';
+import { RedisCache } from '../db/redis.client';
+import { Logger } from '../config/logger.config';
+import { Redis } from '../config/env.config';
+
+export async function useMultiFileAuthStateRedisDb(
+  redisEnv: Partial<Redis>,
+  instanceName: string,
+): Promise<{
+  state: AuthenticationState;
+  saveCreds: () => Promise<void>;
+}> {
+  const logger = new Logger(useMultiFileAuthStateRedisDb.name);
+
+  const cache = new RedisCache(redisEnv, instanceName);
+
+  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 removeData = async (key: string) => {
+    try {
+      return await cache.removeData(key);
+    } catch (error) {
+      logger.error({ readData: 'removeData', error });
+    }
+  };
+
+  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);
+              }
+
+              data[id] = value;
+            }),
+          );
+
+          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);
+        },
+      },
+    },
+    saveCreds: async () => {
+      return await writeData(creds, 'creds');
+    },
+  };
+}