@vegan-friendly/strapi-plugin-elasticsearch 0.1.0-alpha.1 → 0.1.0-alpha.2

package/server/bootstrap.js

@@ -1,142 +0,0 @@
-'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

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

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

@@ -1,35 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,66 +0,0 @@
-'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/perform-search.js

@@ -1,31 +0,0 @@
-'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/routes/configure-indexing.js

@@ -1,42 +0,0 @@
-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/perform-indexing.js

@@ -1,24 +0,0 @@
-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: [] },
-      },
-    ],
-  };

package/server/routes/perform-search.js

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,184 +0,0 @@
-'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 {};
-  },
-});