zaileys 0.29.7-beta → 0.29.9-beta

package/package.json

@@ -1,7 +1,23 @@
 {
   "name": "zaileys",
-  "version": "0.29.07-beta",
+  "version": "0.29.9-beta",
   "description": "Zaileys - Simplify Typescript/Javascript WhatsApp NodeJS API",
+  "main": "dist/zaileys.cjs.js",
+  "module": "dist/zaileys.esm.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/zaileys.esm.js",
+      "require": "./dist/zaileys.cjs.js"
+    }
+  },
+  "scripts": {
+    "build": "rollup --bundleConfigAsCjs -c",
+    "watch": "rollup --bundleConfigAsCjs -c -w",
+    "dev": "concurrently \"npm:dev:test\"",
+    "dev:test": "npx tsx watch test/example.ts",
+    "clean": "rimraf dist"
+  },
   "keywords": [
     "zaileys",
     "whatsapp",
@@ -29,39 +45,36 @@
     "email": "zaadevofc@gmail.com",
     "url": "https://github.com/zeative"
   },
-  "license": "MIT",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "npx ts-node-dev test/example",
-    "test": "npx ts-node test/example",
-    "docs": "typedoc",
-    "prod": "tsup && typedoc && npm publish --tag latest"
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^24.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "@rollup/plugin-typescript": "^12.0.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/pg": "^8.15.1",
+    "concurrently": "^8.0.0",
+    "rimraf": "^5.0.0",
+    "rollup": "^3.0.0",
+    "rollup-plugin-dts": "^5.0.0",
+    "rollup-plugin-esbuild": "^6.2.1",
+    "rollup-plugin-strip": "^1.2.2",
+    "rollup-plugin-terser": "^7.0.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.0.0",
+    "zod": "^3.24.4"
   },
   "dependencies": {
-    "@whiskeysockets/baileys": "^6.7.12",
-    "awesome-phonenumber": "^7.2.0",
-    "chalk": "^5.4.1",
-    "consola": "^3.4.0",
-    "figlet": "^1.8.0",
-    "jimp": "0.22.12",
+    "baileys": "^6.7.16",
+    "better-sqlite3": "^11.10.0",
+    "kysely": "^0.28.2",
+    "libsignal": "^2.0.1",
+    "mysql2": "^3.14.1",
     "node-cache": "^5.1.2",
-    "ora": "^8.2.0",
-    "pino": "^9.6.0",
-    "qrcode-terminal": "^0.12.0"
-  },
-  "devDependencies": {
-    "@types/node": "^16.0.0",
-    "ts-node": "^10.8.1",
-    "ts-node-dev": "^2.0.0",
-    "tsup": "^8.3.6",
-    "typedoc": "^0.24.7",
-    "typedoc-material-theme": "^1.3.0",
-    "typescript": "^4.6.4"
+    "pg": "^8.15.6",
+    "pino": "^9.6.0"
   }
 }

package/rollup.config.js

@@ -0,0 +1,38 @@
+import commonjs from '@rollup/plugin-commonjs';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import typescript from '@rollup/plugin-typescript';
+import { dts } from 'rollup-plugin-dts';
+import { minify } from 'rollup-plugin-esbuild';
+import strip from 'rollup-plugin-strip';
+import { terser } from 'rollup-plugin-terser';
+
+/** @type {import('rollup').RollupOptions[]} */
+export default [
+  {
+    input: 'src/index.ts',
+    external: Object.keys(require('./package.json').dependencies || {}),
+    treeshake: {
+      moduleSideEffects: false,
+      propertyReadSideEffects: false
+    },
+    output: [
+      { file: 'dist/zaileys.cjs.js', format: 'cjs', sourcemap: false },
+      { file: 'dist/zaileys.esm.js', format: 'esm', sourcemap: false }
+    ],
+    plugins: [
+      nodeResolve({
+        extensions: ['.js', '.ts']
+      }), ,
+      commonjs(),
+      minify(),
+      typescript(),
+      strip({ functions: ['assert.*'] }),
+      terser({ format: { comments: false } })
+    ]
+  },
+  {
+    input: 'src/index.ts',
+    output: { file: 'dist/index.d.ts', format: 'es' },
+    plugins: [dts(), typescript()]
+  }
+];

