@infrab4a/connect 5.0.0-alpha.9 → 6.0.0-alpha.0

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

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

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

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

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

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

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

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

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

package/src/domain/catalog/models/types/index.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.ts

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

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

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

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

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

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

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

package/src/domain/catalog/models/types/product-variant-report.type.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.ts

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

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

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

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

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

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

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

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

package/src/domain/catalog/repositories/category-collection-children.repository.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.ts

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

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

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

package/src/domain/catalog/repositories/filter-option.repository.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.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.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> {}

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

@@ -0,0 +1,14 @@
+export * from './category-collection-children.repository'
+export * from './category-filter.repository'
+export * from './category-product.repository'
+export * from './category.repository'
+export * from './filter-option.repository'
+export * from './filter.repository'
+export * from './group.repository'
+export * from './product-errors.repository'
+export * from './product-reviews.repository'
+export * from './product-stock-notification.repository'
+export * from './product.repository'
+export * from './subscription-product.repository'
+export * from './variant.repository'
+export * from './wishlist.repository'

package/src/domain/catalog/repositories/product-errors.repository.ts

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

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

@@ -0,0 +1,8 @@
+import { CrudRepository } from '../../generic/repository/crud.repository'
+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-stock-notification.repository.ts

@@ -0,0 +1,19 @@
+import { RepositoryFindResult } from '../../generic'
+import { CrudRepository } from '../../generic/repository/crud.repository'
+import { ProductStockNotification, ReportStockNotification, ReportStockNotificationInput, Shops } from '../models'
+
+type AddCustomerEmailParams = {
+  shop: Shops
+  productId: string
+  name: string
+  email: string
+}
+
+export interface ProductStockNotificationRepository extends CrudRepository<ProductStockNotification> {
+  addCustomerEmail(params: AddCustomerEmailParams): Promise<void>
+  getNotificationsReport(
+    params: ReportStockNotificationInput,
+    orderBy: { field: string; direction: string },
+    pagination?: { offset: number; limit: number },
+  ): Promise<RepositoryFindResult<ReportStockNotification>>
+}

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

