@infrab4a/connect 5.7.2 → 5.7.3

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

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

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