@vegan-friendly/strapi-plugin-elasticsearch 0.2.1 → 0.2.3

package/dist/admin/src/components/SubNavigation/index.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
 export declare const SubNavigation: ({ activeUrl }: {
-    activeUrl: any;
+    activeUrl?: string | null;
 }) => React.JSX.Element;

package/dist/admin/src/components/SubNavigation/index.js

@@ -10,7 +10,7 @@ const design_system_1 = require("@strapi/design-system");
 const design_system_2 = require("@strapi/design-system");
 const react_router_dom_1 = require("react-router-dom");
 const pluginId_1 = __importDefault(require("../../pluginId"));
-const SubNavigation = ({ activeUrl }) => {
+const SubNavigation = ({ activeUrl = null }) => {
     const links = [
         {
             id: 1,

package/dist/admin/src/pages/ConfigureCollection/index.js

@@ -110,7 +110,7 @@ const ConfigureCollection = () => {
     const updateCollectionsConfig = ({ index, config }) => {
         setCollectionConfig({
             collectionName: collectionConfig.collectionName,
-            attributes: collectionConfig.attributes.map((e, idx) => index === idx ? config : e)
+            attributes: collectionConfig.attributes.map((e, idx) => (index === idx ? config : e)),
         });
     };
     const saveCollectionConfig = () => {
@@ -125,12 +125,16 @@ const ConfigureCollection = () => {
             saveConfigForCollection(collectionConfig.collectionName, data)
                 .then((resp) => {
                 toggleNotification({
-                    type: "success", message: "The collection configuration is saved.", timeout: 5000
+                    type: 'success',
+                    message: 'The collection configuration is saved.',
+                    timeout: 5000,
                 });
             })
                 .catch((err) => {
                 toggleNotification({
-                    type: "warning", message: err.message || "An error was encountered.", timeout: 5000
+                    type: 'warning',
+                    message: err.message || 'An error was encountered.',
+                    timeout: 5000,
                 });
                 console.log(err);
             })
@@ -147,7 +151,9 @@ const ConfigureCollection = () => {
                 .then((resp) => {
                 if (Object.keys(resp).length === 0) {
                     toggleNotification({
-                        type: "warning", message: 'No collection with the selected name exists.', timeout: 5000
+                        type: 'warning',
+                        message: 'No collection with the selected name exists.',
+                        timeout: 5000,
                     });
                 }
                 else {
@@ -162,7 +168,9 @@ const ConfigureCollection = () => {
             })
                 .catch((err) => {
                 toggleNotification({
-                    type: "warning", message: err.message || "An error was encountered.", timeout: 5000
+                    type: 'warning',
+                    message: err.message || 'An error was encountered.',
+                    timeout: 5000,
                 });
                 console.log(err);
             });

package/dist/admin/src/pages/ViewIndexingRunLog/index.js

@@ -51,7 +51,8 @@ const design_system_2 = require("@strapi/design-system");
 const design_system_3 = require("@strapi/design-system");
 const helper_plugin_1 = require("@strapi/helper-plugin");
 const loadRecentIndexingRuns = () => {
-    return axiosInstance_1.default.get(apiUrls_1.apiFetchRecentIndexingRunLog)
+    return axiosInstance_1.default
+        .get(apiUrls_1.apiFetchRecentIndexingRunLog)
         .then((resp) => resp.data)
         .then((data) => {
         return data;
@@ -71,17 +72,17 @@ const formattedDate = (dateString) => {
     const parts = dateTimeFormat.formatToParts(date);
     let formattedDate = '';
     parts.forEach((part) => {
-        if (part.type === "weekday")
+        if (part.type === 'weekday')
             formattedDate += `${part.value}, `;
-        if (part.type === "day")
+        if (part.type === 'day')
             formattedDate += `${part.value}/`;
-        if (part.type === "month")
+        if (part.type === 'month')
             formattedDate += `${part.value}/`;
-        if (part.type === "year")
+        if (part.type === 'year')
             formattedDate += `${part.value}  `;
-        if (part.type === "hour")
+        if (part.type === 'hour')
             formattedDate += `${part.value}:`;
-        if (part.type === "minute")
+        if (part.type === 'minute')
             formattedDate += `${part.value}`;
     });
     return formattedDate;
@@ -89,8 +90,7 @@ const formattedDate = (dateString) => {
 const ViewIndexingRunLog = () => {
     const [logTable, setLogTable] = (0, react_1.useState)(null);
     (0, react_1.useEffect)(() => {
-        loadRecentIndexingRuns()
-            .then(setLogTable);
+        loadRecentIndexingRuns().then(setLogTable);
     }, []);
     if (logTable === null)
         return react_1.default.createElement(helper_plugin_1.LoadingIndicatorPage, null);

package/dist/admin/src/utils/axiosInstance.js

@@ -12,11 +12,9 @@ const instance = axios_1.default.create({
     baseURL: process.env.STRAPI_ADMIN_BACKEND_URL,
 });
 instance.interceptors.request.use(async (config) => {
-    config.headers = {
-        'Authorization': `Bearer ${helper_plugin_1.auth.getToken()}`,
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-    };
+    config.headers.set('Authorization', `Bearer ${helper_plugin_1.auth.getToken()}`);
+    config.headers.set('Accept', 'application/json');
+    config.headers.set('Content-Type', 'application/json');
     return config;
 }, error => {
     Promise.reject(error);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vegan-friendly/strapi-plugin-elasticsearch",
-    "version": "0.2.1",
+    "version": "0.2.3",
     "description": "A Strapi plugin to enable using Elasticsearch with Strapi CMS.",
     "homepage": "https://github.com/vegan-friendly/strapi-plugin-elasticsearch",
     "strapi": {

package/dist/server/bootstrap.js

@@ -12,7 +12,7 @@ exports.default = async ({ strapi }) => {
         await configureIndexingService.initializeStrapiElasticsearch();
         if (!Object.keys(pluginConfig).includes('indexingCronSchedule'))
             console.warn('The plugin strapi-plugin-elasticsearch is enabled but the indexingCronSchedule is not configured.');
-        else if (!Object.keys(pluginConfig).includes('searchConnector'))
+        if (!Object.keys(pluginConfig).includes('searchConnector'))
             console.warn('The plugin strapi-plugin-elasticsearch is enabled but the searchConnector is not configured.');
         else {
             const connector = pluginConfig['searchConnector'];

package/dist/server/index.d.ts

@@ -163,38 +163,7 @@ declare const _default: {
         };
         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;
-            }): {};
-        };
+        }) => import("./types/helper-service.type").HelperService;
         transformContent: {
             transform({ content, from }: {
                 content: any;

package/dist/server/services/es-interface.js

@@ -29,13 +29,14 @@ exports.default = ({ strapi }) => ({
             throw err;
         }
     },
-    async createIndex(indexName) {
+    async createIndex(indexName, mappings) {
         try {
             const exists = await client.indices.exists({ index: indexName });
             if (!exists) {
                 console.log('strapi-plugin-elasticsearch : Search index ', indexName, ' does not exist. Creating index.');
                 await client.indices.create({
                     index: indexName,
+                    mappings: mappings ?? undefined,
                 });
             }
         }
@@ -67,10 +68,10 @@ exports.default = ({ strapi }) => ({
             }
         }
     },
-    async attachAliasToIndex(indexName) {
+    async attachAliasToIndex(indexName, optionalAliasName, mappings) {
         try {
             const pluginConfig = await strapi.config.get('plugin.elasticsearch');
-            const aliasName = pluginConfig.indexAliasName;
+            const aliasName = optionalAliasName ? optionalAliasName : pluginConfig.indexAliasName;
             const aliasExists = await client.indices.existsAlias({ name: aliasName });
             if (aliasExists) {
                 console.log('strapi-plugin-elasticsearch : Alias with this name already exists, removing it.');
@@ -78,7 +79,7 @@ exports.default = ({ strapi }) => ({
             }
             const indexExists = await client.indices.exists({ index: indexName });
             if (!indexExists)
-                await this.createIndex(indexName);
+                await this.createIndex(indexName, mappings);
             console.log('strapi-plugin-elasticsearch : Attaching the alias ', aliasName, ' to index : ', indexName);
             await client.indices.putAlias({ index: indexName, name: aliasName });
         }
@@ -157,4 +158,11 @@ exports.default = ({ strapi }) => ({
             throw err;
         }
     },
+    async listIndicesByPattern(pattern = 'restaurants*') {
+        const results = await client.cat.indices({
+            index: pattern,
+            format: 'json',
+        });
+        return results.map((index) => index.index).filter((index) => index != null);
+    },
 });

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

@@ -1,35 +1,5 @@
+import { HelperService } from '../types/helper-service.type';
 declare const _default: ({ 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;
-    }): {};
-};
+}) => HelperService;
 export default _default;

package/dist/server/services/helper.js

@@ -6,15 +6,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fp_1 = require("lodash/fp");
 const transform_content_1 = __importDefault(require("./transform-content"));
-const getPluginStore = () => {
-    return strapi.store({
-        environment: '',
-        type: 'plugin',
-        name: 'elasticsearch',
-    });
-};
+const defaultIndexPrefix = 'strapi-plugin-elasticsearch-index';
 const getModelPopulationAttributes = (model) => {
-    if (model.uid === "plugin::upload.file") {
+    if (model.uid === 'plugin::upload.file') {
         const { related, ...attributes } = model.attributes;
         return attributes;
     }
@@ -164,110 +158,117 @@ function extractSubfieldData({ config, data }) {
     }
     return returnData;
 }
-exports.default = ({ strapi }) => ({
-    async getElasticsearchInfo() {
-        const configureService = strapi.plugins['elasticsearch'].services.configureIndexing;
-        const esInterface = strapi.plugins['elasticsearch'].services.esInterface;
-        const pluginConfig = await strapi.config.get('plugin.elasticsearch');
-        const connected = pluginConfig.searchConnector && pluginConfig.searchConnector.host ? await esInterface.checkESConnection() : false;
-        return {
-            indexingCronSchedule: pluginConfig.indexingCronSchedule || 'Not configured',
-            elasticHost: pluginConfig.searchConnector ? pluginConfig.searchConnector.host || 'Not configured' : 'Not configured',
-            elasticUserName: pluginConfig.searchConnector ? pluginConfig.searchConnector.username || 'Not configured' : 'Not configured',
-            elasticCertificate: pluginConfig.searchConnector ? pluginConfig.searchConnector.certificate || 'Not configured' : 'Not configured',
-            elasticIndexAlias: pluginConfig.indexAliasName || 'Not configured',
-            connected: connected,
-            initialized: configureService.isInitialized(),
-        };
-    },
-    isCollectionDraftPublish({ collectionName }) {
-        const model = strapi.getModel(collectionName);
-        return model.attributes.publishedAt ? true : false;
-    },
-    getPopulateAttribute({ collectionName }) {
-        //TODO : We currently have set populate to upto 4 levels, should
-        //this be configurable or a different default value?
-        return getFullPopulateObject(collectionName, 4, []);
-    },
-    getIndexItemId({ collectionName, itemId }) {
-        return collectionName + '::' + itemId;
-    },
-    async getCurrentIndexName() {
-        const pluginStore = getPluginStore();
-        const settings = (await pluginStore.get({ key: 'configsettings' }));
-        let indexName = 'strapi-plugin-elasticsearch-index_000001';
-        if (settings) {
-            const objSettings = JSON.parse(settings);
-            if (Object.keys(objSettings).includes('indexConfig')) {
-                const idxConfig = objSettings['indexConfig'];
-                indexName = idxConfig['name'];
+exports.default = ({ strapi }) => {
+    const getEsInterface = () => strapi.plugins['elasticsearch'].services.esInterface;
+    return {
+        async getElasticsearchInfo() {
+            const configureService = strapi.plugins['elasticsearch'].services.configureIndexing;
+            const pluginConfig = await strapi.config.get('plugin.elasticsearch');
+            const connected = pluginConfig.searchConnector && pluginConfig.searchConnector.host ? await getEsInterface().checkESConnection() : false;
+            return {
+                indexingCronSchedule: pluginConfig.indexingCronSchedule || 'Not configured',
+                elasticHost: pluginConfig.searchConnector ? pluginConfig.searchConnector.host || 'Not configured' : 'Not configured',
+                elasticUserName: pluginConfig.searchConnector ? pluginConfig.searchConnector.username || 'Not configured' : 'Not configured',
+                elasticCertificate: pluginConfig.searchConnector ? pluginConfig.searchConnector.certificate || 'Not configured' : 'Not configured',
+                elasticIndexAlias: pluginConfig.indexAliasName || 'Not configured',
+                connected: connected,
+                initialized: configureService.isInitialized(),
+            };
+        },
+        isCollectionDraftPublish({ collectionName }) {
+            const model = strapi.getModel(collectionName);
+            return model.attributes.publishedAt ? true : false;
+        },
+        getPopulateAttribute({ collectionName }) {
+            //TODO : We currently have set populate to upto 4 levels, should
+            //this be configurable or a different default value?
+            return getFullPopulateObject(collectionName, 4, []);
+        },
+        getIndexItemId({ collectionName, itemId }) {
+            return collectionName + '::' + itemId;
+        },
+        async getCurrentIndexName(indexPrefix = defaultIndexPrefix) {
+            const indices = await getEsInterface().listIndicesByPattern(indexPrefix + '_*');
+            if (indices.length === 0) {
+                return indexPrefix + '_000000';
             }
-        }
-        return indexName;
-    },
-    async getIncrementedIndexName() {
-        const currentIndexName = await this.getCurrentIndexName();
-        const number = parseInt(currentIndexName.split('index_')[1]);
-        return 'strapi-plugin-elasticsearch-index_' + String(number + 1).padStart(6, '0');
-    },
-    async storeCurrentIndexName(indexName) {
-        const pluginStore = getPluginStore();
-        const settings = (await pluginStore.get({ key: 'configsettings' }));
-        if (settings) {
-            const objSettings = JSON.parse(settings);
-            objSettings['indexConfig'] = { name: indexName };
-            await pluginStore.set({ key: 'configsettings', value: JSON.stringify(objSettings) });
-        }
-        else {
-            const newSettings = JSON.stringify({ indexConfig: { name: indexName } });
-            await pluginStore.set({ key: 'configsettings', value: newSettings });
-        }
-    },
-    modifySubfieldsConfigForExtractor(collectionConfig) {
-        const collectionName = Object.keys(collectionConfig)[0];
-        const attributes = Object.keys(collectionConfig[collectionName]);
-        for (let r = 0; r < attributes.length; r++) {
-            const attr = attributes[r];
-            const attribFields = Object.keys(collectionConfig[collectionName][attr]);
-            if (attribFields.includes('subfields')) {
-                const subfielddata = collectionConfig[collectionName][attr]['subfields'];
-                if (subfielddata.length > 0) {
-                    try {
-                        const subfieldjson = JSON.parse(subfielddata);
-                        if (Object.keys(subfieldjson).includes('subfields'))
-                            collectionConfig[collectionName][attr]['subfields'] = subfieldjson['subfields'];
-                    }
-                    catch (err) {
-                        continue;
+            const sortedIndices = indices.sort(sortByIndexNumber(indexPrefix)).reverse();
+            return sortedIndices[0];
+        },
+        async getIncrementedIndexName(indexPrefix = defaultIndexPrefix) {
+            const currentIndexName = await this.getCurrentIndexName(indexPrefix);
+            const number = parseInt(currentIndexName.split(indexPrefix + '_')[1]);
+            return indexPrefix + '_' + String(number + 1).padStart(6, '0');
+        },
+        async deleteOldIndices(indexPrefix = defaultIndexPrefix) {
+            const esInterface = getEsInterface();
+            const indices = await esInterface.listIndicesByPattern(indexPrefix + '_*');
+            const sortedIndices = indices.sort(sortByIndexNumber(indexPrefix)).reverse();
+            const indicesToDelete = sortedIndices.slice(1);
+            for (let index of indicesToDelete) {
+                await esInterface.deleteIndex(index);
+            }
+            return indicesToDelete;
+        },
+        modifySubfieldsConfigForExtractor(collectionConfig) {
+            const collectionName = Object.keys(collectionConfig)[0];
+            const attributes = Object.keys(collectionConfig[collectionName]);
+            for (let r = 0; r < attributes.length; r++) {
+                const attr = attributes[r];
+                const attribFields = Object.keys(collectionConfig[collectionName][attr]);
+                if (attribFields.includes('subfields')) {
+                    const subfielddata = collectionConfig[collectionName][attr]['subfields'];
+                    if (subfielddata.length > 0) {
+                        try {
+                            const subfieldjson = JSON.parse(subfielddata);
+                            if (Object.keys(subfieldjson).includes('subfields'))
+                                collectionConfig[collectionName][attr]['subfields'] = subfieldjson['subfields'];
+                        }
+                        catch (err) {
+                            continue;
+                        }
                     }
                 }
             }
-        }
-        return collectionConfig;
-    },
-    extractDataToIndex({ collectionName, data, collectionConfig }) {
-        collectionConfig = this.modifySubfieldsConfigForExtractor(collectionConfig);
-        const fti = Object.keys(collectionConfig[collectionName]);
-        const document = {};
-        for (let k = 0; k < fti.length; k++) {
-            const fieldConfig = collectionConfig[collectionName][fti[k]];
-            if (fieldConfig.index) {
-                let val = null;
-                if (Object.keys(fieldConfig).includes('subfields')) {
-                    val = extractSubfieldData({ config: fieldConfig['subfields'], data: data[fti[k]] });
-                    val = val ? val.trim() : val;
-                }
-                else {
-                    val = data[fti[k]];
-                    if (Object.keys(fieldConfig).includes('transform') && fieldConfig['transform'] === 'markdown')
-                        val = transform_content_1.default.transform({ content: val, from: 'markdown' });
+            return collectionConfig;
+        },
+        extractDataToIndex({ collectionName, data, collectionConfig }) {
+            collectionConfig = this.modifySubfieldsConfigForExtractor(collectionConfig);
+            const fti = Object.keys(collectionConfig[collectionName]);
+            const document = {};
+            for (let k = 0; k < fti.length; k++) {
+                const fieldConfig = collectionConfig[collectionName][fti[k]];
+                if (fieldConfig.index) {
+                    let val = null;
+                    if (Object.keys(fieldConfig).includes('subfields')) {
+                        val = extractSubfieldData({ config: fieldConfig['subfields'], data: data[fti[k]] });
+                        val = val ? val.trim() : val;
+                    }
+                    else {
+                        val = data[fti[k]];
+                        if (Object.keys(fieldConfig).includes('transform') && fieldConfig['transform'] === 'markdown')
+                            val = transform_content_1.default.transform({ content: val, from: 'markdown' });
+                    }
+                    if (Object.keys(fieldConfig).includes('searchFieldName'))
+                        document[fieldConfig['searchFieldName']] = val;
+                    else
+                        document[fti[k]] = val;
                 }
-                if (Object.keys(fieldConfig).includes('searchFieldName'))
-                    document[fieldConfig['searchFieldName']] = val;
-                else
-                    document[fti[k]] = val;
             }
-        }
-        return document;
-    },
-});
+            return document;
+        },
+    };
+};
+/**
+ * sort index names by index number, e.g:
+ * restaurants_000001, restaurants_000002, restaurants_000003
+ * @param indexPrefix index alias, usually
+ * @returns
+ */
+function sortByIndexNumber(indexPrefix) {
+    return (a, b) => {
+        const numA = parseInt(a.split(indexPrefix + '_')[1]);
+        const numB = parseInt(b.split(indexPrefix + '_')[1]);
+        return numA - numB;
+    };
+}

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

@@ -59,38 +59,7 @@ declare const _default: {
     };
     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;
-        }): {};
-    };
+    }) => import("../types/helper-service.type").HelperService;
     transformContent: {
         transform({ content, from }: {
             content: any;

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

@@ -31,11 +31,9 @@ exports.default = ({ strapi }) => ({
                 //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);
-                console.log('strapi-plugin-elasticsearch : Deleting the previous index : ', oldIndexName);
+                console.log('strapi-plugin-elasticsearch : Deleting the previous indices');
                 //Step 5 : Delete the previous index
-                await esInterface.deleteIndex(oldIndexName);
+                await helper.deleteOldIndices();
                 await logIndexingService.recordIndexingPass('Request to immediately re-index site-wide content completed successfully.');
                 return true;
             }

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

@@ -27,44 +27,49 @@ exports.default = ({ strapi }) => {
                     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 itemData = results[0];
+                const esInterface = getElasticsearchService();
                 const helper = getHelperService();
-                const indexItemId = helper.getIndexItemId(collectionName, itemId);
-                await esService.indexDataToSpecificIndex({ itemId: indexItemId, itemData: indexData }, collection.indexName);
+                const indexItemId = helper.getIndexItemId({ collectionName, itemId });
+                const indexName = await helper.getCurrentIndexName(collection.indexAlias);
+                await esInterface.indexDataToSpecificIndex({ itemId: indexItemId, itemData }, indexName);
                 strapi.log.debug(`Indexed virtual item: ${collectionName}:${itemId}`);
-                return indexData;
+                return itemData;
             }
             catch (error) {
                 strapi.log.error(`Error indexing ${collectionName}:${itemId}: ${error?.message}`);
                 throw error;
             }
         },
-        async reindexAll(indexName) {
+        async reindexAll() {
+            const timestamp = Date.now();
             const registry = getRegistryService();
             const collections = registry.getAll();
             let totalIndexed = 0;
             for (const collection of collections) {
-                totalIndexed += await this.reindex(collection.collectionName, indexName);
+                totalIndexed += await this.reindex(collection);
             }
-            console.log(`strapi-plugin-elasticsearch : Reindexed ${totalIndexed} items across all ${collections.length} virtual collections`);
+            strapi.log.info(`strapi-plugin-elasticsearch : Reindexed ${totalIndexed} items across all ${collections.length} virtual collections. took ${(0, humanize_duration_1.default)(Date.now() - timestamp)} `);
             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();
+        async reindex(collection) {
+            const collectionName = collection.collectionName;
+            const privateIndexAlias = collection.indexAlias;
+            const helper = getHelperService();
+            let timestamp = Date.now();
             try {
-                const esService = getElasticsearchService();
-                const helper = getHelperService();
-                // await esService.createIndex(tempIndexName);
+                const esInterface = getElasticsearchService();
+                let indexName;
+                if (privateIndexAlias) {
+                    indexName = await helper.getIncrementedIndexName(privateIndexAlias);
+                    await esInterface.createIndex(indexName, collection.mappings);
+                }
+                else {
+                    indexName = await helper.getCurrentIndexName();
+                }
                 let page = 0;
                 let hasMoreData = true;
                 let totalIndexed = 0;
@@ -75,18 +80,25 @@ exports.default = ({ strapi }) => {
                         break;
                     }
                     const operations = [];
-                    for (const item of pageData) {
-                        const itemId = helper.getIndexItemId({ collectionName, itemId: item.id });
-                        const itemData = collection.mapToIndex ? item : item;
+                    for (const itemData of pageData) {
+                        const itemId = helper.getIndexItemId({ collectionName, itemId: itemData.id });
                         operations.push({ itemId, itemData });
                     }
                     if (operations.length > 0) {
-                        await Promise.all(operations.map((op) => esService.indexDataToSpecificIndex(op, indexName)));
+                        await Promise.all(operations.map((op) => esInterface.indexDataToSpecificIndex(op, indexName)));
                     }
                     totalIndexed += pageData.length;
                     page++;
                 }
-                strapi.log.info(`Reindexed ${totalIndexed} items for virtual collection: ${collectionName}. took ${(0, humanize_duration_1.default)(Date.now() - timestamp)}`);
+                strapi.log.info(`Reindexed ${totalIndexed} items for virtual collection: ${collectionName}. took ${(0, humanize_duration_1.default)(Date.now() - timestamp)}. now updating alias.`);
+                if (privateIndexAlias) {
+                    timestamp = Date.now();
+                    await esInterface.attachAliasToIndex(indexName, privateIndexAlias, collection.mappings);
+                    strapi.log.info(`Done attachAliasToIndex alias ${privateIndexAlias} to index ${indexName}. took ${(0, humanize_duration_1.default)(Date.now() - timestamp)}`);
+                    timestamp = Date.now();
+                    const oldIndicesDeleted = await helper.deleteOldIndices(privateIndexAlias);
+                    strapi.log.info(`Done deleting ${oldIndicesDeleted.length} old indices: ${oldIndicesDeleted}. took ${(0, humanize_duration_1.default)(Date.now() - timestamp)}`);
+                }
                 return totalIndexed;
             }
             catch (error) {
@@ -125,8 +137,8 @@ exports.default = ({ strapi }) => {
                 throw new Error(`Virtual collection not found: ${collectionName}`);
             }
             try {
-                const esService = getElasticsearchService();
-                await esService.removeItemFromIndex({ itemId });
+                const esInterface = getElasticsearchService();
+                await esInterface.removeItemFromIndex({ itemId });
                 strapi.log.debug(`Deleted indexed item: ${collectionName}:${itemId}`);
                 return true;
             }

package/dist/server/types/esInterface.type.d.ts

@@ -1,3 +1,4 @@
+import { MappingTypeMapping } from '@elastic/elasticsearch/lib/api/types';
 export interface EsInterfaceService {
     /**
      * Initializes the search engine connection.
@@ -15,7 +16,7 @@ export interface EsInterfaceService {
      * @param indexName - The name of the index to create.
      * @returns A promise that resolves when the index is created.
      */
-    createIndex(indexName: string): Promise<void>;
+    createIndex(indexName: string, mappings?: MappingTypeMapping): Promise<void>;
     /**
      * Deletes an index from the search engine.
      * @param indexName - The name of the index to delete.
@@ -25,9 +26,10 @@ export interface EsInterfaceService {
     /**
      * Attaches an alias to a specific index.
      * @param indexName - The index to which the alias should be attached.
+     * @param aliasName - Alias to attach. If not provided, alias from configuration 'indexAliasName' will be used.
      * @returns A promise that resolves when the alias is set.
      */
-    attachAliasToIndex(indexName: string): Promise<void>;
+    attachAliasToIndex(indexName: string, aliasName?: string, mappings?: MappingTypeMapping): Promise<void>;
     /**
      * Checks the connection status of the search engine.
      * @returns A promise that resolves with the connection status.
@@ -67,4 +69,5 @@ export interface EsInterfaceService {
      * @returns A promise that resolves with the search results.
      */
     searchData(searchQuery: any): Promise<any>;
+    listIndicesByPattern(pattern: string): Promise<string[]>;
 }

package/dist/server/types/helper-service.type.d.ts

@@ -0,0 +1,33 @@
+export type ElasticsearchInfo = {
+    indexingCronSchedule: string;
+    elasticHost: string;
+    elasticUserName: string;
+    elasticCertificate: string;
+    elasticIndexAlias: number;
+    connected: string;
+    initialized: boolean;
+};
+export interface HelperService {
+    getElasticsearchInfo(): Promise<ElasticsearchInfo>;
+    isCollectionDraftPublish(args: {
+        collectionName: string;
+    }): boolean;
+    getPopulateAttribute(args: {
+        collectionName: string;
+    }): true | {
+        populate: object;
+    } | undefined;
+    getIndexItemId(args: {
+        collectionName: string;
+        itemId: number;
+    }): string;
+    getCurrentIndexName(indexAlias?: string): Promise<string>;
+    getIncrementedIndexName(indexPrefix: string): Promise<string>;
+    deleteOldIndices(indexAlias?: string): Promise<string[]>;
+    modifySubfieldsConfigForExtractor(collectionConfig: object): object;
+    extractDataToIndex(args: {
+        collectionName: string;
+        data: object;
+        collectionConfig: object;
+    }): any;
+}

package/dist/server/types/helper-service.type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let a = {
+    a: 1,
+};
+const example = { foo: "bar" };
+a = example;

package/dist/server/types/virtual-collections.type.d.ts

@@ -1,5 +1,16 @@
-export type VirtualCollectionConfig<T extends {}> = {
-    indexName: string;
+import { MappingTypeMapping } from '@elastic/elasticsearch/lib/api/types';
+export type VirtualCollectionConfig<T extends StrapiEntity> = {
+    /**
+     * Optional -
+     * The alias of the latest index in Elasticsearch.
+     * It also serves as a prefix to actual indexes created in Elasticsearch.
+     * The actuall index name will be the `${indexNameBase}_${ind}`, e.g `restaurants_000001` and so on.
+     * and the alias will be the `indexNameBase`.
+     *
+     * If you don't provide this, the default index name will be used as the alias.
+     * Omit this property if you want to use the default index for all collections.
+     */
+    indexAlias?: string;
     collectionName: string;
     extractData: (page: number, pageSize?: number) => Promise<T[]>;
     extractById: (ids: number[]) => Promise<T[]>;
@@ -7,7 +18,11 @@ export type VirtualCollectionConfig<T extends {}> = {
         collection: string;
         getIdsToReindex: (result: any) => Promise<number[]>;
     }>;
-    mapToIndex?: (item: T) => Promise<object>;
+    /**
+     * Optional schema to be sent to Elasticsearch when creating the index.
+     * If you don't include this, ElasticSearch will automatically create a schema for you.
+     */
+    mappings?: MappingTypeMapping;
 };
 export interface VirtualCollectionsRegistryService {
     /**
@@ -15,7 +30,7 @@ export interface VirtualCollectionsRegistryService {
      * @param config - The configuration for the virtual collection
      * @returns The current instance of the registry
      */
-    register<T extends {}>(config: VirtualCollectionConfig<T>): this;
+    register<T extends StrapiEntity>(config: VirtualCollectionConfig<T>): this;
     /**
      * get all registered virtual collections
      * @returns An array of all registered virtual collections
@@ -24,6 +39,10 @@ export interface VirtualCollectionsRegistryService {
     get(collectionName: string): VirtualCollectionConfig<any> | null;
     findTriggersByCollection(collectionUID: string): Array<VirtualCollectionConfig<any>>;
 }
+export type StrapiEntity = {
+    id: number;
+    [key: string]: any;
+};
 export interface VirtualCollectionsIndexerService {
     /**
      * Index a single item from a virtual collection.
@@ -33,15 +52,13 @@ export interface VirtualCollectionsIndexerService {
     indexItem(collectionName: string, itemId: number): Promise<any>;
     /**
      * Reindex all items in a virtual collection index.
-     * @param indexName - The target index name.
      */
-    reindexAll(indexName: string): Promise<any>;
+    reindexAll(): Promise<any>;
     /**
      * Reindex all items in a virtual collection.
-     * @param collectionName - The name of the virtual collection.
-     * @param indexName - The target index name.
+     * @param collection - The virtual collection config.
      */
-    reindex(collectionName: string, indexName: string): Promise<any>;
+    reindex<T extends StrapiEntity>(collection: VirtualCollectionConfig<T>): Promise<any>;
     /**
      * Handle a trigger event from a collection.
      * @param event - The trigger event.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vegan-friendly/strapi-plugin-elasticsearch",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "A Strapi plugin to enable using Elasticsearch with Strapi CMS.",
   "homepage": "https://github.com/vegan-friendly/strapi-plugin-elasticsearch",
   "strapi": {
@@ -61,4 +61,4 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
   }
-}
+}