@infrab4a/connect 5.7.10 → 5.8.0-alpha.1

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

@@ -1,7 +1,7 @@
-import { CrudRepository, ModelBaseStructure } from '../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { GraphQLRepository } from '../types';
-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 & UpdateHasuraGraphQLRepositoryType<TBase>, MergeConstructorParams<[HasuraConstructorParams<TBase> & CreateConstructorParams & DeleteConstructorParams & GetConstructorParams & UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;
+import { CrudRepository, ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
+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>, TMixinBase extends MixinCtor = MixinCtor>(MixinBase: MixinCtor<GraphQLRepository<TBase>> & 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,5 +1,5 @@
-import { DeleteRepository, ModelBaseStructure } from '../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { GraphQLRepository } from '../types';
-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>>>;
+import { DeleteRepository, ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
+import { DeleteConstructorParams } from './factories';
+export declare const withDeleteHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & DeleteRepository<MBase> & InstanceType<TMixinBase>, MergeConstructorParams<[DeleteConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,4 +1,4 @@
-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>>>;
+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>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & FindRepository<MBase> & InstanceType<TMixinBase>, MergeConstructorParams<[...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,5 +1,5 @@
-import { GetRepository, ModelBaseStructure } from '../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { GraphQLRepository } from '../types';
-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>>>;
+import { GetRepository, ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
+import { GetConstructorParams } from './factories';
+export declare const withGetHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & GetRepository<MBase> & InstanceType<TMixinBase>, MergeConstructorParams<[GetConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>>;

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

@@ -1,6 +1,6 @@
-import { ModelBaseStructure } from '../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../utils';
-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[]>;
+import { ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+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 = MixinCtor>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, MergeConstructorParams<any[], HasuraConstructorParams<MBase>[]>>;

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

@@ -1,6 +1,6 @@
-import { ModelBaseStructure } from '../../../domain';
-import { MergeConstructorParams, MixinCtor } from '../../../utils';
-import { GraphQLRepository } from '../types';
-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>>>;
+import { ModelBaseStructure } from '../../../domain';
+import { MergeConstructorParams, MixinCtor } from '../../../utils';
+import { GraphQLRepository } from '../types';
+import { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType } from './factories/update-hasura-class.factory';
+export { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType };
+export declare const withUpdateHasuraGraphQL: <MBase extends ModelBaseStructure<MBase>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => MixinCtor<GraphQLRepository<MBase> & UpdateHasuraGraphQLRepositoryType<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,7 +1,7 @@
-export * from './category-hasura-graphql';
-export * from './kit-product-hasura-graphql';
-export * from './product-catalog-hasura-graphql';
-export * from './product-errors-hasura-graphql';
-export * from './product-hasura-graphql';
-export * from './product-stock-entry-hasura-graphql';
-export * from './variant-hasura-graphql';
+export * from './category-hasura-graphql';
+export * from './kit-product-hasura-graphql';
+export * from './product-catalog-hasura-graphql';
+export * from './product-errors-hasura-graphql';
+export * from './product-hasura-graphql';
+export * from './product-stock-entry-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-catalog-hasura-graphql.d.ts

@@ -1,16 +1,16 @@
-import { Product } from '../../../domain';
-export declare class ProductCatalogHasuraGraphQL 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;
-}
+import { Product } from '../../../domain';
+export declare class ProductCatalogHasuraGraphQL 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;
+}

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

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

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/product-stock-entry-hasura-graphql.d.ts

@@ -1,3 +1,3 @@
-import { ProductStockEntry } from '../../../domain';
-export declare class ProductStockEntryHasuraGraphQL extends ProductStockEntry {
-}
+import { ProductStockEntry } from '../../../domain';
+export declare class ProductStockEntryHasuraGraphQL extends ProductStockEntry {
+}

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

@@ -1,15 +1,15 @@
-import { Variant } from '../../../domain';
-export declare class VariantHasuraGraphQL extends Variant {
-    firestoreId?: string;
-    fullPrice?: number;
-    subscriberDiscountPercentage?: number;
-    subscriberPrice?: number;
-    hasStock?: boolean;
-    differentials?: string;
-    whoMustUse?: string;
-    howToUse?: string;
-    brandDescription?: string;
-    categoryId?: number;
-    ingredients?: string;
-    intGender?: number;
-}
+import { Variant } from '../../../domain';
+export declare class VariantHasuraGraphQL extends Variant {
+    firestoreId?: string;
+    fullPrice?: number;
+    subscriberDiscountPercentage?: number;
+    subscriberPrice?: number;
+    hasStock?: boolean;
+    differentials?: string;
+    whoMustUse?: string;
+    howToUse?: string;
+    brandDescription?: string;
+    categoryId?: number;
+    ingredients?: string;
+    intGender?: number;
+}

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

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

@@ -1,11 +1,11 @@
-import { CategoryFilter } from '../../../../domain';
-import { CategoryFilterRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-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>;
-    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("../../../..").MixinCtor<import("../..").GraphQLRepository<CategoryFilter> & import("../../../..").CrudRepository<CategoryFilter, import("../../../..").CrudParams<CategoryFilter>> & import("../..").UpdateHasuraGraphQLRepositoryType<CategoryFilter>, [HasuraConstructorParams<CategoryFilter> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../..").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>;
+    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,38 +1,38 @@
-import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, RepositoryCacheOptions, Shops, UpdateRepositoryParams } from '../../../../domain';
-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("../../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;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
-    create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<CategoryHasuraGraphQL>;
-    update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
-    getCategoryBySlug(slug: string, shop: Shops, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category>;
-    getCategoryByShop(shop: string, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    getCategoriesForHome(params: CategoriesForHomeParams): Promise<{
-        category: Category;
-        products: Product[];
-    }[]>;
-    mountCategory(params: MountCategoryParams): Promise<Product[]>;
-    getChildren(parentId: number, _optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
-    private getId;
-    private updateProducts;
-    private updateMetadata;
-    private updateFilters;
-    getBrandsWithProducts(): Promise<Category[]>;
-}
-export {};
+import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, RepositoryCacheOptions, Shops, UpdateRepositoryParams } from '../../../../domain';
+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("../../../..").MixinCtor<import("../..").GraphQLRepository<CategoryHasuraGraphQL> & import("../../../..").CrudRepository<CategoryHasuraGraphQL, import("../../../..").CrudParams<CategoryHasuraGraphQL>> & import("../..").UpdateHasuraGraphQLRepositoryType<CategoryHasuraGraphQL>, [HasuraConstructorParams<CategoryHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../..").UpdateConstructorParams, ...any[]]>;
+export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
+    private readonly productRepository;
+    private readonly categoryFilterRepository;
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
+    get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<CategoryHasuraGraphQL>;
+    update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
+    getCategoryBySlug(slug: string, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category>;
+    getCategoryByShop(shop: string, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    getCategoriesForHome(params: CategoriesForHomeParams): Promise<{
+        category: Category;
+        products: Product[];
+    }[]>;
+    mountCategory(params: MountCategoryParams): Promise<Product[]>;
+    getChildren(parentId: number, _optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    isChild(id: number, parentId: number): Promise<boolean>;
+    private getId;
+    private updateProducts;
+    private updateMetadata;
+    private updateFilters;
+    getBrandsWithProducts(): Promise<Category[]>;
+}
+export {};

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

@@ -1,16 +1,16 @@
-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("../../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>;
-    removeProductFromCategories(productId: string, categoryIds: string[]): Promise<void>;
-    addProductsToCategory(categoryId: string, productIds: {
-        productId: string;
-        order: number;
-    }[]): Promise<void>;
-    addProductToCategories(productId: string, categoryIds: string[]): Promise<void>;
-    removeProductFromAllCategories(productId: string): Promise<void>;
-    removeCategoryFromAllProducts(categoryId: string): Promise<void>;
-}
-export {};
+import { CategoryProduct, CategoryProductRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+declare const CategoryProductHasuraGraphQLRepository_base: import("../../../..").MixinCtor<import("../..").GraphQLRepository<CategoryProduct> & import("../../../..").CrudRepository<CategoryProduct, import("../../../..").CrudParams<CategoryProduct>> & import("../..").UpdateHasuraGraphQLRepositoryType<CategoryProduct>, [HasuraConstructorParams<CategoryProduct> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../..").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>;
+    removeProductFromCategories(productId: string, categoryIds: string[]): Promise<void>;
+    addProductsToCategory(categoryId: string, productIds: {
+        productId: string;
+        order: number;
+    }[]): Promise<void>;
+    addProductToCategories(productId: string, categoryIds: string[]): Promise<void>;
+    removeProductFromAllCategories(productId: string): Promise<void>;
+    removeCategoryFromAllProducts(categoryId: string): Promise<void>;
+}
+export {};

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

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

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

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

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

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

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

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