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

package/dist/providers/import-providers/product-importer.js

@@ -1,753 +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.ProductImporter = void 0;
-const common_1 = require("@nestjs/common");
-const core_1 = require("@vendure/core");
-const rxjs_1 = require("rxjs");
-const extended_fast_importer_service_1 = require("../../services/extended-fast-importer.service");
-const lodash_1 = require("lodash");
-const normalize_string_1 = require("../../helpers/normalize-string");
-const import_parser_1 = require("./import-parser");
-const asset_importer_1 = require("./asset-importer");
-const typeorm_1 = require("typeorm");
-const generate_asset_hash_1 = require("../../helpers/generate-asset-hash");
-const crypto_1 = require("crypto");
-const remove_update_at_fields_1 = require("../../helpers/remove-update-at-fields");
-let ProductImporter = class ProductImporter {
-    connection;
-    configService;
-    importParser;
-    assetImporter;
-    fastImporter;
-    translatableSaver;
-    productService;
-    channelService;
-    facetService;
-    facetValueService;
-    taxCategoryService;
-    assetService;
-    optionGroupService;
-    taxCategoryMatches = {};
-    facetMap = new Map();
-    facetValueMap = new Map();
-    customFieldTypes = {};
-    allAssets = [];
-    constructor(connection, configService, importParser, assetImporter, fastImporter, translatableSaver, productService, channelService, facetService, facetValueService, taxCategoryService, assetService, optionGroupService) {
-        this.connection = connection;
-        this.configService = configService;
-        this.importParser = importParser;
-        this.assetImporter = assetImporter;
-        this.fastImporter = fastImporter;
-        this.translatableSaver = translatableSaver;
-        this.productService = productService;
-        this.channelService = channelService;
-        this.facetService = facetService;
-        this.facetValueService = facetValueService;
-        this.taxCategoryService = taxCategoryService;
-        this.assetService = assetService;
-        this.optionGroupService = optionGroupService;
-    }
-    parseAndImport(input, ctx, updateProductSlug = true, mainLanguage, updatingStrategy) {
-        return new rxjs_1.Observable((subscriber) => {
-            const p = this.doParseAndImport(input, updateProductSlug, mainLanguage, updatingStrategy, ctx, (progress) => {
-                subscriber.next(progress);
-            }).then((value) => {
-                subscriber.next({ ...value, currentProduct: 'Complete' });
-                subscriber.complete();
-            });
-        });
-    }
-    extractProductIdsFromCSV(csvString) {
-        // Split the CSV string into lines
-        const lines = csvString.split('\n');
-        // Initialize an array to hold the product IDs
-        const productIds = [];
-        // Loop through each line in the CSV
-        lines.forEach((line, index) => {
-            if (index === 0)
-                return; // Skip header row
-            const columns = line.split(',');
-            const productId = columns[0].trim();
-            if (productId) {
-                productIds.push(parseInt(productId, 10));
-            }
-            else {
-                productIds.push(null); // Push null or undefined if productId is missing
-            }
-        });
-        return productIds;
-    }
-    preprocessCsv(input, updateProductSlug) {
-        const customFieldTypes = {};
-        const lines = input.split('\n');
-        // Filter out empty lines (lines that are either blank or just commas)
-        const filteredLines = lines.filter((line) => {
-            const trimmed = line.trim();
-            return trimmed !== '' && !/^,+$/.test(trimmed); // Keep lines that are not empty or comma-only
-        });
-        const splitLines = (text) => {
-            // Split text by commas, but not if comma is inside double quotes
-            const splittedText = text.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);
-            return splittedText;
-        };
-        const headers = splitLines(filteredLines[0]); // Use splitCsvLine to split headers correctly
-        const cleanedHeaders = headers.map((header) => {
-            if (header.startsWith('product:') || header.startsWith('variant:')) {
-                const parts = header.split(':');
-                if (parts.length === 3) {
-                    const [prefix, fieldName, type] = parts;
-                    const fullFieldName = `${prefix}:${fieldName}`;
-                    customFieldTypes[fullFieldName] = type.trim();
-                    return fullFieldName;
-                }
-            }
-            return header;
-        });
-        // Recreate the CSV with cleaned headers
-        filteredLines[0] = cleanedHeaders.join(',');
-        // If the updateProductSlug flag is set, find all slug columns and set their values to an empty string.
-        if (updateProductSlug) {
-            const slugIndices = cleanedHeaders
-                .map((header, index) => (header.includes('slug') ? index : -1))
-                .filter((index) => index !== -1); // Get all indices of columns that contain 'slug'
-            if (slugIndices.length > 0) {
-                filteredLines.forEach((line, index) => {
-                    if (index === 0)
-                        return; // Skip header row
-                    const columns = splitLines(line); // Use splitCsvLine to split the data line correctly
-                    slugIndices.forEach((slugIndex) => {
-                        columns[slugIndex] = ''; // Clear each slug column
-                    });
-                    filteredLines[index] = columns.join(','); // Reassemble the line
-                });
-            }
-        }
-        return {
-            cleanedCsv: filteredLines.join('\n'),
-            customFieldTypes,
-        };
-    }
-    async streamToString(stream) {
-        const chunks = [];
-        return new Promise((resolve, reject) => {
-            stream.on('data', (chunk) => chunks.push(chunk));
-            stream.on('error', reject);
-            stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-        });
-    }
-    async getAllAssets(ctx) {
-        let offset = 0;
-        const limit = 100;
-        const assets = [];
-        let totalItems = 0;
-        do {
-            const paginatedAssets = await this.assetService.findAll(ctx, { take: limit, skip: offset });
-            assets.push(...paginatedAssets.items);
-            totalItems = paginatedAssets.totalItems;
-            offset += limit;
-        } while (assets.length < totalItems);
-        return assets;
-    }
-    async setMissingAssetHashes(ctx) {
-        const assets = await this.getAllAssets(ctx);
-        const assetsWithoutHash = assets.filter((asset) => !asset.customFields.hash);
-        for (const asset of assetsWithoutHash) {
-            const hash = (0, generate_asset_hash_1.generateAssetHash)(asset);
-            if (asset.customFields.hash !== hash) {
-                asset.customFields.hash = hash;
-                await this.connection.getRepository(ctx, core_1.Asset).save(asset);
-            }
-        }
-        this.allAssets = assets;
-    }
-    async doParseAndImport(input, updateProductSlug, mainLanguage, updatingStrategy, reqCtx, onProgress) {
-        const ctx = await this.getRequestContext(reqCtx, mainLanguage);
-        await this.setMissingAssetHashes(ctx);
-        let csvContent;
-        if (typeof input === 'string') {
-            csvContent = input;
-        }
-        else {
-            // If input is a Stream, you need to read it fully into memory
-            csvContent = await this.streamToString(input);
-        }
-        // Preprocess the CSV to extract types and clean headers
-        const { cleanedCsv, customFieldTypes } = this.preprocessCsv(csvContent, updateProductSlug);
-        this.customFieldTypes = customFieldTypes;
-        const parsed = (await this.importParser.parseProducts(cleanedCsv, ctx.languageCode));
-        const productIds = this.extractProductIdsFromCSV(cleanedCsv);
-        parsed.results.forEach((result, index) => {
-            const productId = productIds[index];
-            if (productId !== null) {
-                result.product.productId = productId;
-            }
-            // Handle the case where productId is null if necessary
-        });
-        if (parsed && parsed.results.length) {
-            try {
-                const importErrors = await this.importProducts(ctx, parsed.results, updatingStrategy, (progess) => {
-                    onProgress({
-                        ...progess,
-                        processed: parsed.processed,
-                    });
-                });
-                return {
-                    errors: parsed.errors.concat(importErrors),
-                    imported: parsed.results.length,
-                    processed: parsed.processed,
-                };
-            }
-            catch (err) {
-                core_1.Logger.error('Error while importing products:', 'ProductImporter', err?.stack);
-                return {
-                    errors: [err.message],
-                    imported: 0,
-                    processed: parsed.processed,
-                };
-            }
-        }
-        else {
-            return {
-                errors: parsed.errors,
-                imported: 0,
-                processed: parsed.processed,
-            };
-        }
-    }
-    async getRequestContext(ctx, mainLanguage) {
-        if (ctx instanceof core_1.RequestContext) {
-            return new core_1.RequestContext({
-                apiType: 'admin',
-                isAuthorized: true,
-                authorizedAsOwnerOnly: false,
-                channel: ctx.channel,
-                languageCode: mainLanguage,
-            });
-        }
-        else {
-            throw new core_1.InternalServerError('No RequestContext provided');
-        }
-    }
-    async importProducts(ctx, rows, updatingStrategy, onProgress) {
-        let errors = [];
-        let imported = 0;
-        const languageCode = ctx.languageCode;
-        const taxCategories = await this.taxCategoryService.findAll(ctx);
-        // Create taxCategory if none exists
-        if (taxCategories.totalItems === 0) {
-            await this.taxCategoryService.create(ctx, {
-                name: 'Standard Tax',
-                isDefault: true,
-            });
-        }
-        await this.fastImporter.initialize(ctx.channel);
-        for (const { product, variants } of rows) {
-            const productMainTranslation = this.getTranslationByCodeOrFirst(product.translations, ctx.languageCode);
-            const assetsToImport = (0, lodash_1.compact)(product.assetPaths.map((assetPath, idx) => {
-                const assetID = product.assetsJson?.[idx]?.id;
-                if (assetPath.startsWith('http://') || assetPath.startsWith('https://')) {
-                    return {
-                        url: assetPath,
-                        name: product.assetsJson?.[idx]?.name || undefined,
-                        id: assetID && this.allAssets.find((a) => a.id === assetID)
-                            ? product.assetsJson?.[idx]?.id
-                            : undefined,
-                    };
-                }
-            }));
-            const createProductAssets = await this.assetImporter.getAssets(assetsToImport, ctx);
-            const productAssets = createProductAssets.assets;
-            if (createProductAssets.errors.length) {
-                errors = errors.concat(createProductAssets.errors);
-            }
-            const customFields = await this.processCustomFieldValues(product.translations[0].customFields, this.configService.customFields.Product, ctx);
-            let checkExistingProduct;
-            if (product.productId) {
-                checkExistingProduct = await this.productService.findOne(ctx, product.productId);
-            }
-            if (!checkExistingProduct) {
-                const variantSkus = variants.map((v) => v.sku);
-                const foundVariants = await this.connection.getRepository(ctx, core_1.ProductVariant).findBy({
-                    sku: (0, typeorm_1.In)(variantSkus),
-                });
-                if (foundVariants.length) {
-                    checkExistingProduct = { id: foundVariants[0].productId };
-                }
-            }
-            const existingProduct = await this.getProductByIdWithRelations(ctx, checkExistingProduct?.id);
-            try {
-                if (existingProduct?.deletedAt) {
-                    existingProduct.deletedAt = null;
-                    try {
-                        await this.connection.getRepository(ctx, core_1.Product).save([existingProduct]);
-                    }
-                    catch (error) {
-                        errors.push(`Error while restoring the product: ${error}`);
-                        core_1.Logger.error('Error while restoring the product:', 'ProductImporter', error?.stack);
-                    }
-                }
-            }
-            catch (error) {
-                errors.push(`Error while restoring the product: ${error}`);
-                core_1.Logger.error('Error while restoring the product:', 'ProductImporter', error?.stack);
-            }
-            const existingProductName = existingProduct?.translations.find((t) => t.languageCode === languageCode)?.name;
-            const productNameHasChanged = existingProduct && existingProductName !== productMainTranslation.name
-                ? {
-                    name: productMainTranslation.name,
-                    previousName: existingProductName,
-                    normalizedName: (0, normalize_string_1.normalizeString)(productMainTranslation.name, '-', languageCode),
-                    previousNormalizedName: (0, normalize_string_1.normalizeString)(existingProductName),
-                }
-                : undefined;
-            if (existingProduct && updatingStrategy === 'replace') {
-                await this.fastImporter.removeAllAssetsFromProduct(existingProduct);
-            }
-            const productData = {
-                featuredAssetId: existingProduct?.featuredAsset
-                    ? undefined
-                    : productAssets.length
-                        ? productAssets[0].id
-                        : undefined,
-                assetIds: productAssets.map((a) => a.id),
-                facetValueIds: updatingStrategy === 'replace' ? [] : undefined,
-                translations: await Promise.all(product.translations.map(async (translation) => {
-                    return {
-                        languageCode: translation.languageCode,
-                        name: translation.name,
-                        description: translation.description,
-                        slug: translation.slug,
-                        customFields: await this.processCustomFieldValues(translation.customFields, this.configService.customFields.Product, ctx),
-                    };
-                })),
-                customFields,
-            };
-            const createdProductId = existingProduct
-                ? await this.fastImporter.updateProduct(existingProduct.id, {
-                    ...productData,
-                    id: existingProduct.id,
-                })
-                : await this.fastImporter.createProduct(productData);
-            for (const facet of product.facets) {
-                const facetMainTranslation = this.getTranslationByCodeOrFirst(facet.translations, ctx.languageCode);
-                const code = (0, normalize_string_1.normalizeString)(facetMainTranslation.facet, '-', facetMainTranslation.languageCode);
-                const valueCode = (0, normalize_string_1.normalizeString)(facetMainTranslation.value, '-', facetMainTranslation.languageCode);
-                const facetValueId = await this.createFacetAndValue(facet, code, valueCode);
-                await this.fastImporter.addFacetValueToProduct(createdProductId, facetValueId);
-            }
-            const optionsMap = {};
-            for (const [optionGroup, optionGroupIndex] of product.optionGroups.map((group, i) => [group, i])) {
-                const optionGroupMainTranslation = this.getTranslationByCodeOrFirst(optionGroup.translations, ctx.languageCode);
-                const code = (0, normalize_string_1.normalizeString)(`${productMainTranslation.name}-${optionGroupMainTranslation.name}`, '-', optionGroupMainTranslation.languageCode);
-                const productOptionsGroups = await this.optionGroupService.getOptionGroupsByProductId(ctx, createdProductId);
-                const previousCode = (0, normalize_string_1.normalizeString)(`${productNameHasChanged?.previousName}-${optionGroupMainTranslation.name}`, '-', optionGroupMainTranslation.languageCode);
-                const foundOptionGroup = productOptionsGroups.find((group) => group.code === previousCode);
-                let groupId = foundOptionGroup
-                    ? await this.fastImporter.updateProductOptionGroup({
-                        id: foundOptionGroup.id,
-                        code,
-                        options: optionGroupMainTranslation.values.map((name) => ({})),
-                        translations: optionGroup.translations
-                            .map((translation) => {
-                            return {
-                                languageCode: translation.languageCode,
-                                name: translation.name,
-                            };
-                        })
-                            .filter((t) => t.name),
-                    })
-                    : await this.fastImporter.createProductOptionGroup({
-                        code,
-                        options: optionGroupMainTranslation.values.map((name) => ({})),
-                        translations: optionGroup.translations
-                            .map((translation) => {
-                            return {
-                                languageCode: translation.languageCode,
-                                name: translation.name,
-                            };
-                        })
-                            .filter((t) => t.name),
-                    });
-                for (const [optionIndex, value] of optionGroupMainTranslation.values.map((val, index) => [index, val])) {
-                    const createdOptionId = await this.fastImporter.createProductOption({
-                        productOptionGroupId: groupId,
-                        code: (0, normalize_string_1.normalizeString)(value, '-', optionGroupMainTranslation.languageCode),
-                        translations: optionGroup.translations
-                            .map((translation) => {
-                            return {
-                                languageCode: translation.languageCode,
-                                name: translation.values[optionIndex],
-                            };
-                        })
-                            .filter((t) => t.name),
-                    });
-                    optionsMap[`${optionGroupIndex}_${value}`] = createdOptionId;
-                }
-                await this.fastImporter.addOptionGroupToProduct(createdProductId, groupId);
-            }
-            for (const variant of variants) {
-                const variantMainTranslation = this.getTranslationByCodeOrFirst(variant.translations, ctx.languageCode);
-                const assetsToImport = (0, lodash_1.compact)(variant.assetPaths.map((assetPath, idx) => {
-                    const assetID = variant.assetsJson?.[idx]?.id;
-                    if (assetPath.startsWith('http://') || assetPath.startsWith('https://')) {
-                        return {
-                            url: assetPath,
-                            name: variant.assetsJson?.[idx]?.name || undefined,
-                            id: assetID && this.allAssets.find((a) => a.id === assetID)
-                                ? variant.assetsJson?.[idx]?.id
-                                : undefined,
-                        };
-                    }
-                }));
-                const createVariantAssets = await this.assetImporter.getAssets(assetsToImport);
-                const variantAssets = createVariantAssets.assets;
-                if (createVariantAssets.errors.length) {
-                    errors = errors.concat(createVariantAssets.errors);
-                }
-                let facetValueIds = [];
-                if (0 < variant.facets.length) {
-                    facetValueIds = await this.getFacetValueIds(ctx, variant.facets, languageCode);
-                }
-                const variantCustomFields = await this.processCustomFieldValues(variantMainTranslation.customFields, this.configService.customFields.ProductVariant, ctx);
-                const optionIds = variantMainTranslation.optionValues.map((v, index) => optionsMap[`${index}_${v}`]);
-                const existingVariant = await this.connection.getRepository(ctx, core_1.ProductVariant).findOne({
-                    where: {
-                        sku: variant.sku,
-                    },
-                    withDeleted: true,
-                    relations: ['facetValues', 'facetValues.facet', 'assets', 'featuredAsset'],
-                });
-                if (existingVariant?.deletedAt) {
-                    existingVariant.deletedAt = null;
-                    try {
-                        await this.connection.getRepository(ctx, core_1.ProductVariant).save([existingVariant]);
-                    }
-                    catch (error) {
-                        errors.push(`Error while restoring the variant: ${error}`);
-                        core_1.Logger.error('Error while restoring the variant:', 'ProductImporter', error?.stack);
-                    }
-                }
-                if (existingVariant && updatingStrategy === 'replace') {
-                    // Remove all assets from the product
-                    await this.fastImporter.removeAllAssetsFromVariant(existingVariant);
-                }
-                const variantData = {
-                    productId: createdProductId,
-                    facetValueIds: updatingStrategy === 'replace' ? [] : undefined,
-                    featuredAssetId: existingVariant?.featuredAsset
-                        ? undefined
-                        : variantAssets.length
-                            ? variantAssets[0].id
-                            : undefined,
-                    assetIds: variantAssets.map((a) => a.id),
-                    sku: variant.sku,
-                    taxCategoryId: this.getMatchingTaxCategoryId(variant.taxCategory, taxCategories.items),
-                    stockOnHand: variant.stockOnHand,
-                    trackInventory: variant.trackInventory,
-                    optionIds,
-                    translations: await Promise.all(variant.translations.map(async (translation) => {
-                        const productTranslation = product.translations.find((t) => t.languageCode === translation.languageCode);
-                        if (!productTranslation) {
-                            throw new core_1.InternalServerError(`No translation '${translation.languageCode}' for product with slug '${productMainTranslation.slug}'`);
-                        }
-                        return {
-                            languageCode: translation.languageCode,
-                            name: [productTranslation.name, ...translation.optionValues].join(' '),
-                            customFields: await this.processCustomFieldValues(translation.customFields, this.configService.customFields.ProductVariant, ctx),
-                        };
-                    })),
-                    price: Math.round(variant.price * 100),
-                    customFields: variantCustomFields,
-                };
-                const createdVariantId = existingVariant
-                    ? await this.fastImporter.updateProductVariant({ ...variantData, id: existingVariant.id })
-                    : await this.fastImporter.createProductVariant(variantData);
-                for (const facet of variant.facets) {
-                    const facetMainTranslation = this.getTranslationByCodeOrFirst(facet.translations, ctx.languageCode);
-                    const code = (0, normalize_string_1.normalizeString)(facetMainTranslation.facet, '-', facetMainTranslation.languageCode);
-                    const valueCode = (0, normalize_string_1.normalizeString)(facetMainTranslation.value, '-', facetMainTranslation.languageCode);
-                    const facetValueId = await this.createFacetAndValue(facet, code, valueCode);
-                    await this.fastImporter.addFacetValueToProductVariant(createdVariantId, facetValueId);
-                }
-            }
-            if (existingProduct) {
-                const productAfterUpdate = (await this.getProductByIdWithRelations(ctx, createdProductId)); // We know that the product exists, so we can safely cast it to Product
-                const existingProductHash = (0, crypto_1.createHash)('md5')
-                    .update(JSON.stringify((0, remove_update_at_fields_1.removeUpdatedAtFields)(existingProduct)))
-                    .digest('hex');
-                const productAfterUpdateHash = (0, crypto_1.createHash)('md5')
-                    .update(JSON.stringify((0, remove_update_at_fields_1.removeUpdatedAtFields)(productAfterUpdate)))
-                    .digest('hex');
-                // Update product updatedAt to existing product updatedAt
-                if (existingProductHash === productAfterUpdateHash) {
-                    await this.connection.getRepository(ctx, core_1.Product).update(productAfterUpdate.id, {
-                        updatedAt: existingProduct.updatedAt,
-                    });
-                }
-            }
-            imported++;
-            onProgress({
-                processed: 0,
-                imported,
-                errors,
-                currentProduct: productMainTranslation.name,
-            });
-        }
-        return errors;
-    }
-    async getFacetValueIds(ctx, facets, languageCode) {
-        const facetValueIds = [];
-        for (const item of facets) {
-            const itemMainTranslation = this.getTranslationByCodeOrFirst(item.translations, languageCode);
-            const facetName = itemMainTranslation.facet;
-            const valueName = itemMainTranslation.value;
-            let facetEntity;
-            const cachedFacet = this.facetMap.get(facetName);
-            if (cachedFacet) {
-                facetEntity = cachedFacet;
-            }
-            else {
-                const existing = await this.facetService.findByCode(ctx, (0, normalize_string_1.normalizeString)(facetName, '-', languageCode), languageCode);
-                if (existing) {
-                    facetEntity = existing;
-                }
-                else {
-                    facetEntity = await this.facetService.create(ctx, {
-                        isPrivate: false,
-                        code: (0, normalize_string_1.normalizeString)(facetName, '-', languageCode),
-                        translations: item.translations.map((translation) => {
-                            return {
-                                languageCode: translation.languageCode,
-                                name: translation.facet,
-                            };
-                        }),
-                    });
-                }
-                this.facetMap.set(facetName, facetEntity);
-            }
-            let facetValueEntity;
-            const facetValueMapKey = `${facetName}:${valueName}`;
-            const cachedFacetValue = this.facetValueMap.get(facetValueMapKey);
-            if (cachedFacetValue) {
-                facetValueEntity = cachedFacetValue;
-            }
-            else {
-                const existing = facetEntity.values.find((v) => (0, normalize_string_1.normalizeString)(v.name, '-') === (0, normalize_string_1.normalizeString)(valueName, '-', languageCode));
-                if (existing) {
-                    facetValueEntity = existing;
-                }
-                else {
-                    facetValueEntity = await this.facetValueService.create(ctx, facetEntity, {
-                        code: (0, normalize_string_1.normalizeString)(valueName, '-', languageCode),
-                        translations: item.translations.map((translation) => {
-                            return {
-                                languageCode: translation.languageCode,
-                                name: translation.value,
-                            };
-                        }),
-                    });
-                }
-                this.facetValueMap.set(facetValueMapKey, facetValueEntity);
-            }
-            facetValueIds.push(facetValueEntity.id);
-        }
-        return facetValueIds;
-    }
-    async processCustomFieldValues(customFields, config, ctx) {
-        function parseBoolean(input) {
-            if (input == null) {
-                return false;
-            }
-            switch (input.toLowerCase()) {
-                case 'true':
-                case '1':
-                case 'yes':
-                    return true;
-                default:
-                    return false;
-            }
-        }
-        const processed = {};
-        for (const fieldDef of config) {
-            const foundCustomFieldType = (0, lodash_1.find)(this.customFieldTypes, (_type, key) => key.split(':')[1] === fieldDef.name);
-            const value = customFields[fieldDef.name];
-            if (fieldDef.list === true) {
-                processed[fieldDef.name] = value?.split('|').filter((val) => val.trim() !== '');
-            }
-            else if (fieldDef.type === 'boolean') {
-                processed[fieldDef.name] = parseBoolean(value);
-            }
-            else if (fieldDef.type === 'relation') {
-                if (foundCustomFieldType === 'asset') {
-                    // Asset if of type json
-                    if ((0, lodash_1.startsWith)(value, '{') || (0, lodash_1.startsWith)(value, '[')) {
-                        if (typeof value === 'string') {
-                            const assetValue = JSON.parse(value.replace(/'/g, '"').replace(/\s+/g, ' ').replace(/,\s*'/g, ", '"));
-                            if (Array.isArray(assetValue)) {
-                                assetValue.forEach(async (asset) => {
-                                    if (asset.url.startsWith('http://') || asset.url.startsWith('https://')) {
-                                        const createdAssets = await this.assetImporter.getAssets([], ctx);
-                                        processed[fieldDef.name] = createdAssets.assets[0]?.id;
-                                    }
-                                    const foundAsset = this.allAssets.find((a) => a.id === asset.id);
-                                    if (foundAsset && foundAsset.name !== asset.name) {
-                                        this.connection.getRepository(ctx, core_1.Asset).update(foundAsset.id, {
-                                            name: asset.name,
-                                        });
-                                    }
-                                });
-                            }
-                            else {
-                                if (assetValue.url.startsWith('http://') || assetValue.url.startsWith('https://')) {
-                                    const createdAssets = await this.assetImporter.getAssets([assetValue], ctx);
-                                    processed[fieldDef.name] = createdAssets.assets[0]?.id;
-                                }
-                                const foundAsset = this.allAssets.find((a) => a.id === assetValue.id);
-                                if (foundAsset && foundAsset.name !== assetValue.name) {
-                                    this.connection.getRepository(ctx, core_1.Asset).update(foundAsset.id, {
-                                        name: assetValue.name,
-                                    });
-                                }
-                            }
-                        }
-                        // Asset if of type string
-                    }
-                    else {
-                        if (value.startsWith('http://') || value.startsWith('https://')) {
-                            // If value is an external URL, we need to import the asset
-                            const createdAssets = await this.assetImporter.getAssets([{ url: value }], ctx);
-                            processed[fieldDef.name] = createdAssets.assets[0]?.id;
-                        }
-                    }
-                }
-                else {
-                    processed[fieldDef.name] = value ? value : undefined;
-                }
-            }
-            else {
-                if ((0, lodash_1.startsWith)(value, '{') || (0, lodash_1.startsWith)(value, '[')) {
-                    if (typeof value === 'string') {
-                        processed[fieldDef.name] = value.replace(/'/g, '"').replace(/\s+/g, ' ');
-                    }
-                    else {
-                        processed[fieldDef.name] = JSON.stringify(value)
-                            .replace(/'/g, '"')
-                            .replace(/\s+/g, ' ')
-                            .replace(/,\s*'/g, ", '");
-                    }
-                }
-                else {
-                    // Default to string
-                    processed[fieldDef.name] = value ? value : undefined;
-                }
-            }
-        }
-        return processed;
-    }
-    /**
-     * Attempts to match a TaxCategory entity against the name supplied in the import table. If no matches
-     * are found, the first TaxCategory id is returned.
-     */
-    getMatchingTaxCategoryId(name, taxCategories) {
-        if (this.taxCategoryMatches[name]) {
-            return this.taxCategoryMatches[name];
-        }
-        const regex = new RegExp(name, 'i');
-        const found = taxCategories.find((tc) => !!tc.name.match(regex));
-        const match = found ? found : taxCategories[0];
-        if (!match) {
-            throw new core_1.InternalServerError(`No TaxCategory found for name '${name}'`);
-        }
-        this.taxCategoryMatches[name] = match.id;
-        return match.id;
-    }
-    getTranslationByCodeOrFirst(translations, languageCode) {
-        let translation = translations.find((t) => t.languageCode === languageCode);
-        if (!translation) {
-            translation = translations[0];
-        }
-        return translation;
-    }
-    async createFacetAndValue(facet, facetCode, valueCode) {
-        const facetId = await this.fastImporter.createFacet({
-            code: facetCode,
-            isPrivate: false,
-            translations: facet.translations.map((translation) => {
-                return {
-                    languageCode: translation.languageCode,
-                    name: translation.facet,
-                    value: translation.value,
-                };
-            }),
-        });
-        const facetValueId = await this.fastImporter.createFacetValue({
-            facetId,
-            code: valueCode,
-            translations: facet.translations.map((translation) => {
-                return {
-                    languageCode: translation.languageCode,
-                    name: translation.value,
-                };
-            }),
-        });
-        return facetValueId;
-    }
-    async getProductByIdWithRelations(ctx, id) {
-        if (!id) {
-            return undefined;
-        }
-        const product = (await this.connection.getRepository(ctx, core_1.Product).findOne({
-            where: { id },
-            withDeleted: true,
-        })) ?? undefined;
-        if (product) {
-            const [facetValues, optionGroups, variants, assets, featuredAsset] = await Promise.all([
-                this.connection
-                    .getRepository(ctx, core_1.FacetValue)
-                    .find({ where: { products: { id: product.id } }, relations: ['facet'] }),
-                this.connection
-                    .getRepository(ctx, core_1.ProductOptionGroup)
-                    .find({ where: { product: { id: product.id } }, relations: ['options'] }),
-                this.connection
-                    .getRepository(ctx, core_1.ProductVariant)
-                    .find({ where: { product: { id: product.id } }, relations: ['facetValues'] }),
-                this.connection.getRepository(ctx, core_1.ProductAsset).find({ where: { productId: product.id } }),
-                this.connection
-                    .getRepository(ctx, core_1.Asset)
-                    .findOne({ where: { id: product.featuredAssetId } }),
-            ]);
-            product.facetValues = facetValues;
-            product.optionGroups = optionGroups;
-            product.variants = variants;
-            product.assets = assets;
-            featuredAsset && (product.featuredAsset = featuredAsset);
-        }
-        return product;
-    }
-};
-ProductImporter = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.TransactionalConnection,
-        core_1.ConfigService,
-        import_parser_1.ImportParser,
-        asset_importer_1.ExtendedAssetImporter,
-        extended_fast_importer_service_1.ExtendedFastImporterService,
-        core_1.TranslatableSaver,
-        core_1.ProductService,
-        core_1.ChannelService,
-        core_1.FacetService,
-        core_1.FacetValueService,
-        core_1.TaxCategoryService,
-        core_1.AssetService,
-        core_1.ProductOptionGroupService])
-], ProductImporter);
-exports.ProductImporter = ProductImporter;