@infrab4a/connect 5.7.2 → 5.7.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,16 +0,0 @@
-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-catalog-hasura-graphql.repository';
-export * from './product-errors-hasura-graphql.repository';
-export * from './product-group-hasura-graphql.repository';
-export * from './product-hasura-graphql.repository';
-export * from './product-price-log-hasura-graphql.repository';
-export * from './product-review-hasura-graphql.repository';
-export * from './product-stock-entry-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-catalog-hasura-graphql.repository.d.ts

@@ -1,22 +0,0 @@
-import { FindRepositoryParams, Product, ProductCatalogRepository, ProductGender, RepositoryCacheOptions, RepositoryFindResult } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { ProductCatalogHasuraGraphQL, ProductHasuraGraphQL } from '../../models';
-declare const ProductCatalogHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<ProductCatalogHasuraGraphQL> & import("../../../../domain").FindRepository<ProductCatalogHasuraGraphQL, FindRepositoryParams<ProductCatalogHasuraGraphQL>>, any[]>;
-export declare class ProductCatalogHasuraGraphQLRepository extends ProductCatalogHasuraGraphQLRepository_base implements ProductCatalogRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductCatalogHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    get({ id }: {
-        id: string;
-    }, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Product>;
-    getByEAN(EAN: string, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Product>;
-    find(params?: FindRepositoryParams<ProductHasuraGraphQL>, optionsParams?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-}
-export {};

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

@@ -1,13 +0,0 @@
-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("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductErrorsHasuraGraphQL>, [HasuraConstructorParams<ProductErrorsHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductErrorsHasuraGraphQLRepository extends ProductErrorsHasuraGraphQLRepository_base implements ProductErrorsRepository {
-    private readonly productRepository;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, productRepository: ProductHasuraGraphQLRepository);
-    get(params: GetRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<ProductErrorsHasuraGraphQL>;
-    find(params: FindRepositoryParams<ProductErrorsHasuraGraphQL>): Promise<import("../../../../domain").RepositoryFindResult<ProductErrorsHasuraGraphQL>>;
-}
-export {};

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

@@ -1,7 +0,0 @@
-import { ProductGroup, ProductGroupRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-declare const ProductGroupHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductGroup> & import("../../../../domain").CrudRepository<ProductGroup, import("../../../../domain").CrudParams<ProductGroup>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductGroup>, [HasuraConstructorParams<ProductGroup> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductGroupHasuraGraphQLRepository extends ProductGroupHasuraGraphQLRepository_base implements ProductGroupRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductGroup>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-}
-export {};

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

@@ -1,45 +0,0 @@
-import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, PaginatedReviewFilters, ProductGender, ProductRepository, ProductVariantReport, RepositoryCacheOptions, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { ProductHasuraGraphQL } from '../../models';
-declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<ProductHasuraGraphQL> & import("../../../../domain").CrudRepository<ProductHasuraGraphQL, import("../../../../domain").CrudParams<ProductHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductHasuraGraphQL>, [HasuraConstructorParams<ProductHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQLRepository_base implements ProductRepository {
-    private get reviewsFields();
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ProductHasuraGraphQL>;
-    find(params?: FindRepositoryParams<ProductHasuraGraphQL>, optionsParams?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-    getBySlug(slug: string, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ProductHasuraGraphQL>;
-    getByEAN(EAN: string, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ProductHasuraGraphQL>;
-    update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    fetchProductReviews(filters: PaginatedReviewFilters, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ReviewWithProductData[]>;
-    fetchReviews(status: ReviewStatusParams, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<ReviewWithProductData[]>;
-    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>, options?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-    cleanShoppingCountFromIds(ids: string[]): Promise<void>;
-    private getReviewStatus;
-    private updateKitProducts;
-    private updateReviews;
-    private updateMetadata;
-    private getId;
-    private findReviewsByProduct;
-    private findReview;
-    private getReviewByPersonId;
-    private getReviewByAuthorAndEmail;
-    private bindReviewToModel;
-    private bindReviewToHasura;
-    productVariantFullReport(): Promise<ProductVariantReport[]>;
-}
-export {};

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

@@ -1,7 +0,0 @@
-import { ProductPriceLog, ProductPriceLogRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-declare const ProductPriceLogHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductPriceLog> & import("../../../../domain").CrudRepository<ProductPriceLog, import("../../../../domain").CrudParams<ProductPriceLog>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductPriceLog>, [HasuraConstructorParams<ProductPriceLog> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductPriceLogHasuraGraphQLRepository extends ProductPriceLogHasuraGraphQLRepository_base implements ProductPriceLogRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductPriceLog>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-}
-export {};

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

@@ -1,11 +0,0 @@
-import { ProductReview } from '../../../../domain';
-import { ProductReviewRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-declare const ProductReviewHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductReview> & import("../../../../domain").CrudRepository<ProductReview, import("../../../../domain").CrudParams<ProductReview>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductReview>, [HasuraConstructorParams<ProductReview> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductReviewHasuraGraphQLRepository extends ProductReviewHasuraGraphQLRepository_base implements ProductReviewRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductReview>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    updateManyStatus(reviews: Pick<ProductReview, 'id' | 'status'>[]): Promise<void>;
-    aproveReview(id: number): Promise<ProductReview>;
-    disaproveReview(id: number): Promise<ProductReview>;
-}
-export {};

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

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

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

@@ -1,22 +0,0 @@
-import { Filter, ProductStockNotification, ReportStockNotification, ReportStockNotificationInput, RepositoryFindResult, Shops } from '../../../../domain';
-import { ProductStockNotificationRepository } from '../../../../domain/catalog/repositories';
-import { HasuraConstructorParams } from '../../mixins';
-type AddCustomerEmailParams = {
-    shop: Shops;
-    productId: string;
-    name: string;
-    email: string;
-};
-declare const ProductStockNotificationHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductStockNotification> & import("../../../../domain").CrudRepository<ProductStockNotification, import("../../../../domain").CrudParams<ProductStockNotification>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<ProductStockNotification>, [HasuraConstructorParams<ProductStockNotification> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class ProductStockNotificationHasuraGraphQLRepository extends ProductStockNotificationHasuraGraphQLRepository_base implements ProductStockNotificationRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    addCustomerEmail(params: AddCustomerEmailParams): Promise<void>;
-    getNotificationsReport(params: ReportStockNotificationInput, orderBy: {
-        field: string;
-        direction: string;
-    }, pagination?: {
-        offset: number;
-        limit: number;
-    }): Promise<RepositoryFindResult<ReportStockNotification>>;
-}
-export {};

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

@@ -1,14 +0,0 @@
-import { FindRepositoryParams, GetRepositoryParams, RepositoryFindResult, UpdateRepositoryParams, VariantRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { VariantHasuraGraphQL } from '../../models';
-declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<VariantHasuraGraphQL> & import("../../../../domain").CrudRepository<VariantHasuraGraphQL, import("../../../../domain").CrudParams<VariantHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<VariantHasuraGraphQL>, [HasuraConstructorParams<VariantHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class VariantHasuraGraphQLRepository extends VariantHasuraGraphQLRepository_base implements VariantRepository {
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
-    get(identifiers: GetRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
-    find(params?: FindRepositoryParams<VariantHasuraGraphQL>): Promise<RepositoryFindResult<VariantHasuraGraphQL>>;
-    getByEAN(EAN: string): Promise<VariantHasuraGraphQL>;
-    update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;
-    private updateMetadata;
-    private getId;
-}
-export {};

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

@@ -1,30 +0,0 @@
-import { Category, CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, Product, RepositoryFindResult, Shops, UpdateRepositoryParams, Wishlist, WishlistRepository } from '../../../../domain';
-import { HasuraConstructorParams } from '../../mixins';
-import { WishlistHasuraGraphQL } from '../../models/wishlist-hasura-graphql';
-import { CategoryProductHasuraGraphQLRepository } from './category-product-hasura-graphql.repository';
-declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../../types").GraphQLRepository<WishlistHasuraGraphQL> & import("../../../../domain").CrudRepository<WishlistHasuraGraphQL, import("../../../../domain").CrudParams<WishlistHasuraGraphQL>> & import("../../mixins").UpdateHasuraGraphQLRepositoryType<WishlistHasuraGraphQL>, [HasuraConstructorParams<WishlistHasuraGraphQL> & import("../../mixins/factories").CreateConstructorParams & import("../../mixins/factories").DeleteConstructorParams & import("../../mixins/factories").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
-export declare class WishlistHasuraGraphQLRepository extends WishlistHasuraGraphQLRepository_base implements WishlistRepository {
-    private readonly categoryProductRepository;
-    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>, categoryProductRepository: CategoryProductHasuraGraphQLRepository);
-    create(params: CreateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
-    find(params?: FindRepositoryParams<WishlistHasuraGraphQL>): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
-    update(params: UpdateRepositoryParams<WishlistHasuraGraphQL>): Promise<WishlistHasuraGraphQL>;
-    getWishlistBySlug(slug: string): Promise<WishlistHasuraGraphQL>;
-    getWishlistByPerson(personId: string): Promise<WishlistHasuraGraphQL[]>;
-    getCategoryBySlug(slug: string, _shop: Shops): Promise<Wishlist>;
-    getCategoryByShop(shop: string): Promise<any>;
-    findBfluOrGlamgirlWishlists(params: FindRepositoryParams<WishlistHasuraGraphQL>, shops: Shops[]): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
-    getCategoriesForHome(): Promise<{
-        category: Category;
-        products: Product[];
-    }[]>;
-    mountCategory(): Promise<Product[]>;
-    getChildren(_parentId: number): Promise<Category[]>;
-    isChild(_id: number, _parentId: number): Promise<boolean>;
-    private updateMetadata;
-    addProduct(wishlistId: string, productId: string): Promise<void>;
-    removeProduct(wishlistId: string, productId: string): Promise<void>;
-    getBrandsWithProducts(): Promise<Category[]>;
-}
-export {};

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

@@ -1 +0,0 @@
-export * from './catalog';

package/src/infra/hasura-graphql/types/fields.type.d.ts

@@ -1,2 +0,0 @@
-import { NestedField } from './nested-field.type';
-export type Fields = Array<string | object | NestedField | 'aggregate' | 'nodes'>;

package/src/infra/hasura-graphql/types/graphql.repository.type.d.ts

@@ -1,25 +0,0 @@
-import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
-import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../domain';
-import { DebugHelper } from '../../../utils';
-import { HasuraGraphQLAuthOptions } from './hasura-graphql-auth-options.type';
-import { HasuraGraphQLFields } from './hasura-graphql-fields.type';
-import { VariableOptions } from './variable-options.type';
-export type GraphQLParams<Model extends ModelBaseStructure<Model>> = {
-    operation: string | IOperation;
-    fields?: HasuraGraphQLFields<Model>;
-    variables?: VariableOptions;
-};
-export type GraphQLRepository<Model extends ModelBaseStructure<Model>> = {
-    tableName: string;
-    model: BaseModelBuilder<Model>;
-    fields: HasuraGraphQLFields<Model>;
-    endpoint: string;
-    authOptions: HasuraGraphQLAuthOptions;
-    logger: DebugHelper;
-    cache?: CacheConfig;
-    mutation: <ReturnFields = any>(operation: string | IOperation, fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
-    query: <ReturnFields = any>(operation: string | IOperation | GraphQLParams<Model>[], fields?: string[] | HasuraGraphQLFields<Model>, variables?: VariableOptions) => Promise<ReturnFields>;
-    getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
-    convertDataFromHasura(data: Record<string, string | number>, fields?: string[] | HasuraGraphQLFields<Model>): Model;
-    convertDataToHasura(instance: Model, update?: boolean): Record<string, string | number>;
-};

package/src/infra/hasura-graphql/types/hasura-graphql-auth-options.type.d.ts

@@ -1,8 +0,0 @@
-export type HasuraGraphQLAuthOptions = {
-    adminSecret?: string;
-    authRole?: {
-        role: string;
-        userId: string;
-    };
-    authToken?: string;
-};

package/src/infra/hasura-graphql/types/hasura-graphql-fields.type.d.ts

@@ -1,44 +0,0 @@
-import { ModelBaseStructure, NestedRepositoryFindFieltersOptions, NonFunctionAndIdentifierPropertyNames, RepositoryFindField } from '../../../domain';
-import { PropType } from '../../../utils';
-import { HasuraGraphQLColumnType } from '../enums';
-export type ColumnOptions<FieldType, Model, ValueFrom = any> = {
-    type?: HasuraGraphQLColumnType;
-    columnName?: string;
-    filters?: {
-        filterType: HasuraGraphQLColumnType | string;
-        filters: NestedRepositoryFindFieltersOptions<FieldType>;
-    };
-    fields?: HasuraGraphQLFields<FieldType>;
-    foreignKeyColumn?: Partial<Record<NonFunctionAndIdentifierPropertyNames<FieldType extends any[] ? FieldType[number] : FieldType>, NonFunctionAndIdentifierPropertyNames<Model> | (string & {})>> | {};
-    from?: (value: ValueFrom | ValueFrom[], data?: any) => FieldType;
-    to?: (value: FieldType, instance?: Model) => ValueFrom;
-    bindFindFilter?: (sentence: RepositoryFindField<Model, keyof Model>) => Record<string, RepositoryFindField<any, any> | ValueFrom> | RepositoryFindField<any, any> | ValueFrom;
-    bindPersistData?: (value: FieldType, instance?: Model) => Record<string, ValueFrom>;
-};
-export type AggregateOptionNames = 'avg' | 'count' | 'max' | 'min' | 'stddev' | 'stddev_pop' | 'stddev_samp' | 'sum' | 'var_pop' | 'var_samp' | 'variance';
-export type AggregateOptionFields<Model, Type, Properties extends keyof Model = keyof Model> = {
-    [K in Properties]: PropType<Model, K> extends Type ? K : never;
-}[Properties] | string;
-export type AggregateOptions<Model> = {
-    avg?: Array<AggregateOptionFields<Model, number>>;
-    max?: Array<AggregateOptionFields<Model, number | Date>>;
-    min?: Array<AggregateOptionFields<Model, number | Date>>;
-    stddev?: Array<AggregateOptionFields<Model, number>>;
-    stddev_pop?: Array<AggregateOptionFields<Model, number>>;
-    stddev_samp?: Array<AggregateOptionFields<Model, number>>;
-    sum?: Array<AggregateOptionFields<Model, number>>;
-    var_pop?: Array<AggregateOptionFields<Model, number>>;
-    var_samp?: Array<AggregateOptionFields<Model, number>>;
-    variance?: Array<AggregateOptionFields<Model, number>>;
-};
-type ModelBaseHasuraGraphQLFields<Model> = Model extends ModelBaseStructure ? NonFunctionAndIdentifierPropertyNames<Model> | {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: PropType<Model, key> extends ModelBaseStructure ? HasuraGraphQLFields<PropType<Model, key>> : PropType<Model, key> extends any[] ? PropType<Model, key>[] extends ModelBaseStructure[] ? HasuraGraphQLFields<PropType<Model, key>[]> : never : never;
-} | {
-    [key in NonFunctionAndIdentifierPropertyNames<Model>]?: key extends 'aggregate' ? never : PropType<Model, key> extends ModelBaseStructure ? ColumnOptions<PropType<Model, key>, Model> : ColumnOptions<PropType<Model, key>, Model>;
-} | Record<string, ColumnOptions<PropType<Model, any>, Model>> : string;
-export type HasuraGraphQLFields<Model> = (ModelBaseHasuraGraphQLFields<Model> | {
-    aggregate: Array<AggregateOptions<Model> | 'count'>;
-} | {
-    returning: NonFunctionAndIdentifierPropertyNames<Model>[];
-} | 'affected_rows')[];
-export {};

package/src/infra/hasura-graphql/types/hasura-graphql-headers.type.d.ts

@@ -1,7 +0,0 @@
-export type HasuraGraphQLHeaders = {
-    Authorization?: string;
-    'Content-Type': string;
-    'X-Hasura-Admin-Secret'?: string;
-    'X-Hasura-Role'?: string;
-    'X-Hasura-User-Id'?: string;
-};

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

@@ -1,8 +0,0 @@
-export * from './fields.type';
-export * from './graphql.repository.type';
-export * from './nested-field.type';
-export * from './query-builder-options.type';
-export * from './variable-options.type';
-export * from './hasura-graphql-auth-options.type';
-export * from './hasura-graphql-fields.type';
-export * from './hasura-graphql-headers.type';

package/src/infra/hasura-graphql/types/nested-field.type.d.ts

@@ -1,7 +0,0 @@
-import { Fields } from './fields.type';
-import { QueryBuilderOptions } from './query-builder-options.type';
-export type NestedField = {
-    operation: string;
-    variables: QueryBuilderOptions[];
-    fields: Fields;
-};