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

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

@@ -0,0 +1,87 @@
+import { DeleteRepository, DeleteRepositoryParams, IdentifiersModel, ModelBaseStructure } from '../../../../domain'
+import { MixinCtor } from '../../../../utils'
+import { FirestoreHelpers, FirestoreRepository } from '../types'
+
+import { FirestoreCacheHelper } from './helpers/firestore-cache.helper'
+import { FirestoreOperationsHelper } from './helpers/firestore-operations.helper'
+
+type ExecuteDeleteOperationParams<TBase extends ModelBaseStructure<TBase>> = {
+  instance: TBase
+  collectionName: string
+  logger: any
+  req: any
+}
+
+const createDeleteFirestoreClass = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+) => {
+  return class DeleteFirestore extends MixinBase implements DeleteRepository<TBase> {
+    private operationsHelper: FirestoreOperationsHelper<TBase>
+
+    constructor(...args: any[]) {
+      super(...args)
+      this.operationsHelper = new FirestoreOperationsHelper(this.model)
+    }
+
+    generateCacheKey(identifiers: IdentifiersModel<TBase>): string {
+      return FirestoreCacheHelper.generateGetCacheKey(this.model, identifiers)
+    }
+
+    async delete(identifiers: DeleteRepositoryParams<TBase>): Promise<void> {
+      const logger = this.logger.with('delete')
+      const collectionName = this.buildCollectionPathForRemove(identifiers)
+      const instance = this.operationsHelper.buildInstanceFromIdentifiers(identifiers)
+      const req = { collection: collectionName, data: identifiers }
+
+      await this.handleCacheRemoval(identifiers, logger)
+
+      try {
+        await this.executeDeleteOperation({ instance, collectionName, logger, req })
+      } catch (error) {
+        this.operationsHelper.handleError(error, logger, req)
+        throw error
+      }
+    }
+
+    private async handleCacheRemoval(identifiers: IdentifiersModel<TBase>, logger: any): Promise<void> {
+      const cacheKey = this.generateCacheKey(identifiers)
+
+      await FirestoreCacheHelper.removeCacheData(this.cache, { cacheKey, logger })
+    }
+
+    private async executeDeleteOperation(params: ExecuteDeleteOperationParams<TBase>): Promise<void> {
+      const { instance, collectionName, logger, req } = params
+
+      const intercepted = await this.interceptors?.request?.({ instance })
+      const builded = intercepted?.instance || instance
+
+      await this.operationsHelper.executeDelete(this.collection(collectionName), builded)
+      await this.interceptors?.response?.(instance, intercepted)
+
+      logger.log({ req, res: undefined })
+    }
+
+    buildCollectionPathForRemove(identifiers: IdentifiersModel<TBase>): string {
+      return this.isSubCollection(this)
+        ? `${(this as any).parentRepository.collectionName}/${identifiers[(this as any).parentIdField]}/${
+            this.collectionName
+          }`
+        : this.collectionName
+    }
+  }
+}
+
+export const withDeleteFirestore = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+): MixinCtor<
+  FirestoreRepository<TBase> & InstanceType<TMixinBase> & DeleteRepository<TBase> & FirestoreHelpers,
+  []
+> => {
+  return createDeleteFirestoreClass(MixinBase) as any
+}

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

