@infrab4a/connect 4.25.0-beta.1 → 4.25.0-beta.10

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

@@ -1,5 +1,5 @@
 import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
-import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
+import { BaseModelBuilder, CacheConfig, ModelBaseStructure } from '../../../domain';
 import { MergeConstructorParams, MixinCtor } from '../../../utils';
 import { Fields, GraphQLRepository, HasuraGraphQLAuthOptions, HasuraGraphQLFields, VariableOptions } from '../types';
 type QueryBuilderOptions = {
@@ -18,6 +18,7 @@ export type HasuraConstructorParams<Model extends ModelBaseStructure<Model, Mode
     endpoint: string;
     interceptors?: HasuraGraphQLInterceptors;
     authOptions: HasuraGraphQLAuthOptions;
+    cache?: CacheConfig;
 };
 export declare const withHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, T extends MixinCtor<any, any[]> = MixinCtor<any, any[]>>(MixinBase: T) => MixinCtor<GraphQLRepository<MBase>, any[]>;
 export {};

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

@@ -5,6 +5,6 @@ declare const CategoryCollectionChildrenHasuraGraphQLRepository_base: import("..
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryCollectionChildren>): Partial<CategoryCollectionChildren>;
 }, [HasuraConstructorParams<CategoryCollectionChildren> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryCollectionChildrenHasuraGraphQLRepository extends CategoryCollectionChildrenHasuraGraphQLRepository_base implements CategoryCollectionChildrenRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryCollectionChildren>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    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

@@ -5,7 +5,7 @@ declare const CategoryFilterHasuraGraphQLRepository_base: import("../../../../ut
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryFilter>): Partial<CategoryFilter>;
 }, [HasuraConstructorParams<CategoryFilter> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryFilterHasuraGraphQLRepository extends CategoryFilterHasuraGraphQLRepository_base implements CategoryFilterRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
     deleteByCategory(categoryId: number): Promise<any>;
     deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any>;
 }

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

