@infrab4a/connect 5.4.0-beta.9 → 5.4.0

package/index.cjs.js

@@ -62,6 +62,18 @@ exports.OrderBlockedType = void 0;
     OrderBlockedType["Boleto"] = "Boleto";
 })(exports.OrderBlockedType || (exports.OrderBlockedType = {}));
 
+exports.OrderPaymentStatus = void 0;
+(function (OrderPaymentStatus) {
+    OrderPaymentStatus["Em processamento"] = "processing";
+    OrderPaymentStatus["Autorizada"] = "authorized";
+    OrderPaymentStatus["Pago"] = "paid";
+    OrderPaymentStatus["Estornada"] = "refunded";
+    OrderPaymentStatus["Aguardando pagamento"] = "waiting_payment";
+    OrderPaymentStatus["Aguardando estorno"] = "pending_refund";
+    OrderPaymentStatus["Recusada/N\u00E3o autorizada"] = "refused";
+    OrderPaymentStatus["Chargedback"] = "chargedback";
+})(exports.OrderPaymentStatus || (exports.OrderPaymentStatus = {}));
+
 exports.PagarmePaymentStatus = void 0;
 (function (PagarmePaymentStatus) {
     PagarmePaymentStatus["Em processamento"] = "processing";
@@ -114,6 +126,7 @@ exports.PaymentProviders = void 0;
     PaymentProviders["PAGARME"] = "pagarMe";
     PaymentProviders["ADYEN"] = "adyen";
     PaymentProviders["GLAMPOINTS"] = "glampoints";
+    PaymentProviders["MERCADOPAGO"] = "mercadoPago";
 })(exports.PaymentProviders || (exports.PaymentProviders = {}));
 
 exports.TransactionPaymentMethods = void 0;
