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

package/dist/server/bootstrap.js

@@ -0,0 +1,125 @@
+'use strict';
+console.log('strapi-plugin-elasticsearch : 00 Initializing strapi-plugin-elasticsearch plugin.');
+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 {
+        console.log('strapi-plugin-elasticsearch 1: Initializing strapi-plugin-elasticsearch plugin.');
+        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/dist/server/config/index.js

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

package/dist/server/content-types/index.d.ts

@@ -0,0 +1,2 @@
+declare const task: any;
+declare const indexingLog: any;

package/{server → dist/server}/content-types/index.js

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

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

@@ -0,0 +1,35 @@
+"use strict";
+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/dist/server/content-types/name-prefix.js

@@ -0,0 +1 @@
+"use strict";

package/dist/server/content-types/tasks.js

@@ -0,0 +1,52 @@
+"use strict";
+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/dist/server/controllers/configure-indexing.js

@@ -0,0 +1,58 @@
+'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/dist/server/controllers/index.d.ts

@@ -0,0 +1,5 @@
+declare const configureIndexing: any;
+declare const performSearch: any;
+declare const logIndexing: any;
+declare const setupInfo: any;
+declare const performIndexing: any;

package/{server → dist/server}/controllers/index.js

@@ -1,15 +1,13 @@
-'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
-};
+'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 → dist/server}/controllers/log-indexing.js

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

package/{server → dist/server}/controllers/perform-indexing.js

@@ -1,28 +1,22 @@
-'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
-    };     
-}
+'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/dist/server/controllers/perform-search.d.ts

@@ -0,0 +1 @@
+declare const qs: any;

package/dist/server/controllers/perform-search.js

@@ -0,0 +1,29 @@
+'use strict';
+const qs = require('qs');
+module.exports = {
+    search: async (ctx) => {
+        var _a;
+        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 ((_a = resp === null || resp === void 0 ? void 0 : resp.hits) === null || _a === void 0 ? void 0 : _a.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 → dist/server}/controllers/setup-info.js

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

package/{server → dist/server}/destroy.js

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

package/dist/server/index.d.ts

@@ -0,0 +1,10 @@
+declare const register: any;
+declare const bootstrap: any;
+declare const destroy: any;
+declare const config: any;
+declare const contentTypes: any;
+declare const controllers: any;
+declare const routes: any;
+declare const middlewares: any;
+declare const policies: any;
+declare const services: any;

package/{server → dist/server}/index.js

@@ -1,25 +1,23 @@
-'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,
-};
+'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 → dist/server}/middlewares/index.js

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

package/{server → dist/server}/policies/index.js

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

package/{server → dist/server}/register.js

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

package/dist/server/routes/configure-indexing.js

@@ -0,0 +1,43 @@
+"use strict";
+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/dist/server/routes/index.d.ts

@@ -0,0 +1,5 @@
+declare const configureIndexingRoutes: any;
+declare const performSearch: any;
+declare const runLog: any;
+declare const setupInfo: any;
+declare const performIndexing: any;