@infrab4a/connect 4.2.0-beta.2 → 4.2.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect",
-  "version": "4.2.0-beta.2",
+  "version": "4.2.0-beta.4",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -21,18 +21,19 @@
     "ts-md5": "^1.2.9",
     "tslib": "^2.4.0"
   },
-  "module": "fesm2022/infrab4a-connect.mjs",
-  "typings": "index.d.ts",
+  "devDependencies": {
+    "@types/debug": "^4.1.8",
+    "@types/lodash": "^4.14.191",
+    "@types/node-fetch": "^2.6.2"
+  },
   "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
+    "./package.json": "./package.json",
     ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/infrab4a-connect.mjs",
-      "esm": "./esm2022/infrab4a-connect.mjs",
-      "default": "./fesm2022/infrab4a-connect.mjs"
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
     }
   },
-  "sideEffects": false
-}
+  "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-base.d.ts

@@ -0,0 +1,30 @@
+import { BaseModel, GenericIdentifier, ModelBaseStructure } from '../../generic/model';
+import { Shops } from './enums';
+import { Filter } from './filter';
+import { CategoryCondition, CategoryMetadata } 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;
+    brandCategoryBanner?: string;
+    brandCategoryBannerMobile?: string;
+    description: string;
+    conditions?: CategoryCondition;
+    products?: string[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    shop?: Shops;
+    shops?: string[];
+    published: boolean;
+    metadata: CategoryMetadata;
+    isCollection?: boolean;
+    isWishlist?: boolean;
+    reference?: string;
+    parentId?: number;
+    parent?: CategoryBase;
+    filters?: Filter[];
+    static get identifiersFields(): GenericIdentifier[];
+}

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-for-product.d.ts

@@ -0,0 +1,5 @@
+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/category.d.ts

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

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

