@vegan-friendly/strapi-plugin-elasticsearch 0.0.11-alpha.6 → 0.0.11-alpha.7

package/admin/src/pages/Homepage/index.js

@@ -0,0 +1,168 @@
+import React, { useState, useEffect } from 'react';
+import  { SubNavigation } from '../../components/SubNavigation';;
+import { Box, Flex, Tab } from '@strapi/design-system';
+import { Typography } from '@strapi/design-system';
+import { apiGetElasticsearchSetupInfo, apiRequestReIndexing,
+    apiTriggerIndexing } from '../../utils/apiUrls';
+import axiosInstance  from '../../utils/axiosInstance';
+import { IconButton } from '@strapi/design-system';
+import { Table, Tr, Td } from '@strapi/design-system';
+import { Refresh } from '@strapi/icons';
+import { TwoColsLayout, Button } from '@strapi/design-system';
+import { Grid, GridItem, Divider } from '@strapi/design-system';
+import {LoadingIndicatorPage, useNotification} from '@strapi/helper-plugin';
+
+const loadElasticsearchSetupInfo = () => {
+    return axiosInstance.get(apiGetElasticsearchSetupInfo)
+        .then((resp) => resp.data)
+        .then((data) => {
+          return data;
+        });
+}
+
+const Homepage = () => {
+    const [setupInfo, setSetupInfo] = useState(null);
+    const [isInProgress, setIsInProgress] = useState(false);
+    const toggleNotification = useNotification();
+
+    const displayLabels = {'connected' : 'Connected',
+        'elasticCertificate' : 'Certificate',
+        'elasticHost' : 'Elasticsearch host',
+        'elasticIndexAlias' : 'Elasticsearch index Alias name',
+        'elasticUserName' : 'Elasticsearch username',
+        'indexingCronSchedule' : 'Indexing cron schedule',
+        'initialized' : 'Elasticsearch configuration loaded'};
+
+    const reloadElasticsearchSetupInfo = ({showNotification}) => {
+        setIsInProgress(true);
+        loadElasticsearchSetupInfo()
+        .then(setSetupInfo)
+        .then(() => {
+            if (showNotification)
+                toggleNotification({
+                    type: "success", message: "Elasticsearch setup information reloaded.", timeout: 5000
+                });
+        })
+        .finally(() => setIsInProgress(false));
+    }
+
+    const requestFullSiteReindexing = () => {
+        setIsInProgress(true);
+        return axiosInstance.get(apiRequestReIndexing)
+            .then(() => {
+                toggleNotification({
+                    type: "success", message: "Rebuilding the index is triggered.", timeout: 5000
+                });
+            })
+            .catch(() => {
+                toggleNotification({
+                    type: "warning", message: "An error was encountered.", timeout: 5000
+                });
+            })
+            .finally(() => setIsInProgress(false));
+    }
+
+    const triggerIndexingRun = () => {
+        setIsInProgress(true);
+        return axiosInstance.get(apiTriggerIndexing)
+        .then(() => {
+            toggleNotification({
+                type: "success", message: "The indexing job to process the pending tasks is started.", timeout: 5000
+            });
+        })
+        .catch(() => {
+            toggleNotification({
+                type: "warning", message: "An error was encountered.", timeout: 5000
+            });
+        })
+        .finally(() => setIsInProgress(false));
+    }
+    useEffect(() => {
+        reloadElasticsearchSetupInfo({showNotification: false});
+    }, []);
+
+    if (setupInfo === null)
+        return <LoadingIndicatorPage />
+    else
+        return (
+        <Flex alignItems="stretch" gap={4}>
+        <SubNavigation />
+        <Box padding={8} background="neutral100" width="100%">
+        <Box paddingBottom={4}>
+            <Typography variant="alpha">Setup Information</Typography>
+        </Box>   
+        <Box  width="100%" paddingBottom={4}>
+            <TwoColsLayout startCol={
+                <>
+            <Table>
+            {
+                setupInfo && (
+                    Object.keys(setupInfo).map((k, idx) => {
+                        return (
+                            <Tr key={idx}>
+                                <Td><Box padding={2}>
+                                    <Typography textColor="neutral600">{displayLabels[k]} :</Typography>
+                                </Box></Td>
+                                <Td>
+                                    <Box padding={2}>
+                                    <Grid>
+                                        <GridItem padding={2}>
+                                            { 
+                                                k === 'connected' && setupInfo[k] === true && 
+                                                (
+                                                    <Typography fontWeight="bold" textColor="success500">Yes</Typography>
+                                                )
+                                            }
+                                            { 
+                                                k === 'connected' && setupInfo[k] === false && 
+                                                (
+                                                    <Typography fontWeight="bold" textColor="danger500">No</Typography>
+                                                )
+                                            }
+                                            {
+                                                k !== 'connected' && 
+                                                (
+                                                    <Typography textColor="neutral600">{String(setupInfo[k])}</Typography>
+                                                )
+                                            }
+                                        </GridItem>
+                                        <GridItem padding={1}>
+                                            {
+                                                k === 'connected' ?
+                                                <IconButton disabled={isInProgress} onClick={() => reloadElasticsearchSetupInfo({showNotification: true})} label="Refresh" icon={<Refresh />} /> : null                                            
+                                            }
+                                        </GridItem>
+                                    </Grid>
+                                    </Box>
+                                </Td>
+                            </Tr>
+                        );
+                    })
+                )
+            }
+            </Table></>}
+            endCol={<>
+            <Box paddingLeft={2} paddingRight={2} paddingTop={4} paddingBottom={4} >
+                <Box paddingTop={4} paddingBottom={4}>
+                    <Typography variant="pi" fontWeight="bold" textColor="neutral600" >ACTIONS</Typography>
+                </Box>
+                <Divider />
+                <Box paddingTop={4} paddingBottom={4}>
+                    <Box paddingTop={2} paddingBottom={2}>
+                        <Button loading={isInProgress} fullWidth variant="secondary" onClick={requestFullSiteReindexing}>Rebuild Index</Button>
+                    </Box>
+                    <Box paddingTop={2} paddingBottom={2}>
+                        <Button loading={isInProgress} fullWidth variant="secondary" onClick={triggerIndexingRun}>Trigger Indexing</Button>
+                    </Box>
+                </Box>
+            </Box>
+            </>
+            } />
+        </Box>
+        </Box>
+        </Flex>
+        );
+};
+
+
+export default Homepage;

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

