@infrab4a/connect 4.23.2 → 4.24.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "4.23.2",
+  "version": "4.24.0-beta.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },

package/src/domain/catalog/models/category.d.ts

@@ -1,9 +1,51 @@
-import { GenericIdentifier } from '../../generic/model';
-import { CategoryBase } from './category-base';
-import { Filter } from './filter';
-import { ProductForCategory } from './product-for-category';
-export declare class Category extends CategoryBase<Category, GenericIdentifier> {
-    childrenProducts?: ProductForCategory[];
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { Shops } from './enums';
+import type { Filter } from './filter';
+import type { Product } from './product';
+import { CategoryCondition, CategoryImages, CategoryMetadata, CategoryMostRelevant } from './types';
+export declare class Category extends BaseModel<Category> {
+    id: string;
+    brandCategory: boolean;
+    brandLogo?: string;
+    name: string;
+    slug: string;
+    image?: string;
+    images?: CategoryImages;
+    brandCategoryBanner?: string;
+    brandCategoryBannerMobile?: string;
+    description: string;
+    conditions?: CategoryCondition;
+    products?: string[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    shop?: Shops;
+    shops?: string[];
+    published: boolean;
+    metadata: CategoryMetadata;
+    metadatas: CategoryMetadata[];
+    isCollection?: boolean;
+    isWishlist?: boolean;
+    reference?: string;
+    parentId?: number;
+    theme?: string;
+    bannerUrl?: string;
+    mostRelevant?: string[];
+    mostRelevants?: CategoryMostRelevant;
+    parent?: Category;
+    childrenProducts?: Product[];
     filters?: Filter[];
     static get identifiersFields(): GenericIdentifier[];
+    get glamImages(): {
+        image: string;
+        brandBanner: string;
+        brandBannerMobile: string;
+    };
+    get mensImages(): {
+        image: string;
+        brandBanner: string;
+        brandBannerMobile: string;
+    };
+    get glamMetadata(): CategoryMetadata;
+    get mensMetadata(): CategoryMetadata;
+    getMostRelevantByShop(shop: Shops): string[];
 }

package/src/domain/catalog/models/filter.d.ts

@@ -1,5 +1,5 @@
 import { BaseModel, GenericIdentifier } from '../../generic/model';
-import { CategoryBase } from './category-base';
+import { Category } from './category';
 import { FilterOption } from './filter-option';
 export declare class Filter extends BaseModel<Filter> {
     id: number;
@@ -10,6 +10,6 @@ export declare class Filter extends BaseModel<Filter> {
     options?: FilterOption[];
     createdAt?: Date;
     updatedAt?: Date;
-    categories?: CategoryBase[];
+    categories?: Category[];
     static get identifiersFields(): GenericIdentifier[];
 }

package/src/domain/catalog/models/index.d.ts

@@ -8,7 +8,7 @@ export * from './filter-option';
 export * from './kit-product';
 export * from './product';
 export * from './product-errors';
-export * from './product-reviews';
+export * from './product-review';
 export * from './product-stock-notification';
 export * from './types';
 export * from './variant';

package/src/domain/catalog/models/kit-product.d.ts

@@ -1,12 +1,13 @@
 import { BaseModel } from '../../generic/model';
-import { ProductForKit } from './product-for-kit';
+import type { Product } from './product';
 type KitProductIdentifiers = 'productId' | 'kitProductId';
-export declare class KitProduct extends BaseModel<KitProduct, KitProductIdentifiers> {
+export declare class KitProduct extends BaseModel<KitProduct> {
+    id: string;
     productId: string;
     kitProductId: string;
     quantity: number;
-    kit: ProductForKit;
-    product: ProductForKit;
+    kit: Product;
+    product: Product;
     static get identifiersFields(): KitProductIdentifiers[];
 }
 export {};

package/src/domain/catalog/models/product-base.d.ts

@@ -1,14 +1,16 @@
-import { BaseModel, GenericIdentifier, ModelBaseStructure } from '../../generic/model';
-import { ProductEvaluation, ProductGender, ProductLabel, ProductMetadata, ProductReview, ShopDescription, ShopPrice, Stock } from './types';
-import { Variant } from './variant';
-export declare class ProductBase<ChildProduct extends ModelBaseStructure<ChildProduct, Identifiers>, Identifiers = ChildProduct['identifiersFields']> extends BaseModel<ChildProduct, Identifiers> {
+import { BaseModel } from '../../generic/model';
+import { Category } from './category';
+import { KitProduct } from './kit-product';
+import { ProductReview } from './product-review';
+import { ProductEvaluation, ProductGender, ProductLabel, ProductMetadata, ShopDescription, ShopPrice, Stock } from './types';
+type ProductIdentifiers = 'id';
+export declare class ProductBase<T extends ProductBase<T, I>, I = ProductIdentifiers> extends BaseModel<T, I> {
     id: string;
     name: string;
     slug: string;
     description: ShopDescription;
     sku: string;
     price: ShopPrice;
-    hasVariants: boolean;
     NCM: string;
     EAN: string;
     CEST: string;
@@ -25,8 +27,6 @@ export declare class ProductBase<ChildProduct extends ModelBaseStructure<ChildPr
     filters?: string[];
     type?: string;
     categories?: string[];
-    reviews?: ProductReview[];
-    variants?: Variant[];
     video?: string;
     isKit?: boolean;
     rate?: number;
@@ -37,8 +37,12 @@ export declare class ProductBase<ChildProduct extends ModelBaseStructure<ChildPr
     label?: ProductLabel;
     group?: number;
     validity: boolean;
+    category: Category;
+    kitProducts?: KitProduct[];
+    reviews?: ProductReview[];
     private reviewsTotal?;
     get evaluation(): ProductEvaluation;
     set evaluation(evaluation: ProductEvaluation);
-    static get identifiersFields(): GenericIdentifier[];
+    static get identifiersFields(): string[];
 }
+export {};

package/src/domain/catalog/models/product-errors.d.ts

@@ -2,7 +2,8 @@ import { BaseModel } from '../../generic/model';
 import { Product } from './product';
 import { Variant } from './variant';
 type ProductErrorsIdentifiers = 'productId' | 'source' | 'error';
-export declare class ProductErrors<T extends Product | Variant = Product | Variant> extends BaseModel<ProductErrors<T>, ProductErrorsIdentifiers> {
+type ProductAndVariant = Product | Variant;
+export declare class ProductErrors<T extends ProductAndVariant = ProductAndVariant> extends BaseModel<ProductErrors<T>, ProductErrorsIdentifiers> {
     productId: string;
     source: string;
     error: string;

package/src/domain/catalog/models/{product-reviews.d.ts → product-review.d.ts}

@@ -1,8 +1,8 @@
 import { BaseModel, GenericIdentifier } from '../../generic/model';
 import { Shops } from './enums';
-export declare class ProductReviews extends BaseModel<ProductReviews> {
+export declare class ProductReview extends BaseModel<ProductReview> {
     id: number;
-    productId: number;
+    productId: string;
     shop: Shops;
     rate: number;
     author?: string;

package/src/domain/catalog/models/product.d.ts

@@ -1,9 +1,6 @@
-import { GenericIdentifier } from '../../generic/model';
-import { CategoryForProduct } from './category-for-product';
-import { KitProduct } from './kit-product';
 import { ProductBase } from './product-base';
-export declare class Product extends ProductBase<Product, GenericIdentifier> {
-    category: CategoryForProduct;
-    kitProducts?: KitProduct[];
-    static get identifiersFields(): GenericIdentifier[];
+import { Variant } from './variant';
+export declare class Product extends ProductBase<Product> {
+    hasVariants: boolean;
+    variants?: Variant[];
 }

package/src/domain/catalog/models/types/index.d.ts

@@ -6,7 +6,6 @@ export * from './product-evaluation.type';
 export * from './product-gender.type';
 export * from './product-label.type';
 export * from './product-metadata.type';
-export * from './product-review.type';
 export * from './product-variant-report.type';
 export * from './report-stock-notification.type';
 export * from './shop-description.type';

package/src/domain/catalog/models/types/product-evaluation.type.d.ts

@@ -1,4 +1,4 @@
-import { ProductReview } from './product-review.type';
+import { ProductReview } from '../product-review';
 export type ProductEvaluation = {
     reviews?: ProductReview[];
     rating?: number;

package/src/domain/catalog/models/variant.d.ts

@@ -1,21 +1,8 @@
-import { BaseModel } from '../../generic/model';
-import { ShopPrice, Stock, VariantGrade } from './types';
+import { ProductBase } from './product-base';
+import { VariantGrade } from './types';
 export type ProductVariantIdentifiers = 'id' | 'productId';
-export declare class Variant extends BaseModel<Variant, ProductVariantIdentifiers> {
-    id: string;
+export declare class Variant extends ProductBase<Variant, ProductVariantIdentifiers> {
     productId: string;
-    sku: string;
-    price: ShopPrice;
-    EAN: string;
-    stock: Stock;
     grade?: VariantGrade[];
-    costPrice: number;
-    weight: number;
-    createdAt?: Date;
-    updatedAt?: Date;
-    group?: number;
-    validity: boolean;
-    tags: string[];
-    published: boolean;
     static get identifiersFields(): ProductVariantIdentifiers[];
 }

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

@@ -1,7 +1,7 @@
 import { CrudRepository } from '../../generic/repository/crud.repository';
-import { ProductReviews } from '../models';
-export interface ProductReviewsRepository extends CrudRepository<ProductReviews> {
-    aproveReview(id: number): Promise<ProductReviews>;
-    disaproveReview(id: number): Promise<ProductReviews>;
-    updateManyStatus(reviews: Pick<ProductReviews, 'id' | 'status'>[]): Promise<void>;
+import { ProductReview } from '../models';
+export interface ProductReviewRepository extends CrudRepository<ProductReview> {
+    aproveReview(id: number): Promise<ProductReview>;
+    disaproveReview(id: number): Promise<ProductReview>;
+    updateManyStatus(reviews: Pick<ProductReview, 'id' | 'status'>[]): Promise<void>;
 }

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

@@ -2,7 +2,7 @@ import { FindRepositoryParams, RepositoryFindResult } from '../../generic';
 import { CrudRepository } from '../../generic/repository/crud.repository';
 import { Product, ProductGender, ProductReview, ProductVariantReport } from '../models';
 export type ReviewStatusParams = 'pending' | 'approved' | 'rejected';
-export type ReviewWithProductData = ProductReview & {
+export type ReviewWithProductData = Omit<ProductReview, 'identifier' | 'identifiersFields' | 'toPlain'> & {
     productId: string;
     productName: string;
     productSku: string;

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

@@ -8,15 +8,14 @@ export declare class ProductsIndex {
     getById(id: string): Promise<Product>;
     search(searchTerm: string, total: number, shop?: string): Promise<{
         stock: number;
-        category: import("../../../domain/catalog/models/category-for-product").CategoryForProduct;
-        kitProducts?: import("../../../domain").KitProduct[];
+        hasVariants: boolean;
+        variants?: import("../../../domain").Variant[];
         id: string;
         name: string;
         slug: string;
         description: import("../../../domain").ShopDescription;
         sku: string;
         price: import("../../../domain").ShopPrice;
-        hasVariants: boolean;
         NCM: string;
         EAN: string;
         CEST: string;
@@ -32,8 +31,6 @@ export declare class ProductsIndex {
         filters?: string[];
         type?: string;
         categories?: string[];
-        reviews?: import("../../../domain").ProductReview[];
-        variants?: import("../../../domain").Variant[];
         video?: string;
         isKit?: boolean;
         rate?: number;
@@ -44,6 +41,9 @@ export declare class ProductsIndex {
         label?: "outlet" | "on-sale" | "last-units" | "glamstar";
         group?: number;
         validity: boolean;
+        category: import("../../../domain").Category;
+        kitProducts?: import("../../../domain").KitProduct[];
+        reviews?: import("../../../domain").ProductReview[];
     }[]>;
     save(product: ProductHasuraGraphQL): Promise<void>;
     update(product: ProductHasuraGraphQL): Promise<void>;

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

@@ -5,6 +5,4 @@ export declare class VariantHasuraGraphQL extends Variant {
     subscriberDiscountPercentage?: number;
     subscriberPrice?: number;
     hasStock?: boolean;
-    name?: string;
-    hasVariants?: boolean;
 }

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

@@ -1,13 +1,13 @@
-import { ProductReviews } from '../../../../domain';
-import { ProductReviewsRepository } from '../../../../domain/catalog/repositories';
+import { ProductReview } from '../../../../domain';
+import { ProductReviewRepository } from '../../../../domain/catalog/repositories';
 import { HasuraConstructorParams } from '../../mixins';
-declare const ProductReviewsHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductReviews> & import("../../../../domain").CrudRepository<ProductReviews, import("../../../../domain").CrudParams<ProductReviews>> & import("../../../../domain").UpdateRepository<ProductReviews, import("../../../../domain").RepositoryUpdateParams<ProductReviews>> & {
-    paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<ProductReviews>): Partial<ProductReviews>;
-}, [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>;
+declare const ProductReviewHasuraGraphQLRepository_base: import("../../../../utils").MixinCtor<import("../..").GraphQLRepository<ProductReview> & import("../../../../domain").CrudRepository<ProductReview, import("../../../../domain").CrudParams<ProductReview>> & import("../../../../domain").UpdateRepository<ProductReview, import("../../../../domain").RepositoryUpdateParams<ProductReview>> & {
+    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'>);
+    updateManyStatus(reviews: Pick<ProductReview, 'id' | 'status'>[]): Promise<void>;
+    aproveReview(id: number): Promise<ProductReview>;
+    disaproveReview(id: number): Promise<ProductReview>;
 }
 export {};

package/src/utils/circular-dependencies.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Este arquivo define funções para resolver dependências circulares
+ * em ambiente ESM, onde não podemos usar require()
+ */
+export declare function registerClass(name: string, classConstructor: any): void;
+export declare function getClass(name: string): any;
+export declare function resolveClass(name: string): () => any;

package/src/utils/index.d.ts

@@ -1,6 +1,7 @@
 import { add, addBusinessDays, addDays, addMonths, addYears, Duration, endOfDay, format, formatISO9075, parseISO, startOfDay, sub, subDays } from 'date-fns';
 import { chunk, each, get, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set, sortBy, unset } from 'lodash';
 export type DateDuration = Duration;
+export * from './circular-dependencies';
 export * from './decorators';
 export * from './get';
 export * from './helpers';

package/src/domain/catalog/models/category-base.d.ts

@@ -1,47 +0,0 @@
-import { BaseModel, GenericIdentifier, ModelBaseStructure } from '../../generic/model';
-import { Shops } from './enums';
-import { CategoryCondition, CategoryImages, CategoryMetadata, CategoryMostRelevant } from './types';
-export declare class CategoryBase<ChildCategory extends ModelBaseStructure<ChildCategory, Identifiers> = ModelBaseStructure<any, any>, Identifiers = ChildCategory['identifiersFields']> extends BaseModel<ChildCategory, Identifiers> {
-    id: string;
-    brandCategory: boolean;
-    brandLogo?: string;
-    name: string;
-    slug: string;
-    image?: string;
-    images?: CategoryImages;
-    brandCategoryBanner?: string;
-    brandCategoryBannerMobile?: string;
-    description: string;
-    conditions?: CategoryCondition;
-    products?: string[];
-    createdAt?: Date;
-    updatedAt?: Date;
-    shop?: Shops;
-    shops?: string[];
-    published: boolean;
-    metadata: CategoryMetadata;
-    metadatas: CategoryMetadata[];
-    isCollection?: boolean;
-    isWishlist?: boolean;
-    reference?: string;
-    parentId?: number;
-    theme?: string;
-    bannerUrl?: string;
-    mostRelevant?: string[];
-    mostRelevants?: CategoryMostRelevant;
-    parent?: CategoryBase;
-    static get identifiersFields(): GenericIdentifier[];
-    get glamImages(): {
-        image: string;
-        brandBanner: string;
-        brandBannerMobile: string;
-    };
-    get mensImages(): {
-        image: string;
-        brandBanner: string;
-        brandBannerMobile: string;
-    };
-    get glamMetadata(): CategoryMetadata;
-    get mensMetadata(): CategoryMetadata;
-    getMostRelevantByShop(shop: Shops): string[];
-}

package/src/domain/catalog/models/category-for-product.d.ts

@@ -1,5 +0,0 @@
-import { GenericIdentifier } from '../../generic/model';
-import { CategoryBase } from './category-base';
-export declare class CategoryForProduct extends CategoryBase<CategoryForProduct, GenericIdentifier> {
-    static get identifiersFields(): GenericIdentifier[];
-}

package/src/domain/catalog/models/product-for-category.d.ts

@@ -1,7 +0,0 @@
-import { GenericIdentifier } from '../../generic/model';
-import { KitProduct } from './kit-product';
-import { ProductBase } from './product-base';
-export declare class ProductForCategory extends ProductBase<ProductForCategory, GenericIdentifier> {
-    kitProducts?: KitProduct[];
-    static get identifiersFields(): GenericIdentifier[];
-}

package/src/domain/catalog/models/product-for-kit.d.ts

@@ -1,7 +0,0 @@
-import { GenericIdentifier } from '../../generic/model';
-import { CategoryForProduct } from './category-for-product';
-import { ProductBase } from './product-base';
-export declare class ProductForKit extends ProductBase<ProductForKit, GenericIdentifier> {
-    category: CategoryForProduct;
-    static get identifiersFields(): GenericIdentifier[];
-}

package/src/domain/catalog/models/types/product-review.type.d.ts

@@ -1,17 +0,0 @@
-import { Shops } from '../enums/shops.enum';
-export type ProductReview = {
-    id?: string;
-    shop: Shops;
-    rate: number;
-    author?: string;
-    email?: string;
-    location?: string;
-    review?: string;
-    status?: boolean;
-    title?: string;
-    personId?: number;
-    points?: number;
-    orderId?: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-};