@haus-tech/product-import-export-plugin 3.0.5 → 3.0.6

package/dist/services/extended-fast-importer.service.d.ts

@@ -0,0 +1,44 @@
+import { Channel, ChannelService, EntityHydrator, ID, Product, ProductVariant, RequestContextService, StockMovementService, TransactionalConnection, TranslatableSaver } from '@vendure/core';
+import { CreateFacetInput, CreateFacetValueInput, CreateProductInput, CreateProductOptionGroupInput, CreateProductOptionInput, CreateProductVariantInput } from '@vendure/common/lib/generated-types';
+export declare class ExtendedFastImporterService {
+    private connection;
+    private channelService;
+    private stockMovementService;
+    private translatableSaver;
+    private requestContextService;
+    private entityHydrator;
+    private defaultChannel;
+    private importCtx;
+    /** @internal */
+    constructor(connection: TransactionalConnection, channelService: ChannelService, stockMovementService: StockMovementService, translatableSaver: TranslatableSaver, requestContextService: RequestContextService, entityHydrator: EntityHydrator);
+    /**
+     * @description
+     * This should be called prior to any of the import methods, as it establishes the
+     * default Channel as well as the context in which the new entities will be created.
+     *
+     * Passing a `channel` argument means that Products and ProductVariants will be assigned
+     * to that Channel.
+     */
+    initialize(channel?: Channel): Promise<void>;
+    updateProduct(id: ID, input: CreateProductInput & {
+        id: ID;
+    }): Promise<ID>;
+    removeAllAssetsFromProduct(product: Product): Promise<void>;
+    removeAllAssetsFromVariant(variant: ProductVariant): Promise<void>;
+    createProduct(input: CreateProductInput): Promise<ID>;
+    updateProductOptionGroup(input: CreateProductOptionGroupInput & {
+        id: ID;
+    }): Promise<ID>;
+    createProductOptionGroup(input: CreateProductOptionGroupInput): Promise<ID>;
+    createProductOption(input: CreateProductOptionInput): Promise<ID>;
+    addOptionGroupToProduct(productId: ID, optionGroupId: ID): Promise<void>;
+    createFacet(input: CreateFacetInput): Promise<ID>;
+    createFacetValue(input: CreateFacetValueInput): Promise<ID>;
+    addFacetValueToProduct(productId: ID, facetValueId: ID): Promise<void>;
+    addFacetValueToProductVariant(variantId: ID, facetValueId: ID): Promise<void>;
+    updateProductVariant(input: CreateProductVariantInput & {
+        id: ID;
+    }): Promise<ID>;
+    createProductVariant(input: CreateProductVariantInput): Promise<ID>;
+    private ensureInitialized;
+}

package/dist/services/extended-fast-importer.service.js

