@vegan-friendly/strapi-plugin-elasticsearch 0.1.0-alpha.3 → 0.2.0

package/dist/server/services/index.d.ts

@@ -1,7 +1,107 @@
-declare const configureIndexing: any;
-declare const scheduleIndexing: any;
-declare const esInterface: any;
-declare const indexer: any;
-declare const logIndexing: any;
-declare const helper: any;
-declare const transformContent: any;
+declare const _default: {
+    configureIndexing: ({ strapi }: {
+        strapi: any;
+    }) => {
+        initializeStrapiElasticsearch(): Promise<void>;
+        markInitialized(): Promise<void>;
+        isInitialized(): any;
+        cacheConfig(): Promise<void>;
+        getCollectionConfig({ collectionName }: {
+            collectionName: any;
+        }): Promise<{} | null>;
+        getCollectionsConfiguredForIndexing(): Promise<string[]>;
+        isCollectionConfiguredToBeIndexed({ collectionName }: {
+            collectionName: any;
+        }): Promise<boolean>;
+        getContentConfig(): Promise<any>;
+        importContentConfig({ config }: {
+            config: any;
+        }): Promise<any>;
+        setContentConfig({ collection, config }: {
+            collection: any;
+            config: any;
+        }): Promise<any>;
+    };
+    scheduleIndexing: ({ strapi }: {
+        strapi: any;
+    }) => {
+        addFullSiteIndexingTask(): Promise<any>;
+        addCollectionToIndex({ collectionUid }: {
+            collectionUid: any;
+        }): Promise<any>;
+        addItemToIndex({ collectionUid, recordId }: {
+            collectionUid: any;
+            recordId: any;
+        }): Promise<any>;
+        removeItemFromIndex({ collectionUid, recordId }: {
+            collectionUid: any;
+            recordId: any;
+        }): Promise<void>;
+        getItemsPendingToBeIndexed(): Promise<any>;
+        markIndexingTaskComplete(recId: any): Promise<void>;
+    };
+    esInterface: ({ strapi }: {
+        strapi: any;
+    }) => import("..").EsInterfaceService;
+    indexer: ({ strapi }: {
+        strapi: any;
+    }) => {
+        rebuildIndex(): Promise<boolean>;
+        indexCollection(collectionName: any, indexName?: null): Promise<boolean>;
+        indexPendingData(): Promise<boolean>;
+    };
+    logIndexing: ({ strapi }: {
+        strapi: any;
+    }) => {
+        recordIndexingPass(message: any): Promise<void>;
+        recordIndexingFail(message: any): Promise<void>;
+        fetchIndexingLogs(count?: number): Promise<any>;
+    };
+    helper: ({ strapi }: {
+        strapi: any;
+    }) => {
+        getElasticsearchInfo(): Promise<{
+            indexingCronSchedule: any;
+            elasticHost: any;
+            elasticUserName: any;
+            elasticCertificate: any;
+            elasticIndexAlias: any;
+            connected: any;
+            initialized: any;
+        }>;
+        isCollectionDraftPublish({ collectionName }: {
+            collectionName: any;
+        }): boolean;
+        getPopulateAttribute({ collectionName }: {
+            collectionName: any;
+        }): true | {
+            populate: never;
+        } | undefined;
+        getIndexItemId({ collectionName, itemId }: {
+            collectionName: any;
+            itemId: any;
+        }): string;
+        getCurrentIndexName(): Promise<string>;
+        getIncrementedIndexName(): Promise<string>;
+        storeCurrentIndexName(indexName: any): Promise<void>;
+        modifySubfieldsConfigForExtractor(collectionConfig: any): any;
+        extractDataToIndex({ collectionName, data, collectionConfig }: {
+            collectionName: any;
+            data: any;
+            collectionConfig: any;
+        }): {};
+    };
+    transformContent: {
+        transform({ content, from }: {
+            content: any;
+            from: any;
+        }): any;
+    };
+    virtualCollectionsRegistry: ({ strapi }: {
+        strapi: any;
+    }) => import("..").VirtualCollectionsRegistryService;
+    virtualCollectionsIndexer: ({ strapi }: {
+        strapi: any;
+    }) => import("..").VirtualCollectionsIndexerService;
+};
+export default _default;