@@ -0,0 +1,2 @@
+export * from './product-genders.enum';
+export * from './shops.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/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/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,12 @@
+import { BaseModel, GenericIdentifier } from '../../generic/model';
+import { FilterOption } from './filter-option';
+export declare class Filter extends BaseModel<Filter> {
+    id: number;
+    description: string;
+    slug: string;
+    enabled: boolean;
+    options?: FilterOption[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,11 @@
+export * from './category';
+export * from './category-collection-children';
+export * from './category-filter';
+export * from './enums';
+export * from './filter';
+export * from './filter-option';
+export * from './kit-product';
+export * from './product';
+export * from './types';
+export * from './variant';
+export * from './wishlist';

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

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

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

@@ -0,0 +1,40 @@
+import { BaseModel, GenericIdentifier, ModelBaseStructure } from '../../generic/model';
+import { ProductEvaluation, ProductGender, 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> {
+    id: string;
+    name: string;
+    slug: string;
+    description: ShopDescription;
+    sku: string;
+    price: ShopPrice;
+    hasVariants: boolean;
+    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[];
+    reviews?: ProductReview[];
+    variant?: Variant;
+    video?: string;
+    isKit?: boolean;
+    rate?: number;
+    gender?: ProductGender;
+    shoppingCount?: number;
+    metadata: ProductMetadata;
+    private reviewsTotal?;
+    get evaluation(): ProductEvaluation;
+    set evaluation(evaluation: ProductEvaluation);
+    static get identifiersFields(): GenericIdentifier[];
+}

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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/product.d.ts

@@ -0,0 +1,9 @@
+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[];
+}

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-metadata.type.d.ts

@@ -0,0 +1,4 @@
+export type CategoryMetadata = {
+    title?: string;
+    description?: 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,11 @@
+export * from './category-condition.type';
+export * from './category-metadata.type';
+export * from './category-product';
+export * from './product-evaluation.type';
+export * from './product-gender.type';
+export * from './product-metadata.type';
+export * from './product-review.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.type';
+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-metadata.type.d.ts

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

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

@@ -0,0 +1,17 @@
+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;
+};

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

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

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

@@ -0,0 +1,6 @@
+export type ShopPrice = {
+    price: number;
+    fullPrice: number;
+    subscriberDiscountPercentage?: 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,17 @@
+import { BaseModel } from '../../generic/model';
+import { ShopPrice, Stock, VariantGrade } from './types';
+export type ProductVariantIdentifiers = 'id' | 'productId';
+export declare class Variant extends BaseModel<Variant, ProductVariantIdentifiers> {
+    id: string;
+    productId: string;
+    sku: string;
+    price: ShopPrice;
+    EAN: string;
+    stock: Stock;
+    grade?: VariantGrade[];
+    costPrice: number;
+    weight: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    static get identifiersFields(): ProductVariantIdentifiers[];
+}

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

@@ -0,0 +1,8 @@
+import { GenericIdentifier } from '../../generic/model';
+import { Category } from './category';
+export declare class Wishlist extends Category {
+    personId?: string;
+    personName?: string;
+    personPhoto?: string;
+    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,6 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { CategoryFilter } from '../models';
+export interface CategoryFilterRepository extends CrudRepository<CategoryFilter> {
+    deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any>;
+    deleteByCategory(categoryId: number): Promise<any>;
+}

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

@@ -0,0 +1,18 @@
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Product } from '../models';
+import { Category } from '../models/category';
+import { Shops } from '../models/enums/shops.enum';
+export interface CategoryRepository extends CrudRepository<Category> {
+    getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
+    getCategoryByShop(shop: string): Promise<Category[]>;
+    getCategoriesForHome(categoryIds: string[], limit?: number, gender?: string): Promise<{
+        category: Category;
+        products: Product[];
+    }[]>;
+    mountCategory(category: Category, options?: {
+        limit?: number;
+        hasStock?: boolean;
+    }): Promise<Product[]>;
+    getChildren(parentId: number): Promise<Category[]>;
+    isChild(id: number, parentId: number): Promise<boolean>;
+}

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/index.d.ts

@@ -0,0 +1,9 @@
+export * from './category-collection-children.repository';
+export * from './category-filter.repository';
+export * from './category.repository';
+export * from './filter-option.repository';
+export * from './filter.repository';
+export * from './product.repository';
+export * from './subscription-product.repository';
+export * from './variant.repository';
+export * from './wishlist.repository';

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

@@ -0,0 +1,15 @@
+import { FindRepositoryParams, RepositoryFindResult } from '../../generic';
+import { CrudRepository } from '../../generic/repository/crud.repository';
+import { Product, ProductGender, ProductReview } from '../models';
+export type ReviewStatusParams = 'pending' | 'approved' | 'rejected';
+export type ReviewWithProductData = ProductReview & {
+    productId: string;
+    productName: string;
+    productSku: string;
+};
+export interface ProductRepository extends CrudRepository<Product> {
+    getBySlug(slug: string): Promise<Product>;
+    fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]>;
+    cleanShoppingCountFromIds(ids: string[]): Promise<any>;
+    findCatalog(params: FindRepositoryParams<Product>, mainGender?: Extract<ProductGender, 'female' | 'male'>): Promise<RepositoryFindResult<Product>>;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './model';
+export * from './repository';

package/src/domain/generic/model/base.model.d.ts

@@ -0,0 +1,14 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, NonFunctionAndIdentifierPropertyNames } from './types';
+export type GenericIdentifier<M = {
+    id: string;
+}, T = NonFunctionAndIdentifierPropertyNames<M>> = T;
+export declare class BaseModel<Model extends ModelBaseStructure<Model, Identifiers>, Identifiers = GenericIdentifier> implements ModelBaseStructure<Model, Identifiers> {
+    get identifier(): {
+        [key in Extract<NonFunctionAndIdentifierPropertyNames<Model>, Identifiers>]: Model[key];
+    };
+    get identifiersFields(): Identifiers[];
+    constructor(args?: Partial<Model>);
+    static toInstance<T>(this: new () => T, data?: Partial<NonFunctionAndIdentifierProperties<T>>): T;
+    static isModel<T extends ModelBaseStructure>(this: new () => T, value: any): value is T;
+    toPlain(): any;
+}

package/src/domain/generic/model/identifier-fields.d.ts

@@ -0,0 +1,4 @@
+import { NonFunctionPropertyNames } from './types/non-function-property-name.type';
+export interface IdentifierFields<Model> {
+    identifierFields: () => NonFunctionPropertyNames<Model>[];
+}

package/src/domain/generic/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base.model';
+export * from './identifier-fields';
+export * from './types';

package/src/domain/generic/model/types/base-model-builder.type.d.ts

@@ -0,0 +1,17 @@
+import { PartialIdentifiersModel } from './identifier-model.type';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertiesWithNoPartial } from './non-function-properties.type';
+import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
+export interface BaseModelBuilder<T extends ModelBaseStructure<T>, Identifiers = NonFunctionAndIdentifierPropertyNames<T> | any, P extends T & {
+    prototype: unknown;
+} = T & {
+    prototype: unknown;
+}> {
+    new (...args: any[]): T;
+    identifiersFields: Identifiers[];
+    prototype: {
+        [key in keyof P['prototype']]: P['prototype'][key];
+    };
+    toInstance<E>(this: new () => E, data?: NonFunctionAndIdentifierPropertiesWithNoPartial<T> | PartialIdentifiersModel<T>): E;
+    isModel(model: any): model is T;
+}

package/src/domain/generic/model/types/identifier-model.type.d.ts

@@ -0,0 +1,8 @@
+import { PropType } from '../../../../utils';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertyNames } from './non-function-property-name.type';
+export type IdentifierModel<Model extends ModelBaseStructure> = Extract<NonFunctionAndIdentifierPropertyNames<Model>, PropType<Model, 'identifiersFields'>[number]>;
+export type IdentifiersModel<Model extends ModelBaseStructure> = {
+    [K in IdentifierModel<Model>]: Model[K];
+};
+export type PartialIdentifiersModel<Model extends ModelBaseStructure> = Partial<IdentifiersModel<Model>>;

