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

package/server/routes/perform-search.js

@@ -0,0 +1,14 @@
+module.exports = {
+    // accessible only from admin UI
+    type: 'content-api',
+    routes: [
+      {
+        method: 'GET',
+        path: '/search',
+        handler: 'performSearch.search',
+        config: { 
+            policies: []
+        },
+      }
+    ],
+  };

package/server/routes/run-log.js

@@ -0,0 +1,12 @@
+module.exports = {
+    // accessible only from admin UI
+    type: 'admin',
+    routes: [
+      {
+        method: 'GET',
+        path: '/indexing-run-log',
+        handler: 'logIndexing.fetchRecentRunsLog',
+        config: { policies: [] },
+      }
+    ],
+  };

package/server/routes/setup-info.js

@@ -0,0 +1,12 @@
+module.exports = {
+    // accessible only from admin UI
+    type: 'admin',
+    routes: [
+      {
+        method: 'GET',
+        path: '/setup-info',
+        handler: 'setupInfo.getElasticsearchInfo',
+        config: { policies: [] },
+      }      
+    ],
+  };

package/server/services/configure-indexing.js

@@ -0,0 +1,184 @@
+'use strict';
+
+const getPluginStore = () => {
+  return strapi.store({
+    environment: '',
+    type: 'plugin',
+    name: 'elasticsearch',
+  });
+}
+
+module.exports = ({ strapi }) => ({
+  async initializeStrapiElasticsearch() {
+    await this.cacheConfig();
+  },
+  async markInitialized() {
+    if (!strapi.elasticsearch)
+      strapi.elasticsearch = {}
+    strapi.elasticsearch.initialized = true;
+  },
+  isInitialized() {
+    return strapi.elasticsearch?.initialized || false
+  },
+  async cacheConfig() {
+    if (!strapi.elasticsearch)
+      strapi.elasticsearch = {}
+    strapi.elasticsearch.collectionsconfig = await this.getCollectionsConfiguredForIndexing();
+    strapi.elasticsearch.collections = await this.getCollectionsConfiguredForIndexing();  
+  },
+  async getCollectionConfig({collectionName}) {
+    const contentConfig = await this.getContentConfig();
+    if (Object.keys(contentConfig).includes(collectionName))
+    {
+      const ob = {}
+      ob[collectionName] = contentConfig[collectionName];
+      return ob;
+    }
+    else
+      return null;
+  },
+  async getCollectionsConfiguredForIndexing() {
+    const contentConfig = await this.getContentConfig();
+    if (contentConfig)
+      return Object.keys(contentConfig).filter((i) => {
+        let hasAtleastOneIndexableAttribute = false;
+        const attribs = Object.keys(contentConfig[i])
+        for (let k=0; k<attribs.length; k++)
+        {
+          if (contentConfig[i][attribs[k]]['index'] === true)
+          {
+            hasAtleastOneIndexableAttribute = true;
+            break;
+          }
+        }
+        return hasAtleastOneIndexableAttribute;
+      })
+    else
+      return [];
+  },
+  async isCollectionConfiguredToBeIndexed({collectionName}) {
+    const collectionsToIndex = await this.getCollectionsConfiguredForIndexing();
+    return collectionsToIndex.includes(collectionName);
+  },
+  async getContentConfig() {
+    const fieldsToExclude = ['createdAt', 'createdBy', 'publishedAt', 'publishedBy', 'updatedAt', 'updatedBy']
+    const pluginStore = getPluginStore();
+    const settings = await pluginStore.get({ key: 'configsettings' });
+    const contentTypes = strapi.contentTypes;
+    const apiContentTypes = Object.keys(contentTypes).filter((c) => c.includes('api::'));
+    const apiContentConfig = {};
+    for (let r = 0; r < apiContentTypes.length; r++)
+    {
+      apiContentConfig[apiContentTypes[r]] = {};
+      const collectionAttributes = contentTypes[apiContentTypes[r]].attributes
+      const listOfAttributes = Object.keys(collectionAttributes).filter(
+        (i) => fieldsToExclude.includes(i) === false
+      );
+      
+      for (let k = 0; k < listOfAttributes.length; k++)
+      {
+        const currentAttribute = listOfAttributes[k];
+        let attributeType = "regular";
+        if (typeof collectionAttributes[currentAttribute]["type"] !== "undefined"
+          && collectionAttributes[currentAttribute]["type"] !== null)
+          {
+            if (collectionAttributes[currentAttribute]["type"] === "component")
+              attributeType = "component"
+            else if (collectionAttributes[currentAttribute]["type"] === "dynamiczone")
+              attributeType = "dynamiczone"
+          }
+        apiContentConfig[apiContentTypes[r]][listOfAttributes[k]] = {index: false,
+            type: attributeType}
+      }
+        
+    }
+    if (settings)
+    {
+      const objSettings = JSON.parse(settings);
+      if (Object.keys(objSettings).includes('contentConfig'))
+      {
+        const collections = Object.keys(apiContentConfig);
+        for (let r=0; r< collections.length; r++)
+        {
+          if (Object.keys(objSettings['contentConfig']).includes(collections[r]))
+          {
+            const attribsForCollection = Object.keys(apiContentConfig[collections[r]])
+            for (let s = 0; s < attribsForCollection.length; s++)
+            {
+              if (!Object.keys(objSettings['contentConfig'][collections[r]]).includes(attribsForCollection[s]))
+              {
+                objSettings['contentConfig'][collections[r]][attribsForCollection[s]] = {index: false, 
+                  type: apiContentConfig[collections[r]][attribsForCollection[s]].type}
+              }
+              else 
+              {
+                if (!Object.keys(objSettings['contentConfig'][collections[r]][attribsForCollection[s]]).includes('type'))
+                  objSettings['contentConfig'][collections[r]][attribsForCollection[s]]['type'] = apiContentConfig[collections[r]][attribsForCollection[s]].type
+              } 
+            }
+          }
+          else
+            objSettings['contentConfig'][collections[r]] = apiContentConfig[collections[r]]
+        }
+        return objSettings['contentConfig'];  
+      }
+      else
+        return apiContentConfig
+    }
+    else
+      return apiContentConfig;
+  },
+  async importContentConfig({config}){
+    const pluginStore = getPluginStore();
+    const settings = await pluginStore.get({ key: 'configsettings' });
+    if (settings)
+    {
+      const objSettings = JSON.parse(settings);
+      objSettings['contentConfig'] = JSON.parse(config)
+      const stringifySettings = JSON.stringify(objSettings);
+      await pluginStore.set({ key: 'configsettings', value : stringifySettings });
+    }
+    else 
+    {
+      const newSettings =  JSON.stringify({'contentConfig' : config})
+      await pluginStore.set({ key: 'configsettings', value : newSettings});
+    }    
+    const updatedSettings = await pluginStore.get({ key: 'configsettings' });
+    await this.cacheConfig();
+    if (updatedSettings && Object.keys(updatedSettings).includes('contentConfig'))
+      return updatedSettings['contentConfig']
+    else
+      return {};
+  },
+  async setContentConfig({collection, config}){
+    const pluginStore = getPluginStore();
+    const settings = await pluginStore.get({ key: 'configsettings' });
+    if (settings)
+    {
+      const objSettings = JSON.parse(settings);
+      if (Object.keys(objSettings).includes('contentConfig'))
+      {
+        const prevConfig = objSettings['contentConfig'];
+        const changedConfigKey = Object.keys(config)[0];
+        const newConfig = prevConfig;
+        newConfig[changedConfigKey] = config[changedConfigKey]
+        objSettings['contentConfig'] = newConfig
+      }
+      else
+        objSettings['contentConfig'] = config;
+      const stringifySettings = JSON.stringify(objSettings);
+      await pluginStore.set({ key: 'configsettings', value : stringifySettings });
+    }
+    else 
+    {
+      const newSettings =  JSON.stringify({'contentConfig' : config})
+      await pluginStore.set({ key: 'configsettings', value : newSettings});
+    }    
+    const updatedSettings = await pluginStore.get({ key: 'configsettings' });
+    await this.cacheConfig();
+    if (updatedSettings && Object.keys(updatedSettings).includes('contentConfig'))
+      return updatedSettings['contentConfig']
+    else
+      return {};
+  },
+});