package/dist/server/services/index.js

@@ -1,17 +1,25 @@
 'use strict';
-const configureIndexing = require('./configure-indexing');
-const scheduleIndexing = require('./schedule-indexing');
-const esInterface = require('./es-interface');
-const indexer = require('./perform-indexing');
-const logIndexing = require('./log-indexing');
-const helper = require('./helper');
-const transformContent = require('./transform-content');
-module.exports = {
-    configureIndexing,
-    scheduleIndexing,
-    esInterface,
-    indexer,
-    logIndexing,
-    helper,
-    transformContent
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const configure_indexing_1 = __importDefault(require("./configure-indexing"));
+const schedule_indexing_1 = __importDefault(require("./schedule-indexing"));
+const es_interface_1 = __importDefault(require("./es-interface"));
+const perform_indexing_1 = __importDefault(require("./perform-indexing"));
+const log_indexing_1 = __importDefault(require("./log-indexing"));
+const helper_1 = __importDefault(require("./helper"));
+const transform_content_1 = __importDefault(require("./transform-content"));
+const virtual_collections_registry_1 = __importDefault(require("./virtual-collections-registry"));
+const virtual_collections_indexer_1 = __importDefault(require("./virtual-collections-indexer"));
+exports.default = {
+    configureIndexing: configure_indexing_1.default,
+    scheduleIndexing: schedule_indexing_1.default,
+    esInterface: es_interface_1.default,
+    indexer: perform_indexing_1.default,
+    logIndexing: log_indexing_1.default,
+    helper: helper_1.default,
+    transformContent: transform_content_1.default,
+    virtualCollectionsRegistry: virtual_collections_registry_1.default,
+    virtualCollectionsIndexer: virtual_collections_indexer_1.default,
 };

package/dist/server/services/log-indexing.d.ts

@@ -0,0 +1,8 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    recordIndexingPass(message: any): Promise<void>;
+    recordIndexingFail(message: any): Promise<void>;
+    fetchIndexingLogs(count?: number): Promise<any>;
+};
+export default _default;

package/dist/server/services/log-indexing.js

@@ -1,27 +1,28 @@
 "use strict";
-module.exports = ({ strapi }) => ({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => ({
     async recordIndexingPass(message) {
         const entry = await strapi.entityService.create('plugin::elasticsearch.indexing-log', {
             data: {
                 status: 'pass',
-                details: message
-            }
+                details: message,
+            },
         });
     },
     async recordIndexingFail(message) {
         const entry = await strapi.entityService.create('plugin::elasticsearch.indexing-log', {
             data: {
                 status: 'fail',
-                details: String(message)
-            }
+                details: String(message),
+            },
         });
     },
     async fetchIndexingLogs(count = 50) {
         const records = await strapi.entityService.findMany('plugin::elasticsearch.indexing-log', {
             sort: { createdAt: 'DESC' },
             start: 0,
-            limit: count
+            limit: count,
         });
         return records;
-    }
+    },
 });

package/dist/server/services/perform-indexing.d.ts

@@ -0,0 +1,8 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    rebuildIndex(): Promise<boolean>;
+    indexCollection(collectionName: any, indexName?: null): Promise<boolean>;
+    indexPendingData(): Promise<boolean>;
+};
+export default _default;

package/dist/server/services/perform-indexing.js

@@ -1,11 +1,13 @@
 "use strict";
