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

package/src/infra/hasura-graphql/mixins/helpers/update/hasura-update-variables.helper.ts

@@ -0,0 +1,72 @@
+import {
+  ModelBaseStructure,
+  NonFunctionAndIdentifierProperties,
+  NonFunctionAndIdentifierPropertyNames,
+} from '../../../../../domain'
+import { isNil } from '../../../../../utils'
+import { HasuraGraphQLFields } from '../../../types'
+import { AttributeOptionHelper } from '../attribute-option.helper'
+
+export class HasuraUpdateVariablesHelper {
+  static getUpdateModelKeys<MBase extends ModelBaseStructure<MBase>>(
+    data: Partial<MBase>,
+    model: any,
+    fields: any,
+  ): NonFunctionAndIdentifierProperties<MBase> {
+    const instance = model.toInstance(data)
+
+    return model.identifiersFields.reduce((ids: any, identifier: any) => {
+      const identifierBinded: Extract<
+        NonFunctionAndIdentifierPropertyNames<MBase>,
+        MBase['identifiersFields'][number]
+      > = identifier
+
+      if (isNil(instance.identifier[identifierBinded])) return ids
+
+      const columnOption = AttributeOptionHelper.FindByAttribute<MBase, NonFunctionAndIdentifierPropertyNames<MBase>>(
+        identifierBinded,
+        fields,
+      )
+      const value = columnOption?.to?.(data[identifierBinded], instance) || data[columnOption.attributeName]
+
+      return {
+        ...ids,
+        [columnOption.columnName]: value,
+      }
+    }, {} as NonFunctionAndIdentifierProperties<MBase>)
+  }
+
+  static getIdentifierFields<MBase extends ModelBaseStructure<MBase>>(
+    model: any,
+    fields: any,
+  ): HasuraGraphQLFields<MBase> {
+    return model.identifiersFields.map(
+      (field: any) => AttributeOptionHelper.FindByAttribute(field, fields).columnName,
+    ) as HasuraGraphQLFields<MBase>
+  }
+
+  static buildMutationVariables<MBase extends ModelBaseStructure<MBase>>(params: {
+    plainData: Partial<MBase>
+    updateGraphQLObjectType: string
+    updateGraphQLPKType: string
+    convertDataToHasura: (data: any, isUpdate?: boolean) => any
+    getUpdateModelKeys: (data: Partial<MBase>) => NonFunctionAndIdentifierProperties<MBase>
+    model: any
+  }) {
+    const { plainData, updateGraphQLObjectType, updateGraphQLPKType, convertDataToHasura, getUpdateModelKeys, model } =
+      params
+
+    return {
+      _set: {
+        type: updateGraphQLObjectType,
+        value: convertDataToHasura(model.toInstance(plainData), true),
+        required: true,
+      },
+      pk_columns: {
+        type: updateGraphQLPKType,
+        value: getUpdateModelKeys(plainData),
+        required: true,
+      },
+    }
+  }
+}

package/src/infra/hasura-graphql/mixins/helpers/update/index.ts

@@ -0,0 +1,3 @@
+export { HasuraUpdateDataHelper } from './hasura-update-data.helper'
+export { HasuraUpdateOperationsHelper, UpdateOperationsParams } from './hasura-update-operations.helper'
+export { HasuraUpdateVariablesHelper } from './hasura-update-variables.helper'

package/src/infra/hasura-graphql/mixins/index.ts

@@ -0,0 +1,7 @@
+export * from './with-create-hasura-graphql.mixin'
+export * from './with-delete-hasura-graphql.mixin'
+export * from './with-hasura-graphql.mixin'
+export * from './with-update-hasura-graphql.mixin'
+export * from './with-get-hasura-graphql.mixin'
+export * from './with-find-hasura-graphql.mixin'
+export * from './with-crud-hasura-graphql.mixin'

package/src/infra/hasura-graphql/mixins/with-create-hasura-graphql.mixin.ts

