@medusajs/medusa 1.3.7 → 1.3.8

package/dist/strategies/batch-jobs/product/import.js

@@ -0,0 +1,1162 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var medusa_core_utils_1 = require("medusa-core-utils");
+var interfaces_1 = require("../../../interfaces");
+var csv_parser_1 = __importDefault(require("../../../services/csv-parser"));
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+var sales_channels_1 = __importDefault(require("../../../loaders/feature-flags/sales-channels"));
+/**
+ * Process this many variant rows before reporting progress.
+ */
+var BATCH_SIZE = 100;
+/**
+ * Default strategy class used for a batch import of products/variants.
+ */
+var ProductImportStrategy = /** @class */ (function (_super) {
+    __extends(ProductImportStrategy, _super);
+    function ProductImportStrategy(_a) {
+        var batchJobService = _a.batchJobService, productService = _a.productService, salesChannelService = _a.salesChannelService, productVariantService = _a.productVariantService, shippingProfileService = _a.shippingProfileService, regionService = _a.regionService, fileService = _a.fileService, manager = _a.manager, featureFlagRouter = _a.featureFlagRouter;
+        var _this = 
+        // eslint-disable-next-line prefer-rest-params
+        _super.call(this, arguments[0]) || this;
+        _this.processedCounter = {};
+        var isSalesChannelsFeatureOn = featureFlagRouter.isFeatureEnabled(sales_channels_1.default.key);
+        _this.csvParser_ = new csv_parser_1.default(__assign(__assign({}, CSVSchema), { columns: __spreadArray(__spreadArray([], __read(CSVSchema.columns), false), __read((isSalesChannelsFeatureOn ? SalesChannelsSchema.columns : [])), false) }));
+        _this.featureFlagRouter_ = featureFlagRouter;
+        _this.manager_ = manager;
+        _this.fileService_ = fileService;
+        _this.batchJobService_ = batchJobService;
+        _this.productService_ = productService;
+        _this.salesChannelService_ = salesChannelService;
+        _this.productVariantService_ = productVariantService;
+        _this.shippingProfileService_ = shippingProfileService;
+        _this.regionService_ = regionService;
+        return _this;
+    }
+    ProductImportStrategy.prototype.buildTemplate = function () {
+        throw new Error("Not implemented!");
+    };
+    /**
+     * Create a description of a row on which the error occurred and throw a Medusa error.
+     *
+     * @param row - Parsed CSV row data
+     * @param errorDescription - Concrete error
+     */
+    ProductImportStrategy.throwDescriptiveError = function (row, errorDescription) {
+        var message = "Error while processing row with:\n      product id: ".concat(row["product.id"], ",\n      product handle: ").concat(row["product.handle"], ",\n      variant id: ").concat(row["variant.id"], "\n      variant sku: ").concat(row["variant.sku"], "\n      ").concat(errorDescription);
+        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, message);
+    };
+    /**
+     * Generate instructions for update/create of products/variants from parsed CSV rows.
+     *
+     * @param csvData - An array of parsed CSV rows.
+     */
+    ProductImportStrategy.prototype.getImportInstructions = function (csvData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var shippingProfile, seenProducts, productsCreate, productsUpdate, variantsCreate, variantsUpdate, csvData_1, csvData_1_1, row, e_1_1;
+            var e_1, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.shippingProfileService_.retrieveDefault()];
+                    case 1:
+                        shippingProfile = _c.sent();
+                        seenProducts = {};
+                        productsCreate = [];
+                        productsUpdate = [];
+                        variantsCreate = [];
+                        variantsUpdate = [];
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 8, 9, 10]);
+                        csvData_1 = __values(csvData), csvData_1_1 = csvData_1.next();
+                        _c.label = 3;
+                    case 3:
+                        if (!!csvData_1_1.done) return [3 /*break*/, 7];
+                        row = csvData_1_1.value;
+                        if (!row["variant.prices"].length) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.prepareVariantPrices(row)];
+                    case 4:
+                        _c.sent();
+                        _c.label = 5;
+                    case 5:
+                        if (row["variant.id"]) {
+                            variantsUpdate.push(row);
+                        }
+                        else {
+                            variantsCreate.push(row);
+                        }
+                        // save only first occurrence
+                        if (!seenProducts[row["product.handle"]]) {
+                            row["product.profile_id"] = shippingProfile.id;
+                            if (row["product.product.id"]) {
+                                productsUpdate.push(row);
+                            }
+                            else {
+                                productsCreate.push(row);
+                            }
+                            seenProducts[row["product.handle"]] = true;
+                        }
+                        _c.label = 6;
+                    case 6:
+                        csvData_1_1 = csvData_1.next();
+                        return [3 /*break*/, 3];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _c.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (csvData_1_1 && !csvData_1_1.done && (_a = csvData_1.return)) _a.call(csvData_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/, (_b = {},
+                            _b[types_1.OperationType.ProductCreate] = productsCreate,
+                            _b[types_1.OperationType.VariantCreate] = variantsCreate,
+                            _b[types_1.OperationType.ProductUpdate] = productsUpdate,
+                            _b[types_1.OperationType.VariantUpdate] = variantsUpdate,
+                            _b)];
+                }
+            });
+        });
+    };
+    /**
+     * Prepare prices records for insert - find and append region ids to records that contain a region name.
+     *
+     * @param row - An object containing parsed row data.
+     */
+    ProductImportStrategy.prototype.prepareVariantPrices = function (row) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, prices, _c, _d, price, record, _e, e_2, e_3_1;
+            var e_3, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        prices = [];
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 11, 12, 13]);
+                        _c = __values(row["variant.prices"]), _d = _c.next();
+                        _g.label = 2;
+                    case 2:
+                        if (!!_d.done) return [3 /*break*/, 10];
+                        price = _d.value;
+                        record = {
+                            amount: price.amount,
+                        };
+                        if (!price.regionName) return [3 /*break*/, 7];
+                        _g.label = 3;
+                    case 3:
+                        _g.trys.push([3, 5, , 6]);
+                        _e = record;
+                        return [4 /*yield*/, this.regionService_
+                                .withTransaction(transactionManager)
+                                .retrieveByName(price.regionName)];
+                    case 4:
+                        _e.region_id = (_b = (_g.sent())) === null || _b === void 0 ? void 0 : _b.id;
+                        return [3 /*break*/, 6];
+                    case 5:
+                        e_2 = _g.sent();
+                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Trying to set a price for a region ".concat(price.regionName, " that doesn't exist"));
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        record.currency_code = price.currency_code;
+                        _g.label = 8;
+                    case 8:
+                        prices.push(record);
+                        _g.label = 9;
+                    case 9:
+                        _d = _c.next();
+                        return [3 /*break*/, 2];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_3_1 = _g.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 13:
+                        row["variant.prices"] = prices;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * A worker method called after a batch job has been created.
+     * The method parses a CSV file, generates sets of instructions
+     * for processing and stores these instructions to a JSON file
+     * which is uploaded to a bucket.
+     *
+     * @param batchJobId - An id of a job that is being preprocessed.
+     */
+    ProductImportStrategy.prototype.preProcessBatchJob = function (batchJobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var batchJob, csvFileKey, csvStream, parsedData, builtData, ops;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.batchJobService_.retrieve(batchJobId)];
+                    case 1:
+                        batchJob = _a.sent();
+                        csvFileKey = batchJob.context.fileKey;
+                        return [4 /*yield*/, this.fileService_.getDownloadStream({
+                                fileKey: csvFileKey,
+                            })];
+                    case 2:
+                        csvStream = _a.sent();
+                        return [4 /*yield*/, this.csvParser_.parse(csvStream)];
+                    case 3:
+                        parsedData = _a.sent();
+                        return [4 /*yield*/, this.csvParser_.buildData(parsedData)];
+                    case 4:
+                        builtData = _a.sent();
+                        return [4 /*yield*/, this.getImportInstructions(builtData)];
+                    case 5:
+                        ops = _a.sent();
+                        return [4 /*yield*/, this.uploadImportOpsFile(batchJobId, ops)];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, this.batchJobService_.update(batchJobId, {
+                                result: {
+                                    advancement_count: 0,
+                                    // number of update/create operations to execute
+                                    count: Object.keys(ops).reduce(function (acc, k) { return acc + ops[k].length; }, 0),
+                                    stat_descriptors: [
+                                        {
+                                            key: "product-import-count",
+                                            name: "Products/variants to import",
+                                            message: "There will be ".concat(ops[types_1.OperationType.ProductCreate].length, " products created (").concat(ops[types_1.OperationType.ProductUpdate].length, "  updated).\n             ").concat(ops[types_1.OperationType.VariantCreate].length, " variants will be created and ").concat(ops[types_1.OperationType.VariantUpdate].length, " updated"),
+                                        },
+                                    ],
+                                },
+                            })];
+                    case 7:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * The main processing method called after a batch job
+     * is ready/confirmed for processing.
+     *
+     * @param batchJobId - An id of a batch job that is being processed.
+     */
+    ProductImportStrategy.prototype.processJob = function (batchJobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.createProducts(batchJobId)];
+                                    case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, this.updateProducts(batchJobId)];
+                                    case 2:
+                                        _a.sent();
+                                        return [4 /*yield*/, this.createVariants(batchJobId)];
+                                    case 3:
+                                        _a.sent();
+                                        return [4 /*yield*/, this.updateVariants(batchJobId)];
+                                    case 4:
+                                        _a.sent();
+                                        this.finalize(batchJobId);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Create, or retrieve by name, sales channels from the input data.
+     *
+     * NOTE: Sales channel names provided in the CSV must exist in the DB.
+     *       New sales channels will not be created.
+     *
+     * @param data an array of sales channels partials
+     * @return an array of sales channels created or retrieved by name
+     */
+    ProductImportStrategy.prototype.processSalesChannels = function (data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, salesChannelServiceTx, salesChannels, data_1, data_1_1, input, channel, e_4, e_5_1;
+            var e_5, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        salesChannelServiceTx = this.salesChannelService_.withTransaction(transactionManager);
+                        salesChannels = [];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 11, 12, 13]);
+                        data_1 = __values(data), data_1_1 = data_1.next();
+                        _c.label = 2;
+                    case 2:
+                        if (!!data_1_1.done) return [3 /*break*/, 10];
+                        input = data_1_1.value;
+                        channel = null;
+                        if (!input.id) return [3 /*break*/, 6];
+                        _c.label = 3;
+                    case 3:
+                        _c.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, salesChannelServiceTx.retrieve(input.id, {
+                                select: ["id"],
+                            })];
+                    case 4:
+                        channel = _c.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        e_4 = _c.sent();
+                        return [3 /*break*/, 6];
+                    case 6:
+                        if (!!channel) return [3 /*break*/, 8];
+                        return [4 /*yield*/, salesChannelServiceTx.retrieveByName(input.name, {
+                                select: ["id"],
+                            })];
+                    case 7:
+                        channel = (_c.sent());
+                        _c.label = 8;
+                    case 8:
+                        salesChannels.push(channel);
+                        _c.label = 9;
+                    case 9:
+                        data_1_1 = data_1.next();
+                        return [3 /*break*/, 2];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_5_1 = _c.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (data_1_1 && !data_1_1.done && (_b = data_1.return)) _b.call(data_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 13: return [2 /*return*/, salesChannels];
+                }
+            });
+        });
+    };
+    /**
+     * Method creates products using `ProductService` and parsed data from a CSV row.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.createProducts = function (batchJobId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, productOps, productServiceTx, isSalesChannelsFeatureOn, productOps_1, productOps_1_1, productOp, productData, _b, _c, e_6, e_7_1;
+            var e_7, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        return [4 /*yield*/, this.downloadImportOpsFile(batchJobId, types_1.OperationType.ProductCreate)];
+                    case 1:
+                        productOps = _e.sent();
+                        productServiceTx = this.productService_.withTransaction(transactionManager);
+                        isSalesChannelsFeatureOn = this.featureFlagRouter_.isFeatureEnabled(sales_channels_1.default.key);
+                        _e.label = 2;
+                    case 2:
+                        _e.trys.push([2, 12, 13, 14]);
+                        productOps_1 = __values(productOps), productOps_1_1 = productOps_1.next();
+                        _e.label = 3;
+                    case 3:
+                        if (!!productOps_1_1.done) return [3 /*break*/, 11];
+                        productOp = productOps_1_1.value;
+                        productData = (0, utils_1.transformProductData)(productOp);
+                        _e.label = 4;
+                    case 4:
+                        _e.trys.push([4, 8, , 9]);
+                        if (!isSalesChannelsFeatureOn) return [3 /*break*/, 6];
+                        _b = productData;
+                        _c = "sales_channels";
+                        return [4 /*yield*/, this.processSalesChannels(productOp["product.sales_channels"])];
+                    case 5:
+                        _b[_c] = _e.sent();
+                        _e.label = 6;
+                    case 6: return [4 /*yield*/, productServiceTx.create(productData)];
+                    case 7:
+                        _e.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        e_6 = _e.sent();
+                        ProductImportStrategy.throwDescriptiveError(productOp, e_6.message);
+                        return [3 /*break*/, 9];
+                    case 9:
+                        this.updateProgress(batchJobId);
+                        _e.label = 10;
+                    case 10:
+                        productOps_1_1 = productOps_1.next();
+                        return [3 /*break*/, 3];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_7_1 = _e.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (productOps_1_1 && !productOps_1_1.done && (_d = productOps_1.return)) _d.call(productOps_1);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Method updates existing products in the DB using a CSV row data.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.updateProducts = function (batchJobId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, productOps, productServiceTx, isSalesChannelsFeatureOn, productOps_2, productOps_2_1, productOp, productData, _b, _c, e_8, e_9_1;
+            var e_9, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        return [4 /*yield*/, this.downloadImportOpsFile(batchJobId, types_1.OperationType.ProductUpdate)];
+                    case 1:
+                        productOps = _e.sent();
+                        productServiceTx = this.productService_.withTransaction(transactionManager);
+                        isSalesChannelsFeatureOn = this.featureFlagRouter_.isFeatureEnabled(sales_channels_1.default.key);
+                        _e.label = 2;
+                    case 2:
+                        _e.trys.push([2, 12, 13, 14]);
+                        productOps_2 = __values(productOps), productOps_2_1 = productOps_2.next();
+                        _e.label = 3;
+                    case 3:
+                        if (!!productOps_2_1.done) return [3 /*break*/, 11];
+                        productOp = productOps_2_1.value;
+                        productData = (0, utils_1.transformProductData)(productOp);
+                        _e.label = 4;
+                    case 4:
+                        _e.trys.push([4, 8, , 9]);
+                        if (!isSalesChannelsFeatureOn) return [3 /*break*/, 6];
+                        _b = productData;
+                        _c = "sales_channels";
+                        return [4 /*yield*/, this.processSalesChannels(productOp["product.sales_channels"])];
+                    case 5:
+                        _b[_c] = _e.sent();
+                        _e.label = 6;
+                    case 6: return [4 /*yield*/, productServiceTx.update(productOp["product.id"], productData)];
+                    case 7:
+                        _e.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        e_8 = _e.sent();
+                        ProductImportStrategy.throwDescriptiveError(productOp, e_8.message);
+                        return [3 /*break*/, 9];
+                    case 9:
+                        this.updateProgress(batchJobId);
+                        _e.label = 10;
+                    case 10:
+                        productOps_2_1 = productOps_2.next();
+                        return [3 /*break*/, 3];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_9_1 = _e.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (productOps_2_1 && !productOps_2_1.done && (_d = productOps_2.return)) _d.call(productOps_2);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Method creates product variants from a CSV data.
+     * Method also handles processing of variant options.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.createVariants = function (batchJobId) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, variantOps, _loop_1, this_1, variantOps_1, variantOps_1_1, variantOp, e_10_1;
+            var e_10, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        return [4 /*yield*/, this.downloadImportOpsFile(batchJobId, types_1.OperationType.VariantCreate)];
+                    case 1:
+                        variantOps = _e.sent();
+                        _loop_1 = function (variantOp) {
+                            var variant, product_1, optionIds_1, e_11;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        _f.trys.push([0, 3, , 4]);
+                                        variant = (0, utils_1.transformVariantData)(variantOp);
+                                        return [4 /*yield*/, this_1.productService_
+                                                .withTransaction(transactionManager)
+                                                .retrieveByHandle(variantOp["product.handle"], {
+                                                relations: ["variants", "variants.options", "options"],
+                                            })];
+                                    case 1:
+                                        product_1 = _f.sent();
+                                        optionIds_1 = ((_b = variantOp["product.options"]) === null || _b === void 0 ? void 0 : _b.map(function (variantOption) {
+                                            return product_1.options.find(function (createdProductOption) {
+                                                return createdProductOption.title === variantOption.title;
+                                            }).id;
+                                        })) || [];
+                                        variant.options =
+                                            ((_c = variant.options) === null || _c === void 0 ? void 0 : _c.map(function (o, index) { return (__assign(__assign({}, o), { option_id: optionIds_1[index] })); })) || [];
+                                        return [4 /*yield*/, this_1.productVariantService_
+                                                .withTransaction(transactionManager)
+                                                .create(product_1, variant)];
+                                    case 2:
+                                        _f.sent();
+                                        this_1.updateProgress(batchJobId);
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_11 = _f.sent();
+                                        ProductImportStrategy.throwDescriptiveError(variantOp, e_11.message);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _e.label = 2;
+                    case 2:
+                        _e.trys.push([2, 7, 8, 9]);
+                        variantOps_1 = __values(variantOps), variantOps_1_1 = variantOps_1.next();
+                        _e.label = 3;
+                    case 3:
+                        if (!!variantOps_1_1.done) return [3 /*break*/, 6];
+                        variantOp = variantOps_1_1.value;
+                        return [5 /*yield**/, _loop_1(variantOp)];
+                    case 4:
+                        _e.sent();
+                        _e.label = 5;
+                    case 5:
+                        variantOps_1_1 = variantOps_1.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_10_1 = _e.sent();
+                        e_10 = { error: e_10_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (variantOps_1_1 && !variantOps_1_1.done && (_d = variantOps_1.return)) _d.call(variantOps_1);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Method updates product variants from a CSV data.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.updateVariants = function (batchJobId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, variantOps, productServiceTx, variantOps_2, variantOps_2_1, variantOp, product, e_12, e_13_1;
+            var e_13, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        return [4 /*yield*/, this.downloadImportOpsFile(batchJobId, types_1.OperationType.VariantUpdate)];
+                    case 1:
+                        variantOps = _c.sent();
+                        productServiceTx = this.productService_.withTransaction(transactionManager);
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 12, 13, 14]);
+                        variantOps_2 = __values(variantOps), variantOps_2_1 = variantOps_2.next();
+                        _c.label = 3;
+                    case 3:
+                        if (!!variantOps_2_1.done) return [3 /*break*/, 11];
+                        variantOp = variantOps_2_1.value;
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 8, , 9]);
+                        return [4 /*yield*/, productServiceTx.retrieveByHandle(variantOp["product.handle"])];
+                    case 5:
+                        product = _c.sent();
+                        return [4 /*yield*/, this.prepareVariantOptions(variantOp, product.id)];
+                    case 6:
+                        _c.sent();
+                        return [4 /*yield*/, this.productVariantService_
+                                .withTransaction(transactionManager)
+                                .update(variantOp["variant.id"], (0, utils_1.transformVariantData)(variantOp))];
+                    case 7:
+                        _c.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        e_12 = _c.sent();
+                        ProductImportStrategy.throwDescriptiveError(variantOp, e_12.message);
+                        return [3 /*break*/, 9];
+                    case 9:
+                        this.updateProgress(batchJobId);
+                        _c.label = 10;
+                    case 10:
+                        variantOps_2_1 = variantOps_2.next();
+                        return [3 /*break*/, 3];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_13_1 = _c.sent();
+                        e_13 = { error: e_13_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (variantOps_2_1 && !variantOps_2_1.done && (_b = variantOps_2.return)) _b.call(variantOps_2);
+                        }
+                        finally { if (e_13) throw e_13.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Extend records used for creating variant options with corresponding product option ids.
+     *
+     * @param variantOp - Parsed row data form CSV
+     * @param productId - id of variant's product
+     */
+    ProductImportStrategy.prototype.prepareVariantOptions = function (variantOp, productId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var productOptions, productOptions_1, productOptions_1_1, o, option, e_14_1;
+            var e_14, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        productOptions = variantOp["variant.options"] || [];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        productOptions_1 = __values(productOptions), productOptions_1_1 = productOptions_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!productOptions_1_1.done) return [3 /*break*/, 5];
+                        o = productOptions_1_1.value;
+                        return [4 /*yield*/, this.productService_.retrieveOptionByTitle(o._title, productId)];
+                    case 3:
+                        option = _b.sent();
+                        o.option_id = option === null || option === void 0 ? void 0 : option.id;
+                        _b.label = 4;
+                    case 4:
+                        productOptions_1_1 = productOptions_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_14_1 = _b.sent();
+                        e_14 = { error: e_14_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (productOptions_1_1 && !productOptions_1_1.done && (_a = productOptions_1.return)) _a.call(productOptions_1);
+                        }
+                        finally { if (e_14) throw e_14.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Store import ops JSON file to a bucket.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     * @param results - An object containing parsed CSV data.
+     */
+    ProductImportStrategy.prototype.uploadImportOpsFile = function (batchJobId, results) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var uploadPromises, transactionManager, _c, _d, _i, op, _e, writeStream, promise;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        uploadPromises = [];
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        _c = [];
+                        for (_d in results)
+                            _c.push(_d);
+                        _i = 0;
+                        _f.label = 1;
+                    case 1:
+                        if (!(_i < _c.length)) return [3 /*break*/, 4];
+                        op = _c[_i];
+                        if (!((_b = results[op]) === null || _b === void 0 ? void 0 : _b.length)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.fileService_
+                                .withTransaction(transactionManager)
+                                .getUploadStreamDescriptor({
+                                name: "imports/products/ops/".concat(batchJobId, "-").concat(op),
+                                ext: "json",
+                            })];
+                    case 2:
+                        _e = _f.sent(), writeStream = _e.writeStream, promise = _e.promise;
+                        uploadPromises.push(promise);
+                        writeStream.write(JSON.stringify(results[op]));
+                        writeStream.end();
+                        _f.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [4 /*yield*/, Promise.all(uploadPromises)];
+                    case 5:
+                        _f.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Remove parsed ops JSON file.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     * @param op - Type of import operation.
+     */
+    ProductImportStrategy.prototype.downloadImportOpsFile = function (batchJobId, op) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, transactionManager, readableStream;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        data = "";
+                        transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        return [4 /*yield*/, this.fileService_
+                                .withTransaction(transactionManager)
+                                .getDownloadStream({
+                                fileKey: "imports/products/ops/".concat(batchJobId, "-").concat(op, ".json"),
+                            })];
+                    case 1:
+                        readableStream = _b.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                readableStream.on("data", function (chunk) {
+                                    data += chunk;
+                                });
+                                readableStream.on("end", function () {
+                                    resolve(JSON.parse(data));
+                                });
+                                readableStream.on("error", function () {
+                                    // TODO: maybe should throw
+                                    resolve([]);
+                                });
+                            })];
+                    case 2: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Delete parsed CSV ops files.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.deleteOpsFiles = function (batchJobId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactionManager, _b, _c, op;
+            var e_15, _d;
+            return __generator(this, function (_e) {
+                transactionManager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                try {
+                    for (_b = __values(Object.keys(types_1.OperationType)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        op = _c.value;
+                        try {
+                            this.fileService_.withTransaction(transactionManager).delete({
+                                fileKey: "imports/products/ops/-".concat(batchJobId, "-").concat(op),
+                            });
+                        }
+                        catch (e) {
+                            // noop
+                        }
+                    }
+                }
+                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Update count of processed data in the batch job `result` column
+     * and cleanup temp JSON files.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.finalize = function (batchJobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var batchJob, fileKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.batchJobService_.retrieve(batchJobId)];
+                    case 1:
+                        batchJob = _a.sent();
+                        delete this.processedCounter[batchJobId];
+                        return [4 /*yield*/, this.batchJobService_.update(batchJobId, {
+                                result: { advancement_count: batchJob.result.count },
+                            })];
+                    case 2:
+                        _a.sent();
+                        fileKey = batchJob.context.fileKey;
+                        return [4 /*yield*/, this.fileService_.delete({ fileKey: fileKey })];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.deleteOpsFiles(batchJobId)];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Store the progress in the batch job `result` column.
+     * Method is called after every update/create operation,
+     * but after every `BATCH_SIZE` processed rows info is written to the DB.
+     *
+     * @param batchJobId - An id of the current batch job being processed.
+     */
+    ProductImportStrategy.prototype.updateProgress = function (batchJobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var newCount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        newCount = (this.processedCounter[batchJobId] || 0) + 1;
+                        this.processedCounter[batchJobId] = newCount;
+                        if (newCount % BATCH_SIZE !== 0) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.batchJobService_.update(batchJobId, {
+                                result: {
+                                    advancement_count: newCount,
+                                },
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ProductImportStrategy.identifier = "product-import-strategy";
+    ProductImportStrategy.batchType = "product-import";
+    return ProductImportStrategy;
+}(interfaces_1.AbstractBatchJobStrategy));
+exports.default = ProductImportStrategy;
+/**
+ * Schema definition for the CSV parser.
+ */
+var CSVSchema = {
+    columns: [
+        // PRODUCT
+        {
+            name: "Product id",
+            mapTo: "product.id",
+        },
+        {
+            name: "Product Handle",
+            mapTo: "product.handle",
+            required: true,
+        },
+        { name: "Product Title", mapTo: "product.title" },
+        { name: "Product Subtitle", mapTo: "product.subtitle" },
+        { name: "Product Description", mapTo: "product.description" },
+        { name: "Product Status", mapTo: "product.status" },
+        { name: "Product Thumbnail", mapTo: "product.thumbnail" },
+        { name: "Product Weight", mapTo: "product.weight" },
+        { name: "Product Length", mapTo: "product.length" },
+        { name: "Product Width", mapTo: "product.width" },
+        { name: "Product Height", mapTo: "product.height" },
+        { name: "Product HS Code", mapTo: "product.hs_code" },
+        { name: "Product Origin Country", mapTo: "product.origin_country" },
+        { name: "Product Mid Code", mapTo: "product.mid_code" },
+        { name: "Product Material", mapTo: "product.material" },
+        // PRODUCT-COLLECTION
+        { name: "Product Collection Title", mapTo: "product.collection.title" },
+        { name: "Product Collection Handle", mapTo: "product.collection.handle" },
+        // PRODUCT-TYPE
+        { name: "Product Type", mapTo: "product.type.value" },
+        // PRODUCT-TAGS
+        {
+            name: "Product Tags",
+            mapTo: "product.tags",
+            transform: function (value) {
+                return "".concat(value).split(",").map(function (v) { return ({ value: v }); });
+            },
+        },
+        //
+        { name: "Product Discountable", mapTo: "product.discountable" },
+        { name: "Product External ID", mapTo: "product.external_id" },
+        // PRODUCT-SHIPPING_PROFILE
+        { name: "Product Profile Name", mapTo: "product.profile.name" },
+        { name: "Product Profile Type", mapTo: "product.profile.type" },
+        // VARIANTS
+        {
+            name: "Variant id",
+            mapTo: "variant.id",
+        },
+        { name: "Variant Title", mapTo: "variant.title" },
+        { name: "Variant SKU", mapTo: "variant.sku" },
+        { name: "Variant Barcode", mapTo: "variant.barcode" },
+        { name: "Variant Inventory Quantity", mapTo: "variant.inventory_quantity" },
+        { name: "Variant Allow backorder", mapTo: "variant.allow_backorder" },
+        { name: "Variant Manage inventory", mapTo: "variant.manage_inventory" },
+        { name: "Variant Weight", mapTo: "variant.weight" },
+        { name: "Variant Length", mapTo: "variant.length" },
+        { name: "Variant Width", mapTo: "variant.width" },
+        { name: "Variant Height", mapTo: "variant.height" },
+        { name: "Variant HS Code", mapTo: "variant.hs_code" },
+        { name: "Variant Origin Country", mapTo: "variant.origin_country" },
+        { name: "Variant Mid Code", mapTo: "variant.mid_code" },
+        { name: "Variant Material", mapTo: "variant.material" },
+        // ==== DYNAMIC FIELDS ====
+        // PRODUCT_OPTIONS
+        {
+            name: "Option Name",
+            match: /Option \d+ Name/,
+            reducer: function (builtLine, key, value) {
+                builtLine["product.options"] = builtLine["product.options"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                ;
+                builtLine["product.options"].push({ title: value });
+                return builtLine;
+            },
+        },
+        {
+            name: "Option Value",
+            match: /Option \d+ Value/,
+            reducer: function (builtLine, key, value, context) {
+                builtLine["variant.options"] = builtLine["variant.options"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                ;
+                builtLine["variant.options"].push({
+                    value: value,
+                    _title: context.line[key.slice(0, -6) + " Name"],
+                });
+                return builtLine;
+            },
+        },
+        // PRICES
+        {
+            name: "Price Region",
+            match: /Price .* \[([A-Z]{2,4})\]/,
+            reducer: function (builtLine, key, value) {
+                builtLine["variant.prices"] = builtLine["variant.prices"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                var regionName = key.split(" ")[1];
+                builtLine["variant.prices"].push({
+                    amount: value,
+                    regionName: regionName,
+                });
+                return builtLine;
+            },
+        },
+        {
+            name: "Price Currency",
+            match: /Price [A-Z]{2,4}/,
+            reducer: function (builtLine, key, value) {
+                builtLine["variant.prices"] = builtLine["variant.prices"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                var currency = key.split(" ")[1];
+                builtLine["variant.prices"].push({
+                    amount: value,
+                    currency_code: currency,
+                });
+                return builtLine;
+            },
+        },
+        // IMAGES
+        {
+            name: "Image Url",
+            match: /Image \d+ Url/,
+            reducer: function (builtLine, key, value) {
+                builtLine["product.images"] = builtLine["product.images"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                builtLine["product.images"].push(value);
+                return builtLine;
+            },
+        },
+    ],
+};
+var SalesChannelsSchema = {
+    columns: [
+        {
+            name: "Sales Channel Name",
+            match: /Sales Channel \d+ Name/,
+            reducer: function (builtLine, key, value) {
+                builtLine["product.sales_channels"] =
+                    builtLine["product.sales_channels"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                ;
+                builtLine["product.sales_channels"].push({
+                    name: value,
+                });
+                return builtLine;
+            },
+        },
+        {
+            name: "Sales Channel Id",
+            match: /Sales Channel \d+ Id/,
+            reducer: function (builtLine, key, value) {
+                builtLine["product.sales_channels"] =
+                    builtLine["product.sales_channels"] || [];
+                if (typeof value === "undefined" || value === null) {
+                    return builtLine;
+                }
+                ;
+                builtLine["product.sales_channels"].push({
+                    id: value,
+                });
+                return builtLine;
+            },
+        },
+    ],
+};
+//# sourceMappingURL=import.js.map