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

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

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

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

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

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

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

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