@@ -0,0 +1,212 @@
+import {
+  FindRepository,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+  NonFunctionPropertyNames,
+  RepositoryCacheOptions,
+  RepositoryFindField,
+  RepositoryFindFielters,
+  RepositoryFindFieltersOptions,
+  RepositoryFindResult,
+  RepositoryLimitOptions,
+  RepositoryOrderBy,
+} from '../../../../domain'
+import { is, isNil, MixinCtor } from '../../../../utils'
+import { ConnectCollectionReference } from '../services'
+import { ConnectWhereOption, FirestoreHelpers, FirestoreRepository } from '../types'
+
+import { FirestoreCacheHelper } from './helpers/firestore-cache.helper'
+import { FirestoreOperationsHelper } from './helpers/firestore-operations.helper'
+import { FirestoreQueryBuilderHelper } from './helpers/firestore-query-builder.helper'
+
+type ExecuteFindParams = {
+  find: any
+  collectionName: string
+  logger: any
+  req: any
+}
+
+const createFilterHelpers = <TBase extends ModelBaseStructure<TBase>>() => {
+  const checkIfIsFilterOption = (filter: any): filter is RepositoryFindFieltersOptions<TBase, any> =>
+    !isNil(filter?.operator)
+
+  const getValueFromFilter = (filter: RepositoryFindField<TBase, any>): any => {
+    return checkIfIsFilterOption(filter) ? filter.value : filter
+  }
+
+  return { checkIfIsFilterOption, getValueFromFilter }
+}
+
+export const withFindFirestore = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+): MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & FindRepository<TBase> & FirestoreHelpers, []> => {
+  const { getValueFromFilter } = createFilterHelpers<TBase>()
+
+  return class FindFirestore extends MixinBase implements FindRepository<TBase> {
+    private operationsHelper: FirestoreOperationsHelper<TBase>
+    private queryBuilder: FirestoreQueryBuilderHelper<TBase>
+
+    constructor(...args: any[]) {
+      super(...args)
+      this.initializeHelpers()
+    }
+
+    private initializeHelpers(): void {
+      this.operationsHelper = new FirestoreOperationsHelper(this.model)
+      this.queryBuilder = new FirestoreQueryBuilderHelper({
+        model: this.model,
+        fields: this.fields,
+        isSubCollection: (instance: any) => this.isSubCollection(instance),
+        parentIdField: (this as any).parentIdField,
+      })
+    }
+
+    generateCacheKey(findParams: any): string {
+      return FirestoreCacheHelper.generateFindCacheKey(this.model, findParams)
+    }
+
+    async find(
+      find: {
+        fields?: RepositoryFindField<TBase, any>
+        filters?: RepositoryFindFielters<TBase>
+        limits?: RepositoryLimitOptions<TBase>
+        orderBy?: RepositoryOrderBy<TBase>
+        options?: { enableCount?: boolean }
+      } = {},
+      options?: { cache?: RepositoryCacheOptions },
+    ): Promise<RepositoryFindResult<TBase>> {
+      const logger = this.logger.with('find')
+
+      const cachedResult = await this.getCachedResult(find, options, logger)
+
+      if (cachedResult) return cachedResult
+
+      return this.executeFindOperation(find, options, logger)
+    }
+
+    private async getCachedResult(
+      find: any,
+      options: { cache?: RepositoryCacheOptions } | undefined,
+      logger: any,
+    ): Promise<RepositoryFindResult<TBase> | null> {
+      return FirestoreCacheHelper.getCachedFindData(this.cache, {
+        model: this.model,
+        find,
+        options,
+        logger,
+      })
+    }
+
+    private async executeFindOperation(
+      find: any,
+      options: { cache?: RepositoryCacheOptions } | undefined,
+      logger: any,
+    ): Promise<RepositoryFindResult<TBase>> {
+      const collectionName = this.buildCollectionPathForFind(find.filters)
+      const req = { collection: collectionName, data: find }
+
+      try {
+        const result = await this.executeFind({ find, collectionName, logger, req })
+
+        await this.saveCacheData({ find, options, result, logger })
+
+        return result
+      } catch (error) {
+        this.operationsHelper.handleError(error, logger, req)
+        throw error
+      }
+    }
+
+    private async executeFind(params: ExecuteFindParams): Promise<RepositoryFindResult<TBase>> {
+      const { find, collectionName, logger, req } = params
+      const collection: ConnectCollectionReference<TBase> = this.collection(collectionName)
+      const enableCount = find?.options?.enableCount ?? true
+
+      const intercepted = await this.interceptors?.request?.({ find })
+      const { filters, limits, orderBy } = intercepted?.find || find
+
+      const queryData = await this.buildQueryData(filters, orderBy, limits)
+      const docs = await this.executeQuery(collection, queryData)
+      const data = docs.docs.map((doc) => doc.data())
+
+      const result = {
+        data: (await this.interceptors?.response?.(data, intercepted)) || data,
+        count: enableCount ? this.operationsHelper.calculateCount(data, limits) : Infinity,
+      }
+
+      logger.log({ req, ...queryData, res: result })
+
+      return result
+    }
+
+    private async buildQueryData(
+      filters: any,
+      orderBy: any,
+      limits: any,
+    ): Promise<{ queries: any; ordination: any; offsets: any }> {
+      const queries = this.makeFirestoreWhere(filters || {})
+      const ordination = this.queryBuilder.buildOrderBy(filters, orderBy)
+      const offsets = await this.queryBuilder.buildLimits({
+        filters,
+        limits,
+        collection: (path: string) => this.collection(path),
+        buildCollectionPath: (filters: any) => this.buildCollectionPathForFind(filters),
+      })
+
+      return { queries, ordination, offsets }
+    }
+
+    private async executeQuery(
+      collection: ConnectCollectionReference<TBase>,
+      queryData: { queries: any; ordination: any; offsets: any },
+    ): Promise<any> {
+      return this.queryBuilder
+        .buildQuery({
+          collection,
+          ...queryData,
+        })
+        .getDocs()
+    }
+
+    private async saveCacheData(params: {
+      find: any
+      options: { cache?: RepositoryCacheOptions } | undefined
+      result: RepositoryFindResult<TBase>
+      logger: any
+    }): Promise<void> {
+      const { find, options, result, logger } = params
+
+      if (!this.cache?.cacheAdapter || options?.cache?.enabled === false) return
+
+      const cacheKey = this.generateCacheKey(find)
+
+      await FirestoreCacheHelper.saveCacheData(this.cache, {
+        cacheKey,
+        data: result,
+        expirationInSeconds: options?.cache?.ttl,
+        logger,
+      })
+    }
+
+    buildCollectionPathForFind(filters: RepositoryFindFielters<TBase>): string {
+      if (!this.isSubCollection(this)) return this.collectionName
+
+      const parentIdField = (this as any).parentIdField as NonFunctionAndIdentifierPropertyNames<TBase>
+      const parentId = getValueFromFilter(filters?.[parentIdField])
+
+      return `${(this as any).parentRepository.collectionName}/${parentId}/${this.collectionName}`
+    }
+
+    makeFirestoreWhere = (filter: RepositoryFindFielters<TBase>): [string, ConnectWhereOption, any][] =>
+      Object.keys(filter).reduce(
+        (queries: [string, ConnectWhereOption, any][], fieldName: string) => [
+          ...queries,
+          ...this.queryBuilder.buildWhereSentence(fieldName, is(filter[fieldName as NonFunctionPropertyNames<TBase>])),
+        ],
+        [],
+      )
+  } as any
+}

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

