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

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

@@ -1,44 +0,0 @@
-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

@@ -1,462 +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.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,
-        });
-        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,
-            });
-            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 }),
-            });
-            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 }),
-        });
-        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

@@ -1,23 +0,0 @@
-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>;
-}