@infrab4a/connect 4.24.0-beta.1 → 4.24.1-beta.0

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

@@ -1,25 +1,25 @@
-import { GetRepositoryParams, ModelBaseStructure } from '../../../domain';
-import { DebugHelper, 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;
-        get(identifiers: GetRepositoryParams<MBase>): 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;
-        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 { GetRepositoryParams, ModelBaseStructure } from '../../../domain';
+import { DebugHelper, 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>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => {
+    new (...params: any[]): {
+        getGraphQLOperation: string;
+        get(identifiers: GetRepositoryParams<MBase>): 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;
+        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;

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

@@ -1,23 +1,23 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
-import { BaseModelBuilder, 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;
-};
-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 {};
+import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
+import { BaseModelBuilder, 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;
+};
+export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, T extends MixinCtor = MixinCtor>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, any[]>;
+export {};

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

@@ -1,14 +1,14 @@
-import { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } 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 { ModelBaseStructure, RepositoryUpdateParams, UpdateRepository } 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>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateRepository<MBase, RepositoryUpdateParams<MBase>> & {
+    paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>;
+} & InstanceType<TMixinBase>, MergeConstructorParams<[UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/hasura-graphql/models/category-hasura-graphql.d.ts

@@ -1,6 +1,6 @@
-import { Category } from '../../../domain';
-export declare class CategoryHasuraGraphQL extends Category {
-    firestoreId?: string;
-    brandCondition?: string;
-    tagCondition?: string[];
-}
+import { Category } from '../../../domain';
+export declare class CategoryHasuraGraphQL extends Category {
+    firestoreId?: string;
+    brandCondition?: string;
+    tagCondition?: string[];
+}

package/src/infra/hasura-graphql/models/index.d.ts

@@ -1,5 +1,5 @@
-export * from './category-hasura-graphql';
-export * from './kit-product-hasura-graphql';
-export * from './product-errors-hasura-graphql';
-export * from './product-hasura-graphql';
-export * from './variant-hasura-graphql';
+export * from './category-hasura-graphql';
+export * from './kit-product-hasura-graphql';
+export * from './product-errors-hasura-graphql';
+export * from './product-hasura-graphql';
+export * from './variant-hasura-graphql';

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

@@ -1,5 +1,5 @@
-import { KitProduct, Product } from '../../../domain';
-export declare class KitProductHasuraGraphQL extends KitProduct {
-    kit: Product;
-    product: Product;
-}
+import { KitProduct, Product } from '../../../domain';
+export declare class KitProductHasuraGraphQL extends KitProduct {
+    kit: Product;
+    product: Product;
+}

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

@@ -1,6 +1,3 @@
-import { ProductErrors } from '../../../domain';
-import { ProductHasuraGraphQL } from './product-hasura-graphql';
-import { VariantHasuraGraphQL } from './variant-hasura-graphql';
-export declare class ProductErrorsHasuraGraphQL extends ProductErrors<ProductHasuraGraphQL | VariantHasuraGraphQL> {
-    product: ProductHasuraGraphQL | VariantHasuraGraphQL;
-}
+import { ProductErrors } from '../../../domain';
+export declare class ProductErrorsHasuraGraphQL extends ProductErrors {
+}

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

@@ -1,18 +1,18 @@
-import { Product } from '../../../domain';
-import { KitProductHasuraGraphQL } from './kit-product-hasura-graphql';
-export declare class ProductHasuraGraphQL extends Product {
-    firestoreId?: string;
-    fullPrice?: number;
-    subscriberDiscountPercentage?: number;
-    subscriberPrice?: number;
-    productId?: number;
-    differentials?: string;
-    whoMustUse?: string;
-    howToUse?: string;
-    brandDescription?: string;
-    categoryId?: number;
-    ingredients?: string;
-    hasStock?: boolean;
-    intGender?: number;
-    kitProducts?: KitProductHasuraGraphQL[];
-}
+import { Product } from '../../../domain';
+import { KitProductHasuraGraphQL } from './kit-product-hasura-graphql';
+export declare class ProductHasuraGraphQL extends Product {
+    firestoreId?: string;
+    fullPrice?: number;
+    subscriberDiscountPercentage?: number;
+    subscriberPrice?: number;
+    productId?: number;
+    differentials?: string;
+    whoMustUse?: string;
+    howToUse?: string;
+    brandDescription?: string;
+    categoryId?: number;
+    ingredients?: string;
+    hasStock?: boolean;
+    intGender?: number;
+    kitProducts?: KitProductHasuraGraphQL[];
+}

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

@@ -1,8 +1,8 @@
-import { Variant } from '../../../domain';
-export declare class VariantHasuraGraphQL extends Variant {
-    firestoreId?: string;
-    fullPrice?: number;
-    subscriberDiscountPercentage?: number;
-    subscriberPrice?: number;
-    hasStock?: boolean;
-}
+import { Variant } from '../../../domain';
+export declare class VariantHasuraGraphQL extends Variant {
+    firestoreId?: string;
+    fullPrice?: number;
+    subscriberDiscountPercentage?: number;
+    subscriberPrice?: number;
+    hasStock?: boolean;
+}

package/src/infra/hasura-graphql/models/wishlist-hasura-graphql.d.ts

@@ -1,4 +1,4 @@
-import { Wishlist } from '../../../domain';
-export declare class WishlistHasuraGraphQL extends Wishlist {
-    personHasPhoto?: boolean;
-}
+import { Wishlist } from '../../../domain';
+export declare class WishlistHasuraGraphQL extends Wishlist {
+    personHasPhoto?: boolean;
+}

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

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

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

@@ -1,12 +1,12 @@
-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[]]>;
-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 {};
+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[]]>;
+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/src/infra/hasura-graphql/repositories/catalog/category-hasura-graphql.repository.d.ts

@@ -1,34 +1,34 @@
-import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { CategoryHasuraGraphQL } from '../../models';
-import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
-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[]]>;
-export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
-    private readonly productRepository;
-    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>;
-    getCategoryByShop(shop: string): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number): Promise<{
-        category: Category;
-        products: Product[];
-    }[]>;
-    mountCategory(category: Category, shop: Shops, options?: {
-        limit?: number;
-        hasStock?: boolean;
-        gender?: string;
-    }): Promise<Product[]>;
-    getChildren(parentId: number): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
-    private getId;
-    private updateProducts;
-    private updateMetadata;
-    private updateFilters;
-}
-export {};
+import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+import { CategoryHasuraGraphQL } from '../../models';
+import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
+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[]]>;
+export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
+    private readonly productRepository;
+    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>;
+    getCategoryByShop(shop: string): Promise<Category[]>;
+    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number): Promise<{
+        category: Category;
+        products: Product[];
+    }[]>;
+    mountCategory(category: Category, shop: Shops, options?: {
+        limit?: number;
+        hasStock?: boolean;
+        gender?: string;
+    }): Promise<Product[]>;
+    getChildren(parentId: number): Promise<Category[]>;
+    isChild(id: number, parentId: number): Promise<boolean>;
+    private getId;
+    private updateProducts;
+    private updateMetadata;
+    private updateFilters;
+}
+export {};

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

