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

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

@@ -0,0 +1,46 @@
+declare const _default: {
+    kind: string;
+    collectionName: string;
+    info: {
+        singularName: string;
+        pluralName: string;
+        displayName: string;
+        description: string;
+    };
+    options: {
+        draftAndPublish: boolean;
+    };
+    pluginOptions: {
+        'content-manager': {
+            visible: boolean;
+        };
+        'content-type-builder': {
+            visible: boolean;
+        };
+    };
+    attributes: {
+        collection_name: {
+            type: string;
+            required: boolean;
+        };
+        item_id: {
+            type: string;
+        };
+        indexing_status: {
+            type: string;
+            enum: string[];
+            required: boolean;
+            default: string;
+        };
+        full_site_indexing: {
+            type: string;
+        };
+        indexing_type: {
+            type: string;
+            enum: string[];
+            default: string;
+            required: boolean;
+        };
+    };
+};
+export default _default;

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

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

package/dist/server/controllers/configure-indexing.d.ts

@@ -0,0 +1,11 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    getContentConfig: (ctx: any) => Promise<any>;
+    setContentConfig: (ctx: any) => Promise<any>;
+    getCollectionConfig: (ctx: any) => Promise<any>;
+    saveCollectionConfig: (ctx: any) => Promise<any>;
+    exportContentConfig: (ctx: any) => Promise<any>;
+    importContentConfig: (ctx: any) => Promise<any>;
+};
+export default _default;

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

@@ -1,5 +1,6 @@
 'use strict';
-module.exports = ({ strapi }) => {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => {
     const configureIndexingService = strapi.plugins['elasticsearch'].services.configureIndexing;
     const getContentConfig = async (ctx) => {
         return configureIndexingService.getContentConfig();
@@ -53,6 +54,6 @@ module.exports = ({ strapi }) => {
         getCollectionConfig,
         saveCollectionConfig,
         exportContentConfig,
-        importContentConfig
+        importContentConfig,
     };
 };

package/dist/server/controllers/index.d.ts

@@ -1,5 +1,33 @@
-declare const configureIndexing: any;
-declare const performSearch: any;
-declare const logIndexing: any;
-declare const setupInfo: any;
-declare const performIndexing: any;
+declare const _default: {
+    configureIndexing: ({ strapi }: {
+        strapi: any;
+    }) => {
+        getContentConfig: (ctx: any) => Promise<any>;
+        setContentConfig: (ctx: any) => Promise<any>;
+        getCollectionConfig: (ctx: any) => Promise<any>;
+        saveCollectionConfig: (ctx: any) => Promise<any>;
+        exportContentConfig: (ctx: any) => Promise<any>;
+        importContentConfig: (ctx: any) => Promise<any>;
+    };
+    performSearch: {
+        search: (ctx: any) => Promise<void>;
+    };
+    logIndexing: ({ strapi }: {
+        strapi: any;
+    }) => {
+        fetchRecentRunsLog: (ctx: any) => Promise<any>;
+    };
+    setupInfo: ({ strapi }: {
+        strapi: any;
+    }) => {
+        getElasticsearchInfo: (ctx: any) => Promise<any>;
+    };
+    performIndexing: ({ strapi }: {
+        strapi: any;
+    }) => {
+        rebuildIndex: (ctx: any) => Promise<any>;
+        indexCollection: (ctx: any) => Promise<any>;
+        triggerIndexingTask: (ctx: any) => Promise<any>;
+    };
+};
+export default _default;

package/dist/server/controllers/index.js

@@ -1,13 +1,17 @@
 '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
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const configure_indexing_1 = __importDefault(require("./configure-indexing"));
+const perform_search_1 = __importDefault(require("./perform-search"));
+const log_indexing_1 = __importDefault(require("./log-indexing"));
+const setup_info_1 = __importDefault(require("./setup-info"));
+const perform_indexing_1 = __importDefault(require("./perform-indexing"));
+exports.default = {
+    configureIndexing: configure_indexing_1.default,
+    performSearch: perform_search_1.default,
+    logIndexing: log_indexing_1.default,
+    setupInfo: setup_info_1.default,
+    performIndexing: perform_indexing_1.default,
 };

package/dist/server/controllers/log-indexing.d.ts

@@ -0,0 +1,6 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    fetchRecentRunsLog: (ctx: any) => Promise<any>;
+};
+export default _default;

package/dist/server/controllers/log-indexing.js

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

package/dist/server/controllers/perform-indexing.d.ts

@@ -0,0 +1,8 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    rebuildIndex: (ctx: any) => Promise<any>;
+    indexCollection: (ctx: any) => Promise<any>;
+    triggerIndexingTask: (ctx: any) => Promise<any>;
+};
+export default _default;

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

