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

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

@@ -0,0 +1,188 @@
+import { arrayRemove, arrayUnion, deleteField, FieldValue } from 'firebase/firestore'
+
+import {
+  IdentifierModel,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+  RepositoryUpdateParams,
+  UpdateOptionActions,
+  UpdateOptions,
+  UpdateRepository,
+} from '../../../../domain'
+import { is, isNil, MixinCtor, PropType } from '../../../../utils'
+import { FirestoreHelpers, FirestoreRepository } from '../types'
+
+import { FirestoreCacheHelper } from './helpers/firestore-cache.helper'
+import { FirestoreOperationsHelper } from './helpers/firestore-operations.helper'
+
+export type UpdateFirestoreRepositoryType<MBase extends ModelBaseStructure<MBase>> = UpdateRepository<MBase> & {
+  paramsToPlain(params: RepositoryUpdateParams<MBase>): Partial<MBase>
+}
+
+const createUpdateHelpers = <TBase extends ModelBaseStructure<TBase>>() => {
+  const getValueFromParams = (
+    params: RepositoryUpdateParams<TBase>,
+    field: NonFunctionAndIdentifierPropertyNames<TBase> | IdentifierModel<TBase>,
+  ): PropType<TBase, NonFunctionAndIdentifierPropertyNames<TBase>> =>
+    (isNil(is<UpdateOptions<PropType<TBase, NonFunctionAndIdentifierPropertyNames<TBase>>>>(params[field])?.value)
+      ? is<PropType<TBase, NonFunctionAndIdentifierPropertyNames<TBase>>>(params[field])
+      : is<UpdateOptions<PropType<TBase, NonFunctionAndIdentifierPropertyNames<TBase>>>>(params[field]).value) || null
+
+  const getValueByAction = (options: UpdateOptions<TBase>): FieldValue | unknown => {
+    if (isNil(options?.action)) return options
+
+    if (options?.action === UpdateOptionActions.REMOVE_FIELD) return deleteField()
+
+    if (options?.action === UpdateOptionActions.NULL) return null
+
+    if (Array.isArray(options?.value)) {
+      if (options?.action === UpdateOptionActions.MERGE) return arrayUnion(...options.value)
+
+      if (options?.action === UpdateOptionActions.REMOVE) return arrayRemove(...options.value)
+    }
+
+    return options?.value
+  }
+
+  return { getValueFromParams, getValueByAction }
+}
+
+const createUpdateFirestoreClass = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+  helpers: { getValueFromParams: any; getValueByAction: any },
+) => {
+  const { getValueFromParams, getValueByAction } = helpers
+
+  return class UpdateFirestore extends MixinBase implements UpdateRepository<TBase> {
+    private operationsHelper: FirestoreOperationsHelper<TBase>
+
+    constructor(...args: any[]) {
+      super(...args)
+      this.operationsHelper = new FirestoreOperationsHelper(this.model)
+    }
+
+    getIdentifiersFromData(data: RepositoryUpdateParams<TBase>): Record<string, any> {
+      const identifiers: Record<string, any> = {}
+      const keyField = this.operationsHelper.getKeyField()
+      const identifierValue = getValueFromParams(data, keyField as IdentifierModel<TBase>)
+
+      identifiers[keyField] = identifierValue
+
+      return identifiers
+    }
+
+    generateCacheKey(identifiers: Record<string, any>): string {
+      return FirestoreCacheHelper.generateGetCacheKey(this.model, identifiers)
+    }
+
+    async update(data: RepositoryUpdateParams<TBase>): Promise<TBase> {
+      const logger = this.logger.with('update')
+      const collectionName = this.buildCollectionPathForUpdate(data)
+      const req = { collection: collectionName, data }
+
+      await this.handleCacheRemoval(data, logger)
+
+      try {
+        const keyField = this.operationsHelper.getKeyField()
+        const identifiers = getValueFromParams(data, keyField as IdentifierModel<TBase>)
+
+        const docRef = this.collection(collectionName).getDoc(identifiers.toString())
+
+        await this.operationsHelper.validateDocumentExists(docRef, collectionName, identifiers)
+
+        const result = await this.executeUpdate({
+          data,
+          docRef,
+          logger,
+          req,
+          identifiers,
+        })
+
+        return result
+      } catch (error) {
+        this.operationsHelper.handleError(error, logger, req)
+        throw error
+      }
+    }
+
+    private async handleCacheRemoval(data: RepositoryUpdateParams<TBase>, logger: any): Promise<void> {
+      const identifiers = this.getIdentifiersFromData(data)
+      const cacheKey = this.generateCacheKey(identifiers)
+
+      await FirestoreCacheHelper.removeCacheData(this.cache, { cacheKey, logger })
+    }
+
+    private async executeUpdate(params: {
+      data: RepositoryUpdateParams<TBase>
+      docRef: any
+      logger: any
+      req: any
+      identifiers: any
+    }): Promise<TBase> {
+      const { data, docRef, logger, req, identifiers } = params
+
+      const plainFromData = this.model.toInstance(this.paramsToPlain(data))
+      const intercepted = await this.interceptors?.request?.({ instance: plainFromData })
+      const builded = intercepted?.instance || plainFromData
+
+      await docRef.save(builded.toPlain())
+
+      const docData = await docRef.get()
+      const result = this.interceptors?.response?.(docData.data(), intercepted) || docData.data()
+
+      logger.log({ req, res: result, identifiers })
+
+      return result
+    }
+
+    buildCollectionPathForUpdate(identifiers: RepositoryUpdateParams<TBase>): string {
+      return this.isSubCollection(this)
+        ? `${(this as any).parentRepository.collectionName}/${getValueFromParams(
+            identifiers,
+            (this as any).parentIdField,
+          )}/${this.collectionName}`
+        : this.collectionName
+    }
+
+    paramsToPlain(params: RepositoryUpdateParams<TBase>): Partial<TBase> {
+      const model = this.model
+
+      if (model.isModel(params)) return params.toPlain()
+
+      return this.convertParamsToPlainObject(params)
+    }
+
+    private convertParamsToPlainObject(params: RepositoryUpdateParams<TBase>): Partial<TBase> {
+      return Object.keys(params).reduce(
+        (data, currentKey) => ({
+          ...data,
+          ...this.processParamValue(currentKey, params[currentKey as never]),
+        }),
+        {},
+      )
+    }
+
+    private processParamValue(key: string, value: any): Record<string, any> {
+      const processedValue = getValueByAction(value)
+
+      return processedValue === undefined ? {} : { [key]: processedValue }
+    }
+  }
+}
+
+export const withUpdateFirestore = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+): MixinCtor<
+  FirestoreRepository<TBase> & UpdateRepository<TBase> & InstanceType<TMixinBase> & FirestoreHelpers,
+  []
+> => {
+  const helpers = createUpdateHelpers<TBase>()
+
+  return createUpdateFirestoreClass(MixinBase, helpers) as any
+}

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

