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

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

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

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

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