@@ -1,5 +1,6 @@
 'use strict';
-module.exports = ({ strapi }) => {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => {
     const indexer = strapi.plugins['elasticsearch'].services.indexer;
     const scheduleIndexingService = strapi.plugins['elasticsearch'].services.scheduleIndexing;
     const rebuildIndex = async (ctx) => {
@@ -17,6 +18,6 @@ module.exports = ({ strapi }) => {
     return {
         rebuildIndex,
         indexCollection,
-        triggerIndexingTask
+        triggerIndexingTask,
     };
 };

package/dist/server/controllers/perform-search.d.ts

@@ -1 +1,4 @@
-declare const qs: any;
+declare const _default: {
+    search: (ctx: any) => Promise<void>;
+};
+export default _default;

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

@@ -1,15 +1,18 @@
 'use strict';
-const qs = require('qs');
-module.exports = {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qs_1 = __importDefault(require("qs"));
+exports.default = {
     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 query = qs_1.default.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);
+                if (resp?.hits?.hits) {
+                    const filteredData = resp.hits.hits.filter((dt) => dt._source !== null);
                     const filteredMatches = filteredData.map((dt) => dt['_source']);
                     ctx.body = filteredMatches;
                 }
@@ -21,9 +24,9 @@ module.exports = {
         }
         catch (err) {
             ctx.response.status = 500;
-            ctx.body = "An error was encountered while processing the search request.";
+            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/dist/server/controllers/setup-info.d.ts

@@ -0,0 +1,6 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => {
+    getElasticsearchInfo: (ctx: any) => Promise<any>;
+};
+export default _default;

package/dist/server/controllers/setup-info.js

@@ -1,5 +1,6 @@
 'use strict';
-module.exports = ({ strapi }) => {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => {
     const helperService = strapi.plugins['elasticsearch'].services.helper;
     const getElasticsearchInfo = async (ctx) => {
         return helperService.getElasticsearchInfo();

package/dist/server/destroy.d.ts

@@ -0,0 +1,4 @@
+declare const _default: ({ strapi }: {
+    strapi: any;
+}) => void;
+export default _default;

package/dist/server/destroy.js

@@ -1,4 +1,5 @@
 'use strict';
-module.exports = ({ strapi }) => {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ({ strapi }) => {
     // destroy phase
 };

package/dist/server/index.d.ts

@@ -1,10 +1,312 @@
-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;
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: any;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: any;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: any;
+    }) => void;
+    config: {
+        default: {};
+        validator(): void;
+    };
+    controllers: {
+        configureIndexing: ({ strapi }: {
+            strapi: any;
+        }) => {
+            getContentConfig: (ctx: any) => Promise<any>;
+            setContentConfig: (ctx: any) => Promise<any>;
+            getCollectionConfig: (ctx: any) => Promise<any>;
+            saveCollectionConfig: (ctx: any) => Promise<any>;
+            exportContentConfig: (ctx: any) => Promise<any>;
+            importContentConfig: (ctx: any) => Promise<any>;
+        };
+        performSearch: {
+            search: (ctx: any) => Promise<void>;
+        };
+        logIndexing: ({ strapi }: {
+            strapi: any;
+        }) => {
+            fetchRecentRunsLog: (ctx: any) => Promise<any>;
+        };
+        setupInfo: ({ strapi }: {
+            strapi: any;
+        }) => {
+            getElasticsearchInfo: (ctx: any) => Promise<any>;
+        };
+        performIndexing: ({ strapi }: {
+            strapi: any;
+        }) => {
+            rebuildIndex: (ctx: any) => Promise<any>;
+            indexCollection: (ctx: any) => Promise<any>;
+            triggerIndexingTask: (ctx: any) => Promise<any>;
+        };
+    };
+    routes: {
+        config: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+        search: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+        runLog: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+        setupInfo: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+        performIndexing: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+    };
+    services: {
+        configureIndexing: ({ strapi }: {
+            strapi: any;
+        }) => {
+            initializeStrapiElasticsearch(): Promise<void>;
+            markInitialized(): Promise<void>;
+            isInitialized(): any;
+            cacheConfig(): Promise<void>;
+            getCollectionConfig({ collectionName }: {
+                collectionName: any;
+            }): Promise<{} | null>;
+            getCollectionsConfiguredForIndexing(): Promise<string[]>;
+            isCollectionConfiguredToBeIndexed({ collectionName }: {
+                collectionName: any;
+            }): Promise<boolean>;
+            getContentConfig(): Promise<any>;
+            importContentConfig({ config }: {
+                config: any;
+            }): Promise<any>;
+            setContentConfig({ collection, config }: {
+                collection: any;
+                config: any;
+            }): Promise<any>;
+        };
+        scheduleIndexing: ({ strapi }: {
+            strapi: any;
+        }) => {
+            addFullSiteIndexingTask(): Promise<any>;
+            addCollectionToIndex({ collectionUid }: {
+                collectionUid: any;
+            }): Promise<any>;
+            addItemToIndex({ collectionUid, recordId }: {
+                collectionUid: any;
+                recordId: any;
+            }): Promise<any>;
+            removeItemFromIndex({ collectionUid, recordId }: {
+                collectionUid: any;
+                recordId: any;
+            }): Promise<void>;
+            getItemsPendingToBeIndexed(): Promise<any>;
+            markIndexingTaskComplete(recId: any): Promise<void>;
+        };
+        esInterface: ({ strapi }: {
+            strapi: any;
+        }) => {
+            initializeSearchEngine({ host, uname, password, cert }: {
+                host: any;
+                uname: any;
+                password: any;
+                cert: any;
+            }): Promise<void>;
+            createIndex(indexName: any): Promise<void>;
+            deleteIndex(indexName: any): Promise<void>;
+            attachAliasToIndex(indexName: any): Promise<void>;
+            checkESConnection(): Promise<boolean>;
+            indexDataToSpecificIndex({ itemId, itemData }: {
+                itemId: any;
+                itemData: any;
+            }, iName: any): Promise<void>;
+            indexData({ itemId, itemData }: {
+                itemId: any;
+                itemData: any;
+            }): Promise<void>;
+            removeItemFromIndex({ itemId }: {
+                itemId: any;
+            }): Promise<void>;
+            searchData(searchQuery: any): Promise<any>;
+        };
+        indexer: ({ strapi }: {
+            strapi: any;
+        }) => {
+            rebuildIndex(): Promise<boolean | undefined>;
+            indexCollection(collectionName: any, indexName?: null): Promise<boolean>;
+            indexPendingData(): Promise<boolean>;
+        };
+        logIndexing: ({ strapi }: {
+            strapi: any;
+        }) => {
+            recordIndexingPass(message: any): Promise<void>;
+            recordIndexingFail(message: any): Promise<void>;
+            fetchIndexingLogs(count?: number): Promise<any>;
+        };
+        helper: ({ strapi }: {
+            strapi: any;
+        }) => {
+            getElasticsearchInfo(): Promise<{
+                indexingCronSchedule: any;
+                elasticHost: any;
+                elasticUserName: any;
+                elasticCertificate: any;
+                elasticIndexAlias: any;
+                connected: any;
+                initialized: any;
+            }>;
+            isCollectionDraftPublish({ collectionName }: {
+                collectionName: any;
+            }): boolean;
+            getPopulateAttribute({ collectionName }: {
+                collectionName: any;
+            }): true | {
+                populate: never;
+            } | undefined;
+            getIndexItemId({ collectionName, itemId }: {
+                collectionName: any;
+                itemId: any;
+            }): string;
+            getCurrentIndexName(): Promise<string>;
+            getIncrementedIndexName(): Promise<string>;
+            storeCurrentIndexName(indexName: any): Promise<void>;
+            modifySubfieldsConfigForExtractor(collectionConfig: any): any;
+            extractDataToIndex({ collectionName, data, collectionConfig }: {
+                collectionName: any;
+                data: any;
+                collectionConfig: any;
+            }): {};
+        };
+        transformContent: {
+            transform({ content, from }: {
+                content: any;
+                from: any;
+            }): any;
+        };
+    };
+    contentTypes: {
+        task: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    collection_name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    item_id: {
+                        type: string;
+                    };
+                    indexing_status: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                        default: string;
+                    };
+                    full_site_indexing: {
+                        type: string;
+                    };
+                    indexing_type: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        required: boolean;
+                    };
+                };
+            };
+        };
+        'indexing-log': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    status: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                    };
+                    details: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    policies: {};
+    middlewares: {};
+};
+export default _default;