@jasonwch/nodebb-plugin-meilisearch-r 1.1.1 → 1.2.0

package/lib/hooks/topics.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const winston = nodebb.require('winston');
+const Topics = nodebb.require('./src/topics');
+const batch = nodebb.require('./src/batch');
+const { REINDEX_BATCH_SIZE } = require('../constants');
+const { maybeDefer, meiliWrite, enqueuePending } = require('../pending-queue');
+
+// action:topic.* hooks (post/save/edit/move/restore/delete/merge/changeOwner/purge)
+// plus scheduled-topic publish handling.
+module.exports = function attachTopicHooks(plugin) {
+	plugin.indexTopic = async function ({ topic, tid, fromCid, post }) {
+		const isMove = fromCid !== undefined;
+		if (await maybeDefer(plugin, 'indexTopic', { topic, tid, fromCid, post })) return;
+		// #2: On topic.move, no 'topic' key is provided — re-fetch by tid.
+		if (!topic && tid) {
+			topic = await Topics.getTopicData(tid);
+		}
+		if (!topic) {
+			winston.warn('[plugin/meilisearch] indexTopic: no topic data');
+			return;
+		}
+		// Issue 3: Skip deleted topics (admin editing/moving a deleted topic should not re-index it).
+		if (parseInt(topic.deleted, 10) === 1) {
+			winston.debug(`[plugin/meilisearch] Skipping deleted topic ${topic.tid}`);
+			return;
+		}
+		// Issue 5: Skip scheduled topics (timestamp in future) — indexed on publish via onScheduledPublish.
+		// action:topic.post fires AFTER action:post.save, so the main post may already be in Meili.
+		// Deindex it here to prevent full-search from finding scheduled content prematurely.
+		if (topic.scheduled || (topic.timestamp && topic.timestamp > Date.now())) {
+			const mainPid = post ? post.pid : (parseInt(topic.mainPid, 10) > 0 ? topic.mainPid : null);
+			if (mainPid) {
+				await plugin.client.index('post').deleteDocument(mainPid).catch(() => {});
+			}
+			winston.debug(`[plugin/meilisearch] Skipping scheduled topic ${topic.tid}, deindexed main post ${mainPid || 'N/A'}`);
+			return;
+		}
+		await meiliWrite(plugin, 'indexTopic', { topic, tid, fromCid, post }, () =>
+			plugin.client.index('topic').updateDocuments([{
+				tid: topic.tid,
+				cid: topic.cid,
+				uid: topic.uid,
+				mainPid: topic.mainPid,
+				title: topic.title,
+				timestamp: topic.timestamp,
+			}], { primaryKey: 'tid' }));
+		// #4: On topic move, re-index child posts' cids (fire-and-forget with fallback).
+		if (isMove && topic.tid) {
+			if (plugin.healthy) {
+				plugin.reindexTopicPosts({ tid: topic.tid }).catch(err =>
+					winston.error(`[plugin/meilisearch] reindexTopicPosts failed: ${err.message}`));
+			} else {
+				await enqueuePending('reindexTopicPosts', { tid: topic.tid });
+			}
+		}
+	};
+
+	plugin.deindexTopic = async function ({ topic, tid }) {
+		if (await maybeDefer(plugin, 'deindexTopic', { topic, tid })) return;
+		// Tolerate topic.move-style payloads (no 'topic' key) — extract tid.
+		const topicTid = topic ? topic.tid : tid;
+		if (!topicTid) {
+			winston.warn('[plugin/meilisearch] deindexTopic: no tid');
+			return;
+		}
+		await meiliWrite(plugin, 'deindexTopic', { topic, tid }, () =>
+			plugin.client.index('topic').deleteDocument(topicTid));
+		// Also deindex the topic's posts from the post index so admin /search
+		// (which queries both indexes and bypasses NodeBB's relevance-sort
+		// deleted-content filter for admins) can't surface deleted-topic content.
+		if (plugin.healthy) {
+			plugin.deindexTopicPosts({ tid: topicTid }).catch(err =>
+				winston.error(`[plugin/meilisearch] deindexTopicPosts failed: ${err.message}`));
+		} else {
+			await enqueuePending('deindexTopicPosts', { tid: topicTid });
+		}
+	};
+
+	plugin.restoreTopic = async function ({ topic, tid }) {
+		const topicTid = topic ? topic.tid : tid;
+		if (await maybeDefer(plugin, 'restoreTopic', { topic, tid })) return;
+		// Re-fetch topic if missing (defensive — same pattern as indexTopic).
+		if (!topic && topicTid) {
+			topic = await Topics.getTopicData(topicTid);
+		}
+		if (!topic) {
+			winston.warn('[plugin/meilisearch] restoreTopic: no topic data');
+			return;
+		}
+		// Re-index the topic document.
+		await meiliWrite(plugin, 'restoreTopic', { topic, tid }, () =>
+			plugin.client.index('topic').updateDocuments([{
+				tid: topic.tid,
+				cid: topic.cid,
+				uid: topic.uid,
+				mainPid: topic.mainPid,
+				title: topic.title,
+				timestamp: topic.timestamp,
+			}], { primaryKey: 'tid' }));
+		// Re-index the topic's posts (they were deindexed on delete).
+		if (plugin.healthy) {
+			plugin.reindexTopicPosts({ tid: topic.tid }).catch(err =>
+				winston.error(`[plugin/meilisearch] restoreTopic reindexTopicPosts failed: ${err.message}`));
+		} else {
+			await enqueuePending('reindexTopicPosts', { tid: topic.tid });
+		}
+	};
+
+	plugin.changeTopicOwner = async function ({ topics, toUid }) {
+		if (await maybeDefer(plugin, 'changeTopicOwner', { topics, toUid })) return;
+		// topics have OLD uid — re-fetch from DB to get fresh uid.
+		// Skip deleted or scheduled topics.
+		const validTids = (Array.isArray(topics) ? topics : [])
+			.filter(t => t && t.tid && parseInt(t.deleted, 10) !== 1)
+			.map(t => t.tid);
+		if (!validTids.length) return;
+		const freshTopics = await Topics.getTopicsFields(validTids, ['tid', 'cid', 'uid', 'mainPid', 'title', 'timestamp']);
+		// Fix 7: Skip scheduled topics (timestamp in future).
+		const activeTopics = freshTopics.filter(t => t && !(t.timestamp && t.timestamp > Date.now()));
+		if (!activeTopics.length) return;
+		const docs = activeTopics.map(topic => ({
+			tid: topic.tid,
+			cid: topic.cid,
+			uid: topic.uid,
+			mainPid: topic.mainPid,
+			title: topic.title,
+			timestamp: topic.timestamp,
+		}));
+		await meiliWrite(plugin, 'changeTopicOwner', { topics: activeTopics.map(t => ({ tid: t.tid })), toUid }, () =>
+			plugin.client.index('topic').updateDocuments(docs, { primaryKey: 'tid' }));
+	};
+
+	plugin.onTopicMerge = async function ({ otherTids, mergeIntoTid }) {
+		if (await maybeDefer(plugin, 'onTopicMerge', { otherTids, mergeIntoTid })) return;
+		const postIndex = plugin.client.index('post');
+		// Deindex merged-out topics + their posts (Topics.delete in merge fires no action:topic.delete).
+		for (const tid of otherTids) {
+			await plugin.deindexTopic({ tid });
+			// Merge zeros mainPid before Topics.delete, so deindexTopicPosts can't find the main post.
+			// Fallback: search Meili for any orphaned posts still carrying this tid.
+			try {
+				const result = await postIndex.search('', { filter: `tid = ${parseInt(tid, 10)}`, limit: 1000 });
+				if (result.hits && result.hits.length) {
+					const orphanPids = result.hits.map(h => h.pid);
+					await meiliWrite(plugin, 'deindexPostsPurge', { posts: orphanPids.map(pid => ({ pid })) }, () =>
+						postIndex.deleteDocuments(orphanPids));
+				}
+			} catch (err) {
+				winston.error(`[plugin/meilisearch] onTopicMerge orphan cleanup for tid ${tid} failed: ${err.message}`);
+				plugin.healthy = false;
+				// Don't enqueue — orphans are cleaned by next reindex. Continue to next tid.
+			}
+		}
+		// Re-index the merge target (postcount/lastpost changed; posts already moved via action:post.move).
+		await plugin.indexTopic({ tid: mergeIntoTid });
+		if (plugin.healthy) {
+			plugin.reindexTopicPosts({ tid: mergeIntoTid }).catch(err =>
+				winston.error(`[plugin/meilisearch] onTopicMerge reindexTopicPosts failed: ${err.message}`));
+		}
+	};
+
+	plugin.onScheduledPublish = async function ({ topics }) {
+		const tids = (Array.isArray(topics) ? topics : []).filter(t => t && t.tid).map(t => t.tid);
+		if (!tids.length) return;
+		if (await maybeDefer(plugin, 'onScheduledPublish', { topics: tids.map(tid => ({ tid })) })) return;
+		// Re-index each published topic + its posts (DB deleted=0, timestamp in past now).
+		for (const tid of tids) {
+			await plugin.indexTopic({ tid });
+			if (plugin.healthy) {
+				plugin.reindexTopicPosts({ tid }).catch(err =>
+					winston.error(`[plugin/meilisearch] onScheduledPublish reindexTopicPosts failed: ${err.message}`));
+			}
+		}
+	};
+
+	plugin.deindexTopicsPurge = async function ({ topics }) {
+		if (await maybeDefer(plugin, 'deindexTopicsPurge', { topics })) return;
+		const topicsArr = Array.isArray(topics) ? topics.filter(t => t && t.tid) : [];
+		if (!topicsArr.length) {
+			return;
+		}
+		const tids = topicsArr.map(t => t.tid);
+		const mainPids = topicsArr.map(t => t.mainPid).filter(Boolean);
+		const postIndex = plugin.client.index('post');
+		const reducedPayload = { topics: topicsArr.map(t => ({ tid: t.tid, mainPid: t.mainPid })) };
+		try {
+			await Promise.all([
+				plugin.client.index('topic').deleteDocuments(tids),
+				mainPids.length ? postIndex.deleteDocuments(mainPids) : Promise.resolve(),
+			]);
+			await Promise.all(topicsArr.map(async (t) => {
+				await batch.processSortedSet(
+					`tid:${t.tid}:posts`,
+					async (pids) => {
+						if (!pids.length) {
+							return;
+						}
+						await postIndex.deleteDocuments(pids);
+					},
+					{ batch: REINDEX_BATCH_SIZE },
+				);
+			}));
+		} catch (err) {
+			winston.error(`[plugin/meilisearch] deindexTopicsPurge failed: ${err.message}`);
+			plugin.healthy = false;
+			await enqueuePending('deindexTopicsPurge', reducedPayload);
+		}
+	};
+};