package/server/services/es-interface.js

@@ -0,0 +1,187 @@
+const { Client } = require('@elastic/elasticsearch')
+const fs = require('fs')
+const path = require('path');
+
+
+
+let client = null;
+
+module.exports = ({ strapi }) => ({
+    async initializeSearchEngine({host, uname, password, cert}){
+        try
+        {
+          client = new Client({
+            node: host,
+            auth: {
+              username: uname,
+              password: password
+            },
+            tls: {
+              ca: cert,
+              rejectUnauthorized: false
+            }
+          });
+        }
+        catch (err)
+        {
+          if (err.message.includes('ECONNREFUSED'))
+          {
+            console.error('strapi-plugin-elasticsearch : Connection to ElasticSearch at ', host, ' refused.')
+            console.error(err);
+          }
+          else
+          {
+            console.error('strapi-plugin-elasticsearch : Error while initializing connection to ElasticSearch.')
+            console.error(err);
+          }
+          throw(err);
+        }
+    },
+    async createIndex(indexName){
+      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,
+          });
+        }    
+      }
+      catch (err)
+      {
+        if (err.message.includes('ECONNREFUSED'))
+        {
+          console.log('strapi-plugin-elasticsearch : Error while creating index - connection to ElasticSearch refused.')
+          console.log(err);
+        }
+        else
+        {
+          console.log('strapi-plugin-elasticsearch : Error while creating index.')
+          console.log(err);
+        }
+      }  
+    },
+    async deleteIndex(indexName){
+      try{
+        await client.indices.delete({
+          index: indexName
+        });
+      }
+      catch(err)
+      {
+        if (err.message.includes('ECONNREFUSED'))
+        {
+          console.log('strapi-plugin-elasticsearch : Connection to ElasticSearch refused.')
+          console.log(err);
+        }
+        else
+        {
+          console.log('strapi-plugin-elasticsearch : Error while deleting index to ElasticSearch.')
+          console.log(err);
+        }    
+      }
+    },
+    async attachAliasToIndex(indexName) {
+      try{
+          const pluginConfig = await strapi.config.get('plugin.elasticsearch');
+          const aliasName = 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.');
+            await client.indices.deleteAlias({index: '*', name: aliasName});
+          }
+          const indexExists = await client.indices.exists({index: indexName});
+          if (!indexExists)
+            await this.createIndex(indexName);
+          console.log('strapi-plugin-elasticsearch : Attaching the alias ', aliasName, ' to index : ', indexName);
+          await client.indices.putAlias({index: indexName, name: aliasName})
+      }
+      catch(err)
+      {
+        if (err.message.includes('ECONNREFUSED'))
+        {
+          console.log('strapi-plugin-elasticsearch : Attaching alias to the index - Connection to ElasticSearch refused.')
+          console.log(err);
+        }
+        else
+        {
+          console.log('strapi-plugin-elasticsearch : Attaching alias to the index - Error while setting up alias within ElasticSearch.')
+          console.log(err);
+        }    
+      }
+    },
+    async checkESConnection() {
+      if (!client)
+        return false;
+      try {
+        await client.ping();
+        return true;
+      }
+      catch(error)
+      {
+        console.error('strapi-plugin-elasticsearch : Could not connect to Elastic search.')
+        console.error(error);
+        return false;
+      }
+      
+    },
+    async indexDataToSpecificIndex({itemId, itemData}, iName){
+      try
+      {
+        await client.index({
+          index: iName,
+          id: itemId,
+          document: itemData
+        })
+        await client.indices.refresh({ index: iName });
+      }
+      catch(err){
+        console.log('strapi-plugin-elasticsearch : Error encountered while indexing data to ElasticSearch.')
+        console.log(err);
+        throw err;
+      }
+    },
+    async indexData({itemId, itemData}) {
+        const pluginConfig = await strapi.config.get('plugin.elasticsearch');
+        return await this.indexDataToSpecificIndex({itemId, itemData}, pluginConfig.indexAliasName);
+    },
+    async removeItemFromIndex({itemId}) {
+        const pluginConfig = await strapi.config.get('plugin.elasticsearch');      
+        try
+        {
+          await client.delete({
+            index: pluginConfig.indexAliasName,
+            id: itemId
+          });
+          await client.indices.refresh({ index: pluginConfig.indexAliasName });  
+        }
+        catch(err){
+          if (err.meta.statusCode === 404)
+            console.error('strapi-plugin-elasticsearch : The entry to be removed from the index already does not exist.')
+          else
+          {
+            console.error('strapi-plugin-elasticsearch : Error encountered while removing indexed data from ElasticSearch.')
+            throw err;
+          }
+        }    
+    },
+    async searchData(searchQuery){
+      try
+      {
+          const pluginConfig = await strapi.config.get('plugin.elasticsearch');
+          const result= await client.search({
+            index: pluginConfig.indexAliasName,
+            ...searchQuery
+          });
+          return result;
+      }
+      catch(err)
+      {
+        console.log('Search : elasticClient.searchData : Error encountered while making a search request to ElasticSearch.')
+        throw err;
+      }
+    }    
+});