@infrab4a/connect 4.9.7-beta.3 → 4.9.7-beta.31

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

@@ -6,7 +6,45 @@ export declare class ProductsIndex {
     private index;
     constructor(adapter: ElasticSearchAdapter<Product>);
     getById(id: string): Promise<Product>;
-    search(searchTerm: string, total: number, shop: string): Promise<import("..").ElasticSearchResult<Product>>;
+    search(searchTerm: string, total: number, shop?: string): Promise<{
+        stock: number;
+        category: import("../../../domain/catalog/models/category-for-product").CategoryForProduct;
+        kitProducts?: import("../../../domain").KitProduct[];
+        id: string;
+        name: string;
+        slug: string;
+        description: import("../../../domain").ShopDescription;
+        sku: string;
+        price: import("../../../domain").ShopPrice;
+        hasVariants: boolean;
+        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[];
+        reviews?: import("../../../domain").ProductReview[];
+        variants?: import("../../../domain").Variant[];
+        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;
+    }[]>;
     save(product: ProductHasuraGraphQL): Promise<void>;
     update(product: ProductHasuraGraphQL): Promise<void>;
     delete(id: string): Promise<void>;

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

@@ -5,7 +5,7 @@ import { FirestoreRepository, FirestoreSubRepository } from '../types';
 export declare const withHelpers: <TMixinBase extends MixinCtor = MixinCtor>(MixinBase: MixinCtor & TMixinBase) => {
     new (...args: any[]): {
         [x: string]: any;
-        toArray<T extends ModelBaseStructure<T>>(snapShot: QuerySnapshot<T, import("@firebase/firestore").DocumentData> | QueryDocumentSnapshot<T, import("@firebase/firestore").DocumentData>[]): T[];
+        toArray<T extends ModelBaseStructure<T>>(snapShot: QuerySnapshot<T, import("firebase/firestore").DocumentData> | QueryDocumentSnapshot<T, import("firebase/firestore").DocumentData>[]): T[];
         isSubCollection<T_1 extends ModelBaseStructure<T_1>, E extends ModelBaseStructure<E>>(repository: FirestoreRepository<T_1> | FirestoreSubRepository<T_1, E>): repository is FirestoreSubRepository<T_1, E>;
     };
 } & TMixinBase;

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

@@ -4,11 +4,11 @@ declare const CategoryFirestoreRepository_base: import("../../../../../utils").M
 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[], limit?: number, gender?: string): Promise<{
+    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number): Promise<{
         category: Category;
         products: Product[];
     }[]>;