@@ -0,0 +1,122 @@
+import { Category, CategoryRepository, Product, Shops } from '../../../../../domain'
+import { DuplicatedResultsError, NotFoundError, RequiredArgumentError } from '../../../../../errors'
+import { Base, chunk, is, Log } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+import { ConnectWhereOption } from '../../types'
+
+type CategoriesForHomeParams = {
+  categoryIds: string[]
+  shop: Shops
+  limit?: number
+  optionsCache?: any
+}
+
+type MountCategoryParams = {
+  category: Category
+  shop: Shops
+  options?: { limit?: number; hasStock?: boolean; gender?: string }
+  optionsCache?: any
+}
+
+export class CategoryFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<Category>(Base)))
+  implements CategoryRepository
+{
+  constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<Category>, 'firestore' | 'interceptors'>) {
+    super({
+      firestore,
+      collectionName: 'categories',
+      model: Category,
+      interceptors,
+    })
+  }
+
+  @Log()
+  async getCategoryBySlug(slug: string, shop: Shops): Promise<Category> {
+    const categoryDocs = await this.collection(this.collectionName)
+      .where('slug', '==', slug)
+      .where('shop', '==', shop)
+      .where('published', '==', true)
+      .getDocs()
+
+    if (categoryDocs.size > 1) throw new DuplicatedResultsError('Query returned duplicated values')
+
+    if (categoryDocs.empty) throw new NotFoundError(`Document with slug ${slug} not found`)
+
+    return categoryDocs.docs[0].data()
+  }
+
+  @Log()
+  async getCategoriesForHome(params: CategoriesForHomeParams): Promise<{ category: Category; products: Product[] }[]> {
+    const { categoryIds, shop, limit = 4 } = params
+
+    const categorySnap = await this.collection(this.collectionName)
+      .where('id', 'in', categoryIds.filter(Boolean))
+      .where('published', '==', true)
+      .getDocs()
+
+    if (categorySnap.empty) throw new NotFoundError('Categories not found')
+
+    const categories = categorySnap.docs.map((doc) => doc.data())
+    const homeSections = await Promise.all(
+      categories.map(async (category) => ({
+        category,
+        products: await this.mountCategory({
+          category,
+          shop,
+          options: { limit, hasStock: true },
+        }),
+      })),
+    )
+
+    return homeSections
+  }
+
+  @Log()
+  async mountCategory(params: MountCategoryParams): Promise<Product[]> {
+    const { category, options } = params
+
+    if (!category.products) throw new RequiredArgumentError(['Category products is empty'])
+
+    const chunks = chunk(category.products, 10)
+    const products = []
+    const wheres: [string, ConnectWhereOption, any][] = []
+
+    for (const productIds of chunks) {
+      if (options?.limit && products.length >= options?.limit) break
+
+      wheres.push(['published', '==', true], ['id', 'in', productIds])
+
+      if (options?.hasStock) wheres.push(['stock.quantity', '>', 0])
+
+      if (options?.gender) wheres.push(['tags', 'array-contains', options?.gender])
+
+      const productSnap = await wheres
+        .reduce(
+          (collection, where) => collection.where(...where),
+          options?.limit
+            ? this.collection('productsErpVitrine').limit(options.limit)
+            : this.collection('productsErpVitrine'),
+        )
+        .getDocs()
+
+      if (productSnap.empty) continue
+
+      products.push(...productSnap.docs)
+    }
+
+    return is<Product[]>(products)
+  }
+
+  getCategoryByShop(_shop: string): Promise<Category[]> {
+    return
+  }
+
+  getChildren(_parentId: number): Promise<Category[]> {
+    return
+  }
+
+  isChild(_id: number, _parentId: number): Promise<boolean> {
+    return
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Group, GroupRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class GroupFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<Group>(Base)))
+  implements GroupRepository
+{
+  constructor({
+    firestore,
+    interceptors,
+    cache,
+  }: Pick<FirestoreConstructorParams<Group>, 'firestore' | 'interceptors' | 'cache'>) {
+    super({
+      firestore,
+      collectionName: 'hooklabGroups',
+      model: Group,
+      interceptors,
+      cache,
+    })
+  }
+}

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

