@infrab4a/connect 0.17.1-beta.1 → 0.17.1-beta.2

package/src/errors/index.ts

@@ -1,4 +0,0 @@
-export * from './invalid-argument.error'
-export * from './required-argument.error'
-export * from './not-found.error'
-export * from './duplicated-results.error'

package/src/errors/invalid-argument.error.ts

@@ -1,5 +0,0 @@
-export class InvalidArgumentError extends Error {
-  constructor(readonly message) {
-    super(message)
-  }
-}

package/src/errors/not-found.error.ts

@@ -1,5 +0,0 @@
-export class NotFoundError extends Error {
-  constructor(readonly message) {
-    super(message)
-  }
-}

package/src/errors/required-argument.error.ts

@@ -1,9 +0,0 @@
-export class RequiredArgumentError extends Error {
-  arguments: string[]
-
-  constructor(readonly args: string[]) {
-    super(`Required arguments: ${args.join(', ')}`)
-
-    this.arguments = args
-  }
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-import 'reflect-metadata'
-
-export * from './domain'
-export * from './errors'
-export * from './infra'
-export * from './utils'

package/src/infra/elasticsearch/adapters/axios.adapter.ts

@@ -1,27 +0,0 @@
-import axios from 'axios'
-
-import { BaseModel } from '../../../domain'
-import { ElasticSearchResult } from '../types/elastic-search-result'
-
-export type AxiosElasticSearchConfig = {
-  url: string
-  credential: string
-}
-
-export class AxiosAdapter<T extends BaseModel<T>> {
-  constructor(private readonly config: AxiosElasticSearchConfig) {}
-
-  async query(index: string, query: any): Promise<ElasticSearchResult<Partial<T>>> {
-    const { data } = await axios({
-      url: `${this.config.url}/${index}`,
-      method: 'POST',
-      headers: { Authorization: `Basic ${this.config.credential}` },
-      data: query,
-    })
-
-    return {
-      total: data.hits.total.value,
-      hits: data.hits.hits,
-    }
-  }
-}

package/src/infra/elasticsearch/adapters/index.ts

@@ -1,2 +0,0 @@
-export * from './axios.adapter'
-export * from './elastic-search.adapter'

package/src/infra/elasticsearch/index.ts

@@ -1,3 +0,0 @@
-export * from './adapters'
-export * from './indexes'
-export * from './types'

package/src/infra/elasticsearch/indexes/index.ts

@@ -1 +0,0 @@
-export * from './products-index'

package/src/infra/elasticsearch/indexes/products-index.ts

@@ -1,61 +0,0 @@
-import { AxiosAdapter } from '../adapters'
-import { Product, Shops } from '../../../domain'
-
-export class ProductsIndex {
-  constructor(private readonly adapter: AxiosAdapter<Product>) {}
-
-  async findById(ids: string[], options?: { hasStock: boolean; size: number; shop: Shops }): Promise<Product[]> {
-    const publishedField = options.shop === Shops.GLAMSHOP ? 'publishedGlam' : 'published'
-    const fields = [
-      'brand',
-      'id',
-      'images',
-      'miniatures',
-      'name',
-      'price',
-      'sku',
-      'stock',
-      'slug',
-      'reviews',
-      'pricePaid',
-      'isGift',
-      'stock',
-      'weight',
-      'tags',
-      'hasVariants',
-    ]
-    const { hits } = await this.adapter.query('products/_search', {
-      _source: fields,
-      query: {
-        bool: {
-          filter: [
-            {
-              terms: {
-                _id: ids,
-              },
-            },
-            {
-              term: {
-                [publishedField]: true,
-              },
-            },
-            ...(options.hasStock
-              ? [
-                  {
-                    range: {
-                      'stock.quantity': {
-                        gt: 0,
-                      },
-                    },
-                  },
-                ]
-              : []),
-          ],
-        },
-      },
-      ...(options.size ? { size: options.size } : {}),
-    })
-
-    return hits.map((hit) => Product.toInstance(hit._source))
-  }
-}

package/src/infra/elasticsearch/types/elastic-search-result.ts

@@ -1,7 +0,0 @@
-export type ElasticSearchResult<T> = {
-  total: number
-  hits: {
-    _index: string
-    _source: T
-  }[]
-}

package/src/infra/elasticsearch/types/index.ts

@@ -1 +0,0 @@
-export * from './elastic-search-result'

package/src/infra/firebase/auth/authentication-firebase-auth.service.ts

@@ -1,52 +0,0 @@
-import firebase from 'firebase/app'
-
-import { AuthenticationService, BasicUserData, LoginAndPasswordParams } from '../../../domain'
-
-import { FirebaseUserWithId } from './types/firebase-user-with-id.type'
-
-export class AuthenticationFirebaseAuthService implements AuthenticationService {
-  constructor(private readonly firebaseAuth: firebase.auth.Auth) {}
-
-  async signInWithEmailAndPassword(data: LoginAndPasswordParams): Promise<BasicUserData> {
-    const credentials = await this.firebaseAuth.signInWithEmailAndPassword(data.email, data.password)
-    const user = credentials.user
-
-    return {
-      id: user.uid,
-      displayName: user.displayName,
-      email: user.email,
-      phone: user.phoneNumber,
-      isAnonymous: false,
-    }
-  }
-
-  async signInWithGoogle(): Promise<BasicUserData> {
-    const credentials = await this.firebaseAuth.signInWithPopup(new firebase.auth.GoogleAuthProvider())
-    const user = credentials.user
-
-    return {
-      id: user.uid,
-      displayName: user.displayName,
-      email: user.email,
-      phone: user.phoneNumber,
-      isAnonymous: false,
-    }
-  }
-
-  async signOut(): Promise<void> {
-    this.firebaseAuth.signOut()
-  }
-
-  async signInAnonymously(): Promise<FirebaseUserWithId> {
-    const auth = await this.firebaseAuth.signInAnonymously()
-    const user = auth.user as FirebaseUserWithId
-
-    user.id = auth.user.uid
-
-    return user
-  }
-
-  async sendPasswordResetEmail(email: string): Promise<void> {
-    return this.firebaseAuth.sendPasswordResetEmail(email)
-  }
-}

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

@@ -1,2 +0,0 @@
-export * from './authentication-firebase-auth.service'
-export * from './register-firebase-auth.service'

package/src/infra/firebase/auth/register-firebase-auth.service.ts

@@ -1,26 +0,0 @@
-import firebase from 'firebase/app'
-
-import { RegisterParams, RegisterService, UserAlreadyRegisteredError, WeakPasswordError } from '../../../domain'
-
-import { FirebaseUserWithId } from './types/firebase-user-with-id.type'
-
-export class RegisterFirebaseAuthService implements RegisterService {
-  constructor(private readonly firebaseAuth: firebase.auth.Auth) {}
-
-  async register(params: RegisterParams): Promise<FirebaseUserWithId> {
-    try {
-      const auth = await this.firebaseAuth.createUserWithEmailAndPassword(params.email, params.password)
-      const user = auth.user as FirebaseUserWithId
-
-      user.sendEmailVerification()
-      user.id = auth.user.uid
-
-      return user
-    } catch (error) {
-      if (error.code === 'auth/email-already-in-use') throw new UserAlreadyRegisteredError('Email already registered')
-      if (error.code === 'auth/weak-password') throw new WeakPasswordError()
-
-      throw error
-    }
-  }
-}

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

@@ -1 +0,0 @@
-export type FirebaseUserWithId = firebase.User & { id: string }

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

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

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

@@ -1,3 +0,0 @@
-export * from './mixins'
-export * from './types'
-export * from './repositories'

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,36 +0,0 @@
-import { DocumentReference } from '@firebase/firestore-types'
-
-import { CreateRepository, BaseModelWithIdentifier } from '../../../../domain'
-import { FirestoreHelpers, FirestoreRepository } from '../types'
-import { isEmpty, MixinCtor } from '../../../../utils'
-
-export const withCreateFirestore = <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor>(
-  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
-) => {
-  return class CreateFirestore extends MixinBase implements CreateRepository<TBase> {
-    async create(data: Partial<TBase>): Promise<TBase> {
-      const docRef = await this.save(this.model.toInstance(data))
-      const doc = await docRef.get()
-
-      return doc.data()
-    }
-
-    async save(data: TBase): Promise<DocumentReference<TBase>> {
-      const id = data[data.identifierFields().shift()]?.toString()
-      const collectionPath = this.buildCollectionPathForAdd(data)
-
-      if (isEmpty(id)) return this.collection(collectionPath).add(data)
-
-      const docRef = this.collection(collectionPath).doc(id)
-      await docRef.set(data)
-
-      return docRef
-    }
-
-    buildCollectionPathForAdd(identifiers: Partial<TBase>): string {
-      return this.isSubCollection(this)
-        ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
-        : this.collectionName
-    }
-  }
-}

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

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

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

@@ -1,21 +0,0 @@
-import { BaseModelWithIdentifier, NonFunctionProperties, DeleteRepository } from '../../../../domain'
-import { FirestoreHelpers, FirestoreRepository } from '../types'
-import { MixinCtor } from '../../../../utils'
-
-export const withDeleteFirestore = <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor>(
-  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
-) => {
-  return class DeleteFirestore extends MixinBase implements DeleteRepository<TBase> {
-    async delete(identifiers: NonFunctionProperties<TBase>): Promise<void> {
-      await this.collection(this.buildCollectionPathForRemove(identifiers))
-        .doc(Object.values(identifiers).shift().toString())
-        .delete()
-    }
-
-    buildCollectionPathForRemove(identifiers: NonFunctionProperties<TBase>): string {
-      return this.isSubCollection(this)
-        ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
-        : this.collectionName
-    }
-  }
-}

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

@@ -1,142 +0,0 @@
-import { CollectionReference, Query } from '@firebase/firestore-types'
-
-import {
-  BaseModelWithIdentifier,
-  FindRepository,
-  NonFunctionPropertyNames,
-  RepositoryFindField,
-  RepositoryFindFielters,
-  RepositoryFindFieltersOptions,
-  RepositoryFindResult,
-  RepositoryLimitOptions,
-  RepositoryOrderByList,
-  Where,
-} from '../../../../domain'
-import { FirestoreHelpers, FirestoreRepository } from '../types'
-import { isDate, isNil, isNumber, isObject, isString, MixinCtor, set } from '../../../../utils'
-
-export const withFindFirestore = <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor>(
-  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
-) => {
-  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
-  }
-  const getFinalValueFrom = (value: any) =>
-    isNumber(value) || isString(value) || isDate(value) || Array.isArray(value)
-      ? value
-      : Object.values(getFinalValueFrom)
-
-  return class FindFirestore extends MixinBase implements FindRepository<TBase> {
-    async find(
-      filters?: RepositoryFindFielters<TBase>[],
-      limits?: RepositoryLimitOptions<TBase>,
-      orderBy?: RepositoryOrderByList<TBase>,
-    ): Promise<RepositoryFindResult<TBase>> {
-      let query: CollectionReference<TBase> | Query<TBase> = this.collection(this.buildCollectionPathForFind(filters))
-
-      filters?.forEach((filterer) => (query = this.makeFirestoreWhere(query, filterer)))
-
-      orderBy?.forEach((orderer) =>
-        Object.keys(orderer).forEach((fieldName) => (query = query.orderBy(fieldName, orderer[fieldName]))),
-      )
-
-      query = await this.defineLimits(query, filters, limits)
-
-      const docs = await query.get()
-      const data = docs.docs.map((doc) => doc.data())
-
-      return {
-        data,
-        count: this.calculateCount(data, limits),
-      }
-    }
-
-    buildCollectionPathForFind(filters: RepositoryFindFielters<TBase>[]): string {
-      if (!this.isSubCollection<TBase>(this)) return this.collectionName
-
-      const parentIdField = this.parentIdField
-      const parentId = getValueFromFilter(
-        filters.find((groupFilter) => Boolean(getValueFromFilter(groupFilter[parentIdField])))?.[parentIdField],
-      )
-
-      return `${this.parentRepository.collectionName}/${parentId}/${this.collectionName}`
-    }
-
-    makeFirestoreWhere = (
-      queryReference: CollectionReference<TBase> | Query<TBase>,
-      filter: RepositoryFindFielters<TBase>,
-    ): Query<TBase> =>
-      Object.keys(filter).reduce(
-        (query: Query<TBase>, fieldName: string) => this.buildWhereSentence(query, fieldName, filter[fieldName]),
-        queryReference,
-      )
-
-    buildWhereSentence = (
-      queryReference: CollectionReference<TBase> | Query<TBase>,
-      fieldName: NonFunctionPropertyNames<TBase> | string,
-      options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>,
-    ): Query<TBase> => {
-      if (this.isSubCollection<TBase>(this) && fieldName === this.parentIdField) return queryReference
-
-      const value = options?.value || options
-      const object = {}
-
-      set(object, fieldName, value)
-
-      const plainInstance = new this.model(object).toPlain()
-      const firestoreFieldName =
-        fieldName.toString().indexOf('.') > -1
-          ? fieldName.toString()
-          : Object.keys(plainInstance).find((key) => plainInstance[key])
-
-      if (options?.operator === Where.LIKE) {
-        if (Array.isArray(options?.value))
-          return queryReference.where(firestoreFieldName, 'array-contains-any', options.value)
-
-        queryReference = queryReference.where(firestoreFieldName, '>=', options.value)
-        queryReference = queryReference.where(firestoreFieldName, '<=', `${options.value}~`)
-
-        return queryReference
-      }
-      if (options?.operator === Where.IN && Array.isArray(options?.value))
-        return queryReference.where(firestoreFieldName, 'array-contains', options.value)
-      if (isObject(options) && isNil(options?.operator) && isNil(options?.value)) {
-        return Object.keys(options).reduce(
-          (queryReferenceWithWhere, key) =>
-            this.buildWhereSentence(queryReferenceWithWhere, `${fieldName}.${key}`, options[key]),
-          queryReference,
-        )
-      }
-
-      return queryReference.where(firestoreFieldName, options?.operator || '==', options?.value || options)
-    }
-
-    async defineLimits(
-      query: CollectionReference<TBase> | Query<TBase>,
-      filters: RepositoryFindFielters<TBase>[],
-      limits: RepositoryLimitOptions<TBase>,
-    ): Promise<Query<TBase>> {
-      if (limits?.offset) {
-        if (limits.offset instanceof this.model)
-          query = query.startAfter(
-            await this.collection(this.buildCollectionPathForFind(filters))
-              .doc(limits.offset[limits.offset.identifierFields().shift() as string])
-              .get(),
-          )
-        else if (isNumber(limits.offset) || isString(limits.offset)) query = query.startAt(limits.offset)
-      }
-      if (limits?.limit) query = query.limit(limits.limit)
-
-      return query
-    }
-
-    calculateCount(data: TBase[], limits: RepositoryLimitOptions<TBase>): number {
-      if (data.length <= 0) return 0
-      if (data.length < limits?.limit) return data.length
-
-      return Infinity
-    }
-  }
-}

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

