@infrab4a/connect 5.7.3 → 5.7.4

package/src/infra/hasura-graphql/repositories/catalog/category-filter-hasura-graphql.repository.ts

@@ -1,146 +0,0 @@
-import { CategoryFilter } from '../../../../domain'
-import { CategoryFilterRepository } from '../../../../domain/catalog/repositories'
-import { Base, DebugHelper } from '../../../../utils'
-import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
-import { HasuraGraphQLFields } from '../../types'
-
-const fieldsConfiguration: HasuraGraphQLFields<CategoryFilter> = [
-  'id',
-  { filterId: { columnName: 'filter_id' } },
-  { categoryId: { columnName: 'category_id' } },
-  {
-    filter: {
-      columnName: 'filter',
-      foreignKeyColumn: { id: 'filterId' },
-      fields: [
-        'id',
-        'description',
-        'title',
-        'slug',
-        'enabled',
-        { createdAt: { columnName: 'created_at' } },
-        { updatedAt: { columnName: 'updated_at' } },
-        {
-          options: {
-            columnName: 'options',
-            foreignKeyColumn: { filterId: 'id' },
-            fields: [
-              'id',
-              { filterId: { columnName: 'filter_id' } },
-              'description',
-              { createdAt: { columnName: 'created_at' } },
-              { updatedAt: { columnName: 'updated_at' } },
-            ],
-          },
-        },
-      ],
-    },
-  },
-  {
-    category: {
-      columnName: 'category',
-      foreignKeyColumn: { id: 'categoryId' },
-      fields: [
-        'id',
-        'description',
-        {
-          products: {
-            columnName: 'products',
-            fields: ['product_id'],
-            from: (value: { product_id: number }[]) => value.map((product) => product.product_id.toString()),
-            to: (productIds: string[]) =>
-              productIds.map((productId) => ({
-                product_id: +productId,
-              })),
-          },
-        },
-        {
-          childrenProducts: {
-            columnName: 'children_products',
-            foreignKeyColumn: { category_id: 'id' },
-            fields: [
-              'id',
-              'name',
-              'slug',
-              {
-                categories: {
-                  columnName: 'categories',
-                  fields: ['category_id'],
-                  bindPersistData: (value) => ({
-                    categories: { data: value.map((category: string) => ({ category_id: +category })) },
-                  }),
-                  to: (categories: string[]) => categories.map((categoryId) => +categoryId),
-                  from: (categories: { category_id: number }[]) =>
-                    categories?.map((category) => category?.category_id?.toString()) || [],
-                },
-              },
-            ],
-          },
-        },
-      ],
-    },
-  },
-]
-
-export class CategoryFilterHasuraGraphQLRepository
-  extends withCrudHasuraGraphQL(withHasuraGraphQL<CategoryFilter>(Base))
-  implements CategoryFilterRepository
-{
-  constructor({
-    endpoint,
-    authOptions,
-    interceptors,
-    cache,
-  }: Pick<HasuraConstructorParams<CategoryFilter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
-    super({
-      tableName: 'category_filter',
-      model: CategoryFilter,
-      endpoint,
-      authOptions,
-      interceptors,
-      fields: fieldsConfiguration,
-      cache,
-    })
-  }
-
-  async addFiltersToCategory(categoryId: number, filterIds: number[]): Promise<void> {
-    this.logger = DebugHelper.from(this, 'addFiltersToCategory')
-
-    await this.mutation('insert_category_filter', ['affected_rows'], {
-      objects: {
-        type: '[category_filter_insert_input!]',
-        required: true,
-        value: filterIds.map((filterId) => ({ category_id: categoryId, filter_id: filterId })),
-      },
-      on_conflict: {
-        type: 'category_filter_on_conflict',
-        required: true,
-        value: { constraint: 'category_filter_category_id_filter_id_key' },
-      },
-    })
-  }
-
-  deleteByCategory(categoryId: number): Promise<any> {
-    this.logger = DebugHelper.from(this, 'deleteByCategory')
-
-    return this.mutation('delete_category_filter', ['affected_rows'], {
-      where: {
-        type: 'category_filter_bool_exp',
-        required: true,
-        value: { category_id: { _eq: categoryId } },
-      },
-    })
-  }
-
-  deleteByCategoryAndFilter(categoryId: number, filterId: number): Promise<any> {
-    this.logger = DebugHelper.from(this, 'deleteByCategoryAndFilter')
-
-    return this.mutation('delete_category_filter', ['affected_rows'], {
-      where: {
-        type: 'category_filter_bool_exp',
-        required: true,
-        value: { category_id: { _eq: categoryId }, filter_id: { _eq: filterId } },
-      },
-    })
-  }
-}