@@ -0,0 +1,5 @@
+export * from './category-firestore.repository'
+export * from './group-firestore.repository'
+export * from './product-firestore.repository'
+export * from './product-variant-firestore.repository'
+export * from './subscription-product-firestore.repository'

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

@@ -0,0 +1,90 @@
+import {
+  FindRepositoryParams,
+  PaginatedReviewFilters,
+  Product,
+  ProductRepository,
+  ProductVariantReport,
+  RepositoryFindResult,
+  ReviewStatusParams,
+  ReviewWithProductData,
+  Where,
+} from '../../../../../domain'
+import { Base, Log } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class ProductFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<Product>(Base)))
+  implements ProductRepository
+{
+  private reviews: Partial<Record<ReviewStatusParams, ReviewWithProductData[]>> = {}
+
+  constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<Product>, 'firestore' | 'interceptors'>) {
+    super({
+      firestore,
+      collectionName: 'productsErpVitrine',
+      model: Product,
+      interceptors,
+    })
+  }
+  fetchProductReviews(_filters: PaginatedReviewFilters): Promise<ReviewWithProductData[]> {
+    throw new Error('Method not implemented.')
+  }
+
+  @Log()
+  async getBySlug(slug: string): Promise<Product> {
+    const result = await this.find({
+      filters: {
+        slug: { operator: Where.EQUALS, value: slug },
+      },
+    })
+
+    return result?.data?.shift()
+  }
+
+  @Log()
+  async fetchReviews(status: ReviewStatusParams): Promise<ReviewWithProductData[]> {
+    const { data: products } = await this.find()
+
+    products.forEach((product) => {
+      if ([undefined, 0].includes(product.reviews?.length)) return
+
+      const productInfo = {
+        productId: product.id,
+        productName: product.name,
+        productSku: product.sku,
+      }
+
+      this.reviews.pending = []
+      this.reviews.approved = []
+      this.reviews.rejected = []
+
+      product.reviews.forEach((review) => {
+        if ([null, undefined].includes(review.status)) return this.reviews.pending.push({ ...review, ...productInfo })
+
+        if (review.status === false) return this.reviews.rejected.push({ ...review, ...productInfo })
+
+        if (review.status) return this.reviews.approved.push({ ...review, ...productInfo })
+
+        return review
+      })
+    })
+
+    return this.reviews[status]
+  }
+
+  cleanShoppingCountFromIds(): Promise<void> {
+    return
+  }
+
+  findCatalog(params: FindRepositoryParams<Product>): Promise<RepositoryFindResult<Product>> {
+    return this.find(params)
+  }
+
+  async fetchPaginatedReviews(): Promise<ReviewWithProductData[]> {
+    return Promise.resolve([])
+  }
+
+  productVariantFullReport(): Promise<ProductVariantReport[]> {
+    return
+  }
+}

