@vendure/elasticsearch-plugin 1.2.2 → 1.3.0

package/lib/src/{indexer.controller.js → indexing/indexer.controller.js}

@@ -11,14 +11,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var ElasticsearchIndexerController_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElasticsearchIndexerController = exports.variantRelations = exports.productRelations = void 0;
+exports.ElasticsearchIndexerController = exports.defaultVariantRelations = exports.defaultProductRelations = void 0;
 const common_1 = require("@nestjs/common");
 const unique_1 = require("@vendure/common/lib/unique");
 const core_1 = require("@vendure/core");
-const constants_1 = require("./constants");
+const constants_1 = require("../constants");
 const indexing_utils_1 = require("./indexing-utils");
-exports.productRelations = [
+exports.defaultProductRelations = [
     'variants',
     'featuredAsset',
     'facetValues',
@@ -26,7 +27,7 @@ exports.productRelations = [
     'channels',
     'channels.defaultTaxZone',
 ];
-exports.variantRelations = [
+exports.defaultVariantRelations = [
     'featuredAsset',
     'facetValues',
     'facetValues.facet',
@@ -35,16 +36,20 @@ exports.variantRelations = [
     'channels',
     'channels.defaultTaxZone',
 ];
-let ElasticsearchIndexerController = class ElasticsearchIndexerController {
-    constructor(connection, options, productVariantService, configService) {
+let ElasticsearchIndexerController = ElasticsearchIndexerController_1 = class ElasticsearchIndexerController {
+    constructor(connection, options, productPriceApplicator, configService, productVariantService, requestContextCache) {
         this.connection = connection;
         this.options = options;
-        this.productVariantService = productVariantService;
+        this.productPriceApplicator = productPriceApplicator;
         this.configService = configService;
+        this.productVariantService = productVariantService;
+        this.requestContextCache = requestContextCache;
         this.asyncQueue = new core_1.AsyncQueue('elasticsearch-indexer', 5);
     }
     onModuleInit() {
         this.client = indexing_utils_1.getClient(this.options);
+        this.productRelations = this.getReindexRelationsRelations(exports.defaultProductRelations, this.options.hydrateProductRelations);
+        this.variantRelations = this.getReindexRelationsRelations(exports.defaultVariantRelations, this.options.hydrateProductVariantRelations);
     }
     onModuleDestroy() {
         return this.client.close();
@@ -137,27 +142,17 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                 const timeStart = Date.now();
                 const operations = [];
                 const reindexTempName = new Date().getTime();
-                const productIndexName = this.options.indexPrefix + constants_1.PRODUCT_INDEX_NAME;
                 const variantIndexName = this.options.indexPrefix + constants_1.VARIANT_INDEX_NAME;
-                const reindexProductAliasName = productIndexName + `-reindex-${reindexTempName}`;
                 const reindexVariantAliasName = variantIndexName + `-reindex-${reindexTempName}`;
                 try {
-                    await indexing_utils_1.createIndices(this.client, this.options.indexPrefix, this.options.indexSettings, this.options.indexMappingProperties, this.configService.entityIdStrategy.primaryKeyType, true, `-reindex-${reindexTempName}`);
-                    const reindexProductIndexName = await indexing_utils_1.getIndexNameByAlias(this.client, reindexProductAliasName);
+                    await indexing_utils_1.createIndices(this.client, this.options.indexPrefix, this.options.indexSettings, this.options.indexMappingProperties, true, `-reindex-${reindexTempName}`);
                     const reindexVariantIndexName = await indexing_utils_1.getIndexNameByAlias(this.client, reindexVariantAliasName);
-                    const originalProductAliasExist = await this.client.indices.existsAlias({
-                        name: productIndexName,
-                    });
                     const originalVariantAliasExist = await this.client.indices.existsAlias({
                         name: variantIndexName,
                     });
-                    const originalProductIndexExist = await this.client.indices.exists({
-                        index: productIndexName,
-                    });
                     const originalVariantIndexExist = await this.client.indices.exists({
                         index: variantIndexName,
                     });
-                    const originalProductIndexName = await indexing_utils_1.getIndexNameByAlias(this.client, productIndexName);
                     const originalVariantIndexName = await indexing_utils_1.getIndexNameByAlias(this.client, variantIndexName);
                     if (originalVariantAliasExist.body || originalVariantIndexExist.body) {
                         await this.client.reindex({
@@ -172,19 +167,6 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                             },
                         });
                     }
-                    if (originalProductAliasExist.body || originalProductIndexExist.body) {
-                        await this.client.reindex({
-                            refresh: true,
-                            body: {
-                                source: {
-                                    index: productIndexName,
-                                },
-                                dest: {
-                                    index: reindexProductAliasName,
-                                },
-                            },
-                        });
-                    }
                     const actions = [
                         {
                             remove: {
@@ -192,38 +174,13 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                                 alias: reindexVariantAliasName,
                             },
                         },
-                        {
-                            remove: {
-                                index: reindexProductIndexName,
-                                alias: reindexProductAliasName,
-                            },
-                        },
                         {
                             add: {
                                 index: reindexVariantIndexName,
                                 alias: variantIndexName,
                             },
                         },
-                        {
-                            add: {
-                                index: reindexProductIndexName,
-                                alias: productIndexName,
-                            },
-                        },
                     ];
-                    if (originalProductAliasExist.body) {
-                        actions.push({
-                            remove: {
-                                index: originalProductIndexName,
-                                alias: productIndexName,
-                            },
-                        });
-                    }
-                    else if (originalProductIndexExist.body) {
-                        await this.client.indices.delete({
-                            index: [productIndexName],
-                        });
-                    }
                     if (originalVariantAliasExist.body) {
                         actions.push({
                             remove: {
@@ -242,11 +199,6 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                             actions,
                         },
                     });
-                    if (originalProductAliasExist.body) {
-                        await this.client.indices.delete({
-                            index: [originalProductIndexName],
-                        });
-                    }
                     if (originalVariantAliasExist.body) {
                         await this.client.indices.delete({
                             index: [originalVariantIndexName],
@@ -270,18 +222,6 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                             index: [reindexVariantIndexName],
                         });
                     }
-                    const reindexProductAliasExist = await this.client.indices.existsAlias({
-                        name: reindexProductAliasName,
-                    });
-                    if (reindexProductAliasExist.body) {
-                        const reindexProductAliasResult = await this.client.indices.getAlias({
-                            name: reindexProductAliasName,
-                        });
-                        const reindexProductIndexName = Object.keys(reindexProductAliasResult.body)[0];
-                        await this.client.indices.delete({
-                            index: [reindexProductIndexName],
-                        });
-                    }
                 }
                 const deletedProductIds = await this.connection
                     .getRepository(core_1.Product)
@@ -321,26 +261,18 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
         });
     }
     async updateAsset(data) {
-        const result1 = await this.updateAssetFocalPointForIndex(constants_1.PRODUCT_INDEX_NAME, data.asset);
-        const result2 = await this.updateAssetFocalPointForIndex(constants_1.VARIANT_INDEX_NAME, data.asset);
+        const result = await this.updateAssetFocalPointForIndex(constants_1.VARIANT_INDEX_NAME, data.asset);
         await this.client.indices.refresh({
-            index: [
-                this.options.indexPrefix + constants_1.PRODUCT_INDEX_NAME,
-                this.options.indexPrefix + constants_1.VARIANT_INDEX_NAME,
-            ],
+            index: [this.options.indexPrefix + constants_1.VARIANT_INDEX_NAME],
         });
-        return result1 && result2;
+        return result;
     }
     async deleteAsset(data) {
-        const result1 = await this.deleteAssetForIndex(constants_1.PRODUCT_INDEX_NAME, data.asset);
-        const result2 = await this.deleteAssetForIndex(constants_1.VARIANT_INDEX_NAME, data.asset);
+        const result = await this.deleteAssetForIndex(constants_1.VARIANT_INDEX_NAME, data.asset);
         await this.client.indices.refresh({
-            index: [
-                this.options.indexPrefix + constants_1.PRODUCT_INDEX_NAME,
-                this.options.indexPrefix + constants_1.VARIANT_INDEX_NAME,
-            ],
+            index: [this.options.indexPrefix + constants_1.VARIANT_INDEX_NAME],
         });
-        return result1 && result2;
+        return result;
     }
     async updateAssetFocalPointForIndex(indexName, asset) {
         const focalPoint = asset.focalPoint || null;
@@ -396,15 +328,22 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
         const operations = [];
         for (const productId of productIds) {
             operations.push(...(await this.deleteProductOperations(productId)));
-            const product = await this.connection.getRepository(core_1.Product).findOne(productId, {
-                relations: exports.productRelations,
-                where: {
-                    deletedAt: null,
-                },
-            });
+            let product;
+            try {
+                product = await this.connection.getRepository(core_1.Product).findOne(productId, {
+                    relations: this.productRelations,
+                    where: {
+                        deletedAt: null,
+                    },
+                });
+            }
+            catch (e) {
+                core_1.Logger.error(e.message, constants_1.loggerCtx, e.stack);
+                throw e;
+            }
             if (product) {
                 const updatedProductVariants = await this.connection.getRepository(core_1.ProductVariant).findByIds(product.variants.map(v => v.id), {
-                    relations: exports.variantRelations,
+                    relations: this.variantRelations,
                     where: {
                         deletedAt: null,
                     },
@@ -412,15 +351,18 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                         id: 'ASC',
                     },
                 });
+                // tslint:disable-next-line:no-non-null-assertion
                 updatedProductVariants.forEach(variant => (variant.product = product));
                 if (!product.enabled) {
                     updatedProductVariants.forEach(v => (v.enabled = false));
                 }
                 core_1.Logger.verbose(`Updating Product (${productId})`, constants_1.loggerCtx);
-                if (updatedProductVariants.length) {
-                    operations.push(...(await this.updateVariantsOperations(updatedProductVariants)));
+                const languageVariants = [];
+                languageVariants.push(...product.translations.map(t => t.languageCode));
+                for (const variant of product.variants) {
+                    languageVariants.push(...variant.translations.map(t => t.languageCode));
                 }
-                const languageVariants = product.translations.map(t => t.languageCode);
+                const uniqueLanguageVariants = unique_1.unique(languageVariants);
                 for (const channel of product.channels) {
                     const channelCtx = new core_1.RequestContext({
                         channel,
@@ -431,65 +373,73 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
                     });
                     const variantsInChannel = updatedProductVariants.filter(v => v.channels.map(c => c.id).includes(channelCtx.channelId));
                     for (const variant of variantsInChannel) {
-                        await this.productVariantService.applyChannelPriceAndTax(variant, channelCtx);
+                        await this.productPriceApplicator.applyChannelPriceAndTax(variant, channelCtx);
                     }
-                    for (const languageCode of languageVariants) {
-                        operations.push({
-                            index: constants_1.PRODUCT_INDEX_NAME,
-                            operation: {
-                                update: {
-                                    _id: this.getId(product.id, channelCtx.channelId, languageCode),
+                    for (const languageCode of uniqueLanguageVariants) {
+                        if (variantsInChannel.length) {
+                            for (const variant of variantsInChannel) {
+                                operations.push({
+                                    index: constants_1.VARIANT_INDEX_NAME,
+                                    operation: {
+                                        update: {
+                                            _id: ElasticsearchIndexerController_1.getId(variant.id, channelCtx.channelId, languageCode),
+                                        },
+                                    },
+                                }, {
+                                    index: constants_1.VARIANT_INDEX_NAME,
+                                    operation: {
+                                        doc: await this.createVariantIndexItem(variant, variantsInChannel, channelCtx, languageCode),
+                                        doc_as_upsert: true,
+                                    },
+                                });
+                            }
+                        }
+                        else {
+                            operations.push({
+                                index: constants_1.VARIANT_INDEX_NAME,
+                                operation: {
+                                    update: {
+                                        _id: ElasticsearchIndexerController_1.getId(-product.id, channelCtx.channelId, languageCode),
+                                    },
                                 },
-                            },
-                        }, {
-                            index: constants_1.PRODUCT_INDEX_NAME,
-                            operation: {
-                                doc: variantsInChannel.length
-                                    ? this.createProductIndexItem(variantsInChannel, channelCtx.channelId, languageCode)
-                                    : this.createSyntheticProductIndexItem(channelCtx, product, languageCode),
-                                doc_as_upsert: true,
-                            },
-                        });
+                            }, {
+                                index: constants_1.VARIANT_INDEX_NAME,
+                                operation: {
+                                    doc: this.createSyntheticProductIndexItem(product, channelCtx, languageCode),
+                                    doc_as_upsert: true,
+                                },
+                            });
+                        }
                     }
                 }
             }
         }
         return operations;
     }
-    async updateVariantsOperations(productVariants) {
-        if (productVariants.length === 0) {
-            return [];
-        }
-        const operations = [];
-        for (const variant of productVariants) {
-            const languageVariants = variant.translations.map(t => t.languageCode);
-            for (const channel of variant.channels) {
-                const channelCtx = new core_1.RequestContext({
-                    channel,
-                    apiType: 'admin',
-                    authorizedAsOwnerOnly: false,
-                    isAuthorized: true,
-                    session: {},
-                });
-                await this.productVariantService.applyChannelPriceAndTax(variant, channelCtx);
-                for (const languageCode of languageVariants) {
-                    operations.push({
-                        index: constants_1.VARIANT_INDEX_NAME,
-                        operation: {
-                            update: { _id: this.getId(variant.id, channelCtx.channelId, languageCode) },
-                        },
-                    }, {
-                        index: constants_1.VARIANT_INDEX_NAME,
-                        operation: {
-                            doc: this.createVariantIndexItem(variant, channelCtx.channelId, languageCode),
-                            doc_as_upsert: true,
-                        },
-                    });
+    /**
+     * Takes the default relations, and combines them with any extra relations specified in the
+     * `hydrateProductRelations` and `hydrateProductVariantRelations`. This method also ensures
+     * that the relation values are unique and that paths are fully expanded.
+     *
+     * This means that if a `hydrateProductRelations` value of `['assets.asset']` is specified,
+     * this method will also add `['assets']` to the relations array, otherwise TypeORM would
+     * throw an error trying to join a 2nd-level deep relation without the first level also
+     * being joined.
+     */
+    getReindexRelationsRelations(defaultRelations, hydratedRelations) {
+        const uniqueRelations = unique_1.unique([...defaultRelations, ...hydratedRelations]);
+        for (const relation of hydratedRelations) {
+            const path = relation.split('.');
+            const pathToPart = [];
+            for (const part of path) {
+                pathToPart.push(part);
+                const joinedPath = pathToPart.join('.');
+                if (!uniqueRelations.includes(joinedPath)) {
+                    uniqueRelations.push(joinedPath);
                 }
             }
         }
-        core_1.Logger.verbose(`Updating ${productVariants.length} ProductVariants`, constants_1.loggerCtx);
-        return operations;
+        return uniqueRelations;
     }
     async deleteProductOperations(productId) {
         const channels = await this.connection
@@ -505,29 +455,39 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
         }
         core_1.Logger.verbose(`Deleting 1 Product (id: ${productId})`, constants_1.loggerCtx);
         const operations = [];
+        const languageVariants = [];
+        languageVariants.push(...product.translations.map(t => t.languageCode));
+        for (const variant of product.variants) {
+            languageVariants.push(...variant.translations.map(t => t.languageCode));
+        }
+        const uniqueLanguageVariants = unique_1.unique(languageVariants);
         for (const { id: channelId } of channels) {
-            const languageVariants = product.translations.map(t => t.languageCode);
-            for (const languageCode of languageVariants) {
+            for (const languageCode of uniqueLanguageVariants) {
                 operations.push({
-                    index: constants_1.PRODUCT_INDEX_NAME,
-                    operation: { delete: { _id: this.getId(product.id, channelId, languageCode) } },
+                    index: constants_1.VARIANT_INDEX_NAME,
+                    operation: {
+                        delete: {
+                            _id: ElasticsearchIndexerController_1.getId(-product.id, channelId, languageCode),
+                        },
+                    },
                 });
             }
         }
-        operations.push(...(await this.deleteVariantsInternalOperations(product.variants, channels.map(c => c.id))));
+        operations.push(...(await this.deleteVariantsInternalOperations(product.variants, channels.map(c => c.id), uniqueLanguageVariants)));
         return operations;
     }
-    async deleteVariantsInternalOperations(variants, channelIds) {
+    async deleteVariantsInternalOperations(variants, channelIds, languageVariants) {
         core_1.Logger.verbose(`Deleting ${variants.length} ProductVariants`, constants_1.loggerCtx);
         const operations = [];
         for (const variant of variants) {
             for (const channelId of channelIds) {
-                const languageVariants = variant.translations.map(t => t.languageCode);
                 for (const languageCode of languageVariants) {
                     operations.push({
                         index: constants_1.VARIANT_INDEX_NAME,
                         operation: {
-                            delete: { _id: this.getId(variant.id, channelId, languageCode) },
+                            delete: {
+                                _id: ElasticsearchIndexerController_1.getId(variant.id, channelId, languageCode),
+                            },
                         },
                     });
                 }
@@ -543,20 +503,11 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
         return unique_1.unique(variants.map(v => v.product.id));
     }
     async executeBulkOperations(operations) {
-        const productOperations = [];
         const variantOperations = [];
         for (const operation of operations) {
-            if (operation.index === constants_1.PRODUCT_INDEX_NAME) {
-                productOperations.push(operation.operation);
-            }
-            else {
-                variantOperations.push(operation.operation);
-            }
+            variantOperations.push(operation.operation);
         }
-        return Promise.all([
-            this.runBulkOperationsOnIndex(constants_1.PRODUCT_INDEX_NAME, productOperations),
-            this.runBulkOperationsOnIndex(constants_1.VARIANT_INDEX_NAME, variantOperations),
-        ]);
+        return Promise.all([this.runBulkOperationsOnIndex(constants_1.VARIANT_INDEX_NAME, variantOperations)]);
     }
     async runBulkOperationsOnIndex(indexName, operations) {
         var _a;
@@ -594,127 +545,129 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
             core_1.Logger.error('Error details: ' + JSON.stringify((_a = e.body) === null || _a === void 0 ? void 0 : _a.error, null, 2), constants_1.loggerCtx);
         }
     }
-    createVariantIndexItem(v, channelId, languageCode) {
-        const productAsset = v.product.featuredAsset;
-        const variantAsset = v.featuredAsset;
-        const productTranslation = this.getTranslation(v.product, languageCode);
-        const variantTranslation = this.getTranslation(v, languageCode);
-        const collectionTranslations = v.collections.map(c => this.getTranslation(c, languageCode));
-        const item = {
-            channelId,
-            languageCode,
-            productVariantId: v.id,
-            sku: v.sku,
-            slug: productTranslation.slug,
-            productId: v.product.id,
-            productName: productTranslation.name,
-            productAssetId: productAsset ? productAsset.id : undefined,
-            productPreview: productAsset ? productAsset.preview : '',
-            productPreviewFocalPoint: productAsset ? productAsset.focalPoint || undefined : undefined,
-            productVariantName: variantTranslation.name,
-            productVariantAssetId: variantAsset ? variantAsset.id : undefined,
-            productVariantPreview: variantAsset ? variantAsset.preview : '',
-            productVariantPreviewFocalPoint: productAsset ? productAsset.focalPoint || undefined : undefined,
-            price: v.price,
-            priceWithTax: v.priceWithTax,
-            currencyCode: v.currencyCode,
-            description: productTranslation.description,
-            facetIds: this.getFacetIds([v]),
-            channelIds: v.channels.map(c => c.id),
-            facetValueIds: this.getFacetValueIds([v]),
-            collectionIds: v.collections.map(c => c.id.toString()),
-            collectionSlugs: collectionTranslations.map(c => c.slug),
-            enabled: v.enabled && v.product.enabled,
-        };
-        const customMappings = Object.entries(this.options.customProductVariantMappings);
-        for (const [name, def] of customMappings) {
-            item[name] = def.valueFn(v, languageCode);
+    async createVariantIndexItem(v, variants, ctx, languageCode) {
+        try {
+            const productAsset = v.product.featuredAsset;
+            const variantAsset = v.featuredAsset;
+            const productTranslation = this.getTranslation(v.product, languageCode);
+            const variantTranslation = this.getTranslation(v, languageCode);
+            const collectionTranslations = v.collections.map(c => this.getTranslation(c, languageCode));
+            const productCollectionTranslations = variants.reduce((translations, variant) => [
+                ...translations,
+                ...variant.collections.map(c => this.getTranslation(c, languageCode)),
+            ], []);
+            const prices = variants.map(variant => variant.price);
+            const pricesWithTax = variants.map(variant => variant.priceWithTax);
+            const item = {
+                channelId: ctx.channelId,
+                languageCode,
+                productVariantId: v.id,
+                sku: v.sku,
+                slug: productTranslation.slug,
+                productId: v.product.id,
+                productName: productTranslation.name,
+                productAssetId: productAsset ? productAsset.id : undefined,
+                productPreview: productAsset ? productAsset.preview : '',
+                productPreviewFocalPoint: productAsset ? productAsset.focalPoint || undefined : undefined,
+                productVariantName: variantTranslation.name,
+                productVariantAssetId: variantAsset ? variantAsset.id : undefined,
+                productVariantPreview: variantAsset ? variantAsset.preview : '',
+                productVariantPreviewFocalPoint: variantAsset
+                    ? variantAsset.focalPoint || undefined
+                    : undefined,
+                price: v.price,
+                priceWithTax: v.priceWithTax,
+                currencyCode: v.currencyCode,
+                description: productTranslation.description,
+                facetIds: this.getFacetIds([v]),
+                channelIds: v.channels.map(c => c.id),
+                facetValueIds: this.getFacetValueIds([v]),
+                collectionIds: v.collections.map(c => c.id.toString()),
+                collectionSlugs: collectionTranslations.map(c => c.slug),
+                enabled: v.enabled && v.product.enabled,
+                productEnabled: variants.some(variant => variant.enabled) && v.product.enabled,
+                productPriceMin: Math.min(...prices),
+                productPriceMax: Math.max(...prices),
+                productPriceWithTaxMin: Math.min(...pricesWithTax),
+                productPriceWithTaxMax: Math.max(...pricesWithTax),
+                productFacetIds: this.getFacetIds(variants),
+                productFacetValueIds: this.getFacetValueIds(variants),
+                productCollectionIds: unique_1.unique(variants.reduce((ids, variant) => [...ids, ...variant.collections.map(c => c.id)], [])),
+                productCollectionSlugs: unique_1.unique(productCollectionTranslations.map(c => c.slug)),
+                productChannelIds: v.product.channels.map(c => c.id),
+                inStock: 0 < (await this.productVariantService.getSaleableStockLevel(ctx, v)),
+                productInStock: await this.getProductInStockValue(ctx, variants),
+            };
+            const variantCustomMappings = Object.entries(this.options.customProductVariantMappings);
+            for (const [name, def] of variantCustomMappings) {
+                item[`variant-${name}`] = def.valueFn(v, languageCode);
+            }
+            const productCustomMappings = Object.entries(this.options.customProductMappings);
+            for (const [name, def] of productCustomMappings) {
+                item[`product-${name}`] = def.valueFn(v.product, variants, languageCode);
+            }
+            return item;
         }
-        return item;
-    }
-    createProductIndexItem(variants, channelId, languageCode) {
-        const first = variants[0];
-        const prices = variants.map(v => v.price);
-        const pricesWithTax = variants.map(v => v.priceWithTax);
-        const productAsset = first.product.featuredAsset;
-        const variantAsset = variants.filter(v => v.featuredAsset).length
-            ? variants.filter(v => v.featuredAsset)[0].featuredAsset
-            : null;
-        const productTranslation = this.getTranslation(first.product, languageCode);
-        const variantTranslation = this.getTranslation(first, languageCode);
-        const collectionTranslations = variants.reduce((translations, variant) => [
-            ...translations,
-            ...variant.collections.map(c => this.getTranslation(c, languageCode)),
-        ], []);
-        const item = {
-            channelId,
-            languageCode,
-            sku: first.sku,
-            slug: productTranslation.slug,
-            productId: first.product.id,
-            productName: productTranslation.name,
-            productAssetId: productAsset ? productAsset.id : undefined,
-            productPreview: productAsset ? productAsset.preview : '',
-            productPreviewFocalPoint: productAsset ? productAsset.focalPoint || undefined : undefined,
-            productVariantId: first.id,
-            productVariantName: variantTranslation.name,
-            productVariantAssetId: variantAsset ? variantAsset.id : undefined,
-            productVariantPreview: variantAsset ? variantAsset.preview : '',
-            productVariantPreviewFocalPoint: productAsset ? productAsset.focalPoint || undefined : undefined,
-            priceMin: Math.min(...prices),
-            priceMax: Math.max(...prices),
-            priceWithTaxMin: Math.min(...pricesWithTax),
-            priceWithTaxMax: Math.max(...pricesWithTax),
-            currencyCode: first.currencyCode,
-            description: productTranslation.description,
-            facetIds: this.getFacetIds(variants),
-            facetValueIds: this.getFacetValueIds(variants),
-            collectionIds: variants.reduce((ids, v) => [...ids, ...v.collections.map(c => c.id)], []),
-            collectionSlugs: collectionTranslations.map(c => c.slug),
-            channelIds: first.product.channels.map(c => c.id),
-            enabled: variants.some(v => v.enabled) && first.product.enabled,
-        };
-        const customMappings = Object.entries(this.options.customProductMappings);
-        for (const [name, def] of customMappings) {
-            item[name] = def.valueFn(variants[0].product, variants, languageCode);
+        catch (err) {
+            core_1.Logger.error(err.toString());
+            throw Error(`Error while reindexing!`);
         }
-        return item;
+    }
+    async getProductInStockValue(ctx, variants) {
+        const stockLevels = await Promise.all(variants.map(variant => this.productVariantService.getSaleableStockLevel(ctx, variant)));
+        return stockLevels.some(stockLevel => 0 < stockLevel);
     }
     /**
      * If a Product has no variants, we create a synthetic variant for the purposes
      * of making that product visible via the search query.
      */
-    createSyntheticProductIndexItem(ctx, product, languageCode) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        const productTranslation = this.getTranslation(product, ctx.languageCode);
-        return {
+    createSyntheticProductIndexItem(product, ctx, languageCode) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const productTranslation = this.getTranslation(product, languageCode);
+        const productAsset = product.featuredAsset;
+        const item = {
             channelId: ctx.channelId,
             languageCode,
+            productVariantId: 0,
             sku: '',
             slug: productTranslation.slug,
             productId: product.id,
             productName: productTranslation.name,
-            productAssetId: (_b = (_a = product.featuredAsset) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : undefined,
-            productPreview: (_d = (_c = product.featuredAsset) === null || _c === void 0 ? void 0 : _c.preview) !== null && _d !== void 0 ? _d : '',
-            productPreviewFocalPoint: (_f = (_e = product.featuredAsset) === null || _e === void 0 ? void 0 : _e.focalPoint) !== null && _f !== void 0 ? _f : undefined,
-            productVariantId: 0,
+            productAssetId: productAsset ? productAsset.id : undefined,
+            productPreview: productAsset ? productAsset.preview : '',
+            productPreviewFocalPoint: productAsset ? productAsset.focalPoint || undefined : undefined,
             productVariantName: productTranslation.name,
             productVariantAssetId: undefined,
             productVariantPreview: '',
             productVariantPreviewFocalPoint: undefined,
-            priceMin: 0,
-            priceMax: 0,
-            priceWithTaxMin: 0,
-            priceWithTaxMax: 0,
+            price: 0,
+            priceWithTax: 0,
             currencyCode: ctx.channel.currencyCode,
             description: productTranslation.description,
-            facetIds: (_h = (_g = product.facetValues) === null || _g === void 0 ? void 0 : _g.map(fv => fv.facet.id.toString())) !== null && _h !== void 0 ? _h : [],
-            facetValueIds: (_k = (_j = product.facetValues) === null || _j === void 0 ? void 0 : _j.map(fv => fv.id.toString())) !== null && _k !== void 0 ? _k : [],
+            facetIds: (_b = (_a = product.facetValues) === null || _a === void 0 ? void 0 : _a.map(fv => fv.facet.id.toString())) !== null && _b !== void 0 ? _b : [],
+            channelIds: [ctx.channelId],
+            facetValueIds: (_d = (_c = product.facetValues) === null || _c === void 0 ? void 0 : _c.map(fv => fv.id.toString())) !== null && _d !== void 0 ? _d : [],
             collectionIds: [],
             collectionSlugs: [],
-            channelIds: [ctx.channelId],
             enabled: false,
+            productEnabled: false,
+            productPriceMin: 0,
+            productPriceMax: 0,
+            productPriceWithTaxMin: 0,
+            productPriceWithTaxMax: 0,
+            productFacetIds: (_f = (_e = product.facetValues) === null || _e === void 0 ? void 0 : _e.map(fv => fv.facet.id.toString())) !== null && _f !== void 0 ? _f : [],
+            productFacetValueIds: (_h = (_g = product.facetValues) === null || _g === void 0 ? void 0 : _g.map(fv => fv.id.toString())) !== null && _h !== void 0 ? _h : [],
+            productCollectionIds: [],
+            productCollectionSlugs: [],
+            productChannelIds: product.channels.map(c => c.id),
+            inStock: false,
+            productInStock: false,
         };
+        const productCustomMappings = Object.entries(this.options.customProductMappings);
+        for (const [name, def] of productCustomMappings) {
+            item[`product-${name}`] = def.valueFn(product, [], languageCode);
+        }
+        return item;
     }
     getTranslation(translatable, languageCode) {
         return (translatable.translations.find(t => t.languageCode === languageCode) ||
@@ -733,15 +686,17 @@ let ElasticsearchIndexerController = class ElasticsearchIndexerController {
         const productFacetValueIds = variants[0].product.facetValues.map(facetValueIds);
         return unique_1.unique([...variantFacetValueIds, ...productFacetValueIds]);
     }
-    getId(entityId, channelId, languageCode) {
+    static getId(entityId, channelId, languageCode) {
         return `${channelId.toString()}_${entityId.toString()}_${languageCode}`;
     }
 };
-ElasticsearchIndexerController = __decorate([
+ElasticsearchIndexerController = ElasticsearchIndexerController_1 = __decorate([
     common_1.Injectable(),
     __param(1, common_1.Inject(constants_1.ELASTIC_SEARCH_OPTIONS)),
-    __metadata("design:paramtypes", [core_1.TransactionalConnection, Object, core_1.ProductVariantService,
-        core_1.ConfigService])
+    __metadata("design:paramtypes", [core_1.TransactionalConnection, Object, core_1.ProductPriceApplicator,
+        core_1.ConfigService,
+        core_1.ProductVariantService,
+        core_1.RequestContextCacheService])
 ], ElasticsearchIndexerController);
 exports.ElasticsearchIndexerController = ElasticsearchIndexerController;
 //# sourceMappingURL=indexer.controller.js.map