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

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: [] },
+      },
+    ],
+  };

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 {};
+  },
+});