@badzz88/baileys 8.5.7 → 8.5.8

package/lib/Store/make-in-memory-store.js

@@ -1,604 +1,244 @@
-'use strict'
+import fs from "fs";
+import * as WAProto_1 from "../../WAProto/index.js";
+import * as Defaults_1 from "../Defaults/index.js";
+import { LabelAssociationType } from "../Types/LabelAssociation.js";
+import * as Utils_1 from "../Utils/index.js";
+import * as WABinary_1 from "../WABinary/index.js";
+import makeOrderedDictionary from "./make-ordered-dictionary.js";
+import { ObjectRepository } from "./object-repository.js";
+import KeyedDB from "./keyed-db.js";
 
-var __importDefault =
-	(this && this.__importDefault) ||
-	function (mod) {
-		return mod && mod.__esModule ? mod : { default: mod }
-	}
+const waChatKey = (pin) => ({
+    key: (c) =>
+        (pin ? (c.pinned ? "1" : "0") : "") +
+        (c.archived ? "0" : "1") +
+        (c.conversationTimestamp
+            ? c.conversationTimestamp.toString(16).padStart(8, "0")
+            : "") +
+        c.id,
+    compare: (k1, k2) => k2.localeCompare(k1)
+});
 
-Object.defineProperty(exports, '__esModule', { value: true })
+export const waMessageID = (m) => m.key.id || "";
 
-const WAProto_1 = require('../../WAProto')
-const Defaults_1 = require('../Defaults')
-const LabelAssociation_1 = require('../Types/LabelAssociation')
-const Utils_1 = require('../Utils')
-const WABinary_1 = require('../WABinary')
-const Store_1 = require('./make-ordered-dictionary')
-const object_repository_1 = require('./object-repository')
+export const waLabelAssociationKey = {
+    key: (la) =>
+        la.type === LabelAssociationType.Chat
+            ? la.chatId + la.labelId
+            : la.chatId + la.messageId + la.labelId,
+    compare: (k1, k2) => k2.localeCompare(k1)
+};
 
-const waChatKey = pin => ({
-	key: c =>
-		(pin ? (c.pinned ? '1' : '0') : '') +
-		(c.archived ? '0' : '1') +
-		(c.conversationTimestamp ? c.conversationTimestamp.toString(16).padStart(8, '0') : '') +
-		c.id,
-	compare: (k1, k2) => k2.localeCompare(k1)
-})
+const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID);
 