@@ -147,6 +160,9 @@ class AntifraudProviderFactory {
 class GlampointsPaymentMethodFactory extends BasePaymentMethodFactory {
 }
 
+class MercadoPagoPaymentMethodFactory extends BasePaymentMethodFactory {
+}
+
 class PagarmePaymentMethodFactory extends BasePaymentMethodFactory {
 }
 
@@ -757,6 +773,30 @@ tslib.__decorate([
 ], Category.prototype, "filters", void 0);
 registerClass('Category', Category);
 
+class BrandCategory extends BaseModel {
+    get glamImages() {
+        return this.images?.[exports.Shops.GLAMSHOP]
+            ? this.images[exports.Shops.GLAMSHOP]
+            : {
+                brandBanner: null,
+                brandBannerMobile: null,
+                image: null,
+            };
+    }
+    get mensImages() {
+        return this.images?.[exports.Shops.MENSMARKET]
+            ? this.images[exports.Shops.MENSMARKET]
+            : {
+                brandBanner: null,
+                brandBannerMobile: null,
+                image: null,
+            };
+    }
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
 class CategoryCollectionChildren extends BaseModel {
     static get identifiersFields() {
         return ['collectionId', 'categoryId'];
@@ -1760,19 +1800,58 @@ class AntifraudCardService {
     constructor(orderRepository, orderBlockedRepository) {
         this.orderRepository = orderRepository;
         this.orderBlockedRepository = orderBlockedRepository;
-        this.LIMIT_ORDERS_DAY = 2;
-        this.LIMIT_ORDERS_WEEK = 7;
-        this.LIMIT_BLOCKED_ORDERS_DAY = 5;
+        this.LIMIT_ORDERS_DAY = null;
+        this.LIMIT_ORDERS_WEEK = null;
     }
     async validate(checkout, card) {
+        this.setLimitsByUserType(checkout.user.isSubscriber);
         await this.validateBlockedOrderAttempts(checkout, card);
         await this.validateDayAndWeekOrderLimits(checkout, card);
         return true;
     }
+    setLimitsByUserType(isSubscriber) {
+        this.LIMIT_ORDERS_DAY = {
+            subscriber: {
+                cpf: 4,
+                email: 4,
+                phone: 4,
+                card: 4,
+                zip: 4,
+            },
+            nonSubscriber: {
+                cpf: 2,
+                email: 2,
+                phone: 2,
+                card: 2,
+                zip: 2,
+            },
+        };
+        this.LIMIT_ORDERS_WEEK = {
+            subscriber: {
+                cpf: 12,
+                email: 12,
+                phone: 12,
+                card: 12,
+                zip: Infinity,
+            },
+            nonSubscriber: {
+                cpf: 7,
+                email: 7,
+                phone: 7,
+                card: 7,
+                zip: Infinity,
+            },
+        };
+        this.LIMIT_BLOCKED_ORDERS_DAY = isSubscriber ? 7 : 5;
+    }
+    getLimitsByUserType(type, isSubscriber) {
+        const limits = type === 'day' ? this.LIMIT_ORDERS_DAY : this.LIMIT_ORDERS_WEEK;
+        return isSubscriber ? limits['subscriber'] : limits['nonSubscriber'];
+    }
     async validateBlockedOrderAttempts(checkout, card) {
         const isValid = await this.verifyBlockedOrderAttempts(checkout, card);
         if (!isValid) {
-            throw new FraudValidationError('Cliente com mais de 5 compras negadas/bloqueadas no dia', {
+            throw new FraudValidationError(`Cliente com mais de ${this.LIMIT_BLOCKED_ORDERS_DAY} compras negadas/bloqueadas no dia`, {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -1786,7 +1865,7 @@ class AntifraudCardService {
     async validateDayAndWeekOrderLimits(checkout, card) {
         const isValid = await this.verifyDayAndWeekOrders(checkout, card);
         if (!isValid) {
-            throw new FraudValidationError('Cliente tentando comprar mais de 2 vezes no dia ou 7 vezes na semana', {
+            throw new FraudValidationError('Cliente tentando comprar mais do que o permitido no dia/semana', {
                 checkoutId: checkout.id,
                 userEmail: checkout.user.email,
                 info: {
@@ -1805,7 +1884,7 @@ class AntifraudCardService {
             await this.createBlockedOrderRecord({
                 checkout,
                 card,
-                reason: 'More than 5 attempts have failed',
+                reason: `More than ${this.LIMIT_BLOCKED_ORDERS_DAY} attempts have failed`,
                 key: 'Failed attempts',
                 period: 'day',
             });
@@ -1815,7 +1894,7 @@ class AntifraudCardService {
     }
     getTodayDateRange() {
         const timeZone = 'America/Sao_Paulo';
-        const today = dateFnsTz.toZonedTime(new Date(), timeZone);
+        const today = dateFnsTz.utcToZonedTime(new Date(), timeZone);
         const day = dateFns.startOfDay(today);
         const endOfDay = dateFns.endOfDay(today);
         return { day: dateFns.addHours(day, 3), endOfDay: dateFns.addHours(endOfDay, 3) };
@@ -1926,26 +2005,28 @@ class AntifraudCardService {
     }
     async validateDayOrderLimits(checkout, params) {
         const ordersPerDay = await this.validateOrdersByRange(params, this.getDateRange('day'));
+        const limits = this.getLimitsByUserType('day', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerDay,
-            limit: this.LIMIT_ORDERS_DAY,
+            limit: limits,
             period: 'day',
         });
     }
     async validateWeekOrderLimits(checkout, params) {
         const ordersPerWeek = await this.validateOrdersByRange(params, this.getDateRange('week'));
+        const limits = this.getLimitsByUserType('week', checkout.user.isSubscriber);
         return this.checkOrderLimitsAndBlock({
             checkout,
             orderCounts: ordersPerWeek,
-            limit: this.LIMIT_ORDERS_WEEK,
+            limit: limits,
             period: 'week',
         });
     }
     async checkOrderLimitsAndBlock(params) {
         const { checkout, orderCounts, limit, period } = params;
         for (const key in orderCounts) {
-            if (orderCounts[key] >= limit) {
+            if (orderCounts[key] >= limit[key]) {
                 await this.createBlockedOrderRecord({
                     checkout,
                     card: null,
@@ -4763,6 +4844,17 @@ const withCrudFirestore = (MixinBase) => {
     };
 };
 
+class BrandCategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors, }) {
+        super({
+            firestore,
+            collectionName: 'brandsCategory',
+            model: BrandCategory,
+            interceptors,
+        });
+    }
+}
+
 class CategoryFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors }) {
         super({
@@ -5851,9 +5943,6 @@ tslib.__decorate([
     tslib.__metadata("design:type", Product)
 ], KitProductHasuraGraphQL.prototype, "product", void 0);
 
-class ProductCatalogHasuraGraphQL extends Product {
-}
-
 class ProductHasuraGraphQL extends Product {
 }
 tslib.__decorate([
@@ -7219,7 +7308,83 @@ class FilterOptionHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasu
     }
 }
 
-const commonFields$1 = [
+class ProductErrorsHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
+    constructor({ endpoint, authOptions, interceptors, cache, }, productRepository) {
+        super({
+            tableName: 'product_errors',
+            model: ProductErrorsHasuraGraphQL,
+            endpoint,
+            authOptions,
+            interceptors,
+            cache,
+            fields: [
+                {
+                    productId: {
+                        columnName: 'product_id',
+                        to: (value) => +value,
+                        from: (value) => value.toString(),
+                    },
+                },
+                'source',
+                'error',
+                { createdAt: { columnName: 'created_at' } },
+                { updatedAt: { columnName: 'updated_at' } },
+                {
+                    product: {
+                        columnName: 'product',
+                        foreignKeyColumn: { id: 'productId' },
+                        fields: [
+                            { id: { columnName: 'id', from: (value) => value.toString() } },
+                            { productId: { columnName: 'main_product_id' } },
+                            'name',
+                            'published',
+                            'group',
+                            'validity',
+                            { createdAt: { columnName: 'created_at' } },
+                            { updatedAt: { columnName: 'updated_at' } },
+                        ],
+                    },
+                },
+            ],
+        });
+        this.productRepository = productRepository;
+    }
+    async get(params) {
+        const result = await super.get(params);
+        if (result instanceof VariantHasuraGraphQL) {
+            const product = await this.productRepository.get({ id: result.productId.toString() });
+            result.product.name = product.name;
+            result.product.group = product.group;
+        }
+        return result;
+    }
+    async find(params) {
+        const result = await super.find(params);
+        const variantsWithNoData = result.data.filter((item) => item.product instanceof VariantHasuraGraphQL &&
+            (lodash.isEmpty(item.product.name) || lodash.isEmpty(item.product.group) || lodash.isEmpty(item.product)));
+        if (variantsWithNoData.length > 0) {
+            const { data: products } = await this.productRepository.find({
+                filters: {
+                    id: {
+                        operator: exports.Where.IN,
+                        value: Array.from(new Set(variantsWithNoData.map((item) => item.product.productId?.toString()))),
+                    },
+                },
+            });
+            products.forEach((product) => {
+                result.data
+                    .filter((variant) => variant.product.productId?.toString() === product.id.toString())
+                    .forEach((variant) => {
+                    variant.product.name = product.name;
+                    variant.product.group = product.group;
+                });
+            });
+        }
+        return result;
+    }
+}
+
+const commonFields = [
     {
         id: {
             columnName: 'id',
@@ -7386,401 +7551,29 @@ const commonFields$1 = [
     { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
     { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
     { daysOfUse: { columnName: 'days_of_use' } },
-    { showVariants: { columnName: 'show_variants' } },
-    { variantSlug: { columnName: 'variant_slug' } },
 ];
-class ProductCatalogHasuraGraphQLRepository extends withFindHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor({ endpoint, authOptions, interceptors, cache, }) {
-        super({
-            tableName: 'product_catalog',
-            model: ProductCatalogHasuraGraphQL,
-            endpoint,
-            authOptions,
-            interceptors,
-            fields: commonFields$1,
-            cache,
-        });
-    }
-    async get({ id }, options) {
-        if (this.cache?.cacheAdapter && options?.cache?.enabled) {
-            const cacheKey = `${this.model.name.toLowerCase()}:id:${id}`;
-            const cachedData = await this.cache.cacheAdapter.get(cacheKey);
-            if (cachedData) {
-                this.logger.log(`Dados recuperados do cache: ${cacheKey}`);
-                return this.model.toInstance(deserialize(cachedData));
-            }
-        }
-        const product = await super
-            .find({
-            filters: {
-                id,
-            },
-            limits: {
-                limit: 1,
-            },
-        })
-            .then((res) => res.data.at(0));
-        if (!product)
-            throw new NotFoundError(`Product not found`);
-        if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
-            const cacheKey = `${this.model.name.toLowerCase()}:id:${id}`;
-            await this.cache.cacheAdapter.set({
-                key: cacheKey,
-                data: serialize(product),
-                expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
-            });
-            this.logger.log(`Dados salvos no cache: ${cacheKey}`);
-        }
-        return product;
-    }
-    async getByEAN(EAN, options) {
-        if (this.cache?.cacheAdapter && options?.cache?.enabled) {
-            const cacheKey = `${this.model.name.toLowerCase()}:EAN:${EAN}`;
-            const cachedData = await this.cache.cacheAdapter.get(cacheKey);
-            if (cachedData) {
-                this.logger.log(`Dados recuperados do cache: ${cacheKey}`);
-                return this.model.toInstance(deserialize(cachedData));
-            }
-        }
-        const product = await super
-            .find({
-            filters: {
-                EAN,
-            },
-            limits: {
-                limit: 1,
-            },
-        })
-            .then((res) => res.data.at(0));
-        if (!product)
-            return null;
-        RoundProductPricesHelper.roundProductPrices(product);
-        if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
-            const cacheKey = `${this.model.name.toLowerCase()}:EAN:${EAN}`;
-            await this.cache.cacheAdapter.set({
-                key: cacheKey,
-                data: serialize(product),
-                expirationInSeconds: options?.cache?.ttl || this.cache.ttlDefault,
-            });
-            this.logger.log(`Dados salvos no cache: ${cacheKey}`);
-        }
-        return product;
-    }
-    async find(params, optionsParams) {
-        const { filters, fields, ...options } = params || {};
-        const bindFields = fields ||
-            this.fields
-                .map((field) => (typeof field === 'string' ? field : Object.keys(field).shift()))
-                .filter((field) => field !== 'reviews' && field !== 'categories');
-        if (options.options?.minimal?.includes('price'))
-            options.options?.minimal.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
-        if (options.options?.maximum?.includes('price'))
-            options.options?.maximum.push('price.price', 'price.fullPrice', 'price.subscriberPrice');
-        options.options?.minimal?.splice(options.options?.minimal.indexOf('price'), 1);
-        options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1);
-        return super.find({
-            ...options,
-            filters: { ...filters },
+const fieldsConfiguration$2 = [
+    ...commonFields,
+    {
+        categories: {
+            columnName: 'categories',
+            fields: ['category_id'],
+            bindPersistData: (value) => ({
+                categories: { data: value.map((category) => ({ category_id: +category })) },
+            }),
+            to: (categories) => categories.map((categoryId) => +categoryId),
+            from: (categories) => categories?.map((category) => category?.category_id?.toString()) || [],
+        },
+    },
+    {
+        kitProducts: {
+            columnName: 'kit_products',
+            foreignKeyColumn: { productId: 'id' },
             fields: [
-                ...bindFields,
-                ...(bindFields.includes('price')
-                    ? [
-                        'subscriberPrice',
-                        'subscriberDiscountPercentage',
-                        'fullPrice',
-                    ]
-                    : []),
-            ],
-        }, optionsParams);
-    }
-    async findCatalog(params, mainGender, options) {
-        const result = await this.find({
-            ...params,
-            filters: { ...params.filters, published: true },
-            orderBy: {
-                hasStock: 'desc',
-                ...(!mainGender ? {} : { intGender: mainGender === 'female' ? 'desc' : 'asc' }),
-                ...lodash.omit(params.orderBy, ['hasStock', 'intGender']),
-            },
-        }, options);
-        return result;
-    }
-}
-tslib.__decorate([
-    Log(),
-    tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [Object, Object, Object]),
-    tslib.__metadata("design:returntype", Promise)
-], ProductCatalogHasuraGraphQLRepository.prototype, "findCatalog", null);
-
-class ProductErrorsHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor({ endpoint, authOptions, interceptors, cache, }, productRepository) {
-        super({
-            tableName: 'product_errors',
-            model: ProductErrorsHasuraGraphQL,
-            endpoint,
-            authOptions,
-            interceptors,
-            cache,
-            fields: [
-                {
-                    productId: {
-                        columnName: 'product_id',
-                        to: (value) => +value,
-                        from: (value) => value.toString(),
-                    },
-                },
-                'source',
-                'error',
-                { createdAt: { columnName: 'created_at' } },
-                { updatedAt: { columnName: 'updated_at' } },
-                {
-                    product: {
-                        columnName: 'product',
-                        foreignKeyColumn: { id: 'productId' },
-                        fields: [
-                            { id: { columnName: 'id', from: (value) => value.toString() } },
-                            { productId: { columnName: 'main_product_id' } },
-                            'name',
-                            'published',
-                            'group',
-                            'validity',
-                            { createdAt: { columnName: 'created_at' } },
-                            { updatedAt: { columnName: 'updated_at' } },
-                        ],
-                    },
-                },
-            ],
-        });
-        this.productRepository = productRepository;
-    }
-    async get(params) {
-        const result = await super.get(params);
-        if (result instanceof VariantHasuraGraphQL) {
-            const product = await this.productRepository.get({ id: result.productId.toString() });
-            result.product.name = product.name;
-            result.product.group = product.group;
-        }
-        return result;
-    }
-    async find(params) {
-        const result = await super.find(params);
-        const variantsWithNoData = result.data.filter((item) => item.product instanceof VariantHasuraGraphQL &&
-            (lodash.isEmpty(item.product.name) || lodash.isEmpty(item.product.group) || lodash.isEmpty(item.product)));
-        if (variantsWithNoData.length > 0) {
-            const { data: products } = await this.productRepository.find({
-                filters: {
-                    id: {
-                        operator: exports.Where.IN,
-                        value: Array.from(new Set(variantsWithNoData.map((item) => item.product.productId?.toString()))),
-                    },
-                },
-            });
-            products.forEach((product) => {
-                result.data
-                    .filter((variant) => variant.product.productId?.toString() === product.id.toString())
-                    .forEach((variant) => {
-                    variant.product.name = product.name;
-                    variant.product.group = product.group;
-                });
-            });
-        }
-        return result;
-    }
-}
-
-const commonFields = [
-    {
-        id: {
-            columnName: 'id',
-            to: (value) => +value,
-            from: (value) => value.toString(),
-        },
-    },
-    { firestoreId: { columnName: 'firestore_id' } },
-    { productId: { columnName: 'main_product_id' } },
-    { CEST: { columnName: 'cest' } },
-    { EAN: { columnName: 'ean' } },
-    { NCM: { columnName: 'ncm' } },
-    'brand',
-    { costPrice: { columnName: 'cost_price' } },
-    {
-        description: {
-            columnName: 'description',
-            from: (description, data) => ({
-                description,
-                differentials: data.differentials,
-                whoMustUse: data.who_must_use,
-                howToUse: data.how_to_use,
-                brand: data.brand_description,
-                ingredients: data.ingredients,
-                purpose: data.purpose,
-            }),
-            bindFindFilter: (filters) => {
-                return {
-                    ...(filters?.description && { description: filters.description }),
-                    ...(filters.differentials && { differentials: filters.differentials }),
-                    ...(filters.whoMustUse && {
-                        who_must_use: filters.whoMustUse,
-                    }),
-                    ...(filters.howToUse && {
-                        how_to_use: filters.howToUse,
-                    }),
-                    ...(filters.brand && {
-                        brand_description: filters.brand,
-                    }),
-                    ...(filters.ingredients && {
-                        ingredients: filters.ingredients,
-                    }),
-                    ...(filters.purpose && {
-                        purpose: filters.purpose,
-                    }),
-                };
-            },
-            bindPersistData: (descriptionData) => ({
-                ...(descriptionData?.description && { description: descriptionData.description }),
-                ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
-                ...(descriptionData.whoMustUse && {
-                    who_must_use: descriptionData.whoMustUse,
-                }),
-                ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
-                ...(descriptionData.brand && { brand_description: descriptionData.brand }),
-                ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
-                ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
-            }),
-        },
-    },
-    { differentials: { columnName: 'differentials' } },
-    { whoMustUse: { columnName: 'who_must_use' } },
-    { howToUse: { columnName: 'how_to_use' } },
-    { brandDescription: { columnName: 'brand_description' } },
-    { ingredients: { columnName: 'ingredients' } },
-    { purpose: { columnName: 'purpose' } },
-    { hasVariants: { columnName: 'has_variants' } },
-    {
-        images: {
-            columnName: 'images',
-            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
-        },
-    },
-    {
-        miniatures: {
-            columnName: 'miniatures',
-            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
-        },
-    },
-    {
-        imagesCard: {
-            columnName: 'images_card',
-            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
-        },
-    },
-    'name',
-    {
-        price: {
-            columnName: 'price',
-            from: (price, data) => ({
-                price,
-                fullPrice: data.full_price,
-                subscriberDiscountPercentage: data.subscriber_discount_percentage,
-                fullPriceDiscountPercentage: data.full_price_discount_percentage,
-                subscriberPrice: data.subscriber_price,
-            }),
-            bindFindFilter: (filters) => {
-                return {
-                    ...((filters?.price || filters?.price === 0) && { price: filters.price }),
-                    ...((filters.fullPrice || filters.fullPrice === 0) && { full_price: filters.fullPrice }),
-                    ...((filters.subscriberDiscountPercentage || filters.subscriberDiscountPercentage === 0) && {
-                        subscriber_discount_percentage: filters.subscriberDiscountPercentage,
-                    }),
-                    ...((filters.subscriberPrice || filters.subscriberPrice === 0) && {
-                        subscriber_price: filters.subscriberPrice,
-                    }),
-                    ...((filters.fullPriceDiscountPercentage || filters.fullPriceDiscountPercentage === 0) && {
-                        full_price_discount_percentage: filters.fullPriceDiscountPercentage,
-                    }),
-                };
-            },
-            bindPersistData: (priceData) => ({
-                ...(priceData?.price >= 0 && { price: priceData.price }),
-                ...(priceData.fullPrice >= 0 && { full_price: priceData.fullPrice }),
-                ...(priceData.subscriberDiscountPercentage >= 0 && {
-                    subscriber_discount_percentage: priceData.subscriberDiscountPercentage,
-                }),
-                ...(priceData.subscriberPrice >= 0 && { subscriber_price: priceData.subscriberPrice }),
-                ...(priceData.fullPriceDiscountPercentage >= 0 && {
-                    full_price_discount_percentage: priceData.fullPriceDiscountPercentage,
-                }),
-            }),
-        },
-    },
-    { fullPrice: { columnName: 'full_price' } },
-    { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
-    { fullPriceDiscountPercentage: { columnName: 'full_price_discount_percentage' } },
-    { subscriberPrice: { columnName: 'subscriber_price' } },
-    'published',
-    'outlet',
-    'label',
-    'sku',
-    {
-        stock: {
-            columnName: 'stock',
-            from: (quantity) => ({ quantity }),
-            to: (value) => (lodash.isNil(value?.quantity) ? value : value?.quantity),
-        },
-    },
-    { hasStock: { columnName: 'has_stock' } },
-    'slug',
-    'type',
-    'video',
-    'weight',
-    'gender',
-    { intGender: { columnName: 'int_gender' } },
-    { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
-    { isKit: { columnName: 'is_kit' } },
-    { createdAt: { columnName: 'created_at' } },
-    { updatedAt: { columnName: 'updated_at' } },
-    { rate: { columnName: 'rating' } },
-    { reviewsTotal: { columnName: 'reviews_total' } },
-    { shoppingCount: { columnName: 'shopping_count' } },
-    { categoryId: { columnName: 'category_id' } },
-    {
-        category: {
-            columnName: 'category',
-            foreignKeyColumn: { id: 'categoryId' },
-            fields: ['id', 'name', 'reference', 'slug'],
-        },
-    },
-    'group',
-    'validity',
-    { tagsCollection: { columnName: 'tags_collection', type: HasuraGraphQLColumnType.Jsonb } },
-    { tagsProfile: { columnName: 'tags_profile', type: HasuraGraphQLColumnType.Jsonb } },
-    { daysOfUse: { columnName: 'days_of_use' } },
-    { showVariants: { columnName: 'show_variants' } },
-    { variantSlug: { columnName: 'variant_slug' } },
-];
-const fieldsConfiguration$2 = [
-    ...commonFields,
-    {
-        categories: {
-            columnName: 'categories',
-            fields: ['category_id'],
-            bindPersistData: (value) => ({
-                categories: { data: value.map((category) => ({ category_id: +category })) },
-            }),
-            to: (categories) => categories.map((categoryId) => +categoryId),
-            from: (categories) => categories?.map((category) => category?.category_id?.toString()) || [],
-        },
-    },
-    {
-        kitProducts: {
-            columnName: 'kit_products',
-            foreignKeyColumn: { productId: 'id' },
-            fields: [
-                { productId: { columnName: 'product_id' } },
-                { kitProductId: { columnName: 'kit_product_id' } },
-                'quantity',
-                { product: { columnName: 'product', foreignKeyColumn: { id: 'product_id' }, fields: commonFields } },
+                { productId: { columnName: 'product_id' } },
+                { kitProductId: { columnName: 'kit_product_id' } },
+                'quantity',
+                { product: { columnName: 'product', foreignKeyColumn: { id: 'product_id' }, fields: commonFields } },
             ],
         },
     },
@@ -7821,61 +7614,9 @@ const fieldsConfiguration$2 = [
             foreignKeyColumn: { product_id: 'id' },
             fields: [
                 'id',
-                'name',
                 'ean',
                 'sku',
-                {
-                    description: {
-                        columnName: 'description',
-                        from: (description, data) => ({
-                            description,
-                            differentials: data.differentials,
-                            whoMustUse: data.who_must_use,
-                            howToUse: data.how_to_use,
-                            brand: data.brand_description,
-                            ingredients: data.ingredients,
-                            purpose: data.purpose,
-                        }),
-                        bindFindFilter: (filters) => {
-                            return {
-                                ...(filters?.description && { description: filters.description }),
-                                ...(filters.differentials && { differentials: filters.differentials }),
-                                ...(filters.whoMustUse && {
-                                    who_must_use: filters.whoMustUse,
-                                }),
-                                ...(filters.howToUse && {
-                                    how_to_use: filters.howToUse,
-                                }),
-                                ...(filters.brand && {
-                                    brand_description: filters.brand,
-                                }),
-                                ...(filters.ingredients && {
-                                    ingredients: filters.ingredients,
-                                }),
-                                ...(filters.purpose && {
-                                    purpose: filters.purpose,
-                                }),
-                            };
-                        },
-                        bindPersistData: (descriptionData) => ({
-                            ...(descriptionData?.description && { description: descriptionData.description }),
-                            ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
-                            ...(descriptionData.whoMustUse && {
-                                who_must_use: descriptionData.whoMustUse,
-                            }),
-                            ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
-                            ...(descriptionData.brand && { brand_description: descriptionData.brand }),
-                            ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
-                            ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
-                        }),
-                    },
-                },
-                { differentials: { columnName: 'differentials' } },
-                { whoMustUse: { columnName: 'who_must_use' } },
-                { howToUse: { columnName: 'how_to_use' } },
-                { brandDescription: { columnName: 'brand_description' } },
-                { ingredients: { columnName: 'ingredients' } },
-                { purpose: { columnName: 'purpose' } },
+                'description',
                 {
                     grade: {
                         columnName: 'grade',
@@ -7921,6 +7662,10 @@ const fieldsConfiguration$2 = [
                         }),
                     },
                 },
+                { fullPrice: { columnName: 'full_price' } },
+                { subscriberDiscountPercentage: { columnName: 'subscriber_discount_percentage' } },
+                { subscriberPrice: { columnName: 'subscriber_price' } },
+                { fullPriceDiscountPercentage: { columnName: 'full_price_discount_percentage' } },
                 'published',
                 {
                     stock: {
@@ -7949,29 +7694,6 @@ const fieldsConfiguration$2 = [
                 },
                 { tagsProfile: { columnName: 'tags_profile' } },
                 { tagsCollection: { columnName: 'tags_collection' } },
-                { variantSlug: { columnName: 'variant_slug' } },
-                {
-                    reviews: {
-                        columnName: 'reviews',
-                        foreignKeyColumn: { product_id: 'id' },
-                        fields: [
-                            'id',
-                            'shop',
-                            'rate',
-                            'author',
-                            'email',
-                            'location',
-                            'review',
-                            'status',
-                            'title',
-                            { personId: { columnName: 'person_id' } },
-                            'points',
-                            { orderId: { columnName: 'order_id' } },
-                            { createdAt: { columnName: 'created_at' } },
-                            { updatedAt: { columnName: 'updated_at' } },
-                        ],
-                    },
-                },
             ],
         },
     },
@@ -8037,12 +7759,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             : await super.get(identifiers, options);
         if (product.productId)
             throw new NotFoundError('Product not found, it is a variant');
-        product.reviews = product.reviews || (await this.findReviewsByProduct(+product.id, false, options));
-        if (!product.variants?.length) {
-            for (const [index, variant] of product.variants.entries()) {
-                product.variants[index].reviews = await this.findReviewsByProduct(+variant.id, true);
-            }
-        }
+        product.reviews = product.reviews || (await this.findReviewsByProduct(+product.id, options));
         return product;
     }
     async find(params, optionsParams) {
@@ -8059,7 +7776,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         options.options?.maximum?.splice(options.options?.maximum.indexOf('price'), 1);
         return super.find({
             ...options,
-            filters: { ...filters },
+            filters: { ...filters, productId: { operator: exports.Where.ISNULL } },
             fields: [
                 ...bindFields,
                 ...(bindFields.includes('price')
@@ -8084,9 +7801,6 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         const result = await this.find({
             filters: {
                 slug,
-                productId: {
-                    operator: exports.Where.ISNULL,
-                },
             },
             fields: this.fields.map((field) => typeof field === 'string' ? field : Object.keys(field).shift()),
             options: {
@@ -8096,11 +7810,6 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         if (!result.data.length)
             return null;
         const product = result?.data?.shift();
-        if (!product.variants?.length) {
-            for (const [index, variant] of product.variants.entries()) {
-                product.variants[index].reviews = await this.findReviewsByProduct(+variant.id, true);
-            }
-        }
         RoundProductPricesHelper.roundProductPrices(product);
         if (this.cache?.cacheAdapter && options?.cache?.enabled && product) {
             const cacheKey = `${this.model.name.toLowerCase()}:slug:${slug}`;
@@ -8302,7 +8011,7 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             return data?.[0]?.id;
         throw new NotFoundError(`Product with id ${id} not found`);
     }
-    async findReviewsByProduct(productId, onlyApproved, options) {
+    async findReviewsByProduct(productId, options) {
         if (this.cache?.cacheAdapter && options?.cache?.enabled) {
             const cacheKey = `${this.model.name.toLowerCase()}:reviews:product:${productId}`;
             const cachedData = await this.cache.cacheAdapter.get(cacheKey);
@@ -8315,16 +8024,10 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             where: {
                 value: {
                     product_id: { _eq: productId },
-                    ...(onlyApproved && { status: { _eq: true } }),
                 },
                 type: 'product_review_bool_exp',
                 required: true,
             },
-            order_by: {
-                type: '[product_review_order_by]',
-                value: [{ createdAt: 'desc' }],
-                required: true,
-            },
         });
         const reviews = data?.map((review) => this.bindReviewToModel(review));
         if (this.cache?.cacheAdapter && options?.cache?.enabled && reviews) {
@@ -8429,7 +8132,7 @@ tslib.__decorate([
 tslib.__decorate([
     Log(),
     tslib.__metadata("design:type", Function),
-    tslib.__metadata("design:paramtypes", [Number, Boolean, Object]),
+    tslib.__metadata("design:paramtypes", [Number, Object]),
     tslib.__metadata("design:returntype", Promise)
 ], ProductHasuraGraphQLRepository.prototype, "findReviewsByProduct", null);
 
@@ -8668,115 +8371,15 @@ const fieldsConfiguration$1 = [
     {
         miniatures: {
             columnName: 'miniatures',
-            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
-        },
-    },
-    {
-        imagesCard: {
-            columnName: 'images_card',
-            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
-        },
-    },
-    'slug',
-    'brand',
-    'name',
-    'sku',
-    { NCM: { columnName: 'ncm' } },
-    { CEST: { columnName: 'cest' } },
-    {
-        description: {
-            columnName: 'description',
-            from: (description, data) => ({
-                description,
-                differentials: data.differentials,
-                whoMustUse: data.who_must_use,
-                howToUse: data.how_to_use,
-                brand: data.brand_description,
-                ingredients: data.ingredients,
-                purpose: data.purpose,
-            }),
-            bindFindFilter: (filters) => {
-                return {
-                    ...(filters?.description && { description: filters.description }),
-                    ...(filters.differentials && { differentials: filters.differentials }),
-                    ...(filters.whoMustUse && {
-                        who_must_use: filters.whoMustUse,
-                    }),
-                    ...(filters.howToUse && {
-                        how_to_use: filters.howToUse,
-                    }),
-                    ...(filters.brand && {
-                        brand_description: filters.brand,
-                    }),
-                    ...(filters.ingredients && {
-                        ingredients: filters.ingredients,
-                    }),
-                    ...(filters.purpose && {
-                        purpose: filters.purpose,
-                    }),
-                };
-            },
-            bindPersistData: (descriptionData) => ({
-                ...(descriptionData?.description && { description: descriptionData.description }),
-                ...(descriptionData.differentials && { differentials: descriptionData.differentials }),
-                ...(descriptionData.whoMustUse && {
-                    who_must_use: descriptionData.whoMustUse,
-                }),
-                ...(descriptionData.howToUse && { how_to_use: descriptionData.howToUse }),
-                ...(descriptionData.brand && { brand_description: descriptionData.brand }),
-                ...(descriptionData.ingredients && { ingredients: descriptionData.ingredients }),
-                ...(descriptionData.purpose && { purpose: descriptionData.purpose }),
-            }),
-        },
-    },
-    { differentials: { columnName: 'differentials' } },
-    { whoMustUse: { columnName: 'who_must_use' } },
-    { howToUse: { columnName: 'how_to_use' } },
-    { brandDescription: { columnName: 'brand_description' } },
-    { ingredients: { columnName: 'ingredients' } },
-    { purpose: { columnName: 'purpose' } },
-    'gender',
-    { intGender: { columnName: 'int_gender' } },
-    'label',
-    { filters: { columnName: 'filters', type: HasuraGraphQLColumnType.Jsonb } },
-    { rate: { columnName: 'rating' } },
-    { reviewsTotal: { columnName: 'reviews_total' } },
-    { shoppingCount: { columnName: 'shopping_count' } },
-    { categoryId: { columnName: 'category_id' } },
-    {
-        metadata: {
-            columnName: 'metadata',
-            fields: ['title', 'description'],
-            bindPersistData: (value) => ({
-                metadata: { data: value },
-            }),
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
         },
     },
     {
-        reviews: {
-            columnName: 'reviews',
-            foreignKeyColumn: { product_id: 'id' },
-            fields: [
-                'id',
-                'shop',
-                'rate',
-                'author',
-                'email',
-                'location',
-                'review',
-                'status',
-                'title',
-                { personId: { columnName: 'person_id' } },
-                'points',
-                { orderId: { columnName: 'order_id' } },
-                { createdAt: { columnName: 'created_at' } },
-                { updatedAt: { columnName: 'updated_at' } },
-            ],
+        imagesCard: {
+            columnName: 'images_card',
+            to: (value) => (value?.length > 0 ? `{"${value?.join?.('","') || ''}"}` : '{}'),
         },
     },
-    { variantSlug: { columnName: 'variant_slug' } },
-    { createdAt: { columnName: 'created_at' } },
-    { updatedAt: { columnName: 'updated_at' } },
 ];
 class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
@@ -8817,37 +8420,18 @@ class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
         return data.at(0);
     }
     async update(params) {
-        const { productId, id: checkId, metadata, ...data } = params;
+        const { productId, id: checkId, ...data } = params;
         const dataWithProductId = this.paramsToPlain({ id: checkId, productId });
         if (!dataWithProductId.id) {
             throw new NotFoundError('Variant ID is required for update');
         }
         const id = await this.getId(dataWithProductId.id);
         const product = await super.update({ id, ...data });
-        product.metadata = metadata && (await this.updateMetadata(+id, { metadata }));
         if (dataWithProductId.productId) {
             product.productId = dataWithProductId.productId;
         }
         return product;
     }
-    async updateMetadata(productId, { metadata }) {
-        const plainData = this.paramsToPlain({ metadata });
-        if (!plainData.metadata)
-            return null;
-        await this.mutation('update_product_metadata_by_pk', ['product_id'], {
-            pk_columns: {
-                value: { product_id: productId },
-                type: 'product_metadata_pk_columns_input',
-                required: true,
-            },
-            _set: {
-                value: lodash.omit(metadata, ['product_id']),
-                type: 'product_metadata_set_input',
-                required: true,
-            },
-        });
-        return plainData.metadata;
-    }
     async getId(id) {
         if (!Number.isNaN(+id))
             return id;
@@ -9191,6 +8775,438 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], WishlistHasuraGraphQLRepository.prototype, "findBfluOrGlamgirlWishlists", null);
 
+class MercadoPagoRequestHelper {
+    static build(data) {
+        const { checkout, method, postback, card } = data;
+        return {
+            transaction_amount: +checkout.totalPrice.toFixed(2),
+            notification_url: postback,
+            metadata: {
+                checkoutId: checkout.id,
+            },
+            payer: this.buildPayer(checkout, card),
+            statement_descriptor: checkout.shop === exports.Shops.GLAMSHOP ? 'Glam' : 'Mens Market',
+            additional_info: {
+                items: this.buildItems(checkout),
+            },
+            ...(method === 'credit_card' && this.buildCardPayment(card)),
+            ...(method === 'pix' && this.buildPixPayment()),
+            ...(method === 'boleto' && this.buildBoletoPayment(checkout)),
+        };
+    }
+    static buildItems(checkout) {
+        return checkout.lineItems
+            .filter((item) => !item.isGift)
+            .map((item) => {
+            return {
+                id: item.EAN,
+                title: item.name,
+                description: item.name,
+                picture_url: item.image ?? null,
+                category_id: item.category?.id ?? null,
+                quantity: item.quantity,
+                unit_price: +item.pricePaid.toFixed(2),
+            };
+        });
+    }
+    static buildPayer(checkout, card) {
+        return {
+            ...(card && { id: card.customerId }),
+            first_name: checkout.user.firstName,
+            last_name: checkout.user.lastName,
+            email: checkout.user.email,
+            identification: {
+                type: 'CPF',
+                number: checkout.user.cpf.replace(/\D/g, ''),
+            },
+        };
+    }
+    static buildFullPayer(checkout) {
+        return {
+            first_name: checkout.user.firstName,
+            last_name: checkout.user.lastName,
+            phone: {
+                area_code: checkout.user.phone.substring(0, 2),
+                number: checkout.user.phone.substring(2),
+            },
+            address: {
+                zip_code: checkout.shippingAddress.zip,
+                street_name: `${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+                street_number: checkout.shippingAddress.number,
+                neighborhood: checkout.shippingAddress.district,
+                city: checkout.shippingAddress.city,
+                federal_unit: checkout.shippingAddress.state,
+            },
+        };
+    }
+    static buildCardPayment(card) {
+        return {
+            installments: card.installments,
+            token: card.cardId,
+            binary_mode: true,
+            capture: true,
+        };
+    }
+    static buildPixPayment() {
+        return {
+            payment_method_id: 'pix',
+            date_of_expiration: dateFns.format(dateFns.addDays(new Date(), 1), 'yyyy-MM-dd') + 'T23:59:59.999-03:00',
+        };
+    }
+    static buildBoletoPayment(checkout) {
+        return {
+            payment_method_id: 'bolbradesco',
+            date_of_expiration: dateFns.format(dateFns.addDays(new Date(), 3), 'yyyy-MM-dd') + 'T23:59:59.999-03:00',
+            payer: {
+                first_name: checkout.user.firstName,
+                last_name: checkout.user.lastName,
+                email: checkout.user.email,
+                identification: {
+                    type: 'CPF',
+                    number: checkout.user.cpf.replace(/\D/g, ''),
+                },
+                phone: {
+                    area_code: checkout.user.phone.substring(0, 2),
+                    number: checkout.user.phone.substring(2),
+                },
+                address: {
+                    zip_code: checkout.shippingAddress.zip.replace(/\D/g, ''),
+                    street_name: `${checkout.shippingAddress.street}, ${checkout.shippingAddress.district}`,
+                    street_number: checkout.shippingAddress.number,
+                    neighborhood: checkout.shippingAddress.district,
+                    city: checkout.shippingAddress.city,
+                    federal_unit: checkout.shippingAddress.state,
+                },
+            },
+        };
+    }
+}
+
+class MercadoPagoResponseHelper {
+    static build(method, checkout, response) {
+        return Payment.toInstance({
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            userId: checkout.user.id,
+            checkoutId: checkout.id,
+            totalPrice: checkout.totalPrice,
+            paymentProvider: exports.PaymentProviders.MERCADOPAGO,
+            mercadoPagoId: response.id,
+            transaction: this.buildPaymentTransaction(method, response),
+        });
+    }
+    static buildPaymentTransaction(method, response) {
+        return PaymentTransaction.toInstance({
+            id: response.id.toString(),
+            acquirer_name: exports.PaymentProviders.MERCADOPAGO,
+            amount: response.transaction_amount,
+            status: this.statusMapping(response.status),
+            status_reason: response.status_detail?.toString(),
+            payment_method: method,
+            currency: response.currency_id?.toString(),
+            paid_amount: response.transaction_details?.total_paid_amount ?? null,
+            paid_at: response.date_approved ?? null,
+            charger_id: response.charges_details?.at(0)?.id?.toString() ?? null,
+            ...(method == exports.TransactionPaymentMethods.PIX && this.getPixReponse(response)),
+            ...(method == exports.TransactionPaymentMethods.CARD && this.getCardReponse(response)),
+            ...(method == exports.TransactionPaymentMethods.BANKSLIP && this.getBoletoReponse(response)),
+        });
+    }
+    static getBoletoReponse(response) {
+        return {
+            boleto_url: response.transaction_details?.external_resource_url?.toString(),
+            boleto_barcode: response.transaction_details?.barcode?.content?.toString(),
+            boleto_line: response.transaction_details?.digitable_line?.toString(),
+            boleto_expiration_date: response.date_of_expiration?.toString(),
+            boleto_document_number: response.transaction_details?.verification_code?.toString(),
+        };
+    }
+    static getPixReponse(response) {
+        return {
+            pix_qr_code: response.point_of_interaction?.transaction_data?.qr_code,
+            pix_expiration_date: response.date_of_expiration?.toString(),
+        };
+    }
+    static getCardReponse(response) {
+        return {
+            soft_descriptor: response.statement_descriptor?.toString(),
+            installments: response.installments,
+            card_brand: response.payment_method_id?.toString(),
+            card_first_digits: response.card?.first_six_digits?.toString(),
+            card_last_digits: response.card?.last_four_digits?.toString(),
+            card_id: response.card?.id?.toString(),
+            card_holder_name: response.card?.cardholder?.name?.toString(),
+            card_expiration_month: response.card?.expiration_month?.toString(),
+            card_expiration_year: response.card?.expiration_year?.toString(),
+            capture_method: response.payment_type_id?.toString(),
+            authorization_code: response.authorization_code?.toString(),
+            paid_amount: this.statusMapping(response.status) == 'paid' ? response.transaction_details?.total_paid_amount : null,
+            paid_at: this.statusMapping(response.status) == 'paid' ? response.date_approved : null,
+        };
+    }
+    static statusMapping(status) {
+        const statusMap = {
+            approved: 'paid',
+            pending: 'waiting_payment',
+            in_process: 'processing',
+            rejected: 'refused',
+            cancelled: 'refused',
+            refunded: 'refunded',
+            charged_back: 'chargedback',
+        };
+        return statusMap[status] || status;
+    }
+}
+
+class MercadoPagoBankSlipAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const payload = MercadoPagoRequestHelper.build({
+                checkout,
+                method: 'boleto',
+                postback: this.credentials.postback,
+            });
+            console.warn('[MERCADO PAGO BOLETO DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/payments`,
+                headers: {
+                    'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[MERCADO PAGO RESPONSE BOLETO DATA]', JSON.stringify(data));
+            const payment = await this.paymentRepository.create(MercadoPagoResponseHelper.build(exports.TransactionPaymentMethods.BANKSLIP, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.message));
+            }
+            throw new PaymentError('Houve uma falha ao gerar o boleto. Tente novamente', {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response.data?.message || error.message?.toString(),
+            });
+        }
+    }
+    getBoletoTransaction(paymentId) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+class MercadoPagoCardAxiosAdapter {
+    constructor(credentials, paymentRepository, orderBlockedRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+        this.orderBlockedRepository = orderBlockedRepository;
+    }
+    async pay(checkout, card) {
+        try {
+            const payload = await this.getPaymentPayload(checkout, card);
+            console.warn('[MERCADO PAGO CARD DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/payments`,
+                headers: {
+                    'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[MERCADO PAGO RESPONSE CARD DATA]', JSON.stringify(data));
+            if (data.status == exports.MercadoPagoStatusEnum.rejected) {
+                await this.orderBlockedRepository.createBlockedOrderOrPayment({
+                    checkout,
+                    blockType: 'Card not authorized',
+                    type: 'Card',
+                    limiteRange: 'day',
+                    card,
+                });
+                throw new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', {
+                    checkoutId: checkout.id,
+                    userEmail: checkout.user.email,
+                    info: data,
+                });
+            }
+            const payment = await this.paymentRepository.create(MercadoPagoResponseHelper.build(exports.TransactionPaymentMethods.CARD, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.message));
+            }
+            throw new PaymentError('Seu pagamento com cartão não foi autorizado. Para não perder seus produtos, pague com PIX ou outro cartão de crédito', {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response.data?.message || error.message?.toString(),
+            });
+        }
+    }
+    async getPaymentPayload(checkout, card) {
+        const cardResponse = await this.getCardByToken(card.customerId, card.cardId, card.cardCvv);
+        const payload = MercadoPagoRequestHelper.build({
+            checkout,
+            method: 'credit_card',
+            postback: this.credentials.postback,
+            card: {
+                ...card,
+                cardId: cardResponse.id,
+            },
+        });
+        return payload;
+    }
+    async addCard(card, customer) {
+        return;
+    }
+    async getCardByToken(customerId, token, cardCvv) {
+        try {
+            const payload = { cardId: token, customerId: customerId, securityCode: cardCvv };
+            console.warn('payload getCardByToken', payload);
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/card_tokens`,
+                headers: {
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            return data;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.cause));
+            }
+            throw error;
+        }
+    }
+    createCardHash(bu, shop, card) {
+        return;
+    }
+    createTransaction(info) {
+        return;
+    }
+    async createOrUpdateCustomer(customer) {
+        const { data } = await axios__default["default"]({
+            method: 'POST',
+            url: `${this.credentials.url}/v1/customers`,
+            headers: {
+                Authorization: `Bearer ${this.credentials.api_key}`,
+                'Content-Type': 'application/json',
+            },
+            data: {
+                email: customer.email,
+                first_name: customer.firstName,
+                last_name: customer.lastName,
+                phone: {
+                    area_code: customer.phone.substring(0, 2),
+                    number: customer.phone.substring(2),
+                },
+                identification: {
+                    type: 'CPF',
+                    number: customer.cpf.replace(/\D/g, ''),
+                },
+            },
+        });
+        return data;
+    }
+}
+
+class MercadoPagoPixAxiosAdapter {
+    constructor(credentials, paymentRepository) {
+        this.credentials = credentials;
+        this.paymentRepository = paymentRepository;
+    }
+    async pay(checkout) {
+        try {
+            const payload = MercadoPagoRequestHelper.build({
+                checkout,
+                method: 'pix',
+                postback: this.credentials.postback,
+            });
+            console.warn('[MERCADO PAGO PIX DATA TO SEND]', JSON.stringify(payload));
+            const { data } = await axios__default["default"]({
+                method: 'POST',
+                url: `${this.credentials.url}/v1/payments`,
+                headers: {
+                    'X-Idempotency-Key': `${checkout.id}-${new Date().getTime()}`,
+                    Authorization: `Bearer ${this.credentials.api_key}`,
+                    'Content-Type': 'application/json',
+                },
+                data: payload,
+            });
+            console.warn('[MERCADO PAGO RESPONSE PIX DATA]', JSON.stringify(data));
+            const payment = await this.paymentRepository.create(MercadoPagoResponseHelper.build(exports.TransactionPaymentMethods.PIX, checkout, data));
+            return payment;
+        }
+        catch (error) {
+            if (error instanceof axios.AxiosError) {
+                console.warn(JSON.stringify(error.response.data.message));
+            }
+            throw new PaymentError('Houve uma falha ao processar pagamento com pix', {
+                checkoutId: checkout.id,
+                userEmail: checkout.user.email,
+                info: error.response.data?.message || error.message?.toString(),
+            });
+        }
+    }
+}
+
+exports.MercadoPagoStatusDetailEnum = void 0;
+(function (MercadoPagoStatusDetailEnum) {
+    MercadoPagoStatusDetailEnum["accredited"] = "accredited";
+    MercadoPagoStatusDetailEnum["partially_refunded"] = "partially_refunded";
+    MercadoPagoStatusDetailEnum["pending_capture"] = "pending_capture";
+    MercadoPagoStatusDetailEnum["offline_process"] = "offline_process";
+    MercadoPagoStatusDetailEnum["pending_contingency"] = "pending_contingency";
+    MercadoPagoStatusDetailEnum["pending_review_manual"] = "pending_review_manual";
+    MercadoPagoStatusDetailEnum["pending_waiting_transfer"] = "pending_waiting_transfer";
+    MercadoPagoStatusDetailEnum["pending_waiting_payment"] = "pending_waiting_payment";
+    MercadoPagoStatusDetailEnum["pending_challenge"] = "pending_challenge";
+    MercadoPagoStatusDetailEnum["bank_error"] = "bank_error";
+    MercadoPagoStatusDetailEnum["cc_rejected_3ds_mandatory"] = "cc_rejected_3ds_mandatory";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_card_number"] = "cc_rejected_bad_filled_card_number";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_date"] = "cc_rejected_bad_filled_date";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_other"] = "cc_rejected_bad_filled_other";
+    MercadoPagoStatusDetailEnum["cc_rejected_bad_filled_security_code"] = "cc_rejected_bad_filled_security_code";
+    MercadoPagoStatusDetailEnum["cc_rejected_blacklist"] = "cc_rejected_blacklist";
+    MercadoPagoStatusDetailEnum["cc_rejected_call_for_authorize"] = "cc_rejected_call_for_authorize";
+    MercadoPagoStatusDetailEnum["cc_rejected_card_disabled"] = "cc_rejected_card_disabled";
+    MercadoPagoStatusDetailEnum["cc_rejected_card_error"] = "cc_rejected_card_error";
+    MercadoPagoStatusDetailEnum["cc_rejected_duplicated_payment"] = "cc_rejected_duplicated_payment";
+    MercadoPagoStatusDetailEnum["cc_rejected_high_risk"] = "cc_rejected_high_risk";
+    MercadoPagoStatusDetailEnum["cc_rejected_insufficient_amount"] = "cc_rejected_insufficient_amount";
+    MercadoPagoStatusDetailEnum["cc_rejected_invalid_installments"] = "cc_rejected_invalid_installments";
+    MercadoPagoStatusDetailEnum["cc_rejected_max_attempts"] = "cc_rejected_max_attempts";
+    MercadoPagoStatusDetailEnum["cc_rejected_other_reason"] = "cc_rejected_other_reason";
+    MercadoPagoStatusDetailEnum["cc_amount_rate_limit_exceeded"] = "cc_amount_rate_limit_exceeded";
+    MercadoPagoStatusDetailEnum["rejected_insufficient_data"] = "rejected_insufficient_data";
+    MercadoPagoStatusDetailEnum["rejected_by_bank"] = "rejected_by_bank";
+    MercadoPagoStatusDetailEnum["rejected_by_regulations"] = "rejected_by_regulations";
+    MercadoPagoStatusDetailEnum["insufficient_amount"] = "insufficient_amount";
+    MercadoPagoStatusDetailEnum["cc_rejected_card_type_not_allowed"] = "cc_rejected_card_type_not_allowed";
+})(exports.MercadoPagoStatusDetailEnum || (exports.MercadoPagoStatusDetailEnum = {}));
+
+exports.MercadoPagoStatusEnum = void 0;
+(function (MercadoPagoStatusEnum) {
+    MercadoPagoStatusEnum["approved"] = "approved";
+    MercadoPagoStatusEnum["authorized"] = "authorized";
+    MercadoPagoStatusEnum["pending"] = "pending";
+    MercadoPagoStatusEnum["in_process"] = "in_process";
+    MercadoPagoStatusEnum["rejected"] = "rejected";
+    MercadoPagoStatusEnum["cancelled"] = "cancelled";
+    MercadoPagoStatusEnum["refunded"] = "refunded";
+    MercadoPagoStatusEnum["charged_back"] = "charged_back";
+})(exports.MercadoPagoStatusEnum || (exports.MercadoPagoStatusEnum = {}));
+
 class PagarmeBankSlipAxiosAdapter {
     constructor(credentials, paymentRepository) {
         this.credentials = credentials;
@@ -9338,15 +9354,17 @@ class PagarMeV5RequestHelper {
             customer: this.buildCustomer(checkout),
             shipping: this.buildShipping(checkout),
             payments: this.buildPayment(checkout, method, card),
+            ...this.buildAdditionalInfo(checkout),
         };
     }
     static buildItems(checkout) {
+        const isSubscriber = checkout.user?.isSubscriber ?? false;
         return checkout.lineItems
             .filter((item) => !item.isGift)
             .map((item) => {
             return {
                 amount: Math.floor(item.pricePaid * 100),
-                description: item.name,
+                description: isSubscriber ? `${item.name} - ASSINANTE` : item.name,
                 quantity: item.quantity,
                 code: item.EAN,
             };
@@ -9443,6 +9461,14 @@ class PagarMeV5RequestHelper {
             },
         };
     }
+    static buildAdditionalInfo(checkout) {
+        const isSubscriber = checkout.user?.isSubscriber ?? false;
+        if (isSubscriber)
+            return {
+                antifraude_enabled: false,
+            };
+        return {};
+    }
 }
 
 class PagarMeV5ResponseHelper {
@@ -10227,14 +10253,6 @@ Object.defineProperty(exports, 'formatInTimeZone', {
   enumerable: true,
   get: function () { return dateFnsTz.formatInTimeZone; }
 });
-Object.defineProperty(exports, 'fromZonedTime', {
-  enumerable: true,
-  get: function () { return dateFnsTz.fromZonedTime; }
-});
-Object.defineProperty(exports, 'toZonedTime', {
-  enumerable: true,
-  get: function () { return dateFnsTz.toZonedTime; }
-});
 Object.defineProperty(exports, 'chunk', {
   enumerable: true,
   get: function () { return lodash.chunk; }
@@ -10322,6 +10340,8 @@ exports.Base = Base;
 exports.BaseModel = BaseModel;
 exports.BeautyProfile = BeautyProfile;
 exports.BeautyQuestionsHelper = BeautyQuestionsHelper;
+exports.BrandCategory = BrandCategory;
+exports.BrandCategoryFirestoreRepository = BrandCategoryFirestoreRepository;
 exports.BusinessError = BusinessError;
 exports.Buy2Win = Buy2Win;
 exports.Buy2WinFirestoreRepository = Buy2WinFirestoreRepository;
@@ -10380,6 +10400,12 @@ exports.Log = Log;
 exports.LogDocument = LogDocument;
 exports.LogFirestoreRepository = LogFirestoreRepository;
 exports.Logger = Logger;
+exports.MercadoPagoBankSlipAxiosAdapter = MercadoPagoBankSlipAxiosAdapter;
+exports.MercadoPagoCardAxiosAdapter = MercadoPagoCardAxiosAdapter;
+exports.MercadoPagoPaymentMethodFactory = MercadoPagoPaymentMethodFactory;
+exports.MercadoPagoPixAxiosAdapter = MercadoPagoPixAxiosAdapter;
+exports.MercadoPagoRequestHelper = MercadoPagoRequestHelper;
+exports.MercadoPagoResponseHelper = MercadoPagoResponseHelper;
 exports.NotFoundError = NotFoundError;
 exports.ObsEmitter = ObsEmitter;
 exports.Order = Order;
@@ -10399,8 +10425,6 @@ exports.PaymentFirestoreRepository = PaymentFirestoreRepository;
 exports.PaymentProviderFactory = PaymentProviderFactory;
 exports.PaymentTransaction = PaymentTransaction;
 exports.Product = Product;
-exports.ProductCatalogHasuraGraphQL = ProductCatalogHasuraGraphQL;
-exports.ProductCatalogHasuraGraphQLRepository = ProductCatalogHasuraGraphQLRepository;
 exports.ProductErrors = ProductErrors;
 exports.ProductErrorsHasuraGraphQL = ProductErrorsHasuraGraphQL;
 exports.ProductErrorsHasuraGraphQLRepository = ProductErrorsHasuraGraphQLRepository;