@infrab4a/connect 0.17.0-beta.8 → 0.17.1-beta.1

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export type FirebaseUserWithId = firebase.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/index.ts

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

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,36 @@
+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

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

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

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

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

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

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

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

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

@@ -0,0 +1,69 @@
+import firebase from 'firebase'
+
+import {
+  BaseModelWithIdentifier,
+  NonFunctionPropertyNames,
+  RepositoryUpdateParams,
+  UpdateOptionActions,
+  UpdateOptions,
+  UpdateRepository,
+} from '../../../../domain'
+import { FirestoreHelpers, FirestoreRepository } from '../types'
+import { isNil, MixinCtor, PropType } from '../../../../utils'
+
+export const withUpdateFirestore = <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor>(
+  MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase,
+) => {
+  const getValueFromParams = (
+    params: RepositoryUpdateParams<TBase>,
+    field: NonFunctionPropertyNames<TBase>,
+  ): PropType<TBase, NonFunctionPropertyNames<TBase>> =>
+    (isNil(params[field as string]?.value) ? params[field as string] : params[field as string].value) || null
+  const getValueByAction = (options: UpdateOptions<TBase>): firebase.firestore.FieldValue | unknown => {
+    const fieldValues = firebase.firestore.FieldValue
+
+    if (isNil(options.action)) return options
+    if (options.action === UpdateOptionActions.REMOVE_FIELD) return fieldValues.delete()
+    if (Array.isArray(options.value)) {
+      if (options.action === UpdateOptionActions.MERGE) return fieldValues.arrayUnion(...options.value)
+      if (options.action === UpdateOptionActions.REMOVE) return fieldValues.arrayRemove(...options.value)
+    }
+
+    return options.value
+  }
+
+  return class UpdateFirestore extends MixinBase implements UpdateRepository<TBase> {
+    async update(data: RepositoryUpdateParams<TBase>): Promise<TBase> {
+      const model = new this.model()
+      const keyField = model.identifierFields().shift()
+      const docRef = this.collection(this.buildCollectionPathForUpdate(data)).doc(
+        getValueFromParams(data, keyField).toString(),
+      )
+
+      await docRef.set(this.paramsToPlain(data), { merge: true })
+
+      const doc = await docRef.get()
+
+      return doc.data()
+    }
+
+    buildCollectionPathForUpdate(identifiers: RepositoryUpdateParams<TBase>): string {
+      return this.isSubCollection(this)
+        ? `${this.parentRepository.collectionName}/${getValueFromParams(identifiers, this.parentIdField)}/${
+            this.collectionName
+          }`
+        : this.collectionName
+    }
+
+    paramsToPlain(params: RepositoryUpdateParams<TBase>): Partial<TBase> {
+      const model = this.model
+
+      if (params instanceof model) return params
+
+      return Object.keys(params).reduce(
+        (data, currentKey) => ({ ...data, [currentKey]: getValueByAction(params[currentKey]) }),
+        {},
+      )
+    }
+  }
+}

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

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

package/src/infra/firebase/firestore/models/user-search.ts

@@ -0,0 +1,13 @@
+import { BaseModel, IdentifierFields, NonFunctionPropertyNames } from '../../../../domain/general'
+
+export class UserSearch extends BaseModel<UserSearch> implements IdentifierFields<UserSearch> {
+  id: string
+  cpf?: string
+  email?: string
+  createdAt: Date
+  copiedAt: Date
+
+  identifierFields(): NonFunctionPropertyNames<UserSearch>[] {
+    return ['id']
+  }
+}