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

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

@@ -0,0 +1,159 @@
+"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.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");
+/**
+ * @description
+ * This service creates new {@link Asset} entities based on string paths provided in the CSV
+ * import format. The source files are resolved by joining the value of `importExportOptions.importAssetsDir`
+ * with the asset path. This service is used internally by the {@link Importer} service.
+ *
+ * @docsCategory import-export
+ */
+let ExtendedAssetImporter = class ExtendedAssetImporter {
+    configService;
+    assetService;
+    connection;
+    channelService;
+    assetMap = new Map();
+    defaultChannel;
+    /** @internal */
+    constructor(configService, assetService, connection, channelService) {
+        this.configService = configService;
+        this.assetService = assetService;
+        this.connection = connection;
+        this.channelService = channelService;
+    }
+    async onModuleInit() {
+        this.defaultChannel = await this.channelService.getDefaultChannel();
+    }
+    /**
+     * @description
+     * Creates Asset entities for the given paths, using the assetMap cache to prevent the
+     * creation of duplicates.
+     */
+    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);
+            if (cachedAsset) {
+                if (ctx?.channelId &&
+                    cachedAsset.channels.some((channel) => channel.id !== ctx?.channelId)) {
+                    await this.connection
+                        .getRepository(ctx, core_1.Asset)
+                        .createQueryBuilder()
+                        .relation(core_1.Asset, 'channels')
+                        .of(cachedAsset.id)
+                        .add(ctx?.channel);
+                    cachedAsset.channels.push(ctx?.channel);
+                }
+                if (cachedAsset.name !== assetPath.name && assetPath.name) {
+                    this.connection.getRepository(ctx, core_1.Asset).update(cachedAsset.id, {
+                        name: assetPath.name,
+                    });
+                    // Update the cached asset with the new name
+                    this.assetMap.set(assetPath.url, { ...cachedAsset, name: assetPath.name });
+                    assets.push({ ...cachedAsset, name: assetPath.name });
+                }
+                else {
+                    assets.push(cachedAsset);
+                }
+            }
+            else {
+                try {
+                    const assetHash = (0, generate_asset_hash_1.generateAssetHash)({
+                        source: assetPath.url,
+                    });
+                    const assetFromHash = await this.connection.getRepository(ctx, core_1.Asset).findOne({
+                        where: {
+                            customFields: {
+                                hash: assetHash,
+                            },
+                        },
+                        relations: ['channels'],
+                    });
+                    if (assetFromHash) {
+                        // Check if the asset name has changed
+                        if ((assetPath.name && assetFromHash.name !== assetPath.name) ||
+                            assetFromHash.channels.some((channel) => channel.id !== ctx?.channelId)) {
+                            assetFromHash.name = assetPath.name || assetFromHash.name;
+                            assetFromHash.channels.push(ctx?.channel);
+                            await this.connection.getRepository(ctx, core_1.Asset).save(assetFromHash);
+                        }
+                        this.assetMap.set(assetPath.url, assetFromHash);
+                        assets.push(assetFromHash);
+                        continue;
+                    }
+                    const stream = await assetImportStrategy.getStreamFromPath(assetPath.url);
+                    if (stream) {
+                        const createdAsset = await this.assetService.createFromFileStream(stream, assetPath.url, ctx);
+                        if ((0, core_1.isGraphQlErrorResult)(createdAsset)) {
+                            errors.push(createdAsset.message);
+                        }
+                        else {
+                            let assetToUpdate = createdAsset;
+                            let shouldDeleteCreatedAsset = false;
+                            const assetFromHash = await this.connection.getRepository(ctx, core_1.Asset).findOne({
+                                where: {
+                                    customFields: {
+                                        hash: assetHash,
+                                    },
+                                },
+                                relations: ['channels'],
+                            });
+                            if (assetFromHash) {
+                                shouldDeleteCreatedAsset = true;
+                                assetToUpdate = { ...assetFromHash, name: assetPath.name || assetFromHash.name };
+                            }
+                            if (assetPath.id) {
+                                shouldDeleteCreatedAsset = true;
+                                assetToUpdate = {
+                                    ...assetToUpdate,
+                                    id: assetPath.id,
+                                };
+                            }
+                            this.assetMap.set(assetPath.url, assetToUpdate);
+                            assets.push(assetToUpdate);
+                            assetToUpdate.name = assetPath.name || assetToUpdate.name;
+                            assetToUpdate.channels.push(ctx?.channel);
+                            assetToUpdate.customFields = {
+                                ...assetToUpdate.customFields,
+                                hash: assetHash,
+                            };
+                            await this.connection.getRepository(ctx, core_1.Asset).save(assetToUpdate);
+                            if (shouldDeleteCreatedAsset) {
+                                this.connection.getRepository(ctx, core_1.Asset).delete(createdAsset.id);
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    errors.push(e.message);
+                }
+            }
+        }
+        return { assets, errors };
+    }
+};
+ExtendedAssetImporter = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ConfigService,
+        core_1.AssetService,
+        core_1.TransactionalConnection,
+        core_1.ChannelService])
+], ExtendedAssetImporter);
+exports.ExtendedAssetImporter = ExtendedAssetImporter;