-module.exports = ({ strapi }) => ({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => ({
     async rebuildIndex() {
         const helper = strapi.plugins['elasticsearch'].services.helper;
         const esInterface = strapi.plugins['elasticsearch'].services.esInterface;
         const scheduleIndexingService = strapi.plugins['elasticsearch'].services.scheduleIndexing;
         const configureIndexingService = strapi.plugins['elasticsearch'].services.configureIndexing;
         const logIndexingService = strapi.plugins['elasticsearch'].services.logIndexing;
+        const virtualCollectionsIndexer = strapi.plugins['elasticsearch'].services['virtualCollectionsIndexer'];
         try {
             console.log('strapi-plugin-elasticsearch : Request to rebuild the index received.');
             const oldIndexName = await helper.getCurrentIndexName();
@@ -21,11 +23,13 @@ module.exports = ({ strapi }) => ({
                 const cols = await configureIndexingService.getCollectionsConfiguredForIndexing();
                 for (let r = 0; r < cols.length; r++)
                     await this.indexCollection(cols[r], newIndexName);
+                // Indexing the virtual collections
+                console.log('strapi-plugin-elasticsearch : Starting to index virtual collections.');
+                const totalIndexed = await virtualCollectionsIndexer.reindexAll(newIndexName);
                 await scheduleIndexingService.markIndexingTaskComplete(item.id);
                 console.log('strapi-plugin-elasticsearch : Indexing of data into the new index complete.');
                 //Step 4 : Move the alias to this new index
                 await esInterface.attachAliasToIndex(newIndexName);
-                ;
                 console.log('strapi-plugin-elasticsearch : Attaching the newly created index to the alias.');
                 //Step 3 : Update the search-indexing-name
                 await helper.storeCurrentIndexName(newIndexName);
@@ -44,6 +48,7 @@ module.exports = ({ strapi }) => ({
             console.log('strapi-plugin-elasticsearch : searchController : An error was encountered while re-indexing.');
             console.log(err);
             await logIndexingService.recordIndexingFail(err);
+            throw err;
         }
     },
     async indexCollection(collectionName, indexName = null) {
@@ -54,16 +59,16 @@ module.exports = ({ strapi }) => ({
         const esInterface = strapi.plugins['elasticsearch'].services.esInterface;
         if (indexName === null)
             indexName = await helper.getCurrentIndexName();
-        let entries = [];
+        let entries = []; //TODO: strapi should provide a type for this
         if (isCollectionDraftPublish) {
             entries = await strapi.entityService.findMany(collectionName, {
                 sort: { createdAt: 'DESC' },
                 populate: populateAttrib['populate'],
                 filters: {
                     publishedAt: {
-                        $notNull: true
-                    }
-                }
+                        $notNull: true,
+                    },
+                },
             });
         }
         else {
@@ -75,10 +80,17 @@ module.exports = ({ strapi }) => ({
         if (entries) {
             for (let s = 0; s < entries.length; s++) {
                 const item = entries[s];
-                const indexItemId = helper.getIndexItemId({ collectionName: collectionName, itemId: item.id });
-                const collectionConfig = await configureIndexingService.getCollectionConfig({ collectionName });
+                const indexItemId = helper.getIndexItemId({
+                    collectionName: collectionName,
+                    itemId: item.id,
+                });
+                const collectionConfig = await configureIndexingService.getCollectionConfig({
+                    collectionName,
+                });
                 const dataToIndex = await helper.extractDataToIndex({
-                    collectionName, data: item, collectionConfig
+                    collectionName,
+                    data: item,
+                    collectionConfig,
                 });
                 await esInterface.indexDataToSpecificIndex({ itemId: indexItemId, itemData: dataToIndex }, indexName);
             }
@@ -92,7 +104,7 @@ module.exports = ({ strapi }) => ({
         const esInterface = strapi.plugins['elasticsearch'].services.esInterface;
         const helper = strapi.plugins['elasticsearch'].services.helper;
         const recs = await scheduleIndexingService.getItemsPendingToBeIndexed();
-        const fullSiteIndexing = recs.filter(r => r.full_site_indexing === true).length > 0;
+        const fullSiteIndexing = recs.filter((r) => r.full_site_indexing === true).length > 0;
         if (fullSiteIndexing) {
             await this.rebuildIndex();
             for (let r = 0; r < recs.length; r++)
@@ -108,24 +120,30 @@ module.exports = ({ strapi }) => ({
                             if (recs[r].indexing_type !== 'remove-from-index') {
                                 const populateAttrib = helper.getPopulateAttribute({ collectionName: col });
                                 const item = await strapi.entityService.findOne(col, recs[r].item_id, {
-                                    populate: populateAttrib['populate']
+                                    populate: populateAttrib['populate'],
                                 });
                                 const indexItemId = helper.getIndexItemId({ collectionName: col, itemId: item.id });
-                                const collectionConfig = await configureIndexingService.getCollectionConfig({ collectionName: col });
+                                const collectionConfig = await configureIndexingService.getCollectionConfig({
+                                    collectionName: col,
+                                });
                                 const dataToIndex = await helper.extractDataToIndex({
-                                    collectionName: col, data: item, collectionConfig
+                                    collectionName: col,
+                                    data: item,
+                                    collectionConfig,
                                 });
                                 await esInterface.indexData({ itemId: indexItemId, itemData: dataToIndex });
                                 await scheduleIndexingService.markIndexingTaskComplete(recs[r].id);
                             }
                             else {
-                                const indexItemId = helper.getIndexItemId({ collectionName: col, itemId: recs[r].item_id });
+                                const indexItemId = helper.getIndexItemId({
+                                    collectionName: col,
+                                    itemId: recs[r].item_id,
+                                });
                                 await esInterface.removeItemFromIndex({ itemId: indexItemId });
                                 await scheduleIndexingService.markIndexingTaskComplete(recs[r].id);
                             }
-                        }
-                        else //index the entire collection
-                         {
+                        } //index the entire collection
+                        else {
                             //PENDING : Index an entire collection
                             await this.indexCollection(col);
                             await scheduleIndexingService.markIndexingTaskComplete(recs[r].id);

package/dist/server/services/schedule-indexing.d.ts

@@ -0,0 +1,19 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    addFullSiteIndexingTask(): Promise<any>;
+    addCollectionToIndex({ collectionUid }: {
+        collectionUid: any;
+    }): Promise<any>;
+    addItemToIndex({ collectionUid, recordId }: {
+        collectionUid: any;
+        recordId: any;
+    }): Promise<any>;
+    removeItemFromIndex({ collectionUid, recordId }: {
+        collectionUid: any;
+        recordId: any;
+    }): Promise<void>;
+    getItemsPendingToBeIndexed(): Promise<any>;
+    markIndexingTaskComplete(recId: any): Promise<void>;
+};
+export default _default;

package/dist/server/services/schedule-indexing.js

@@ -1,13 +1,14 @@
 "use strict";
-module.exports = ({ strapi }) => ({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => ({
     async addFullSiteIndexingTask() {
         const data = await strapi.entityService.create('plugin::elasticsearch.task', {
             data: {
                 collection_name: '',
                 indexing_status: 'to-be-done',
                 full_site_indexing: true,
-                indexing_type: "add-to-index"
-            }
+                indexing_type: 'add-to-index',
+            },
         });
         return data;
     },
@@ -17,8 +18,8 @@ module.exports = ({ strapi }) => ({
                 collection_name: collectionUid,
                 indexing_status: 'to-be-done',
                 full_site_indexing: false,
-                indexing_type: "add-to-index"
-            }
+                indexing_type: 'add-to-index',
+            },
         });
         return data;
     },
@@ -29,8 +30,8 @@ module.exports = ({ strapi }) => ({
                 collection_name: collectionUid,
                 indexing_status: 'to-be-done',
                 full_site_indexing: false,
-                indexing_type: "add-to-index"
-            }
+                indexing_type: 'add-to-index',
+            },
         });
         return data;
     },
@@ -41,8 +42,8 @@ module.exports = ({ strapi }) => ({
                 collection_name: collectionUid,
                 indexing_status: 'to-be-done',
                 full_site_indexing: false,
-                indexing_type: "remove-from-index"
-            }
+                indexing_type: 'remove-from-index',
+            },
         });
     },
     async getItemsPendingToBeIndexed() {
@@ -54,8 +55,8 @@ module.exports = ({ strapi }) => ({
     async markIndexingTaskComplete(recId) {
         const entries = await strapi.entityService.update('plugin::elasticsearch.task', recId, {
             data: {
-                'indexing_status': 'done'
-            }
+                indexing_status: 'done',
+            },
         });
-    }
+    },
 });

package/dist/server/services/transform-content.d.ts

@@ -1,2 +1,7 @@
-declare const markdownToTxt: any;
-declare function transformMarkdownToText(md: any): any;
+declare const _default: {
+    transform({ content, from }: {
+        content: any;
+        from: any;
+    }): any;
+};
+export default _default;

package/dist/server/services/transform-content.js

@@ -1,9 +1,10 @@
 "use strict";
-const { markdownToTxt } = require('markdown-to-txt');
+Object.defineProperty(exports, "__esModule", { value: true });
+const markdown_to_txt_1 = require("markdown-to-txt");
 function transformMarkdownToText(md) {
     let text = md;
     try {
-        text = markdownToTxt(md);
+        text = (0, markdown_to_txt_1.markdownToTxt)(md);
     }
     catch (err) {
         console.error('strapi-plugin-elasticsearch : Error while transforming markdown to text.');
@@ -11,7 +12,7 @@ function transformMarkdownToText(md) {
     }
     return text;
 }
-module.exports = {
+exports.default = {
     transform({ content, from }) {
         if (from === 'markdown')
             return transformMarkdownToText(content);

package/dist/server/services/virtual-collections-indexer.d.ts

@@ -0,0 +1,8 @@
+import { VirtualCollectionsIndexerService } from '../types';
+/**
+ * Service to handle indexing of virtual collections
+ */
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => VirtualCollectionsIndexerService;
+export default _default;

package/dist/server/services/virtual-collections-indexer.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pretty_ms_1 = __importDefault(require("pretty-ms"));
+/**
+ * Service to handle indexing of virtual collections
+ */
+exports.default = ({ strapi }) => {
+    const getElasticsearchService = () => strapi.plugin('elasticsearch').service('esInterface');
+    const getRegistryService = () => strapi.service('plugin::elasticsearch.virtualCollectionsRegistry');
+    const getHelperService = () => strapi.plugins['elasticsearch'].services.helper;
+    return {
+        /**
+         * Index a single item from a virtual collection
+         */
+        async indexItem(collectionName, itemId) {
+            const registry = getRegistryService();
+            const collection = registry.get(collectionName);
+            if (!collection) {
+                throw new Error(`Virtual collection not found: ${collectionName}`);
+            }
+            try {
+                const results = await collection.extractById([itemId]);
+                if (!results || !Array.isArray(results) || results.length === 0) {
+                    strapi.log.warn(`No data extracted for ${collectionName} with ID ${itemId}`);
+                    return null;
+                }
+                const data = results[0];
+                const indexData = collection.mapToIndex ? data : data;
+                const esService = getElasticsearchService();
+                const helper = getHelperService();
+                const indexItemId = helper.getIndexItemId(collectionName, itemId);
+                await esService.indexDataToSpecificIndex({ itemId: indexItemId, itemData: indexData }, collection.indexName);
+                strapi.log.debug(`Indexed virtual item: ${collectionName}:${itemId}`);
+                return indexData;
+            }
+            catch (error) {
+                strapi.log.error(`Error indexing ${collectionName}:${itemId}: ${error?.message}`);
+                throw error;
+            }
+        },
+        async reindexAll(indexName) {
+            const registry = getRegistryService();
+            const collections = registry.getAll();
+            let totalIndexed = 0;
+            for (const collection of collections) {
+                totalIndexed += await this.reindex(collection.collectionName, indexName);
+            }
+            console.log(`strapi-plugin-elasticsearch : Reindexed ${totalIndexed} items across all ${collections.length} virtual collections`);
+            return totalIndexed;
+        },
+        /**
+         * Reindex all items in a virtual collection
+         */
+        async reindex(collectionName, indexName) {
+            const registry = getRegistryService();
+            const collection = registry.get(collectionName);
+            if (!collection) {
+                throw new Error(`Virtual collection not found: ${collectionName}`);
+            }
+            const timestamp = Date.now();
+            try {
+                const esService = getElasticsearchService();
+                const helper = getHelperService();
+                // await esService.createIndex(tempIndexName);
+                let page = 0;
+                let hasMoreData = true;
+                let totalIndexed = 0;
+                while (hasMoreData) {
+                    const pageData = await collection.extractData(page);
+                    if (!Array.isArray(pageData) || pageData.length === 0) {
+                        hasMoreData = false;
+                        break;
+                    }
+                    const operations = [];
+                    for (const item of pageData) {
+                        const itemId = helper.getIndexItemId({ collectionName, itemId: item.id });
+                        const itemData = collection.mapToIndex ? item : item;
+                        operations.push({ itemId, itemData });
+                    }
+                    if (operations.length > 0) {
+                        await Promise.all(operations.map((op) => esService.indexDataToSpecificIndex(op, indexName)));
+                    }
+                    totalIndexed += pageData.length;
+                    page++;
+                }
+                strapi.log.info(`Reindexed ${totalIndexed} items for virtual collection: ${collectionName}. took ${(0, pretty_ms_1.default)(Date.now() - timestamp)}`);
+                return totalIndexed;
+            }
+            catch (error) {
+                strapi.log.error(`Error reindexing ${collectionName}: ${error?.message} after ${(0, pretty_ms_1.default)(Date.now() - timestamp)}`);
+                throw error;
+            }
+        },
+        /**
+         * Handle a trigger event from a collection
+         */
+        async handleTriggerEvent(event) {
+            const { model, result } = event;
+            const registry = getRegistryService();
+            // Find virtual collections that should be triggered by this model
+            const affectedCollections = registry.findTriggersByCollection(model);
+            for (const collection of affectedCollections) {
+                // Find the specific trigger for this collection
+                const trigger = collection.triggers.find((t) => t.collection === model);
+                if (trigger && trigger.getIdsToReindex) {
+                    // Get IDs that need to be reindexed
+                    const idsToReindex = await trigger.getIdsToReindex(result);
+                    // Reindex each item
+                    for (const id of idsToReindex) {
+                        await this.indexItem(collection.collectionName, id);
+                    }
+                }
+            }
+        },
+        /**
+         * Delete an item from a virtual collection index
+         */
+        async deleteItem(collectionName, itemId) {
+            const registry = getRegistryService();
+            const collection = registry.get(collectionName);
+            if (!collection) {
+                throw new Error(`Virtual collection not found: ${collectionName}`);
+            }
+            try {
+                const esService = getElasticsearchService();
+                await esService.removeItemFromIndex({ itemId });
+                strapi.log.debug(`Deleted indexed item: ${collectionName}:${itemId}`);
+                return true;
+            }
+            catch (error) {
+                if (error?.meta?.statusCode === 404) {
+                    return false;
+                }
+                strapi.log.error(`Error deleting ${collectionName}:${itemId}: ${error.message}`);
+                throw error;
+            }
+        },
+    };
+};

package/dist/server/services/virtual-collections-registry.d.ts

@@ -0,0 +1,8 @@
+import { VirtualCollectionsRegistryService } from '../types';
+/**
+ * Service to handle indexing of virtual collections
+ */
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => VirtualCollectionsRegistryService;
+export default _default;

package/dist/server/services/virtual-collections-registry.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Service to handle indexing of virtual collections
+ */
+exports.default = ({ strapi }) => {
+    // const getElasticsearchService = () => strapi.plugin('elasticsearch').service('esInterface');
+    // const getAll = () => {
+    //   const config = strapi.plugin('elasticsearch').config('virtualCollections');
+    //   return config || [];
+    // };
+    // const get = (collectionName) => {
+    //   return getAll().find((collection) => collection.collectionName === collectionName);
+    // };
+    return {
+        getAll() {
+            const config = strapi.plugin('elasticsearch').config('virtualCollections');
+            return config || [];
+        },
+        get(collectionName) {
+            return this.getAll().find((collection) => collection.collectionName === collectionName) ?? null;
+        },
+        register: function (config) {
+            throw new Error('Function not implemented.');
+        },
+        findTriggersByCollection: function (collectionUID) {
+            return this.getAll().filter((collection) => {
+                return collection.triggers.some((trigger) => trigger.collection === collectionUID);
+            });
+        },
+    };
+};