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

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

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

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

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

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

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

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

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

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

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