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

package/dist/providers/import-providers/asset-importer.d.ts

@@ -1,6 +1,8 @@
+/// <reference types="node" />
 import { OnModuleInit } from '@nestjs/common';
 import { Asset, AssetService, ChannelService, ConfigService, RequestContext, TransactionalConnection } from '@vendure/core';
 import { JsonAsset } from '../../types';
+import { Readable } from 'stream';
 /**
  * @description
  * This service creates new {@link Asset} entities based on string paths provided in the CSV
@@ -28,4 +30,7 @@ export declare class ExtendedAssetImporter implements OnModuleInit {
         assets: Asset[];
         errors: string[];
     }>;
+    getStreamFromPath(assetPath: string): Readable | Promise<Readable>;
+    private getStreamFromUrl;
+    private getStreamFromLocalFile;
 }

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

@@ -8,11 +8,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendedAssetImporter = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@vendure/core");
 const generate_asset_hash_1 = require("../../helpers/generate-asset-hash");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const axios_1 = __importDefault(require("axios"));
+const path_1 = __importDefault(require("path"));
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
 /**
  * @description
  * This service creates new {@link Asset} entities based on string paths provided in the CSV
@@ -46,7 +54,6 @@ let ExtendedAssetImporter = class ExtendedAssetImporter {
     async getAssets(assetPaths, ctx) {
         const assets = [];
         const errors = [];
-        const { assetImportStrategy } = this.configService.importExportOptions;
         const uniqueAssetPaths = new Set(assetPaths);
         for (const assetPath of uniqueAssetPaths.values()) {
             const cachedAsset = this.assetMap.get(assetPath.url);
@@ -98,7 +105,7 @@ let ExtendedAssetImporter = class ExtendedAssetImporter {
                         assets.push(assetFromHash);
                         continue;
                     }
-                    const stream = await assetImportStrategy.getStreamFromPath(assetPath.url);
+                    const stream = await this.getStreamFromPath(assetPath.url);
                     if (stream) {
                         const createdAsset = await this.assetService.createFromFileStream(stream, assetPath.url, ctx);
                         if ((0, core_1.isGraphQlErrorResult)(createdAsset)) {
@@ -142,12 +149,63 @@ let ExtendedAssetImporter = class ExtendedAssetImporter {
                     }
                 }
                 catch (e) {
-                    errors.push(e.message);
+                    if (e.message.includes('no elements in sequence')) {
+                        errors.push(`Could not find asset at path "${assetPath.url}"`);
+                    }
+                    else {
+                        errors.push(e.message);
+                    }
                 }
             }
         }
         return { assets, errors };
     }
+    getStreamFromPath(assetPath) {
+        if (/^https?:\/\//.test(assetPath)) {
+            return this.getStreamFromUrl(assetPath);
+        }
+        else {
+            return this.getStreamFromLocalFile(assetPath);
+        }
+    }
+    getStreamFromUrl(assetUrl) {
+        const retryCount = 3;
+        const retryDelayMs = 200;
+        return (0, rxjs_1.lastValueFrom)((0, rxjs_1.from)(fetchUrlWithAxios(assetUrl)).pipe((0, operators_1.retryWhen)((errors) => errors.pipe((0, operators_1.tap)((error) => {
+            core_1.Logger.verbose(error.message);
+            if (error.message.includes('Status code: 404')) {
+                throw error; // Stop retrying on 404 errors
+            }
+            core_1.Logger.verbose(`CustomAssetImportStrategy: retrying fetchUrl for ${assetUrl}`);
+        }), (0, operators_1.delay)(retryDelayMs ?? 200), (0, operators_1.take)(retryCount ?? 3)))));
+    }
+    getStreamFromLocalFile(assetPath) {
+        const { importAssetsDir } = this.configService.importExportOptions;
+        const filename = path_1.default.join(importAssetsDir, assetPath);
+        if (fs_extra_1.default.existsSync(filename)) {
+            const fileStat = fs_extra_1.default.statSync(filename);
+            if (fileStat.isFile()) {
+                try {
+                    const stream = fs_extra_1.default.createReadStream(filename);
+                    return stream;
+                }
+                catch (err) {
+                    core_1.Logger.error(`Error creating read stream for local file "${filename}": ${err.message}`);
+                    throw err;
+                }
+            }
+            else {
+                const errorMessage = `Could not find file "${filename}"`;
+                core_1.Logger.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+        }
+        else {
+            const errorMessage = `File "${filename}" does not exist`;
+            core_1.Logger.error(errorMessage);
+            throw new Error(errorMessage);
+        }
+    }
 };
 ExtendedAssetImporter = __decorate([
     (0, common_1.Injectable)(),
@@ -157,3 +215,20 @@ ExtendedAssetImporter = __decorate([
         core_1.ChannelService])
 ], ExtendedAssetImporter);
 exports.ExtendedAssetImporter = ExtendedAssetImporter;
+async function fetchUrlWithAxios(urlString) {
+    try {
+        const response = await axios_1.default.get(urlString, {
+            responseType: 'stream',
+            timeout: 5000, // 5 seconds timeout
+        });
+        if (response.status !== 200) {
+            core_1.Logger.error(`Failed to fetch "${urlString}", statusCode: ${response.status}`);
+            throw new Error(`Request failed. Status code: ${response.status}`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        core_1.Logger.error(`Error fetching URL "${urlString}": ${error.message}`);
+        throw error;
+    }
+}

package/dist/providers/import-providers/product-importer.d.ts

@@ -35,7 +35,6 @@ export declare class ProductImporter {
     private doParseAndImport;
     private getRequestContext;
     importProducts(ctx: RequestContext, rows: ParsedProductWithId[], updatingStrategy: UpdatingStrategy, onProgress: OnProgressFn): Promise<string[]>;
-    private getFacetValueIds;
     private processCustomFieldValues;
     /**
      * Attempts to match a TaxCategory entity against the name supplied in the import table. If no matches

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

@@ -413,10 +413,10 @@ let ProductImporter = class ProductImporter {
                 if (createVariantAssets.errors.length) {
                     errors = errors.concat(createVariantAssets.errors);
                 }
-                let facetValueIds = [];
-                if (0 < variant.facets.length) {
-                    facetValueIds = await this.getFacetValueIds(ctx, variant.facets, languageCode);
-                }
+                // let facetValueIds: ID[] = []
+                // 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({
@@ -504,64 +504,79 @@ let ProductImporter = class ProductImporter {
         }
         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;
-    }
+    // private async getFacetValueIds(
+    //   ctx: RequestContext,
+    //   facets: ParsedFacet[],
+    //   languageCode: LanguageCode,
+    // ): Promise<ID[]> {
+    //   const facetValueIds: ID[] = []
+    //   for (const item of facets) {
+    //     const itemMainTranslation = this.getTranslationByCodeOrFirst(item.translations, languageCode)
+    //     const facetName = itemMainTranslation.facet
+    //     const valueName = itemMainTranslation.value
+    //     let facetEntity: Facet
+    //     const cachedFacet = this.facetMap.get(facetName)
+    //     if (cachedFacet?.code === 'kategorier') {
+    //       console.log('cachedFacet', cachedFacet)
+    //     }
+    //     if (cachedFacet) {
+    //       facetEntity = cachedFacet
+    //     } else {
+    //       const existing = await this.facetService.findByCode(
+    //         ctx,
+    //         normalizeString(facetName, '-', languageCode),
+    //         languageCode,
+    //       )
+    //       if (existing) {
+    //         if (existing?.code === 'kategorier') {
+    //           console.log('existingFacet', existing)
+    //         }
+    //         facetEntity = existing
+    //       } else {
+    //         facetEntity = await this.facetService.create(ctx, {
+    //           isPrivate: false,
+    //           code: normalizeString(facetName, '-', languageCode),
+    //           translations: item.translations.map((translation) => {
+    //             return {
+    //               languageCode: translation.languageCode,
+    //               name: translation.facet,
+    //             }
+    //           }),
+    //         })
+    //       }
+    //       this.facetMap.set(facetName, facetEntity)
+    //     }
+    //     let facetValueEntity: FacetValue
+    //     const facetValueMapKey = `${facetName}:${valueName}`
+    //     const cachedFacetValue = this.facetValueMap.get(facetValueMapKey)
+    //     if (cachedFacetValue) {
+    //       facetValueEntity = cachedFacetValue
+    //       if (cachedFacetValue?.code === 'duschhoerna') {
+    //         console.log('cachedFacetValue', cachedFacetValue)
+    //       }
+    //     } else {
+    //       const existing = facetEntity.values.find(
+    //         (v) => normalizeString(v.name, '-') === normalizeString(valueName, '-', languageCode),
+    //       )
+    //       if (existing) {
+    //         facetValueEntity = existing
+    //       } else {
+    //         facetValueEntity = await this.facetValueService.create(ctx, facetEntity, {
+    //           code: 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) {

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

@@ -252,7 +252,7 @@ let ExtendedFastImporterService = class ExtendedFastImporterService {
         const facetValueExists = await this.connection
             .getRepository(this.importCtx, core_1.FacetValue)
             .findOne({
-            where: { code: input.code },
+            where: { code: input.code, facet: { id: input.facetId } },
             relations: ['channels', 'translations'],
         });
         if (facetValueExists) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haus-tech/product-import-export-plugin",
-  "version": "3.0.6",
+  "version": "3.0.8",
   "description": "A Vendure plugin for importing and exporting products using a CSV file",
   "author": "Haus Tech",
   "repository": {