package/src/classes/Client.ts

@@ -0,0 +1,73 @@
+import makeWASocket, { Browsers, makeCacheableSignalKeyStore } from "baileys";
+import { Kysely, sql } from "kysely";
+import NodeCache from "node-cache";
+import pino from "pino";
+import { z } from "zod";
+import { AuthAdapterHandler, ConnectDB, StoreAdapterHandler } from "../database/handler";
+import { DB } from "../database/schema";
+import { ClientClassesType } from "../types/classes/client";
+import { EventCallbackType, EventEnumType } from "../types/classes/event";
+import Event from "./Event";
+
+class Client {
+  options: z.infer<typeof ClientClassesType> | undefined;
+  private chatId = "zaileys-chats";
+
+  private logger = pino({ level: "silent", enabled: false });
+  private event: Event;
+  private db: Kysely<DB> | undefined;
+  private socket: ReturnType<typeof makeWASocket> | undefined;
+  private groupCache = new NodeCache({ stdTTL: 5 * 60, useClones: false });
+
+  constructor(private props: z.input<typeof ClientClassesType>) {
+    this.initialize();
+    this.event = new Event(this);
+  }
+
+  async initialize() {
+    this.options = await ClientClassesType.parseAsync(this.props);
+    this.db = ConnectDB(this.options!.database.type, this.options!.database.connection.url);
+
+    const { state, saveCreds, removeCreds } = await AuthAdapterHandler(this.db, this.chatId);
+    const store = await StoreAdapterHandler(this.db, this.chatId);
+
+    this.socket = makeWASocket({
+      logger: this.logger,
+      markOnlineOnConnect: this.options.autoOnline,
+      syncFullHistory: false,
+      defaultQueryTimeoutMs: undefined,
+      msgRetryCounterCache: new NodeCache(),
+      cachedGroupMetadata: async (jid) => this.groupCache.get(jid),
+      printQRInTerminal: this.options.authType == "qr",
+      browser: Browsers.ubuntu(this.options.authType == "qr" ? "Zaileys Library" : "Firefox"),
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, this.logger),
+      },
+    });
+
+    if (this.options.authType == "pairing" && this.options.phoneNumber && !this.socket?.authState.creds.registered) {
+      setTimeout(async () => {
+        try {
+          if (this.options?.authType == "pairing") {
+            const code = await this.socket?.requestPairingCode(this.options.phoneNumber.toString());
+            console.log("🚀 ~ Client.ts:53 ~ Client ~ setTimeout ~ code:", code);
+          }
+        } catch {
+          console.log("Connection failed");
+          process.exit(1);
+        }
+      }, 5000);
+    }
+
+    this.socket?.ev.on("creds.update", saveCreds);
+    store.bind(this.socket?.ev);
+    this.event.setup(this.socket);
+  }
+
+  on<T extends EventEnumType>(event: T, handler: EventCallbackType[T]) {
+    this.event.on(event, handler);
+  }
+}
+
+export default Client;

