@openstax/ts-utils 1.34.0 → 1.34.1

package/dist/esm/services/searchProvider/openSearch.js

@@ -0,0 +1,150 @@
+// cspell:ignore opensearch, Sigv
+import { defaultProvider } from '@aws-sdk/credential-provider-node';
+import { Client } from '@opensearch-project/opensearch';
+import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
+import { resolveConfigValue } from '../../config';
+import { ifDefined, isDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+const mapFilter = (filter) => {
+    if ('key' in filter && 'value' in filter) {
+        const { key } = filter;
+        const values = filter.value instanceof Array ? filter.value : [filter.value];
+        return { terms: { [key]: values } };
+    }
+    else {
+        return filter;
+    }
+};
+export const openSearchService = (initializer = {}) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
+    const client = once(async () => new Client({
+        ...AwsSigv4Signer({
+            getCredentials: () => defaultProvider()(),
+            region: await resolveConfigValue(config.region),
+            service: 'es',
+        }),
+        maxRetries: 4, // default is 3
+        requestTimeout: 5000, // default is 30000
+        pingTimeout: 2000, // default is 30000
+        node: await resolveConfigValue(config.node),
+    }));
+    return (indexConfig) => {
+        const pageSize = indexConfig.pageSize || 10;
+        const deleteIndexIfExists = async () => {
+            const { indices } = await client();
+            const index = indexConfig.name;
+            const { body } = await indices.exists({ index });
+            if (body) {
+                await indices.delete({ index });
+            }
+        };
+        const ensureIndexCreated = async () => {
+            const { indices } = await client();
+            const index = indexConfig.name;
+            const { body } = await indices.exists({ index });
+            if (!body) {
+                await indices.create({
+                    index,
+                    body: {
+                        mappings: {
+                            dynamic: false,
+                            properties: indexConfig.mappings
+                        }
+                    }
+                });
+            }
+        };
+        const index = async (params) => {
+            const openSearchClient = await client();
+            await openSearchClient.index({
+                index: indexConfig.name,
+                body: params.body,
+                id: params.id,
+                refresh: true
+            }, {
+                requestTimeout: 10000,
+                maxRetries: 1,
+            });
+        };
+        const bulkIndex = async (items) => {
+            const openSearchClient = await client();
+            await openSearchClient.bulk({
+                index: indexConfig.name,
+                body: items.flatMap((item) => [
+                    { index: { _id: item.id } },
+                    item.body
+                ]),
+                refresh: true
+            }, {
+                requestTimeout: 10000,
+                maxRetries: 1,
+            });
+        };
+        const search = async (options) => {
+            var _a;
+            const body = {
+                query: { bool: {} },
+                track_total_hits: true,
+                size: pageSize
+            };
+            if (options.query) {
+                body.query.bool.must = [{
+                        multi_match: {
+                            fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
+                            query: options.query
+                        }
+                    }];
+            }
+            const { must_not, should, must, filter } = options;
+            if (filter && filter.length > 0) {
+                body.query.bool.filter = filter.map(mapFilter);
+            }
+            if (must && must.length > 0) {
+                (_a = body.query.bool).must || (_a.must = []);
+                body.query.bool.must = body.query.bool.must.concat(must.map(mapFilter));
+            }
+            if (must_not && must_not.length > 0) {
+                body.query.bool.must_not = must_not.map(mapFilter);
+            }
+            if (should && should.length > 0) {
+                body.query.bool.should = should.map(mapFilter);
+                body.query.bool.minimum_should_match = 1;
+            }
+            if (options.sort && options.sort.length > 0) {
+                body.sort = options.sort.map(sort => ({
+                    [sort.key]: { order: sort.order }
+                }));
+            }
+            if (options.page) {
+                body.from = (options.page - 1) * pageSize;
+            }
+            const response = await (await client()).search({
+                body,
+                index: indexConfig.name
+            });
+            if (response.statusCode !== 200) {
+                throw new Error(`Unexpected status code: ${response.statusCode} from OpenSearch`);
+            }
+            const hits = response.body.hits;
+            const items = hits.hits.map((hit) => hit._source).filter(isDefined);
+            const currentPage = options.page || 1;
+            const { total } = hits;
+            const totalItems = typeof total === 'number' ? total : total.value;
+            const totalPages = Math.ceil(totalItems / pageSize) || 1;
+            return { items, pageSize, currentPage, totalItems, totalPages };
+        };
+        const updateMappings = async () => {
+            const { indices } = await client();
+            await indices.putMapping({
+                index: indexConfig.name,
+                body: {
+                    properties: indexConfig.mappings
+                }
+            }, {
+                requestTimeout: 10000,
+                maxRetries: 1,
+            });
+        };
+        return { ensureIndexCreated, deleteIndexIfExists, index, bulkIndex, search, updateMappings };
+    };
+};