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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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