package/src/classes/Event.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { DisconnectReason, WASocket } from "baileys";
+import { EventCallbackType, EventEnumType } from "../types/classes/event";
+import Client from "./Client";
+
+class Event {
+  private events: Map<EventEnumType, Function[]> = new Map();
+
+  constructor(private client: Client) {}
+
+  setup(sock: WASocket) {
+    sock.ev.on("connection.update", async (update) => {
+      const { connection, lastDisconnect, qr } = update;
+      this.emit("connection", { status: connection || "connecting" });
+
+      if (this.client.options?.authType == "qr" && qr) {
+        console.log("Scan qrcode with your whatsapp: ");
+      }
+
+      if (connection === "close") {
+        const code = (lastDisconnect?.error as any)?.output?.statusCode;
+        const isReconnect = code !== DisconnectReason.loggedOut;
+        console.log(lastDisconnect?.error?.message);
+
+        if (code == 401 || code == 405 || code == 500) {
+          // await this.client.logout();
+          // await this.client.initialize();
+          return;
+        }
+
+        if (isReconnect) await this.client.initialize();
+      } else if (connection === "open") {
+        this.emit("connection", { status: "open" });
+      }
+    });
+
+    sock.ev.on("messages.upsert", ({ messages }) => {
+      this.emit("messages", messages as never);
+    });
+
+    sock.ev.on("call", (call) => {
+      this.emit("call", call as never);
+    });
+  }
+
+  on<T extends EventEnumType>(event: T, handler: EventCallbackType[T]) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event)!.push(handler);
+  }
+
+  private emit<T extends EventEnumType>(event: T, data: Parameters<EventCallbackType[T]>[0]) {
+    const handlers = this.events.get(event) || [];
+    handlers.forEach((handler) => handler(data));
+  }
+}
+
+export default Event;

package/src/classes/Parser.ts

@@ -0,0 +1,3 @@
+export default class Parser {
+  constructor(parameters) {}
+}

package/src/database/handler.ts