@@ -0,0 +1,124 @@
+/*
+ *
+ * HomePage
+ *
+ */
+
+import React, { useState, useEffect } from 'react';
+// import PropTypes from 'prop-types';
+import pluginId from '../../pluginId';
+import  { SubNavigation } from '../../components/SubNavigation';;
+import { Box, Flex } from '@strapi/design-system';
+import { apiFetchRecentIndexingRunLog } from "../../utils/apiUrls";
+import axiosInstance  from '../../utils/axiosInstance';
+import { Table, Thead, Tbody, Tr, Td, Th } from '@strapi/design-system';
+import { Typography } from '@strapi/design-system';
+import {LoadingIndicatorPage} from '@strapi/helper-plugin';
+
+const loadRecentIndexingRuns = () => {
+  return axiosInstance.get(apiFetchRecentIndexingRunLog)
+      .then((resp) => resp.data)
+      .then((data) => {
+        return data;
+      });
+} 
+
+const formattedDate = (dateString) => {
+  const date = new Date(dateString);
+  const options = {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+  };
+  
+  const dateTimeFormat = new Intl.DateTimeFormat('en-US', options);
+  const parts = dateTimeFormat.formatToParts(date);
+  
+  let formattedDate = '';
+  parts.forEach((part) => {
+      if (part.type === "weekday") 
+          formattedDate+= `${part.value}, `;
+       if (part.type === "day") 
+          formattedDate+= `${part.value}/`;   
+       if (part.type === "month") 
+          formattedDate+= `${part.value}/`;  
+       if (part.type === "year") 
+          formattedDate+= `${part.value}  `;
+       if (part.type === "hour") 
+          formattedDate+= `${part.value}:`;
+       if (part.type === "minute") 
+          formattedDate+= `${part.value}`;         
+  });
+
+  return formattedDate;
+}
+
+const ViewIndexingRunLog = () => {
+  const [logTable, setLogTable] = useState(null);
+  useEffect(() => {
+    loadRecentIndexingRuns()
+    .then(setLogTable)
+    }, []);
+  
+  if (logTable === null)
+        return <LoadingIndicatorPage />
+  else
+    return (
+        <Flex alignItems="stretch" gap={4}>
+            <SubNavigation />
+            <Box padding={8} background="neutral100" width="100%">
+              <Box paddingBottom={4}>
+                <Typography variant="alpha">Recent Indexing Run Logs</Typography>
+              </Box>
+              {
+                logTable && logTable.length > 0 && (
+                  <>
+                    <Table colCount={3} rowCount={logTable.length}>
+                      <Thead>
+                        <Tr>
+                          <Th>
+                            <Typography variant="sigma">Date</Typography>
+                          </Th>
+                          <Th>
+                            <Typography variant="sigma">Status</Typography>
+                          </Th>
+                          <Th>
+                            <Typography variant="sigma">Details</Typography>
+                          </Th>
+                        </Tr>
+                      </Thead>
+                      <Tbody>
+                      {
+                        logTable.map((data, index) => {
+                          return (
+                            <Tr key={index}>
+                              <Td>
+                                <Typography textColor="neutral600">{formattedDate(data.createdAt)}</Typography>
+                              </Td>
+                              <Td>
+                                <Typography textColor="neutral600">{data.status}</Typography>
+                              </Td>
+                              <Td>
+                                <Typography textColor="neutral600">{data.details}</Typography>
+                              </Td>                                 
+                            </Tr>
+                          );
+                        })
+                      }
+                      </Tbody>
+                    </Table>
+                    <Box paddingTop={2} paddingBottom={2}>
+                      <Typography textColor="neutral600">This view lists the details of the 50 recent-most indexing runs.</Typography>
+                    </Box>
+                  </>
+                )
+              }
+            </Box>    
+        </Flex>
+  );
+};
+
+export default ViewIndexingRunLog;