@@ -0,0 +1,63 @@
+import {
+  BaseModelBuilder,
+  CacheConfig,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+} from '../../../../domain'
+import { DebugHelper, MergeConstructorParams, MixinCtor } from '../../../../utils'
+import { FirestoreFieldType } from '../enums'
+import { ConnectCollectionReference, ConnectFirestore } from '../services'
+import { ConnectDocumentData, ConnectDocumentSnapshot, FirestoreInterceptors, FirestoreRepository } from '../types'
+
+import { FirestoreModelConverterHelper } from './helpers/firestore-model-converter.helper'
+
+export type FirestoreConstructorParams<Model extends ModelBaseStructure<Model>> = {
+  firestore: ConnectFirestore
+  collectionName: string
+  model: BaseModelBuilder<Model>
+  fields?: Partial<Record<NonFunctionAndIdentifierPropertyNames<Model>, FirestoreFieldType>>
+  interceptors?: FirestoreInterceptors<Model>
+  cache?: CacheConfig
+}
+
+export const withFirestore = <TBase extends ModelBaseStructure<TBase>, T extends MixinCtor = MixinCtor>(
+  MixinBase: T,
+): MixinCtor<FirestoreRepository<TBase>, MergeConstructorParams<any[], FirestoreConstructorParams<TBase>[]>> => {
+  return class extends MixinBase implements FirestoreRepository<TBase> {
+    firestore: ConnectFirestore
+    fields: Partial<Record<NonFunctionAndIdentifierPropertyNames<TBase>, FirestoreFieldType>> = {}
+    interceptors: FirestoreInterceptors<TBase> = {}
+    collectionName = ''
+    model: BaseModelBuilder<TBase>
+    logger: DebugHelper
+    cache?: CacheConfig
+    private modelConverter: FirestoreModelConverterHelper<TBase>
+
+    constructor(...params: any[]) {
+      super(...params)
+      this.initializeFirestoreRepository(params[0])
+    }
+
+    private initializeFirestoreRepository(options: FirestoreConstructorParams<TBase>): void {
+      this.firestore = options.firestore
+      this.collectionName = options.collectionName
+      this.model = options.model
+      this.fields = options.fields
+      this.interceptors = options.interceptors
+      this.logger = DebugHelper.from(this)
+      this.cache = options.cache
+      this.modelConverter = new FirestoreModelConverterHelper(this.model)
+    }
+
+    collection(path?: string): ConnectCollectionReference<TBase> {
+      return this.firestore.getCollection<TBase>(path || this.collectionName).withConverter(this.buildModelInstance())
+    }
+
+    buildModelInstance(): {
+      toFirestore: (data: TBase) => ConnectDocumentData<TBase>
+      fromFirestore: (snap: ConnectDocumentSnapshot<TBase>) => TBase
+    } {
+      return this.modelConverter.getConverters()
+    }
+  }
+}

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

