@extravirgin/payload-plugin-meilisearch 0.0.2 → 0.0.4

package/dist/indexCollections.js

@@ -1,395 +1,197 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+import { MeiliSearch } from 'meilisearch';
+import { compile } from 'html-to-text';
+import { convertLexicalToHTML, consolidateHTMLConverters } from '@payloadcms/richtext-lexical';
+const getIndexName = (config, collectionSlug)=>`${config?.indexPrefix ?? ''}${collectionSlug}`;
+export const indexCollection = (collection, config)=>{
+    if (!collection.hooks) {
+        collection.hooks = {};
     }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
+    if (!collection.hooks.afterChange) {
+        collection.hooks.afterChange = [];
+    }
+    collection.hooks.afterChange.push(handleAfterChange(config));
+    if (!collection.hooks.afterDelete) {
+        collection.hooks.afterDelete = [];
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
+    collection.hooks.afterDelete.push(afterDeleteHook(config));
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indexCollections = void 0;
-var meilisearch_1 = require("meilisearch");
-var html_to_text_1 = require("html-to-text");
-var richtext_lexical_1 = require("@payloadcms/richtext-lexical");
-var getIndexName = function (config, collectionSlug) { var _a; return "".concat((_a = config === null || config === void 0 ? void 0 : config.indexPrefix) !== null && _a !== void 0 ? _a : '').concat(collectionSlug); };
-function handleAfterChange(_a) {
-    var _b, _c, _d, _e, _f, _g;
-    var doc = _a.doc, previousDoc = _a.previousDoc, req = _a.req, collection = _a.collection, config = _a.config;
-    return __awaiter(this, void 0, void 0, function () {
-        var baseDoc, collectionConfig, payload, client, index, documents, _h, locales, defaultLocale, fallback, _i, locales_1, locale, localizedDoc, _j, documentId, shouldIndex, transformedDoc, _k, documentId, shouldIndex, transformedDoc, _l, error_1;
-        return __generator(this, function (_m) {
-            switch (_m.label) {
-                case 0:
-                    _m.trys.push([0, 19, , 20]);
-                    baseDoc = doc;
-                    collectionConfig = config.collections && (config === null || config === void 0 ? void 0 : config.collections.find(function (c) { return c.slug === collection.slug; }));
-                    payload = req.payload;
-                    client = getMeilisearchClient(config);
-                    return [4 /*yield*/, upsertIndex(client, getIndexName(config, collection.slug))];
-                case 1:
-                    _m.sent();
-                    index = client.index(getIndexName(config, collection.slug));
-                    documents = [];
-                    if (!(((_b = payload.config) === null || _b === void 0 ? void 0 : _b.localization) && ((_c = payload.config.localization.locales) === null || _c === void 0 ? void 0 : _c.length) > 0)) return [3 /*break*/, 13];
-                    _h = payload.config.localization, locales = _h.locales, defaultLocale = _h.defaultLocale, fallback = _h.fallback;
-                    _i = 0, locales_1 = locales;
-                    _m.label = 2;
-                case 2:
-                    if (!(_i < locales_1.length)) return [3 /*break*/, 10];
-                    locale = locales_1[_i];
-                    if (!(req.locale === locale.code)) return [3 /*break*/, 3];
-                    _j = doc;
-                    return [3 /*break*/, 5];
-                case 3: return [4 /*yield*/, req.payload.findByID({
+const handleAfterChange = (config)=>{
+    return async function({ doc, previousDoc, req, collection }) {
+        try {
+            let baseDoc = doc;
+            const collectionConfig = config.collections && config?.collections.find((c)=>c.slug === collection.slug);
+            const payload = req.payload;
+            const client = getMeilisearchClient(config);
+            await upsertIndex(client, getIndexName(config, collection.slug));
+            const index = client.index(getIndexName(config, collection.slug));
+            const documents = [];
+            if (payload.config?.localization && payload.config.localization.locales?.length > 0) {
+                const { locales, defaultLocale, fallback } = payload.config.localization;
+                for (const locale of locales){
+                    const localizedDoc = await req.payload.findByID({
                         collection: collection.slug,
                         id: doc.id,
-                        locale: locale,
-                        fallbackLocale: locale.fallbackLocale || defaultLocale,
-                    })];
-                case 4:
-                    _j = _m.sent();
-                    _m.label = 5;
-                case 5:
-                    localizedDoc = _j;
-                    documentId = doc.id + "_".concat(locale.code);
-                    shouldIndex = (_e = (_d = collectionConfig === null || collectionConfig === void 0 ? void 0 : collectionConfig.shouldIndex) === null || _d === void 0 ? void 0 : _d.call(collectionConfig, localizedDoc, previousDoc, locale.code)) !== null && _e !== void 0 ? _e : 'index';
-                    if (!(shouldIndex === 'index')) return [3 /*break*/, 7];
-                    _k = [{}];
-                    return [4 /*yield*/, transformDocumentForMeilisearch(localizedDoc, collection.fields, req)];
-                case 6:
-                    transformedDoc = __assign.apply(void 0, [__assign.apply(void 0, _k.concat([_m.sent()])), { id: documentId, documentId: doc.id, locale: locale.code }]);
-                    documents.push(transformedDoc);
-                    return [3 /*break*/, 9];
-                case 7:
-                    if (!(shouldIndex === 'delete')) return [3 /*break*/, 9];
-                    return [4 /*yield*/, index.deleteDocument(documentId)];
-                case 8:
-                    _m.sent();
-                    _m.label = 9;
-                case 9:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 10:
-                    if (!(documents.length > 0)) return [3 /*break*/, 12];
-                    return [4 /*yield*/, index.addDocuments(documents)];
-                case 11:
-                    _m.sent();
-                    _m.label = 12;
-                case 12: return [3 /*break*/, 18];
-                case 13:
-                    documentId = doc.id;
-                    shouldIndex = (_g = (_f = collectionConfig === null || collectionConfig === void 0 ? void 0 : collectionConfig.shouldIndex) === null || _f === void 0 ? void 0 : _f.call(collectionConfig, doc, previousDoc)) !== null && _g !== void 0 ? _g : 'index';
-                    if (!(shouldIndex === 'index')) return [3 /*break*/, 16];
-                    _l = [{}];
-                    return [4 /*yield*/, transformDocumentForMeilisearch(doc, collection.fields, req)];
-                case 14:
-                    transformedDoc = __assign.apply(void 0, [__assign.apply(void 0, _l.concat([_m.sent()])), { id: documentId, documentId: doc.id }]);
-                    return [4 /*yield*/, index.addDocuments([transformedDoc])];
-                case 15:
-                    _m.sent();
-                    return [3 /*break*/, 18];
-                case 16:
-                    if (!(shouldIndex === 'delete')) return [3 /*break*/, 18];
-                    return [4 /*yield*/, index.deleteDocument(documentId)];
-                case 17:
-                    _m.sent();
-                    _m.label = 18;
-                case 18: return [3 /*break*/, 20];
-                case 19:
-                    error_1 = _m.sent();
-                    console.error('Meilisearch indexing error:', error_1);
-                    return [3 /*break*/, 20];
-                case 20: return [2 /*return*/];
+                        locale: locale.code,
+                        draft: false,
+                        overrideAccess: true,
+                        fallbackLocale: locale.fallbackLocale || defaultLocale
+                    });
+                    const documentId = doc.id + `_${locale.code}`;
+                    if (!localizedDoc) {
+                        await index.deleteDocument(documentId);
+                        continue;
+                    }
+                    const shouldIndex = collectionConfig?.shouldIndex?.(localizedDoc, previousDoc, locale.code) ?? 'index';
+                    if (shouldIndex === 'index') {
+                        const transformedDoc = {
+                            ...await transformDocumentForMeilisearch(localizedDoc, collection.fields, req),
+                            id: documentId,
+                            documentId: doc.id,
+                            locale: locale.code
+                        };
+                        documents.push(transformedDoc);
+                    } else if (shouldIndex === 'delete') {
+                        await index.deleteDocument(documentId);
+                    }
+                }
+                if (documents.length > 0) {
+                    await index.addDocuments(documents);
+                }
+            } else {
+                const documentId = doc.id;
+                const shouldIndex = collectionConfig?.shouldIndex?.(doc, previousDoc) ?? 'index';
+                if (shouldIndex === 'index') {
+                    const transformedDoc = {
+                        ...await transformDocumentForMeilisearch(doc, collection.fields, req),
+                        id: documentId,
+                        documentId: doc.id
+                    };
+                    await index.addDocuments([
+                        transformedDoc
+                    ]);
+                } else if (shouldIndex === 'delete') {
+                    await index.deleteDocument(documentId);
+                }
             }
-        });
-    });
-}
-var indexCollections = function (collections, config) {
-    return collections.map(function (collection) {
-        var _a, _b;
-        var collectionConfig = config.collections && (config === null || config === void 0 ? void 0 : config.collections.find(function (c) { return c.slug === collection.slug; }));
-        if (!collectionConfig) {
-            return collection;
+        } catch (error) {
+            console.error('Meilisearch indexing error:', error);
         }
-        return __assign(__assign({}, collection), { hooks: __assign(__assign({}, (collection.hooks || {})), { afterChange: __spreadArray(__spreadArray([], (((_a = collection.hooks) === null || _a === void 0 ? void 0 : _a.afterChange) || []), true), [
-                    function (_a) {
-                        var doc = _a.doc, previousDoc = _a.previousDoc, req = _a.req;
-                        handleAfterChange({ doc: doc, previousDoc: previousDoc, req: req, collection: collection, config: config });
-                    },
-                ], false), afterDelete: __spreadArray(__spreadArray([], (((_b = collection.hooks) === null || _b === void 0 ? void 0 : _b.afterDelete) || []), true), [
-                    function (_a) {
-                        var doc = _a.doc, req = _a.req;
-                        return __awaiter(void 0, void 0, void 0, function () {
-                            var payload, localization, client, index, locales, _i, locales_2, locale, documentId, error_2;
-                            var _b, _c;
-                            return __generator(this, function (_d) {
-                                switch (_d.label) {
-                                    case 0:
-                                        _d.trys.push([0, 9, , 10]);
-                                        payload = req.payload;
-                                        localization = (_b = payload.config) === null || _b === void 0 ? void 0 : _b.localization;
-                                        client = getMeilisearchClient(config);
-                                        return [4 /*yield*/, upsertIndex(client, getIndexName(config, collection.slug))];
-                                    case 1:
-                                        _d.sent();
-                                        index = client.index(getIndexName(config, collection.slug));
-                                        if (!(localization && ((_c = localization.locales) === null || _c === void 0 ? void 0 : _c.length) > 0)) return [3 /*break*/, 6];
-                                        locales = localization.locales;
-                                        _i = 0, locales_2 = locales;
-                                        _d.label = 2;
-                                    case 2:
-                                        if (!(_i < locales_2.length)) return [3 /*break*/, 5];
-                                        locale = locales_2[_i];
-                                        documentId = doc.id + "_".concat(locale.code);
-                                        return [4 /*yield*/, index.deleteDocument(documentId)];
-                                    case 3:
-                                        _d.sent();
-                                        _d.label = 4;
-                                    case 4:
-                                        _i++;
-                                        return [3 /*break*/, 2];
-                                    case 5: return [3 /*break*/, 8];
-                                    case 6: return [4 /*yield*/, index.deleteDocument(doc.id)];
-                                    case 7:
-                                        _d.sent();
-                                        _d.label = 8;
-                                    case 8: return [3 /*break*/, 10];
-                                    case 9:
-                                        error_2 = _d.sent();
-                                        console.error('Meilisearch indexing error:', error_2);
-                                        return [3 /*break*/, 10];
-                                    case 10: return [2 /*return*/];
-                                }
-                            });
-                        });
-                    },
-                ], false) }) });
-    });
+    };
 };
-exports.indexCollections = indexCollections;
-var meilisearch;
+const afterDeleteHook = (config)=>{
+    return async ({ doc, req, collection })=>{
+        try {
+            const payload = req.payload;
+            const localization = payload.config?.localization;
+            const client = getMeilisearchClient(config);
+            await upsertIndex(client, getIndexName(config, collection.slug));
+            const index = client.index(getIndexName(config, collection.slug));
+            if (localization && localization.locales?.length > 0) {
+                const { locales } = localization;
+                for (const locale of locales){
+                    const documentId = doc.id + `_${locale.code}`;
+                    await index.deleteDocument(documentId);
+                }
+            } else {
+                await index.deleteDocument(doc.id);
+            }
+        } catch (error) {
+            console.error('Meilisearch indexing error:', error);
+        }
+    };
+};
+let meilisearch;
 function getMeilisearchClient(config) {
     if (!meilisearch) {
-        meilisearch = new meilisearch_1.MeiliSearch({
+        meilisearch = new MeiliSearch({
             host: config.host,
-            apiKey: config.apiKey,
+            apiKey: config.apiKey
         });
     }
     return meilisearch;
 }
-function upsertIndex(client, indexUID) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var error_3;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 6]);
-                    // Attempt to retrieve the index
-                    return [4 /*yield*/, client.getIndex(indexUID)];
-                case 1:
-                    // Attempt to retrieve the index
-                    _b.sent();
-                    return [3 /*break*/, 6];
-                case 2:
-                    error_3 = _b.sent();
-                    if (!(((_a = error_3 === null || error_3 === void 0 ? void 0 : error_3.cause) === null || _a === void 0 ? void 0 : _a.code) === 'index_not_found')) return [3 /*break*/, 4];
-                    // Index doesn't exist; create it
-                    return [4 /*yield*/, client.createIndex(indexUID, {
-                            primaryKey: 'id',
-                        })];
-                case 3:
-                    // Index doesn't exist; create it
-                    _b.sent();
-                    console.log("Index '".concat(indexUID, "' has been created."));
-                    return [3 /*break*/, 5];
-                case 4: 
-                // Rethrow any other errors
-                throw error_3;
-                case 5: return [3 /*break*/, 6];
-                case 6: return [2 /*return*/];
-            }
-        });
-    });
+async function upsertIndex(client, indexUID) {
+    try {
+        // Attempt to retrieve the index
+        await client.getIndex(indexUID);
+    } catch (error) {
+        // Check if the error is because the index was not found
+        // @ts-ignore
+        if (error?.cause?.code === 'index_not_found') {
+            // Index doesn't exist; create it
+            await client.createIndex(indexUID, {
+                primaryKey: 'id'
+            });
+            console.log(`Index '${indexUID}' has been created.`);
+        } else {
+            // Rethrow any other errors
+            throw error;
+        }
+    }
 }