package/src/infra/firebase/firestore/repositories/catalog/product-variant-firestore.repository.ts

@@ -0,0 +1,29 @@
+import { Product, Variant, VariantRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import {
+  FirestoreConstructorParams,
+  withCrudFirestore,
+  withFirestore,
+  withHelpers,
+  withSubCollection,
+} from '../../mixins'
+
+import { ProductFirestoreRepository } from './product-firestore.repository'
+
+export class ProductVariantFirestoreRepository
+  extends withSubCollection(withCrudFirestore(withHelpers(withFirestore<Variant>(Base))), Product)
+  implements VariantRepository
+{
+  constructor(
+    { firestore, interceptors }: Pick<FirestoreConstructorParams<Variant>, 'firestore' | 'interceptors'>,
+    override readonly parentRepository: ProductFirestoreRepository,
+  ) {
+    super({
+      firestore,
+      collectionName: 'variants',
+      parentIdField: 'productId',
+      model: Variant,
+      interceptors,
+    })
+  }
+}

package/src/infra/firebase/firestore/repositories/catalog/subscription-product-firestore.repository.ts

@@ -0,0 +1,17 @@
+import { Product, SubscriptionProductRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class SubscriptionProductFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<Product>(Base)))
+  implements SubscriptionProductRepository
+{
+  constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<Product>, 'firestore' | 'interceptors'>) {
+    super({
+      firestore,
+      collectionName: 'subscriptionProducts',
+      model: Product,
+      interceptors,
+    })
+  }
+}

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

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

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

@@ -0,0 +1,20 @@
+import { LogDocument, LogRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class LogFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<LogDocument>(Base)))
+  implements LogRepository
+{
+  constructor({
+    firestore,
+    interceptors,
+  }: Pick<FirestoreConstructorParams<LogDocument>, 'firestore' | 'interceptors'>) {
+    super({
+      firestore,
+      collectionName: 'logs',
+      model: LogDocument,
+      interceptors,
+    })
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Sequence, SequenceRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class SequenceFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<Sequence>(Base)))
+  implements SequenceRepository
+{
+  constructor({ firestore, interceptors }: Pick<FirestoreConstructorParams<Sequence>, 'firestore' | 'interceptors'>) {
+    super({
+      firestore,
+      collectionName: 'sequences',
+      model: Sequence,
+      interceptors,
+    })
+  }
+}

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

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

package/src/infra/firebase/firestore/repositories/shop-settings/home-firestore.repository.ts