package/admin/src/pluginId.js

@@ -0,0 +1,5 @@
+import pluginPkg from '../../package.json';
+
+const pluginId = pluginPkg.strapi.name;
+
+export default pluginId;

package/admin/src/translations/en.json

@@ -0,0 +1 @@
+{}

package/admin/src/translations/fr.json

@@ -0,0 +1 @@
+{}

package/admin/src/utils/apiUrls.js

@@ -0,0 +1,14 @@
+import { collectionName } from "../../../server/content-types/tasks";
+import pluginId from "../pluginId";
+export const apiGetContentConfig = `/${pluginId}/content-config/`
+export const apiGetCollectionConfig = (collectionName) => `/${pluginId}/collection-config/${collectionName}`
+export const apiSaveCollectionConfig = (collectionName) => `/${pluginId}/collection-config/${collectionName}`
+export const apiGetElasticsearchSetupInfo = `/${pluginId}/setup-info`
+export const apiFetchRecentIndexingRunLog = `/${pluginId}/indexing-run-log`
+export const apiRequestReIndexing = `/${pluginId}/reindex`
+export const apiRequestCollectionIndexing = (collectionName) => `/${pluginId}/collection-reindex/${collectionName}`
+export const apiTriggerIndexing = `/${pluginId}/trigger-indexing/`
+
+export const apiExportContentConfig = `/${pluginId}/export-content-config/`
+export const apiImportContentConfig = `/${pluginId}/import-content-config/`
+

package/admin/src/utils/axiosInstance.js