-const waMessageID = m => m.key.id || ''
+export default function makeInMemoryStore(config) {
+    const socket = config.socket;
+    const chatKey = config.chatKey || waChatKey(true);
+    const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey;
+    const logger =
+        config.logger ||
+        Defaults_1.DEFAULT_CONNECTION_CONFIG.logger.child({
+            stream: "in-mem-store"
+        });
 
-const waLabelAssociationKey = {
-	key: la =>
-		la.type === LabelAssociation_1.LabelAssociationType.Chat
-			? la.chatId + la.labelId
-			: la.chatId + la.messageId + la.labelId,
-	compare: (k1, k2) => k2.localeCompare(k1)
-}
+    const chats = new KeyedDB(chatKey.compare, chatKey.key);
+    const messages = {};
+    const contacts = {};
+    const groupMetadata = {};
+    const presences = {};
+    const state = { connection: "close" };
+    const labels = new ObjectRepository();
+    const labelAssociations = new KeyedDB(labelAssociationKey.compare, labelAssociationKey.key);
 
-const makeMessagesDictionary = () => Store_1.makeOrderedDictionary(waMessageID)
+    const assertMessageList = (jid) => {
+        if (!messages[jid]) messages[jid] = makeMessagesDictionary();
+        return messages[jid];
+    };
 
-const ENCRYPTED_STORE_MARKER = 'xazbails-store-v1'
+    const contactsUpsert = (newContacts) => {
+        const oldContacts = new Set(Object.keys(contacts));
+        for (const contact of newContacts) {
+            oldContacts.delete(contact.id);
+            contacts[contact.id] = { ...(contacts[contact.id] || {}), ...contact };
+        }
+        return oldContacts;
+    };
 
-const deriveStoreKey = secret => {
-	const { createHash } = require('crypto')
-	return createHash('sha256').update(String(secret)).digest()
-}
+    const labelsUpsert = (newLabels) => {
+        for (const label of newLabels) labels.upsertById(label.id, label);
+    };
 
-const encryptStoreJSON = (jsonStr, secret) => {
-	const { createCipheriv, randomBytes } = require('crypto')
-	const key = deriveStoreKey(secret)
-	const iv = randomBytes(12)
-	const cipher = createCipheriv('aes-256-gcm', key, iv)
-	const encrypted = Buffer.concat([cipher.update(jsonStr, 'utf-8'), cipher.final()])
-	const authTag = cipher.getAuthTag()
-	return JSON.stringify({
-		marker: ENCRYPTED_STORE_MARKER,
-		iv: iv.toString('base64'),
-		authTag: authTag.toString('base64'),
-		data: encrypted.toString('base64')
-	})
-}
+    const bind = (ev) => {
+        ev.on("connection.update", (update) => Object.assign(state, update));
 
-const decryptStoreJSON = (fileStr, secret) => {
-	const parsed = JSON.parse(fileStr)
-	if (parsed.marker !== ENCRYPTED_STORE_MARKER) {
-		// not an encrypted store file -- assume it's already plain JSON
-		return fileStr
-	}
-	const { createDecipheriv } = require('crypto')
-	const key = deriveStoreKey(secret)
-	const iv = Buffer.from(parsed.iv, 'base64')
-	const authTag = Buffer.from(parsed.authTag, 'base64')
-	const decipher = createDecipheriv('aes-256-gcm', key, iv)
-	decipher.setAuthTag(authTag)
-	const decrypted = Buffer.concat([decipher.update(Buffer.from(parsed.data, 'base64')), decipher.final()])
-	return decrypted.toString('utf-8')
-}
+        ev.on("messaging-history.set", ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
+            if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) return;
+            if (isLatest) {
+                chats.clear();
+                for (const id in messages) delete messages[id];
+            }
+            chats.insertIfAbsent(...newChats);
+            const oldContacts = contactsUpsert(newContacts);
+            if (isLatest) for (const jid of oldContacts) delete contacts[jid];
+            for (const msg of newMessages) {
+                const jid = msg.key.remoteJid;
+                const list = assertMessageList(jid);
+                list.upsert(msg, "prepend");
+            }
+        });
 
