@infrab4a/connect 4.29.0 → 4.29.1-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "4.29.0",
+  "version": "4.29.1-alpha.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -18,7 +18,7 @@
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
     "serialize-javascript": "^6.0.2",
-    "ts-custom-error": "3.2.2",
+    "ts-custom-error": "^3.3.1",
     "ts-md5": "^1.2.9",
     "tslib": "^2.4.0"
   },

package/src/domain/catalog/repositories/category.repository.d.ts

@@ -3,6 +3,25 @@ import { RepositoryCacheOptions } from '../../generic/repository/types';
 import { Product } from '../models';
 import { Category } from '../models/category';
 import { Shops } from '../models/enums/shops.enum';
+type CategoriesForHomeParams = {
+    categoryIds: string[];
+    shop: Shops;
+    limit?: number;
+    optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    };
+};
+type MountCategoryParams = {
+    category: Category;
+    shop: Shops;
+    options?: {
+        limit?: number;
+        hasStock?: boolean;
+    };
+    optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    };
+};
 export interface CategoryRepository<T extends Category = Category> extends CrudRepository<T> {
     getCategoryBySlug(slug: string, shop: Shops, optionsCache?: {
         cache?: RepositoryCacheOptions;
@@ -10,20 +29,14 @@ export interface CategoryRepository<T extends Category = Category> extends CrudR
     getCategoryByShop(shop: string, optionsCache?: {
         cache?: RepositoryCacheOptions;
     }): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<{
+    getCategoriesForHome(params: CategoriesForHomeParams): Promise<{
         category: Category;
         products: Product[];
     }[]>;
-    mountCategory(category: Category, shop: Shops, options?: {
-        limit?: number;
-        hasStock?: boolean;
-    }, optionsCache?: {
-        cache?: RepositoryCacheOptions;
-    }): Promise<Product[]>;
+    mountCategory(params: MountCategoryParams): Promise<Product[]>;
     getChildren(parentId: number, optionsCache?: {
         cache?: RepositoryCacheOptions;
     }): Promise<Category[]>;
     isChild(id: number, parentId: number): Promise<boolean>;
 }
+export {};

package/src/domain/catalog/repositories/filter-option.repository.d.ts

@@ -1,4 +1,4 @@
 import { CrudRepository } from '../../generic/repository/crud.repository';
-import { FilterOption } from "../models";
+import { FilterOption } from '../models';
 export interface FilterOptionRepository extends CrudRepository<FilterOption> {
 }

package/src/domain/catalog/repositories/filter.repository.d.ts

@@ -1,4 +1,4 @@
 import { CrudRepository } from '../../generic/repository/crud.repository';
-import { Filter } from "../models";
+import { Filter } from '../models';
 export interface FilterRepository extends CrudRepository<Filter> {
 }

package/src/domain/catalog/repositories/product-stock-notification.repository.d.ts

@@ -1,8 +1,14 @@
 import { RepositoryFindResult } from '../../generic';
 import { CrudRepository } from '../../generic/repository/crud.repository';
 import { ProductStockNotification, ReportStockNotification, ReportStockNotificationInput, Shops } from '../models';
+type AddCustomerEmailParams = {
+    shop: Shops;
+    productId: string;
+    name: string;
+    email: string;
+};
 export interface ProductStockNotificationRepository extends CrudRepository<ProductStockNotification> {
-    addCustomerEmail(shop: Shops, productId: string, name: string, email: string): Promise<void>;
+    addCustomerEmail(params: AddCustomerEmailParams): Promise<void>;
     getNotificationsReport(params: ReportStockNotificationInput, orderBy: {
         field: string;
         direction: string;
@@ -11,3 +17,4 @@ export interface ProductStockNotificationRepository extends CrudRepository<Produ
         limit: number;
     }): Promise<RepositoryFindResult<ReportStockNotification>>;
 }
+export {};

package/src/domain/catalog/repositories/wishlist.repository.d.ts

@@ -1,7 +1,7 @@
-import { CategoryRepository } from '.';
 import { FindRepositoryParams, RepositoryFindResult } from '../../generic';
 import { Shops } from '../models';
 import { Wishlist } from '../models/wishlist';
+import { CategoryRepository } from '.';
 export interface WishlistRepository extends CategoryRepository<Wishlist> {
     getWishlistBySlug(slug: string): Promise<Wishlist>;
     getWishlistByPerson(personId: string): Promise<Wishlist[]>;

package/src/domain/shopping/models/campaign-dashboard.d.ts

@@ -1,4 +1,4 @@
-import { BaseModel, GenericIdentifier } from "../../generic";
+import { BaseModel, GenericIdentifier } from '../../generic';
 export declare class CampaignDashboard extends BaseModel<CampaignDashboard> {
     id: string;
     status: string;

package/src/domain/shopping/models/campaign-hashtag.d.ts

@@ -1,4 +1,4 @@
-import { BaseModel, GenericIdentifier } from "../../generic";
+import { BaseModel, GenericIdentifier } from '../../generic';
 export declare class CampaignHashtag extends BaseModel<CampaignHashtag> {
     id: string;
     status?: string;

package/src/domain/shopping/repositories/order-blocked.repository.d.ts

@@ -1,6 +1,14 @@
 import { CrudRepository } from '../../generic/repository/crud.repository';
 import { Checkout, OrderBlocked } from '../models';
 import { PaymentCardInfo } from '../types';
+type CreateBlockedOrderParams = {
+    checkout: Checkout;
+    blockType: string;
+    type: string;
+    limiteRange: string;
+    card?: PaymentCardInfo;
+};
 export interface OrderBlockedRepository extends CrudRepository<OrderBlocked> {
-    createBlockedOrderOrPayment(checkout: Checkout, blockType: string, type: string, limiteRange: string, card?: PaymentCardInfo): Promise<OrderBlocked>;
+    createBlockedOrderOrPayment(params: CreateBlockedOrderParams): Promise<OrderBlocked>;
 }
+export {};

package/src/domain/shopping/services/antifraud-card.service.d.ts

@@ -10,8 +10,25 @@ export declare class AntifraudCardService implements AntifraudProvider {
     private LIMIT_BLOCKED_ORDERS_DAY;
     constructor(orderRepository: OrderRepository, orderBlockedRepository: OrderBlockedRepository);
     validate(checkout: Checkout, card: PaymentCardInfo): Promise<Boolean>;
+    private validateBlockedOrderAttempts;
+    private validateDayAndWeekOrderLimits;
     private verifyBlockedOrderAttempts;
+    private getTodayDateRange;
+    private getBlockedOrdersByMultipleCriteria;
+    private getBlockedOrdersByCpf;
+    private getBlockedOrdersByEmail;
+    private getBlockedOrdersByZip;
+    private getBlockedOrdersByPhone;
+    private calculateUniqueBlockedAttempts;
+    private filterUniqueEmailBlocked;
+    private filterUniqueZipBlocked;
+    private filterUniquePhoneBlocked;
+    private createBlockedOrderRecord;
     private verifyDayAndWeekOrders;
+    private buildValidationParams;
+    private validateDayOrderLimits;
+    private validateWeekOrderLimits;
+    private checkOrderLimitsAndBlock;
     private validateOrdersByRange;
     private countOrdersByField;
     private getDateRange;

package/src/domain/shopping/services/antifraud-glampoints.service.d.ts

@@ -2,5 +2,5 @@ import { AntifraudProvider } from '../interfaces';
 import { Checkout } from '../models';
 export declare class AntifraudGlampointsService implements AntifraudProvider {
     constructor();
-    validate(checkout: Checkout): Promise<Boolean>;
+    validate(_checkout: Checkout): Promise<Boolean>;
 }

package/src/domain/shopping/services/antifraud-pix.service.d.ts

@@ -2,5 +2,5 @@ import { AntifraudProvider } from '../interfaces';
 import { Checkout } from '../models';
 export declare class AntifraudPixService implements AntifraudProvider {
     constructor();
-    validate(checkout: Checkout): Promise<Boolean>;
+    validate(_checkout: Checkout): Promise<boolean>;
 }

package/src/infra/adyen/adapters/adyen-card-payment-axios.adapter.d.ts

@@ -8,10 +8,12 @@ export declare class AdyenCardAxiosAdapter implements PaymentProviderCard<AdyenC
     private paymentRepository;
     private orderBlockedRepository;
     constructor(credentials: AdyenCredentials, paymentRepository: PaymentRepository, orderBlockedRepository: OrderBlockedRepository);
-    createCardHash(bu: BusinessUnitEnum): Promise<string>;
+    createCardHash(_bu: BusinessUnitEnum): Promise<string>;
     pay(checkout: Checkout, card: PaymentCardInfo): Promise<Payment>;
-    private createCardPayment;
+    private executeAdyenPayment;
+    private handleUnauthorizedPayment;
+    private createSuccessfulPayment;
     addCard(): Promise<AdyenCard>;
-    getCardByToken(token: string): Promise<AdyenCard>;
-    createTransaction(info: any): Promise<PaymentTransaction>;
+    getCardByToken(_token: string): Promise<AdyenCard>;
+    createTransaction(_info: any): Promise<PaymentTransaction>;
 }

package/src/infra/adyen/helpers/adyen-blocked-order.helper.d.ts

@@ -0,0 +1,13 @@
+import { Checkout } from '../../../domain/shopping/models';
+import { OrderBlockedRepository } from '../../../domain/shopping/repositories';
+import { PaymentCardInfo } from '../../../domain/shopping/types';
+import { PaymentError } from '../../../errors';
+export declare class AdyenBlockedOrderHelper {
+    static handleUnauthorizedPayment(params: {
+        checkout: Checkout;
+        card: PaymentCardInfo;
+        orderBlockedRepository: OrderBlockedRepository;
+        adyenResponse: any;
+    }): Promise<never>;
+    static createPaymentError(checkout: Checkout, errorInfo: any): PaymentError;
+}

package/src/infra/adyen/helpers/adyen-payment-factory.helper.d.ts

@@ -0,0 +1,6 @@
+import { Checkout, Payment } from '../../../domain/shopping/models';
+import { PaymentRepository } from '../../../domain/shopping/repositories';
+import { AdyenPaymentResponse } from './adyen-payment-operations.helper';
+export declare class AdyenPaymentFactoryHelper {
+    static createPaymentFromAdyenResponse(checkout: Checkout, adyenResponse: AdyenPaymentResponse, paymentRepository: PaymentRepository): Promise<Payment>;
+}

package/src/infra/adyen/helpers/adyen-payment-operations.helper.d.ts

@@ -0,0 +1,31 @@
+import { AxiosResponse } from 'axios';
+import { Checkout } from '../../../domain/shopping/models';
+import { AdyenCredentials, PaymentCardInfo } from '../../../domain/shopping/types';
+export interface AdyenPaymentRequest {
+    amount: {
+        currency: string;
+        value: number;
+    };
+    paymentMethod: {
+        type: string;
+        storedPaymentMethodId: string;
+    };
+    reference: string;
+    shopperInteraction: string;
+    merchantAccount: string;
+    shopperReference: string;
+    recurringProcessingModel: string;
+    returnUrl: string;
+    installments: {
+        value: number;
+    };
+}
+export interface AdyenPaymentResponse {
+    resultCode: 'Authorised' | 'Refused' | 'Error' | string;
+    [key: string]: any;
+}
+export declare class AdyenPaymentOperationsHelper {
+    static buildPaymentRequest(checkout: Checkout, card: PaymentCardInfo, credentials: AdyenCredentials): AdyenPaymentRequest;
+    static executePaymentRequest(paymentRequest: AdyenPaymentRequest, credentials: AdyenCredentials): Promise<AxiosResponse<AdyenPaymentResponse>>;
+    static isPaymentAuthorised(response: AdyenPaymentResponse): boolean;
+}

package/src/infra/adyen/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './adyen-blocked-order.helper';
+export * from './adyen-payment-factory.helper';
+export * from './adyen-payment-operations.helper';

package/src/infra/elasticsearch/helpers/elasticsearch-fields.helper.d.ts

@@ -0,0 +1,8 @@
+export declare class ElasticSearchFieldsHelper {
+    static getProductSearchFields(total: number): string[];
+    static getProductSearchFilters(): Array<{
+        term: {
+            [key: string]: string | boolean | number;
+        };
+    }>;
+}

package/src/infra/elasticsearch/helpers/elasticsearch-query-builder.helper.d.ts

@@ -0,0 +1,16 @@
+export interface ElasticSearchQuery {
+    should: any[];
+    filter: Array<{
+        term: {
+            [key: string]: string | boolean | number;
+        };
+    }>;
+}
+export declare class ElasticSearchQueryBuilderHelper {
+    static buildProductSearchQuery(searchTerm: string, filters: Array<{
+        term: {
+            [key: string]: string | boolean | number;
+        };
+    }>): ElasticSearchQuery;
+    private static addComplementarySearchRules;
+}

package/src/infra/elasticsearch/helpers/elasticsearch-result-processor.helper.d.ts

@@ -0,0 +1,8 @@
+import { Product } from '../../../domain';
+import { ElasticSearchResult } from '../types';
+export declare class ElasticSearchResultProcessorHelper {
+    static processProductSearchResults(search: ElasticSearchResult<Product>): any[];
+    private static filterValidHits;
+    private static applyPriceRounding;
+    private static transformHitsToProducts;
+}

package/src/infra/elasticsearch/helpers/elasticsearch-search-operations.helper.d.ts

@@ -0,0 +1,11 @@
+import { Product } from '../../../domain';
+import { ElasticSearchAdapter } from '../adapters';
+export interface ProductSearchParams {
+    searchTerm: string;
+    total: number;
+    shop?: string;
+}
+export declare class ElasticSearchOperationsHelper {
+    static executeProductSearch(params: ProductSearchParams, adapter: ElasticSearchAdapter<Product>, index: string): Promise<any[]>;
+    private static performSearch;
+}

package/src/infra/elasticsearch/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './elasticsearch-fields.helper';
+export * from './elasticsearch-query-builder.helper';
+export * from './elasticsearch-result-processor.helper';
+export * from './elasticsearch-search-operations.helper';

package/src/infra/elasticsearch/indexes/products-index.d.ts

@@ -6,45 +6,7 @@ export declare class ProductsIndex {
     private index;
     constructor(adapter: ElasticSearchAdapter<Product>);
     getById(id: string): Promise<Product>;
-    search(searchTerm: string, total: number, shop?: string): Promise<{
-        stock: number;
-        hasVariants: boolean;
-        variants?: import("../../../domain").Variant[];
-        id: string;
-        name: string;
-        slug: string;
-        description: import("../../../domain").ShopDescription;
-        sku: string;
-        price: import("../../../domain").ShopPrice;
-        NCM: string;
-        EAN: string;
-        CEST: string;
-        weight: number;
-        costPrice: number;
-        images?: string[];
-        miniatures?: string[];
-        published: boolean;
-        createdAt?: Date;
-        updatedAt?: Date;
-        brand: string;
-        tags?: string[];
-        filters?: string[];
-        type?: string;
-        categories?: string[];
-        video?: string;
-        isKit?: boolean;
-        rate?: number;
-        gender?: import("../../../domain").ProductGender;
-        shoppingCount?: number;
-        metadata: import("../../../domain").ProductMetadata;
-        outlet?: boolean;
-        label?: "outlet" | "on-sale" | "last-units" | "glamstar";
-        group?: number;
-        validity: boolean;
-        category: import("../../../domain").Category;
-        kitProducts?: import("../../../domain").KitProduct[];
-        reviews?: import("../../../domain").ProductReview[];
-    }[]>;
+    search(searchTerm: string, total: number, shop?: string): Promise<any[]>;
     save(product: ProductHasuraGraphQL): Promise<void>;
     update(product: ProductHasuraGraphQL): Promise<void>;
     delete(id: string): Promise<void>;

package/src/infra/firebase/firestore/mixins/helpers/firestore-cache.helper.d.ts

@@ -0,0 +1,41 @@
+import { BaseModelBuilder, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain';
+type CacheConfig = {
+    cacheAdapter?: any;
+    ttlDefault?: number;
+};
+type CacheGetParams<TBase extends ModelBaseStructure<TBase>> = {
+    model: BaseModelBuilder<TBase>;
+    identifiers: any;
+    options?: {
+        cache?: RepositoryCacheOptions;
+    };
+    logger: any;
+    req: any;
+};
+type CacheSaveParams = {
+    cacheKey: string;
+    data: any;
+    expirationInSeconds?: number;
+    logger: any;
+    req?: any;
+};
+type CacheRemoveParams = {
+    cacheKey: string;
+    logger: any;
+};
+export declare class FirestoreCacheHelper {
+    static getCachedData<TBase extends ModelBaseStructure<TBase>>(cache: CacheConfig | undefined, params: CacheGetParams<TBase>): Promise<any | null>;
+    static getCachedFindData<TBase extends ModelBaseStructure<TBase>>(cache: CacheConfig | undefined, params: {
+        model: BaseModelBuilder<TBase>;
+        find: any;
+        options?: {
+            cache?: RepositoryCacheOptions;
+        };
+        logger: any;
+    }): Promise<any | null>;
+    static saveCacheData(cache: CacheConfig | undefined, params: CacheSaveParams): Promise<void>;
+    static removeCacheData(cache: CacheConfig | undefined, params: CacheRemoveParams): Promise<void>;
+    static generateGetCacheKey<TBase extends ModelBaseStructure<TBase>>(model: BaseModelBuilder<TBase>, identifiers: any): string;
+    static generateFindCacheKey<TBase extends ModelBaseStructure<TBase>>(model: BaseModelBuilder<TBase>, findParams: any): string;
+}
+export {};

package/src/infra/firebase/firestore/mixins/helpers/firestore-data-converter.helper.d.ts

@@ -0,0 +1,7 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoPartial } from '../../../../../domain';
+export declare class FirestoreDataConverterHelper {
+    static isValidObjectForDateBinding(data: any): boolean;
+    static convertToDate(data: any, keyName: string): any;
+    static processArrayData(arrayData: any[]): any[];
+    static bindAllDateFromObject<TBase extends ModelBaseStructure<TBase> = any>(data: Record<string, any>): NonFunctionAndIdentifierPropertiesWithNoPartial<TBase>;
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-model-converter.helper.d.ts

@@ -0,0 +1,14 @@
+import { BaseModelBuilder, ModelBaseStructure } from '../../../../../domain';
+import { ConnectDocumentData, ConnectDocumentSnapshot } from '../../types';
+export declare class FirestoreModelConverterHelper<TBase extends ModelBaseStructure<TBase>> {
+    private model;
+    constructor(model: BaseModelBuilder<TBase>);
+    static omitByRecursivelyInPlace(value: any, iteratee: (value: any, key: string) => boolean): any;
+    buildToFirestoreConverter(): (data: TBase) => ConnectDocumentData<TBase>;
+    buildFromFirestoreConverter(): (snap: ConnectDocumentSnapshot<TBase>) => TBase;
+    private handleConversionError;
+    getConverters(): {
+        toFirestore: (data: TBase) => ConnectDocumentData<TBase>;
+        fromFirestore: (snap: ConnectDocumentSnapshot<TBase>) => TBase;
+    };
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-operations.helper.d.ts

@@ -0,0 +1,24 @@
+import { BaseModelBuilder, ModelBaseStructure } from '../../../../../domain';
+export declare class FirestoreOperationsHelper<TBase extends ModelBaseStructure<TBase>> {
+    private model;
+    constructor(model: BaseModelBuilder<TBase>);
+    buildInstanceFromIdentifiers(identifiers: any): TBase;
+    validateDocumentExists(docRef: any, collectionName: string, identifiers: any): Promise<void>;
+    validateDocumentData(data: any, collectionName: string, identifiers: any): void;
+    getDocumentSnapshot(collection: any, instance: TBase): Promise<any>;
+    executeDelete(collection: any, instance: TBase): Promise<void>;
+    calculateCount<T>(data: T[], limits?: {
+        limit?: number;
+    }): number;
+    handleError(error: unknown, logger: any, req: any): void;
+    buildCollectionPath(params: {
+        isSubCollection: boolean;
+        collectionName: string;
+        parentRepository?: {
+            collectionName: string;
+        };
+        parentIdField?: string;
+        identifiers?: any;
+    }): string;
+    getKeyField(): string;
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-query-builder.helper.d.ts

@@ -0,0 +1,37 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryLimitOptions, RepositoryOrderBy } from '../../../../../domain';
+import { FirestoreFieldType } from '../../enums';
+import { ConnectCollectionReference } from '../../services';
+import { ConnectDocumentSnapshot, ConnectWhereOption } from '../../types';
+export declare class FirestoreQueryBuilderHelper<TBase extends ModelBaseStructure<TBase>> {
+    private config;
+    constructor(config: {
+        model: any;
+        fields?: Partial<Record<NonFunctionAndIdentifierPropertyNames<TBase>, FirestoreFieldType>>;
+        isSubCollection?: (instance: any) => boolean;
+        parentIdField?: string;
+    });
+    buildWhereSentence(fieldName: NonFunctionPropertyNames<TBase> | string, options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>): [string, ConnectWhereOption, any][];
+    private getFirestoreFieldName;
+    private buildWhereConditions;
+    private buildLikeConditions;
+    private buildInConditions;
+    private buildNestedObjectConditions;
+    private isArrayField;
+    private isNestedObjectFilter;
+    buildOrderBy(filters: RepositoryFindFielters<TBase>, fieldsToOrderBy?: RepositoryOrderBy<TBase>): [string, 'asc' | 'desc'][];
+    private addMissingOrderFields;
+    private convertToOrderByArray;
+    buildLimits(params: {
+        filters: RepositoryFindFielters<TBase>;
+        limits: RepositoryLimitOptions<TBase>;
+        collection: (path: string) => ConnectCollectionReference<TBase>;
+        buildCollectionPath: (filters: RepositoryFindFielters<TBase>) => string;
+    }): Promise<['fromStartAfter' | 'fromStartAt' | 'limit', string | number | ConnectDocumentSnapshot<TBase>][]>;
+    private addOffsetQuery;
+    buildQuery(params: {
+        collection: ConnectCollectionReference<TBase>;
+        queries: [string, ConnectWhereOption, any][];
+        ordination: [string, 'asc' | 'desc'][];
+        offsets: ['fromStartAfter' | 'fromStartAt' | 'limit', string | number | ConnectDocumentSnapshot<TBase>][];
+    }): ConnectCollectionReference<TBase>;
+}

package/src/infra/firebase/firestore/mixins/helpers/index.d.ts

@@ -1 +1,4 @@
 export * from './cache-key-generator.helper';
+export * from './firestore-cache.helper';
+export * from './firestore-operations.helper';
+export * from './firestore-query-builder.helper';

package/src/infra/firebase/firestore/mixins/with-sub-collection.mixin.d.ts

@@ -5,7 +5,7 @@ import { FirestoreConstructorParams } from './with-firestore.mixin';
 export type FirestoreSubCollectionConstructorParams<TBase extends ModelBaseStructure> = {
     parentIdField: keyof IdentifiersModel<TBase>;
 };
-export declare const withSubCollection: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TBaseParent extends ModelBaseStructure<TBaseParent, TBaseParent["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase>, any[]> & TMixinBase, ParentModel: new () => TBaseParent) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & {
+export declare const withSubCollection: <TBase extends ModelBaseStructure<TBase, TBase["identifiersFields"][number]>, TBaseParent extends ModelBaseStructure<TBaseParent, TBaseParent["identifiersFields"][number]>, TMixinBase extends MixinCtor<FirestoreRepository<TBase>, any[]>>(MixinBase: MixinCtor<FirestoreRepository<TBase>, any[]> & TMixinBase, _ParentModel: new () => TBaseParent) => MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & {
     readonly parentRepository: FirestoreRepository<TBaseParent>;
     parentIdField: Extract<import("../../../../domain").NonFunctionAndIdentifierPropertyNames<TBase>, import("../../../../utils").PropType<TBase, "identifiersFields">[number]>;
 } & FirestoreHelpers, MergeConstructorParams<[FirestoreConstructorParams<TBase> & FirestoreSubCollectionConstructorParams<TBase>, ...any[]], ConstructorParameters<TMixinBase>>>;

package/src/infra/firebase/firestore/repositories/catalog/category-firestore.repository.d.ts

@@ -1,20 +1,32 @@
 import { Category, CategoryRepository, Product, Shops } from '../../../../../domain';
 import { FirestoreConstructorParams } from '../../mixins';
+type CategoriesForHomeParams = {
+    categoryIds: string[];
+    shop: Shops;
+    limit?: number;
+    optionsCache?: any;
+};
+type MountCategoryParams = {
+    category: Category;
+    shop: Shops;
+    options?: {
+        limit?: number;
+        hasStock?: boolean;
+        gender?: string;
+    };
+    optionsCache?: any;
+};
 declare const CategoryFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("../../types").FirestoreRepository<Category> & import("../../../../../domain").CrudRepository<Category, import("../../../../../domain").CrudParams<Category>> & import("../../types").FirestoreHelpers, [FirestoreConstructorParams<Category>, ...any[]]>;
 export declare class CategoryFirestoreRepository extends CategoryFirestoreRepository_base implements CategoryRepository {
     constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<Category>, 'firestore' | 'interceptors'>);
     getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
-    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number): Promise<{
+    getCategoriesForHome(params: CategoriesForHomeParams): Promise<{
         category: Category;
         products: Product[];
     }[]>;
-    mountCategory(category: Category, shop: Shops, options?: {
-        limit?: number;
-        hasStock?: boolean;
-        gender?: string;
-    }): Promise<Product[]>;
-    getCategoryByShop(shop: string): Promise<Category[]>;
-    getChildren(parentId: number): Promise<Category[]>;
-    isChild(id: number, parentId: number): Promise<boolean>;
+    mountCategory(params: MountCategoryParams): Promise<Product[]>;
+    getCategoryByShop(_shop: string): Promise<Category[]>;
+    getChildren(_parentId: number): Promise<Category[]>;
+    isChild(_id: number, _parentId: number): Promise<boolean>;
 }
 export {};

package/src/infra/firebase/firestore/repositories/catalog/product-firestore.repository.d.ts

@@ -4,7 +4,7 @@ declare const ProductFirestoreRepository_base: import("../../../../../utils").Mi
 export declare class ProductFirestoreRepository extends ProductFirestoreRepository_base implements ProductRepository {
     private reviews;
     constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<Product>, 'firestore' | 'interceptors'>);
-    fetchProductReviews(filters: PaginatedReviewFilters): Promise<ReviewWithProductData[]>;
+    fetchProductReviews(_filters: PaginatedReviewFilters): Promise<ReviewWithProductData[]>;
     getBySlug(slug: string): Promise<Product>;
     fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
     cleanShoppingCountFromIds(): Promise<void>;

package/src/infra/firebase/firestore/repositories/shopping/order-blocked-firestore.repository.d.ts

@@ -1,9 +1,16 @@
 import { Checkout, OrderBlocked, OrderBlockedRepository, OrderBlockedType, PaymentCardInfo } from '../../../../../domain';
 import { FirestoreConstructorParams } from '../../mixins';
+type CreateBlockedOrderParams = {
+    checkout: Checkout;
+    blockType: string;
+    type: OrderBlockedType;
+    limiteRange: string;
+    card?: PaymentCardInfo;
+};
 declare const OrderBlockedFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("../..").FirestoreRepository<OrderBlocked> & import("../../../../../domain").CrudRepository<OrderBlocked, import("../../../../../domain").CrudParams<OrderBlocked>> & import("../..").FirestoreHelpers, [FirestoreConstructorParams<OrderBlocked>, ...any[]]>;
 export declare class OrderBlockedFirestoreRepository extends OrderBlockedFirestoreRepository_base implements OrderBlockedRepository {
     constructor({ firestore, interceptors, cache, }: Pick<FirestoreConstructorParams<OrderBlocked>, 'firestore' | 'interceptors' | 'cache'>);
-    createBlockedOrderOrPayment(checkout: Checkout, blockType: string, type: OrderBlockedType, limiteRange: string, card?: PaymentCardInfo): Promise<OrderBlocked>;
+    createBlockedOrderOrPayment(params: CreateBlockedOrderParams): Promise<OrderBlocked>;
     private formatZip;
 }
 export {};

package/src/infra/hasura-graphql/mixins/factories/create-hasura-class.factory.d.ts

@@ -0,0 +1,30 @@
+import { CreateRepositoryParams, ModelBaseStructure } from '../../../../domain';
+import { MixinCtor } from '../../../../utils';
+import { GraphQLRepository } from '../../types';
+export type CreateConstructorParams = {
+    insertGraphQLOperation?: string;
+    insertAllGraphQLOperation?: string;
+    insertGraphQLObjectType?: string;
+};
+export declare function createCreateHasuraGraphQLClass<MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase): {
+    new (...params: any[]): {
+        insertGraphQLOperation: string;
+        insertGraphQLObjectType: string;
+        create(data: CreateRepositoryParams<MBase>): Promise<MBase>;
+        save(data: MBase): Promise<Partial<MBase>>;
+        tableName: string;
+        model: import("../../../../domain").BaseModelBuilder<MBase, any, MBase & {
+            prototype: unknown;
+        }>;
+        fields: import("../../types").HasuraGraphQLFields<MBase>;
+        endpoint: string;
+        authOptions: import("../../types").HasuraGraphQLAuthOptions;
+        logger: import("../../../../utils").DebugHelper;
+        cache?: import("../../../../domain").CacheConfig;
+        mutation: <ReturnFields = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields>;
+        query: <ReturnFields_1 = any>(operation: string | import("gql-query-builder/build/IQueryBuilderOptions").IOperation | import("../../types").GraphQLParams<MBase>[], fields?: import("../../types").HasuraGraphQLFields<MBase> | string[], variables?: import("../../types").VariableOptions) => Promise<ReturnFields_1>;
+        getAttributeGraphQLTypeOf: <FieldValue>(value: FieldValue) => string;
+        convertDataFromHasura(data: Record<string, string | number>, fields?: import("../../types").HasuraGraphQLFields<MBase> | string[]): MBase;
+        convertDataToHasura(instance: MBase, update?: boolean): Record<string, string | number>;
+    };
+} & TMixinBase;