@infrab4a/connect 4.0.0-beta.8 → 4.0.0

package/infra/firebase/firestore/repositories/users/user-firestore.repository.d.ts

@@ -1,9 +1,9 @@
-import { DocumentData, Firestore, QueryDocumentSnapshot } from 'firebase/firestore';
+import { DocumentData, QueryDocumentSnapshot } from 'firebase/firestore';
 import { User, UserRepository } from '../../../../../domain';
-declare const UserFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<User> & import("../../../../../domain").CrudRepository<User, import("../../../../../domain").CrudParams<User>> & import("@infrab4a/connect").FirestoreHelpers, {}[]>;
+import { FirestoreConstructorParams } from '../../mixins';
+declare const UserFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<User> & import("../../../../../domain").CrudRepository<User, import("../../../../../domain").CrudParams<User>> & import("@infrab4a/connect").FirestoreHelpers, [FirestoreConstructorParams<User>, ...any[]]>;
 export declare class UserFirestoreRepository extends UserFirestoreRepository_base implements UserRepository {
-    readonly firestore: Firestore;
-    constructor(firestore: Firestore);
+    constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<User>, 'firestore' | 'interceptors'>);
     get(identifiers: Partial<User>): Promise<User>;
     checkIfExistsByField(field: string, value: string): Promise<boolean>;
     buildModelInstance(): {

package/infra/firebase/firestore/repositories/users/user-payment-method-firestore.repository.d.ts

@@ -1,13 +1,12 @@
-import { Firestore } from 'firebase/firestore';
 import { User, UserPaymentMethod, UserPaymentMethodRepository } from '../../../../../domain';
+import { FirestoreConstructorParams } from '../../mixins';
 import { UserFirestoreRepository } from './user-firestore.repository';
 declare const UserPaymentMethodFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("@infrab4a/connect").FirestoreRepository<UserPaymentMethod> & import("../../../../../domain").CrudRepository<UserPaymentMethod, import("../../../../../domain").CrudParams<UserPaymentMethod>> & import("@infrab4a/connect").FirestoreHelpers & {
     readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<User>;
     parentIdField: "id" | "userId";
-}, {}[][]>;
+}, [FirestoreConstructorParams<UserPaymentMethod> & import("../../mixins").FirestoreSubCollectionConstructorParams<UserPaymentMethod>, ...any[]]>;
 export declare class UserPaymentMethodFirestoreRepository extends UserPaymentMethodFirestoreRepository_base implements UserPaymentMethodRepository {
-    readonly firestore: Firestore;
     readonly parentRepository: UserFirestoreRepository;
-    constructor(firestore: Firestore, parentRepository: UserFirestoreRepository);
+    constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<UserPaymentMethod>, 'firestore' | 'interceptors'>, parentRepository: UserFirestoreRepository);
 }
 export {};

package/infra/firebase/firestore/types/firestore-interceptors.type.d.ts

@@ -0,0 +1,14 @@
+import { ModelBaseStructure, RepositoryFindFielters, RepositoryLimitOptions, RepositoryOrderBy } from '../../../../domain';
+export declare type FirestoreIntertceptorRequestParams<TBase extends ModelBaseStructure, T = any> = {
+    instance?: TBase;
+    find?: {
+        filters?: RepositoryFindFielters<TBase>;
+        limits?: RepositoryLimitOptions<TBase>;
+        orderBy?: RepositoryOrderBy<TBase>;
+    };
+} & T;
+export interface FirestoreInterceptors<TBase extends ModelBaseStructure> {
+    request?: <R>(request: FirestoreIntertceptorRequestParams<TBase, R>) => Promise<FirestoreIntertceptorRequestParams<TBase, R>>;
+    response?<R, T>(response: TBase, request: FirestoreIntertceptorRequestParams<TBase, T>): Promise<TBase & R>;
+    response?<R, T>(response: TBase[], request: FirestoreIntertceptorRequestParams<TBase, T>): Promise<TBase[] & R>;
+}

package/infra/firebase/firestore/types/firestore-sub.repository.type.d.ts