@@ -0,0 +1,40 @@
+/**
+ * axios with a custom config.
+ */
+
+import axios from 'axios';
+import { auth } from '@strapi/helper-plugin';
+
+const instance = axios.create({
+  baseURL: process.env.STRAPI_ADMIN_BACKEND_URL,
+});
+
+instance.interceptors.request.use(
+  async config => {
+    config.headers = {
+      Authorization: `Bearer ${auth.getToken()}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    };
+
+    return config;
+  },
+  error => {
+    Promise.reject(error);
+  }
+);
+
+instance.interceptors.response.use(
+  response => response,
+  error => {
+    // whatever you want to do with the error
+    if (error.response?.status === 401) {
+      auth.clearAppStorage();
+      window.location.reload();
+    }
+
+    throw error;
+  }
+);
+
+export default instance;

package/admin/src/utils/getTrad.js

@@ -0,0 +1,5 @@
+import pluginId from '../pluginId';
+
+const getTrad = (id) => `${pluginId}.${id}`;
+
+export default getTrad;

package/package.json

@@ -1,80 +1,40 @@
-{
-  "name": "@vegan-friendly/strapi-plugin-elasticsearch",
-  "description": "A Strapi plugin to enable using Elasticsearch with Strapi CMS.",
-  "license": "MIT",
-  "author": "Punit Sethi <punit@tezify.com>",
-  "homepage": "https://github.com/vegan-friendly/strapi-plugin-elasticsearch",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/vegan-friendly/strapi-plugin-elasticsearch.git"
-  },
-  "maintainers": [
-    {
-      "name": "Punit Sethi",
-      "email": "punit@tezify.com",
-      "url": "https://punits.dev"
-    }
-  ],
-  "engines": {
-    "node": ">=18.0.0 <=22.x.x",
-    "npm": ">=6.0.0"
-  },
-  "version": "0.0.11-alpha.6",
-  "keywords": [],
-  "type": "commonjs",
-  "exports": {
-    "./package.json": "./package.json",
-    "./strapi-admin": {
-      "source": "./admin/src/index.js",
-      "import": "./dist/admin/index.mjs",
-      "require": "./dist/admin/index.js",
-      "default": "./dist/admin/index.js"
-    },
-    "./strapi-server": {
-      "source": "./server/src/index.js",
-      "import": "./dist/server/index.mjs",
-      "require": "./dist/server/index.js",
-      "default": "./dist/server/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "strapi-plugin build",
-    "watch": "strapi-plugin watch",
-    "watch:link": "strapi-plugin watch:link",
-    "verify": "strapi-plugin verify"
-  },
-  "dependencies": {
-    "@elastic/elasticsearch": "^8.17.1",
-    "@radix-ui/react-tooltip": "^1.1.8",
-    "@strapi/design-system": "^2.0.0-rc.18",
-    "@strapi/icons": "^2.0.0-rc.18",
-    "markdown-to-txt": "^2.0.1",
-    "react-intl": "^7.1.9"
-  },
-  "devDependencies": {
-    "@strapi/sdk-plugin": "^5.3.2 || ^4.0.0",
-    "@strapi/strapi": "^5.11.3 || ^4.0.0",
-    "prettier": "^3.5.3",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-router-dom": "^6.30.0 || ^5",
-    "styled-components": "^6.1.16 || ^5"
-  },
-  "peerDependencies": {
-    "@strapi/sdk-plugin": "^5.3.2 || ^4.0.0",
-    "@strapi/strapi": "^5.11.3 || ^4.0.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-router-dom": "^6.30.0 || ^5",
-    "styled-components": "^6.1.16 || ^5"
-  },
-  "strapi": {
-    "name": "elasticsearch",
-    "description": "A plugin to enable using Elasticsearch with Strapi CMS.",
-    "kind": "plugin",
-    "displayName": "Strapi <-> Elasticsearch"
-  }
-}
+{
+  "name": "@vegan-friendly/strapi-plugin-elasticsearch",
+  "version": "0.0.11-alpha.7",
+  "description": "A Strapi plugin to enable using Elasticsearch with Strapi CMS.",
+  "homepage": "https://github.com/vegan-friendly/strapi-plugin-elasticsearch",
+  "strapi": {
+    "name": "elasticsearch",
+    "description": "A plugin to enable using Elasticsearch with Strapi CMS.",
+    "kind": "plugin",
+    "displayName": "Strapi <-> Elasticsearch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/vegan-friendly/strapi-plugin-elasticsearch.git"
+  },
+  "author": {
+    "name": "Punit Sethi",
+    "email": "punit@tezify.com",
+    "url": "https://punits.dev"
+  },
+  "dependencies": {
+    "@elastic/elasticsearch": "^8.9.0",
+    "markdown-to-txt": "^2.0.1"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^4.0.0"
+  },
+  "maintainers": [
+    {
+      "name": "Punit Sethi",
+      "email": "punit@tezify.com",
+      "url": "https://punits.dev"
+    }
+  ],
+  "engines": {
+    "node": ">=16.0.0 <=20.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "MIT"
+}

package/server/bootstrap.js

@@ -0,0 +1,142 @@
+'use strict';
+
+module.exports = async ({ strapi }) => {
+    const pluginConfig = await strapi.config.get('plugin.elasticsearch');
+    const configureIndexingService = strapi.plugins['elasticsearch'].services.configureIndexing;
+    const scheduleIndexingService = strapi.plugins['elasticsearch'].services.scheduleIndexing;
+    const esInterface = strapi.plugins['elasticsearch'].services.esInterface;
+    const indexer = strapi.plugins['elasticsearch'].services.indexer;
+    const helper = strapi.plugins['elasticsearch'].services.helper; 
+    try
+    {
+      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'))
+        console.warn("The plugin strapi-plugin-elasticsearch is enabled but the searchConnector is not configured.");
+      else
+      {
+        const connector = pluginConfig['searchConnector'];
+        await esInterface.initializeSearchEngine({host : connector.host, uname: connector.username, 
+              password: connector.password, cert: connector.certificate});
+        strapi.cron.add({
+          elasticsearchIndexing: {
+            task: async ({ strapi }) => {
+              await indexer.indexPendingData();
+            },
+            options: {
+              rule: pluginConfig['indexingCronSchedule'],
+            },
+          },
+        });   
+        
+        if (await esInterface.checkESConnection())
+        {
+          //Attach the alias to the current index:
+          const idxName = await helper.getCurrentIndexName();
+          await esInterface.attachAliasToIndex(idxName);
+        }
+          
+      }
+  
+      strapi.db.lifecycles.subscribe(async (event) => {
+        if (event.action === 'afterCreate' || event.action === 'afterUpdate') {
+          if (strapi.elasticsearch.collections.includes(event.model.uid))
+          {
+            //collection without draft-publish
+            if (typeof event.model.attributes.publishedAt === "undefined")
+            {
+              await scheduleIndexingService.addItemToIndex({
+                collectionUid: event.model.uid,
+                recordId: event.result.id
+              });  
+            }
+            else if (event.model.attributes.publishedAt)
+            {
+              if (event.result.publishedAt)
+              {
+                await scheduleIndexingService.addItemToIndex({
+                  collectionUid: event.model.uid,
+                  recordId: event.result.id
+                });    
+              }
+              else
+              {
+                //unpublish
+                await scheduleIndexingService.removeItemFromIndex({
+                  collectionUid: event.model.uid,
+                  recordId: event.result.id
+                });    
+              }
+            }
+          }
+        }
+        //bulk publish-unpublish from list view
+        if (event.action === 'afterCreateMany' || event.action === 'afterUpdateMany') {
+          if (strapi.elasticsearch.collections.includes(event.model.uid))
+          {
+            if (Object.keys(event.params.where.id).includes('$in'))
+            {
+              const updatedItemIds = event.params.where.id['$in']
+              //bulk unpublish
+              if (typeof event.params.data.publishedAt === "undefined" || 
+                event.params.data.publishedAt === null)
+                {
+                  for (let k = 0; k< updatedItemIds.length; k++)
+                  {
+                    await scheduleIndexingService.removeItemFromIndex({
+                      collectionUid: event.model.uid,
+                      recordId: updatedItemIds[k]
+                    });            
+                  }    
+                }
+              else
+              {
+                for (let k = 0; k< updatedItemIds.length; k++)
+                {
+                  await scheduleIndexingService.addItemToIndex({
+                    collectionUid: event.model.uid,
+                    recordId: updatedItemIds[k]
+                  });   
+                }
+              }
+            }
+          }
+        }    
+        if (event.action === 'afterDelete') {
+          if (strapi.elasticsearch.collections.includes(event.model.uid))
+          {
+            await scheduleIndexingService.removeItemFromIndex({
+              collectionUid: event.model.uid,
+              recordId: event.result.id
+            });  
+          }
+        }
+        if (event.action === 'afterDeleteMany') {
+          if (strapi.elasticsearch.collections.includes(event.model.uid))
+          {
+            if (Object.keys(event.params.where).includes('$and') &&
+            Array.isArray(event.params.where['$and']) &&
+            Object.keys(event.params.where['$and'][0]).includes('id') && 
+            Object.keys(event.params.where['$and'][0]['id']).includes('$in'))
+            {
+              const deletedItemIds = event.params.where['$and'][0]['id']['$in']
+              for (let k = 0; k< deletedItemIds.length; k++)
+              {
+                await scheduleIndexingService.removeItemFromIndex({
+                  collectionUid: event.model.uid,
+                  recordId: deletedItemIds[k]
+                });            
+              }
+            }        
+          }
+        }
+      });   
+      configureIndexingService.markInitialized(); 
+    }
+    catch(err) {
+      console.error('An error was encountered while initializing the strapi-plugin-elasticsearch plugin.')
+      console.error(err);
+    }  
+};

package/server/config/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  default: {},
+  validator() {},
+};

package/server/content-types/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const task = require('./tasks');
+const indexingLog = require('./indexing-logs');
+
+module.exports = {
+    'task' : {schema : task},
+    'indexing-log' : {schema: indexingLog}
+};