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

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.1.0-alpha.0",
+  "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}
+};

package/server/content-types/indexing-logs.js

@@ -0,0 +1,35 @@
+module.exports = {
+    "kind": "collectionType",
+    "collectionName": "indexing-log",
+    "info": {
+      "singularName": "indexing-log",
+      "pluralName": "indexing-logs",
+      "displayName": "Indexing Logs",
+      "description": "Logged runs of the indexing cron job"
+    },
+    "options": {
+      "draftAndPublish": false
+    },
+    "pluginOptions": {
+      'content-manager': {
+        visible: false,
+      },
+      'content-type-builder': {
+        visible: false,
+      }        
+    },
+    "attributes": {
+      "status": {
+        "type": "enumeration",
+        "enum": [
+          "pass",
+          "fail"
+        ],
+        "required": true
+      },
+      "details": {
+        "type": "text"
+      }  
+    }
+  }
+  

package/server/content-types/tasks.js

@@ -0,0 +1,52 @@
+module.exports = {
+    "kind": "collectionType",
+    "collectionName": "task",
+    "info": {
+      "singularName": "task",
+      "pluralName": "tasks",
+      "displayName": "Task",
+      "description": "Search indexing tasks"
+    },
+    "options": {
+      "draftAndPublish": false
+    },
+    "pluginOptions": {
+        'content-manager': {
+            visible: false,
+          },
+          'content-type-builder': {
+            visible: false,
+          }        
+    },
+    "attributes": {
+      "collection_name": {
+        "type": "string",
+        "required": true
+      },
+      "item_id": {
+        "type": "integer"
+      },
+      "indexing_status": {
+        "type": "enumeration",
+        "enum": [
+          "to-be-done",
+          "done"
+        ],
+        "required": true,
+        "default": "to-be-done"
+      },
+      "full_site_indexing": {
+        "type": "boolean"
+      },
+      "indexing_type": {
+        "type": "enumeration",
+        "enum": [
+          "add-to-index",
+          "remove-from-index"
+        ],
+        "default": "add-to-index",
+        "required": true
+      }
+    }
+  }
+  

package/server/controllers/configure-indexing.js

@@ -0,0 +1,66 @@
+'use strict';
+
+
+
+module.exports = ({ strapi }) => {
+  const configureIndexingService = strapi.plugins['elasticsearch'].services.configureIndexing;
+
+  const getContentConfig = async (ctx) => {
+    return configureIndexingService.getContentConfig();
+  };
+
+  const saveCollectionConfig = async (ctx) => {
+    const { body } = ctx.request;
+    try {
+      const updatedConfig = await configureIndexingService.setContentConfig({collection: ctx.params.collectionname, config : body.data});
+      return updatedConfig;
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  };
+  
+  const importContentConfig = async (ctx) => {
+    const { body } = ctx.request;
+    try {
+      if (body['data'])
+      {
+        const updatedConfig = await configureIndexingService.importContentConfig({config : body['data']});
+        return updatedConfig;  
+      }
+      else
+        ctx.throw(400, 'Invalid parameters')
+    } catch (err) {
+      ctx.throw(500, err);
+    }    
+  }
+
+  const exportContentConfig = async (ctx) => {
+    return configureIndexingService.getContentConfig();
+  }
+
+  const setContentConfig = async (ctx) => {
+    const { body } = ctx.request;
+    try {
+        const updatedConfig = await configureIndexingService.setContentConfig({config : body});
+        return updatedConfig;
+      } catch (err) {
+        ctx.throw(500, err);
+      }    
+  }
+
+  const getCollectionConfig = async (ctx) => {
+    if (ctx.params.collectionname)
+      return configureIndexingService.getCollectionConfig({collectionName: ctx.params.collectionname})
+    else
+      return null;
+  }
+
+  return {
+    getContentConfig,
+    setContentConfig,
+    getCollectionConfig,
+    saveCollectionConfig,
+    exportContentConfig, 
+    importContentConfig
+  };  
+};

package/server/controllers/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const configureIndexing = require('./configure-indexing');
+const performSearch = require('./perform-search');
+const logIndexing = require('./log-indexing');
+const setupInfo = require('./setup-info');
+const performIndexing = require('./perform-indexing');
+
+module.exports = {
+  configureIndexing,
+  performSearch,
+  logIndexing,
+  setupInfo,
+  performIndexing
+};

package/server/controllers/log-indexing.js

@@ -0,0 +1,11 @@
+
+module.exports = ({ strapi }) => {
+    const logIndexingService = strapi.plugins['elasticsearch'].services.logIndexing;
+    const fetchRecentRunsLog = async (ctx) => {
+        return await logIndexingService.fetchIndexingLogs();
+    }
+
+    return {
+        fetchRecentRunsLog
+    };
+}

package/server/controllers/perform-indexing.js

@@ -0,0 +1,28 @@
+'use strict';
+
+
+
+module.exports = ({ strapi }) => {
+    const indexer = strapi.plugins['elasticsearch'].services.indexer;
+    const scheduleIndexingService = strapi.plugins['elasticsearch'].services.scheduleIndexing;
+    const rebuildIndex = async (ctx) => {
+        return await indexer.rebuildIndex();
+    }
+
+    const indexCollection = async (ctx) => {
+        if (ctx.params.collectionname)
+            return await scheduleIndexingService.addCollectionToIndex({collectionUid: ctx.params.collectionname})
+        else
+            return null;
+    }
+
+    const triggerIndexingTask = async (ctx) => {
+        return await indexer.indexPendingData()
+    }
+
+    return {
+        rebuildIndex,
+        indexCollection,
+        triggerIndexingTask
+    };     
+}

package/server/controllers/perform-search.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const qs = require('qs');
+
+module.exports =  {
+  search : async (ctx) => {
+    try {
+        const esInterface = strapi.plugins['elasticsearch'].services.esInterface;
+        if (ctx.query.query)
+        {
+          const query = qs.parse(ctx.query.query);
+          const resp = await esInterface.searchData(query);
+          if (resp?.hits?.hits)
+          {
+            const filteredData = resp.hits.hits.filter(dt => dt._source !== null);
+            const filteredMatches = filteredData.map((dt) => dt['_source']);
+            ctx.body = filteredMatches;
+          }
+          else
+            ctx.body = {}
+        }
+        else
+          ctx.body = {}
+      } catch (err) {
+        ctx.response.status = 500;
+        ctx.body = "An error was encountered while processing the search request."
+        console.log('An error was encountered while processing the search request.')
+        console.log(err);
+      }
+  }  
+};

package/server/controllers/setup-info.js

@@ -0,0 +1,14 @@
+'use strict';
+
+
+
+module.exports = ({ strapi }) => {
+    const helperService = strapi.plugins['elasticsearch'].services.helper;
+    const getElasticsearchInfo = async (ctx) => {
+        return helperService.getElasticsearchInfo();
+    }
+
+    return {
+        getElasticsearchInfo,
+    };     
+}

package/server/destroy.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // destroy phase
+};