@@ -0,0 +1,272 @@
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { Kysely, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+import mysql from "mysql2";
+import path from "path";
+import { Pool } from "pg";
+import { URL } from "url";
+import { z } from "zod";
+import { BufferJSON, fromObject, initAuthCreds } from "../helpers/adapter";
+import { AuthAdapterHandlerType, AuthenticationCreds, SignalDataTypeMap } from "../types/adapter/general";
+import { AdapterDatabaseType, ClientClassesType } from "../types/classes/client";
+import type { DB } from "./schema";
+import { BaileysEventEmitter } from "baileys";
+
+export const ConnectDB = (type: z.infer<typeof AdapterDatabaseType>["type"], url: string): Kysely<DB> => {
+  if (type === "sqlite") {
+    const filepath = url || "./db/zaileys.db";
+    const resolvedPath = path.resolve(filepath);
+
+    mkdirSync(path.dirname(resolvedPath), { recursive: true });
+    writeFileSync(resolvedPath, "", { flag: "a" });
+
+    return new Kysely<DB>({
+      dialect: new SqliteDialect({
+        database: new Database(resolvedPath),
+      }),
+    });
+  }
+
+  const conn = new URL(url);
+  const protocol = conn.protocol.replace(":", "");
+
+  if (type === "mysql") {
+    return new Kysely<DB>({
+      dialect: new MysqlDialect({
+        pool: mysql.createPool({
+          host: conn.hostname,
+          user: conn.username,
+          password: conn.password,
+          database: conn.pathname.replace("/", ""),
+          port: parseInt(conn.port || "3306", 10),
+        }),
+      }),
+    });
+  }
+
+  if (type === "postgresql") {
+    return new Kysely<DB>({
+      dialect: new PostgresDialect({
+        pool: new Pool({
+          host: conn.hostname,
+          user: conn.username,
+          password: conn.password,
+          database: conn.pathname.replace("/", ""),
+          port: parseInt(conn.port || "5432", 10),
+        }),
+      }),
+    });
+  }
+
+  throw new Error(`Unsupported database protocol: ${protocol}`);
+};
+
+export const MigrateDB = async (db: Kysely<DB>) => {
+  await db.schema
+    .createTable("auth")
+    .ifNotExists()
+    .addColumn("session", "varchar(50)", (col) => col.notNull())
+    .addColumn("id", "varchar(80)", (col) => col.notNull())
+    .addColumn("value", "text", (col) => col.defaultTo(null))
+    .addUniqueConstraint("auth_session_id_unique", ["session", "id"])
+    .execute();
+
+  await db.schema
+    .createTable("chats")
+    .ifNotExists()
+    .addColumn("session", "varchar(50)", (col) => col.notNull())
+    .addColumn("id", "varchar(80)", (col) => col.notNull())
+    .addColumn("value", "text", (col) => col.defaultTo(null))
+    .addUniqueConstraint("chats_session_id_unique", ["session", "id"])
+    .execute();
+
+  await db.schema
+    .createTable("contacts")
+    .ifNotExists()
+    .addColumn("session", "varchar(50)", (col) => col.notNull())
+    .addColumn("id", "varchar(80)", (col) => col.notNull())
+    .addColumn("value", "text", (col) => col.defaultTo(null))
+    .addUniqueConstraint("contacts_session_id_unique", ["session", "id"])
+    .execute();
+
+  await db.schema
+    .createTable("messages")
+    .ifNotExists()
+    .addColumn("session", "varchar(50)", (col) => col.notNull())
+    .addColumn("id", "varchar(80)", (col) => col.notNull())
+    .addColumn("value", "text", (col) => col.defaultTo(null))
+    .addUniqueConstraint("messages_session_id_unique", ["session", "id"])
+    .execute();
+
+  await db.schema.createIndex("auth_session_idx").ifNotExists().on("auth").column("session").execute();
+  await db.schema.createIndex("auth_id_idx").ifNotExists().on("auth").column("id").execute();
+  await db.schema.createIndex("chats_session_idx").ifNotExists().on("chats").column("session").execute();
+  await db.schema.createIndex("chats_id_idx").ifNotExists().on("chats").column("id").execute();
+  await db.schema.createIndex("contacts_session_idx").ifNotExists().on("contacts").column("session").execute();
+  await db.schema.createIndex("contacts_id_idx").ifNotExists().on("contacts").column("id").execute();
+  await db.schema.createIndex("messages_session_idx").ifNotExists().on("messages").column("session").execute();
+  await db.schema.createIndex("messages_id_idx").ifNotExists().on("messages").column("id").execute();
+};
+
+export const AuthAdapterHandler = async (db: Kysely<DB>, session: string): AuthAdapterHandlerType => {
+  const TABLE_NAME = "auth";
+  const RETRY_DELAY = 200;
+  const MAX_RETRIES = 10;
+
+  await MigrateDB(db);
+
+  const retry = async <T>(fn: () => Promise<T>): Promise<T> => {
+    for (let x = 0; x < MAX_RETRIES; x++) {
+      try {
+        return await fn();
+      } catch (e) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY));
+      }
+    }
+    throw new Error("Max retries reached");
+  };
+
+  const readData = async (id: string) => {
+    const row = await retry(() => db.selectFrom(TABLE_NAME).select(["value"]).where("id", "=", id).where("session", "=", session).executeTakeFirst());
+
+    if (!row?.value) return null;
+
+    const credsStr = typeof row.value === "object" ? JSON.stringify(row.value) : row.value;
+    return JSON.parse(credsStr, BufferJSON.reviver);
+  };
+
+  const writeData = async (id: string, value: object) => {
+    const valueFixed = JSON.stringify(value, BufferJSON.replacer);
+
+    await retry(() =>
+      db
+        .insertInto(TABLE_NAME)
+        .values({
+          session: session,
+          id,
+          value: valueFixed,
+        })
+        .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: valueFixed }))
+        .execute()
+    );
+  };
+
+  const removeData = async (id: string) => {
+    await retry(() => db.deleteFrom(TABLE_NAME).where("id", "=", id).where("session", "=", session).execute());
+  };
+
+  const clearAll = async () => {
+    await retry(() => db.deleteFrom(TABLE_NAME).where("session", "=", session).where("id", "!=", "creds").execute());
+  };
+
+  const removeAll = async () => {
+    await retry(() => db.deleteFrom(TABLE_NAME).where("session", "=", session).execute());
+  };
+
+  const creds: AuthenticationCreds = (await readData("creds")) || initAuthCreds();
+
+  return {
+    state: {
+      creds: creds,
+      keys: {
+        get: async (type, ids) => {
+          const data: { [id: string]: SignalDataTypeMap[typeof type] } = {};
+          for (const id of ids) {
+            let value = await readData(`${type}-${id}`);
+            if (type === "app-state-sync-key" && value) {
+              value = fromObject(value);
+            }
+            data[id] = value;
+          }
+          return data;
+        },
+        set: async (data) => {
+          for (const category in data) {
+            for (const id in data[category as never] as any) {
+              const value = data[category as never][id];
+              const name = `${category}-${id}`;
+              if (value) {
+                await writeData(name, value);
+              } else {
+                await removeData(name);
+              }
+            }
+          }
+        },
+      },
+    },
+    saveCreds: async () => {
+      await writeData("creds", creds);
+    },
+    clear: async () => {
+      await clearAll();
+    },
+    removeCreds: async () => {
+      await removeAll();
+    },
+  };
+};
+
+export const StoreAdapterHandler = async (db: Kysely<DB>, session: string) => {
+  return {
+    bind: (event: BaileysEventEmitter) => {
+      event.on("messaging-history.set", async (update) => {
+        const { chats, contacts, messages } = update;
+
+        for (const chat of chats) {
+          await db
+            .insertInto("chats")
+            .values({ session, id: chat.id!, value: JSON.stringify(chat) })
+            .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: JSON.stringify(chat) }))
+            .execute();
+        }
+
+        for (const contact of contacts) {
+          await db
+            .insertInto("contacts")
+            .values({ session, id: contact.id!, value: JSON.stringify(contact) })
+            .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: JSON.stringify(contact) }))
+            .execute();
+        }
+
+        for (const message of messages) {
+          await db
+            .insertInto("messages")
+            .values({ session, id: message.key.id!, value: JSON.stringify(message) })
+            .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: JSON.stringify(message) }))
+            .execute();
+        }
+      });
+
+      event.on("messages.upsert", async ({ messages }) => {
+        for (const message of messages) {
+          await db
+            .insertInto("messages")
+            .values({ session, id: message.key.id!, value: JSON.stringify(message) })
+            .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: JSON.stringify(message) }))
+            .execute();
+        }
+      });
+
+      event.on("chats.upsert", async (chats) => {
+        for (const chat of chats) {
+          await db
+            .insertInto("chats")
+            .values({ session, id: chat.id!, value: JSON.stringify(chat) })
+            .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: JSON.stringify(chat) }))
+            .execute();
+        }
+      });
+
+      event.on("contacts.upsert", async (contacts) => {
+        for (const contact of contacts) {
+          await db
+            .insertInto("contacts")
+            .values({ session, id: contact.id!, value: JSON.stringify(contact) })
+            .onConflict((oc) => oc.columns(["session", "id"]).doUpdateSet({ value: JSON.stringify(contact) }))
+            .execute();
+        }
+      });
+    },
+  };
+};

package/src/database/schema.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const AuthSchema = z.object({
+  session: z.string(),
+  id: z.string(),
+  value: z.string().nullable(),
+});
+
+export const ChatSchema = z.object({
+  session: z.string(),
+  id: z.string(),
+  value: z.string().nullable(),
+});
+
+export const ContactSchema = z.object({
+  session: z.string(),
+  id: z.string(),
+  value: z.string().nullable(),
+});
+
+export const MessageSchema = z.object({
+  session: z.string(),
+  id: z.string(),
+  value: z.string().nullable(),
+});
+
+export type AuthTable = z.infer<typeof AuthSchema>;
+export type ChatTable = z.infer<typeof ChatSchema>;
+export type ContactTable = z.infer<typeof ContactSchema>;
+export type MessageTable = z.infer<typeof MessageSchema>;
+
+export type DB = {
+  auth: AuthTable;
+  chats: ChatTable;
+  contacts: ContactTable;
+  messages: MessageTable;
+};