@infrab4a/connect 6.0.0-alpha.0 → 6.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "6.0.0-alpha.0",
+  "version": "6.0.0-alpha.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -26,5 +26,15 @@
     "@types/debug": "^4.1.8",
     "@types/lodash": "^4.14.191",
     "@types/node-fetch": "^2.6.2"
-  }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js"
 }

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

@@ -0,0 +1 @@
+export * from './round-product-price.helper';

package/src/domain/catalog/helpers/round-product-price.helper.d.ts

@@ -0,0 +1,4 @@
+import { Product } from '../models';
+export declare class RoundProductPricesHelper {
+    static roundProductPrices(product: Product): Product;
+}

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

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './models';
+export * from './repositories';

package/src/domain/catalog/models/category-collection-children.d.ts

@@ -0,0 +1,13 @@
+import { BaseModel } from '../../generic/model';
+export type CategoryCollectionChildrenIdentifiers = 'collectionId' | 'categoryId';
+export declare class CategoryCollectionChildren extends BaseModel<CategoryCollectionChildren, CategoryCollectionChildrenIdentifiers> {
+    collectionId: number;
+    categoryId: number;
+    parentCollectionId?: number;
+    parentCategoryId?: number;
+    name: string;
+    slug: string;
+    reference?: string;
+    parent?: CategoryCollectionChildren;
+    static get identifiersFields(): CategoryCollectionChildrenIdentifiers[];
+}

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

