@vendure/core 1.7.1 → 1.7.2

package/cli/service/services/product-variant.service.d.ts

@@ -1,70 +0,0 @@
-import { AssignProductVariantsToChannelInput, CreateProductVariantInput, DeletionResponse, RemoveProductVariantsFromChannelInput, UpdateProductVariantInput } from '@vendure/common/lib/generated-types';
-import { ID, PaginatedList } from '@vendure/common/lib/shared-types';
-import { RequestContext } from '../../api/common/request-context';
-import { RequestContextCacheService } from '../../cache/request-context-cache.service';
-import { ListQueryOptions } from '../../common/types/common-types';
-import { Translated } from '../../common/types/locale-types';
-import { ConfigService } from '../../config/config.service';
-import { TransactionalConnection } from '../../connection/transactional-connection';
-import { Channel, Order, ProductVariantPrice } from '../../entity';
-import { FacetValue } from '../../entity/facet-value/facet-value.entity';
-import { ProductOption } from '../../entity/product-option/product-option.entity';
-import { ProductVariant } from '../../entity/product-variant/product-variant.entity';
-import { Product } from '../../entity/product/product.entity';
-import { EventBus } from '../../event-bus/event-bus';
-import { CustomFieldRelationService } from '../helpers/custom-field-relation/custom-field-relation.service';
-import { ListQueryBuilder } from '../helpers/list-query-builder/list-query-builder';
-import { ProductPriceApplicator } from '../helpers/product-price-applicator/product-price-applicator';
-import { TranslatableSaver } from '../helpers/translatable-saver/translatable-saver';
-import { AssetService } from './asset.service';
-import { ChannelService } from './channel.service';
-import { FacetValueService } from './facet-value.service';
-import { GlobalSettingsService } from './global-settings.service';
-import { RoleService } from './role.service';
-import { StockMovementService } from './stock-movement.service';
-import { TaxCategoryService } from './tax-category.service';
-export declare class ProductVariantService {
-    private connection;
-    private configService;
-    private taxCategoryService;
-    private facetValueService;
-    private assetService;
-    private translatableSaver;
-    private eventBus;
-    private listQueryBuilder;
-    private globalSettingsService;
-    private stockMovementService;
-    private channelService;
-    private roleService;
-    private customFieldRelationService;
-    private requestCache;
-    private productPriceApplicator;
-    constructor(connection: TransactionalConnection, configService: ConfigService, taxCategoryService: TaxCategoryService, facetValueService: FacetValueService, assetService: AssetService, translatableSaver: TranslatableSaver, eventBus: EventBus, listQueryBuilder: ListQueryBuilder, globalSettingsService: GlobalSettingsService, stockMovementService: StockMovementService, channelService: ChannelService, roleService: RoleService, customFieldRelationService: CustomFieldRelationService, requestCache: RequestContextCacheService, productPriceApplicator: ProductPriceApplicator);
-    findAll(ctx: RequestContext, options?: ListQueryOptions<ProductVariant>): Promise<PaginatedList<Translated<ProductVariant>>>;
-    findOne(ctx: RequestContext, productVariantId: ID): Promise<Translated<ProductVariant> | undefined>;
-    findByIds(ctx: RequestContext, ids: ID[]): Promise<Array<Translated<ProductVariant>>>;
-    getVariantsByProductId(ctx: RequestContext, productId: ID, options?: ListQueryOptions<ProductVariant>): Promise<PaginatedList<Translated<ProductVariant>>>;
-    getVariantsByCollectionId(ctx: RequestContext, collectionId: ID, options: ListQueryOptions<ProductVariant>): Promise<PaginatedList<Translated<ProductVariant>>>;
-    getProductVariantChannels(ctx: RequestContext, productVariantId: ID): Promise<Channel[]>;
-    getVariantByOrderLineId(ctx: RequestContext, orderLineId: ID): Promise<Translated<ProductVariant>>;
-    getOptionsForVariant(ctx: RequestContext, variantId: ID): Promise<Array<Translated<ProductOption>>>;
-    getFacetValuesForVariant(ctx: RequestContext, variantId: ID): Promise<Array<Translated<FacetValue>>>;
-    getProductForVariant(ctx: RequestContext, variant: ProductVariant): Promise<Translated<Product>>;
-    getSaleableStockLevel(ctx: RequestContext, variant: ProductVariant): Promise<number>;
-    getDisplayStockLevel(ctx: RequestContext, variant: ProductVariant): Promise<string>;
-    getFulfillableStockLevel(ctx: RequestContext, variant: ProductVariant): Promise<number>;
-    create(ctx: RequestContext, input: CreateProductVariantInput[]): Promise<Array<Translated<ProductVariant>>>;
-    update(ctx: RequestContext, input: UpdateProductVariantInput[]): Promise<Array<Translated<ProductVariant>>>;
-    private createSingle;
-    private updateSingle;
-    createOrUpdateProductVariantPrice(ctx: RequestContext, productVariantId: ID, price: number, channelId: ID): Promise<ProductVariantPrice>;
-    softDelete(ctx: RequestContext, id: ID | ID[]): Promise<DeletionResponse>;
-    hydratePriceFields<F extends 'currencyCode' | 'price' | 'priceWithTax' | 'taxRateApplied'>(ctx: RequestContext, variant: ProductVariant, priceField: F): Promise<ProductVariant[F]>;
-    applyChannelPriceAndTax(variant: ProductVariant, ctx: RequestContext, order?: Order): Promise<ProductVariant>;
-    assignProductVariantsToChannel(ctx: RequestContext, input: AssignProductVariantsToChannelInput): Promise<Array<Translated<ProductVariant>>>;
-    removeProductVariantsFromChannel(ctx: RequestContext, input: RemoveProductVariantsFromChannelInput): Promise<Array<Translated<ProductVariant>>>;
-    private validateVariantOptionIds;
-    private throwIncompatibleOptionsError;
-    private sortJoin;
-    private getTaxCategoryForNewVariant;
-}