package/dist/providers/import-providers/import-parser.d.ts

@@ -0,0 +1,137 @@
+/// <reference types="node" />
+import { GlobalFlag, LanguageCode } from '@vendure/common/lib/generated-types';
+import { ConfigService } from '@vendure/core';
+import { Stream } from 'stream';
+/**
+ * @description
+ * The intermediate representation of an OptionGroup after it has been parsed
+ * by the {@link ImportParser}.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ */
+export interface ParsedOptionGroup {
+    translations: Array<{
+        languageCode: LanguageCode;
+        name: string;
+        values: string[];
+    }>;
+}
+/**
+ * @description
+ * The intermediate representation of a Facet after it has been parsed
+ * by the {@link ImportParser}.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ */
+export interface ParsedFacet {
+    translations: Array<{
+        languageCode: LanguageCode;
+        facet: string;
+        value: string;
+    }>;
+}
+export interface ParsedAsset {
+    id?: string;
+    url: string;
+    name?: string;
+}
+/**
+ * @description
+ * The intermediate representation of a ProductVariant after it has been parsed
+ * by the {@link ImportParser}.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ */
+export interface ParsedProductVariant {
+    sku: string;
+    price: number;
+    taxCategory: string;
+    stockOnHand: number;
+    trackInventory: GlobalFlag;
+    assetPaths: string[];
+    assetsJson?: ParsedAsset[];
+    facets: ParsedFacet[];
+    translations: Array<{
+        languageCode: LanguageCode;
+        optionValues: string[];
+        customFields: {
+            [name: string]: string;
+        };
+    }>;
+}
+/**
+ * @description
+ * The intermediate representation of a Product after it has been parsed
+ * by the {@link ImportParser}.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ */
+export interface ParsedProduct {
+    assetPaths: string[];
+    assetsJson?: ParsedAsset[];
+    optionGroups: ParsedOptionGroup[];
+    facets: ParsedFacet[];
+    translations: Array<{
+        languageCode: LanguageCode;
+        name: string;
+        slug: string;
+        description: string;
+        customFields: {
+            [name: string]: string;
+        };
+    }>;
+}
+/**
+ * @description
+ * The data structure into which an import CSV file is parsed by the
+ * {@link ImportParser} `parseProducts()` method.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ */
+export interface ParsedProductWithVariants {
+    product: ParsedProduct;
+    variants: ParsedProductVariant[];
+}
+/**
+ * @description
+ * The result returned by the {@link ImportParser} `parseProducts()` method.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ */
+export interface ParseResult<T> {
+    results: T[];
+    errors: string[];
+    processed: number;
+}
+/**
+ * @description
+ * Validates and parses CSV files into a data structure which can then be used to created new entities.
+ * This is used internally by the {@link Importer}.
+ *
+ * @docsCategory import-export
+ * @docsPage ImportParser
+ * @docsWeight 0
+ */
+export declare class ImportParser {
+    private configService;
+    /** @internal */
+    constructor(configService: ConfigService);
+    /**
+     * @description
+     * Parses the contents of the [product import CSV file](/guides/developer-guide/importing-data/#product-import-format) and
+     * returns a data structure which can then be used to populate Vendure using the {@link FastImporterService}.
+     */
+    parseProducts(input: string | Stream, mainLanguage?: LanguageCode): Promise<ParseResult<ParsedProductWithVariants>>;
+    private processRawRecords;
+    private validateCustomFields;
+    private isTranslatable;
+    private validateHeaderTranslations;
+    private parseProductFromRecord;
+    private parseVariantFromRecord;
+}