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

package/src/infra/firebase/auth/types/firebase-user-with-id.type.ts

@@ -0,0 +1,5 @@
+import { User } from 'firebase/auth'
+
+import { BasicUserData } from '../../../../domain'
+
+export type FirebaseUserWithId = BasicUserData & User & { id: string }

package/src/infra/firebase/auth/types/index.ts

@@ -0,0 +1 @@
+export * from './firebase-user-with-id.type'

package/src/infra/firebase/firestore/enums/firestore-field-type.enum.ts

@@ -0,0 +1,8 @@
+export enum FirestoreFieldType {
+  String = 'string',
+  Number = 'number',
+  Boolean = 'boolean',
+  Timestamp = 'timestamp',
+  Array = 'array',
+  Map = 'map',
+}

package/src/infra/firebase/firestore/enums/index.ts

@@ -0,0 +1 @@
+export * from './firestore-field-type.enum'

package/src/infra/firebase/firestore/index.ts

@@ -0,0 +1,5 @@
+export * from './mixins'
+export * from './repositories'
+export * from './services'
+export * from './types'
+export * from './vo'

package/src/infra/firebase/firestore/mixins/helpers/cache-key-generator.helper.ts

@@ -0,0 +1,27 @@
+import { ModelBaseStructure } from '../../../../../domain'
+import { MD5GeneratorHelper } from '../../../../hasura-graphql/mixins/helpers'
+
+export class FirestoreCacheKeyGeneratorHelper {
+  static generateGetCacheKey<Model extends ModelBaseStructure<Model>>(
+    model: { name: string },
+    identifiers: Record<string, any>,
+  ): string {
+    const sortedEntries = Object.entries(identifiers).sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+    const keyParts: string[] = []
+
+    for (const [key, value] of sortedEntries) {
+      keyParts.push(`${key}:${value}`)
+    }
+
+    return `${model.name.toLowerCase()}:get:${keyParts.join(':')}`
+  }
+
+  static generateFindCacheKey<Model extends ModelBaseStructure<Model>>(
+    model: { name: string },
+    findParams: any,
+  ): string {
+    const md5 = MD5GeneratorHelper.generateMD5(findParams)
+
+    return `${model.name.toLowerCase()}:find:${md5}`
+  }
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-cache.helper.ts

@@ -0,0 +1,111 @@
+import { BaseModelBuilder, ModelBaseStructure, RepositoryCacheOptions } from '../../../../../domain'
+import { deserialize, serialize } from '../../../../../utils'
+
+import { FirestoreCacheKeyGeneratorHelper } from './cache-key-generator.helper'
+
+type CacheConfig = {
+  cacheAdapter?: any
+  ttlDefault?: number
+}
+
+type CacheGetParams<TBase extends ModelBaseStructure<TBase>> = {
+  model: BaseModelBuilder<TBase>
+  identifiers: any
+  options?: { cache?: RepositoryCacheOptions }
+  logger: any
+  req: any
+}
+
+type CacheSaveParams = {
+  cacheKey: string
+  data: any
+  expirationInSeconds?: number
+  logger: any
+  req?: any
+}
+
+type CacheRemoveParams = {
+  cacheKey: string
+  logger: any
+}
+
+export class FirestoreCacheHelper {
+  static async getCachedData<TBase extends ModelBaseStructure<TBase>>(
+    cache: CacheConfig | undefined,
+    params: CacheGetParams<TBase>,
+  ): Promise<any | null> {
+    const { model, identifiers, options, logger, req } = params
+
+    if (!cache?.cacheAdapter || options?.cache?.enabled === false) return null
+
+    const cacheKey = FirestoreCacheKeyGeneratorHelper.generateGetCacheKey(model, identifiers)
+    const cachedData = await cache.cacheAdapter.get(cacheKey)
+
+    if (cachedData) {
+      logger.log({ req, res: 'Dados recuperados do cache', cacheKey })
+
+      return deserialize(cachedData)
+    }
+
+    return null
+  }
+
+  static async getCachedFindData<TBase extends ModelBaseStructure<TBase>>(
+    cache: CacheConfig | undefined,
+    params: { model: BaseModelBuilder<TBase>; find: any; options?: { cache?: RepositoryCacheOptions }; logger: any },
+  ): Promise<any | null> {
+    const { model, find, options, logger } = params
+
+    if (!cache?.cacheAdapter || options?.cache?.enabled === false) return null
+
+    const cacheKey = FirestoreCacheKeyGeneratorHelper.generateFindCacheKey(model, find)
+    const cachedData = await cache.cacheAdapter.get(cacheKey)
+
+    if (cachedData) {
+      logger.log(`Dados recuperados do cache: ${cacheKey}`)
+
+      return deserialize(cachedData)
+    }
+
+    return null
+  }
+
+  static async saveCacheData(cache: CacheConfig | undefined, params: CacheSaveParams): Promise<void> {
+    const { cacheKey, data, expirationInSeconds, logger, req } = params
+
+    if (!cache?.cacheAdapter) return
+
+    await cache.cacheAdapter.set({
+      key: cacheKey,
+      data: serialize(data),
+      expirationInSeconds: expirationInSeconds || cache.ttlDefault,
+    })
+
+    const logData = req ? { req, message: 'Dados salvos no cache', cacheKey } : `Dados salvos no cache: ${cacheKey}`
+
+    logger.log(logData)
+  }
+
+  static async removeCacheData(cache: CacheConfig | undefined, params: CacheRemoveParams): Promise<void> {
+    const { cacheKey, logger } = params
+
+    if (!cache?.cacheAdapter) return
+
+    await cache.cacheAdapter.remove(cacheKey)
+    logger.log(`Cache removido: ${cacheKey}`)
+  }
+
+  static generateGetCacheKey<TBase extends ModelBaseStructure<TBase>>(
+    model: BaseModelBuilder<TBase>,
+    identifiers: any,
+  ): string {
+    return FirestoreCacheKeyGeneratorHelper.generateGetCacheKey(model, identifiers)
+  }
+
+  static generateFindCacheKey<TBase extends ModelBaseStructure<TBase>>(
+    model: BaseModelBuilder<TBase>,
+    findParams: any,
+  ): string {
+    return FirestoreCacheKeyGeneratorHelper.generateFindCacheKey(model, findParams)
+  }
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-data-converter.helper.ts

@@ -0,0 +1,47 @@
+import { ModelBaseStructure, NonFunctionAndIdentifierPropertiesWithNoPartial } from '../../../../../domain'
+
+export class FirestoreDataConverterHelper {
+  static isValidObjectForDateBinding(data: any): boolean {
+    return (
+      data &&
+      !Array.isArray(data) &&
+      typeof data === 'object' &&
+      data?.constructor.name !== 'Timestamp' &&
+      !('seconds' in data)
+    )
+  }
+
+  static convertToDate(data: any, keyName: string): any {
+    if (data?.constructor.name === 'Timestamp') return data.toDate()
+
+    if (data && typeof data === 'object' && 'seconds' in data) return new Date(data.seconds * 1000)
+
+    if (typeof data === 'number' && ['createdAt', 'updatedAt'].includes(keyName)) return new Date(data)
+
+    return data
+  }
+
+  static processArrayData(arrayData: any[]): any[] {
+    return arrayData.map((element: any) =>
+      this.isValidObjectForDateBinding(element) ? this.bindAllDateFromObject(element) : element,
+    )
+  }
+
+  static bindAllDateFromObject<TBase extends ModelBaseStructure<TBase> = any>(
+    data: Record<string, any>,
+  ): NonFunctionAndIdentifierPropertiesWithNoPartial<TBase> {
+    const result: Record<string, any> = {}
+
+    for (const [key, value] of Object.entries(data)) {
+      if (this.isValidObjectForDateBinding(value)) {
+        result[key] = this.bindAllDateFromObject(value)
+      } else if (Array.isArray(value)) {
+        result[key] = this.processArrayData(value)
+      } else {
+        result[key] = this.convertToDate(value, key)
+      }
+    }
+
+    return result as NonFunctionAndIdentifierPropertiesWithNoPartial<TBase>
+  }
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-model-converter.helper.ts

@@ -0,0 +1,60 @@
+import { BaseModelBuilder, ModelBaseStructure } from '../../../../../domain'
+import { each, isObject, unset } from '../../../../../utils'
+import { ConnectDocumentData, ConnectDocumentSnapshot } from '../../types'
+
+import { FirestoreDataConverterHelper } from './firestore-data-converter.helper'
+
+export class FirestoreModelConverterHelper<TBase extends ModelBaseStructure<TBase>> {
+  constructor(private model: BaseModelBuilder<TBase>) {}
+
+  static omitByRecursivelyInPlace(value: any, iteratee: (value: any, key: string) => boolean): any {
+    each(value, (v, k) => {
+      if (iteratee(v, k)) {
+        unset(value, k)
+      } else if (isObject(v)) {
+        this.omitByRecursivelyInPlace(v, iteratee)
+      }
+    })
+
+    return value
+  }
+
+  buildToFirestoreConverter(): (data: TBase) => ConnectDocumentData<TBase> {
+    return (data: TBase): ConnectDocumentData<TBase> => {
+      const plain = data?.toPlain ? data.toPlain() : data
+
+      return FirestoreModelConverterHelper.omitByRecursivelyInPlace(plain, (value) => value === undefined)
+    }
+  }
+
+  buildFromFirestoreConverter(): (snap: ConnectDocumentSnapshot<TBase>) => TBase {
+    return (snap: ConnectDocumentSnapshot<TBase>): TBase => {
+      try {
+        const data = snap.data()
+        const ids = { id: snap.id }
+        const bindedData = FirestoreDataConverterHelper.bindAllDateFromObject<TBase>(data)
+
+        return this.model.toInstance({ ...bindedData, ...ids })
+      } catch (error) {
+        this.handleConversionError(snap.id, snap.data(), error)
+        throw error
+      }
+    }
+  }
+
+  private handleConversionError(snapId: string, data: any, error: any): void {
+    console.warn('id', snapId)
+    console.warn('data', JSON.stringify(data))
+    console.error(error)
+  }
+
+  getConverters(): {
+    toFirestore: (data: TBase) => ConnectDocumentData<TBase>
+    fromFirestore: (snap: ConnectDocumentSnapshot<TBase>) => TBase
+  } {
+    return {
+      toFirestore: this.buildToFirestoreConverter(),
+      fromFirestore: this.buildFromFirestoreConverter(),
+    }
+  }
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-operations.helper.ts

@@ -0,0 +1,73 @@
+import { BaseModelBuilder, IdentifiersModel, ModelBaseStructure } from '../../../../../domain'
+import { NotFoundError } from '../../../../../errors'
+
+export class FirestoreOperationsHelper<TBase extends ModelBaseStructure<TBase>> {
+  constructor(private model: BaseModelBuilder<TBase>) {}
+
+  buildInstanceFromIdentifiers(identifiers: any): TBase {
+    return this.model.toInstance(
+      this.model.identifiersFields.reduce(
+        (acc, field) => ({ ...acc, [field]: identifiers[field as keyof IdentifiersModel<TBase>] }),
+        {},
+      ),
+    )
+  }
+
+  async validateDocumentExists(docRef: any, collectionName: string, identifiers: any): Promise<void> {
+    const docSnapshot = await docRef.get()
+
+    if (!docSnapshot.data()) {
+      throw new NotFoundError(`Document '${collectionName}/${Object.values(identifiers.toString())}' not found`)
+    }
+  }
+
+  validateDocumentData(data: any, collectionName: string, identifiers: any): void {
+    if (!data) {
+      throw new NotFoundError(`Document '${collectionName}/${Object.values(identifiers).shift()}' not found`)
+    }
+  }
+
+  async getDocumentSnapshot(collection: any, instance: TBase): Promise<any> {
+    return await collection.getDoc(Object.values(instance.identifier).shift().toString()).get()
+  }
+
+  async executeDelete(collection: any, instance: TBase): Promise<void> {
+    await collection.getDoc(Object.values(instance.identifier).shift().toString()).delete()
+  }
+
+  calculateCount<T>(data: T[], limits: { limit?: number }): number {
+    if (data.length <= 0) return 0
+
+    if (data.length < limits?.limit) return data.length
+
+    return Infinity
+  }
+
+  handleError(error: unknown, logger: any, req: any): void {
+    if (error instanceof Error) {
+      logger.log({ req, res: error, stack: error.stack })
+    }
+  }
+
+  buildCollectionPath(params: {
+    isSubCollection: boolean
+    collectionName: string
+    parentRepository?: { collectionName: string }
+    parentIdField?: string
+    identifiers?: any
+  }): string {
+    const { isSubCollection, collectionName, parentRepository, parentIdField, identifiers } = params
+
+    if (!isSubCollection) return collectionName
+
+    const parentId = identifiers?.[parentIdField]
+
+    return `${parentRepository?.collectionName}/${parentId}/${collectionName}`
+  }
+
+  getKeyField(): string {
+    const model = new this.model()
+
+    return model.identifiersFields.shift() as string
+  }
+}

package/src/infra/firebase/firestore/mixins/helpers/firestore-query-builder.helper.ts

@@ -0,0 +1,216 @@
+import {
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+  NonFunctionPropertyNames,
+  RepositoryFindFielters,
+  RepositoryFindFieltersOptions,
+  RepositoryLimitOptions,
+  RepositoryOrderBy,
+  Where,
+} from '../../../../../domain'
+import { is, isNil, isNumber, isObject, isString, set } from '../../../../../utils'
+import { FirestoreFieldType } from '../../enums'
+import { ConnectCollectionReference } from '../../services'
+import { ConnectDocumentSnapshot, ConnectWhereOption } from '../../types'
+
+export class FirestoreQueryBuilderHelper<TBase extends ModelBaseStructure<TBase>> {
+  constructor(
+    private config: {
+      model: any
+      fields?: Partial<Record<NonFunctionAndIdentifierPropertyNames<TBase>, FirestoreFieldType>>
+      isSubCollection?: (instance: any) => boolean
+      parentIdField?: string
+    },
+  ) {}
+
+  buildWhereSentence(
+    fieldName: NonFunctionPropertyNames<TBase> | string,
+    options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>,
+  ): [string, ConnectWhereOption, any][] {
+    if (this.config.isSubCollection?.(this) && fieldName === this.config.parentIdField) return []
+
+    const firestoreFieldName = this.getFirestoreFieldName(fieldName, options)
+
+    return this.buildWhereConditions(firestoreFieldName, options, fieldName)
+  }
+
+  private getFirestoreFieldName(fieldName: string | NonFunctionPropertyNames<TBase>, options: any): string {
+    const value = options?.value || options
+    const object = {}
+
+    set(object, fieldName.toString(), value)
+
+    const plainInstance = new this.config.model(object).toPlain()
+
+    return fieldName.toString().indexOf('.') > -1
+      ? fieldName.toString()
+      : Object.keys(plainInstance).find((key) => plainInstance[key])
+  }
+
+  private buildWhereConditions(
+    firestoreFieldName: string,
+    options: any,
+    fieldName: string | NonFunctionPropertyNames<TBase>,
+  ): [string, ConnectWhereOption, any][] {
+    if (options?.operator === Where.LIKE) {
+      return this.buildLikeConditions(firestoreFieldName, options)
+    }
+
+    if (options?.operator === Where.IN && Array.isArray(options?.value)) {
+      return this.buildInConditions(firestoreFieldName, options)
+    }
+
+    if (this.isNestedObjectFilter(options)) {
+      return this.buildNestedObjectConditions(fieldName, options)
+    }
+
+    return [[firestoreFieldName, (options?.operator || '==') as ConnectWhereOption, options?.value || options]]
+  }
+
+  private buildLikeConditions(firestoreFieldName: string, options: any): [string, ConnectWhereOption, any][] {
+    if (this.isArrayField(firestoreFieldName) && Array.isArray(options?.value)) {
+      return [[firestoreFieldName, 'array-contains-any', options.value]]
+    }
+
+    return [
+      [firestoreFieldName, '>=', options.value],
+      [firestoreFieldName, '<=', `${options.value}~`],
+    ]
+  }
+
+  private buildInConditions(firestoreFieldName: string, options: any): [string, ConnectWhereOption, any][] {
+    if (this.isArrayField(firestoreFieldName)) {
+      return [[firestoreFieldName, 'array-contains', options.value]]
+    }
+
+    return [[firestoreFieldName, 'in', options.value]]
+  }
+
+  private buildNestedObjectConditions(
+    fieldName: string | NonFunctionPropertyNames<TBase>,
+    options: any,
+  ): [string, ConnectWhereOption, any][] {
+    return Object.keys(options).reduce(
+      (queries, key) => [
+        ...queries,
+        ...this.buildWhereSentence(`${fieldName.toString()}.${key}`, is<Record<string, any>>(options)[key]),
+      ],
+      [],
+    )
+  }
+
+  private isArrayField(firestoreFieldName: string): boolean {
+    return (
+      this.config.fields?.[firestoreFieldName as NonFunctionAndIdentifierPropertyNames<TBase>] ===
+        FirestoreFieldType.Array ||
+      !this.config.fields?.[firestoreFieldName as NonFunctionAndIdentifierPropertyNames<TBase>]
+    )
+  }
+
+  private isNestedObjectFilter(options: any): boolean {
+    return isObject(options) && isNil((options as any)?.operator) && isNil((options as any)?.value)
+  }
+
+  buildOrderBy(
+    filters: RepositoryFindFielters<TBase>,
+    fieldsToOrderBy?: RepositoryOrderBy<TBase>,
+  ): [string, 'asc' | 'desc'][] {
+    const orderByKeys = Object.keys(fieldsToOrderBy || {})
+
+    if (!orderByKeys.length) return []
+
+    const updatedOrderBy = this.addMissingOrderFields(filters, fieldsToOrderBy)
+
+    return this.convertToOrderByArray(updatedOrderBy)
+  }
+
+  private addMissingOrderFields(
+    filters: RepositoryFindFielters<TBase>,
+    fieldsToOrderBy: RepositoryOrderBy<TBase>,
+  ): RepositoryOrderBy<TBase> {
+    const orderByKeys = Object.keys(fieldsToOrderBy || {})
+    const filtersKeysWithUnordered = Object.keys(filters || {}).filter((filterKey) => !orderByKeys.includes(filterKey))
+
+    let updatedOrderBy = fieldsToOrderBy || {}
+
+    filtersKeysWithUnordered.forEach((filterKey) => {
+      const filterValue = filters[filterKey as NonFunctionAndIdentifierPropertyNames<TBase>]
+      const filterOptions =
+        is<RepositoryFindFieltersOptions<TBase, NonFunctionAndIdentifierPropertyNames<TBase>>>(filterValue)
+
+      if (filterOptions?.operator && ![Where.EQUALS].includes(filterOptions.operator)) {
+        updatedOrderBy = { [filterKey]: 'asc', ...updatedOrderBy }
+      }
+    })
+
+    return updatedOrderBy
+  }
+
+  private convertToOrderByArray(fieldsToOrderBy: RepositoryOrderBy<TBase>): [string, 'asc' | 'desc'][] {
+    return Object.keys(fieldsToOrderBy).map((fieldName) => [
+      fieldName,
+      fieldsToOrderBy[fieldName as NonFunctionAndIdentifierPropertyNames<TBase>],
+    ])
+  }
+
+  async buildLimits(params: {
+    filters: RepositoryFindFielters<TBase>
+    limits: RepositoryLimitOptions<TBase>
+    collection: (path: string) => ConnectCollectionReference<TBase>
+    buildCollectionPath: (filters: RepositoryFindFielters<TBase>) => string
+  }): Promise<['fromStartAfter' | 'fromStartAt' | 'limit', string | number | ConnectDocumentSnapshot<TBase>][]> {
+    const { filters, limits, collection, buildCollectionPath } = params
+    const queries: ['fromStartAfter' | 'fromStartAt' | 'limit', string | number | ConnectDocumentSnapshot<TBase>][] = []
+
+    if (limits?.offset) {
+      await this.addOffsetQuery({ queries, limits, filters, collection, buildCollectionPath })
+    }
+
+    if (limits?.limit) {
+      queries.push(['limit', limits.limit])
+    }
+
+    return queries
+  }
+
+  private async addOffsetQuery(params: {
+    queries: ['fromStartAfter' | 'fromStartAt' | 'limit', string | number | ConnectDocumentSnapshot<TBase>][]
+    limits: RepositoryLimitOptions<TBase>
+    filters: RepositoryFindFielters<TBase>
+    collection: (path: string) => ConnectCollectionReference<TBase>
+    buildCollectionPath: (filters: RepositoryFindFielters<TBase>) => string
+  }): Promise<void> {
+    const { queries, limits, filters, collection, buildCollectionPath } = params
+
+    if (this.config.model.isModel(limits.offset)) {
+      const docSnapshot = await collection(buildCollectionPath(filters))
+        .getDoc(
+          Object.values((limits.offset as TBase).identifier)
+            .shift()
+            ?.toString(),
+        )
+        .get()
+
+      queries.push(['fromStartAfter', docSnapshot])
+    } else if (isNumber(limits.offset) || isString(limits.offset)) {
+      queries.push(['fromStartAt', limits.offset])
+    }
+  }
+
+  buildQuery(params: {
+    collection: ConnectCollectionReference<TBase>
+    queries: [string, ConnectWhereOption, any][]
+    ordination: [string, 'asc' | 'desc'][]
+    offsets: ['fromStartAfter' | 'fromStartAt' | 'limit', string | number | ConnectDocumentSnapshot<TBase>][]
+  }): ConnectCollectionReference<TBase> {
+    const { collection, queries, ordination, offsets } = params
+
+    return queries.reduce(
+      (collection, where) => collection.where(...where),
+      ordination.reduce(
+        (collection, ordination) => collection.order(...ordination),
+        offsets.reduce((collection, offset) => collection[offset[0]](offset[1] as any), collection),
+      ),
+    )
+  }
+}

package/src/infra/firebase/firestore/mixins/helpers/index.ts

@@ -0,0 +1,4 @@
+export * from './cache-key-generator.helper'
+export * from './firestore-cache.helper'
+export * from './firestore-operations.helper'
+export * from './firestore-query-builder.helper'

package/src/infra/firebase/firestore/mixins/index.ts

@@ -0,0 +1,9 @@
+export * from './with-firestore.mixin'
+export * from './with-helpers.mixin'
+export * from './with-get-firestore.mixin'
+export * from './with-find-firestore.mixin'
+export * from './with-create-firestore.mixin'
+export * from './with-update-firestore.mixin'
+export * from './with-delete-firestore.mixin'
+export * from './with-sub-collection.mixin'
+export * from './with-crud-firestore.mixin'

package/src/infra/firebase/firestore/mixins/with-create-firestore.mixin.ts

@@ -0,0 +1,51 @@
+import { CreateRepository, CreateRepositoryParams, ModelBaseStructure } from '../../../../domain'
+import { MixinCtor } from '../../../../utils'
+import { ConnectDocumentReference } from '../services'
+import { FirestoreHelpers, FirestoreRepository } from '../types'
+
+export const withCreateFirestore = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+    MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+  ): MixinCtor<
+  FirestoreRepository<TBase> & InstanceType<TMixinBase> & CreateRepository<TBase> & FirestoreHelpers,
+  []
+> => {
+  return class CreateFirestore extends MixinBase implements CreateRepository<TBase> {
+    async create(data: CreateRepositoryParams<TBase>): Promise<TBase> {
+      const logger = this.logger.with('create')
+      const instance = this.model.toInstance(data as any)
+      const intercepted = await this.interceptors?.request?.({ instance })
+      const builded = intercepted?.instance || instance
+      const req = { collection: this.buildCollectionPathForAdd(builded), data }
+
+      try {
+        const docRef = await this.save(builded)
+        const doc = (await docRef.get()).data()
+        const docBuilded = (await this.interceptors?.response?.(doc, intercepted)) || doc
+
+        logger.log({ req, res: docBuilded })
+
+        return docBuilded
+      } catch (error) {
+        if (error instanceof Error) logger.log({ req, res: error, stack: error.stack })
+
+        throw error
+      }
+    }
+
+    async save(data: TBase): Promise<ConnectDocumentReference<TBase>> {
+      const collectionPath = this.buildCollectionPathForAdd(data)
+      const collection = this.collection(collectionPath)
+
+      return collection.add(data, Object.values(data.identifier).shift()?.toString?.())
+    }
+
+    buildCollectionPathForAdd(identifiers: Partial<TBase>): string {
+      return this.isSubCollection(this)
+        ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
+        : this.collectionName
+    }
+  } as any
+}

package/src/infra/firebase/firestore/mixins/with-crud-firestore.mixin.ts

@@ -0,0 +1,33 @@
+import { CrudRepository, ModelBaseStructure } from '../../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../../utils'
+import { FirestoreHelpers, FirestoreRepository } from '../types'
+
+import { withCreateFirestore } from './with-create-firestore.mixin'
+import { withDeleteFirestore } from './with-delete-firestore.mixin'
+import { withFindFirestore } from './with-find-firestore.mixin'
+import { FirestoreConstructorParams } from './with-firestore.mixin'
+import { withGetFirestore } from './with-get-firestore.mixin'
+import { withUpdateFirestore } from './with-update-firestore.mixin'
+
+export const withCrudFirestore = <
+  TBase extends ModelBaseStructure<TBase>,
+  Repository = CrudRepository<TBase>,
+  TMixinBase extends MixinCtor = MixinCtor,
+>(
+    MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+  ): MixinCtor<
+  FirestoreRepository<TBase> & Repository & FirestoreHelpers,
+  MergeConstructorParams<[FirestoreConstructorParams<TBase>, ...any[]], ConstructorParameters<TMixinBase>>
+> => {
+  return class CrudFirestore
+    extends withUpdateFirestore(
+      withGetFirestore(
+        withFindFirestore(
+          withDeleteFirestore(
+            withCreateFirestore(MixinBase as MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers>),
+          ),
+        ),
+      ),
+    )
+    implements CrudRepository<TBase> {} as any
+}