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

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

@@ -0,0 +1,429 @@
+import {
+  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,
+    })
+  }
+}

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

@@ -0,0 +1,97 @@
+import { CategoryProduct, CategoryProductRepository } from '../../../../domain'
+import { Base, DebugHelper } from '../../../../utils'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+
+export class CategoryProductHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<CategoryProduct>(Base))
+  implements CategoryProductRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<CategoryProduct>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'category_product',
+      model: CategoryProduct,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: [{ productId: { columnName: 'product_id' } }, { categoryId: { columnName: 'category_id' } }, 'order'],
+      cache,
+    })
+  }
+
+  async removeProductsFromCategory(categoryId: string, productIds: string[]): Promise<void> {
+    this.logger = DebugHelper.from(this, 'removeProductsFromCategory')
+
+    await this.mutation('delete_category_product', ['affected_rows'], {
+      where: {
+        type: 'category_product_bool_exp',
+        required: true,
+        value: {
+          product_id: { _in: productIds },
+          category_id: { _eq: categoryId },
+        },
+      },
+    })
+  }
+
+  async removeProductFromCategories(productId: string, categoryIds: string[]): Promise<void> {
+    this.logger = DebugHelper.from(this, 'removeProductFromCategories')
+
+    await this.mutation('delete_category_product', ['affected_rows'], {
+      where: {
+        type: 'category_product_bool_exp',
+        required: true,
+        value: {
+          product_id: { _eq: productId },
+          category_id: { _in: categoryIds },
+        },
+      },
+    })
+  }
+
+  async addProductsToCategory(categoryId: string, productIds: { productId: string; order: number }[]): Promise<void> {
+    this.logger = DebugHelper.from(this, 'addProductsToCategory')
+
+    await this.mutation('insert_category_product', ['affected_rows'], {
+      objects: {
+        type: '[category_product_insert_input!]',
+        required: true,
+        value: productIds.map(({ productId, order }) => ({
+          category_id: categoryId,
+          product_id: productId,
+          order,
+        })),
+      },
+      on_conflict: {
+        type: 'category_product_on_conflict',
+        required: true,
+        value: { constraint: 'category_product_pkey', update_columns: ['order'] },
+      },
+    })
+  }
+
+  async addProductToCategories(productId: string, categoryIds: string[]): Promise<void> {
+    this.logger = DebugHelper.from(this, 'addProductToCategories')
+
+    await this.mutation('insert_category_product', ['affected_rows'], {
+      objects: {
+        type: '[category_product_insert_input!]',
+        required: true,
+        value: categoryIds.map((categoryId) => ({
+          category_id: categoryId,
+          product_id: productId,
+          order: 0,
+        })),
+      },
+      on_conflict: {
+        type: 'category_product_on_conflict',
+        required: true,
+        value: { constraint: 'category_product_pkey' },
+      },
+    })
+  }
+}

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

@@ -0,0 +1,154 @@
+import { DeleteRepositoryParams, Filter, UpdateRepositoryParams } from '../../../../domain'
+import { FilterRepository } from '../../../../domain/catalog/repositories'
+import { Base, Log } from '../../../../utils'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+import { HasuraGraphQLFields } from '../../types'
+
+import { CategoryFilterHasuraGraphQLRepository } from './category-filter-hasura-graphql.repository'
+import { FilterOptionHasuraGraphQLRepository } from './filter-option-hasura-graphql.repository'
+
+const fieldsConfiguration: HasuraGraphQLFields<Filter> = [
+  'id',
+  'title',
+  'description',
+  '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' } },
+      ],
+    },
+  },
+  {
+    categories: {
+      columnName: 'categories',
+      foreignKeyColumn: { category_id: 'id' },
+      fields: [{ category: ['id', 'name', 'slug'] }],
+      bindPersistData: (value: Filter['categories']) => ({
+        categories: { data: value.map((filter) => ({ filter_id: filter.id })) },
+      }),
+      from: (categories: { category: { id: number; name: string; slug: string } }[]) =>
+        categories?.map((category) => category?.category) || [],
+    },
+  },
+]
+
+export class FilterHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<Filter>(Base))
+  implements FilterRepository
+{
+  constructor(
+    {
+      endpoint,
+      authOptions,
+      interceptors,
+      cache,
+    }: Pick<HasuraConstructorParams<Filter>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>,
+    private readonly filterOptionRepository: FilterOptionHasuraGraphQLRepository,
+    private readonly categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
+  ) {
+    super({
+      tableName: 'filter',
+      model: Filter,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: fieldsConfiguration,
+      cache,
+    })
+  }
+
+  override async update(params: UpdateRepositoryParams<Filter>): Promise<Filter> {
+    const { options, ...data } = params
+
+    const filter = await super.update(data)
+
+    filter.options = await this.updateOptions(+data.id, { options })
+
+    return filter
+  }
+
+  @Log()
+  async updateOptions(filterId: number, { options }: Pick<UpdateRepositoryParams<Filter>, 'options'>) {
+    if (!options) return []
+
+    if ('action' in options && options.action === 'remove' && options.value.length) {
+      for (let i = 0; i < options.value.length; i++) {
+        await this.filterOptionRepository.delete({ id: options.value[i].id })
+      }
+
+      return []
+    }
+
+    if ('action' in options && options.action === 'merge' && options.value.length) {
+      const filterOptions = []
+
+      for (let i = 0; i < options.value.length; i++) {
+        try {
+          const hasFilter = await this.filterOptionRepository.get({ id: options.value[i].id })
+
+          if (hasFilter) filterOptions.push(hasFilter)
+        } catch {
+          const newOption = await this.filterOptionRepository.create({ ...options.value[i], filterId })
+
+          filterOptions.push(newOption)
+        }
+      }
+
+      return filterOptions
+    }
+
+    if (Array.isArray(options) && options.length) {
+      const filterOptions = []
+
+      for (let i = 0; i < options.length; i++) {
+        try {
+          const hasFilter = await this.filterOptionRepository.get({ id: options[i].id })
+
+          if (hasFilter) filterOptions.push(hasFilter)
+        } catch {
+          const newOption = await this.filterOptionRepository.create({ ...options[i], filterId })
+
+          filterOptions.push(newOption)
+        }
+      }
+    }
+
+    return []
+  }
+
+  override async delete(params: DeleteRepositoryParams<Filter>): Promise<void> {
+    const { data: categoryFilters } = await this.categoryFilterRepository.find({
+      filters: {
+        filterId: params.id,
+      },
+    })
+
+    if (categoryFilters.length) throw new Error('Erro: o filtro está associado a uma ou mais categoria(s)')
+
+    await this.deleteOptions(+params.id)
+    await super.delete({ id: +params.id })
+
+    return
+  }
+
+  @Log()
+  async deleteOptions(filterId: number): Promise<void> {
+    await this.mutation('delete_filter_option', ['affected_rows'], {
+      where: {
+        type: 'filter_option_bool_exp',
+        required: true,
+        value: { filter_id: { _eq: filterId } },
+      },
+    })
+  }
+}