@@ -0,0 +1,125 @@
+import { GetRepository, IdentifiersModel, ModelBaseStructure, RepositoryCacheOptions } from '../../../../domain'
+import { MixinCtor } from '../../../../utils'
+import { FirestoreHelpers, FirestoreRepository } from '../types'
+
+import { FirestoreCacheHelper } from './helpers/firestore-cache.helper'
+import { FirestoreOperationsHelper } from './helpers/firestore-operations.helper'
+
+const createGetFirestoreClass = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+) => {
+  return class GetFirestore extends MixinBase implements GetRepository<TBase> {
+    private operationsHelper: FirestoreOperationsHelper<TBase>
+
+    constructor(...args: any[]) {
+      super(...args)
+      this.operationsHelper = new FirestoreOperationsHelper(this.model)
+    }
+
+    async get(identifiers: IdentifiersModel<TBase>, options?: { cache?: RepositoryCacheOptions }): Promise<TBase> {
+      const logger = this.logger.with('get')
+      const collectionName = this.buildCollectionPathForGet(identifiers)
+      const instance = this.operationsHelper.buildInstanceFromIdentifiers(identifiers)
+      const req = { collection: collectionName, data: identifiers }
+
+      const cachedResult = await FirestoreCacheHelper.getCachedData(this.cache, {
+        model: this.model,
+        identifiers,
+        options,
+        logger,
+        req,
+      })
+
+      if (cachedResult) return this.model.toInstance(cachedResult)
+
+      try {
+        const result = await this.executeGet({
+          instance,
+          collectionName,
+          identifiers,
+          logger,
+          req,
+        })
+
+        await this.saveCacheData({
+          identifiers,
+          options,
+          result,
+          logger,
+          req,
+        })
+
+        return result
+      } catch (error) {
+        this.operationsHelper.handleError(error, logger, req)
+        throw error
+      }
+    }
+
+    private async executeGet(params: {
+      instance: TBase
+      collectionName: string
+      identifiers: IdentifiersModel<TBase>
+      logger: any
+      req: any
+    }): Promise<TBase> {
+      const { instance, collectionName, identifiers, logger, req } = params
+
+      const intercepted = await this.interceptors?.request?.({ instance })
+      const builded = intercepted?.instance || instance
+
+      const docRef = await this.operationsHelper.getDocumentSnapshot(this.collection(collectionName), builded)
+      const data = docRef.data()
+
+      this.operationsHelper.validateDocumentData(data, collectionName, identifiers)
+
+      const result = (await this.interceptors?.response?.(data, intercepted)) || data
+
+      logger.log({ req, res: result })
+
+      return result
+    }
+
+    private async saveCacheData(params: {
+      identifiers: IdentifiersModel<TBase>
+      options: { cache?: RepositoryCacheOptions } | undefined
+      result: TBase
+      logger: any
+      req: any
+    }): Promise<void> {
+      const { identifiers, options, result, logger, req } = params
+
+      if (!this.cache?.cacheAdapter || options?.cache?.enabled === false) return
+
+      const cacheKey = FirestoreCacheHelper.generateGetCacheKey(this.model, identifiers)
+
+      await FirestoreCacheHelper.saveCacheData(this.cache, {
+        cacheKey,
+        data: result,
+        expirationInSeconds: options?.cache?.ttl,
+        logger,
+        req,
+      })
+    }
+
+    buildCollectionPathForGet(identifiers: IdentifiersModel<TBase>): string {
+      return this.isSubCollection(this)
+        ? `${(this as any).parentRepository.collectionName}/${
+            identifiers[(this as any).parentIdField as keyof typeof identifiers]
+          }/${this.collectionName}`
+        : this.collectionName
+    }
+  }
+}
+
+export const withGetFirestore = <
+  TBase extends ModelBaseStructure<TBase>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+): MixinCtor<FirestoreRepository<TBase> & InstanceType<TMixinBase> & GetRepository<TBase> & FirestoreHelpers, []> => {
+  return createGetFirestoreClass(MixinBase) as any
+}

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