package/lib/pending-queue.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const winston = nodebb.require('winston');
+const db = nodebb.require('./src/database');
+const { PENDING_KEY, PENDING_MAX, DRAIN_MAX, REPLAY_OPS } = require('./constants');
+
+// Persists a write that couldn't be applied to MeiliSearch yet, so it can be replayed later.
+async function enqueuePending(op, payload) {
+	const count = await db.sortedSetCard(PENDING_KEY);
+	if (count >= PENDING_MAX) {
+		const oldest = await db.getSortedSetRange(PENDING_KEY, 0, 0);
+		if (oldest.length) await db.sortedSetRemove(PENDING_KEY, ...oldest);
+	}
+	await db.sortedSetAdd(PENDING_KEY, Date.now(), JSON.stringify({ op, payload }));
+}
+
+// Decides whether a write hook should be deferred instead of applied immediately:
+// buffered in memory during a forced reindex, or queued to the DB while MeiliSearch is unhealthy.
+async function maybeDefer(plugin, op, payload) {
+	if (plugin.reindexingForced) {
+		if (plugin.pendingDuringReindex.length >= PENDING_MAX) {
+			plugin.pendingDuringReindex.shift();
+		}
+		plugin.pendingDuringReindex.push({ op, payload });
+		return true;
+	}
+	if (!plugin.healthy && !(await plugin.checkHealth())) {
+		await enqueuePending(op, payload);
+		return true;
+	}
+	return false;
+}
+
+// Runs a MeiliSearch write, falling back to the pending queue on failure.
+async function meiliWrite(plugin, op, payload, fn) {
+	try {
+		await fn();
+	} catch (err) {
+		winston.error(`[plugin/meilisearch] ${op} write failed: ${err.message}`);
+		plugin.healthy = false;
+		await enqueuePending(op, payload);
+	}
+}
+
+// Replays queued writes once MeiliSearch is healthy again.
+async function drainPending(plugin) {
+	if (!plugin.healthy || plugin.reindexingForced) return;
+	let drained = 0;
+	for (;;) {
+		if (!plugin.healthy) break;
+		const members = await db.getSortedSetRange(PENDING_KEY, 0, 49);
+		if (!members.length) break;
+		await db.sortedSetRemove(PENDING_KEY, ...members);
+		for (const member of members) {
+			try {
+				const { op, payload } = JSON.parse(member);
+				if (op && REPLAY_OPS.includes(op)) {
+					await plugin[op](payload);
+				}
+			} catch (err) {
+				winston.error(`[plugin/meilisearch] replay failed: ${err.message}`);
+			}
+			drained += 1;
+		}
+		if (drained >= DRAIN_MAX) break;
+	}
+}
+
+module.exports = { enqueuePending, maybeDefer, meiliWrite, drainPending };