@@ -1,42 +0,0 @@
-import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types'
-import firebase from 'firebase'
-
-import { BaseModelBuilder, BaseModelWithIdentifier } from '../../../../domain'
-import { FirestoreRepository } from '../types'
-import { MixinCtor } from '../../../../utils'
-
-export const withFirestore = <TBase extends BaseModelWithIdentifier<TBase>>(MixinBase: MixinCtor) => {
-  return class extends MixinBase implements FirestoreRepository<TBase> {
-    readonly firestore?: FirebaseFirestore
-    collectionName: string
-    model: BaseModelBuilder<TBase>
-
-    constructor(...args: Array<any>) {
-      super(args)
-    }
-
-    collection(path?: string): CollectionReference<TBase> {
-      return this.firestore.collection(path || this.collectionName).withConverter(this.buildModelInstance())
-    }
-
-    buildModelInstance(): {
-      toFirestore: (data: TBase) => DocumentData
-      fromFirestore: (snap: QueryDocumentSnapshot<TBase>) => TBase
-    } {
-      return {
-        toFirestore: (data: TBase): DocumentData => (data?.toPlain ? data.toPlain() : data),
-        fromFirestore: (snap: QueryDocumentSnapshot<TBase>): TBase => {
-          const data = snap.data()
-
-          Object.keys(data).forEach((key) => {
-            if (data[key] instanceof firebase.firestore.Timestamp) {
-              data[key] = data[key].toDate()
-            }
-          })
-
-          return this.model.toInstance({ ...data, id: snap.id })
-        },
-      }
-    }
-  }
-}

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