package/src/infra/hasura-graphql/repositories/catalog/category-hasura-graphql.repository.ts

@@ -1,451 +0,0 @@
-import {
-  BrandsShopMenu,
-  Category,
-  CategoryMetadata,
-  CategoryRepository,
-  CreateRepositoryParams,
-  Filter,
-  GetRepositoryParams,
-  Product,
-  RepositoryCacheOptions,
-  Shops,
-  UpdateRepositoryParams,
-  Where,
-} from '../../../../domain'
-import { DuplicatedResultsError, NotFoundError } from '../../../../errors'
-import { Base, Log, sortBy } from '../../../../utils'
-import { HasuraGraphQLColumnType } from '../../enums'
-import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
-import { CategoryHasuraGraphQL } from '../../models'
-import { HasuraGraphQLFields } from '../../types'
-
-import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository'
-import {
-  CategoriesForHomeParams,
-  CategoryFilterOperationsHelper,
-  CategoryHomeOperationsHelper,
-  CategoryMountOperationsHelper,
-  MountCategoryParams,
-} from './helpers'
-import { ProductHasuraGraphQLRepository } from './product-hasura-graphql.repository'
-
-const fieldsConfiguration: HasuraGraphQLFields<CategoryHasuraGraphQL> = [
-  { id: { columnName: 'id', to: (value: string) => +value, from: (value: number) => value.toString() } },
-  { firestoreId: { columnName: 'firestore_id' } },
-  'name',
-  'description',
-  'image',
-  { images: { columnName: 'images', type: HasuraGraphQLColumnType.Jsonb } },
-  'published',
-  'shop',
-  { shops: { columnName: 'shops', type: HasuraGraphQLColumnType.Jsonb } },
-  'slug',
-  { brandEquity: { columnName: 'brand_equity' } },
-  { brandCategory: { columnName: 'brand_category' } },
-  { brandCategoryBanner: { columnName: 'brand_banner' } },
-  { brandCategoryBannerMobile: { columnName: 'brand_banner_mobile' } },
-  { brandLogo: { columnName: 'brand_logo' } },
-  { brandCondition: { columnName: 'brand_condition' } },
-  {
-    conditions: {
-      columnName: 'tag_condition',
-      type: HasuraGraphQLColumnType.Jsonb,
-      from: (tags: unknown, row: Record<'brand_condition', any>) => ({
-        brand: row.brand_condition,
-        tags: Array.isArray(tags) ? tags : [],
-      }),
-      bindPersistData: (value: CategoryHasuraGraphQL['conditions']) => {
-        return {
-          brand_condition: value.brand,
-          tag_condition: value?.tags || [],
-        }
-      },
-      bindFindFilter: (sentence: any) => {
-        return {
-          ...(sentence.brand ? { brand_condition: sentence.brand } : {}),
-          ...(sentence.tags ? { tag_condition: sentence.tags } : {}),
-        }
-      },
-    },
-  },
-  {
-    filters: {
-      columnName: 'filters',
-      foreignKeyColumn: { filter_id: 'id' },
-      fields: [{ filter: ['id', 'title', 'description', 'slug', 'enabled'] }],
-      bindPersistData: (value: CategoryHasuraGraphQL['filters']) => ({
-        filters: { data: value.map((filter) => ({ filter_id: filter.id })) },
-      }),
-      from: (filters: { filter: { id: number; description: string; slug: string; enabled: boolean } }[]) =>
-        filters?.map((filter) => filter?.filter).filter((filter) => filter.enabled) || [],
-    },
-  },
-  { createdAt: { columnName: 'created_at' } },
-  { updatedAt: { columnName: 'updated_at' } },
-  {
-    products: {
-      columnName: 'products',
-      fields: ['product_id', 'order'],
-      from: (value: { product_id: number; order: number }[]) =>
-        sortBy(value, (row) => row.order).map((product) => product.product_id.toString()),
-      to: (productIds: string[]) =>
-        productIds.map((productId, index) => ({
-          product_id: +productId,
-          order: ++index,
-        })),
-    },
-  },
-  {
-    metadata: {
-      columnName: 'metadata',
-      fields: ['shop', 'title', 'description'],
-      bindPersistData: (value: CategoryHasuraGraphQL['metadata']) => ({
-        metadata: { data: value },
-      }),
-    },
-  },
-  {
-    metadatas: {
-      columnName: 'metadatas',
-      fields: ['shop', 'title', 'description'],
-      bindPersistData: (value: CategoryHasuraGraphQL['metadatas']) => ({
-        metadatas: { data: value },
-      }),
-    },
-  },
-  { isCollection: { columnName: 'is_collection' } },
-  { isWishlist: { columnName: 'is_wishlist' } },
-  'reference',
-  { parentId: { columnName: 'parent_id' } },
-  {
-    parent: {
-      columnName: 'parent',
-      foreignKeyColumn: { id: 'parentId' },
-      fields: ['id', 'name', 'reference', 'slug'],
-    },
-  },
-  'theme',
-  { bannerUrl: { columnName: 'banner_url' } },
-  { mostRelevant: { columnName: 'most_relevant', type: HasuraGraphQLColumnType.Jsonb } },
-  { mostRelevants: { columnName: 'most_relevants', type: HasuraGraphQLColumnType.Jsonb } },
-]
-
-export class CategoryHasuraGraphQLRepository
-  extends withCrudHasuraGraphQL(withHasuraGraphQL<CategoryHasuraGraphQL>(Base))
-  implements CategoryRepository
-{
-  constructor(
-    {
-      endpoint,
-      authOptions,
-      interceptors,
-      cache,
-    }: Pick<HasuraConstructorParams<CategoryHasuraGraphQL>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>,
-    private readonly productRepository: ProductHasuraGraphQLRepository,
-    private readonly categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
-  ) {
-    super({
-      tableName: 'category',
-      model: CategoryHasuraGraphQL,
-      endpoint,
-      authOptions,
-      interceptors,
-      cache,
-      fields: fieldsConfiguration,
-    })
-  }
-
-  override async create(params: CreateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL> {
-    const { images, mostRelevants, metadatas, ...data } = params
-
-    return super.create({
-      ...data,
-      isWishlist: false,
-      metadatas: metadatas || [{ shop: null, description: null, title: null }],
-      mostRelevants: mostRelevants || {
-        [Shops.GLAMSHOP]: null,
-        [Shops.MENSMARKET]: null,
-      },
-      images: images || {
-        [Shops.GLAMSHOP]: {
-          brandBanner: null,
-          brandBannerMobile: null,
-          image: null,
-        },
-        [Shops.MENSMARKET]: {
-          brandBanner: null,
-          brandBannerMobile: null,
-          image: null,
-        },
-      },
-    })
-  }
-
-  override async get(
-    identifiers: GetRepositoryParams<CategoryHasuraGraphQL>,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<CategoryHasuraGraphQL> {
-    const id = await this.getId(identifiers.id as string)
-
-    return super.get({ id }, optionsCache)
-  }
-
-  override async update(params: UpdateRepositoryParams<CategoryHasuraGraphQL>): Promise<CategoryHasuraGraphQL> {
-    const { id, products, metadatas, filters, ...data } = params
-
-    const categoryId = +(await this.getId(id as string))
-
-    const [category] = await Promise.all([
-      super.update({ id: categoryId?.toString(), ...data }),
-      ...(products ? [this.updateProducts(categoryId, { products })] : []),
-      ...(metadatas ? [this.updateMetadata(categoryId, { metadatas })] : []),
-      ...(filters ? [this.updateFilters(categoryId, { filters })] : []),
-    ])
-
-    return category
-  }
-
-  @Log()
-  async getCategoryBySlug(
-    slug: string,
-    shop: Shops,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<Category> {
-    if (!slug) return
-
-    const { data } = await this.find(
-      {
-        filters: {
-          slug,
-          shops: { operator: Where.IN, value: [shop] },
-          published: true,
-        },
-        limits: { limit: 1 },
-        options: { enableCount: false },
-      },
-      optionsCache,
-    )
-
-    if (!data.length) throw new NotFoundError(`Category with slug ${slug} not found`)
-
-    if (data.length > 1) throw new DuplicatedResultsError('Query returned duplicated values')
-
-    return data.shift()
-  }
-
-  @Log()
-  async getCategoryByShop(shop: string, optionsCache?: { cache?: RepositoryCacheOptions }): Promise<Category[]> {
-    if (!shop) return
-
-    const { data } = await this.find(
-      {
-        filters: {
-          shops: { operator: Where.IN, value: [shop] },
-          published: true,
-          isWishlist: false,
-        },
-        options: { enableCount: false },
-      },
-      optionsCache,
-    )
-
-    return data
-  }
-
-  @Log()
-  async getCategoriesForHome(params: CategoriesForHomeParams): Promise<{ category: Category; products: Product[] }[]> {
-    const { categoryIds, shop, limit = 4, optionsCache } = params
-
-    if (!categoryIds?.length) return []
-
-    const { firestore, hasura } = CategoryHomeOperationsHelper.separateCategoryIds(categoryIds)
-    const categories = []
-
-    if (firestore.length) {
-      const firestoreCategories = await CategoryHomeOperationsHelper.fetchFirestoreCategories(
-        firestore,
-        this.find.bind(this),
-        optionsCache,
-      )
-
-      categories.push(...firestoreCategories)
-    }
-
-    if (hasura.length) {
-      const hasuraCategories = await CategoryHomeOperationsHelper.fetchHasuraCategories(
-        hasura,
-        this.find.bind(this),
-        optionsCache,
-      )
-
-      categories.push(...hasuraCategories)
-    }
-
-    if (!categories.length) return []
-
-    return CategoryHomeOperationsHelper.buildHomeSections(categories, this.mountCategory.bind(this), {
-      shop,
-      limit,
-      optionsCache,
-    })
-  }
-
-  @Log()
-  async mountCategory(params: MountCategoryParams): Promise<Product[]> {
-    return CategoryMountOperationsHelper.executeMount(params, {
-      productRepository: this.productRepository,
-      cacheAdapter: this.cache?.cacheAdapter,
-      defaultCacheTtl: this.cache?.ttlDefault,
-      logger: this.logger,
-    })
-  }
-
-  @Log()
-  public async getChildren(parentId: number, _optionsCache?: { cache?: RepositoryCacheOptions }): Promise<Category[]> {
-    const { category_tree: categoryTree } = await this.query(
-      'category_tree',
-      ['id', 'name', 'parent_id', 'slug', 'reference', 'published', 'shops'],
-      {
-        args: {
-          type: 'category_tree_args',
-          value: { parentid: parentId },
-          required: true,
-        },
-      },
-    )
-
-    return categoryTree.map((category: Record<string, any>) => Category.toInstance(category))
-  }
-
-  @Log()
-  public async isChild(id: number, parentId: number): Promise<boolean> {
-    const categoryTree = await this.getChildren(parentId)
-
-    return categoryTree.some((c) => c.id == id.toString())
-  }
-
-  private async getId(id: string): Promise<string> {
-    if (!Number.isNaN(+id)) return id
-
-    const { data } = await this.find({ filters: { firestoreId: id }, options: { enableCount: false } })
-
-    if (data?.[0]?.id) return data?.[0]?.id
-
-    throw new NotFoundError(`Category with id ${id} not found`)
-  }
-
-  private async updateProducts(
-    categoryId: number,
-    { products }: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'products'>,
-  ): Promise<CategoryHasuraGraphQL['products']> {
-    if ('action' in products && products.action === 'remove') {
-      await this.mutation('delete_category_product', ['affected_rows'], {
-        where: {
-          type: 'category_product_bool_exp',
-          required: true,
-          value: { category_id: { _eq: categoryId } },
-        },
-      })
-
-      return []
-    }
-
-    const productsOrder = (products as String[]).map((product, index) => {
-      return {
-        id: product,
-        order: index,
-      }
-    })
-
-    const updateQueries = productsOrder.map((product: any) => ({
-      where: {
-        category_id: { _eq: categoryId },
-        product_id: { _eq: product.id },
-      },
-      _set: {
-        order: product.order,
-      },
-    }))
-
-    await this.mutation('update_category_product_many', ['affected_rows'], {
-      updates: {
-        value: updateQueries,
-        type: '[category_product_updates!]',
-        required: true,
-      },
-    })
-
-    const plainData = this.paramsToPlain({ products })
-
-    return plainData.products
-  }
-
-  private async updateMetadata(
-    categoryId: number,
-    { metadatas }: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'metadatas'>,
-  ): Promise<CategoryMetadata[]> {
-    if (Array.isArray(metadatas) && !metadatas.length) return []
-
-    if (Array.isArray(metadatas) && metadatas.length) {
-      await this.mutation('delete_category_metadata', ['affected_rows'], {
-        where: {
-          type: 'category_metadata_bool_exp',
-          required: true,
-          value: { category_id: { _eq: categoryId } },
-        },
-      })
-
-      await this.mutation('insert_category_metadata', ['affected_rows'], {
-        objects: {
-          type: '[category_metadata_insert_input!]',
-          required: true,
-          value: metadatas.map((m) => ({ category_id: categoryId, ...m })),
-        },
-      })
-
-      return metadatas
-    }
-
-    if ('action' in metadatas && metadatas.action === 'remove' && metadatas.value.length) {
-      await this.mutation('delete_category_metadata', ['affected_rows'], {
-        where: {
-          type: 'category_metadata_bool_exp',
-          required: true,
-          value: { category_id: { _eq: categoryId } },
-        },
-      })
-
-      return []
-    }
-  }
-
-  private async updateFilters(
-    categoryId: number,
-    { filters }: Pick<UpdateRepositoryParams<CategoryHasuraGraphQL>, 'filters'>,
-  ): Promise<Filter[]> {
-    return CategoryFilterOperationsHelper.executeUpdate(categoryId, filters, {
-      categoryFilterRepository: this.categoryFilterRepository,
-    })
-  }
-
-  async getBrandsWithProducts(): Promise<Category[]> {
-    const fields = ['id', 'name', 'slug', 'brand_category', 'published', 'images']
-    const {
-      brands_with_products_query: data,
-    }: {
-      brands_with_products_query: BrandsShopMenu[]
-    } = await this.query('brands_with_products_query', fields)
-
-    return data.map((brand) =>
-      Category.toInstance({
-        id: brand.id,
-        name: brand.name,
-        slug: brand.slug,
-        brandCategory: brand.brand_category,
-        shops: brand.shops,
-        published: brand.published,
-        images: brand.images,
-      }),
-    )
-  }
-}