package/lib/reindex.js

@@ -0,0 +1,311 @@
+'use strict';
+
+const _ = nodebb.require('lodash');
+const winston = nodebb.require('winston');
+const db = nodebb.require('./src/database');
+const batch = nodebb.require('./src/batch');
+const Posts = nodebb.require('./src/posts');
+const Topics = nodebb.require('./src/topics');
+const Messaging = nodebb.require('./src/messaging');
+const pubsub = nodebb.require('./src/pubsub');
+const settings = nodebb.require('./src/meta/settings');
+const {
+	REINDEX_BATCH_SIZE, REINDEX_LOCK_KEY, REINDEX_LOCK_TTL, LOCK_REFRESH_INTERVAL, REPLAY_OPS,
+} = require('./constants');
+const { isSemanticSearchEnabled } = require('./embedder');
+const { waitForSucceededTask } = require('./client');
+
+// Full reindex of posts, topics, and chat messages, guarded by a cross-instance lock.
+module.exports = function attachReindex(plugin) {
+	const emitProgress = _.throttle(() => {
+		pubsub.publish('meilisearch:reindex', plugin.indexing);
+	}, 500, { leading: true, trailing: true });
+
+	async function acquireReindexLock() {
+		const ttl = await db.ttl(REINDEX_LOCK_KEY);
+		if (ttl > 0) {
+			winston.warn('[plugin/meilisearch] Reindex lock held by another instance');
+			return false;
+		}
+		await db.set(REINDEX_LOCK_KEY, String(Date.now()));
+		await db.expire(REINDEX_LOCK_KEY, REINDEX_LOCK_TTL);
+		plugin.reindexLockRefresh = setInterval(() => {
+			db.expire(REINDEX_LOCK_KEY, REINDEX_LOCK_TTL).catch(err =>
+				winston.error(`[plugin/meilisearch] lock refresh failed: ${err.message}`));
+		}, LOCK_REFRESH_INTERVAL);
+		return true;
+	}
+
+	async function releaseReindexLock() {
+		if (plugin.reindexLockRefresh) {
+			clearInterval(plugin.reindexLockRefresh);
+			plugin.reindexLockRefresh = null;
+		}
+		try {
+			await db.delete(REINDEX_LOCK_KEY);
+		} catch (err) {
+			winston.warn(`[plugin/meilisearch] Could not release reindex lock: ${err.message}`);
+		}
+	}
+
+	async function runReindex(force) {
+		let succeeded = false;
+		let errorMsg = null;
+		let skippedDeletedTopics = 0;
+		let skippedDeletedPosts = 0;
+		let skippedDeletedMessages = 0;
+		let skippedSystemMessages = 0;
+		let skippedOrphanMessages = 0;
+		const locked = await acquireReindexLock();
+		if (!locked) {
+			plugin.indexing.running = false;
+			return;
+		}
+		pubsub.publish('meilisearch:init', true);
+		plugin.initializingOnAnotherInstance = true;
+		try {
+			if (force) {
+				plugin.reindexingForced = true;
+				if (await isSemanticSearchEnabled(plugin)) {
+					// Every document added back after this will need a fresh embedding call
+					// against the configured (often paid) embedding API - there is no way
+					// around that once the documents themselves are gone, so surface it here.
+					winston.warn('[plugin/meilisearch] Force reindex with semantic search enabled: all vector embeddings will be regenerated from scratch via the embedding API.');
+				}
+				const postTask = await plugin.client.index('post').deleteAllDocuments();
+				const topicTask = await plugin.client.index('topic').deleteAllDocuments();
+				const messageTask = await plugin.client.index('chat_message').deleteAllDocuments();
+				await waitForSucceededTask(plugin, postTask.taskUid, { timeout: 600000, interval: 200 });
+				await waitForSucceededTask(plugin, topicTask.taskUid, { timeout: 600000, interval: 200 });
+				await waitForSucceededTask(plugin, messageTask.taskUid, { timeout: 600000, interval: 200 });
+			}
+			const [postSettingsTask, topicSettingsTask, messageSettingsTask] = await plugin.updateIndexSettings();
+			await waitForSucceededTask(plugin, postSettingsTask.taskUid, { timeout: 600000, interval: 200 });
+			await waitForSucceededTask(plugin, topicSettingsTask.taskUid, { timeout: 600000, interval: 200 });
+			await waitForSucceededTask(plugin, messageSettingsTask.taskUid, { timeout: 600000, interval: 200 });
+			// Explicit, deliberate part of a reindex run - ensures the embedder config
+			// matches current ACP settings before documents start flowing back in. Gated
+			// internally (plugin.updateEmbedders) so it's a no-op unless something about
+			// the semantic search config actually changed since it was last applied.
+			await plugin.updateEmbedders();
+			plugin.indexing.topic_progress.total = await db.sortedSetCard('topics:tid') || 0;
+			plugin.indexing.post_progress.total = await db.sortedSetCard('posts:pid') || 0;
+			plugin.indexing.message_progress.total = await db.sortedSetCard('messages:mid') || 0;
+			emitProgress();
+			await Promise.all([
+				batch.processSortedSet(
+					'topics:tid',
+					async (tids) => {
+						plugin.indexing.topic_progress.current += tids.length;
+						emitProgress();
+						const topics = await Topics.getTopicsFields(tids, ['tid', 'cid', 'uid', 'mainPid', 'title', 'timestamp', 'deleted']);
+						const activeTopics = [];
+						const deletedTids = [];
+						topics.forEach((topic) => {
+							if (parseInt(topic.deleted, 10) === 1) {
+								deletedTids.push(topic.tid);
+							} else {
+								activeTopics.push(topic);
+							}
+						});
+						skippedDeletedTopics += deletedTids.length;
+						if (deletedTids.length) {
+							await plugin.client.index('topic').deleteDocuments(deletedTids);
+						}
+						if (!activeTopics.length) return;
+						await plugin.client.index('topic').updateDocuments(
+							activeTopics.map(topic => ({
+								tid: topic.tid,
+								cid: topic.cid,
+								uid: topic.uid,
+								mainPid: topic.mainPid,
+								title: topic.title,
+								timestamp: topic.timestamp,
+							})),
+							{ primaryKey: 'tid' },
+						);
+					},
+					{
+						batch: REINDEX_BATCH_SIZE,
+						progress: plugin.indexing.topic_progress,
+					},
+				),
+				batch.processSortedSet(
+					'posts:pid',
+					async (pids) => {
+						plugin.indexing.post_progress.current += pids.length;
+						emitProgress();
+						const posts = await Posts.getPostsFields(pids, ['pid', 'tid', 'uid', 'content', 'timestamp', 'deleted']);
+						// Fetch topic deleted status for posts in this batch
+						const tids = [...new Set(posts.map(p => p && p.tid).filter(Boolean))];
+						const topicsData = tids.length ? await Topics.getTopicsFields(tids, ['tid', 'deleted']) : [];
+						const tidToDeleted = {};
+						topicsData.forEach((t) => { tidToDeleted[t.tid] = parseInt(t.deleted, 10) === 1; });
+
+						const activePosts = [];
+						const deletedPids = [];
+						posts.forEach((post) => {
+							if (parseInt(post.deleted, 10) === 1 || tidToDeleted[post.tid]) {
+								deletedPids.push(post.pid);
+							} else {
+								activePosts.push(post);
+							}
+						});
+						skippedDeletedPosts += deletedPids.length;
+						if (deletedPids.length) {
+							await plugin.client.index('post').deleteDocuments(deletedPids);
+						}
+						const activePids = activePosts.map(p => p.pid);
+						const cids = activePids.length ? await Posts.getCidsByPids(activePids) : [];
+						await plugin.client.index('post').updateDocuments(
+							activePosts.map((post, index) => ({
+								pid: post.pid,
+								tid: post.tid,
+								cid: cids[index],
+								uid: post.uid,
+								content: post.content,
+								timestamp: post.timestamp,
+							})),
+							{ primaryKey: 'pid' },
+						);
+					},
+					{
+						batch: REINDEX_BATCH_SIZE,
+						progress: plugin.indexing.post_progress,
+					},
+				),
+			]);
+			// Reindex chat messages SEQUENTIALLY after topics+posts (keeps Meilisearch enqueue rate bounded).
+			// Option B: cross-check each batch's roomIds against existing rooms and deindex orphan messages
+			// whose room was deleted via admin (messaging.deleteRooms fires no message hook and leaves
+			// message:${mid} objects + messages:mid entries, so they would otherwise be re-indexed as orphans).
+			await batch.processSortedSet(
+				'messages:mid',
+				async (mids) => {
+					plugin.indexing.message_progress.current += mids.length;
+					emitProgress();
+					const messages = await Messaging.getMessagesFields(mids, ['mid', 'content', 'roomId', 'fromuid', 'timestamp', 'deleted', 'system']);
+					// Resolve deleted/system messages and orphan rooms in one pass.
+					const seenRoomIds = [...new Set(messages.map(m => m && m.roomId).filter(rid => rid != null && rid !== ''))];
+					const roomsData = seenRoomIds.length ? await Messaging.getRoomsData(seenRoomIds) : [];
+					const roomIdToExists = {};
+					roomsData.forEach((room) => {
+						if (room && room.roomId != null) roomIdToExists[room.roomId] = true;
+					});
+					const activeMessages = [];
+					const deletedMids = [];
+					const systemMids = [];
+					const orphanMids = [];
+					messages.forEach((msg) => {
+						if (!msg || !msg.mid) return;
+						if (parseInt(msg.deleted, 10) === 1) {
+							deletedMids.push(msg.mid);
+						} else if (parseInt(msg.system, 10) === 1) {
+							systemMids.push(msg.mid);
+						} else if (!roomIdToExists[msg.roomId]) {
+							orphanMids.push(msg.mid);
+						} else {
+							activeMessages.push(msg);
+						}
+					});
+					skippedDeletedMessages += deletedMids.length;
+					skippedSystemMessages += systemMids.length;
+					skippedOrphanMessages += orphanMids.length;
+					const allDeindexMids = [...deletedMids, ...systemMids, ...orphanMids];
+					if (allDeindexMids.length) {
+						await plugin.client.index('chat_message').deleteDocuments(allDeindexMids);
+					}
+					if (!activeMessages.length) return;
+					await plugin.client.index('chat_message').updateDocuments(
+						activeMessages.map(msg => ({
+							mid: msg.mid,
+							roomId: msg.roomId,
+							uid: msg.fromuid,
+							content: msg.content,
+							timestamp: msg.timestamp,
+						})),
+						{ primaryKey: 'mid' },
+					);
+				},
+				{ batch: REINDEX_BATCH_SIZE, progress: plugin.indexing.message_progress },
+			);
+			succeeded = true;
+			winston.info('[plugin/meilisearch] Indexing of posts, topics and chat messages complete');
+		} catch (err) {
+			winston.error(`[plugin/meilisearch] Indexing failed: ${err.message}`);
+			errorMsg = err.message;
+		} finally {
+			plugin.indexing.running = false;
+			plugin.reindexingForced = false;
+			plugin.initializingOnAnotherInstance = false;
+			pubsub.publish('meilisearch:init', false);
+			await releaseReindexLock();
+			emitProgress.flush();
+			const pending = plugin.pendingDuringReindex.splice(0);
+			for (const { op, payload } of pending) {
+				if (!REPLAY_OPS.includes(op)) continue;
+				try {
+					await plugin[op](payload);
+				} catch (err) {
+					winston.error(`[plugin/meilisearch] replay ${op} failed: ${err.message}`);
+				}
+			}
+			const lastIndexResult = {
+				success: succeeded,
+				finishedAt: Date.now(),
+				topic_progress: {
+					current: plugin.indexing.topic_progress.current,
+					total: plugin.indexing.topic_progress.total,
+				},
+				post_progress: {
+					current: plugin.indexing.post_progress.current,
+					total: plugin.indexing.post_progress.total,
+				},
+				message_progress: {
+					current: plugin.indexing.message_progress.current,
+					total: plugin.indexing.message_progress.total,
+				},
+				skippedDeletedTopics,
+				skippedDeletedPosts,
+				skippedDeletedMessages,
+				skippedSystemMessages,
+				skippedOrphanMessages,
+				error: errorMsg,
+			};
+			try {
+				await settings.set(plugin.id, { lastReindexResult: lastIndexResult }, true);
+				if (succeeded) {
+					await settings.set(plugin.id, { indexed: true }, true);
+				}
+			} catch (err) {
+				winston.error(`[plugin/meilisearch] Failed to persist reindex result: ${err.message}`);
+			}
+		}
+	}
+
+	plugin.reindex = async function (force = false) {
+		if (plugin.indexing.running) {
+			winston.warn('[plugin/meilisearch] Already indexing');
+			return;
+		}
+		plugin.indexing = {
+			running: true,
+			topic_progress: {
+				current: 0,
+				total: 0,
+			},
+			post_progress: {
+				current: 0,
+				total: 0,
+			},
+			message_progress: {
+				current: 0,
+				total: 0,
+			},
+		};
+		emitProgress();
+		winston.info(`[plugin/meilisearch] Indexing posts, topics and chat messages${force ? ' (forced)' : ''}`);
+		plugin._reindexPromise = runReindex(force);
+		return plugin._reindexPromise;
+	};
+};