@@ -0,0 +1,13 @@
+import { BaseModel } from '../../generic/model';
+import { Category } from './category';
+import { Filter } from './filter';
+type CategoryFilterIdentifiers = 'id' | 'filterId' | 'categoryId';
+export declare class CategoryFilter extends BaseModel<CategoryFilter, CategoryFilterIdentifiers> {
+    id: number;
+    filterId: number;
+    categoryId: number;
+    filter?: Filter;
+    category?: Category;
+    static get identifiersFields(): CategoryFilterIdentifiers[];
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { BaseModel } from '../../generic/model';
+export type CategoryProductIdentifiers = 'productId' | 'categoryId';
+export declare class CategoryProduct extends BaseModel<CategoryProduct, CategoryProductIdentifiers> {
+    categoryId: number;
+    productId: number;
+    order: number;
+    static get identifiersFields(): CategoryProductIdentifiers[];
+}

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

@@ -0,0 +1,52 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { Shops } from './enums';
+import type { Filter } from './filter';
+import type { Product } from './product';
+import type { BrandEquityOption, CategoryCondition, CategoryImages, CategoryMetadata, CategoryMostRelevant } from './types';
+export declare class Category extends BaseModel<Category> {
+    id: string;
+    brandCategory: boolean;
+    brandLogo?: string;
+    brandEquity?: BrandEquityOption;
+    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/enums/brand-equity-options.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum BrandEquityOptions {
+    '1_DETRACTOR' = "detractor",
+    '2_UNKNOWN' = "unknown",
+    '3_LOW' = "low",
+    '4_MID' = "mid",
+    '5_STRONG' = "strong"
+}

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

@@ -0,0 +1,5 @@
+export * from './brand-equity-options.enum';
+export * from './product-genders.enum';
+export * from './product-label.enum';
+export * from './shops.enum';
+export * from './wishlist-log.enum';

package/src/domain/catalog/models/enums/product-genders.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum GenderDestination {
+    FEMALE = "female",
+    MALE = "male",
+    UNISEX = "unisex"
+}

package/src/domain/catalog/models/enums/product-label.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum ProductLabelEnum {
+    ON_SALE = "on-sale",
+    OUTLET = "outlet",
+    LAST_UNITS = "last-units",
+    GLAMSTAR = "glamstar"
+}

package/src/domain/catalog/models/enums/shops.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum Shops {
+    MENSMARKET = "mensmarket",
+    GLAMSHOP = "Glamshop",
+    GLAMPOINTS = "Glampoints",
+    ALL = "ALL"
+}

package/src/domain/catalog/models/enums/wishlist-log.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum WishlistLogType {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete",
+    ADD_PRODUCT = "add_product",
+    REMOVE_PRODUCT = "remove_product"
+}

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

@@ -0,0 +1,9 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+export declare class FilterOption extends BaseModel<FilterOption> {
+    id: string;
+    filterId: number;
+    description: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,15 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { Category } from './category';
+import { FilterOption } from './filter-option';
+export declare class Filter extends BaseModel<Filter> {
+    id: number;
+    description: string;
+    title?: string;
+    slug: string;
+    enabled: boolean;
+    options?: FilterOption[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    categories?: Category[];
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,6 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+export declare class Group extends BaseModel<Group> {
+    id: number;
+    name: string;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,16 @@
+export * from './category';
+export * from './category-collection-children';
+export * from './category-filter';
+export * from './category-product';
+export * from './enums';
+export * from './filter';
+export * from './filter-option';
+export * from './group';
+export * from './kit-product';
+export * from './product';
+export * from './product-errors';
+export * from './product-review';
+export * from './product-stock-notification';
+export * from './types';
+export * from './variant';
+export * from './wishlist';

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

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

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

@@ -0,0 +1,48 @@
+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;
+    NCM: string;
+    EAN: string;
+    CEST: string;
+    weight: number;
+    stock: Stock;
+    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?: ProductGender;
+    shoppingCount?: number;
+    metadata: ProductMetadata;
+    outlet?: boolean;
+    label?: ProductLabel;
+    group?: number;
+    validity: boolean;
+    category: Category;
+    kitProducts?: KitProduct[];
+    reviews?: ProductReview[];
+    private reviewsTotal?;
+    get evaluation(): ProductEvaluation;
+    set evaluation(evaluation: ProductEvaluation);
+    static get identifiersFields(): string[];
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { BaseModel } from '../../generic/model';
+import { Product } from './product';
+import { Variant } from './variant';
+type ProductErrorsIdentifiers = 'productId' | 'source' | 'error';
+type ProductAndVariant = Product | Variant;
+export declare class ProductErrors<T extends ProductAndVariant = ProductAndVariant> extends BaseModel<ProductErrors<T>, ProductErrorsIdentifiers> {
+    productId: string;
+    source: string;
+    error: string;
+    createdAt: Date;
+    updatedAt: Date;
+    product: T;
+    static get identifiersFields(): ProductErrorsIdentifiers[];
+    getProductId(): string;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { Shops } from './enums';
+export declare class ProductReview extends BaseModel<ProductReview> {
+    id: number;
+    productId: 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;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,12 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { Shops } from './enums';
+export declare class ProductStockNotification extends BaseModel<ProductStockNotification> {
+    id: number;
+    productId: string;
+    name: string;
+    email: string;
+    shop: Shops;
+    createdAt?: Date;
+    updatedAt?: Date;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,6 @@
+import { ProductBase } from './product-base';
+import { Variant } from './variant';
+export declare class Product extends ProductBase<Product> {
+    hasVariants: boolean;
+    variants?: Variant[];
+}

package/src/domain/catalog/models/types/brand-equity-option.type.d.ts

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

package/src/domain/catalog/models/types/category-condition.type.d.ts

@@ -0,0 +1,4 @@
+export type CategoryCondition = {
+    tags?: string[];
+    brand?: string;
+};

package/src/domain/catalog/models/types/category-images.type.d.ts

@@ -0,0 +1,8 @@
+import { Shops } from '../enums';
+export type CategoryImages = {
+    [shop in Shops]?: {
+        image: string;
+        brandBanner: string;
+        brandBannerMobile: string;
+    };
+};

package/src/domain/catalog/models/types/category-metadata.type.d.ts

@@ -0,0 +1,6 @@
+import { Shops } from '../enums';
+export type CategoryMetadata = {
+    shop: Shops;
+    title?: string;
+    description?: string;
+};

package/src/domain/catalog/models/types/category-most-relevant.type.d.ts

@@ -0,0 +1,4 @@
+import { Shops } from '../enums';
+export type CategoryMostRelevant = {
+    [shop in Shops]?: string[];
+};

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

@@ -0,0 +1,4 @@
+export type CategoryProduct = {
+    category_id: number;
+    product_id: number;
+};

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

@@ -0,0 +1,15 @@
+export * from './brand-equity-option.type';
+export * from './category-condition.type';
+export * from './category-images.type';
+export * from './category-metadata.type';
+export * from './category-most-relevant.type';
+export * from './product-evaluation.type';
+export * from './product-gender.type';
+export * from './product-label.type';
+export * from './product-metadata.type';
+export * from './product-variant-report.type';
+export * from './report-stock-notification.type';
+export * from './shop-description.type';
+export * from './shop-price.type';
+export * from './stock.type';
+export * from './variant-grade.type';

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

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

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

@@ -0,0 +1 @@
+export type ProductGender = 'female' | 'male' | 'unisex';

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

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

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

@@ -0,0 +1,4 @@
+export type ProductMetadata = {
+    title?: string;
+    description?: string;
+};

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

@@ -0,0 +1,46 @@
+export type ProductVariantReport = {
+    id: number;
+    name?: string;
+    description?: string;
+    slug?: string;
+    sku?: string;
+    ean?: string;
+    cest?: string;
+    ncm?: string;
+    has_variants?: boolean;
+    is_variant?: boolean;
+    grade: any;
+    type?: string;
+    is_kit?: boolean;
+    tags?: string[];
+    published?: boolean;
+    stock?: number;
+    brand?: string;
+    brand_description?: string;
+    images?: string[];
+    miniatures?: string[];
+    video?: string;
+    weight?: number;
+    cost_price?: number;
+    full_price?: number;
+    price?: number;
+    subscriber_discount_percentage?: number;
+    subscriber_price?: number;
+    how_to_use?: string;
+    who_must_use?: string;
+    differentials?: string;
+    ingredients?: string;
+    purpose?: string;
+    filters: string[];
+    category_id?: number;
+    outlet?: boolean;
+    label?: string;
+    group?: number;
+    validity?: boolean;
+    gender?: string;
+    shopping_count?: number;
+    rating?: number;
+    reviews_total?: number;
+    created_at?: Date;
+    updated_at?: Date;
+};

package/src/domain/catalog/models/types/report-stock-notification.type.d.ts

@@ -0,0 +1,21 @@
+export type ReportStockNotification = {
+    product_id: string;
+    ean: string;
+    sku: string;
+    name: string;
+    stock: number;
+    category: string;
+    category_id: string;
+    category_reference: string;
+    emails_registered: number;
+};
+export type ReportStockNotificationInput = {
+    productId?: string;
+    ean?: string;
+    sku?: string;
+    name?: string;
+    category?: string;
+    categoryId?: string;
+    reference?: string;
+    emailsCount?: number;
+};

package/src/domain/catalog/models/types/shop-description.type.d.ts

@@ -0,0 +1,9 @@
+export type ShopDescription = {
+    description: string;
+    differentials?: string;
+    whoMustUse?: string;
+    howToUse?: string;
+    brand?: string;
+    ingredients?: string;
+    purpose?: string;
+};

package/src/domain/catalog/models/types/shop-price.type.d.ts

@@ -0,0 +1,7 @@
+export type ShopPrice = {
+    price: number;
+    fullPrice: number;
+    subscriberDiscountPercentage?: number;
+    fullPriceDiscountPercentage?: number;
+    subscriberPrice?: number;
+};

package/src/domain/catalog/models/types/stock.type.d.ts

@@ -0,0 +1,3 @@
+export type Stock = {
+    quantity: number;
+};

package/src/domain/catalog/models/types/variant-grade.type.d.ts

@@ -0,0 +1,4 @@
+export type VariantGrade = {
+    title: string;
+    value: string;
+};

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

@@ -0,0 +1,8 @@
+import { ProductBase } from './product-base';
+import { VariantGrade } from './types';
+export type ProductVariantIdentifiers = 'id' | 'productId';
+export declare class Variant extends ProductBase<Variant, ProductVariantIdentifiers> {
+    productId: string;
+    grade?: VariantGrade[];
+    static get identifiersFields(): ProductVariantIdentifiers[];
+}

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

@@ -0,0 +1,11 @@
+import { GenericIdentifier } from '../../generic/model';
+import { PersonType } from '../../users';
+import { Category } from './category';
+export declare class Wishlist extends Category {
+    personId?: string;
+    personName?: string;
+    personPhoto?: string;
+    personType?: PersonType;
+    personIsSubscriber?: boolean;
+    static get identifiersFields(): GenericIdentifier[];
+}

package/src/domain/catalog/repositories/category-collection-children.repository.d.ts

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

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

@@ -0,0 +1,7 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { CategoryFilter } from '../models';
+export interface CategoryFilterRepository extends CrudRepository<CategoryFilter> {
+    addFiltersToCategory(categoryId: number, filterIds: number[]): Promise<void>;
+    deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any>;
+    deleteByCategory(categoryId: number): Promise<any>;
+}

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

@@ -0,0 +1,11 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { CategoryProduct } from '../models';
+export interface CategoryProductRepository extends CrudRepository<CategoryProduct> {
+    removeProductsFromCategory(categoryId: string, productIds: string[]): Promise<void>;
+    removeProductFromCategories(productId: string, categoryIds: string[]): Promise<void>;
+    addProductsToCategory(categoryId: string, productIds: {
+        productId: string;
+        order: number;
+    }[]): Promise<void>;
+    addProductToCategories(productId: string, categoryIds: string[]): Promise<void>;
+}

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

@@ -0,0 +1,42 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+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;
+    }): Promise<Category>;
+    getCategoryByShop(shop: string, optionsCache?: {
+        cache?: RepositoryCacheOptions;
+    }): Promise<Category[]>;
+    getCategoriesForHome(params: CategoriesForHomeParams): Promise<{
+        category: Category;
+        products: 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

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

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

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

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

@@ -0,0 +1,4 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Group } from '../models/group';
+export interface GroupRepository<T extends Group = Group> extends CrudRepository<T> {
+}