-var options = {
-    wordwrap: 130,
-    // ...
+const options = {
+    wordwrap: 130
 };
-var compiledConvert = (0, html_to_text_1.compile)(options);
+const compiledConvert = compile(options);
 // Helper function to extract text from HTML in nodejs
 function extractTextFromHTML(html) {
     return compiledConvert(html);
 }
 // Helper function to transform a document for Meilisearch indexing
-function transformDocumentForMeilisearch(doc, fields, req) {
-    return __awaiter(this, void 0, void 0, function () {
-        var transformedDoc;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    transformedDoc = {};
-                    return [4 /*yield*/, Promise.all(fields.map(function (field) { return __awaiter(_this, void 0, void 0, function () {
-                            var lexicalAdapter, sanitizedServerEditorConfig, html, _a, _b, _c, _d, _e, _f;
-                            var _this = this;
-                            var _g;
-                            return __generator(this, function (_h) {
-                                switch (_h.label) {
-                                    case 0:
-                                        if (!(field.type === 'richText')) return [3 /*break*/, 2];
-                                        lexicalAdapter = field.editor;
-                                        sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
-                                        return [4 /*yield*/, (0, richtext_lexical_1.convertLexicalToHTML)({
-                                                converters: (0, richtext_lexical_1.consolidateHTMLConverters)({ editorConfig: sanitizedServerEditorConfig }),
-                                                data: doc[field.name],
-                                            })];
-                                    case 1:
-                                        html = _h.sent();
-                                        transformedDoc[field.name] = extractTextFromHTML(html);
-                                        return [3 /*break*/, 11];
-                                    case 2:
-                                        if (!(field.type === 'array' && field.fields)) return [3 /*break*/, 4];
-                                        // For array fields, transform each item
-                                        _a = transformedDoc;
-                                        _b = field.name;
-                                        return [4 /*yield*/, Promise.all((doc[field.name] || []).map(function (item) {
-                                                return transformDocumentForMeilisearch(item, field.fields, req);
-                                            }))];
-                                    case 3:
-                                        // For array fields, transform each item
-                                        _a[_b] = _h.sent();
-                                        return [3 /*break*/, 11];
-                                    case 4:
-                                        if (!(field.type === 'tabs')) return [3 /*break*/, 6];
-                                        return [4 /*yield*/, Promise.all(field.tabs.map(function (tab, index) { return __awaiter(_this, void 0, void 0, function () {
-                                                return __generator(this, function (_a) {
-                                                    switch (_a.label) {
-                                                        case 0: return [4 /*yield*/, transformDocumentForMeilisearch(doc, tab.fields, req)];
-                                                        case 1: return [2 /*return*/, _a.sent()];
-                                                    }
-                                                });
-                                            }); }))];
-                                    case 5:
-                                        // For tab fields, transform each tab
-                                        (_h.sent()).forEach(function (t) { return Object.assign(transformedDoc, t); });
-                                        return [3 /*break*/, 11];
-                                    case 6:
-                                        if (!(field.type === 'blocks')) return [3 /*break*/, 8];
-                                        // For block fields, transform each block
-                                        _c = transformedDoc;
-                                        _d = field.name;
-                                        return [4 /*yield*/, Promise.all((doc[field.name] || []).map(function (block) { return __awaiter(_this, void 0, void 0, function () {
-                                                var fields;
-                                                var _a;
-                                                var _b;
-                                                return __generator(this, function (_c) {
-                                                    switch (_c.label) {
-                                                        case 0:
-                                                            fields = (_b = field.blocks.find(function (b) { return b.slug === block.blockType; })) === null || _b === void 0 ? void 0 : _b.fields;
-                                                            if (!fields) {
-                                                                return [2 /*return*/, {
-                                                                        type: block.blockType,
-                                                                        data: "",
-                                                                    }];
-                                                            }
-                                                            _a = {
-                                                                type: block.blockType
-                                                            };
-                                                            return [4 /*yield*/, transformDocumentForMeilisearch(block, fields, req)];
-                                                        case 1: return [2 /*return*/, (_a.data = _c.sent(),
-                                                                _a)];
-                                                    }
-                                                });
-                                            }); }))];
-                                    case 7:
-                                        // For block fields, transform each block
-                                        _c[_d] = _h.sent();
-                                        return [3 /*break*/, 11];
-                                    case 8:
-                                        if (!(field.type === 'group' && field.fields)) return [3 /*break*/, 10];
-                                        // For group fields, transform the nested fields
-                                        _e = transformedDoc;
-                                        _f = field.name;
-                                        return [4 /*yield*/, transformDocumentForMeilisearch(doc[field.name], field.fields, req)];
-                                    case 9:
-                                        // For group fields, transform the nested fields
-                                        _e[_f] = _h.sent();
-                                        return [3 /*break*/, 11];
-                                    case 10:
-                                        if (field.type === 'relationship' || field.type === 'upload') {
-                                            // For relationship and upload fields, just include the ID
-                                            transformedDoc[field.name] = ((_g = doc[field.name]) === null || _g === void 0 ? void 0 : _g.id) || doc[field.name];
-                                        }
-                                        else {
-                                            // For other field types, include as-is
-                                            try {
-                                                // @ts-ignore
-                                                transformedDoc[field.name] = doc[field.name];
-                                            }
-                                            catch (err) {
-                                                console.log(err, field, doc);
-                                            }
-                                        }
-                                        _h.label = 11;
-                                    case 11: return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/, transformedDoc];
+async function transformDocumentForMeilisearch(doc, fields, req) {
+    const transformedDoc = {};
+    await Promise.all(fields.map(async (field)=>{
+        if (field.type === 'richText') {
+            // For rich text fields, convert Lexical to HTML, then extract text
+            const lexicalAdapter = field.editor;
+            const sanitizedServerEditorConfig = lexicalAdapter.editorConfig;
+            const html = await convertLexicalToHTML({
+                converters: consolidateHTMLConverters({
+                    editorConfig: sanitizedServerEditorConfig
+                }),
+                data: doc[field.name]
+            });
+            transformedDoc[field.name] = extractTextFromHTML(html);
+        } else if (field.type === 'array' && field.fields) {
+            // For array fields, transform each item
+            transformedDoc[field.name] = await Promise.all((doc[field.name] || []).map((item)=>transformDocumentForMeilisearch(item, field.fields, req)));
+        } else if (field.type === 'tabs') {
+            // For tab fields, transform each tab
+            (await Promise.all(field.tabs.map(async (tab)=>{
+                return await transformDocumentForMeilisearch(doc, tab.fields, req);
+            }))).forEach((t)=>Object.assign(transformedDoc, t));
+        } else if (field.type === 'blocks') {
+            // For block fields, transform each block
+            transformedDoc[field.name] = await Promise.all((doc[field.name] || []).map(async (block)=>{
+                const fields = field.blocks.find((b)=>b.slug === block.blockType)?.fields;
+                if (!fields) {
+                    return {
+                        type: block.blockType,
+                        data: ""
+                    };
+                }
+                return {
+                    type: block.blockType,
+                    data: await transformDocumentForMeilisearch(block, fields, req)
+                };
+            }));
+        } else if (field.type === 'group' && field.fields) {
+            // For group fields, transform the nested fields
+            transformedDoc[field.name] = await transformDocumentForMeilisearch(doc[field.name], field.fields, req);
+        } else if (field.type === 'relationship' || field.type === 'upload') {
+            // For relationship and upload fields, just include the ID
+            transformedDoc[field.name] = doc[field.name]?.id || doc[field.name];
+        } else {
+            // For other field types, include as-is
+            try {
+                // @ts-ignore
+                transformedDoc[field.name] = doc[field.name];
+            } catch (err) {
+                console.log(err, field, doc);
             }
-        });
-    });
+        }
+    }));
+    return transformedDoc;
 }
+
 //# sourceMappingURL=indexCollections.js.map