-const makeInMemoryStore = config => {
-	const socket = config.socket
-	const chatKey = config.chatKey || waChatKey(true)
-	const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey
-	const logger =
-		config.logger ||
-		Defaults_1.DEFAULT_CONNECTION_CONFIG.logger.child({
-			stream: 'in-mem-store'
-		})
-	const KeyedDB = require('@adiwajshing/keyed-db').default
-	const chats = new KeyedDB(chatKey, c => c.id)
-	const messages = {}
-	const contacts = {}
-	const groupMetadata = {}
-	const presences = {}
-	const state = { connection: 'close' }
-	const labels = new object_repository_1.ObjectRepository()
-	const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key)
-	const maxMessagesPerChat = config.maxMessagesPerChat
-	const trimMessagesIfNeeded = jid => {
-		if (!maxMessagesPerChat) return
-		const list = messages[jid]
-		if (!list || list.array.length <= maxMessagesPerChat) return
-		while (list.array.length > maxMessagesPerChat) {
-			let oldest = list.array[0]
-			for (const m of list.array) {
-				if ((m.messageTimestamp || 0) < (oldest.messageTimestamp || 0)) oldest = m
-			}
-			list.remove(oldest)
-		}
-	}
-	const assertMessageList = jid => {
-		if (!messages[jid]) {
-			messages[jid] = makeMessagesDictionary()
-		}
-		return messages[jid]
-	}
-	const contactsUpsert = newContacts => {
-		const oldContacts = new Set(Object.keys(contacts))
-		for (const contact of newContacts) {
-			oldContacts.delete(contact.id)
-			contacts[contact.id] = Object.assign(contacts[contact.id] || {}, contact)
-		}
-		return oldContacts
-	}
-	const labelsUpsert = newLabels => {
-		for (const label of newLabels) {
-			labels.upsertById(label.id, label)
-		}
-	}
-	/**
-	 * binds to a BaileysEventEmitter.
-	 * It listens to all events and constructs a state that you can query accurate data from.
-	 * Eg. can use the store to fetch chats, contacts, messages etc.
-	 * @param ev typically the event emitter from the socket connection
-	 */
-	const bind = ev => {
-		ev.on('connection.update', update => {
-			Object.assign(state, update)
-		})
-		ev.on(
-			'messaging-history.set',
-			({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
-				if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
-					return // FOR NOW,
-					//TODO: HANDLE
-				}
-				if (isLatest) {
-					chats.clear()
-					for (const id in messages) {
-						delete messages[id]
-					}
-				}
-				const chatsAdded = chats.insertIfAbsent(...newChats).length
-				logger.debug({ chatsAdded }, 'synced chats')
-				const oldContacts = contactsUpsert(newContacts)
-				if (isLatest) {
-					for (const jid of oldContacts) {
-						delete contacts[jid]
-					}
-				}
-				logger.debug({ deletedContacts: isLatest ? oldContacts.size : 0, newContacts }, 'synced contacts')
-				for (const msg of newMessages) {
-					const jid = msg.key.remoteJid
-					const list = assertMessageList(jid)
-					list.upsert(msg, 'prepend')
-					trimMessagesIfNeeded(jid)
-				}
-				logger.debug({ messages: newMessages.length }, 'synced messages')
-			}
-		)
-		ev.on('contacts.upsert', contacts => {
-			contactsUpsert(contacts)
-		})
-		ev.on('contacts.update', async updates => {
-			for (const update of updates) {
-				let contact
-				if (contacts[update.id]) {
-					contact = contacts[update.id]
-				} else {
-					const contactHashes = await Promise.all(
-						Object.keys(contacts).map(async contactId => {
-							const { user } = WABinary_1.jidDecode(contactId)
-							return [
-								contactId,
-								(await Utils_1.md5(Buffer.from(user + 'WA_ADD_NOTIF', 'utf8'))).toString('base64').slice(0, 3)
-							]
-						})
-					)
-					contact = contacts[contactHashes.find(([, b]) => b === update.id?.[0]) || ''] // find contact by attrs.hash, when user is not saved as a contact
-				}
-				if (contact) {
-					if (update.imgUrl === 'changed') {
-						contact.imgUrl = socket ? await socket.profilePictureUrl(contact.id) : undefined
-					} else if (update.imgUrl === 'removed') {
-						delete contact.imgUrl
-					}
-				} else {
-					return logger.debug({ update }, 'got update for non-existant contact')
-				}
-				Object.assign(contacts[contact.id], contact)
-			}
-		})
-		ev.on('chats.upsert', newChats => {
-			chats.upsert(...newChats)
-		})
-		ev.on('chats.update', updates => {
-			for (let update of updates) {
-				const result = chats.update(update.id, chat => {
-					if (update.unreadCount > 0) {
-						update = { ...update }
-						update.unreadCount = (chat.unreadCount || 0) + update.unreadCount
-					}
-					Object.assign(chat, update)
-				})
-				if (!result) {
-					logger.debug({ update }, 'got update for non-existant chat')
-				}
-			}
-		})
-		ev.on('labels.edit', label => {
-			if (label.deleted) {
-				return labels.deleteById(label.id)
-			}
-			// WhatsApp can store only up to 20 labels
-			if (labels.count() < 20) {
-				return labels.upsertById(label.id, label)
-			}
-			logger.error('Labels count exceed')
-		})
-		ev.on('labels.association', ({ type, association }) => {
-			switch (type) {
-				case 'add':
-					labelAssociations.upsert(association)
-					break
-				case 'remove':
-					labelAssociations.delete(association)
-					break
-				default:
-					logger.error({ type }, 'unknown label association operation type')
-			}
-		})
-		ev.on('presence.update', ({ id, presences: update }) => {
-			presences[id] = presences[id] || {}
-			Object.assign(presences[id], update)
-		})
-		ev.on('chats.delete', deletions => {
-			for (const item of deletions) {
-				if (chats.get(item)) {
-					chats.deleteById(item)
-				}
-			}
-		})
-		ev.on('messages.upsert', ({ messages: newMessages, type }) => {
-			switch (type) {
-				case 'append':
-				case 'notify':
-					for (const msg of newMessages) {
-						const jid = WABinary_1.jidNormalizedUser(msg.key.remoteJid)
-						const list = assertMessageList(jid)
-						list.upsert(msg, 'append')
-						trimMessagesIfNeeded(jid)
-						if (type === 'notify' && !chats.get(jid)) {
-							ev.emit('chats.upsert', [
-								{
-									id: jid,
-									conversationTimestamp: Utils_1.toNumber(msg.messageTimestamp),
-									unreadCount: 1
-								}
-							])
-						}
-					}
-					break
-			}
-		})
-		ev.on('messages.update', updates => {
-			for (const { update, key } of updates) {
-				const list = assertMessageList(WABinary_1.jidNormalizedUser(key.remoteJid))
-				if (update?.status) {
-					const listStatus = list.get(key.id)?.status
-					if (listStatus && update?.status <= listStatus) {
-						logger.debug({ update, storedStatus: listStatus }, 'status stored newer then update')
-						delete update.status
-						logger.debug({ update }, 'new update object')
-					}
-				}
-				const result = list.updateAssign(key.id, update)
-				if (!result) {
-					logger.debug({ update }, 'got update for non-existent message')
-				}
-			}
-		})
-		ev.on('messages.delete', item => {
-			if ('all' in item) {
-				const list = messages[item.jid]
-				list?.clear()
-			} else {
-				const jid = item.keys[0].remoteJid
-				const list = messages[jid]
-				if (list) {
-					const idSet = new Set(item.keys.map(k => k.id))
-					list.filter(m => !idSet.has(m.key.id))
-				}
-			}
-		})
-		ev.on('groups.update', updates => {
-			for (const update of updates) {
-				const id = update.id
-				if (groupMetadata[id]) {
-					Object.assign(groupMetadata[id], update)
-				} else {
-					logger.debug({ update }, 'got update for non-existant group metadata')
-				}
-			}
-		})
-		ev.on('group-participants.update', ({ id, participants, action }) => {
-			const metadata = groupMetadata[id]
-			if (metadata) {
-				switch (action) {
-					case 'add':
-						metadata.participants.push(
-							...participants.map(id => ({
-								id,
-								isAdmin: false,
-								isSuperAdmin: false
-							}))
-						)
-						break
-					case 'demote':
-					case 'promote':
-						for (const participant of metadata.participants) {
-							if (participants.includes(participant.id)) {
-								participant.isAdmin = action === 'promote'
-							}
-						}
-						break
-					case 'remove':
-						metadata.participants = metadata.participants.filter(p => !participants.includes(p.id))
-						break
-				}
-			}
-		})
-		ev.on('message-receipt.update', updates => {
-			for (const { key, receipt } of updates) {
-				const obj = messages[key.remoteJid]
-				const msg = obj?.get(key.id)
-				if (msg) {
-					Utils_1.updateMessageWithReceipt(msg, receipt)
-				}
-			}
-		})
-		ev.on('messages.reaction', reactions => {
-			for (const { key, reaction } of reactions) {
-				const obj = messages[key.remoteJid]
-				const msg = obj?.get(key.id)
-				if (msg) {
-					Utils_1.updateMessageWithReaction(msg, reaction)
-				}
-			}
-		})
-		ev.on('settings.update', ({ setting, value }) => {
-			state.settings = state.settings || {}
-			state.settings[setting] = value
-		})
-		ev.on('labels.reorder', ({ labelIds }) => {
-			let order = 0
-			for (const id of labelIds) {
-				const label = labels.findById(id)
-				if (label) {
-					labels.upsertById(id, { ...label, order: order++ })
-				}
-				order++
-			}
-		})
-		ev.on('call.scheduled', ({ messageKey, scheduledCall, chatId }) => {
-			state.scheduledCalls = state.scheduledCalls || {}
-			state.scheduledCalls[messageKey.id] = { key: messageKey, scheduledCall, chatId }
-		})
-		ev.on('call.schedule-cancelled', ({ messageKey, editedCallKey }) => {
-			if (state.scheduledCalls?.[editedCallKey?.id]) {
-				delete state.scheduledCalls[editedCallKey.id]
-			}
-		})
-		ev.on('payment.split', ({ messageKey, splitPayment }) => {
-			const list = assertMessageList(WABinary_1.jidNormalizedUser(messageKey.remoteJid))
-			const msg = list?.get(messageKey.id)
-			if (msg) {
-				msg.splitPayment = splitPayment
-			}
-		})
-		ev.on('message.comment', ({ commentKey, comment, targetKey }) => {
-			const list = assertMessageList(WABinary_1.jidNormalizedUser(targetKey.remoteJid))
-			const msg = list?.get(targetKey.id)
-			if (msg) {
-				msg.commentCount = (msg.commentCount || 0) + 1
-			}
-		})
-		ev.on('poll.add-option', ({ pollKey, addedOption }) => {
-			const list = assertMessageList(WABinary_1.jidNormalizedUser(pollKey.remoteJid))
-			const msg = list?.get(pollKey.id)
-			if (msg?.message) {
-				const poll =
-					msg.message.pollCreationMessage ||
-					msg.message.pollCreationMessageV3 ||
-					msg.message.pollCreationMessageV5 ||
-					msg.message.pollCreationMessageV6
-				if (poll && addedOption) {
-					poll.options = [...(poll.options || []), addedOption]
-				}
-			}
-		})
-		ev.on('chats.lock', ({ id, locked }) => {
-			const result = chats.update(id, chat => {
-				chat.locked = locked
-			})
-			if (!result) logger.debug({ id }, 'got chats.lock for non-existent chat')
-		})
-		ev.on('messaging-history.status', ({ syncType, status }) => {
-			state.historySyncStatus = state.historySyncStatus || {}
-			state.historySyncStatus[syncType] = status
-		})
-	}
-	const toJSON = () => ({
-		chats,
-		contacts,
-		messages,
-		labels,
-		labelAssociations,
-		groupMetadata,
-		presences,
-		state
-	})
-	const fromJSON = json => {
-		chats.upsert(...json.chats)
-		labelAssociations.upsert(...(json.labelAssociations || []))
-		contactsUpsert(Object.values(json.contacts))
-		labelsUpsert(Object.values(json.labels || {}))
-		for (const jid in json.messages) {
-			const list = assertMessageList(jid)
-			for (const msg of json.messages[jid]) {
-				list.upsert(WAProto_1.proto.WebMessageInfo.fromObject(msg), 'append')
-			}
-			trimMessagesIfNeeded(jid)
-		}
-		if (json.groupMetadata) {
-			Object.assign(groupMetadata, json.groupMetadata)
-		}
-		if (json.presences) {
-			Object.assign(presences, json.presences)
-		}
-		if (json.state) {
-			Object.assign(state, json.state)
-		}
-	}
-	return {
-		chats,
-		contacts,
-		messages,
-		groupMetadata,
-		state,
-		presences,
-		labels,
-		labelAssociations,
-		bind,
-		/** loads messages from the store, if not found -- uses the legacy connection */
-		loadMessages: async (jid, count, cursor) => {
-			const list = assertMessageList(jid)
-			const mode = !cursor || 'before' in cursor ? 'before' : 'after'
-			const cursorKey = !!cursor ? ('before' in cursor ? cursor.before : cursor.after) : undefined
-			const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined
-			let messages
-			if (list && mode === 'before' && (!cursorKey || cursorValue)) {
-				if (cursorValue) {
-					const msgIdx = list.array.findIndex(m => m.key.id === cursorKey?.id)
-					messages = list.array.slice(0, msgIdx)
-				} else {
-					messages = list.array
-				}
-				const diff = count - messages.length
-				if (diff < 0) {
-					messages = messages.slice(-count) // get the last X messages
-				}
-			} else {
-				messages = []
-			}
-			return messages
-		},
-		/**
-		 * Get all available labels for profile
-		 *
-		 * Keep in mind that the list is formed from predefined tags and tags
-		 * that were "caught" during their editing.
-		 */
-		getLabels: () => {
-			return labels
-		},
-		/**
-		 * Get labels for chat
-		 *
-		 * @returns Label IDs
-		 **/
-		getChatLabels: chatId => {
-			return labelAssociations.filter(la => la.chatId === chatId).all()
-		},
-		/**
-		 * Get labels for message
-		 *
-		 * @returns Label IDs
-		 **/
-		getMessageLabels: messageId => {
-			const associations = labelAssociations.filter(la => la.messageId === messageId).all()
-			return associations.map(({ labelId }) => labelId)
-		},
-		loadMessage: async (jid, id) => messages[jid]?.get(id),
-		mostRecentMessage: async jid => {
-			const message = messages[jid]?.array.slice(-1)[0]
-			return message
-		},
-		fetchImageUrl: async (jid, suki) => {
-			const contact = contacts[jid]
-			if (!contact) {
-				return suki?.profilePictureUrl(jid)
-			}
-			if (typeof contact.imgUrl === 'undefined') {
-				contact.imgUrl = await suki?.profilePictureUrl(jid)
-			}
-			return contact.imgUrl
-		},
-		fetchGroupMetadata: async (jid, suki) => {
-			if (!groupMetadata[jid]) {
-				const metadata = await suki?.groupMetadata(jid)
-				if (metadata) {
-					groupMetadata[jid] = metadata
-				}
-			}
-			return groupMetadata[jid]
-		},
-		// fetchBroadcastListInfo: async(jid: string, sock: WASocket | undefined) => {
-		// 	if(!groupMetadata[jid]) {
-		// 		const metadata = await sock?.getBroadcastListInfo(jid)
-		// 		if(metadata) {
-		// 			groupMetadata[jid] = metadata
-		// 		}
-		// 	}
-		// 	return groupMetadata[jid]
-		// },
-		fetchMessageReceipts: async ({ remoteJid, id }) => {
-			const list = messages[remoteJid]
-			const msg = list?.get(id)
-			return msg?.userReceipt
-		},
-		toJSON,
-		fromJSON,
-		writeToFile: path => {
-			// require fs here so that in case "fs" is not available -- the app does not crash
-			const { writeFileSync } = require('fs')
-			const jsonStr = JSON.stringify(toJSON())
-			writeFileSync(path, config.encryptionKey ? encryptStoreJSON(jsonStr, config.encryptionKey) : jsonStr)
-		},
-		readFromFile: path => {
-			// require fs here so that in case "fs" is not available -- the app does not crash
-			const { readFileSync, existsSync } = require('fs')
-			if (existsSync(path)) {
-				logger.debug({ path }, 'reading from file')
-				const fileStr = readFileSync(path, { encoding: 'utf-8' })
-				const jsonStr = config.encryptionKey ? decryptStoreJSON(fileStr, config.encryptionKey) : fileStr
-				const json = JSON.parse(jsonStr)
-				fromJSON(json)
-			}
-		},
-		/**
-		 * Periodically writes the store to `path` every `intervalMs` (default 30s),
-		 * and does one final write when the bound socket closes (if `registerSocketEndHandler`
-		 * is available on it). Returns a function that stops the auto-save.
-		 */
-		startAutoSave: (path, intervalMs = 30000) => {
-			const timer = setInterval(() => {
-				try {
-					const { writeFileSync } = require('fs')
-					const jsonStr = JSON.stringify(toJSON())
-					writeFileSync(path, config.encryptionKey ? encryptStoreJSON(jsonStr, config.encryptionKey) : jsonStr)
-				} catch (error) {
-					logger.warn({ error, path }, 'failed to auto-save store')
-				}
-			}, intervalMs)
-			if (timer.unref) timer.unref()
-			if (socket && typeof socket.registerSocketEndHandler === 'function') {
-				socket.registerSocketEndHandler(async () => {
-					try {
-						const { writeFileSync } = require('fs')
-						const jsonStr = JSON.stringify(toJSON())
-						writeFileSync(path, config.encryptionKey ? encryptStoreJSON(jsonStr, config.encryptionKey) : jsonStr)
-						logger.debug({ path }, 'final store flush on socket end')
-					} catch (error) {
-						logger.warn({ error, path }, 'failed to flush store on socket end')
-					}
-				})
-			}
-			return () => clearInterval(timer)
-		}
-	}
-}
+        ev.on("contacts.upsert", contactsUpsert);
 