@@ -1,11 +1,11 @@
-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[]]>;
-export declare class CategoryProductHasuraGraphQLRepository extends CategoryProductHasuraGraphQLRepository_base implements CategoryProductRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors'>);
-    removeProductFromCategory(categoryId: string, productId: string): Promise<void>;
-    addProductToCategory(categoryId: string, productId: string): Promise<void>;
-}
-export {};
+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[]]>;
+export declare class CategoryProductHasuraGraphQLRepository extends CategoryProductHasuraGraphQLRepository_base implements CategoryProductRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    removeProductFromCategory(categoryId: string, productId: string): Promise<void>;
+    addProductToCategory(categoryId: string, productId: string): Promise<void>;
+}
+export {};

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

@@ -1,18 +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("../..").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 {};
+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("../..").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/src/infra/hasura-graphql/repositories/catalog/filter-option-hasura-graphql.repository.d.ts

@@ -1,10 +1,10 @@
-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[]]>;
-export declare class FilterOptionHasuraGraphQLRepository extends FilterOptionHasuraGraphQLRepository_base implements FilterOptionRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors'>);
-}
-export {};
+import { FilterOption } from '../../../../domain';
+import { FilterOptionRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<FilterOption> & import("../../../../domain").CrudRepository<FilterOption, import("../../../../domain").CrudParams<FilterOption>> & import("../../../../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/src/infra/hasura-graphql/repositories/catalog/index.d.ts

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

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

@@ -1,15 +1,15 @@
-import { FindRepositoryParams, GetRepositoryParams } from '../../../../domain';
-import { ProductErrorsRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-import { ProductErrorsHasuraGraphQL } from '../../models';
-import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
-declare const ProductErrorsHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductErrorsHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").CrudParams<ProductErrorsHasuraGraphQL>> & import("../../../../domain").UpdateRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductErrorsHasuraGraphQL>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductErrorsHasuraGraphQL>): Partial<ProductErrorsHasuraGraphQL>;
-}, [HasuraConstructorParams<ProductErrorsHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductErrorsHasuraGraphQLRepository extends ProductErrorsHasuraGraphQLRepository_base implements ProductErrorsRepository {
-    private readonly productRepository;
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>, productRepository: ProductHasuraGraphQLRepository);
-    get(params: GetRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<ProductErrorsHasuraGraphQL>;
-    find(params: FindRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<import("../../../../domain").RepositoryFindResult<ProductErrorsHasuraGraphQL>>;
-}
-export {};
+import { FindRepositoryParams, GetRepositoryParams } from '../../../../domain';
+import { ProductErrorsRepository } from '../../../../domain/catalog/repositories';
+import { HasuraConstructorParams } from '../../mixins';
+import { ProductErrorsHasuraGraphQL } from '../../models';
+import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository';
+declare const ProductErrorsHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductErrorsHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").CrudParams<ProductErrorsHasuraGraphQL>> & import("../../../../domain").UpdateRepository<ProductErrorsHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductErrorsHasuraGraphQL>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductErrorsHasuraGraphQL>): Partial<ProductErrorsHasuraGraphQL>;
+}, [HasuraConstructorParams<ProductErrorsHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class ProductErrorsHasuraGraphQLRepository extends ProductErrorsHasuraGraphQLRepository_base implements ProductErrorsRepository {
+    private readonly productRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>, productRepository: ProductHasuraGraphQLRepository);
+    get(params: GetRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<ProductErrorsHasuraGraphQL>;
+    find(params: FindRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<import("../../../../domain").RepositoryFindResult<ProductErrorsHasuraGraphQL>>;
+}
+export {};