@@ -0,0 +1,23 @@
+import { QueryDocumentSnapshot, QuerySnapshot } from 'firebase/firestore'
+
+import { ModelBaseStructure } from '../../../../domain'
+import { isNil, MixinCtor } from '../../../../utils'
+import { FirestoreHelpers, FirestoreRepository, FirestoreSubRepository } from '../types'
+
+export const withHelpers = <TMixinBase extends MixinCtor = MixinCtor>(MixinBase: MixinCtor & TMixinBase) => {
+  return class extends MixinBase implements FirestoreHelpers {
+    toArray<T extends ModelBaseStructure<T>>(snapShot: QuerySnapshot<T> | QueryDocumentSnapshot<T>[]): T[] {
+      if (Array.isArray(snapShot)) {
+        return snapShot.map((doc: QueryDocumentSnapshot<T>) => doc.data())
+      } else {
+        return snapShot.docs.map((doc: QueryDocumentSnapshot<T>) => doc.data())
+      }
+    }
+
+    isSubCollection<T extends ModelBaseStructure<T>, E extends ModelBaseStructure<E>>(
+      repository: FirestoreRepository<T> | FirestoreSubRepository<T, E>,
+    ): repository is FirestoreSubRepository<T, E> {
+      return !isNil(Object.keys(this).find((key) => key === 'parentRepository'))
+    }
+  }
+}

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

@@ -0,0 +1,48 @@
+import { IdentifiersModel, ModelBaseStructure } from '../../../../domain'
+import { MergeConstructorParams, MixinCtor } from '../../../../utils'
+import { ConnectCollectionReference } from '../services'
+import { FirestoreHelpers, FirestoreRepository, FirestoreSubRepository } from '../types'
+
+import { FirestoreConstructorParams } from './with-firestore.mixin'
+
+export type FirestoreSubCollectionConstructorParams<TBase extends ModelBaseStructure> = {
+  parentIdField: keyof IdentifiersModel<TBase>
+}
+
+export const withSubCollection = <
+  TBase extends ModelBaseStructure<TBase>,
+  TBaseParent extends ModelBaseStructure<TBaseParent>,
+  TMixinBase extends MixinCtor<FirestoreRepository<TBase>>,
+>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase>> & TMixinBase,
+  _ParentModel: new () => TBaseParent,
+): MixinCtor<
+  FirestoreRepository<TBase> &
+    InstanceType<TMixinBase> &
+    FirestoreSubRepository<TBase, InstanceType<typeof _ParentModel>> &
+    FirestoreHelpers,
+  MergeConstructorParams<
+    [FirestoreConstructorParams<TBase> & FirestoreSubCollectionConstructorParams<TBase>, ...any[]],
+    ConstructorParameters<TMixinBase>
+  >
+> => {
+  return class SubCollectionMix
+    extends MixinBase
+    implements FirestoreSubRepository<TBase, InstanceType<typeof _ParentModel>>
+  {
+    readonly parentRepository: FirestoreRepository<InstanceType<typeof _ParentModel>>
+    parentIdField: keyof IdentifiersModel<TBase>
+
+    constructor(...params: any[]) {
+      const options: FirestoreSubCollectionConstructorParams<TBase> = params[0]
+
+      super(...params)
+
+      this.parentIdField = options.parentIdField
+    }
+
+    override collection(path?: string): ConnectCollectionReference<TBase> {
+      return super.collection(path)
+    }
+  } as any
+}