package/src/domain/generic/model/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './non-function-property-name.type';
+export * from './non-function-properties.type';
+export * from './base-model-builder.type';
+export * from './model-base-structure.type';
+export * from './identifier-model.type';

package/src/domain/generic/model/types/model-base-structure.type.d.ts

@@ -0,0 +1,12 @@
+import { NonFunctionAndIdentifierPropertyNames } from '..';
+type ModelBaseStructureRecord = Record<string, any> & {
+    identifiersFields: any[];
+};
+export type ModelBaseStructure<M extends ModelBaseStructureRecord = ModelBaseStructureRecord, I = M['identifiersFields'][number]> = {
+    identifier: {
+        [key in Extract<NonFunctionAndIdentifierPropertyNames<M>, I>]: M[key];
+    };
+    identifiersFields: I[];
+    toPlain: any;
+};
+export {};

package/src/domain/generic/model/types/non-function-properties.type.d.ts

@@ -0,0 +1,12 @@
+import { PropType } from '../../../../utils';
+import { IdentifierModel, PartialIdentifiersModel } from './identifier-model.type';
+import { ModelBaseStructure } from './model-base-structure.type';
+import { NonFunctionAndIdentifierPropertyNames, NonFunctionPropertyNames } from './non-function-property-name.type';
+export type NonFunctionProperties<T> = Pick<Partial<T>, NonFunctionPropertyNames<T>>;
+export type NonFunctionAndIdentifierProperties<T> = Pick<Partial<T>, NonFunctionAndIdentifierPropertyNames<T>>;
+export type NonFunctionAndIdentifierPropertiesWithNoPartial<T> = Pick<T, NonFunctionAndIdentifierPropertyNames<T>>;
+export type NonFunctionAndIdentifierPropertiesWithNoModels<T> = {
+    [key in keyof NonFunctionAndIdentifierPropertiesWithNoPartial<T>]: PropType<T, key> extends ModelBaseStructure ? NonFunctionAndIdentifierPropertiesWithNoIdentifiers<PropType<T, key>> & PartialIdentifiersModel<PropType<T, key>> : PropType<T, key> extends ModelBaseStructure[] ? PropType<T, key>[] : PropType<T, key>;
+};
+export type NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> = Omit<NonFunctionAndIdentifierPropertiesWithNoModels<T>, T extends ModelBaseStructure ? IdentifierModel<T> : never>;
+export type NonFunctionAndIdentifierPropertiesWithPartialIdentifiers<T> = NonFunctionAndIdentifierPropertiesWithNoIdentifiers<T> & (T extends ModelBaseStructure ? PartialIdentifiersModel<T> : never);

