@kyyinfinite/lumina 1.0.2 → 1.0.4

package/README.md

@@ -360,6 +360,88 @@ Type-checked features:
 - Enum-like catalogs (`MessageType`, `HeaderType`, `LayoutKind`, ...) are `Readonly`
 - `Bot.raw` escape hatch typed as `WASocket`
 
+
+---
+
+## Baileys Compatibility
+
+Lumina is not tied to a specific Baileys version or fork. When `new Bot(sock)` is called, Lumina automatically detects the available Baileys package in your project.
+
+### Auto-Detect (default)
+
+No configuration is required. Lumina tries the following packages in order and uses the first one that can be successfully imported:
+
+```
+@kyyinfinite/baileys
+@whiskeysockets/baileys
+baileys
+@adiwajshing/baileys
+@brunocgc/baileys
+@open-wa/baileys
+```
+
+```js
+// Lumina automatically detects @kyyinfinite/baileys (or any installed fork)
+const bot = new Bot(sock)
+```
+
+---
+
+### Explicit Package Name
+
+If you're using a custom-named fork, specify it with `baileysPackage`:
+
+```js
+const bot = new Bot(sock, {
+  baileysPackage: '@namafork/baileys',
+})
+```
+
+---
+
+### Module Injection
+
+The fastest option — zero dynamic imports. Simply inject the module directly:
+
+```js
+import * as baileys from '@kyyinfinite/baileys'
+
+const bot = new Bot(sock, {
+  baileys,
+})
+```
+
+This is ideal if you've already imported Baileys elsewhere and want to avoid duplicate imports.
+
+---
+
+### Socket Fallback
+
+If no Baileys package is found, Lumina falls back to its internal socket-based implementation. Core features (text, buttons, carousel, stickers) continue to work. Media uploads require `sock.waUploadToServer` to be available.
+
+---
+
+### Debug: Check the Active Adapter
+
+```js
+const bot = new Bot(sock)
+console.log(await bot.connection.adapterSource())
+// → '@kyyinfinite/baileys'
+// → '@whiskeysockets/baileys'
+// → 'injected-module'
+// → 'socket-fallback'
+```
+
+---
+
+### Summary
+
+| Option | When to use |
+|---|---|
+| _(not set)_ | Auto-detect. Recommended for most use cases. |
+| `baileysPackage: 'name'` | For custom forks that are not included in the auto-detect list. |
+| `baileys: module` | Manual module injection for the best performance. |
+
 ---
 
 ## API Reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyyinfinite/lumina",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Lumina — Modern WhatsApp framework built on top of Baileys. Hide the protocol complexity, expose a fluent API.",
   "type": "module",
   "main": "./src/index.js",

package/src/client/baileys-adapter.js