package/cli/service/services/product-variant.service.js

@@ -1,560 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProductVariantService = void 0;
-const common_1 = require("@nestjs/common");
-const generated_types_1 = require("@vendure/common/lib/generated-types");
-const request_context_cache_service_1 = require("../../cache/request-context-cache.service");
-const errors_1 = require("../../common/error/errors");
-const utils_1 = require("../../common/utils");
-const config_service_1 = require("../../config/config.service");
-const transactional_connection_1 = require("../../connection/transactional-connection");
-const entity_1 = require("../../entity");
-const product_option_entity_1 = require("../../entity/product-option/product-option.entity");
-const product_variant_translation_entity_1 = require("../../entity/product-variant/product-variant-translation.entity");
-const product_variant_entity_1 = require("../../entity/product-variant/product-variant.entity");
-const product_entity_1 = require("../../entity/product/product.entity");
-const event_bus_1 = require("../../event-bus/event-bus");
-const product_variant_channel_event_1 = require("../../event-bus/events/product-variant-channel-event");
-const product_variant_event_1 = require("../../event-bus/events/product-variant-event");
-const custom_field_relation_service_1 = require("../helpers/custom-field-relation/custom-field-relation.service");
-const list_query_builder_1 = require("../helpers/list-query-builder/list-query-builder");
-const product_price_applicator_1 = require("../helpers/product-price-applicator/product-price-applicator");
-const translatable_saver_1 = require("../helpers/translatable-saver/translatable-saver");
-const samples_each_1 = require("../helpers/utils/samples-each");
-const translate_entity_1 = require("../helpers/utils/translate-entity");
-const asset_service_1 = require("./asset.service");
-const channel_service_1 = require("./channel.service");
-const facet_value_service_1 = require("./facet-value.service");
-const global_settings_service_1 = require("./global-settings.service");
-const role_service_1 = require("./role.service");
-const stock_movement_service_1 = require("./stock-movement.service");
-const tax_category_service_1 = require("./tax-category.service");
-let ProductVariantService = class ProductVariantService {
-    constructor(connection, configService, taxCategoryService, facetValueService, assetService, translatableSaver, eventBus, listQueryBuilder, globalSettingsService, stockMovementService, channelService, roleService, customFieldRelationService, requestCache, productPriceApplicator) {
-        this.connection = connection;
-        this.configService = configService;
-        this.taxCategoryService = taxCategoryService;
-        this.facetValueService = facetValueService;
-        this.assetService = assetService;
-        this.translatableSaver = translatableSaver;
-        this.eventBus = eventBus;
-        this.listQueryBuilder = listQueryBuilder;
-        this.globalSettingsService = globalSettingsService;
-        this.stockMovementService = stockMovementService;
-        this.channelService = channelService;
-        this.roleService = roleService;
-        this.customFieldRelationService = customFieldRelationService;
-        this.requestCache = requestCache;
-        this.productPriceApplicator = productPriceApplicator;
-    }
-    async findAll(ctx, options) {
-        const relations = ['featuredAsset', 'taxCategory', 'channels'];
-        return this.listQueryBuilder
-            .build(product_variant_entity_1.ProductVariant, options, {
-            relations,
-            channelId: ctx.channelId,
-            where: { deletedAt: null },
-            ctx,
-        })
-            .getManyAndCount()
-            .then(async ([variants, totalItems]) => {
-            const items = await Promise.all(variants.map(async (variant) => translate_entity_1.translateDeep(await this.applyChannelPriceAndTax(variant, ctx), ctx.languageCode)));
-            return {
-                items,
-                totalItems,
-            };
-        });
-    }
-    findOne(ctx, productVariantId) {
-        const relations = ['product', 'product.featuredAsset', 'taxCategory'];
-        return this.connection
-            .findOneInChannel(ctx, product_variant_entity_1.ProductVariant, productVariantId, ctx.channelId, {
-            relations,
-            where: { deletedAt: null },
-        })
-            .then(async (result) => {
-            if (result) {
-                return translate_entity_1.translateDeep(await this.applyChannelPriceAndTax(result, ctx), ctx.languageCode, [
-                    'product',
-                ]);
-            }
-        });
-    }
-    findByIds(ctx, ids) {
-        return this.connection
-            .findByIdsInChannel(ctx, product_variant_entity_1.ProductVariant, ids, ctx.channelId, {
-            relations: [
-                'options',
-                'facetValues',
-                'facetValues.facet',
-                'taxCategory',
-                'assets',
-                'featuredAsset',
-            ],
-        })
-            .then(variants => {
-            return Promise.all(variants.map(async (variant) => translate_entity_1.translateDeep(await this.applyChannelPriceAndTax(variant, ctx), ctx.languageCode, [
-                'options',
-                'facetValues',
-                ['facetValues', 'facet'],
-            ])));
-        });
-    }
-    getVariantsByProductId(ctx, productId, options = {}) {
-        const relations = [
-            'options',
-            'facetValues',
-            'facetValues.facet',
-            'taxCategory',
-            'assets',
-            'featuredAsset',
-        ];
-        const qb = this.listQueryBuilder
-            .build(product_variant_entity_1.ProductVariant, options, {
-            relations,
-            orderBy: { id: 'ASC' },
-            where: { deletedAt: null },
-            ctx,
-        })
-            .innerJoinAndSelect('productvariant.channels', 'channel', 'channel.id = :channelId', {
-            channelId: ctx.channelId,
-        })
-            .innerJoinAndSelect('productvariant.product', 'product', 'product.id = :productId', {
-            productId,
-        });
-        if (ctx.apiType === 'shop') {
-            qb.andWhere('productvariant.enabled = :enabled', { enabled: true });
-        }
-        return qb.getManyAndCount().then(async ([variants, totalItems]) => {
-            const items = await Promise.all(variants.map(async (variant) => {
-                const variantWithPrices = await this.applyChannelPriceAndTax(variant, ctx);
-                return translate_entity_1.translateDeep(variantWithPrices, ctx.languageCode, [
-                    'options',
-                    'facetValues',
-                    ['facetValues', 'facet'],
-                ]);
-            }));
-            return {
-                items,
-                totalItems,
-            };
-        });
-    }
-    getVariantsByCollectionId(ctx, collectionId, options) {
-        const qb = this.listQueryBuilder
-            .build(product_variant_entity_1.ProductVariant, options, {
-            relations: ['taxCategory', 'channels'],
-            channelId: ctx.channelId,
-            ctx,
-        })
-            .leftJoin('productvariant.collections', 'collection')
-            .leftJoin('productvariant.product', 'product')
-            .andWhere('product.deletedAt IS NULL')
-            .andWhere('productvariant.deletedAt IS NULL')
-            .andWhere('collection.id = :collectionId', { collectionId });
-        if (options && options.filter && options.filter.enabled && options.filter.enabled.eq === true) {
-            qb.andWhere('product.enabled = :enabled', { enabled: true });
-        }
-        return qb.getManyAndCount().then(async ([variants, totalItems]) => {
-            const items = await Promise.all(variants.map(async (variant) => {
-                const variantWithPrices = await this.applyChannelPriceAndTax(variant, ctx);
-                return translate_entity_1.translateDeep(variantWithPrices, ctx.languageCode);
-            }));
-            return {
-                items,
-                totalItems,
-            };
-        });
-    }
-    async getProductVariantChannels(ctx, productVariantId) {
-        const variant = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, productVariantId, {
-            relations: ['channels'],
-            channelId: ctx.channelId,
-        });
-        return variant.channels;
-    }
-    async getVariantByOrderLineId(ctx, orderLineId) {
-        const { productVariant } = await this.connection.getEntityOrThrow(ctx, entity_1.OrderLine, orderLineId, {
-            relations: ['productVariant'],
-        });
-        return translate_entity_1.translateDeep(productVariant, ctx.languageCode);
-    }
-    getOptionsForVariant(ctx, variantId) {
-        return this.connection
-            .findOneInChannel(ctx, product_variant_entity_1.ProductVariant, variantId, ctx.channelId, {
-            relations: ['options'],
-        })
-            .then(variant => (!variant ? [] : variant.options.map(o => translate_entity_1.translateDeep(o, ctx.languageCode))));
-    }
-    getFacetValuesForVariant(ctx, variantId) {
-        return this.connection
-            .findOneInChannel(ctx, product_variant_entity_1.ProductVariant, variantId, ctx.channelId, {
-            relations: ['facetValues', 'facetValues.facet', 'facetValues.channels'],
-        })
-            .then(variant => !variant ? [] : variant.facetValues.map(o => translate_entity_1.translateDeep(o, ctx.languageCode, ['facet'])));
-    }
-    async getProductForVariant(ctx, variant) {
-        const product = await this.connection.getEntityOrThrow(ctx, product_entity_1.Product, variant.productId, {
-            includeSoftDeleted: true,
-        });
-        return translate_entity_1.translateDeep(product, ctx.languageCode);
-    }
-    async getSaleableStockLevel(ctx, variant) {
-        const { outOfStockThreshold, trackInventory } = await this.requestCache.get(ctx, 'globalSettings', () => this.globalSettingsService.getSettings(ctx));
-        const inventoryNotTracked = variant.trackInventory === generated_types_1.GlobalFlag.FALSE ||
-            (variant.trackInventory === generated_types_1.GlobalFlag.INHERIT && trackInventory === false);
-        if (inventoryNotTracked) {
-            return Number.MAX_SAFE_INTEGER;
-        }
-        const effectiveOutOfStockThreshold = variant.useGlobalOutOfStockThreshold
-            ? outOfStockThreshold
-            : variant.outOfStockThreshold;
-        return variant.stockOnHand - variant.stockAllocated - effectiveOutOfStockThreshold;
-    }
-    async getDisplayStockLevel(ctx, variant) {
-        const { stockDisplayStrategy } = this.configService.catalogOptions;
-        const saleableStockLevel = await this.getSaleableStockLevel(ctx, variant);
-        return stockDisplayStrategy.getStockLevel(ctx, variant, saleableStockLevel);
-    }
-    async getFulfillableStockLevel(ctx, variant) {
-        const { outOfStockThreshold, trackInventory } = await this.globalSettingsService.getSettings(ctx);
-        const inventoryNotTracked = variant.trackInventory === generated_types_1.GlobalFlag.FALSE ||
-            (variant.trackInventory === generated_types_1.GlobalFlag.INHERIT && trackInventory === false);
-        if (inventoryNotTracked) {
-            return Number.MAX_SAFE_INTEGER;
-        }
-        return variant.stockOnHand;
-    }
-    async create(ctx, input) {
-        const ids = [];
-        for (const productInput of input) {
-            const id = await this.createSingle(ctx, productInput);
-            ids.push(id);
-        }
-        const createdVariants = await this.findByIds(ctx, ids);
-        this.eventBus.publish(new product_variant_event_1.ProductVariantEvent(ctx, createdVariants, 'created', input));
-        return createdVariants;
-    }
-    async update(ctx, input) {
-        for (const productInput of input) {
-            await this.updateSingle(ctx, productInput);
-        }
-        const updatedVariants = await this.findByIds(ctx, input.map(i => i.id));
-        this.eventBus.publish(new product_variant_event_1.ProductVariantEvent(ctx, updatedVariants, 'updated', input));
-        return updatedVariants;
-    }
-    async createSingle(ctx, input) {
-        await this.validateVariantOptionIds(ctx, input);
-        if (!input.optionIds) {
-            input.optionIds = [];
-        }
-        if (input.price == null) {
-            input.price = 0;
-        }
-        input.taxCategoryId = (await this.getTaxCategoryForNewVariant(ctx, input.taxCategoryId)).id;
-        const inputWithoutPrice = Object.assign({}, input);
-        delete inputWithoutPrice.price;
-        const createdVariant = await this.translatableSaver.create({
-            ctx,
-            input: inputWithoutPrice,
-            entityType: product_variant_entity_1.ProductVariant,
-            translationType: product_variant_translation_entity_1.ProductVariantTranslation,
-            beforeSave: async (variant) => {
-                const { optionIds } = input;
-                if (optionIds && optionIds.length) {
-                    const selectedOptions = await this.connection
-                        .getRepository(ctx, product_option_entity_1.ProductOption)
-                        .findByIds(optionIds);
-                    variant.options = selectedOptions;
-                }
-                if (input.facetValueIds) {
-                    variant.facetValues = await this.facetValueService.findByIds(ctx, input.facetValueIds);
-                }
-                variant.product = { id: input.productId };
-                variant.taxCategory = { id: input.taxCategoryId };
-                await this.assetService.updateFeaturedAsset(ctx, variant, input);
-                await this.channelService.assignToCurrentChannel(variant, ctx);
-            },
-            typeOrmSubscriberData: {
-                channelId: ctx.channelId,
-                taxCategoryId: input.taxCategoryId,
-            },
-        });
-        await this.customFieldRelationService.updateRelations(ctx, product_variant_entity_1.ProductVariant, input, createdVariant);
-        await this.assetService.updateEntityAssets(ctx, createdVariant, input);
-        if (input.stockOnHand != null && input.stockOnHand !== 0) {
-            await this.stockMovementService.adjustProductVariantStock(ctx, createdVariant.id, 0, input.stockOnHand);
-        }
-        const defaultChannelId = (await this.channelService.getDefaultChannel()).id;
-        await this.createOrUpdateProductVariantPrice(ctx, createdVariant.id, input.price, ctx.channelId);
-        if (!utils_1.idsAreEqual(ctx.channelId, defaultChannelId)) {
-            await this.createOrUpdateProductVariantPrice(ctx, createdVariant.id, input.price, defaultChannelId);
-        }
-        return createdVariant.id;
-    }
-    async updateSingle(ctx, input) {
-        const existingVariant = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, input.id, {
-            channelId: ctx.channelId,
-            relations: ['facetValues', 'facetValues.channels'],
-        });
-        if (input.stockOnHand && input.stockOnHand < 0) {
-            throw new errors_1.UserInputError('error.stockonhand-cannot-be-negative');
-        }
-        const inputWithoutPrice = Object.assign({}, input);
-        delete inputWithoutPrice.price;
-        const updatedVariant = await this.translatableSaver.update({
-            ctx,
-            input: inputWithoutPrice,
-            entityType: product_variant_entity_1.ProductVariant,
-            translationType: product_variant_translation_entity_1.ProductVariantTranslation,
-            beforeSave: async (v) => {
-                if (input.taxCategoryId) {
-                    const taxCategory = await this.taxCategoryService.findOne(ctx, input.taxCategoryId);
-                    if (taxCategory) {
-                        v.taxCategory = taxCategory;
-                    }
-                }
-                if (input.facetValueIds) {
-                    const facetValuesInOtherChannels = existingVariant.facetValues.filter(fv => fv.channels.every(channel => !utils_1.idsAreEqual(channel.id, ctx.channelId)));
-                    v.facetValues = [
-                        ...facetValuesInOtherChannels,
-                        ...(await this.facetValueService.findByIds(ctx, input.facetValueIds)),
-                    ];
-                }
-                if (input.stockOnHand != null) {
-                    await this.stockMovementService.adjustProductVariantStock(ctx, existingVariant.id, existingVariant.stockOnHand, input.stockOnHand);
-                }
-                await this.assetService.updateFeaturedAsset(ctx, v, input);
-                await this.assetService.updateEntityAssets(ctx, v, input);
-            },
-            typeOrmSubscriberData: {
-                channelId: ctx.channelId,
-                taxCategoryId: input.taxCategoryId,
-            },
-        });
-        await this.customFieldRelationService.updateRelations(ctx, product_variant_entity_1.ProductVariant, input, updatedVariant);
-        if (input.price != null) {
-            const variantPriceRepository = this.connection.getRepository(ctx, entity_1.ProductVariantPrice);
-            const variantPrice = await variantPriceRepository.findOne({
-                where: {
-                    variant: input.id,
-                    channelId: ctx.channelId,
-                },
-            });
-            if (!variantPrice) {
-                throw new errors_1.InternalServerError(`error.could-not-find-product-variant-price`);
-            }
-            variantPrice.price = input.price;
-            await variantPriceRepository.save(variantPrice);
-        }
-        return updatedVariant.id;
-    }
-    async createOrUpdateProductVariantPrice(ctx, productVariantId, price, channelId) {
-        let variantPrice = await this.connection.getRepository(ctx, entity_1.ProductVariantPrice).findOne({
-            where: {
-                variant: productVariantId,
-                channelId,
-            },
-        });
-        if (!variantPrice) {
-            variantPrice = new entity_1.ProductVariantPrice({
-                channelId,
-                variant: new product_variant_entity_1.ProductVariant({ id: productVariantId }),
-            });
-        }
-        variantPrice.price = price;
-        return this.connection.getRepository(ctx, entity_1.ProductVariantPrice).save(variantPrice);
-    }
-    async softDelete(ctx, id) {
-        const ids = Array.isArray(id) ? id : [id];
-        const variants = await this.connection.getRepository(ctx, product_variant_entity_1.ProductVariant).findByIds(ids);
-        for (const variant of variants) {
-            variant.deletedAt = new Date();
-        }
-        await this.connection.getRepository(ctx, product_variant_entity_1.ProductVariant).save(variants, { reload: false });
-        this.eventBus.publish(new product_variant_event_1.ProductVariantEvent(ctx, variants, 'deleted', id));
-        return {
-            result: generated_types_1.DeletionResult.DELETED,
-        };
-    }
-    async hydratePriceFields(ctx, variant, priceField) {
-        const cacheKey = `hydrate-variant-price-fields-${variant.id}`;
-        let populatePricesPromise = this.requestCache.get(ctx, cacheKey);
-        if (!populatePricesPromise) {
-            populatePricesPromise = new Promise(async (resolve, reject) => {
-                var _a;
-                try {
-                    if (!((_a = variant.productVariantPrices) === null || _a === void 0 ? void 0 : _a.length)) {
-                        const variantWithPrices = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, variant.id, { relations: ['productVariantPrices'] });
-                        variant.productVariantPrices = variantWithPrices.productVariantPrices;
-                    }
-                    if (!variant.taxCategory) {
-                        const variantWithTaxCategory = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, variant.id, { relations: ['taxCategory'] });
-                        variant.taxCategory = variantWithTaxCategory.taxCategory;
-                    }
-                    resolve(await this.applyChannelPriceAndTax(variant, ctx));
-                }
-                catch (e) {
-                    reject(e);
-                }
-            });
-            this.requestCache.set(ctx, cacheKey, populatePricesPromise);
-        }
-        const hydratedVariant = await populatePricesPromise;
-        return hydratedVariant[priceField];
-    }
-    async applyChannelPriceAndTax(variant, ctx, order) {
-        return this.productPriceApplicator.applyChannelPriceAndTax(variant, ctx, order);
-    }
-    async assignProductVariantsToChannel(ctx, input) {
-        var _a;
-        const hasPermission = await this.roleService.userHasPermissionOnChannel(ctx, input.channelId, generated_types_1.Permission.UpdateCatalog);
-        if (!hasPermission) {
-            throw new errors_1.ForbiddenError();
-        }
-        const variants = await this.connection
-            .getRepository(ctx, product_variant_entity_1.ProductVariant)
-            .findByIds(input.productVariantIds, { relations: ['taxCategory', 'assets'] });
-        const priceFactor = input.priceFactor != null ? input.priceFactor : 1;
-        for (const variant of variants) {
-            if (variant.deletedAt) {
-                continue;
-            }
-            await this.applyChannelPriceAndTax(variant, ctx);
-            await this.channelService.assignToChannels(ctx, product_entity_1.Product, variant.productId, [input.channelId]);
-            await this.channelService.assignToChannels(ctx, product_variant_entity_1.ProductVariant, variant.id, [input.channelId]);
-            const targetChannel = await this.channelService.findOne(ctx, input.channelId);
-            const price = (targetChannel === null || targetChannel === void 0 ? void 0 : targetChannel.pricesIncludeTax) ? variant.priceWithTax : variant.price;
-            await this.createOrUpdateProductVariantPrice(ctx, variant.id, Math.round(price * priceFactor), input.channelId);
-            const assetIds = ((_a = variant.assets) === null || _a === void 0 ? void 0 : _a.map(a => a.assetId)) || [];
-            await this.assetService.assignToChannel(ctx, { channelId: input.channelId, assetIds });
-        }
-        const result = await this.findByIds(ctx, variants.map(v => v.id));
-        for (const variant of variants) {
-            this.eventBus.publish(new product_variant_channel_event_1.ProductVariantChannelEvent(ctx, variant, input.channelId, 'assigned'));
-        }
-        return result;
-    }
-    async removeProductVariantsFromChannel(ctx, input) {
-        const hasPermission = await this.roleService.userHasPermissionOnChannel(ctx, input.channelId, generated_types_1.Permission.UpdateCatalog);
-        if (!hasPermission) {
-            throw new errors_1.ForbiddenError();
-        }
-        const defaultChannel = await this.channelService.getDefaultChannel();
-        if (utils_1.idsAreEqual(input.channelId, defaultChannel.id)) {
-            throw new errors_1.UserInputError('error.products-cannot-be-removed-from-default-channel');
-        }
-        const variants = await this.connection
-            .getRepository(ctx, product_variant_entity_1.ProductVariant)
-            .findByIds(input.productVariantIds);
-        for (const variant of variants) {
-            await this.channelService.removeFromChannels(ctx, product_variant_entity_1.ProductVariant, variant.id, [input.channelId]);
-            await this.connection.getRepository(ctx, entity_1.ProductVariantPrice).delete({
-                channelId: input.channelId,
-                variant,
-            });
-            const productVariants = await this.connection.getRepository(ctx, product_variant_entity_1.ProductVariant).find({
-                where: {
-                    productId: variant.productId,
-                },
-                relations: ['channels'],
-            });
-            const productChannelsFromVariants = [].concat(...productVariants.map(pv => pv.channels));
-            if (!productChannelsFromVariants.find(c => c.id === input.channelId)) {
-                await this.channelService.removeFromChannels(ctx, product_entity_1.Product, variant.productId, [
-                    input.channelId,
-                ]);
-            }
-        }
-        const result = await this.findByIds(ctx, variants.map(v => v.id));
-        for (const variant of variants) {
-            this.eventBus.publish(new product_variant_channel_event_1.ProductVariantChannelEvent(ctx, variant, input.channelId, 'removed'));
-        }
-        return result;
-    }
-    async validateVariantOptionIds(ctx, input) {
-        const optionGroups = (await this.connection.getEntityOrThrow(ctx, product_entity_1.Product, input.productId, {
-            channelId: ctx.channelId,
-            relations: ['optionGroups', 'optionGroups.options'],
-            loadEagerRelations: false,
-        })).optionGroups;
-        const optionIds = input.optionIds || [];
-        if (optionIds.length !== optionGroups.length) {
-            this.throwIncompatibleOptionsError(optionGroups);
-        }
-        if (!samples_each_1.samplesEach(optionIds, optionGroups.map(g => g.options.map(o => o.id)))) {
-            this.throwIncompatibleOptionsError(optionGroups);
-        }
-        const product = await this.connection.getEntityOrThrow(ctx, product_entity_1.Product, input.productId, {
-            channelId: ctx.channelId,
-            relations: ['variants', 'variants.options'],
-            loadEagerRelations: false,
-        });
-        const inputOptionIds = this.sortJoin(optionIds, ',');
-        product.variants
-            .filter(v => !v.deletedAt)
-            .forEach(variant => {
-            const variantOptionIds = this.sortJoin(variant.options, ',', 'id');
-            if (variantOptionIds === inputOptionIds) {
-                throw new errors_1.UserInputError('error.product-variant-options-combination-already-exists', {
-                    variantName: translate_entity_1.translateDeep(variant, ctx.languageCode).name,
-                });
-            }
-        });
-    }
-    throwIncompatibleOptionsError(optionGroups) {
-        throw new errors_1.UserInputError('error.product-variant-option-ids-not-compatible', {
-            groupNames: this.sortJoin(optionGroups, ', ', 'code'),
-        });
-    }
-    sortJoin(arr, glue, prop) {
-        return arr
-            .map(x => (prop ? x[prop] : x))
-            .sort()
-            .join(glue);
-    }
-    async getTaxCategoryForNewVariant(ctx, taxCategoryId) {
-        var _a;
-        let taxCategory;
-        if (taxCategoryId) {
-            taxCategory = await this.connection.getEntityOrThrow(ctx, entity_1.TaxCategory, taxCategoryId);
-        }
-        else {
-            const taxCategories = await this.taxCategoryService.findAll(ctx);
-            taxCategory = (_a = taxCategories.find(t => t.isDefault === true)) !== null && _a !== void 0 ? _a : taxCategories[0];
-        }
-        if (!taxCategory) {
-            taxCategory = await this.taxCategoryService.create(ctx, { name: 'Standard Tax' });
-        }
-        return taxCategory;
-    }
-};
-ProductVariantService = __decorate([
-    common_1.Injectable(),
-    __metadata("design:paramtypes", [transactional_connection_1.TransactionalConnection,
-        config_service_1.ConfigService,
-        tax_category_service_1.TaxCategoryService,
-        facet_value_service_1.FacetValueService,
-        asset_service_1.AssetService,
-        translatable_saver_1.TranslatableSaver,
-        event_bus_1.EventBus,
-        list_query_builder_1.ListQueryBuilder,
-        global_settings_service_1.GlobalSettingsService,
-        stock_movement_service_1.StockMovementService,
-        channel_service_1.ChannelService,
-        role_service_1.RoleService,
-        custom_field_relation_service_1.CustomFieldRelationService,
-        request_context_cache_service_1.RequestContextCacheService,
-        product_price_applicator_1.ProductPriceApplicator])
-], ProductVariantService);
-exports.ProductVariantService = ProductVariantService;
-//# sourceMappingURL=product-variant.service.js.map