@shoru/kitten 0.0.1-beta

package/src/formatter/format-message.js

@@ -0,0 +1,144 @@
+import {
+  isJidGroup, 
+  areJidsSameUser,
+  getDevice,
+  downloadMediaMessage,
+  getContentType,
+  isLidUser,
+  jidNormalizedUser
+ } from 'baileys';
+
+import {
+  getTimeString,
+  isString,
+  toNumber,
+  toBase64,
+  getPN
+} from '#utils.js';
+
+const extractMessage = (message) => {
+  let type = getContentType(message);
+  let data = message?.[type];
+
+  // cases like viewonce or document messages etc
+  if (data?.message) {
+    const innerType = getContentType(data.message);
+    if (innerType) {
+      type = innerType;
+      data = data.message[type];
+    }
+  }
+  return [type, data];
+};
+
+const extractContent = (message = {}) => ({
+    body: message.text ?? message.caption ??
+      (isString(message) ? message : undefined),
+    mentions: message.contextInfo?.mentionedJid,
+    groupMentions: message.contextInfo?.groupMentions,
+    mimetype: message.mimetype,
+    fileName: message.fileName,
+    pageCount: message.pageCount,
+    fileLength: toNumber(message.fileLength),
+    hash: toBase64(message.fileSha256),
+    isViewOnce: message.viewOnce,
+    url: message.matchedText,
+    description: message.description,
+    thumbnail: message.jpegThumbnail,
+});
+
+const load = async (x) => downloadMediaMessage(x, 'buffer', {});
+
+export const formatMessage = (sock, raw) => {
+  const myId = jidNormalizedUser(sock.user.lid);
+  const [type, messageData] = extractMessage(raw.message);
+
+  const {
+    pushName: name,
+    messageTimestamp,
+    participant: p1,
+    broadcast,
+    key,
+    key: {
+      remoteJid: roomId, 
+      id, fromMe,
+      participant: p2,
+    }
+  } = raw;
+
+  const jid = fromMe ? myId : p2 || p1 || roomId;
+
+  const {
+    quotedMessage,
+    participant: quotedSender,
+    stanzaId: quotedId,
+    isForwarded,
+    forwardingScore,
+  } = messageData?.contextInfo || {};
+  const [quotedType, quotedData] = extractMessage(quotedMessage);
+
+  const quotedKey = {
+    id: quotedId,
+    participant: quotedSender,
+    remoteJid: roomId,
+    fromMe: areJidsSameUser(quotedSender, myId)
+  };
+
+  return {
+    type,
+    name,
+    id,
+    broadcast,
+    isForwarded,
+    forwardingScore,
+    fromMe,
+    jid,
+    roomId,
+    timestamp: toNumber(messageTimestamp),
+    isLid: isLidUser(jid),
+    device: getDevice(id),
+    isGroup: isJidGroup(roomId),
+    timeString: getTimeString(messageTimestamp),
+    ...extractContent(messageData),
+    key, raw,
+    contextInfo: {
+      stanzaId: id,
+      participant: jid,
+      remoteJid: roomId
+    },
+    load() {
+      return load(this.raw)
+    },
+    senderIs(id) {
+      return areJidsSameUser(this.jid, id)
+    },
+    pn() {
+      return getPN(sock, this.jid)
+    },
+    quoted: quotedData ? {
+      type: quotedType,
+      jid: quotedSender,
+      id: quotedId,
+      ...extractContent(quotedData),
+      key: quotedKey,
+      contextInfo: {
+        stanzaId: quotedId,
+        participant: quotedSender,
+        remoteJid: roomId
+      },
+      raw: {
+        key: quotedKey,
+        message: quotedMessage
+      },
+      load() {
+        return load(this.raw)
+      },
+      senderIs(id) {
+        return areJidsSameUser(this.jid, id)
+      },
+      pn() {
+        return getPN(sock, this.jid)
+      }
+    }: undefined,
+  }
+}

package/src/formatter/index.js

@@ -0,0 +1,11 @@
+import { formatMessage } from './format-message.js';
+
+export const formatter = async (wa, event, eventName) => {
+  eventName ??= 'massages.upsert';
+  
+  switch (eventName) {
+    case 'massages.upsert':
+      return formatMessage(wa, event);
+    default: return event;
+  }
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export * from "#auth.js";
+export * from "#client.js";
+export * from "#internals.js";
+export * from "#utils.js";

package/src/internals/config.js

@@ -0,0 +1,40 @@
+import { cosmiconfig } from 'cosmiconfig';
+import { defu } from 'defu';
+
+const loadDefaultConfig = async () => {
+  try {
+    const module = await import('../config/default.js');
+    const defaultConfig = module?.default ?? module;
+
+    if (typeof defaultConfig !== 'object' || defaultConfig === null || Array.isArray(defaultConfig)) {
+      throw new Error(`[INTERNAL_CONFIG] default config must export an object`);
+    }
+    
+    return defaultConfig;
+  } catch (err) {
+    throw new Error(`[INTERNAL_CONFIG] Error loading default config: ${err.message}`, { cause: err });
+  }
+};
+
+const loadUserConfig = async () => {
+  try {
+    const explorer = cosmiconfig('kittenwa');
+    const result = await explorer.search();
+    return result?.config ?? {};
+  } catch (err) {
+    throw new Error(`[USER_CONFIG] Error loading user config: ${err.message}`, { cause: err });
+  }
+};
+
+export const loadConfig = async () => {
+  const [userConfig, defaultConfig] = await Promise.all([
+    loadUserConfig(),
+    loadDefaultConfig()
+  ]);
+  
+  return defu(userConfig, defaultConfig);
+};
+
+const configObject = await loadConfig()
+
+export const config = Object.freeze(configObject);

package/src/internals/index.js

@@ -0,0 +1,5 @@
+export * from './logger.js';
+export * from './lmdb-manager.js';
+export * from './config.js';
+export * from './spinner.js';
+export * from './plugin-manager.js'

package/src/internals/lmdb-manager.js

@@ -0,0 +1,52 @@
+import { open } from 'lmdb';
+import { logger } from './logger.js';
+import { config } from './config.js';
+
+class LMDBDatabaseManager {
+  #db = null;
+  #config = config.db;
+  #isClosing = false;
+
+  constructor(config) {
+    this.#config = { ...this.#config, ...config };
+  }
+
+  get db() {
+    if (this.#isClosing) {
+      throw new Error('[LMDBManager] Database is closing');
+    }
+
+    if (!this.#db) {
+      this.#db = open(this.#config);
+    }
+
+    return this.#db;
+  }
+
+  get isOpen() {
+    return this.#db !== null && !this.#isClosing;
+  }
+
+  get config() {
+    return Object.freeze({ ...this.#config });
+  }
+
+  async close() {
+    if (!this.#db || this.#isClosing) return;
+
+    this.#isClosing = true;
+
+    try {
+      await this.#db.flushed;
+      await this.#db.close();
+    } catch (err) {
+      logger.error(err, '[LMDBManager] Error closing database');
+      throw err;
+    } finally {
+      this.#db = null;
+      this.#isClosing = false;
+    }
+  }
+}
+
+export const LMDBManager = new LMDBDatabaseManager();

package/src/internals/logger.js

@@ -0,0 +1,15 @@
+import pino from "pino";
+
+const logger = pino({
+  transport: {
+    target: "pino-pretty",
+    options: { 
+      colorize: true,
+      ignore: "pid,hostname",
+    }
+  }
+});
+
+logger.prompt = console.log.bind(console);
+
+export { logger, pino };