@infrab4a/connect 5.2.0-beta.4 → 5.3.0-beta.0

package/src/infra/hasura-graphql/repositories/catalog/filter-hasura-graphql.repository.d.ts

@@ -1,16 +1,16 @@
-import { DeleteRepositoryParams, Filter, UpdateRepositoryParams } from '../../../../domain';
-import { FilterRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
-import { FilterOptionHasuraGraphQLRepository } from './filter-option-hasura-graphql.repository';
-declare const FilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<Filter> & import("../../../../domain").CrudRepository<Filter, import("../../../../domain").CrudParams<Filter>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<Filter>, [HasuraConstructorParams<Filter> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class FilterHasuraGraphQLRepository extends FilterHasuraGraphQLRepository_base implements FilterRepository {
-    private readonly filterOptionRepository;
-    private readonly categoryFilterRepository;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, filterOptionRepository: FilterOptionHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
-    update(params: UpdateRepositoryParams<Filter>): Promise<Filter>;
-    updateOptions(filterId: number, { options }: Pick<UpdateRepositoryParams<Filter>, 'options'>): Promise<any[]>;
-    delete(params: DeleteRepositoryParams<Filter>): Promise<void>;
-    deleteOptions(filterId: number): Promise<void>;
-}
-export {};
+import { DeleteRepositoryParams, Filter, UpdateRepositoryParams } from '../../../../domain';
+import { FilterRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
+import { FilterOptionHasuraGraphQLRepository } from './filter-option-hasura-graphql.repository';
+declare const FilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<Filter> & import("../../../../domain").CrudRepository<Filter, import("../../../../domain").CrudParams<Filter>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<Filter>, [HasuraConstructorParams<Filter> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class FilterHasuraGraphQLRepository extends FilterHasuraGraphQLRepository_base implements FilterRepository {
+    private readonly filterOptionRepository;
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, filterOptionRepository: FilterOptionHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    update(params: UpdateRepositoryParams<Filter>): Promise<Filter>;
+    updateOptions(filterId: number, { options }: Pick<UpdateRepositoryParams<Filter>, 'options'>): Promise<any[]>;
+    delete(params: DeleteRepositoryParams<Filter>): Promise<void>;
+    deleteOptions(filterId: number): Promise<void>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/filter-option-hasura-graphql.repository.d.ts

@@ -1,8 +1,8 @@
-import { FilterOption } from '../../../../domain';
-import { FilterOptionRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<FilterOption> & import("../../../../domain").CrudRepository<FilterOption, import("../../../../domain").CrudParams<FilterOption>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<FilterOption>, [HasuraConstructorParams<FilterOption> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class FilterOptionHasuraGraphQLRepository extends FilterOptionHasuraGraphQLRepository_base implements FilterOptionRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-}
-export {};
+import { FilterOption } from '../../../../domain';
+import { FilterOptionRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<FilterOption> & import("../../../../domain").CrudRepository<FilterOption, import("../../../../domain").CrudParams<FilterOption>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<FilterOption>, [HasuraConstructorParams<FilterOption> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class FilterOptionHasuraGraphQLRepository extends FilterOptionHasuraGraphQLRepository_base implements FilterOptionRepository {
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-cache-operations.helper.d.ts

@@ -1,31 +1,31 @@
-import { CacheAdapter, Category, Product, RepositoryCacheOptions, Shops } from '../../../../../domain';
-import { DebugHelper } from '../../../../../utils';
-import { ProductHasuraGraphQL } from '../../../models';
-export interface CategoryCacheParams {
-    category: Category;
-    shop: Shops;
-    options: {
-        limit?: number;
-        hasStock?: boolean;
-    };
-    optionsCache: {
-        cache?: RepositoryCacheOptions;
-    };
-}
-export declare class CategoryCacheOperationsHelper {
-    static generateCacheKey(category: Category, shop: Shops, options: {
-        limit?: number;
-        hasStock?: boolean;
-    }): string;
-    static getCachedProducts(cacheAdapter: CacheAdapter, cacheKey: string, logger: DebugHelper): Promise<ProductHasuraGraphQL[] | null>;
-    static saveProductsToCache(params: {
-        cacheAdapter: CacheAdapter;
-        cacheKey: string;
-        products: Product[];
-        ttl: number;
-        logger: DebugHelper;
-    }): Promise<void>;
-    static shouldUseCache(cacheAdapter: CacheAdapter, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): boolean;
-}
+import { CacheAdapter, Category, Product, RepositoryCacheOptions, Shops } from '../../../../../domain';
+import { DebugHelper } from '../../../../../utils';
+import { ProductHasuraGraphQL } from '../../../models';
+export interface CategoryCacheParams {
+    category: Category;
+    shop: Shops;
+    options: {
+        limit?: number;
+        hasStock?: boolean;
+    };
+    optionsCache: {
+        cache?: RepositoryCacheOptions;
+    };
+}
+export declare class CategoryCacheOperationsHelper {
+    static generateCacheKey(category: Category, shop: Shops, options: {
+        limit?: number;
+        hasStock?: boolean;
+    }): string;
+    static getCachedProducts(cacheAdapter: CacheAdapter, cacheKey: string, logger: DebugHelper): Promise<ProductHasuraGraphQL[] | null>;
+    static saveProductsToCache(params: {
+        cacheAdapter: CacheAdapter;
+        cacheKey: string;
+        products: Product[];
+        ttl: number;
+        logger: DebugHelper;
+    }): Promise<void>;
+    static shouldUseCache(cacheAdapter: CacheAdapter, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): boolean;
+}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-filter-operations.helper.d.ts

@@ -1,17 +1,17 @@
-import { Filter, UpdateRepositoryParams } from '../../../../../domain';
-import { CategoryHasuraGraphQL } from '../../../models';
-import { CategoryFilterHasuraGraphQLRepository } from '../category-filter-hasura-graphql.repository';
-interface FilterUpdateDependencies {
-    categoryFilterRepository: CategoryFilterHasuraGraphQLRepository;
-}
-export declare class CategoryFilterOperationsHelper {
-    static executeUpdate(categoryId: number, filters: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'filters'>['filters'], dependencies: FilterUpdateDependencies): Promise<Filter[]>;
-    private static handleRemoveAction;
-    private static handleMergeAction;
-    private static handleReplaceAction;
-    private static getCurrentFilters;
-    private static calculateFilterDifferences;
-    private static processFilterDeletions;
-    private static processFilterInsertions;
-}
-export {};
+import { Filter, UpdateRepositoryParams } from '../../../../../domain';
+import { CategoryHasuraGraphQL } from '../../../models';
+import { CategoryFilterHasuraGraphQLRepository } from '../category-filter-hasura-graphql.repository';
+interface FilterUpdateDependencies {
+    categoryFilterRepository: CategoryFilterHasuraGraphQLRepository;
+}
+export declare class CategoryFilterOperationsHelper {
+    static executeUpdate(categoryId: number, filters: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'filters'>['filters'], dependencies: FilterUpdateDependencies): Promise<Filter[]>;
+    private static handleRemoveAction;
+    private static handleMergeAction;
+    private static handleReplaceAction;
+    private static getCurrentFilters;
+    private static calculateFilterDifferences;
+    private static processFilterDeletions;
+    private static processFilterInsertions;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-home-operations.helper.d.ts

@@ -1,32 +1,32 @@
-import { Category, Product, RepositoryCacheOptions, Shops } from '../../../../../domain';
-export interface CategoriesForHomeParams {
-    categoryIds: string[];
-    shop: Shops;
-    limit?: number;
-    optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    };
-}
-export interface CategoryHomeSection {
-    category: Category;
-    products: Product[];
-}
-export declare class CategoryHomeOperationsHelper {
-    static separateCategoryIds(categoryIds: string[]): {
-        firestore: string[];
-        hasura: string[];
-    };
-    static fetchFirestoreCategories(categoriesFirestore: string[], findFunction: Function, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    static fetchHasuraCategories(categoriesHasura: string[], findFunction: Function, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    static buildHomeSections(categories: Category[], mountCategoryFunction: Function, params: {
-        shop: Shops;
-        limit: number;
-        optionsCache?: {
-            cache?: RepositoryCacheOptions;
-        };
-    }): Promise<CategoryHomeSection[]>;
-}
+import { Category, Product, RepositoryCacheOptions, Shops } from '../../../../../domain';
+export interface CategoriesForHomeParams {
+    categoryIds: string[];
+    shop: Shops;
+    limit?: number;
+    optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    };
+}
+export interface CategoryHomeSection {
+    category: Category;
+    products: Product[];
+}
+export declare class CategoryHomeOperationsHelper {
+    static separateCategoryIds(categoryIds: string[]): {
+        firestore: string[];
+        hasura: string[];
+    };
+    static fetchFirestoreCategories(categoriesFirestore: string[], findFunction: Function, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    static fetchHasuraCategories(categoriesHasura: string[], findFunction: Function, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    static buildHomeSections(categories: Category[], mountCategoryFunction: Function, params: {
+        shop: Shops;
+        limit: number;
+        optionsCache?: {
+            cache?: RepositoryCacheOptions;
+        };
+    }): Promise<CategoryHomeSection[]>;
+}

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-mount-operations.helper.d.ts

@@ -1,19 +1,19 @@
-import { CacheAdapter, Product } from '../../../../../domain';
-import { DebugHelper } from '../../../../../utils';
-import { ProductHasuraGraphQLRepository } from '../product-hasura-graphql.repository';
-import { MountCategoryParams } from './category-product-operations.helper';
-interface MountCategoryDependencies {
-    productRepository: ProductHasuraGraphQLRepository;
-    cacheAdapter?: CacheAdapter;
-    defaultCacheTtl: number;
-    logger: DebugHelper;
-}
-export declare class CategoryMountOperationsHelper {
-    static executeMount(params: MountCategoryParams, dependencies: MountCategoryDependencies): Promise<Product[]>;
-    private static tryGetFromCache;
-    private static fetchMostRelevantProducts;
-    private static finalizeMountWithMostRelevants;
-    private static finalizeMountWithAllProducts;
-    private static saveToCacheIfNeeded;
-}
-export {};
+import { CacheAdapter, Product } from '../../../../../domain';
+import { DebugHelper } from '../../../../../utils';
+import { ProductHasuraGraphQLRepository } from '../product-hasura-graphql.repository';
+import { MountCategoryParams } from './category-product-operations.helper';
+interface MountCategoryDependencies {
+    productRepository: ProductHasuraGraphQLRepository;
+    cacheAdapter?: CacheAdapter;
+    defaultCacheTtl: number;
+    logger: DebugHelper;
+}
+export declare class CategoryMountOperationsHelper {
+    static executeMount(params: MountCategoryParams, dependencies: MountCategoryDependencies): Promise<Product[]>;
+    private static tryGetFromCache;
+    private static fetchMostRelevantProducts;
+    private static finalizeMountWithMostRelevants;
+    private static finalizeMountWithAllProducts;
+    private static saveToCacheIfNeeded;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/category-product-operations.helper.d.ts

@@ -1,62 +1,62 @@
-import { Category, FindRepositoryParams, NonFunctionPropertyNames, ProductRepository, RepositoryCacheOptions, Shops, Where } from '../../../../../domain';
-import { ProductHasuraGraphQL } from '../../../models';
-export interface MountCategoryParams {
-    category: Category;
-    shop: Shops;
-    options?: {
-        limit?: number;
-        hasStock?: boolean;
-        gender?: string;
-    };
-    optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    };
-}
-export interface ProductSearchFilters {
-    id: {
-        operator: Where;
-        value: string[];
-    };
-    published: boolean;
-    stock?: {
-        quantity: {
-            operator: Where;
-            value: number;
-        };
-    };
-}
-export declare class CategoryProductOperationsHelper {
-    static getProductFields(): NonFunctionPropertyNames<ProductHasuraGraphQL>[];
-    static buildProductFilters(productIds: string[], hasStock?: boolean): ProductSearchFilters;
-    static buildProductQuery(params: {
-        productIds: string[];
-        fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
-        hasStock?: boolean;
-        limit?: number;
-    }): FindRepositoryParams<ProductHasuraGraphQL>;
-    static getGenderParam(shop: Shops): 'male' | 'female';
-    static fetchMostRelevantProducts(params: {
-        productRepository: ProductRepository;
-        mostRelevantsIds: string[];
-        fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
-        shop: Shops;
-        hasStock?: boolean;
-        optionsCache?: {
-            cache?: RepositoryCacheOptions;
-        };
-    }): Promise<ProductHasuraGraphQL[]>;
-    static fetchRegularProducts(params: {
-        productRepository: ProductRepository;
-        productIds: string[];
-        fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
-        shop: Shops;
-        options: {
-            hasStock?: boolean;
-            limit?: number;
-        };
-        optionsCache?: {
-            cache?: RepositoryCacheOptions;
-        };
-    }): Promise<ProductHasuraGraphQL[]>;
-    static reorganizeMostRelevantsProducts(products: ProductHasuraGraphQL[], mostRelevantsIds: string[], limit?: number): ProductHasuraGraphQL[];
-}
+import { Category, FindRepositoryParams, NonFunctionPropertyNames, ProductRepository, RepositoryCacheOptions, Shops, Where } from '../../../../../domain';
+import { ProductHasuraGraphQL } from '../../../models';
+export interface MountCategoryParams {
+    category: Category;
+    shop: Shops;
+    options?: {
+        limit?: number;
+        hasStock?: boolean;
+        gender?: string;
+    };
+    optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    };
+}
+export interface ProductSearchFilters {
+    id: {
+        operator: Where;
+        value: string[];
+    };
+    published: boolean;
+    stock?: {
+        quantity: {
+            operator: Where;
+            value: number;
+        };
+    };
+}
+export declare class CategoryProductOperationsHelper {
+    static getProductFields(): NonFunctionPropertyNames<ProductHasuraGraphQL>[];
+    static buildProductFilters(productIds: string[], hasStock?: boolean): ProductSearchFilters;
+    static buildProductQuery(params: {
+        productIds: string[];
+        fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
+        hasStock?: boolean;
+        limit?: number;
+    }): FindRepositoryParams<ProductHasuraGraphQL>;
+    static getGenderParam(shop: Shops): 'male' | 'female';
+    static fetchMostRelevantProducts(params: {
+        productRepository: ProductRepository;
+        mostRelevantsIds: string[];
+        fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
+        shop: Shops;
+        hasStock?: boolean;
+        optionsCache?: {
+            cache?: RepositoryCacheOptions;
+        };
+    }): Promise<ProductHasuraGraphQL[]>;
+    static fetchRegularProducts(params: {
+        productRepository: ProductRepository;
+        productIds: string[];
+        fields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
+        shop: Shops;
+        options: {
+            hasStock?: boolean;
+            limit?: number;
+        };
+        optionsCache?: {
+            cache?: RepositoryCacheOptions;
+        };
+    }): Promise<ProductHasuraGraphQL[]>;
+    static reorganizeMostRelevantsProducts(products: ProductHasuraGraphQL[], mostRelevantsIds: string[], limit?: number): ProductHasuraGraphQL[];
+}

package/src/infra/hasura-graphql/repositories/catalog/helpers/index.d.ts

@@ -1,10 +1,10 @@
-export * from './category-cache-operations.helper';
-export * from './category-filter-operations.helper';
-export * from './category-home-operations.helper';
-export * from './category-mount-operations.helper';
-export * from './category-product-operations.helper';
-export * from './product-fetch-reviews.helper';
-export * from './product-review-cache.helper';
-export * from './product-review-operations.helper';
-export * from './product-review-update.helper';
-export * from './product-variant-report.helper';
+export * from './category-cache-operations.helper';
+export * from './category-filter-operations.helper';
+export * from './category-home-operations.helper';
+export * from './category-mount-operations.helper';
+export * from './category-product-operations.helper';
+export * from './product-fetch-reviews.helper';
+export * from './product-review-cache.helper';
+export * from './product-review-operations.helper';
+export * from './product-review-update.helper';
+export * from './product-variant-report.helper';

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-fetch-reviews.helper.d.ts

@@ -1,17 +1,17 @@
-import { ProductReview, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain';
-import { ProductHasuraGraphQL } from '../../../models';
-interface FetchReviewsDependencies {
-    query: (table: string, fields: any, params?: any) => Promise<any>;
-    bindReviewToModel: (plain: any) => ProductReview;
-    reviewsFields: any;
-}
-export declare class ProductFetchReviewsHelper {
-    static buildReviewsExpression(status: ReviewStatusParams): any;
-    static fetchProductsWithReviews(status: ReviewStatusParams, dependencies: FetchReviewsDependencies): Promise<any[]>;
-    static processReviewsData(data: Array<Omit<ProductHasuraGraphQL, 'reviews'> & {
-        reviews: Array<Record<'person_id' | 'order_id' | 'created_at' | 'updated_at' | 'status', any>>;
-    }>, status: ReviewStatusParams, bindReviewToModel: (plain: any) => ProductReview): ReviewWithProductData[];
-    private static matchesStatus;
-    static executeQuery(status: ReviewStatusParams, dependencies: FetchReviewsDependencies): Promise<ReviewWithProductData[]>;
-}
-export {};
+import { ProductReview, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain';
+import { ProductHasuraGraphQL } from '../../../models';
+interface FetchReviewsDependencies {
+    query: (table: string, fields: any, params?: any) => Promise<any>;
+    bindReviewToModel: (plain: any) => ProductReview;
+    reviewsFields: any;
+}
+export declare class ProductFetchReviewsHelper {
+    static buildReviewsExpression(status: ReviewStatusParams): any;
+    static fetchProductsWithReviews(status: ReviewStatusParams, dependencies: FetchReviewsDependencies): Promise<any[]>;
+    static processReviewsData(data: Array<Omit<ProductHasuraGraphQL, 'reviews'> & {
+        reviews: Array<Record<'person_id' | 'order_id' | 'created_at' | 'updated_at' | 'status', any>>;
+    }>, status: ReviewStatusParams, bindReviewToModel: (plain: any) => ProductReview): ReviewWithProductData[];
+    private static matchesStatus;
+    static executeQuery(status: ReviewStatusParams, dependencies: FetchReviewsDependencies): Promise<ReviewWithProductData[]>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-review-cache.helper.d.ts

@@ -1,28 +1,28 @@
-import { PaginatedReviewFilters, ProductReview, RepositoryCacheOptions, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain';
-interface CacheOperationDependencies {
-    cacheAdapter: any;
-    logger: any;
-    modelName: string;
-    defaultTtl: number;
-}
-interface CacheCheckParams {
-    key: string;
-    dependencies: CacheOperationDependencies;
-}
-interface CacheSaveParams {
-    key: string;
-    data: any;
-    ttl?: number;
-    dependencies: CacheOperationDependencies;
-}
-export declare class ProductReviewCacheHelper {
-    static generateProductReviewsCacheKey(filters: PaginatedReviewFilters, modelName: string): string;
-    static generateReviewsStatusCacheKey(status: ReviewStatusParams, modelName: string): string;
-    static generateProductReviewsCacheKeyForProduct(productId: number, modelName: string): string;
-    static tryGetFromCache(params: CacheCheckParams): Promise<ReviewWithProductData[] | ProductReview[] | null>;
-    static saveToCache(params: CacheSaveParams): Promise<void>;
-    static shouldUseCache(cacheAdapter: any, options?: {
-        cache?: RepositoryCacheOptions;
-    }): boolean;
-}
-export {};
+import { PaginatedReviewFilters, ProductReview, RepositoryCacheOptions, ReviewStatusParams, ReviewWithProductData } from '../../../../../domain';
+interface CacheOperationDependencies {
+    cacheAdapter: any;
+    logger: any;
+    modelName: string;
+    defaultTtl: number;
+}
+interface CacheCheckParams {
+    key: string;
+    dependencies: CacheOperationDependencies;
+}
+interface CacheSaveParams {
+    key: string;
+    data: any;
+    ttl?: number;
+    dependencies: CacheOperationDependencies;
+}
+export declare class ProductReviewCacheHelper {
+    static generateProductReviewsCacheKey(filters: PaginatedReviewFilters, modelName: string): string;
+    static generateReviewsStatusCacheKey(status: ReviewStatusParams, modelName: string): string;
+    static generateProductReviewsCacheKeyForProduct(productId: number, modelName: string): string;
+    static tryGetFromCache(params: CacheCheckParams): Promise<ReviewWithProductData[] | ProductReview[] | null>;
+    static saveToCache(params: CacheSaveParams): Promise<void>;
+    static shouldUseCache(cacheAdapter: any, options?: {
+        cache?: RepositoryCacheOptions;
+    }): boolean;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-review-operations.helper.d.ts

@@ -1,20 +1,20 @@
-import { PaginatedReviewFilters, ProductReview, ReviewWithProductData } from '../../../../../domain';
-import { ProductHasuraGraphQL } from '../../../models';
-interface ReviewDataFetchParams {
-    repository: any;
-    limit: number;
-}
-interface ReviewProcessingParams {
-    data: ProductHasuraGraphQL[];
-    getReviewStatus: (review: ProductReview) => 'approved' | 'rejected' | 'pending';
-}
-interface ReviewFilteringParams {
-    reviews: ReviewWithProductData[];
-    filters: PaginatedReviewFilters;
-}
-export declare class ProductReviewOperationsHelper {
-    static fetchAllProductsWithReviews(params: ReviewDataFetchParams): Promise<ProductHasuraGraphQL[]>;
-    static processProductsToReviews(params: ReviewProcessingParams): ReviewWithProductData[];
-    static applyReviewFilters(params: ReviewFilteringParams): ReviewWithProductData[];
-}
-export {};
+import { PaginatedReviewFilters, ProductReview, ReviewWithProductData } from '../../../../../domain';
+import { ProductHasuraGraphQL } from '../../../models';
+interface ReviewDataFetchParams {
+    repository: any;
+    limit: number;
+}
+interface ReviewProcessingParams {
+    data: ProductHasuraGraphQL[];
+    getReviewStatus: (review: ProductReview) => 'approved' | 'rejected' | 'pending';
+}
+interface ReviewFilteringParams {
+    reviews: ReviewWithProductData[];
+    filters: PaginatedReviewFilters;
+}
+export declare class ProductReviewOperationsHelper {
+    static fetchAllProductsWithReviews(params: ReviewDataFetchParams): Promise<ProductHasuraGraphQL[]>;
+    static processProductsToReviews(params: ReviewProcessingParams): ReviewWithProductData[];
+    static applyReviewFilters(params: ReviewFilteringParams): ReviewWithProductData[];
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-review-update.helper.d.ts

@@ -1,20 +1,20 @@
-import { NonFunctionPropertyNames, ProductReview, UpdateRepositoryParams } from '../../../../../domain';
-import { UpdateHasuraGraphQLRepositoryType } from '../../../mixins';
-import { ProductHasuraGraphQL } from '../../../models';
-import { GraphQLRepository } from '../../../types';
-interface ReviewUpdateDependencies {
-    mutation: GraphQLRepository<ProductHasuraGraphQL>['mutation'];
-    findReview: (review: ProductReview, productId: number) => Promise<ProductReview>;
-    bindReviewToModel: (plain: Record<'person_id' | 'order_id' | 'created_at' | 'updated_at', any>) => ProductReview;
-    bindReviewToHasura: (review: ProductReview) => any;
-    reviewsFields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
-    paramsToPlain: UpdateHasuraGraphQLRepositoryType<ProductHasuraGraphQL>['paramsToPlain'];
-}
-export declare class ProductReviewUpdateHelper {
-    static executeUpdate(productId: number, reviews: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'reviews'>['reviews'], dependencies: ReviewUpdateDependencies): Promise<ProductReview[]>;
-    private static handleRemoveReviews;
-    private static handleUpsertReviews;
-    private static updateExistingReview;
-    private static insertNewReview;
-}
-export {};
+import { NonFunctionPropertyNames, ProductReview, UpdateRepositoryParams } from '../../../../../domain';
+import { UpdateHasuraGraphQLRepositoryType } from '../../../mixins';
+import { ProductHasuraGraphQL } from '../../../models';
+import { GraphQLRepository } from '../../../types';
+interface ReviewUpdateDependencies {
+    mutation: GraphQLRepository<ProductHasuraGraphQL>['mutation'];
+    findReview: (review: ProductReview, productId: number) => Promise<ProductReview>;
+    bindReviewToModel: (plain: Record<'person_id' | 'order_id' | 'created_at' | 'updated_at', any>) => ProductReview;
+    bindReviewToHasura: (review: ProductReview) => any;
+    reviewsFields: NonFunctionPropertyNames<ProductHasuraGraphQL>[];
+    paramsToPlain: UpdateHasuraGraphQLRepositoryType<ProductHasuraGraphQL>['paramsToPlain'];
+}
+export declare class ProductReviewUpdateHelper {
+    static executeUpdate(productId: number, reviews: Pick<UpdateRepositoryParams<ProductHasuraGraphQL>, 'reviews'>['reviews'], dependencies: ReviewUpdateDependencies): Promise<ProductReview[]>;
+    private static handleRemoveReviews;
+    private static handleUpsertReviews;
+    private static updateExistingReview;
+    private static insertNewReview;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/helpers/product-variant-report.helper.d.ts

@@ -1,9 +1,9 @@
-import { ProductVariantReport } from '../../../../../domain';
-interface VariantReportDependencies {
-    query: (table: string, fields: string[]) => Promise<any>;
-}
-export declare class ProductVariantReportHelper {
-    static getReportFields(): string[];
-    static executeReport(dependencies: VariantReportDependencies): Promise<ProductVariantReport[]>;
-}
-export {};
+import { ProductVariantReport } from '../../../../../domain';
+interface VariantReportDependencies {
+    query: (table: string, fields: string[]) => Promise<any>;
+}
+export declare class ProductVariantReportHelper {
+    static getReportFields(): string[];
+    static executeReport(dependencies: VariantReportDependencies): Promise<ProductVariantReport[]>;
+}
+export {};

package/src/infra/hasura-graphql/repositories/catalog/index.d.ts

@@ -1,12 +1,12 @@
-export * from './category-collection-children-hasura-graphql.repository';
-export * from './category-filter-hasura-graphql.repository';
-export * from './category-hasura-graphql.repository';
-export * from './category-product-hasura-graphql.repository';
-export * from './filter-hasura-graphql.repository';
-export * from './filter-option-hasura-graphql.repository';
-export * from './product-errors-hasura-graphql.repository';
-export * from './product-hasura-graphql.repository';
-export * from './product-review-hasura-graphql.repository';
-export * from './product-stock-notification-hasura-graphql.repository';
-export * from './variant-hasura-graphql.repository';
-export * from './wishlist-hasura-graphql.repository';
+export * from './category-collection-children-hasura-graphql.repository';
+export * from './category-filter-hasura-graphql.repository';
+export * from './category-hasura-graphql.repository';
+export * from './category-product-hasura-graphql.repository';
+export * from './filter-hasura-graphql.repository';
+export * from './filter-option-hasura-graphql.repository';
+export * from './product-errors-hasura-graphql.repository';
+export * from './product-hasura-graphql.repository';
+export * from './product-review-hasura-graphql.repository';
+export * from './product-stock-notification-hasura-graphql.repository';
+export * from './variant-hasura-graphql.repository';
+export * from './wishlist-hasura-graphql.repository';