@@ -0,0 +1,474 @@
+"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.ExtendedFastImporterService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const normalize_string_1 = require("../helpers/normalize-string");
+const unique_1 = require("@vendure/common/lib/unique");
+const lodash_1 = require("lodash");
+let ExtendedFastImporterService = class ExtendedFastImporterService {
+    connection;
+    channelService;
+    stockMovementService;
+    translatableSaver;
+    requestContextService;
+    entityHydrator;
+    defaultChannel;
+    importCtx;
+    /** @internal */
+    constructor(connection, channelService, stockMovementService, translatableSaver, requestContextService, entityHydrator) {
+        this.connection = connection;
+        this.channelService = channelService;
+        this.stockMovementService = stockMovementService;
+        this.translatableSaver = translatableSaver;
+        this.requestContextService = requestContextService;
+        this.entityHydrator = entityHydrator;
+    }
+    /**
+     * @description
+     * This should be called prior to any of the import methods, as it establishes the
+     * default Channel as well as the context in which the new entities will be created.
+     *
+     * Passing a `channel` argument means that Products and ProductVariants will be assigned
+     * to that Channel.
+     */
+    async initialize(channel) {
+        this.importCtx = channel
+            ? await this.requestContextService.create({
+                apiType: 'admin',
+                channelOrToken: channel,
+            })
+            : core_1.RequestContext.empty();
+        this.defaultChannel = await this.channelService.getDefaultChannel(this.importCtx);
+    }
+    async updateProduct(id, input) {
+        this.ensureInitialized();
+        input.translations?.map((translation) => {
+            translation.slug = (0, normalize_string_1.normalizeString)(translation.slug, '-', translation.languageCode);
+        });
+        const product = await this.translatableSaver.update({
+            ctx: this.importCtx,
+            input,
+            entityType: core_1.Product,
+            translationType: core_1.ProductTranslation,
+            beforeSave: async (p) => {
+                await this.entityHydrator.hydrate(this.importCtx, p, { relations: ['channels'] });
+                p.channels = (0, unique_1.unique)([...p.channels, this.defaultChannel, this.importCtx.channel], 'id');
+                if (input.facetValueIds) {
+                    p.facetValues = input.facetValueIds.map((id) => ({ id }));
+                }
+                if (input.featuredAssetId) {
+                    p.featuredAsset = { id: input.featuredAssetId };
+                }
+            },
+        });
+        if (input.assetIds) {
+            const existingAssets = await this.connection
+                .getRepository(this.importCtx, core_1.ProductAsset)
+                .find({
+                where: { productId: id },
+            });
+            const newAssets = input.assetIds
+                .filter((id) => !existingAssets.some((asset) => asset.assetId === id))
+                .map((id, i) => new core_1.ProductAsset({ assetId: id, productId: product.id, position: i }));
+            await this.connection
+                .getRepository(this.importCtx, core_1.ProductAsset)
+                .save(newAssets, { reload: false });
+        }
+        return product.id;
+    }
+    async removeAllAssetsFromProduct(product) {
+        this.ensureInitialized();
+        await this.connection
+            .getRepository(this.importCtx, core_1.ProductAsset)
+            .delete({ productId: product.id });
+        product.featuredAsset = undefined;
+    }
+    async removeAllAssetsFromVariant(variant) {
+        this.ensureInitialized();
+        await this.connection
+            .getRepository(this.importCtx, core_1.ProductVariantAsset)
+            .delete({ productVariantId: variant.id });
+        variant.featuredAsset = undefined;
+    }
+    async createProduct(input) {
+        this.ensureInitialized();
+        // https://github.com/vendure-ecommerce/vendure/issues/2053
+        // normalizes slug without validation for faster performance
+        input.translations.map((translation) => {
+            translation.slug = (0, normalize_string_1.normalizeString)(translation.slug, '-', translation.languageCode);
+        });
+        const product = await this.translatableSaver.create({
+            ctx: this.importCtx,
+            input,
+            entityType: core_1.Product,
+            translationType: core_1.ProductTranslation,
+            beforeSave: async (p) => {
+                try {
+                    p.channels = (0, unique_1.unique)([this.defaultChannel, this.importCtx.channel], 'id');
+                    if (input.featuredAssetId) {
+                        p.featuredAsset = { id: input.featuredAssetId };
+                    }
+                }
+                catch (error) {
+                    console.log(error);
+                }
+            },
+        });
+        if (input.assetIds) {
+            const productAssets = input.assetIds.map((id, i) => new core_1.ProductAsset({
+                assetId: id,
+                productId: product.id,
+                position: i,
+            }));
+            await this.connection
+                .getRepository(this.importCtx, core_1.ProductAsset)
+                .save(productAssets, { reload: false });
+        }
+        return product.id;
+    }
+    async updateProductOptionGroup(input) {
+        this.ensureInitialized();
+        const group = await this.translatableSaver.update({
+            ctx: this.importCtx,
+            input: { ...(0, lodash_1.omit)(input, 'options') },
+            entityType: core_1.ProductOptionGroup,
+            translationType: core_1.ProductOptionGroupTranslation,
+            beforeSave: (group) => {
+                group.deletedAt = null;
+            },
+        });
+        return group.id;
+    }
+    async createProductOptionGroup(input) {
+        this.ensureInitialized();
+        const groupExists = await this.connection
+            .getRepository(this.importCtx, core_1.ProductOptionGroup)
+            .findOne({
+            where: { code: input.code },
+        });
+        if (groupExists) {
+            await this.translatableSaver.update({
+                ctx: this.importCtx,
+                input: { ...(0, lodash_1.omit)(input, 'options'), id: groupExists.id },
+                entityType: core_1.ProductOptionGroup,
+                translationType: core_1.ProductOptionGroupTranslation,
+                beforeSave: (group) => {
+                    group.deletedAt = null;
+                },
+            });
+            return groupExists.id;
+        }
+        const group = await this.translatableSaver.create({
+            ctx: this.importCtx,
+            input,
+            entityType: core_1.ProductOptionGroup,
+            translationType: core_1.ProductOptionGroupTranslation,
+        });
+        return group.id;
+    }
+    async createProductOption(input) {
+        this.ensureInitialized();
+        const optionsExist = await this.connection
+            .getRepository(this.importCtx, core_1.ProductOption)
+            .findOne({
+            where: { code: input.code, groupId: input.productOptionGroupId },
+        });
+        if (optionsExist) {
+            const updatedOption = await this.translatableSaver.update({
+                ctx: this.importCtx,
+                input: { ...input, id: optionsExist.id },
+                entityType: core_1.ProductOption,
+                translationType: core_1.ProductOptionTranslation,
+                beforeSave: (po) => {
+                    po.group = { id: input.productOptionGroupId };
+                    po.deletedAt = null;
+                },
+            });
+            return updatedOption.id;
+        }
+        const option = await this.translatableSaver.create({
+            ctx: this.importCtx,
+            input,
+            entityType: core_1.ProductOption,
+            translationType: core_1.ProductOptionTranslation,
+            beforeSave: (po) => {
+                po.group = { id: input.productOptionGroupId };
+                po.deletedAt = null;
+            },
+        });
+        return option.id;
+    }
+    async addOptionGroupToProduct(productId, optionGroupId) {
+        this.ensureInitialized();
+        await this.connection
+            .getRepository(this.importCtx, core_1.Product)
+            .createQueryBuilder()
+            .relation('optionGroups')
+            .of(productId)
+            .add(optionGroupId);
+    }
+    async createFacet(input) {
+        this.ensureInitialized();
+        const facetExists = await this.connection.getRepository(this.importCtx, core_1.Facet).findOne({
+            where: { code: input.code },
+            relations: ['channels', 'translations'],
+        });
+        if (facetExists) {
+            const facet = await this.translatableSaver.update({
+                ctx: this.importCtx,
+                input: { ...input, id: facetExists.id },
+                entityType: core_1.Facet,
+                translationType: core_1.FacetTranslation,
+                beforeSave: async (facet) => {
+                    await this.entityHydrator.hydrate(this.importCtx, facet, { relations: ['channels'] });
+                    facet.channels = (0, unique_1.unique)([...facet.channels, this.defaultChannel, this.importCtx.channel], 'id');
+                },
+            });
+            return facet.id;
+        }
+        const facet = await this.translatableSaver.create({
+            ctx: this.importCtx,
+            input,
+            entityType: core_1.Facet,
+            translationType: core_1.FacetTranslation,
+            beforeSave: async (facet) => {
+                facet.channels = (0, unique_1.unique)([this.defaultChannel, this.importCtx.channel], 'id');
+            },
+        });
+        return facet.id;
+    }
+    async createFacetValue(input) {
+        this.ensureInitialized();
+        const facetValueExists = await this.connection
+            .getRepository(this.importCtx, core_1.FacetValue)
+            .findOne({
+            where: { code: input.code },
+            relations: ['channels', 'translations'],
+        });
+        if (facetValueExists) {
+            const updatedFacetValue = await this.translatableSaver.update({
+                ctx: this.importCtx,
+                input: { ...input, id: facetValueExists.id },
+                entityType: core_1.FacetValue,
+                translationType: core_1.FacetValueTranslation,
+                beforeSave: async (facetValue) => {
+                    await this.entityHydrator.hydrate(this.importCtx, facetValue, { relations: ['channels'] });
+                    facetValue.facet = { id: input.facetId };
+                    facetValue.channels = (0, unique_1.unique)([...facetValue.channels, this.defaultChannel, this.importCtx.channel], 'id');
+                },
+            });
+            return updatedFacetValue.id;
+        }
+        const facetValue = await this.translatableSaver.create({
+            ctx: this.importCtx,
+            input,
+            entityType: core_1.FacetValue,
+            translationType: core_1.FacetValueTranslation,
+            beforeSave: async (facetValue) => {
+                facetValue.facet = { id: input.facetId };
+                facetValue.channels = (0, unique_1.unique)([this.defaultChannel, this.importCtx.channel], 'id');
+            },
+        });
+        return facetValue.id;
+    }
+    async addFacetValueToProduct(productId, facetValueId) {
+        this.ensureInitialized();
+        const existingRelation = await this.connection
+            .getRepository(this.importCtx, core_1.Product)
+            .createQueryBuilder()
+            .relation(core_1.Product, 'facetValues')
+            .of(productId)
+            .loadMany();
+        if (!existingRelation.some((relation) => relation.id === facetValueId)) {
+            await this.connection
+                .getRepository(this.importCtx, core_1.Product)
+                .createQueryBuilder()
+                .relation(core_1.Product, 'facetValues')
+                .of(productId)
+                .add(facetValueId);
+        }
+    }
+    async addFacetValueToProductVariant(variantId, facetValueId) {
+        this.ensureInitialized();
+        const existingRelation = await this.connection
+            .getRepository(this.importCtx, core_1.ProductVariant)
+            .createQueryBuilder()
+            .relation(core_1.ProductVariant, 'facetValues')
+            .of(variantId)
+            .loadMany();
+        if (!existingRelation.some((relation) => relation.id === facetValueId)) {
+            await this.connection
+                .getRepository(this.importCtx, core_1.ProductVariant)
+                .createQueryBuilder()
+                .relation(core_1.ProductVariant, 'facetValues')
+                .of(variantId)
+                .add(facetValueId);
+        }
+    }
+    async updateProductVariant(input) {
+        this.ensureInitialized();
+        if (!input.optionIds) {
+            input.optionIds = [];
+        }
+        if (input.price == null) {
+            input.price = 0;
+        }
+        const inputWithoutPrice = {
+            ...input,
+        };
+        delete inputWithoutPrice.price;
+        const updatedVariant = await this.translatableSaver.update({
+            ctx: this.importCtx,
+            input: inputWithoutPrice,
+            entityType: core_1.ProductVariant,
+            translationType: core_1.ProductVariantTranslation,
+            beforeSave: async (variant) => {
+                await this.entityHydrator.hydrate(this.importCtx, variant, { relations: ['channels'] });
+                variant.channels = (0, unique_1.unique)([...variant.channels, this.defaultChannel, this.importCtx.channel], 'id');
+                const { optionIds } = input;
+                if (optionIds && optionIds.length) {
+                    variant.options = optionIds.map((id) => ({ id }));
+                }
+                if (input.facetValueIds) {
+                    variant.facetValues = input.facetValueIds.map((id) => ({ id }));
+                }
+                variant.product = { id: input.productId };
+                variant.taxCategory = { id: input.taxCategoryId };
+                if (input.featuredAssetId) {
+                    variant.featuredAsset = { id: input.featuredAssetId };
+                }
+            },
+        });
+        if (input.assetIds) {
+            const existingAssets = await this.connection
+                .getRepository(this.importCtx, core_1.ProductVariantAsset)
+                .find({
+                where: { productVariantId: input.id },
+            });
+            const newAssets = input.assetIds
+                .filter((id) => !existingAssets.some((asset) => asset.assetId === id))
+                .map((id, i) => new core_1.ProductVariantAsset({
+                assetId: id,
+                productVariantId: updatedVariant.id,
+                position: i,
+            }));
+            await this.connection
+                .getRepository(this.importCtx, core_1.ProductVariantAsset)
+                .save(newAssets, { reload: false });
+        }
+        await this.stockMovementService.adjustProductVariantStock(this.importCtx, updatedVariant.id, input.stockOnHand ?? 0);
+        const assignedChannelIds = (0, unique_1.unique)([this.defaultChannel, this.importCtx.channel], 'id').map((c) => c.id);
+        for (const channelId of assignedChannelIds) {
+            const allPrices = await this.connection
+                .getRepository(this.importCtx, core_1.ProductVariantPrice)
+                .find({
+                where: {
+                    variant: { id: updatedVariant.id },
+                },
+            });
+            let existingVariantPrice = allPrices.find((p) => (0, core_1.idsAreEqual)(p.channelId, channelId) &&
+                p.currencyCode === this.importCtx.channel.defaultCurrencyCode);
+            if (!existingVariantPrice) {
+                const variantPrice = new core_1.ProductVariantPrice({
+                    price: input.price,
+                    channelId,
+                    currencyCode: this.importCtx.channel.defaultCurrencyCode,
+                });
+                variantPrice.variant = updatedVariant;
+                await this.connection.rawConnection
+                    .getRepository(core_1.ProductVariantPrice)
+                    .save(variantPrice, { reload: false });
+            }
+            else {
+                existingVariantPrice.price = input.price;
+                await this.connection.rawConnection
+                    .getRepository(core_1.ProductVariantPrice)
+                    .save(existingVariantPrice, { reload: false });
+            }
+        }
+        return updatedVariant.id;
+    }
+    async createProductVariant(input) {
+        this.ensureInitialized();
+        if (!input.optionIds) {
+            input.optionIds = [];
+        }
+        if (input.price == null) {
+            input.price = 0;
+        }
+        const inputWithoutPrice = {
+            ...input,
+        };
+        delete inputWithoutPrice.price;
+        const createdVariant = await this.translatableSaver.create({
+            ctx: this.importCtx,
+            input: inputWithoutPrice,
+            entityType: core_1.ProductVariant,
+            translationType: core_1.ProductVariantTranslation,
+            beforeSave: async (variant) => {
+                variant.channels = (0, unique_1.unique)([this.defaultChannel, this.importCtx.channel], 'id');
+                const { optionIds } = input;
+                if (optionIds && optionIds.length) {
+                    variant.options = optionIds.map((id) => ({ id }));
+                }
+                if (input.facetValueIds) {
+                    variant.facetValues = input.facetValueIds.map((id) => ({ id }));
+                }
+                variant.product = { id: input.productId };
+                variant.taxCategory = { id: input.taxCategoryId };
+                if (input.featuredAssetId) {
+                    variant.featuredAsset = { id: input.featuredAssetId };
+                }
+            },
+        });
+        if (input.assetIds) {
+            const variantAssets = input.assetIds.map((id, i) => new core_1.ProductVariantAsset({
+                assetId: id,
+                productVariantId: createdVariant.id,
+                position: i,
+            }));
+            await this.connection
+                .getRepository(this.importCtx, core_1.ProductVariantAsset)
+                .save(variantAssets, { reload: false });
+        }
+        await this.stockMovementService.adjustProductVariantStock(this.importCtx, createdVariant.id, input.stockOnHand ?? 0);
+        const assignedChannelIds = (0, unique_1.unique)([this.defaultChannel, this.importCtx.channel], 'id').map((c) => c.id);
+        for (const channelId of assignedChannelIds) {
+            const variantPrice = new core_1.ProductVariantPrice({
+                price: input.price,
+                channelId,
+                currencyCode: this.importCtx.channel.defaultCurrencyCode,
+            });
+            variantPrice.variant = createdVariant;
+            await this.connection.rawConnection
+                .getRepository(core_1.ProductVariantPrice)
+                .save(variantPrice, { reload: false });
+        }
+        return createdVariant.id;
+    }
+    ensureInitialized() {
+        if (!this.defaultChannel || !this.importCtx) {
+            throw new Error("The FastImporterService must be initialized with a call to 'initialize()' before importing data");
+        }
+    }
+};
+ExtendedFastImporterService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection,
+        core_1.ChannelService,
+        core_1.StockMovementService,
+        core_1.TranslatableSaver,
+        core_1.RequestContextService,
+        core_1.EntityHydrator])
+], ExtendedFastImporterService);
+exports.ExtendedFastImporterService = ExtendedFastImporterService;

package/dist/services/product-export.service.d.ts

@@ -0,0 +1,23 @@
+import { EntityHydrator, ID, ProductService, RequestContext, StockLevelService, ChannelService, ConfigService } from '@vendure/core';
+import { PluginInitOptions } from '../types';
+export type RelationType = 'string' | 'boolean' | 'localeString' | 'text' | 'localeText' | 'int' | 'float' | 'datetime' | 'relation';
+export declare class ProductExportService {
+    private options;
+    private productService;
+    private stockLevelService;
+    private entityHydratorService;
+    private channelService;
+    private configService;
+    constructor(options: PluginInitOptions, productService: ProductService, stockLevelService: StockLevelService, entityHydratorService: EntityHydrator, channelService: ChannelService, configService: ConfigService);
+    createExportFile(ctx: RequestContext, selectionIds: ID[], fileName: string, selectedCustomFields: string, exportAssetsAs: 'url' | 'json', selectedExportFields: string): Promise<string>;
+    private handleAssets;
+    private handleCustomFields;
+    private getStockOnHand;
+    private mapTranslations;
+    private mapFacetTranslations;
+    getCustomFields(ctx: RequestContext, productIds: string[]): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    getConfig(): Promise<PluginInitOptions>;
+}