package/src/domain/generic/model/types/non-function-property-name.type.d.ts

@@ -0,0 +1,13 @@
+export type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
+export type ReadonlyKeys<T> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, never, P>;
+}[keyof T];
+export type WritableKeys<T> = Exclude<keyof T, ReadonlyKeys<T>>;
+export type NonFunctionPropertyNames<T, P = T, E extends WritableKeys<P> = WritableKeys<P>> = {
+    [K in E]: P[K] extends Function ? never : K extends 'identifiersFields' ? never : K;
+}[E];
+export type NonFunctionAndIdentifierPropertyNames<T> = NonFunctionPropertyNames<Omit<T, 'identifier' | 'identifiersFields'>>;

package/src/domain/generic/repository/create.repository.d.ts

@@ -0,0 +1,8 @@
+import { PropType } from '../../../utils';
+import { ModelBaseStructure, NonFunctionAndIdentifierProperties, PartialIdentifiersModel } from '../model/types';
+export type CreateRepositoryParams<Model extends ModelBaseStructure> = {
+    [key in keyof NonFunctionAndIdentifierProperties<Model>]: PropType<Model, key> extends ModelBaseStructure ? CreateRepositoryParams<PropType<Model, key>> : PropType<Model, key>;
+} & PartialIdentifiersModel<Model>;
+export interface CreateRepository<Model extends ModelBaseStructure, Params = CreateRepositoryParams<Model>> {
+    create(data: Params): Promise<Model>;
+}

package/src/domain/generic/repository/crud.repository.d.ts

@@ -0,0 +1,19 @@
+import { ModelBaseStructure } from '../model/types/model-base-structure.type';
+import { CreateRepository, CreateRepositoryParams } from './create.repository';
+import { DeleteRepository, DeleteRepositoryParams } from './delete.repository';
+import { ReadRepository, ReadRepositoryParams } from './read.repository';
+import { UpdateRepository, UpdateRepositoryParams } from './update.repository';
+export type CrudGenericParams = {
+    Create?: any;
+    Delete?: any;
+    Read?: ReadRepositoryParams<any>;
+    Update?: any;
+};
+export type CrudParams<Model extends ModelBaseStructure> = {
+    Create?: CreateRepositoryParams<Model>;
+    Delete?: DeleteRepositoryParams<Model>;
+    Read?: ReadRepositoryParams<Model>;
+    Update?: UpdateRepositoryParams<Model>;
+};
+export interface CrudRepository<Model extends ModelBaseStructure, Params extends CrudGenericParams = CrudParams<Model>> extends CreateRepository<Model, CreateRepositoryParams<Model> & Params['Create']>, DeleteRepository<Model, DeleteRepositoryParams<Model> & Params['Delete']>, ReadRepository<Model, ReadRepositoryParams<Model> & Params['Read']>, UpdateRepository<Model, UpdateRepositoryParams<Model> & Params['Update']> {
+}