@@ -0,0 +1,38 @@
+import { FindRepositoryParams, RepositoryCacheOptions, 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 = Omit<ProductReview, 'identifier' | 'identifiersFields' | 'toPlain'> & {
+  productId: string
+  productName: string
+  productSku: string
+  reviewStatus?: 'pending' | 'approved' | 'rejected'
+}
+export type PaginatedReviewFilters = {
+  sku?: string
+  status: ReviewStatusParams
+  email?: string
+  rate?: number
+  period?: { start: Date; end: Date }
+  limit?: number
+}
+
+export interface ProductRepository extends CrudRepository<Product> {
+  getBySlug(slug: string, options?: { cache?: RepositoryCacheOptions }): Promise<Product>
+  fetchReviews(
+    status: ReviewStatusParams,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<ReviewWithProductData[]>
+  fetchProductReviews(
+    filters: PaginatedReviewFilters,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<ReviewWithProductData[]>
+  cleanShoppingCountFromIds(ids: string[]): Promise<any>
+  findCatalog(
+    params: FindRepositoryParams<Product>,
+    mainGender?: Extract<ProductGender, 'female' | 'male' | 'unisex'>,
+    options?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<Product>>
+  productVariantFullReport(): Promise<ProductVariantReport[]>
+}

package/src/domain/catalog/repositories/subscription-product.repository.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.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.ts

@@ -0,0 +1,16 @@
+import { FindRepositoryParams, RepositoryFindResult } from '../../generic'
+import { Shops } from '../models'
+import { Wishlist } from '../models/wishlist'
+
+import { CategoryRepository } from '.'
+
+export interface WishlistRepository extends CategoryRepository<Wishlist> {
+  getWishlistBySlug(slug: string): Promise<Wishlist>
+  getWishlistByPerson(personId: string): Promise<Wishlist[]>
+  findBfluOrGlamgirlWishlists(
+    params: FindRepositoryParams<Wishlist>,
+    shops: Shops[],
+  ): Promise<RepositoryFindResult<Wishlist>>
+  addProduct(wishlistId: string, productId: string): Promise<void>
+  removeProduct(wishlistId: string, productId: string): Promise<void>
+}

package/src/domain/general/cacheadapter.ts

@@ -0,0 +1,12 @@
+export interface CacheOptions {
+  key: string
+  data: any
+  expirationInSeconds?: number
+}
+
+export interface CacheAdapter {
+  set(options: CacheOptions): Promise<boolean>
+  get<T = any>(key: string): Promise<T | null>
+  remove(key: string): Promise<boolean>
+  clear(): Promise<boolean>
+}

package/src/domain/general/index.ts

@@ -0,0 +1,5 @@
+export * from './cacheadapter'
+export * from './models'
+export * from './repositories'
+export * from './search'
+export * from './storage'

package/src/domain/general/models/index.ts

@@ -0,0 +1,2 @@
+export * from './log-document'
+export * from './sequences'

package/src/domain/general/models/log-document.ts

@@ -0,0 +1,19 @@
+import { BaseModel, GenericIdentifier } from '../../generic'
+
+export class LogDocument extends BaseModel<LogDocument> {
+  id?: string
+  collection: string
+  documentId: string
+  user?: {
+    id?: string
+    name?: string
+    email?: string
+  }
+  document: any
+  date: Date
+  operation: 'CREATE' | 'UPDATE' | 'DELETE'
+
+  static get identifiersFields(): GenericIdentifier[] {
+    return ['id']
+  }
+}

package/src/domain/general/models/sequences.ts

@@ -0,0 +1,13 @@
+import { BaseModel, GenericIdentifier } from '../../generic'
+
+export class Sequence extends BaseModel<Sequence> {
+  id?: string
+  type: string
+  counter: number
+  month: number
+  year: number
+
+  static get identifiersFields(): GenericIdentifier[] {
+    return ['id']
+  }
+}

package/src/domain/general/repositories/index.ts

@@ -0,0 +1,2 @@
+export * from './log.repository'
+export * from './sequences.repository'

package/src/domain/general/repositories/log.repository.ts

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

package/src/domain/general/repositories/sequences.repository.ts

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

package/src/domain/general/search/index.ts

@@ -0,0 +1 @@
+export * from './product-search-index'

package/src/domain/general/search/product-search-index.ts

@@ -0,0 +1,3 @@
+export interface ProductSearchIndex {
+  search<T>(searchTerm: string, total: number, gender?: String): Promise<T[]>
+}

package/src/domain/general/storage/file-uploader.service.ts

@@ -0,0 +1,3 @@
+export interface FileUploaderService {
+  upload(url: string, file: Blob | Uint8Array | ArrayBuffer): Promise<string>
+}

package/src/domain/general/storage/index.ts

@@ -0,0 +1 @@
+export * from './file-uploader.service'

package/src/domain/generic/index.ts

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

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

@@ -0,0 +1,43 @@
+import { instanceToPlain, plainToInstance } from 'class-transformer'
+
+import {
+  BaseModelBuilder,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierProperties,
+  NonFunctionAndIdentifierPropertyNames,
+} from './types'
+
+export type GenericIdentifier<M = { id: string }, T = NonFunctionAndIdentifierPropertyNames<M>> = T
+
+export class BaseModel<Model extends ModelBaseStructure<Model, Identifiers>, Identifiers = GenericIdentifier>
+implements ModelBaseStructure<Model, Identifiers>
+{
+  get identifier(): { [key in Extract<NonFunctionAndIdentifierPropertyNames<Model>, Identifiers>]: Model[key] } {
+    const fields = (this.constructor as BaseModelBuilder<Model>).identifiersFields.filter(
+      (field) => field !== 'identifier',
+    )
+    const data: Record<string, any> = this
+
+    return fields.reduce((object, field) => ({ ...object, [field]: data[field] }), {})
+  }
+
+  get identifiersFields(): Identifiers[] {
+    return (this.constructor as BaseModelBuilder<Model, Identifiers>).identifiersFields
+  }
+
+  constructor(args?: Partial<Model>) {
+    Object.assign(this, args)
+  }
+
+  static toInstance<T>(this: new () => T, data?: Partial<NonFunctionAndIdentifierProperties<T>>): T {
+    return plainToInstance(this, data || {})
+  }
+
+  static isModel<T extends ModelBaseStructure>(this: new () => T, value: any): value is T {
+    return value instanceof this
+  }
+
+  toPlain(): any {
+    return instanceToPlain(this)
+  }
+}

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

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

package/src/domain/generic/model/index.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.ts

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

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

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

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