@infrab4a/connect 4.29.0 → 4.29.1-alpha.1

package/src/infra/hasura-graphql/mixins/with-create-hasura-graphql.mixin.d.ts

@@ -1,9 +1,5 @@
-import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../domain';
+import { CreateRepository, ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-export type CreateConstructorParams = {
-    insertGraphQLOperation?: string;
-    insertAllGraphQLOperation?: string;
-    insertGraphQLObjectType?: string;
-};
-export declare const withCreateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & InstanceType<TMixinBase> & CreateRepository<MBase, CreateRepositoryParams<MBase>>, MergeConstructorParams<[CreateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+import { CreateConstructorParams } from './factories';
+export declare const withCreateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & InstanceType<TMixinBase> & CreateRepository<MBase, import("../../../domain").CreateRepositoryParams<MBase>>, MergeConstructorParams<[CreateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/mixins/with-crud-hasura-graphql.mixin.d.ts

@@ -1,11 +1,7 @@
 import { CrudRepository, ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-import { CreateConstructorParams } from './with-create-hasura-graphql.mixin';
-import { DeleteConstructorParams } from './with-delete-hasura-graphql.mixin';
-import { GetConstructorParams } from './with-get-hasura-graphql.mixin';
+import { CreateConstructorParams, DeleteConstructorParams, GetConstructorParams } from './factories';
 import { HasuraConstructorParams } from './with-hasura-graphql.mixin';
 import { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType } from './with-update-hasura-graphql.mixin';
-export declare const withCrudHasuraGraphQL: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, Repository = CrudRepository<TBase, import("../../../domain").CrudParams<TBase>>, TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<GraphQLRepository<TBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<TBase> & Repository & import("../../../domain").UpdateRepository<TBase, import("../../../domain").RepositoryUpdateParams<TBase>> & {
-    paramsToPlain(params: import("../../../domain").RepositoryUpdateParams<TBase>): Partial<TBase>;
-}, MergeConstructorParams<[HasuraConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+export declare const withCrudHasuraGraphQL: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, Repository = CrudRepository<TBase, import("../../../domain").CrudParams<TBase>>, TMixinBase extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: MixinCtor<GraphQLRepository<TBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<TBase> & Repository & UpdateHasuraGraphQLRepositoryType<TBase>, MergeConstructorParams<[HasuraConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/mixins/with-delete-hasura-graphql.mixin.d.ts

@@ -1,7 +1,5 @@
-import { DeleteRepository, DeleteRepositoryParams, ModelBaseStructure } from '../../../domain';
+import { DeleteRepository, ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-export type DeleteConstructorParams = {
-    deleteGraphQLOperation?: string;
-};
-export declare const withDeleteHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & DeleteRepository<MBase, DeleteRepositoryParams<MBase>> & InstanceType<TMixinBase>, MergeConstructorParams<[DeleteConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+import { DeleteConstructorParams } from './factories';
+export declare const withDeleteHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & DeleteRepository<MBase, import("../../../domain").DeleteRepositoryParams<MBase>> & InstanceType<TMixinBase>, MergeConstructorParams<[DeleteConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/mixins/with-find-hasura-graphql.mixin.d.ts

@@ -1,54 +1,4 @@
-import { BaseModelBuilder, FindRepositoryParams, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, RepositoryCacheOptions, RepositoryFindResult, RepositoryOrderBy } from '../../../domain';
-import { DebugHelper, MixinCtor } from '../../../utils';
-import { GraphQLParams, GraphQLRepository, HasuraGraphQLFields } from '../types';
-export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
-    new (...args: any[]): {
-        lastDistinct: Record<string, any>;
-        find(params?: FindRepositoryParams<MBase>, options?: {
-            cache?: RepositoryCacheOptions;
-        }): Promise<RepositoryFindResult<MBase>>;
-        bindResult(result: any, { enableCount, findOptions, tableFiltersNamed, }: {
-            enableCount: boolean;
-            findOptions: {
-                enableCount?: boolean;
-                minimal?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-                maximum?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-                distinct?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-            };
-            tableFiltersNamed: string;
-        }): {
-            distinct: any;
-            maximum?: import("../../../domain").NonFunctionAndIdentifierPropertiesWithNoPartial<MBase> extends infer T extends import("../../../domain").NonFunctionAndIdentifierPropertiesWithNoPartial<MBase> ? { [key in keyof T]: import("../../../domain").NonFunctionAndIdentifierPropertiesWithNoPartial<MBase>[key]; } : never;
-            minimal?: import("../../../domain").NonFunctionAndIdentifierPropertiesWithNoPartial<MBase> extends infer T extends import("../../../domain").NonFunctionAndIdentifierPropertiesWithNoPartial<MBase> ? { [key in keyof T]: import("../../../domain").NonFunctionAndIdentifierPropertiesWithNoPartial<MBase>[key]; } : never;
-            data: MBase[];
-            count: any;
-        };
-        bindOrderByAttributes: (orderBy: RepositoryOrderBy<MBase>, fields: HasuraGraphQLFields<MBase>) => any[];
-        bindAggretageAttributes: (aggregates: {
-            minimal?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-            maximum?: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[];
-        }, fields: HasuraGraphQLFields<MBase>) => ({
-            min: {}[];
-            max?: undefined;
-        } | {
-            max: {}[];
-            min?: undefined;
-        })[];
-        bindDistinctAttributes: (distinct: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[], fields: HasuraGraphQLFields<MBase>) => {}[];
-        bindAttributesToColumns: (attributes: ({} | NonFunctionAndIdentifierPropertyNames<MBase>)[], fields: HasuraGraphQLFields<MBase>) => {}[];
-        tableName: string;
-        model: BaseModelBuilder<MBase, any, MBase & {
-            prototype: unknown;
-        }>;
-        fields: HasuraGraphQLFields<MBase>;
-        endpoint: string;
-        authOptions: import("../types").HasuraGraphQLAuthOptions;
-        logger: DebugHelper;
-        cache?: import("../../../domain").CacheConfig;
-        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: string[] | HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | GraphQLParams<MBase>[], fields?: string[] | HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
-        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<MBase>): MBase;
-        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
-    };
-} & TMixinBase;
+import { FindRepository, ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
+export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & FindRepository<MBase, import("../../../domain").FindRepositoryParams<MBase>> & InstanceType<TMixinBase>, MergeConstructorParams<any[], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/mixins/with-get-hasura-graphql.mixin.d.ts

@@ -1,29 +1,5 @@
-import { GetRepositoryParams, ModelBaseStructure, RepositoryCacheOptions } from '../../../domain';
-import { DebugHelper, MixinCtor } from '../../../utils';
+import { GetRepository, ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-export type GetConstructorParams = {
-    getGraphQLOperation?: string;
-};
-export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
-    new (...params: any[]): {
-        getGraphQLOperation: string;
-        generateCacheKey(identifiers: GetRepositoryParams<MBase>): string;
-        get(identifiers: GetRepositoryParams<MBase>, options?: {
-            cache?: RepositoryCacheOptions;
-        }): Promise<MBase>;
-        tableName: string;
-        model: import("../../../domain").BaseModelBuilder<MBase, any, MBase & {
-            prototype: unknown;
-        }>;
-        fields: import("../types").HasuraGraphQLFields<MBase>;
-        endpoint: string;
-        authOptions: import("../types").HasuraGraphQLAuthOptions;
-        logger: DebugHelper;
-        cache?: import("../../../domain").CacheConfig;
-        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: string[] | import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../types").GraphQLParams<MBase>[], fields?: string[] | import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
-        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | import("../types").HasuraGraphQLFields<MBase>): MBase;
-        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
-    };
-} & TMixinBase;
+import { GetConstructorParams } from './factories';
+export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & GetRepository<MBase, import("../../../domain").GetRepositoryParams<MBase>> & InstanceType<TMixinBase>, MergeConstructorParams<[GetConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/mixins/with-hasura-graphql.mixin.d.ts

@@ -1,24 +1,6 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
-import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../domain';
+import { ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { Fields, GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../types';
-type QueryBuilderOptions = {
-    operation: string | IOperation;
-    fields: Fields;
-    variables?: VariableOptions;
-};
-type HasuraGraphQLInterceptors<P = QueryBuilderOptions | QueryBuilderOptions[]> = {
-    request?: <R>(request: P) => Promise<P & R>;
-    response?: <R>(response: R, request: P) => Promise<R>;
-};
-export type HasuraConstructorParams<Model extends ModelBaseStructure<Model, Model['identifiersFields'][number]>> = {
-    tableName: string;
-    model: BaseModelBuilder<Model>;
-    fields: HasuraGraphQLFields<Model>;
-    endpoint: string;
-    interceptors?: HasuraGraphQLInterceptors;
-    authOptions: HasuraGraphQLAuthOptions;
-    cache?: CacheConfig;
-};
+import { GraphQLRepository } from '../types';
+import { HasuraConstructorParams, HasuraGraphQLInterceptors } from './factories/hasura-graphql-class.factory';
+export { HasuraConstructorParams, HasuraGraphQLInterceptors };
 export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, any[]>;
-export {};

package/src/infra/hasura-graphql/mixins/with-update-hasura-graphql.mixin.d.ts

@@ -1,14 +1,6 @@
-import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } from '../../../domain';
+import { ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-export type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>> = UpdateRepository<MBase> & {
-    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
-};
-export type UpdateConstructorParams = {
-    updateGraphQLOperation?: string;
-    updateGraphQLObjectType?: string;
-    updateGraphQLPKType?: string;
-};
-export declare const withUpdateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateRepository<MBase, RepositoryUpdateParams<MBase>> & {
-    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
-} & InstanceType<TMixinBase>, MergeConstructorParams<[UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+import { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType } from './factories/update-hasura-class.factory';
+export { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType };
+export declare const withUpdateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateHasuraGraphQLRepositoryType<MBase> & InstanceType<TMixinBase>, MergeConstructorParams<[UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/repositories/catalog/category-collection-children-hasura-graphql.repository.d.ts

@@ -1,9 +1,7 @@
 import { CategoryCollectionChildren } from '../../../../domain';
 import { CategoryCollectionChildrenRepository } from '../../../../domain/catalog/repositories/category-collection-children.repository';
 import { HasuraConstructorParams } from '../../mixins';
-declare const CategoryCollectionChildrenHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryCollectionChildren> & import("../../../../domain").CrudRepository<CategoryCollectionChildren, import("../../../../domain").CrudParams<CategoryCollectionChildren>> & import("../../../../domain").UpdateRepository<CategoryCollectionChildren, import("../../../../domain").RepositoryUpdateParams<CategoryCollectionChildren>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryCollectionChildren>): Partial<CategoryCollectionChildren>;
-}, [HasuraConstructorParams<CategoryCollectionChildren> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+declare const CategoryCollectionChildrenHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryCollectionChildren> & import("../../../../domain").CrudRepository<CategoryCollectionChildren, import("../../../../domain").CrudParams<CategoryCollectionChildren>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<CategoryCollectionChildren>, [HasuraConstructorParams<CategoryCollectionChildren> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryCollectionChildrenHasuraGraphQLRepository extends CategoryCollectionChildrenHasuraGraphQLRepository_base implements CategoryCollectionChildrenRepository {
     constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryCollectionChildren>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
 }

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

@@ -1,9 +1,7 @@
 import { CategoryFilter } from '../../../../domain';
 import { CategoryFilterRepository } from '../../../../domain/catalog/repositories';
 import { HasuraConstructorParams } from '../../mixins';
-declare const CategoryFilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryFilter> & import("../../../../domain").CrudRepository<CategoryFilter, import("../../../../domain").CrudParams<CategoryFilter>> & import("../../../../domain").UpdateRepository<CategoryFilter, import("../../../../domain").RepositoryUpdateParams<CategoryFilter>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryFilter>): Partial<CategoryFilter>;
-}, [HasuraConstructorParams<CategoryFilter> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+declare const CategoryFilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<CategoryFilter> & import("../../../../domain").CrudRepository<CategoryFilter, import("../../../../domain").CrudParams<CategoryFilter>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<CategoryFilter>, [HasuraConstructorParams<CategoryFilter> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryFilterHasuraGraphQLRepository extends CategoryFilterHasuraGraphQLRepository_base implements CategoryFilterRepository {
     constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
     addFiltersToCategory(categoryId: number, filterIds: number[]): Promise<void>;

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

@@ -2,10 +2,9 @@ import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryPara
 import { HasuraConstructorParams } from '../../mixins';
 import { CategoryHasuraGraphQL } from '../../models';
 import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
+import { CategoriesForHomeParams, MountCategoryParams } from './helpers';
 import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
-declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryHasuraGraphQL> & import("../../../../domain").CrudRepository<CategoryHasuraGraphQL, import("../../../../domain").CrudParams<CategoryHasuraGraphQL>> & import("../../../../domain").UpdateRepository<CategoryHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<CategoryHasuraGraphQL>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryHasuraGraphQL>): Partial<CategoryHasuraGraphQL>;
-}, [HasuraConstructorParams<CategoryHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<CategoryHasuraGraphQL> & import("../../../../domain").CrudRepository<CategoryHasuraGraphQL, import("../../../../domain").CrudParams<CategoryHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<CategoryHasuraGraphQL>, [HasuraConstructorParams<CategoryHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
     private readonly productRepository;
     private readonly categoryFilterRepository;
@@ -21,19 +20,11 @@ export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraph
     getCategoryByShop(shop: string, optionsCache?: {
         cache?: RepositoryCacheOptions;
     }): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<{
+    getCategoriesForHome(params: CategoriesForHomeParams): Promise<{
         category: Category;
         products: Product[];
     }[]>;
-    mountCategory(category: Category, shop: Shops, options?: {
-        limit?: number;
-        hasStock?: boolean;
-        gender?: string;
-    }, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Product[]>;
+    mountCategory(params: MountCategoryParams): Promise<Product[]>;
     getChildren(parentId: number, _optionsCache?: {
         cache?: RepositoryCacheOptions;
     }): Promise<Category[]>;
@@ -42,7 +33,5 @@ export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraph
     private updateProducts;
     private updateMetadata;
     private updateFilters;
-    private saveToCache;
-    private reorganizeMostRelevantsProducts;
 }
 export {};

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

@@ -1,8 +1,6 @@
 import { CategoryProduct, CategoryProductRepository } from '../../../../domain';
 import { HasuraConstructorParams } from '../../mixins';
-declare const CategoryProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryProduct> & import("../../../../domain").CrudRepository<CategoryProduct, import("../../../../domain").CrudParams<CategoryProduct>> & import("../../../../domain").UpdateRepository<CategoryProduct, import("../../../../domain").RepositoryUpdateParams<CategoryProduct>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryProduct>): Partial<CategoryProduct>;
-}, [HasuraConstructorParams<CategoryProduct> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+declare const CategoryProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryProduct> & import("../../../../domain").CrudRepository<CategoryProduct, import("../../../../domain").CrudParams<CategoryProduct>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<CategoryProduct>, [HasuraConstructorParams<CategoryProduct> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryProductHasuraGraphQLRepository extends CategoryProductHasuraGraphQLRepository_base implements CategoryProductRepository {
     constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
     removeProductsFromCategory(categoryId: string, productIds: string[]): Promise<void>;

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

@@ -3,15 +3,13 @@ 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("../..").GraphQLRepository<Filter> & import("../../../../domain").CrudRepository<Filter, import("../../../../domain").CrudParams<Filter>> & import("../../../../domain").UpdateRepository<Filter, import("../../../../domain").RepositoryUpdateParams<Filter>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<Filter>): Partial<Filter>;
-}, [HasuraConstructorParams<Filter> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+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<import("../../../../domain").FilterOption[]>;
+    updateOptions(filterId: number, { options }: Pick<UpdateRepositoryParams<Filter>, 'options'>): Promise<any[]>;
     delete(params: DeleteRepositoryParams<Filter>): Promise<void>;
     deleteOptions(filterId: number): Promise<void>;
 }

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

@@ -1,9 +1,7 @@
 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("../../../../domain").UpdateRepository<FilterOption, import("../../../../domain").RepositoryUpdateParams<FilterOption>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<FilterOption>): Partial<FilterOption>;
-}, [HasuraConstructorParams<FilterOption> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+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'>);
 }

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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 {};

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

@@ -0,0 +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[]>;
+}

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

@@ -0,0 +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 {};

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

@@ -0,0 +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[];
+}

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

@@ -0,0 +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';

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

@@ -0,0 +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 {};

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

@@ -0,0 +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 {};

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

@@ -0,0 +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 {};

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

@@ -0,0 +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 {};

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

@@ -0,0 +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 {};