package/server/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+const destroy = require('./destroy');
+const config = require('./config');
+const contentTypes = require('./content-types');
+const controllers = require('./controllers');
+const routes = require('./routes');
+const middlewares = require('./middlewares');
+const policies = require('./policies');
+const services = require('./services');
+
+module.exports = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares,
+};

package/server/middlewares/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = {};

package/server/policies/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = {};

package/server/register.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // register phase
+};

package/server/routes/configure-indexing.js

@@ -0,0 +1,42 @@
+module.exports = {
+    // accessible only from admin UI
+    type: 'admin',
+    routes: [
+      {
+        method: 'GET',
+        path: '/content-config',
+        handler: 'configureIndexing.getContentConfig',
+        config: { policies: [] },
+      },
+      {
+        method: 'GET',
+        path: '/collection-config/:collectionname',
+        handler: 'configureIndexing.getCollectionConfig',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/collection-config/:collectionname',
+        handler: 'configureIndexing.saveCollectionConfig',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/content-config',
+        handler: 'configureIndexing.setContentConfig',
+        config: { policies: [] },
+      },
+      {
+        method: 'GET',
+        path: '/export-content-config',
+        handler: 'configureIndexing.exportContentConfig',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/import-content-config',
+        handler: 'configureIndexing.importContentConfig',
+        config: { policies: [] },
+      },
+    ],
+  };

package/server/routes/index.js

@@ -0,0 +1,13 @@
+const configureIndexingRoutes = require('./configure-indexing');
+const performSearch = require('./perform-search');
+const runLog = require('./run-log');
+const setupInfo = require('./setup-info');
+const performIndexing = require('./perform-indexing');
+
+module.exports = {
+  config: configureIndexingRoutes,
+  search: performSearch,
+  runLog: runLog,
+  setupInfo: setupInfo,
+  performIndexing: performIndexing
+};

package/server/routes/perform-indexing.js

@@ -0,0 +1,24 @@
+module.exports = {
+    // accessible only from admin UI
+    type: 'admin',
+    routes: [
+      {
+        method: 'GET',
+        path: '/reindex',
+        handler: 'performIndexing.rebuildIndex',
+        config: { policies: [] },
+      },
+      {
+        method: 'GET',
+        path: '/collection-reindex/:collectionname',
+        handler: 'performIndexing.indexCollection',
+        config: { policies: [] },
+      },
+      {
+        method: 'GET',
+        path: '/trigger-indexing/',
+        handler: 'performIndexing.triggerIndexingTask',
+        config: { policies: [] },
+      },
+    ],
+  };