@infrab4a/connect 3.14.3-beta.3 → 3.14.4

package/bundles/infrab4a-connect.umd.js

@@ -1823,43 +1823,43 @@
         return Filter;
     }(BaseModel));
 
-    var Product = /** @class */ (function (_super) {
-        __extends(Product, _super);
-        function Product() {
+    var CategoryBase = /** @class */ (function (_super) {
+        __extends(CategoryBase, _super);
+        function CategoryBase() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        Object.defineProperty(Product, "identifiersFields", {
+        Object.defineProperty(CategoryBase, "identifiersFields", {
             get: function () {
                 return ['id'];
             },
             enumerable: false,
             configurable: true
         });
-        return Product;
-    }(ProductBase));
+        return CategoryBase;
+    }(BaseModel));
+    __decorate([
+        classTransformer.Type(function () { return CategoryBase; }),
+        __metadata("design:type", CategoryBase)
+    ], CategoryBase.prototype, "parent", void 0);
+    __decorate([
+        classTransformer.Type(function () { return Filter; }),
+        __metadata("design:type", Array)
+    ], CategoryBase.prototype, "filters", void 0);
 
-    var KitProduct = /** @class */ (function (_super) {
-        __extends(KitProduct, _super);
-        function KitProduct() {
+    var CategoryForProduct = /** @class */ (function (_super) {
+        __extends(CategoryForProduct, _super);
+        function CategoryForProduct() {
             return _super !== null && _super.apply(this, arguments) || this;
         }
-        Object.defineProperty(KitProduct, "identifiersFields", {
+        Object.defineProperty(CategoryForProduct, "identifiersFields", {
             get: function () {
-                return ['productId', 'kitProductId'];
+                return ['id'];
             },
             enumerable: false,
             configurable: true
         });
-        return KitProduct;
-    }(BaseModel));
-    __decorate([
-        classTransformer.Type(function () { return Product; }),
-        __metadata("design:type", Product)
-    ], KitProduct.prototype, "kit", void 0);
-    __decorate([
-        classTransformer.Type(function () { return Product; }),
-        __metadata("design:type", Product)
-    ], KitProduct.prototype, "product", void 0);
+        return CategoryForProduct;
+    }(CategoryBase));
 
     var ProductBase = /** @class */ (function (_super) {
         __extends(ProductBase, _super);
@@ -1897,14 +1897,48 @@
         });
         return ProductBase;
     }(BaseModel));
+
+    var ProductForKit = /** @class */ (function (_super) {
+        __extends(ProductForKit, _super);
+        function ProductForKit() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(ProductForKit, "identifiersFields", {
+            get: function () {
+                return ['id'];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return ProductForKit;
+    }(ProductBase));
+    __decorate([
+        classTransformer.Type(function () { return CategoryForProduct; }),
+        __metadata("design:type", CategoryForProduct)
+    ], ProductForKit.prototype, "category", void 0);
+
+    var KitProduct = /** @class */ (function (_super) {
+        __extends(KitProduct, _super);
+        function KitProduct() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(KitProduct, "identifiersFields", {
+            get: function () {
+                return ['productId', 'kitProductId'];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return KitProduct;
+    }(BaseModel));
     __decorate([
-        classTransformer.Type(function () { return Category; }),
-        __metadata("design:type", Category)
-    ], ProductBase.prototype, "category", void 0);
+        classTransformer.Type(function () { return ProductForKit; }),
+        __metadata("design:type", ProductForKit)
+    ], KitProduct.prototype, "kit", void 0);
     __decorate([
-        classTransformer.Type(function () { return KitProduct; }),
-        __metadata("design:type", Array)
-    ], ProductBase.prototype, "kitProducts", void 0);
+        classTransformer.Type(function () { return ProductForKit; }),
+        __metadata("design:type", ProductForKit)
+    ], KitProduct.prototype, "product", void 0);
 
     var ProductForCategory = /** @class */ (function (_super) {
         __extends(ProductForCategory, _super);
@@ -1920,6 +1954,10 @@
         });
         return ProductForCategory;
     }(ProductBase));
+    __decorate([
+        classTransformer.Type(function () { return KitProduct; }),
+        __metadata("design:type", Array)
+    ], ProductForCategory.prototype, "kitProducts", void 0);
 
     var Category = /** @class */ (function (_super) {
         __extends(Category, _super);
@@ -1934,15 +1972,7 @@
             configurable: true
         });
         return Category;
-    }(BaseModel));
-    __decorate([
-        classTransformer.Type(function () { return Category; }),
-        __metadata("design:type", Category)
-    ], Category.prototype, "parent", void 0);
-    __decorate([
-        classTransformer.Type(function () { return Filter; }),
-        __metadata("design:type", Array)
-    ], Category.prototype, "filters", void 0);
+    }(CategoryBase));
     __decorate([
         classTransformer.Type(function () { return ProductForCategory; }),
         __metadata("design:type", Array)
@@ -2020,6 +2050,29 @@
         return FilterOption;
     }(BaseModel));
 