@@ -0,0 +1,17 @@
+import { CreateRepository, ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import { CreateConstructorParams, createCreateHasuraGraphQLClass } from './factories'
+
+export const withCreateHasuraGraphQL = <
+  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
+  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
+>(
+  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,
+): MixinCtor<
+  GraphQLRepository<MBase> & InstanceType<TMixinBase> & CreateRepository<MBase>,
+  MergeConstructorParams<[CreateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>
+> => {
+  return createCreateHasuraGraphQLClass(MixinBase) as any
+}

package/src/infra/hasura-graphql/mixins/with-crud-hasura-graphql.mixin.ts

@@ -0,0 +1,46 @@
+import { CrudRepository, ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import { CreateConstructorParams, DeleteConstructorParams, GetConstructorParams } from './factories'
+import { withCreateHasuraGraphQL } from './with-create-hasura-graphql.mixin'
+import { withDeleteHasuraGraphQL } from './with-delete-hasura-graphql.mixin'
+import { withFindHasuraGraphQL } from './with-find-hasura-graphql.mixin'
+import { withGetHasuraGraphQL } from './with-get-hasura-graphql.mixin'
+import { HasuraConstructorParams } from './with-hasura-graphql.mixin'
+import {
+  UpdateConstructorParams,
+  UpdateHasuraGraphQLRepositoryType,
+  withUpdateHasuraGraphQL,
+} from './with-update-hasura-graphql.mixin'
+
+export const withCrudHasuraGraphQL = <
+  TBase extends ModelBaseStructure<TBase, TBase['identifiersFields'][number]>,
+  Repository = CrudRepository<TBase>,
+  TMixinBase extends MixinCtor = MixinCtor,
+>(
+  MixinBase: MixinCtor<GraphQLRepository<TBase>> & TMixinBase,
+): MixinCtor<
+  GraphQLRepository<TBase> & Repository & UpdateHasuraGraphQLRepositoryType<TBase>,
+  MergeConstructorParams<
+    [
+      HasuraConstructorParams<TBase> &
+        CreateConstructorParams &
+        DeleteConstructorParams &
+        GetConstructorParams &
+        UpdateConstructorParams,
+      ...any[],
+    ],
+    ConstructorParameters<TMixinBase>
+  >
+> => {
+  return class CrudHasuraGraphQLMixin
+    extends withUpdateHasuraGraphQL(
+      withGetHasuraGraphQL(
+        withFindHasuraGraphQL(
+          withDeleteHasuraGraphQL(withCreateHasuraGraphQL(MixinBase as MixinCtor<GraphQLRepository<TBase>>)),
+        ),
+      ),
+    )
+    implements CrudRepository<TBase> {} as any
+}

package/src/infra/hasura-graphql/mixins/with-delete-hasura-graphql.mixin.ts

@@ -0,0 +1,17 @@
+import { DeleteRepository, ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import { DeleteConstructorParams, createDeleteHasuraGraphQLClass } from './factories'
+
+export const withDeleteHasuraGraphQL = <
+  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
+  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
+>(
+  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,
+): MixinCtor<
+  GraphQLRepository<MBase> & DeleteRepository<MBase> & InstanceType<TMixinBase>,
+  MergeConstructorParams<[DeleteConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>
+> => {
+  return createDeleteHasuraGraphQLClass(MixinBase) as any
+}

package/src/infra/hasura-graphql/mixins/with-find-hasura-graphql.mixin.ts

@@ -0,0 +1,17 @@
+import { FindRepository, ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import { createFindHasuraGraphQLClass } from './factories/find-hasura-class.factory'
+
+export const withFindHasuraGraphQL = <
+  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
+  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
+>(
+  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,
+): MixinCtor<
+  GraphQLRepository<MBase> & FindRepository<MBase> & InstanceType<TMixinBase>,
+  MergeConstructorParams<[...any[]], ConstructorParameters<TMixinBase>>
+> => {
+  return createFindHasuraGraphQLClass(MixinBase) as any
+}

package/src/infra/hasura-graphql/mixins/with-get-hasura-graphql.mixin.ts

@@ -0,0 +1,17 @@
+import { GetRepository, ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import { GetConstructorParams, createGetHasuraGraphQLClass } from './factories'
+
+export const withGetHasuraGraphQL = <
+  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
+  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
+>(
+  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,
+): MixinCtor<
+  GraphQLRepository<MBase> & GetRepository<MBase> & InstanceType<TMixinBase>,
+  MergeConstructorParams<[GetConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>
+> => {
+  return createGetHasuraGraphQLClass(MixinBase) as any
+}

package/src/infra/hasura-graphql/mixins/with-hasura-graphql.mixin.ts

@@ -0,0 +1,20 @@
+import { ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import {
+  createHasuraGraphQLClass,
+  HasuraConstructorParams,
+  HasuraGraphQLInterceptors,
+} from './factories/hasura-graphql-class.factory'
+
+export { HasuraConstructorParams, HasuraGraphQLInterceptors }
+
+export const withHasuraGraphQL = <
+  MBase extends ModelBaseStructure<MBase, MBase['identifiersFields'][number]>,
+  T extends MixinCtor = MixinCtor,
+>(
+  MixinBase: T,
+): MixinCtor<GraphQLRepository<MBase>, MergeConstructorParams<any[], HasuraConstructorParams<MBase>[]>> => {
+  return createHasuraGraphQLClass(MixinBase) as any
+}

package/src/infra/hasura-graphql/mixins/with-update-hasura-graphql.mixin.ts

@@ -0,0 +1,23 @@
+import { ModelBaseStructure } from '../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../utils'
+import { GraphQLRepository } from '../types'
+
+import {
+  createUpdateHasuraGraphQLClass,
+  UpdateConstructorParams,
+  UpdateHasuraGraphQLRepositoryType,
+} from './factories/update-hasura-class.factory'
+
+export { UpdateConstructorParams, UpdateHasuraGraphQLRepositoryType }
+
+export const withUpdateHasuraGraphQL = <
+  MBase extends ModelBaseStructure<MBase>,
+  TMixinBase extends MixinCtor<GraphQLRepository<MBase>>,
+>(
+  MixinBase: MixinCtor<GraphQLRepository<MBase>> & TMixinBase,
+): MixinCtor<
+  GraphQLRepository<MBase> & UpdateHasuraGraphQLRepositoryType<MBase> & InstanceType<TMixinBase>,
+  MergeConstructorParams<[UpdateConstructorParams, ...any[]], ConstructorParameters<TMixinBase>>
+> => {
+  return createUpdateHasuraGraphQLClass(MixinBase) as any
+}

package/src/infra/hasura-graphql/models/category-hasura-graphql.ts

@@ -0,0 +1,7 @@
+import { Category } from '../../../domain'
+
+export class CategoryHasuraGraphQL extends Category {
+  firestoreId?: string
+  brandCondition?: string
+  tagCondition?: string[]
+}

package/src/infra/hasura-graphql/models/index.ts

@@ -0,0 +1,5 @@
+export * from './category-hasura-graphql'
+export * from './kit-product-hasura-graphql'
+export * from './product-errors-hasura-graphql'
+export * from './product-hasura-graphql'
+export * from './variant-hasura-graphql'

package/src/infra/hasura-graphql/models/kit-product-hasura-graphql.ts

@@ -0,0 +1,11 @@
+import { Type } from 'class-transformer'
+
+import { KitProduct, Product } from '../../../domain'
+
+export class KitProductHasuraGraphQL extends KitProduct {
+  @Type(() => Product)
+  override kit: Product
+
+  @Type(() => Product)
+  override product: Product
+}

package/src/infra/hasura-graphql/models/product-errors-hasura-graphql.ts

@@ -0,0 +1,11 @@
+import { Type } from 'class-transformer'
+
+import { ProductErrors } from '../../../domain'
+
+import { ProductHasuraGraphQL } from './product-hasura-graphql'
+import { VariantHasuraGraphQL } from './variant-hasura-graphql'
+
+export class ProductErrorsHasuraGraphQL extends ProductErrors<ProductHasuraGraphQL | VariantHasuraGraphQL> {
+  @Type((type) => (+type.object['product']['productId'] ? VariantHasuraGraphQL : ProductHasuraGraphQL))
+  override product: ProductHasuraGraphQL | VariantHasuraGraphQL
+}

package/src/infra/hasura-graphql/models/product-hasura-graphql.ts

@@ -0,0 +1,24 @@
+import { Type } from 'class-transformer'
+
+import { Product } from '../../../domain'
+
+import { KitProductHasuraGraphQL } from './kit-product-hasura-graphql'
+
+export class ProductHasuraGraphQL extends Product {
+  firestoreId?: string
+  fullPrice?: number
+  subscriberDiscountPercentage?: number
+  subscriberPrice?: number
+  productId?: number
+  differentials?: string
+  whoMustUse?: string
+  howToUse?: string
+  brandDescription?: string
+  categoryId?: number
+  ingredients?: string
+  hasStock?: boolean
+  intGender?: number
+
+  @Type(() => KitProductHasuraGraphQL)
+  override kitProducts?: KitProductHasuraGraphQL[]
+}

package/src/infra/hasura-graphql/models/variant-hasura-graphql.ts

@@ -0,0 +1,9 @@
+import { Variant } from '../../../domain'
+
+export class VariantHasuraGraphQL extends Variant {
+  firestoreId?: string
+  fullPrice?: number
+  subscriberDiscountPercentage?: number
+  subscriberPrice?: number
+  hasStock?: boolean
+}

package/src/infra/hasura-graphql/models/wishlist-hasura-graphql.ts

@@ -0,0 +1,5 @@
+import { Wishlist } from '../../../domain'
+
+export class WishlistHasuraGraphQL extends Wishlist {
+  personHasPhoto?: boolean
+}

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

@@ -0,0 +1,49 @@
+import { CategoryCollectionChildren } from '../../../../domain'
+import { CategoryCollectionChildrenRepository } from '../../../../domain/catalog/repositories/category-collection-children.repository'
+import { Base } from '../../../../utils'
+import { HasuraConstructorParams, withCrudHasuraGraphQL, withHasuraGraphQL } from '../../mixins'
+
+export class CategoryCollectionChildrenHasuraGraphQLRepository
+  extends withCrudHasuraGraphQL(withHasuraGraphQL<CategoryCollectionChildren>(Base))
+  implements CategoryCollectionChildrenRepository
+{
+  constructor({
+    endpoint,
+    authOptions,
+    interceptors,
+    cache,
+  }: Pick<HasuraConstructorParams<CategoryCollectionChildren>, 'endpoint' | 'authOptions' | 'interceptors' | 'cache'>) {
+    super({
+      tableName: 'category_collection_children',
+      model: CategoryCollectionChildren,
+      endpoint,
+      authOptions,
+      interceptors,
+      fields: [
+        { collectionId: { columnName: 'collection_id' } },
+        { categoryId: { columnName: 'category_id' } },
+        'name',
+        'slug',
+        'reference',
+        { parentCollectionId: { columnName: 'parent_collection_id' } },
+        { parentCategoryId: { columnName: 'parent_category_id' } },
+        {
+          parent: {
+            columnName: 'parent',
+            foreignKeyColumn: { collectionId: 'parentCollectionId', categoryId: 'parentCategoryId' },
+            fields: [
+              { collectionId: { columnName: 'collection_id' } },
+              { categoryId: { columnName: 'category_id' } },
+              'name',
+              'slug',
+              'reference',
+              { parentCollectionId: { columnName: 'parent_collection_id' } },
+              { parentCategoryId: { columnName: 'parent_category_id' } },
+            ],
+          },
+        },
+      ],
+      cache,
+    })
+  }
+}

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 } },
+      },
+    })
+  }
+}