@@ -1,27 +0,0 @@
-import { BaseModelWithIdentifier, GetRepository, NonFunctionProperties } from '../../../../domain'
-import { FirestoreHelpers, FirestoreRepository } from '../types'
-import { isNil, MixinCtor } from '../../../../utils'
-import { NotFoundError } from '../../../../errors'
-
-export const withGetFirestore = <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor>(
-  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
-) => {
-  return class GetFirestore extends MixinBase implements GetRepository<TBase> {
-    async get(identifiers: NonFunctionProperties<TBase>): Promise<TBase> {
-      const doc = await this.collection(this.buildCollectionPathForGet(identifiers))
-        .doc(Object.values(identifiers).shift().toString())
-        .get()
-      const data = doc.data()
-
-      if (isNil(data)) throw new NotFoundError(`Document ${JSON.stringify(identifiers)} not found`)
-
-      return data
-    }
-
-    buildCollectionPathForGet(identifiers: NonFunctionProperties<TBase>): string {
-      return this.isSubCollection(this)
-        ? `${this.parentRepository.collectionName}/${identifiers[this.parentIdField]}/${this.collectionName}`
-        : this.collectionName
-    }
-  }
-}

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

@@ -1,26 +0,0 @@
-import { QuerySnapshot, QueryDocumentSnapshot } from '@firebase/firestore-types'
-
-import { BaseModelWithIdentifier } from '../../../../domain'
-
-import { FirestoreHelpers, FirestoreRepository, FirestoreSubRepository } from '../types'
-import { isNil, MixinCtor } from '../../../../utils'
-
-export const withHelpers = <Model extends BaseModelWithIdentifier<Model>, TMixinBase extends MixinCtor>(
-  MixinBase: MixinCtor & TMixinBase,
-) => {
-  return class extends MixinBase implements FirestoreHelpers {
-    toArray<T extends BaseModelWithIdentifier<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 BaseModelWithIdentifier<T>>(
-      repository: FirestoreRepository<T>,
-    ): repository is FirestoreSubRepository<T> {
-      return !isNil(Object.keys(this).find((key) => key === 'parentRepository'))
-    }
-  }
-}

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

@@ -1,30 +0,0 @@
-import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types'
-
-import { BaseModelWithIdentifier, NonFunctionPropertyNames } from '../../../../domain'
-import { FirestoreRepository, FirestoreSubRepository } from '../types'
-import { MixinCtor } from '../../../../utils'
-
-export const withSubCollection = <
-  TBase extends BaseModelWithIdentifier<TBase>,
-  TBaseParent extends BaseModelWithIdentifier<TBaseParent>,
-  TMixinBase extends MixinCtor,
->(
-  MixinBase: MixinCtor<FirestoreRepository<TBase>> & TMixinBase,
-  ParentModel: new () => TBaseParent,
-) => {
-  return class SubCollectionMix
-    extends MixinBase
-    implements FirestoreSubRepository<TBase, InstanceType<typeof ParentModel>>
-  {
-    readonly parentRepository: FirestoreRepository<InstanceType<typeof ParentModel>>
-    parentIdField: NonFunctionPropertyNames<TBase>
-
-    constructor(...args: Array<any>) {
-      super(args)
-    }
-
-    collection(path?: string): CollectionReference<TBase> {
-      return super.collection(path)
-    }
-  }
-}