@infrab4a/connect 5.4.0-beta.8 → 5.4.1-beta.0

package/index.cjs.js

@@ -1815,7 +1815,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) };
@@ -7216,280 +7216,6 @@ class FilterOptionHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasu
     }
 }
 
-const commonFields$1 = [
-    {
-        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' } },
-];
-class ProductCatalogHasuraGraphQLRepository extends withFindHasuraGraphQL(withHasuraGraphQL(Base)) {
-    constructor({ endpoint, authOptions, interceptors, cache, }) {
-        super({
-            tableName: 'product_catalog',
-            model: ProductHasuraGraphQL,
-            endpoint,
-            authOptions,
-            interceptors,
-            fields: commonFields$1,
-            cache,
-        });
-    }
-    async get({ id }) {
-        return super
-            .find({
-            filters: {
-                id,
-            },
-            limits: {
-                limit: 1,
-            },
-        })
-            .then((res) => res.data.at(0));
-    }
-    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 },
-            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({
@@ -7733,8 +7459,6 @@ const commonFields = [
     { 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,
@@ -7798,61 +7522,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',
@@ -7898,6 +7570,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: {
@@ -7926,29 +7602,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' } },
-                        ],
-                    },
-                },
             ],
         },
     },
@@ -8014,12 +7667,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) {
@@ -8036,7 +7684,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')
@@ -8061,9 +7709,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: {
@@ -8073,11 +7718,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}`;
@@ -8279,7 +7919,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);
@@ -8292,16 +7932,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) {
@@ -8406,7 +8040,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);
 
@@ -8654,106 +8288,6 @@ const fieldsConfiguration$1 = [
             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 },
-            }),
-        },
-    },
-    {
-        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' } },
-            ],
-        },
-    },
-    { variantSlug: { columnName: 'variant_slug' } },
-    { createdAt: { columnName: 'created_at' } },
-    { updatedAt: { columnName: 'updated_at' } },
 ];
 class VariantHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
     constructor({ endpoint, authOptions, interceptors, cache, }) {
@@ -8794,37 +8328,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;
@@ -10204,14 +9719,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; }
@@ -10376,7 +9883,6 @@ exports.PaymentFirestoreRepository = PaymentFirestoreRepository;
 exports.PaymentProviderFactory = PaymentProviderFactory;
 exports.PaymentTransaction = PaymentTransaction;
 exports.Product = Product;
-exports.ProductCatalogHasuraGraphQLRepository = ProductCatalogHasuraGraphQLRepository;
 exports.ProductErrors = ProductErrors;
 exports.ProductErrorsHasuraGraphQL = ProductErrorsHasuraGraphQL;
 exports.ProductErrorsHasuraGraphQLRepository = ProductErrorsHasuraGraphQLRepository;