@@ -0,0 +1,84 @@
+import { Timestamp } from 'firebase/firestore'
+
+import { Category, Home, HomeCategoryGroup, HomeRepository, Product } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+import { ConnectDocumentData, ConnectDocumentSnapshot } from '../../types'
+
+export class HomeFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<Home>(Base)))
+  implements HomeRepository
+{
+  constructor({
+    firestore,
+    interceptors,
+    cache,
+  }: Pick<FirestoreConstructorParams<Home>, 'firestore' | 'interceptors' | 'cache'>) {
+    super({
+      firestore,
+      collectionName: 'dms',
+      model: Home,
+      interceptors,
+      cache,
+    })
+  }
+
+  override buildModelInstance(): {
+    toFirestore: (data: Home) => ConnectDocumentData<Home>
+    fromFirestore: (snap: ConnectDocumentSnapshot<Home>) => Home
+    } {
+    const { fromFirestore, toFirestore } = super.buildModelInstance()
+
+    return {
+      toFirestore: (data: Home): ConnectDocumentData<Home> => {
+        const modifiedData = this.homeToFirestore(data)
+
+        return toFirestore(modifiedData)
+      },
+      fromFirestore: (snap: ConnectDocumentSnapshot<Home>): Home => {
+        const instance = fromFirestore(snap)
+
+        return this.homeFromFirestore(instance)
+      },
+    }
+  }
+
+  private homeToFirestore(home: Home): Home {
+    if (home.data?.data) {
+      home.data.data.discoverProducts = home.data.data.discoverProducts?.map(this.homeCategoryGroupToPlain) || []
+      home.data.data.featuredProducts = home.data.data.featuredProducts?.map(this.homeCategoryGroupToPlain) || []
+      home.data.data.verticalProducts = home.data.data.verticalProducts?.map(this.homeCategoryGroupToPlain) || []
+    }
+
+    return home
+  }
+
+  private homeCategoryGroupToPlain = (homeCategoryGroup: HomeCategoryGroup) => ({
+    category: homeCategoryGroup?.category?.toPlain
+      ? homeCategoryGroup?.category?.toPlain()
+      : homeCategoryGroup?.category,
+    products:
+      homeCategoryGroup?.products
+        ?.map((product) => (product?.toPlain ? product?.toPlain() : product))
+        .filter(Boolean) || [],
+  })
+
+  private homeFromFirestore(home: Home): Home {
+    if (home.data?.data) {
+      home.data.data.discoverProducts = home.data.data.discoverProducts.map(this.plainToHomeCategoryGroup)
+      home.data.data.featuredProducts = home.data.data.featuredProducts.map(this.plainToHomeCategoryGroup)
+      home.data.data.verticalProducts = home.data.data.verticalProducts.map(this.plainToHomeCategoryGroup)
+      home.data.createdAt =
+        home.data.createdAt instanceof Timestamp ? home.data.createdAt.toDate() : home.data.createdAt
+      home.data.expiresAt =
+        home.data.expiresAt instanceof Timestamp ? home.data.expiresAt.toDate() : home.data.expiresAt
+    }
+
+    return home
+  }
+
+  private plainToHomeCategoryGroup = (homeCategoryGroup: HomeCategoryGroup) => ({
+    category: Category.toInstance(homeCategoryGroup?.category),
+    products: homeCategoryGroup.products?.map((product) => Product.toInstance(product)),
+  })
+}

package/src/infra/firebase/firestore/repositories/shop-settings/index.ts

@@ -0,0 +1,3 @@
+export * from './home-firestore.repository'
+export * from './shop-menu-firestore.repository'
+export * from './shop-settings-firestore.repository'

package/src/infra/firebase/firestore/repositories/shop-settings/shop-menu-firestore.repository.ts

@@ -0,0 +1,22 @@
+import { ShopMenu, ShopMenuRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class ShopMenuFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<ShopMenu>(Base)))
+  implements ShopMenuRepository
+{
+  constructor({
+    firestore,
+    interceptors,
+    cache,
+  }: Pick<FirestoreConstructorParams<ShopMenu>, 'firestore' | 'interceptors' | 'cache'>) {
+    super({
+      firestore,
+      collectionName: 'shopMenus',
+      model: ShopMenu,
+      interceptors,
+      cache,
+    })
+  }
+}

package/src/infra/firebase/firestore/repositories/shop-settings/shop-settings-firestore.repository.ts

@@ -0,0 +1,22 @@
+import { ShopSettings, ShopSettingsRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+
+export class ShopSettingsFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<ShopSettings>(Base)))
+  implements ShopSettingsRepository
+{
+  constructor({
+    firestore,
+    interceptors,
+    cache,
+  }: Pick<FirestoreConstructorParams<ShopSettings>, 'firestore' | 'interceptors' | 'cache'>) {
+    super({
+      firestore,
+      collectionName: 'shopSettings',
+      model: ShopSettings,
+      interceptors,
+      cache,
+    })
+  }
+}