-exports.waChatKey = waChatKey
-exports.waMessageID = waMessageID
-exports.waLabelAssociationKey = waLabelAssociationKey
-exports.makeInMemoryStore = makeInMemoryStore
+        ev.on("contacts.update", async (updates) => {
+            for (const update of updates) {
+                const contact = contacts[update.id];
+                if (contact) Object.assign(contact, update);
+            }
+        });
+
+        ev.on("chats.upsert", (newChats) => chats.upsert(...newChats));
+
+        ev.on("chats.update", (updates) => {
+            for (let update of updates) {
+                chats.update(update.id, (chat) => Object.assign(chat, update));
+            }
+        });
+
+        ev.on("labels.edit", (label) => {
+            if (label.deleted) return labels.deleteById(label.id);
+            if (labels.count() < 20) labels.upsertById(label.id, label);
+        });
+
+        ev.on("labels.association", ({ type, association }) => {
+            if (type === "add") labelAssociations.upsert(association);
+            if (type === "remove") labelAssociations.delete(association);
+        });
+
+        ev.on("presence.update", ({ id, presences: update }) => {
+            presences[id] = presences[id] || {};
+            Object.assign(presences[id], update);
+        });
+
+        ev.on("chats.delete", (deletions) => {
+            for (const item of deletions) chats.deleteById(item);
+        });
+
+        ev.on("messages.upsert", ({ messages: newMessages, type }) => {
+            if (type !== "append" && type !== "notify") return;
+            for (const msg of newMessages) {
+                const jid = WABinary_1.jidNormalizedUser(msg.key.remoteJid);
+                const list = assertMessageList(jid);
+                list.upsert(msg, "append");
+                if (type === "notify" && !chats.get(jid))
+                    ev.emit("chats.upsert", [
+                        {
+                            id: jid,
+                            conversationTimestamp: Utils_1.toNumber(msg.messageTimestamp),
+                            unreadCount: 1
+                        }
+                    ]);
+            }
+        });
+
+        ev.on("messages.update", (updates) => {
+            for (const { update, key } of updates) {
+                const list = assertMessageList(WABinary_1.jidNormalizedUser(key.remoteJid));
+                list.updateAssign(key.id, update);
+            }
+        });
+
+        ev.on("messages.delete", (item) => {
+            if ("all" in item) messages[item.jid]?.clear();
+            else {
+                const jid = item.keys[0].remoteJid;
+                const list = messages[jid];
+                if (list) {
+                    const idSet = new Set(item.keys.map((k) => k.id));
+                    list.filter((m) => !idSet.has(m.key.id));
+                }
+            }
+        });
+    };
+
+    const toJSON = () => ({
+        chats,
+        contacts,
+        messages,
+        labels,
+        labelAssociations
+    });
+
+    const fromJSON = (json) => {
+        chats.upsert(...json.chats);
+        labelAssociations.upsert(...(json.labelAssociations || []));
+        contactsUpsert(Object.values(json.contacts));
+        labelsUpsert(Object.values(json.labels || {}));
+        for (const jid in json.messages) {
+            const list = assertMessageList(jid);
+            for (const msg of json.messages[jid])
+                list.upsert(WAProto_1.proto.WebMessageInfo.fromObject(msg), "append");
+        }
+    };
+    const loadMessage = async (jid, id) => {
+        return messages[jid]?.get(id)
+    }
+
+    /**
+     * Persist the whole store to a JSON file on disk (synchronous, atomic write).
+     * Writes to a temp file first then renames, so a crash mid-write can't
+     * corrupt the existing store file.
+     */
+    const writeToFile = (path) => {
+        try {
+            const tmpPath = `${path}.tmp`;
+            fs.writeFileSync(tmpPath, JSON.stringify(toJSON()));
+            fs.renameSync(tmpPath, path);
+        } catch (err) {
+            logger.error({ err }, "failed to write store to file");
+        }
+    };
+
+    /**
+     * Load store state from a JSON file on disk, if it exists.
+     * Safe to call even if the file was never created yet.
+     */
+    const readFromFile = (path) => {
+        if (!fs.existsSync(path)) return;
+        try {
+            const jsonStr = fs.readFileSync(path, { encoding: "utf-8" });
+            const json = JSON.parse(jsonStr);
+            fromJSON(json);
+        } catch (err) {
+            logger.error({ err }, "failed to read store from file");
+        }
+    };
+
+    /**
+     * Convenience helper: load once from `path` (if present), then keep
+     * saving to the same file every `intervalMs` (default 10s).
+     * Returns a function to stop the auto-save interval.
+     */
+    const writeToFileInterval = (path, intervalMs = 10_000) => {
+        readFromFile(path);
+        const interval = setInterval(() => writeToFile(path), intervalMs);
+        return () => clearInterval(interval);
+    };
+
+    return {
+        chats,
+        contacts,
+        messages,
+        groupMetadata,
+        state,
+        presences,
+        labels,
+        labelAssociations,
+        bind,
+        toJSON,
+        fromJSON,
+        loadMessage,
+        writeToFile,
+        readFromFile,
+        writeToFileInterval
+    };
+}