-    mountCategory(category: Category, options?: {
+    mountCategory(category: Category, shop: Shops, options?: {
         limit?: number;
         hasStock?: boolean;
         gender?: string;

package/src/infra/firebase/firestore/repositories/general/index.d.ts

@@ -0,0 +1 @@
+export * from './log-firestore.repository';

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

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

package/src/infra/firebase/firestore/repositories/index.d.ts

@@ -1,4 +1,5 @@
-export * from './users';
 export * from './catalog';
-export * from './shopping';
+export * from './general';
 export * from './shop-settings';
+export * from './shopping';
+export * from './users';

package/src/infra/firebase/firestore/repositories/shopping/index.d.ts

@@ -5,6 +5,7 @@ export * from './checkout-firestore.repository';
 export * from './checkout-subscription-firestore.repository';
 export * from './coupon-firestore.repository';
 export * from './legacy-order-firestore.repository';
+export * from './order-blocked-firestore.repository.ts';
 export * from './order-firestore.repository';
 export * from './payment-firestore.repository';
 export * from './subscription-plan-firestore.repository';

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

@@ -0,0 +1,9 @@
+import { Checkout, OrderBlocked, OrderBlockedRepository, PaymentCardInfo } from '../../../../../domain';
+import { FirestoreConstructorParams } from '../../mixins';
+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, }: Pick<FirestoreConstructorParams<OrderBlocked>, 'firestore' | 'interceptors'>);
+    createBlockedOrderOrPayment(checkout: Checkout, blockType: string, type: string, limiteRange: string, card?: PaymentCardInfo): Promise<OrderBlocked>;
+    private formatZip;
+}
+export {};

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

@@ -3,6 +3,7 @@ import { DebugHelper, MixinCtor } from '../../../utils';
 import { GraphQLParams, GraphQLRepository, HasuraGraphQLFields } from '../types';
 export declare const withFindHasuraGraphQL: <MBase extends ModelBaseStructure<MBase, MBase["identifiersFields"][number]>, TMixinBase extends MixinCtor<GraphQLRepository<MBase>>>(MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase) => {
     new (...args: any[]): {
+        lastDistinct: Record<string, any>;
         find(params?: FindRepositoryParams<MBase>): Promise<RepositoryFindResult<MBase>>;
         bindOrderByAttributes: (orderBy: RepositoryOrderBy<MBase>, fields: HasuraGraphQLFields<MBase>) => any[];
         bindAggretageAttributes: (aggregates: {

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

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

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

@@ -15,11 +15,11 @@ export declare class CategoryHasuraGraphQLRepository extends CategoryHasuraGraph
     update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL>;
     getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
     getCategoryByShop(shop: string): Promise<Category[]>;
-    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): Promise<{
+    getCategoriesForHome(categoryIds: string[], shop: Shops, limit?: number): Promise<{
         category: Category;
         products: Product[];
     }[]>;
-    mountCategory(category: Category, options?: {
+    mountCategory(category: Category, shop: Shops, options?: {
         limit?: number;
         hasStock?: boolean;
         gender?: string;

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

@@ -0,0 +1,11 @@
+import { CategoryProduct, CategoryProductRepository } from '../../../../domain';
+import { HasuraConstructorParams } from '../../mixins';
+declare const CategoryProductHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<CategoryProduct> & import("../../../../domain").CrudRepository<CategoryProduct, import("../../../../domain").CrudParams<CategoryProduct>> & import("../../../../domain").UpdateRepository<CategoryProduct, import("../../../../domain").RepositoryUpdateParams<CategoryProduct>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<CategoryProduct>): Partial<CategoryProduct>;
+}, [HasuraConstructorParams<CategoryProduct> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+export declare class CategoryProductHasuraGraphQLRepository extends CategoryProductHasuraGraphQLRepository_base implements CategoryProductRepository {
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    removeProductFromCategory(categoryId: string, productId: string): Promise<void>;
+    addProductToCategory(categoryId: string, productId: string): Promise<void>;
+}
+export {};

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

@@ -1,6 +1,7 @@
 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-hasura-graphql.repository';

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

@@ -17,7 +17,6 @@ export declare class ProductHasuraGraphQLRepository extends ProductHasuraGraphQL
     findCatalog(params: FindRepositoryParams<ProductHasuraGraphQL>, mainGender?: Extract<ProductGender, 'female' | 'male'>): Promise<RepositoryFindResult<ProductHasuraGraphQL>>;
     cleanShoppingCountFromIds(ids: string[]): Promise<void>;
     private getReviewStatus;
-    private updateCategories;
     private updateKitProducts;
     private updateReviews;
     private updateMetadata;

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

@@ -6,6 +6,7 @@ declare const ProductReviewsHasuraGraphQLRepository_base: import("../../../../ut
 }, [HasuraConstructorParams<ProductReviews> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
 export declare class ProductReviewsHasuraGraphQLRepository extends ProductReviewsHasuraGraphQLRepository_base implements ProductReviewsRepository {
     constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<ProductReviews>, 'endpoint' | 'authOptions' | 'interceptors'>);
+    updateManyStatus(reviews: Pick<ProductReviews, 'id' | 'status'>[]): Promise<void>;
     aproveReview(id: number): Promise<ProductReviews>;
     disaproveReview(id: number): Promise<ProductReviews>;
 }

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

@@ -1,4 +1,4 @@
-import { Filter, ProductStockNotification, Shops } from '../../../../domain';
+import { Filter, ProductStockNotification, ReportStockNotification, ReportStockNotificationInput, RepositoryFindResult, Shops } from '../../../../domain';
 import { ProductStockNotificationRepository } from '../../../../domain/catalog/repositories';
 import { HasuraConstructorParams } from '../../mixins';
 declare const ProductStockNotificationHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductStockNotification> & import("../../../../domain").CrudRepository<ProductStockNotification, import("../../../../domain").CrudParams<ProductStockNotification>> & import("../../../../domain").UpdateRepository<ProductStockNotification, import("../../../../domain").RepositoryUpdateParams<ProductStockNotification>> & {
@@ -7,5 +7,12 @@ declare const ProductStockNotificationHasuraGraphQLRepository_base: import("../.
 export declare class ProductStockNotificationHasuraGraphQLRepository extends ProductStockNotificationHasuraGraphQLRepository_base implements ProductStockNotificationRepository {
     constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors'>);
     addCustomerEmail(shop: Shops, productId: string, name: string, email: string): 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/wishlist-hasura-graphql.repository.d.ts

@@ -1,28 +1,31 @@
 import { Category, CreateRepositoryParams, FindRepositoryParams, GetRepositoryParams, Product, RepositoryFindResult, Shops, UpdateRepositoryParams, Wishlist, WishlistRepository } from '../../../../domain';
 import { HasuraConstructorParams } from '../../mixins';
-import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository';
-declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<Wishlist> & import("../../../../domain").CrudRepository<Wishlist, import("../../../../domain").CrudParams<Wishlist>> & import("../../../../domain").UpdateRepository<Wishlist, import("../../../../domain").RepositoryUpdateParams<Wishlist>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<Wishlist>): Partial<Wishlist>;
-}, [HasuraConstructorParams<Wishlist> & import("../../mixins").CreateConstructorParams & import("../../mixins").DeleteConstructorParams & import("../../mixins").GetConstructorParams & import("../../mixins").UpdateConstructorParams, ...any[]]>;
+import { WishlistHasuraGraphQL } from '../../models/wishlist-hasura-graphql';
+import { CategoryProductHasuraGraphQLRepository } from './category-product-hasura-graphql.repository';
+declare const WishlistHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<WishlistHasuraGraphQL> & import("../../../../domain").CrudRepository<WishlistHasuraGraphQL, import("../../../../domain").CrudParams<WishlistHasuraGraphQL>> & import("../../../../domain").UpdateRepository<WishlistHasuraGraphQL, import("../../../../domain").RepositoryUpdateParams<WishlistHasuraGraphQL>> & {
+    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<WishlistHasuraGraphQL>): Partial<WishlistHasuraGraphQL>;
+}, [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 categoryFilterRepository;
-    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors'>, categoryFilterRepository: CategoryFilterHasuraGraphQLRepository);
-    create(params: CreateRepositoryParams<Wishlist>): Promise<Wishlist>;
-    get(identifiers: GetRepositoryParams<Wishlist>): Promise<Wishlist>;
-    find(params?: FindRepositoryParams<Wishlist>): Promise<RepositoryFindResult<Wishlist>>;
-    update(params: UpdateRepositoryParams<Wishlist>): Promise<Wishlist>;
-    getWishlistBySlug(slug: string): Promise<Wishlist>;
-    getWishlistByPerson(personId: string): Promise<Wishlist[]>;
+    private readonly categoryProductRepository;
+    constructor({ endpoint, authOptions, interceptors, }: Pick<HasuraConstructorParams<Wishlist>, 'endpoint' | 'authOptions' | 'interceptors'>, 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>;
-    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): any;
-    mountCategory(category: Category, options?: {
+    findBfluOrGlamgirlWishlists(params: FindRepositoryParams<WishlistHasuraGraphQL>, shops: Shops[]): Promise<RepositoryFindResult<WishlistHasuraGraphQL>>;
+    getCategoriesForHome(categoryIds: string[], gender?: string, limit?: number): any;
+    mountCategory(category: Category, shop: Shops, options?: {
         limit?: number;
         hasStock?: boolean;
     }): Promise<Product[]>;
     getChildren(parentId: number): Promise<Category[]>;
     isChild(id: number, parentId: number): Promise<boolean>;
-    private updateProducts;
     private updateMetadata;
+    addProduct(wishlistId: string, productId: string): Promise<void>;
+    removeProduct(wishlistId: string, productId: string): Promise<void>;
 }
 export {};

package/src/infra/index.d.ts

@@ -1,3 +1,4 @@
 export * from './elasticsearch';
 export * from './firebase';
 export * from './hasura-graphql';
+export * from './vertex-ai';

package/src/infra/vertex-ai/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './vertex-ai-search.adapter';
+export * from './vertex-axios.adapter';

package/src/infra/vertex-ai/adapters/vertex-ai-search.adapter.d.ts

@@ -0,0 +1,10 @@
+import { Product } from '../../../domain';
+import { ProductBulk } from '../types';
+export interface VertexSearchAdapter<T> {
+    query(searchTerm: string, total: number, gender?: String): Promise<T[]>;
+    get(id: string): Promise<T>;
+    save(data: Product): Promise<any>;
+    update(id: string, data: Product): Promise<any>;
+    delete(id: string): Promise<void>;
+    bulkProducts(products: ProductBulk[]): Promise<void>;
+}

package/src/infra/vertex-ai/adapters/vertex-axios.adapter.d.ts

@@ -0,0 +1,15 @@
+import { Product } from '../../../domain';
+import { ProductBulk, ProductSearch } from '../types';
+import { VertexSearchConfig } from '../types/axios-vertex-search-config';
+import { VertexSearchAdapter } from './vertex-ai-search.adapter';
+export declare class VertexAxiosAdapter implements VertexSearchAdapter<ProductSearch> {
+    private readonly config;
+    private logger;
+    constructor(config: VertexSearchConfig);
+    query(term: string, total: number, gender?: String): Promise<ProductSearch[]>;
+    get(id: string): Promise<ProductSearch>;
+    save(data: Product): Promise<any>;
+    update(id: string, data: Product): Promise<any>;
+    delete(id: string): Promise<void>;
+    bulkProducts(products: ProductBulk[]): Promise<void>;
+}

package/src/infra/vertex-ai/index.d.ts

@@ -0,0 +1,3 @@
+export * from './adapters';
+export * from './indexes';
+export * from './types';

package/src/infra/vertex-ai/indexes/index.d.ts

@@ -0,0 +1 @@
+export * from './products-vertex-search';

package/src/infra/vertex-ai/indexes/products-vertex-search.d.ts

@@ -0,0 +1,13 @@
+import { ProductSearchIndex } from '../../../domain';
+import { ProductHasuraGraphQL } from '../../hasura-graphql';
+import { VertexSearchAdapter } from '../adapters';
+import { ProductSearch } from '../types';
+export declare class ProductsVertexSearch implements ProductSearchIndex {
+    private readonly adapter;
+    constructor(adapter: VertexSearchAdapter<ProductSearch>);
+    getById(id: string): Promise<ProductSearch>;
+    search<ProductSearch>(searchTerm: string, total: number, gender?: String): Promise<ProductSearch[]>;
+    save(product: ProductHasuraGraphQL): Promise<void>;
+    update(product: ProductHasuraGraphQL): Promise<void>;
+    delete(id: string): Promise<void>;
+}

package/src/infra/vertex-ai/types/axios-vertex-search-config.d.ts

@@ -0,0 +1,4 @@
+export type VertexSearchConfig = {
+    url: string;
+    token?: string;
+};

package/src/infra/vertex-ai/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './axios-vertex-search-config';
+export * from './product-bulk';
+export * from './product-search';

package/src/infra/vertex-ai/types/product-bulk.d.ts

@@ -0,0 +1,4 @@
+export type ProductBulk = {
+    id: string;
+    jsonData: string;
+};

package/src/infra/vertex-ai/types/product-search.d.ts

@@ -0,0 +1,21 @@
+export type ProductSearch = {
+    id: string;
+    name: string;
+    ean?: string;
+    sku: string;
+    icon?: string;
+    miniatures?: string;
+    description?: string;
+    slug: string;
+    brand: string;
+    published: boolean;
+    gender: string;
+    shoppingCount: number;
+    stock: number;
+    rating: number;
+    fullPrice: number;
+    price: number;
+    subscriberPrice: number;
+    outlet: boolean;
+    createdAt: Date;
+};