+    var Product = /** @class */ (function (_super) {
+        __extends(Product, _super);
+        function Product() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(Product, "identifiersFields", {
+            get: function () {
+                return ['id'];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return Product;
+    }(ProductBase));
+    __decorate([
+        classTransformer.Type(function () { return CategoryForProduct; }),
+        __metadata("design:type", CategoryForProduct)
+    ], Product.prototype, "category", void 0);
+    __decorate([
+        classTransformer.Type(function () { return KitProduct; }),
+        __metadata("design:type", Array)
+    ], Product.prototype, "kitProducts", void 0);
+
     var Variant = /** @class */ (function (_super) {
         __extends(Variant, _super);
         function Variant() {
@@ -2035,6 +2088,21 @@
         return Variant;
     }(BaseModel));
 
+    var Wishlist = /** @class */ (function (_super) {
+        __extends(Wishlist, _super);
+        function Wishlist() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(Wishlist, "identifiersFields", {
+            get: function () {
+                return ['id'];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return Wishlist;
+    }(Category));
+
     var Buy2Win = /** @class */ (function (_super) {
         __extends(Buy2Win, _super);
         function Buy2Win() {
@@ -4785,6 +4853,15 @@
                 ],
             }) || this;
         }
+        CategoryFilterHasuraGraphQLRepository.prototype.deleteByCategory = function (categoryId) {
+            return this.mutation('delete_category_filter', ['affected_rows'], {
+                where: {
+                    type: 'category_filter_bool_exp',
+                    required: true,
+                    value: { category_id: { _eq: categoryId } },
+                },
+            });
+        };
         CategoryFilterHasuraGraphQLRepository.prototype.deleteByCategoryAndFilter = function (categoryId, filterId) {
             return this.mutation('delete_category_filter', ['affected_rows'], {
                 where: {
@@ -4869,6 +4946,7 @@
                         },
                     },
                     { isCollection: { columnName: 'is_collection' } },
+                    { isWishlist: { columnName: 'is_wishlist' } },
                     'reference',
                     { parentId: { columnName: 'parent_id' } },
                     {
@@ -4892,7 +4970,7 @@
                 var metadata, data;
                 return __generator(this, function (_c) {
                     metadata = params.metadata, data = __rest(params, ["metadata"]);
-                    return [2 /*return*/, _super.create.call(this, Object.assign(Object.assign({}, data), { metadata: metadata || { description: null, title: null } }))];
+                    return [2 /*return*/, _super.create.call(this, Object.assign(Object.assign({}, data), { isWishlist: false, metadata: metadata || { description: null, title: null } }))];
                 });
             });
         };
@@ -4933,7 +5011,7 @@
                             return [4 /*yield*/, this.getId(plainData.id)];
                         case 1:
                             id = _j.sent();
-                            return [4 /*yield*/, _super.update.call(this, Object.assign({ id: id }, data))];
+                            return [4 /*yield*/, _super.update.call(this, Object.assign(Object.assign({ id: id }, data), { isWishlist: false }))];
                         case 2:
                             category = _j.sent();
                             _c = category;
@@ -4981,6 +5059,7 @@
                                         slug: slug,
                                         shops: { operator: exports.Where.IN, value: [shop] },
                                         published: { operator: exports.Where.EQUALS, value: true },
+                                        isWishlist: { operator: exports.Where.EQUALS, value: false },
                                     },
                                     options: {
                                         enableCount: false,
@@ -5009,6 +5088,7 @@
                                     filters: {
                                         shops: { operator: exports.Where.IN, value: [shop] },
                                         published: { operator: exports.Where.EQUALS, value: true },
+                                        isWishlist: { operator: exports.Where.EQUALS, value: false },
                                     },
                                     options: {
                                         enableCount: false,
@@ -5226,104 +5306,136 @@
         CategoryHasuraGraphQLRepository.prototype.updateFilters = function (categoryId, _c) {
             var filters = _c.filters;
             return __awaiter(this, void 0, void 0, function () {
-                var i, filtersList, i, hasFilter, newCategoryFilter, error_1, filtersList, i, hasFilter, newCategoryFilter, error_2;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
+                var i, filtersList, currentFilters, currentFiltersId_1, filtersUpdatedId_1, filterToBeDeleted, filterToBeInserted, _loop_1, this_1, filterToBeDeleted_1, filterToBeDeleted_1_1, filter, e_1_1, filterToBeInserted_1, filterToBeInserted_1_1, filter, newCategoryFilter, e_2_1, filtersList, i, newCategoryFilter;
+                var e_1, _c, e_2, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
                         case 0:
                             if (!('action' in filters && filters.action === 'remove' && filters.value.length)) return [3 /*break*/, 5];
                             i = 0;
-                            _c.label = 1;
+                            _e.label = 1;
                         case 1:
                             if (!(i < filters.value.length)) return [3 /*break*/, 4];
                             return [4 /*yield*/, this.categoryFilterRepository.deleteByCategoryAndFilter(categoryId, filters.value[i].id)];
                         case 2:
-                            _c.sent();
-                            _c.label = 3;
+                            _e.sent();
+                            _e.label = 3;
                         case 3:
                             i++;
                             return [3 /*break*/, 1];
                         case 4: return [2 /*return*/, []];
                         case 5:
-                            if (!('action' in filters && filters.action === 'merge' && filters.value.length)) return [3 /*break*/, 15];
+                            if (!('action' in filters && filters.action === 'merge' && filters.value.length)) return [3 /*break*/, 22];
                             filtersList = [];
-                            i = 0;
-                            _c.label = 6;
-                        case 6:
-                            if (!(i < filters.value.length)) return [3 /*break*/, 14];
-                            _c.label = 7;
-                        case 7:
-                            _c.trys.push([7, 12, , 13]);
                             return [4 /*yield*/, this.categoryFilterRepository
                                     .find({
                                     filters: {
                                         categoryId: categoryId,
-                                        filterId: filters.value[i].id,
                                     },
                                 })
-                                    .then(function (data) { return data.data.shift(); })];
+                                    .then(function (res) { return res.data; })];
+                        case 6:
+                            currentFilters = _e.sent();
+                            currentFiltersId_1 = currentFilters.map(function (f) { return f.id; });
+                            filtersUpdatedId_1 = filters.value.map(function (f) { return f.id; });
+                            filterToBeDeleted = currentFiltersId_1.filter(function (c) { return !filtersUpdatedId_1.includes(c); });
+                            filterToBeInserted = filtersUpdatedId_1.filter(function (c) { return !currentFiltersId_1.includes(c); });
+                            _loop_1 = function (filter) {
+                                var index;
+                                return __generator(this, function (_f) {
+                                    switch (_f.label) {
+                                        case 0:
+                                            index = currentFilters.findIndex(function (f) { return f.id == filter; });
+                                            if (index != -1) {
+                                                currentFilters.splice(index, 1);
+                                            }
+                                            return [4 /*yield*/, this_1.categoryFilterRepository.deleteByCategoryAndFilter(categoryId, filter)];
+                                        case 1:
+                                            _f.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            this_1 = this;
+                            _e.label = 7;
+                        case 7:
+                            _e.trys.push([7, 12, 13, 14]);
+                            filterToBeDeleted_1 = __values(filterToBeDeleted), filterToBeDeleted_1_1 = filterToBeDeleted_1.next();
+                            _e.label = 8;
                         case 8:
-                            hasFilter = _c.sent();
-                            if (!hasFilter) return [3 /*break*/, 9];
-                            filtersList.push(hasFilter);
-                            return [3 /*break*/, 11];
-                        case 9: return [4 /*yield*/, this.categoryFilterRepository.create({
-                                filterId: filters.value[i].id,
-                                categoryId: categoryId,
-                            })];
+                            if (!!filterToBeDeleted_1_1.done) return [3 /*break*/, 11];
+                            filter = filterToBeDeleted_1_1.value;
+                            return [5 /*yield**/, _loop_1(filter)];
+                        case 9:
+                            _e.sent();
+                            _e.label = 10;
                         case 10:
-                            newCategoryFilter = _c.sent();
-                            filtersList.push(newCategoryFilter);
-                            _c.label = 11;
-                        case 11: return [3 /*break*/, 13];
+                            filterToBeDeleted_1_1 = filterToBeDeleted_1.next();
+                            return [3 /*break*/, 8];
+                        case 11: return [3 /*break*/, 14];
                         case 12:
-                            error_1 = _c.sent();
-                            console.log('catch error: ', error_1);
-                            return [3 /*break*/, 13];
+                            e_1_1 = _e.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 14];
                         case 13:
-                            i++;
-                            return [3 /*break*/, 6];
-                        case 14: return [2 /*return*/, filtersList];
+                            try {
+                                if (filterToBeDeleted_1_1 && !filterToBeDeleted_1_1.done && (_c = filterToBeDeleted_1.return)) _c.call(filterToBeDeleted_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 14:
+                            _e.trys.push([14, 19, 20, 21]);
+                            filterToBeInserted_1 = __values(filterToBeInserted), filterToBeInserted_1_1 = filterToBeInserted_1.next();
+                            _e.label = 15;
                         case 15:
-                            if (!(Array.isArray(filters) && filters.length)) return [3 /*break*/, 25];
-                            filtersList = [];
-                            i = 0;
-                            _c.label = 16;
+                            if (!!filterToBeInserted_1_1.done) return [3 /*break*/, 18];
+                            filter = filterToBeInserted_1_1.value;
+                            return [4 /*yield*/, this.categoryFilterRepository.create({
+                                    filterId: filter,
+                                    categoryId: categoryId,
+                                })];
                         case 16:
-                            if (!(i < filters.length)) return [3 /*break*/, 24];
-                            _c.label = 17;
+                            newCategoryFilter = _e.sent();
+                            filtersList.push(newCategoryFilter);
+                            _e.label = 17;
                         case 17:
-                            _c.trys.push([17, 22, , 23]);
-                            return [4 /*yield*/, this.categoryFilterRepository
-                                    .find({
-                                    filters: {
-                                        categoryId: categoryId,
-                                        filterId: filters[i].id,
-                                    },
-                                })
-                                    .then(function (data) { return data.data.shift(); })];
-                        case 18:
-                            hasFilter = _c.sent();
-                            if (!hasFilter) return [3 /*break*/, 19];
-                            filtersList.push(hasFilter);
+                            filterToBeInserted_1_1 = filterToBeInserted_1.next();
+                            return [3 /*break*/, 15];
+                        case 18: return [3 /*break*/, 21];
+                        case 19:
+                            e_2_1 = _e.sent();
+                            e_2 = { error: e_2_1 };
                             return [3 /*break*/, 21];
-                        case 19: return [4 /*yield*/, this.categoryFilterRepository.create({
-                                filterId: filters[i].id,
-                                categoryId: categoryId,
-                            })];
                         case 20:
-                            newCategoryFilter = _c.sent();
-                            filtersList.push(newCategoryFilter);
-                            _c.label = 21;
-                        case 21: return [3 /*break*/, 23];
+                            try {
+                                if (filterToBeInserted_1_1 && !filterToBeInserted_1_1.done && (_d = filterToBeInserted_1.return)) _d.call(filterToBeInserted_1);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                            return [7 /*endfinally*/];
+                        case 21: return [2 /*return*/, __spreadArray(__spreadArray([], __read(currentFilters)), __read(filtersList))];
                         case 22:
-                            error_2 = _c.sent();
-                            console.log('catch error: ', error_2);
-                            return [3 /*break*/, 23];
+                            if (!(Array.isArray(filters) && filters.length)) return [3 /*break*/, 28];
+                            return [4 /*yield*/, this.categoryFilterRepository.deleteByCategory(categoryId)];
                         case 23:
+                            _e.sent();
+                            filtersList = [];
+                            i = 0;
+                            _e.label = 24;
+                        case 24:
+                            if (!(i < filters.length)) return [3 /*break*/, 27];
+                            return [4 /*yield*/, this.categoryFilterRepository.create({
+                                    filterId: filters[i].id,
+                                    categoryId: categoryId,
+                                })];
+                        case 25:
+                            newCategoryFilter = _e.sent();
+                            filtersList.push(newCategoryFilter);
+                            _e.label = 26;
+                        case 26:
                             i++;
-                            return [3 /*break*/, 16];
-                        case 24: return [2 /*return*/, filtersList];
-                        case 25: return [2 /*return*/];
+                            return [3 /*break*/, 24];
+                        case 27: return [2 /*return*/, filtersList];
+                        case 28: return [2 /*return*/];
                     }
                 });
             });
@@ -6445,6 +6557,339 @@
         return VariantHasuraGraphQLRepository;
     }(withCrudHasuraGraphQL(withHasuraGraphQL(Base))));
 
+    var WishlistHasuraGraphQLRepository = /** @class */ (function (_super_1) {
+        __extends(WishlistHasuraGraphQLRepository, _super_1);
+        function WishlistHasuraGraphQLRepository(endpoint, authOptions, categoryFilterRepository) {
+            var _this = _super_1.call(this, {
+                tableName: 'category',
+                model: Wishlist,
+                endpoint: endpoint,
+                authOptions: authOptions,
+                fields: [
+                    { id: { columnName: 'id', to: function (value) { return +value; }, from: function (value) { return value.toString(); } } },
+                    { firestoreId: { columnName: 'firestore_id' } },
+                    'name',
+                    'description',
+                    'image',
+                    'published',
+                    'shop',
+                    { shops: { columnName: 'shops', type: HasuraGraphQLColumnType.Jsonb } },
+                    'slug',
+                    { brandCategory: { columnName: 'brand_category' } },
+                    { brandCategoryBanner: { columnName: 'brand_banner' } },
+                    { brandCategoryBannerMobile: { columnName: 'brand_banner_mobile' } },
+                    { brandLogo: { columnName: 'brand_logo' } },
+                    { brandCondition: { columnName: 'brand_condition' } },
+                    {
+                        conditions: {
+                            columnName: 'tag_condition',
+                            type: HasuraGraphQLColumnType.Jsonb,
+                            from: function (tags, row) { return ({ brand: row.brand_condition, tags: Array.isArray(tags) ? tags : [] }); },
+                            bindPersistData: function (value) {
+                                return {
+                                    brand_condition: value.brand,
+                                    tag_condition: (value === null || value === void 0 ? void 0 : value.tags) || [],
+                                };
+                            },
+                            bindFindFilter: function (sentence) {
+                                return Object.assign(Object.assign({}, (sentence.brand ? { brand_condition: sentence.brand } : {})), (sentence.tags ? { tag_condition: sentence.tags } : {}));
+                            },
+                        },
+                    },
+                    {
+                        filters: {
+                            columnName: 'filters',
+                            foreignKeyColumn: { filter_id: 'id' },
+                            fields: [{ filter: ['id', 'description', 'slug', 'enabled'] }],
+                            bindPersistData: function (value) { return ({
+                                filters: { data: value.map(function (filter) { return ({ filter_id: filter.id }); }) },
+                            }); },
+                            from: function (filters) { return (filters === null || filters === void 0 ? void 0 : filters.map(function (filter) { return filter === null || filter === void 0 ? void 0 : filter.filter; })) || []; },
+                        },
+                    },
+                    { createdAt: { columnName: 'created_at' } },
+                    { updatedAt: { columnName: 'updated_at' } },
+                    {
+                        products: {
+                            columnName: 'products',
+                            fields: ['product_id'],
+                            from: function (value) { return value.map(function (product) { return product.product_id.toString(); }); },
+                            to: function (productIds) { return productIds.map(function (productId) { return ({
+                                product_id: +productId,
+                            }); }); },
+                        },
+                    },
+                    {
+                        metadata: {
+                            columnName: 'metadata',
+                            fields: ['title', 'description'],
+                            bindPersistData: function (value) { return ({
+                                metadata: { data: value },
+                            }); },
+                        },
+                    },
+                    { isCollection: { columnName: 'is_collection' } },
+                    { isWishlist: { columnName: 'is_wishlist' } },
+                    'reference',
+                    { parentId: { columnName: 'parent_id' } },
+                    {
+                        parent: {
+                            columnName: 'parent',
+                            foreignKeyColumn: { id: 'parentId' },
+                            fields: ['id', 'name', 'reference', 'slug'],
+                        },
+                    },
+                    { personId: { columnName: 'person_id' } },
+                ],
+            }) || this;
+            _this.categoryFilterRepository = categoryFilterRepository;
+            return _this;
+        }
+        WishlistHasuraGraphQLRepository.prototype.create = function (params) {
+            var _super = Object.create(null, {
+                create: { get: function () { return _super_1.prototype.create; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var metadata, data;
+                return __generator(this, function (_a) {
+                    metadata = params.metadata, data = __rest(params, ["metadata"]);
+                    return [2 /*return*/, _super.create.call(this, Object.assign(Object.assign({}, data), { isWishlist: true, isCollection: true, brandCategory: false, metadata: metadata || { description: data.description, title: data.name } }))];
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.get = function (identifiers) {
+            var _super = Object.create(null, {
+                get: { get: function () { return _super_1.prototype.get; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, _super.get.call(this, identifiers)];
+                        case 1:
+                            data = _a.sent();
+                            if (!data.isWishlist)
+                                throw new NotFoundError("Category with id " + identifiers.id + " is not a wishlist");
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.update = function (params) {
+            var _super = Object.create(null, {
+                update: { get: function () { return _super_1.prototype.update; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var products, checkId, metadata, filters, data, plainData, id, category, _a, _b, _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            products = params.products, checkId = params.id, metadata = params.metadata, filters = params.filters, data = __rest(params, ["products", "id", "metadata", "filters"]);
+                            plainData = this.paramsToPlain({ id: checkId });
+                            id = plainData.id;
+                            return [4 /*yield*/, _super.update.call(this, Object.assign(Object.assign({ id: id }, data), { isWishlist: true, isCollection: true, brandCategory: false }))];
+                        case 1:
+                            category = _e.sent();
+                            _a = category;
+                            _b = products;
+                            if (!_b) return [3 /*break*/, 3];
+                            return [4 /*yield*/, this.updateProducts(+id, { products: products })];
+                        case 2:
+                            _b = (_e.sent());
+                            _e.label = 3;
+                        case 3:
+                            _a.products = _b;
+                            _c = category;
+                            _d = metadata;
+                            if (!_d) return [3 /*break*/, 5];
+                            return [4 /*yield*/, this.updateMetadata(+id, { metadata: metadata })];
+                        case 4:
+                            _d = (_e.sent());
+                            _e.label = 5;
+                        case 5:
+                            _c.metadata = _d;
+                            return [2 /*return*/, category];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.getWishlistBySlug = function (slug) {
+            return __awaiter(this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!slug)
+                                return [2 /*return*/];
+                            return [4 /*yield*/, this.find({
+                                    filters: {
+                                        slug: slug,
+                                        isWishlist: { operator: exports.Where.EQUALS, value: true },
+                                    },
+                                    options: {
+                                        enableCount: false,
+                                    },
+                                })];
+                        case 1:
+                            data = (_a.sent()).data;
+                            if (!data.length)
+                                throw new NotFoundError("Wishlist with slug " + slug + " not found");
+                            if (data.length > 1)
+                                throw new DuplicatedResultsError('Query returned duplicated values');
+                            return [2 /*return*/, data.shift()];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.getWishlistByPerson = function (personId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!personId)
+                                return [2 /*return*/];
+                            return [4 /*yield*/, this.find({
+                                    filters: {
+                                        personId: { operator: exports.Where.EQUALS, value: personId },
+                                        isWishlist: { operator: exports.Where.EQUALS, value: true },
+                                    },
+                                    options: {
+                                        enableCount: false,
+                                    },
+                                })];
+                        case 1:
+                            data = (_a.sent()).data;
+                            if (!data.length)
+                                throw new NotFoundError("Wishlists from person " + personId + " not found");
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.updateProducts = function (categoryId, _a) {
+            var products = _a.products;
+            return __awaiter(this, void 0, void 0, function () {
+                var plainData;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!('action' in products && products.action === 'remove')) return [3 /*break*/, 3];
+                            return [4 /*yield*/, this.mutation('delete_category_product', ['affected_rows'], {
+                                    where: {
+                                        type: 'category_product_bool_exp',
+                                        required: true,
+                                        value: { category_id: { _eq: categoryId } },
+                                    },
+                                })];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, this.categoryFilterRepository.deleteByCategory(categoryId)];
+                        case 2:
+                            _a.sent();
+                            return [2 /*return*/, []];
+                        case 3:
+                            plainData = this.paramsToPlain({ products: products });
+                            if (!plainData.products || plainData.products.length <= 0)
+                                return [2 /*return*/, []];
+                            return [4 /*yield*/, this.mutation('delete_category_product', ['affected_rows'], {
+                                    where: {
+                                        type: 'category_product_bool_exp',
+                                        required: true,
+                                        value: { category_id: { _eq: categoryId } },
+                                    },
+                                })];
+                        case 4:
+                            _a.sent();
+                            return [4 /*yield*/, this.categoryFilterRepository.deleteByCategory(categoryId)];
+                        case 5:
+                            _a.sent();
+                            return [4 /*yield*/, this.mutation('insert_category_product', ['affected_rows'], {
+                                    objects: {
+                                        type: '[category_product_insert_input!]',
+                                        required: true,
+                                        value: plainData.products.map(function (productId) { return ({ category_id: categoryId, product_id: productId }); }),
+                                    },
+                                })];
+                        case 6:
+                            _a.sent();
+                            return [2 /*return*/, plainData.products];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.updateMetadata = function (categoryId, _a) {
+            var metadata = _a.metadata;
+            return __awaiter(this, void 0, void 0, function () {
+                var plainData;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            plainData = this.paramsToPlain({ metadata: metadata });
+                            if (!plainData.metadata)
+                                return [2 /*return*/];
+                            return [4 /*yield*/, this.mutation('update_category_metadata_by_pk', ['category_id'], {
+                                    pk_columns: {
+                                        value: { category_id: categoryId },
+                                        type: 'category_metadata_pk_columns_input',
+                                        required: true,
+                                    },
+                                    _set: {
+                                        value: lodash.omit(metadata, ['category_id']),
+                                        type: 'category_metadata_set_input',
+                                        required: true,
+                                    },
+                                })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, plainData.metadata];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.getCategoryBySlug = function (slug, _shop) {
+            return this.getWishlistBySlug(slug);
+        };
+        WishlistHasuraGraphQLRepository.prototype.getCategoryByShop = function (shop) {
+            return __awaiter(this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!shop)
+                                return [2 /*return*/];
+                            return [4 /*yield*/, this.find({
+                                    filters: {
+                                        shops: { operator: exports.Where.IN, value: [shop] },
+                                        published: { operator: exports.Where.EQUALS, value: true },
+                                        isWishlist: { operator: exports.Where.EQUALS, value: true },
+                                    },
+                                    options: {
+                                        enableCount: false,
+                                    },
+                                })];
+                        case 1:
+                            data = (_a.sent()).data;
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        };
+        WishlistHasuraGraphQLRepository.prototype.getCategoriesForHome = function (categoryIds, limit, gender) {
+            return;
+        };
+        WishlistHasuraGraphQLRepository.prototype.mountCategory = function (category, options) {
+            return;
+        };
+        WishlistHasuraGraphQLRepository.prototype.getChildren = function (parentId) {
+            return;
+        };
+        WishlistHasuraGraphQLRepository.prototype.isChild = function (id, parentId) {
+            return;
+        };
+        return WishlistHasuraGraphQLRepository;
+    }(withCrudHasuraGraphQL(withHasuraGraphQL(Base))));
+
     /**
      * Generated bundle index. Do not edit.
      */
@@ -6655,6 +7100,8 @@
     exports.VariantHasuraGraphQL = VariantHasuraGraphQL;
     exports.VariantHasuraGraphQLRepository = VariantHasuraGraphQLRepository;
     exports.WeakPasswordError = WeakPasswordError;
+    exports.Wishlist = Wishlist;
+    exports.WishlistHasuraGraphQLRepository = WishlistHasuraGraphQLRepository;
     exports.isDebuggable = isDebuggable;
     exports.isUUID = isUUID;
     exports.parseDateTime = parseDateTime;