@@ -0,0 +1,140 @@
+import crypto from 'node:crypto'
+import { ConnectionError } from '../errors.js'
+
+const KNOWN_PACKAGES = [
+  '@kyyinfinite/baileys',
+  '@whiskeysockets/baileys',
+  'baileys',
+  '@adiwajshing/baileys',
+  '@brunocgc/baileys',
+  '@open-wa/baileys',
+]
+
+const REQUIRED_FNS = [
+  'prepareWAMessageMedia',
+  'generateWAMessageFromContent',
+  'generatePollMessage',
+  'generateReactionMessage',
+]
+
+function extractFns(mod) {
+  const missing = REQUIRED_FNS.filter((fn) => typeof mod[fn] !== 'function')
+  if (missing.length > 0) return null
+  return {
+    prepareWAMessageMedia: mod.prepareWAMessageMedia,
+    generateWAMessageFromContent: mod.generateWAMessageFromContent,
+    generatePollMessage: mod.generatePollMessage,
+    generateReactionMessage: mod.generateReactionMessage,
+  }
+}
+
+function makeFallbackFns(socket) {
+  const generateId = () => crypto.randomBytes(8).toString('hex').toUpperCase()
+
+  const generateWAMessageFromContent = (jid, content, opts = {}) => ({
+    key: {
+      remoteJid: jid,
+      fromMe: true,
+      id: opts.messageId ?? generateId(),
+      participant: opts.participant,
+    },
+    message: content,
+    messageTimestamp: Math.floor(Date.now() / 1000),
+    status: 1,
+  })
+
+  const generatePollMessage = async (jid, opts) => {
+    const msg = await socket.sendMessage(jid, {
+      poll: {
+        name: opts.name,
+        values: opts.values,
+        selectableCount: opts.selectableCount ?? 1,
+      },
+    })
+    return msg
+  }
+
+  const generateReactionMessage = (jid, opts) =>
+    generateWAMessageFromContent(jid, {
+      reactionMessage: { key: opts.key, text: opts.text },
+    })
+
+  const prepareWAMessageMedia = async (media, opts = {}) => {
+    if (!socket.waUploadToServer) {
+      throw new ConnectionError(
+        'Cannot upload media: no baileys package found and socket.waUploadToServer is unavailable',
+        { code: 'LUMINA_ADAPTER_NO_UPLOAD' },
+      )
+    }
+    const [type, source] = Object.entries(media)[0]
+    const uploaded = await socket.waUploadToServer(
+      Buffer.isBuffer(source) ? source : source,
+      { mediaType: type, jid: opts.jid },
+    )
+    return { [type]: { url: uploaded.url, ...uploaded } }
+  }
+
+  return { generateWAMessageFromContent, generatePollMessage, generateReactionMessage, prepareWAMessageMedia }
+}
+
+export class BaileysAdapter {
+  #fns = null
+  #source = 'unknown'
+
+  static async resolve(socket, opts = {}) {
+    const adapter = new BaileysAdapter()
+
+    if (opts.baileys && typeof opts.baileys === 'object') {
+      const fns = extractFns(opts.baileys)
+      if (fns) {
+        adapter.#fns = fns
+        adapter.#source = 'injected-module'
+        return adapter
+      }
+    }
+
+    if (typeof opts.baileysPackage === 'string') {
+      try {
+        const mod = await import(opts.baileysPackage)
+        const fns = extractFns(mod)
+        if (fns) {
+          adapter.#fns = fns
+          adapter.#source = opts.baileysPackage
+          return adapter
+        }
+      } catch {
+        throw new ConnectionError(
+          `baileysPackage "${opts.baileysPackage}" could not be imported or is missing required functions`,
+          { code: 'LUMINA_ADAPTER_PACKAGE_NOT_FOUND' },
+        )
+      }
+    }
+
+    for (const pkg of KNOWN_PACKAGES) {
+      try {
+        const mod = await import(pkg)
+        const fns = extractFns(mod)
+        if (fns) {
+          adapter.#fns = fns
+          adapter.#source = pkg
+          return adapter
+        }
+      } catch {}
+    }
+
+    adapter.#fns = makeFallbackFns(socket)
+    adapter.#source = 'socket-fallback'
+    return adapter
+  }
+
+  get source() {
+    return this.#source
+  }
+
+  get prepareWAMessageMedia() { return this.#fns.prepareWAMessageMedia }
+  get generateWAMessageFromContent() { return this.#fns.generateWAMessageFromContent }
+  get generatePollMessage() { return this.#fns.generatePollMessage }
+  get generateReactionMessage() { return this.#fns.generateReactionMessage }
+}
+
+export default BaileysAdapter

package/src/client/connection.js

@@ -1,11 +1,12 @@
 import { ConnectionError } from '../errors.js'
+import { BaileysAdapter } from './baileys-adapter.js'
 
 export class Connection {
+  #socket = null
+  #adapter = null
+
   constructor(socket, opts = {}) {
     if (!socket) throw new ConnectionError('socket is required', { code: 'LUMINA_CONNECTION_NO_SOCKET' })
-    this.#socket = socket
-    this.uploadJid = opts.uploadJid
-    this.logger = opts.logger
 
     const required = ['relayMessage', 'ev']
     for (const m of required) {
@@ -15,34 +16,46 @@ export class Connection {
         })
       }
     }
+
+    this.#socket = socket
+    this.uploadJid = opts.uploadJid
+    this.logger = opts.logger
+    this.#adapter = BaileysAdapter.resolve(socket, opts)
   }
 
-  #socket = null
+  async #fn() {
+    if (this.#adapter instanceof Promise) this.#adapter = await this.#adapter
+    return this.#adapter
+  }
 
   async uploadMedia(media, opts = {}) {
-    const { prepareWAMessageMedia } = await import('@whiskeysockets/baileys')
+    const adapter = await this.#fn()
     const jid = opts.jid ?? this.uploadJid
     if (!jid) {
       throw new ConnectionError('uploadJid must be set (via constructor or per-call)', {
         code: 'LUMINA_CONNECTION_NO_UPLOAD_JID',
       })
     }
-    return prepareWAMessageMedia(media, { upload: this.#socket.waUploadToServer, jid, ...opts })
+    return adapter.prepareWAMessageMedia(media, {
+      upload: this.#socket.waUploadToServer,
+      jid,
+      ...opts,
+    })
   }
 
   async generateMessage(jid, content, opts = {}) {
-    const { generateWAMessageFromContent } = await import('@whiskeysockets/baileys')
-    return generateWAMessageFromContent(jid, content, opts)
+    const adapter = await this.#fn()
+    return adapter.generateWAMessageFromContent(jid, content, opts)
   }
 
   async generatePoll(jid, opts) {
-    const { generatePollMessage } = await import('@whiskeysockets/baileys')
-    return generatePollMessage(jid, opts)
+    const adapter = await this.#fn()
+    return adapter.generatePollMessage(jid, opts)
   }
 
   async generateReaction(jid, opts) {
-    const { generateReactionMessage } = await import('@whiskeysockets/baileys')
-    return generateReactionMessage(jid, opts)
+    const adapter = await this.#fn()
+    return adapter.generateReactionMessage(jid, opts)
   }
 
   async relayMessage(jid, message, opts = {}) {
@@ -65,8 +78,11 @@ export class Connection {
     this.#socket.ev.off(event, handler)
   }
 
-  get raw() {
-    return this.#socket
+  get raw() { return this.#socket }
+
+  async adapterSource() {
+    const adapter = await this.#fn()
+    return adapter.source
   }
 }