@@ -1,6 +1,6 @@
+import { IdentifierModel, ModelBaseStructure } from '../../../../domain';
 import { FirestoreRepository } from './firestore.repository.type';
-import { BaseModel, ModelBaseStructure, IdentifiersModel } from '../../../../domain';
-export declare type FirestoreSubRepository<Model extends ModelBaseStructure, ParentModel extends ModelBaseStructure = BaseModel<{}>> = {
+export declare type FirestoreSubRepository<Model extends ModelBaseStructure<Model>, ParentModel extends ModelBaseStructure<ParentModel>> = {
     readonly parentRepository: FirestoreRepository<ParentModel>;
-    parentIdField: keyof IdentifiersModel<Model>;
+    parentIdField: IdentifierModel<Model>;
 } & FirestoreRepository<Model>;

package/infra/firebase/firestore/types/firestore.helpers.type.d.ts

@@ -1,8 +1,8 @@
-import { QuerySnapshot, QueryDocumentSnapshot } from 'firebase/firestore';
-import { BaseModel } from '../../../../domain';
-import { FirestoreRepository } from './firestore.repository.type';
+import { QueryDocumentSnapshot, QuerySnapshot } from 'firebase/firestore';
+import { ModelBaseStructure } from '../../../../domain';
 import { FirestoreSubRepository } from './firestore-sub.repository.type';
+import { FirestoreRepository } from './firestore.repository.type';
 export interface FirestoreHelpers {
-    toArray<T extends BaseModel<T>>(snapShot: QuerySnapshot<T> | Array<QueryDocumentSnapshot<T>>): Array<T>;
-    isSubCollection<T extends BaseModel<T>>(repository: FirestoreRepository<T>): repository is FirestoreSubRepository<T>;
+    toArray<T extends ModelBaseStructure<T>>(snapShot: QuerySnapshot<T> | Array<QueryDocumentSnapshot<T>>): Array<T>;
+    isSubCollection<T extends ModelBaseStructure<T>, E extends ModelBaseStructure<E>>(repository: FirestoreRepository<T> | FirestoreSubRepository<T, E>): repository is FirestoreSubRepository<T, E>;
 }

package/infra/firebase/firestore/types/firestore.repository.type.d.ts

@@ -1,12 +1,14 @@
 import { CollectionReference, DocumentData, Firestore, QueryDocumentSnapshot } from 'firebase/firestore';
 import { BaseModelBuilder, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames } from '../../../../domain';
 import { FirestoreFieldType } from '../enums';
-export declare type FirestoreRepository<Model extends ModelBaseStructure> = {
+import { FirestoreInterceptors } from './firestore-interceptors.type';
+export declare type FirestoreRepository<Model extends ModelBaseStructure<Model>> = {
     readonly firestore?: Firestore;
     collectionName: string;
     model: BaseModelBuilder<Model>;
     collection(path?: string): CollectionReference<Model>;
     fields?: Partial<Record<NonFunctionAndIdentifierPropertyNames<Model>, FirestoreFieldType>>;
+    interceptors?: FirestoreInterceptors<Model>;
     buildModelInstance(): {
         toFirestore: (data: Model) => DocumentData;
         fromFirestore: (snap: QueryDocumentSnapshot<Model>) => Model;

package/infra/firebase/firestore/types/index.d.ts

@@ -1,3 +1,4 @@
-export * from './firestore.repository.type';
-export * from './firestore.helpers.type';
+export * from './firestore-interceptors.type';
 export * from './firestore-sub.repository.type';
+export * from './firestore.helpers.type';
+export * from './firestore.repository.type';

package/infra/hasura-graphql/mixins/helpers/attribute-option.helper.d.ts

@@ -4,9 +4,15 @@ declare type FindByAttributeResult<MBase extends ModelBaseStructure<MBase>, Attr
     attributeName: Attribute;
 };
 export declare class AttributeOptionHelper {
-    static FindByAttribute: <MBase extends ModelBaseStructure<any, any>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase> = NonFunctionAndIdentifierPropertyNames<MBase>>(attributeName: Attribute, fields: HasuraGraphQLFields<MBase>) => FindByAttributeResult<MBase, Attribute>;
-    static CheckIsColumnOption: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(fieldValue: any) => fieldValue is ColumnOptions<Model, ParentModel, any>;
-    static FindColumnOptionFromList: <Model extends ModelBaseStructure<any, any>, ParentModel extends ModelBaseStructure<any, any>>(columnName: string, fields: HasuraGraphQLFields<ParentModel>) => ColumnOptions<Model, ParentModel, any> & {
+    static FindByAttribute: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, Attribute extends NonFunctionAndIdentifierPropertyNames<MBase> = NonFunctionAndIdentifierPropertyNames<MBase>>(attributeName: Attribute, fields: HasuraGraphQLFields<MBase>) => FindByAttributeResult<MBase, Attribute>;
+    static CheckIsColumnOption: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>, ParentModel extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>>(fieldValue: any) => fieldValue is ColumnOptions<Model, ParentModel, any>;
+    static FindColumnOptionFromList: <Model extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>, ParentModel extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>>(columnName: string, fields: HasuraGraphQLFields<ParentModel>) => ColumnOptions<Model, ParentModel, any> & {
         attributeName: NonFunctionAndIdentifierPropertyNames<ParentModel>;
     };
 }

package/infra/hasura-graphql/mixins/helpers/bind-filter-query.helper.d.ts

@@ -2,9 +2,9 @@ import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionP
 import { HasuraGraphQLWhere } from '../../enums';
 import { ColumnOptions, HasuraGraphQLFields, VariableOptions } from '../../types';
 export declare class BindFilterQueryHelper {
-    static MakeGraphQLWhere: <MBase extends ModelBaseStructure<any, any>>(filter: RepositoryFindFielters<MBase>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
-    static BuildWhereSentence: <MBase extends ModelBaseStructure<any, any>>(field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
-    static BuildOperatorSentence: <MBase extends ModelBaseStructure<any, any>>(options: RepositoryFindFieltersOptions<MBase, any>, fieldOption: ColumnOptions<any, any>) => VariableOptions;
-    static GetHasuraOperator: <MBase extends ModelBaseStructure<any, any>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>, fieldOption: ColumnOptions<any, any>) => HasuraGraphQLWhere;
-    static GetHasuraJsonbOperator: <MBase extends ModelBaseStructure<any, any>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, keyof MBase>>) => HasuraGraphQLWhere;
+    static MakeGraphQLWhere: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(filter: RepositoryFindFielters<MBase>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
+    static BuildWhereSentence: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(field: NonFunctionAndIdentifierPropertyNames<MBase>, options: RepositoryFindFieltersOptions<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>, fields: HasuraGraphQLFields<MBase>) => VariableOptions;
+    static BuildOperatorSentence: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(options: RepositoryFindFieltersOptions<MBase, any>, fieldOption: ColumnOptions<any, any>) => VariableOptions;
+    static GetHasuraOperator: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, MBase, Exclude<keyof MBase, import("../../../../domain").ReadonlyKeys<MBase>>>>, fieldOption: ColumnOptions<any, any>) => HasuraGraphQLWhere;
+    static GetHasuraJsonbOperator: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>>(options: RepositoryFindFieltersOptions<MBase, NonFunctionPropertyNames<MBase, MBase, Exclude<keyof MBase, import("../../../../domain").ReadonlyKeys<MBase>>>>) => HasuraGraphQLWhere;
 }

package/infra/hasura-graphql/mixins/helpers/filter-option.helper.d.ts

@@ -1,6 +1,8 @@
 import { ModelBaseStructure, RepositoryFindFieltersOptions } from '../../../../domain';
 import { ColumnOptions } from '../../types';
 export declare class FilterOptionHelper {
-    static CheckIfIsFilterOption: <Model extends ModelBaseStructure<any, any>>(filter: any) => filter is RepositoryFindFieltersOptions<Model, any>;
-    static GetValueFromFilter: <Model extends ModelBaseStructure<any, any>>(filter: RepositoryFindFieltersOptions<Model, any>, fieldOption: ColumnOptions<any, any>) => any;
+    static CheckIfIsFilterOption: <Model extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>>(filter: any) => filter is RepositoryFindFieltersOptions<Model, any>;
+    static GetValueFromFilter: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>>(filter: RepositoryFindFieltersOptions<Model, any>, fieldOption: ColumnOptions<any, any>) => any;
 }

package/infra/hasura-graphql/mixins/helpers/graphql-field.helper.d.ts

@@ -1,8 +1,12 @@
-import { ModelBaseStructure, NonFunctionProperties } from '../../../../domain';
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoPartial, PartialIdentifiersModel } from '../../../../domain';
 import { Fields, GraphQLParams, HasuraGraphQLFields } from '../../types';
 export declare class GraphQLFieldHelper {
-    static CheckIsGraphQLParams: <Model extends ModelBaseStructure<any, any>>(params: string | GraphQLParams<Model>[]) => params is GraphQLParams<Model>[];
-    static ConvertModelFieldsToGraphQLFields: <Model extends ModelBaseStructure<any, any>>(fields: HasuraGraphQLFields<Model>) => Fields;
-    static ConvertFieldValueFrom: <Model extends ModelBaseStructure<any, any>, RecordDataType extends string | number | Date | DataType, DataType extends Record<string, RecordDataType | RecordDataType[]>>(data: DataType, fields: HasuraGraphQLFields<Model>) => Partial<NonFunctionProperties<Model>>;
-    static ConvertFieldValueTo: <Model extends ModelBaseStructure<any, any>, DataType extends Record<string, string | number | Date | DataType>>(instance: Model, fields: HasuraGraphQLFields<Model>, update?: boolean) => DataType;
+    static CheckIsGraphQLParams: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>>(params: string | IOperation | GraphQLParams<Model>[]) => params is GraphQLParams<Model>[];
+    static ConvertModelFieldsToGraphQLFields: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>>(fields: HasuraGraphQLFields<Model>) => Fields;
+    static ConvertFieldValueFrom: <Model extends ModelBaseStructure<Record<string, any> & {
+        identifiersFields: any[];
+    }, any>, RecordDataType extends string | number | Date | DataType, DataType extends Record<string, RecordDataType | RecordDataType[]>>(data: DataType, fields: HasuraGraphQLFields<Model>) => NonFunctionAndIdentifierPropertiesWithNoPartial<Model> | Partial<import("../../../../domain").IdentifiersModel<Model>>;
+    static ConvertFieldValueTo: <Model extends ModelBaseStructure<Model, Model["identifiersFields"][number]>, DataType extends Record<string, string | number | Date | DataType>>(instance: Model, fields: HasuraGraphQLFields<Model>, update?: boolean) => DataType;
+    private static ConvertNestedFieldsToGraphQLFields;
 }

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

@@ -3,6 +3,7 @@ import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
 export declare type CreateConstructorParams = {
     insertGraphQLOperation?: string;
+    insertAllGraphQLOperation?: string;
     insertGraphQLObjectType?: string;
 };
-export declare const withCreateHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, 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>>>;
+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>>>;

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

@@ -4,8 +4,8 @@ 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 { ConstructorParams } from './with-hasura-graphql.mixin';
+import { HasuraConstructorParams } from './with-hasura-graphql.mixin';
 import { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType } from './with-update-hasura-graphql.mixin';
-export declare const withCrudHasuraGraphQL: <TBase extends ModelBaseStructure<any, any>, 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>> & {
+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<[ConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+}, MergeConstructorParams<[HasuraConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -4,4 +4,4 @@ import { GraphQLRepository } from '../types';
 export declare type DeleteConstructorParams = {
     deleteGraphQLOperation?: string;
 };
-export declare const withDeleteHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, 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>>>;
+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>>>;

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

@@ -1,25 +1,34 @@
-import { ModelBaseStructure, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderBy } from '../../../domain';
-import { MixinCtor } from '../../../utils';
-import { GraphQLRepository } from '../types';
-export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+import { FindRepositoryParams, ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, 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[]): {
-        find(options?: {
-            filters?: RepositoryFindFielters<MBase>;
-            fields?: NonFunctionPropertyNames<MBase, keyof MBase>[];
-            limits?: RepositoryLimitOptions<MBase>;
-            orderBy?: RepositoryOrderBy<MBase>;
-        }): Promise<RepositoryFindResult<MBase>>;
+        find(params?: FindRepositoryParams<MBase>): Promise<RepositoryFindResult<MBase>>;
+        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: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
+        model: import("../../../domain").BaseModelBuilder<MBase, any, MBase & {
             prototype: unknown;
         }>;
-        fields: import("../types").HasuraGraphQLFields<MBase>;
+        fields: HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        logger: DebugHelper;
+        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>) => MBase;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<MBase>): MBase;
         convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
     };
 } & TMixinBase;

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

@@ -1,24 +1,25 @@
 import { GetRepositoryParams, ModelBaseStructure } from '../../../domain';
-import { MixinCtor } from '../../../utils';
+import { DebugHelper, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
 export declare type GetConstructorParams = {
     getGraphQLOperation?: string;
 };
-export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => {
+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;
         get(identifiers: GetRepositoryParams<MBase>): Promise<MBase>;
         tableName: string;
-        model: import("../../../domain").BaseModelBuilder<MBase, import("../../../domain").NonFunctionAndIdentifierPropertyNames<MBase>, MBase & {
+        model: import("../../../domain").BaseModelBuilder<MBase, any, MBase & {
             prototype: unknown;
         }>;
         fields: import("../types").HasuraGraphQLFields<MBase>;
         endpoint: string;
         authOptions: import("../types").HasuraGraphQLAuthOptions;
-        mutation: <ReturnFields = any>(operation: string, fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields>;
-        query: <ReturnFields_1 = any>(operation: string | import("../types").GraphQLParams<MBase>[], fields?: import("../types").HasuraGraphQLFields<MBase>, variables?: import("../types").VariableOptions) => Promise<ReturnFields_1>;
+        logger: DebugHelper;
+        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>) => MBase;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | import("../types").HasuraGraphQLFields<MBase>): MBase;
         convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
     };
 } & TMixinBase;

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

@@ -1,11 +1,23 @@
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
 import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields } from '../types';
-export declare type ConstructorParams<Model extends ModelBaseStructure> = {
+import { Fields, GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../types';
+declare type QueryBuilderOptions = {
+    operation: string | IOperation;
+    fields: Fields;
+    variables?: VariableOptions;
+};
+declare type HasuraGraphQLInterceptors<P = QueryBuilderOptions | QueryBuilderOptions[]> = {
+    request?: <R>(request: P) => Promise<P & R>;
+    response?: <R>(response: R, request: P) => Promise<R>;
+};
+export declare type HasuraConstructorParams<Model extends ModelBaseStructure<Model, Model['identifiersFields'][number]>> = {
     tableName: string;
     model: BaseModelBuilder<Model>;
     fields: HasuraGraphQLFields<Model>;
     endpoint: string;
+    interceptors?: HasuraGraphQLInterceptors;
     authOptions: HasuraGraphQLAuthOptions;
 };
-export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, MergeConstructorParams<any[], ConstructorParameters<T>>>;
+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/infra/hasura-graphql/mixins/with-update-hasura-graphql.mixin.d.ts

@@ -1,7 +1,7 @@
 import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { GraphQLRepository } from '../types';
-export declare type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure> = UpdateRepository<MBase> & {
+export declare type UpdateHasuraGraphQLRepositoryType<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>> = UpdateRepository<MBase> & {
     paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
 };
 export declare type UpdateConstructorParams = {
@@ -9,6 +9,6 @@ export declare type UpdateConstructorParams = {
     updateGraphQLObjectType?: string;
     updateGraphQLPKType?: string;
 };
-export declare const withUpdateHasuraGraphQL: <MBase extends ModelBaseStructure<any, any>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>, any[]>>(MixinBase: MixinCtor<GraphQLRepository<MBase>, any[]> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateRepository<MBase, RepositoryUpdateParams<MBase>> & {
+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>>>;

package/infra/hasura-graphql/models/product-hasura-graphql.d.ts

@@ -10,5 +10,9 @@ export declare class ProductHasuraGraphQL extends Product {
     whoMustUse?: string;
     howToUse?: string;
     brandDescription?: string;
+    categoryId?: number;
+    ingredients?: string;
+    hasStock?: boolean;
+    intGender?: number;
     kitProducts?: KitProductHasuraGraphQL[];
 }

package/infra/hasura-graphql/models/variant-hasura-graphql.d.ts

@@ -4,6 +4,7 @@ export declare class VariantHasuraGraphQL extends Variant {
     fullPrice?: number;
     subscriberDiscountPercentage?: number;
     subscriberPrice?: number;
+    hasStock?: boolean;
     name?: string;
     hasVariants?: boolean;
 }

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

@@ -0,0 +1,10 @@
+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("@infrab4a/connect").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[]]>;
+export declare class CategoryCollectionChildrenHasuraGraphQLRepository extends CategoryCollectionChildrenHasuraGraphQLRepository_base implements CategoryCollectionChildrenRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryCollectionChildren>, 'endpoint' | 'authOptions' | 'interceptors'>);
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { CategoryFilter } from '../../../../domain';
+import { CategoryFilterRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const CategoryFilterHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").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[]]>;
+export declare class CategoryFilterHasuraGraphQLRepository extends CategoryFilterHasuraGraphQLRepository_base implements CategoryFilterRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    deleteByCategory(categoryId: number): Promise<any>;
+    deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any>;
+}
+export {};

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

@@ -1,27 +1,34 @@
 import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
 import { CategoryHasuraGraphQL } from '../../models';
-import { HasuraGraphQLAuthOptions } from '../../types';
+import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
 import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
-declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<CategoryHasuraGraphQL> & import("../../../../domain").CrudRepository<CategoryHasuraGraphQL, import("../../../../domain").CrudParams<CategoryHasuraGraphQL>> & import("../../../../domain").UpdateRepository<CategoryHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<CategoryHasuraGraphQL>> & {
+declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").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>;
-}, [import("../../mixins").ConstructorParams<CategoryHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+}, [HasuraConstructorParams<CategoryHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
     private readonly productRepository;
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions, productRepository: ProductHasuraGraphQLRepository);
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
     create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
-    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
+    getCategoryByShop(shop: string): Promise<Category[]>;
+    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): Promise<{
         category: Category;
         products: Product[];
     }[]>;
     mountCategory(category: Category, options?: {
         limit?: number;
         hasStock?: boolean;
+        gender?: string;
     }): Promise<Product[]>;
     private getId;
     private updateProducts;
     private updateMetadata;
+    private updateFilters;
+    getChildren(parentId: number): Promise<Category[]>;
+    isChild(id: number, parentId: number): Promise<boolean>;
 }
 export {};

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

@@ -0,0 +1,18 @@
+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("@infrab4a/connect").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[]]>;
+export declare class FilterHasuraGraphQLRepository extends FilterHasuraGraphQLRepository_base implements FilterRepository {
+    private readonly filterOptionRepository;
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors'>, filterOptionRepository: FilterOptionHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    update(params: UpdateRepositoryParams<Filter>): Promise<Filter>;
+    updateOptions(filterId: number, { options }: Pick<UpdateRepositoryParams<Filter>, 'options'>): Promise<import("../../../../domain").FilterOption[]>;
+    delete(params: DeleteRepositoryParams<Filter>): Promise<void>;
+    deleteOptions(filterId: number): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { FilterOption } from '../../../../domain';
+import { FilterOptionRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").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[]]>;
+export declare class FilterOptionHasuraGraphQLRepository extends FilterOptionHasuraGraphQLRepository_base implements FilterOptionRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors'>);
+}
+export {};

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

@@ -1,3 +1,8 @@
+export * from './category-collection-children-hasura-graphql.repository';
+export * from './category-filter-hasura-graphql.repository';
 export * from './category-hasura-graphql.repository';
+export * from './filter-hasura-graphql.repository';
+export * from './filter-option-hasura-graphql.repository';
 export * from './product-hasura-graphql.repository';
 export * from './variant-hasura-graphql.repository';
+export * from './wishlist-hasura-graphql.repository';

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

@@ -1,18 +1,19 @@
-import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductRepository, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductGender, ProductRepository, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
 import { ProductHasuraGraphQL } from '../../models';
-import { HasuraGraphQLAuthOptions } from '../../types';
 declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<ProductHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductHasuraGraphQL, import("../../../../domain").CrudParams<ProductHasuraGraphQL>> & import("../../../../domain").UpdateRepository<ProductHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>> & {
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>): Partial<ProductHasuraGraphQL>;
-}, [import("../../mixins").ConstructorParams<ProductHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+}, [HasuraConstructorParams<ProductHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQLRepository_base implements ProductRepository {
     private get reviewsFields();
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions);
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>);
     create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     find(params?: FindRepositoryParams<ProductHasuraGraphQL>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
     getBySlug(slug: string): Promise<ProductHasuraGraphQL>;
     update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
     fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
+    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
     private updateCategories;
     private updateKitProducts;
     private updateReviews;
@@ -24,5 +25,6 @@ export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQL
     private getReviewByAuthorAndEmail;
     private bindReviewToModel;
     private bindReviewToHasura;
+    cleanShoppingCountFromIds(ids: string[]): Promise<void>;
 }
 export {};

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

@@ -1,11 +1,11 @@
 import { FindRepositoryParams, GetRepositoryParams, RepositoryFindResult, UpdateRepositoryParams, VariantRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
 import { VariantHasuraGraphQL } from '../../models';
-import { HasuraGraphQLAuthOptions } from '../../types';
-declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../../../domain").UpdateRepository<VariantHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>> & {
+declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../../../domain").UpdateRepository<VariantHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>> & {
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>): Partial<VariantHasuraGraphQL>;
-}, [import("../../mixins").ConstructorParams<VariantHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+}, [HasuraConstructorParams<VariantHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class VariantHasuraGraphQLRepository extends VariantHasuraGraphQLRepository_base implements VariantRepository {
-    constructor(endpoint: string, authOptions: HasuraGraphQLAuthOptions);
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>);
     get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
     find(params?: FindRepositoryParams<VariantHasuraGraphQL>): Promise<RepositoryFindResult<VariantHasuraGraphQL>>;
     update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;

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

@@ -0,0 +1,27 @@
+import { Category, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams, Wishlist, WishlistRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
+declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("@infrab4a/connect").GraphQLRepository<Wishlist> & import("../../../../domain").CrudRepository<Wishlist, import("../../../../domain").CrudParams<Wishlist>> & import("../../../../domain").UpdateRepository<Wishlist, import("../../../../domain").RepositoryUpdateParams<Wishlist>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<Wishlist>): Partial<Wishlist>;
+}, [HasuraConstructorParams<Wishlist> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class WishlistHasuraGraphQLRepository extends WishlistHasuraGraphQLRepository_base implements WishlistRepository {
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors'>, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    create(params: CreateRepositoryParams<Wishlist>): Promise<Wishlist>;
+    get(identifiers: GetRepositoryParams<Wishlist>): Promise<Wishlist>;
+    update(params: UpdateRepositoryParams<Wishlist>): Promise<Wishlist>;
+    getWishlistBySlug(slug: string): Promise<Wishlist>;
+    getWishlistByPerson(personId: string): Promise<Wishlist[]>;
+    private updateProducts;
+    private updateMetadata;
+    getCategoryBySlug(slug: string, _shop: Shops): Promise<Wishlist>;
+    getCategoryByShop(shop: string): Promise<any>;
+    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): any;
+    mountCategory(category: Category, options?: {
+        limit?: number;
+        hasStock?: boolean;
+    }): Promise<Product[]>;
+    getChildren(parentId: number): Promise<Category[]>;
+    isChild(id: number, parentId: number): Promise<boolean>;
+}
+export {};