@@ -1,4 +1,4 @@
-import { Category, CategoryRepository, CreateRepositoryParams, GetRepositoryParams, Product, Shops, UpdateRepositoryParams } from '../../../../domain';
+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';
@@ -9,13 +9,21 @@ declare const CategoryHasuraGraphQLRepository_base: import("../../../../utils").
 export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraphQLRepository_base implements CategoryRepository {
     private readonly productRepository;
     private readonly categoryFilterRepository;
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>, productRepository: ProductHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    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>): Promise<CategoryHasuraGraphQL>;
+    get(identifiers: GetRepositoryParams<CategoryHasuraGraphQL>, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<CategoryHasuraGraphQL>;
     update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
-    getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
-    getCategoryByShop(shop: string): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number): Promise<{
+    getCategoryBySlug(slug: string, shop: Shops, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category>;
+    getCategoryByShop(shop: string, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<{
         category: Category;
         products: Product[];
     }[]>;
@@ -23,8 +31,12 @@ export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraph
         limit?: number;
         hasStock?: boolean;
         gender?: string;
+    }, optionsCache?: {
+        cache?: RepositoryCacheOptions;
     }): Promise<Product[]>;
-    getChildren(parentId: number): Promise<Category[]>;
+    getChildren(parentId: number, _optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
     isChild(id: number, parentId: number): Promise<boolean>;
     private getId;
     private updateProducts;

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

@@ -4,7 +4,7 @@ declare const CategoryProductHasuraGraphQLRepository_base: import("../../../../u
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryProduct>): Partial<CategoryProduct>;
 }, [HasuraConstructorParams<CategoryProduct> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class CategoryProductHasuraGraphQLRepository extends CategoryProductHasuraGraphQLRepository_base implements CategoryProductRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
     removeProductFromCategory(categoryId: string, productId: string): Promise<void>;
     addProductToCategory(categoryId: string, productId: string): Promise<void>;
 }

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

@@ -9,7 +9,7 @@ declare const FilterHasuraGraphQLRepository_base: import("../../../../utils").Mi
 export declare class FilterHasuraGraphQLRepository extends FilterHasuraGraphQLRepository_base implements FilterRepository {
     private readonly filterOptionRepository;
     private readonly categoryFilterRepository;
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors'>, filterOptionRepository: FilterOptionHasuraGraphQLRepository, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
+    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<import("../../../../domain").FilterOption[]>;
     delete(params: DeleteRepositoryParams<Filter>): Promise<void>;

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

@@ -5,6 +5,6 @@ declare const FilterOptionHasuraGraphQLRepository_base: import("../../../../util
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<FilterOption>): Partial<FilterOption>;
 }, [HasuraConstructorParams<FilterOption> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class FilterOptionHasuraGraphQLRepository extends FilterOptionHasuraGraphQLRepository_base implements FilterOptionRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<FilterOption>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
 }
 export {};

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

@@ -8,7 +8,7 @@ declare const ProductErrorsHasuraGraphQLRepository_base: import("../../../../uti
 }, [HasuraConstructorParams<ProductErrorsHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductErrorsHasuraGraphQLRepository extends ProductErrorsHasuraGraphQLRepository_base implements ProductErrorsRepository {
     private readonly productRepository;
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductErrorsHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>, productRepository: ProductHasuraGraphQLRepository);
+    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>>;
 }

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

@@ -1,4 +1,4 @@
-import { CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, ProductGender, ProductRepository, ProductVariantReport, RepositoryFindResult, ReviewStatusParams, ReviewWithProductData, UpdateRepositoryParams } from '../../../../domain';
+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("../../../../domain").UpdateRepository<ProductHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<ProductHasuraGraphQL>> & {
@@ -6,15 +6,27 @@ declare const ProductHasuraGraphQLRepository_base: import("../../../../utils").M
 }, [HasuraConstructorParams<ProductHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQLRepository_base implements ProductRepository {
     private get reviewsFields();
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<ProductHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
     create(params: CreateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    get(identifiers: GetRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    find(params?: FindRepositoryParams<ProductHasuraGraphQL>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
-    getBySlug(slug: string): 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>;
     update(params: UpdateRepositoryParams<ProductHasuraGraphQL>): Promise<ProductHasuraGraphQL>;
-    fetchProductReviews(): Promise<ReviewWithProductData[]>;
-    fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
-    findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>): Promise<RepositoryFindResult<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;

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

@@ -5,7 +5,7 @@ declare const ProductReviewHasuraGraphQLRepository_base: import("../../../../uti
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductReview>): Partial<ProductReview>;
 }, [HasuraConstructorParams<ProductReview> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductReviewHasuraGraphQLRepository extends ProductReviewHasuraGraphQLRepository_base implements ProductReviewRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductReview>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    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>;

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

@@ -5,7 +5,7 @@ declare const ProductStockNotificationHasuraGraphQLRepository_base: import("../.
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductStockNotification>): Partial<ProductStockNotification>;
 }, [HasuraConstructorParams<ProductStockNotification> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductStockNotificationHasuraGraphQLRepository extends ProductStockNotificationHasuraGraphQLRepository_base implements ProductStockNotificationRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    constructor({ endpoint, authOptions, interceptors, cache, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>);
     addCustomerEmail(shop: Shops, productId: string, name: string, email: string): Promise<void>;
     getNotificationsReport(params: ReportStockNotificationInput, orderBy: {
         field: string;

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

@@ -5,7 +5,7 @@ declare const VariantHasuraGraphQLRepository_base: import("../../../../utils").M
     paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<VariantHasuraGraphQL>): Partial<VariantHasuraGraphQL>;
 }, [HasuraConstructorParams<VariantHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class VariantHasuraGraphQLRepository extends VariantHasuraGraphQLRepository_base implements VariantRepository {
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<VariantHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    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>>;
     update(params: UpdateRepositoryParams<VariantHasuraGraphQL>): Promise<VariantHasuraGraphQL>;

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

@@ -7,7 +7,7 @@ declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").
 }, [HasuraConstructorParams<WishlistHasuraGraphQL> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class WishlistHasuraGraphQLRepository extends WishlistHasuraGraphQLRepository_base implements WishlistRepository {
     private readonly categoryProductRepository;
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors'>, categoryProductRepository: CategoryProductHasuraGraphQLRepository);
+    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>>;

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

@@ -1,5 +1,5 @@
 import { IOperation } from 'gql-query-builder/build/IQueryBuilderOptions';
-import { BaseModelBuilder, ModelBaseStructure } from '../../../domain';
+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';
@@ -16,6 +16,7 @@ export type GraphQLRepository<Model extends ModelBaseStructure<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;

package/src/infra/index.d.ts

@@ -1,4 +1,5 @@
 export * from './adyen';
+export * from './cache';
 export * from './elasticsearch';
 export * from './firebase';
 export * from './hasura-graphql';

package/src/domain/general/enums/index.d.ts

@@ -1 +0,0 @@
-export * from './queue-status.enum';

package/src/domain/general/enums/queue-status.enum.d.ts

@@ -1,6 +0,0 @@
-export declare enum QueueStatusEnum {
-    PENDING = "pending",
-    PROCESSING = "processing",
-    FAILED = "failed",
-    DONE = "done"
-}

package/src/domain/general/models/product-queue.d.ts

@@ -1,15 +0,0 @@
-import { BaseModel, GenericIdentifier } from '../../generic';
-import { QueueStatus } from '../types';
-export declare class ProductQueue extends BaseModel<ProductQueue> {
-    id?: string;
-    queueName: string;
-    status: QueueStatus;
-    retries?: number;
-    error?: string;
-    url: string;
-    payload: string;
-    createdAt: Date;
-    startedAt?: Date;
-    processedAt?: Date;
-    static get identifiersFields(): GenericIdentifier[];
-}

package/src/domain/general/repositories/product-queue.repository.d.ts

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

package/src/domain/general/types/index.d.ts

@@ -1 +0,0 @@
-export * from './queue-status.type';

package/src/domain/general/types/queue-status.type.d.ts

@@ -1,2 +0,0 @@
-import { QueueStatusEnum } from '../enums';
-export type QueueStatus = `${QueueStatusEnum}`;

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

@@ -1,7 +0,0 @@
-import { ProductQueue, ProductQueueRepository } from '../../../../../domain';
-import { FirestoreConstructorParams } from '../../mixins';
-declare const ProductQueueFirestoreRepository_base: import("../../../../../utils").MixinCtor<import("../..").FirestoreRepository<ProductQueue> & import("../../../../../domain").CrudRepository<ProductQueue, import("../../../../../domain").CrudParams<ProductQueue>> & import("../..").FirestoreHelpers, [FirestoreConstructorParams<ProductQueue>, ...any[]]>;
-export declare class ProductQueueFirestoreRepository extends ProductQueueFirestoreRepository_base implements ProductQueueRepository {
-    constructor({ firestore, interceptors, }: Pick<FirestoreConstructorParams<ProductQueue>, 'firestore' | 'interceptors'>);
-}
-export {};