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

package/src/infra/firebase/firestore/repositories/users/user-firestore.repository.ts

@@ -0,0 +1,90 @@
+import { DocumentData } from 'firebase/firestore'
+
+import { BeautyProfile, User, UserRepository } from '../../../../../domain'
+import { Base, Log } from '../../../../../utils'
+import { FirestoreConstructorParams, withCrudFirestore, withFirestore, withHelpers } from '../../mixins'
+import { ConnectDocumentData, ConnectDocumentSnapshot } from '../../types'
+
+export class UserFirestoreRepository
+  extends withCrudFirestore(withHelpers(withFirestore<User>(Base)))
+  implements UserRepository
+{
+  constructor({
+    firestore,
+    interceptors,
+    cache,
+  }: Pick<FirestoreConstructorParams<User>, 'firestore' | 'interceptors' | 'cache'>) {
+    super({
+      firestore,
+      collectionName: 'users',
+      model: User,
+      interceptors,
+      cache,
+    })
+  }
+
+  @Log()
+  override async get(identifiers: Partial<User>): Promise<User> {
+    const user = await super.get({ id: identifiers.id })
+
+    user.beautyProfile = await this.getBeautyProfile(user.id)
+    user.isSubscriber = await this.checkIfIsSubscriber(user.id)
+
+    return user
+  }
+
+  @Log()
+  async checkIfExistsByField(field: string, value: string): Promise<boolean> {
+    const result = await this.find({ filters: { [field]: value } })
+
+    return result.count > 0
+  }
+
+  override buildModelInstance(): {
+    toFirestore: (data: User) => ConnectDocumentData<User>
+    fromFirestore: (snap: ConnectDocumentSnapshot<User>) => User
+    } {
+    const { fromFirestore, toFirestore } = super.buildModelInstance()
+
+    return {
+      toFirestore: (data: User): ConnectDocumentData<User> => {
+        const plain = toFirestore(data) as DocumentData & { isSubscriber: boolean }
+
+        delete plain.isSubscriber
+
+        return plain
+      },
+      fromFirestore,
+    }
+  }
+
+  private async getBeautyProfile(userId: string): Promise<BeautyProfile> {
+    const beautyProfile = await this.firestore
+      .getCollection<BeautyProfile>(`${this.collectionName}/${userId}/CX`)
+      .withConverter(this.buildBeautyProfileModelInstance())
+      .getDoc('beautyProfile')
+      .get()
+
+    return beautyProfile.data()
+  }
+
+  private async checkIfIsSubscriber(userId: string): Promise<boolean> {
+    const docs = await this.collection('subscription')
+      .where('user.id', '==', userId)
+      .where('status', '==', 'active')
+      .getDocs()
+
+    return !!docs && !!docs.size
+  }
+
+  private buildBeautyProfileModelInstance(): {
+    toFirestore: (data: BeautyProfile) => ConnectDocumentData<BeautyProfile>
+    fromFirestore: (snap: ConnectDocumentSnapshot<BeautyProfile>) => BeautyProfile
+    } {
+    return {
+      toFirestore: (data: BeautyProfile): DocumentData => data.toPlain(),
+      fromFirestore: (snap: ConnectDocumentSnapshot<BeautyProfile>): BeautyProfile =>
+        BeautyProfile.toInstance(snap.data()),
+    }
+  }
+}

package/src/infra/firebase/firestore/repositories/users/user-payment-method-firestore.repository.ts

@@ -0,0 +1,34 @@
+import { User, UserPaymentMethod, UserPaymentMethodRepository } from '../../../../../domain'
+import { Base } from '../../../../../utils'
+import {
+  FirestoreConstructorParams,
+  withCrudFirestore,
+  withFirestore,
+  withHelpers,
+  withSubCollection,
+} from '../../mixins'
+
+import { UserFirestoreRepository } from './user-firestore.repository'
+
+export class UserPaymentMethodFirestoreRepository
+  extends withSubCollection(withCrudFirestore(withHelpers(withFirestore<UserPaymentMethod>(Base))), User)
+  implements UserPaymentMethodRepository
+{
+  constructor(
+    {
+      firestore,
+      interceptors,
+      cache,
+    }: Pick<FirestoreConstructorParams<UserPaymentMethod>, 'firestore' | 'interceptors' | 'cache'>,
+    override readonly parentRepository: UserFirestoreRepository,
+  ) {
+    super({
+      firestore,
+      collectionName: 'payment_method',
+      parentIdField: 'userId',
+      model: UserPaymentMethod,
+      interceptors,
+      cache,
+    })
+  }
+}

package/src/infra/firebase/firestore/services/connect-collection-reference.ts

@@ -0,0 +1,26 @@
+import { ConnectQuerySnapshot, ConnectWhereOption } from '../types'
+import { ConnectDocumentData } from '../types/connect-firestore/connect-document-data.type'
+import {
+  ConnectDocumentSnapshot,
+  ConnectSnapshotOptions,
+} from '../types/connect-firestore/connect-document-snapshot.type'
+
+import { ConnectDocumentReference } from './connect-document-reference'
+
+export interface ConnectCollectionReference<T extends ConnectDocumentData> {
+  add(data: Partial<T>, id?: string): Promise<ConnectDocumentReference<T>>
+  where(attribute: string, operator: ConnectWhereOption, value: any): ConnectCollectionReference<T>
+  order(attribute: string, order: 'asc' | 'desc'): ConnectCollectionReference<T>
+  limit(quantity: number): ConnectCollectionReference<T>
+  offset(offset: number): ConnectCollectionReference<T>
+  fromStartAt(startAt: number): ConnectCollectionReference<T>
+  fromStartAt(startAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>
+  fromStartAfter(startAt: number): ConnectCollectionReference<T>
+  fromStartAfter(startAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>
+  withConverter(converter: {
+    toFirestore: (data: T) => ConnectDocumentData<T>
+    fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T
+  }): ConnectCollectionReference<T>
+  getDoc(id?: string): ConnectDocumentReference<T>
+  getDocs(): Promise<ConnectQuerySnapshot<T>>
+}

package/src/infra/firebase/firestore/services/connect-collection.service.ts

@@ -0,0 +1,151 @@
+import {
+  addDoc,
+  collection,
+  CollectionReference,
+  doc,
+  DocumentReference,
+  Firestore,
+  getDocs,
+  limit,
+  orderBy,
+  query,
+  QueryConstraint,
+  QueryDocumentSnapshot,
+  QueryFieldFilterConstraint,
+  QueryOrderByConstraint,
+  QueryStartAtConstraint,
+  setDoc,
+  startAfter,
+  where,
+} from 'firebase/firestore'
+
+import { isEmpty } from '../../../../utils'
+import {
+  ConnectDocumentData,
+  ConnectDocumentSnapshot,
+  ConnectQuerySnapshot,
+  ConnectSnapshotOptions,
+  ConnectWhereOption,
+} from '../types'
+import { ConnectBaseDocumentSnapshot } from '../vo'
+
+import { ConnectCollectionReference } from './connect-collection-reference'
+import { ConnectDocumentReference } from './connect-document-reference'
+import { ConnectDocumentService } from './connect-document.service'
+
+export class ConnectCollectionService<T extends ConnectDocumentData> implements ConnectCollectionReference<T> {
+  private reference: CollectionReference<T>
+  private wheres: QueryFieldFilterConstraint[] = []
+  private orderBys: QueryOrderByConstraint[] = []
+  private limitBy: number
+  private offsetBy: number
+  private startingAt: number
+  private startingAfter: QueryStartAtConstraint
+  private converter: {
+    toFirestore: (data: T) => ConnectDocumentData<T>
+    fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T
+  }
+
+  constructor(path: string, private readonly firestore: Firestore) {
+    this.reference = collection(firestore, path).withConverter<T>({
+      toFirestore: (data) => data,
+      fromFirestore: (snapshot) => {
+        return { id: snapshot.id, ...snapshot.data() } as T
+      },
+    })
+  }
+
+  async add(data: T, id?: string): Promise<ConnectDocumentReference<T>> {
+    const newDoc = await this.save(data, id)
+
+    return new ConnectDocumentService<T>(newDoc.path, this.firestore).withConverter(this.converter)
+  }
+
+  async getDocs(): Promise<ConnectQuerySnapshot<T> | any> {
+    if (this.startingAt > 0) this.limitBy += this.startingAt
+
+    const constraints: QueryConstraint[] = [
+      ...this.wheres,
+      ...this.orderBys,
+      ...(this.limitBy ? [limit(this.limitBy)] : []),
+    ]
+
+    return getDocs(query(this.reference, ...constraints)).then((docs) => {
+      const docsPaginated = this.startingAt > 0 ? docs.docs.slice(this.startingAt, this.limitBy) : docs.docs
+
+      return {
+        empty: Boolean(docsPaginated.length),
+        size: docsPaginated.length,
+        docs: docsPaginated.map((doc) => new ConnectBaseDocumentSnapshot(doc)),
+      }
+    })
+  }
+
+  getDoc(id?: string): ConnectDocumentReference<T> {
+    return new ConnectDocumentService<T>(`${this.reference.path}/${id}`, this.firestore).withConverter(this.converter)
+  }
+
+  where(attribute: string, operator: ConnectWhereOption, value: any): ConnectCollectionReference<T> {
+    this.wheres.push(where(attribute, operator, value))
+
+    return this
+  }
+
+  order(attribute: string, order: 'asc' | 'desc'): ConnectCollectionReference<T> {
+    this.orderBys.push(orderBy(attribute, order))
+
+    return this
+  }
+
+  limit(quantity: number): ConnectCollectionReference<T> {
+    this.limitBy = quantity
+
+    return this
+  }
+
+  offset(offsetBy: number): ConnectCollectionReference<T> {
+    this.offsetBy = offsetBy
+
+    return this
+  }
+
+  fromStartAt(startingAt: number): ConnectCollectionReference<T>
+  fromStartAt(startingAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>
+  fromStartAt(startingAt: unknown): ConnectCollectionReference<T> {
+    this.startingAt = startingAt as any
+
+    return this
+  }
+
+  fromStartAfter(startingAt: number): ConnectCollectionReference<T>
+  fromStartAfter(startingAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>
+  fromStartAfter(startingAt: unknown): ConnectCollectionReference<T> {
+    this.startingAfter = startAfter(startingAt)
+
+    return this
+  }
+
+  withConverter(params: {
+    toFirestore: (data: T) => ConnectDocumentData<T>
+    fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T
+  }): ConnectCollectionReference<T> {
+    this.converter = params
+    this.reference = this.reference.withConverter({
+      toFirestore: (data: T) => params.toFirestore(data),
+      fromFirestore: (snapshot: QueryDocumentSnapshot<T>, options?: ConnectSnapshotOptions) =>
+        params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
+    })
+
+    return this
+  }
+
+  private async save(data: T, id?: string): Promise<DocumentReference<T>> {
+    if (isEmpty(id)) return addDoc(this.reference, data)
+
+    const docRef = doc(this.reference, id)
+
+    await setDoc(docRef, data)
+
+    return docRef
+  }
+}

package/src/infra/firebase/firestore/services/connect-document-reference.ts

@@ -0,0 +1,16 @@
+import { ConnectDocumentData } from '../types/connect-firestore/connect-document-data.type'
+import {
+  ConnectDocumentSnapshot,
+  ConnectSnapshotOptions,
+} from '../types/connect-firestore/connect-document-snapshot.type'
+
+export interface ConnectDocumentReference<T extends ConnectDocumentData> {
+  get(): Promise<ConnectDocumentSnapshot<T>>
+  getId(): string
+  save(data: T): Promise<ConnectDocumentReference<T>>
+  delete(): Promise<void>
+  withConverter(converter: {
+    toFirestore: (data: T) => ConnectDocumentData<T>
+    fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T
+  }): ConnectDocumentReference<T>
+}

package/src/infra/firebase/firestore/services/connect-document.service.ts

@@ -0,0 +1,63 @@
+import {
+  deleteDoc,
+  doc,
+  DocumentReference,
+  Firestore,
+  getDoc,
+  QueryDocumentSnapshot,
+  setDoc,
+  UpdateData,
+  updateDoc,
+} from 'firebase/firestore'
+
+import { ConnectDocumentData, ConnectDocumentSnapshot, ConnectSnapshotOptions } from '../types'
+import { ConnectBaseDocumentSnapshot } from '../vo'
+
+import { ConnectDocumentReference } from './connect-document-reference'
+
+export class ConnectDocumentService<T extends ConnectDocumentData> implements ConnectDocumentReference<T> {
+  private reference: DocumentReference<T>
+
+  constructor(private path: string, private firestore: Firestore) {
+    this.reference = doc(this.firestore, this.path).withConverter<T>({
+      toFirestore: (data) => data,
+      fromFirestore: (snapshot) => {
+        return { id: snapshot.id, ...snapshot.data() } as T
+      },
+    })
+  }
+
+  async get(): Promise<ConnectDocumentSnapshot<T>> {
+    return new ConnectBaseDocumentSnapshot(await getDoc(this.reference))
+  }
+
+  getId(): string {
+    return this.reference.id
+  }
+
+  async save(data: T): Promise<ConnectDocumentReference<T>> {
+    const doc = await getDoc(this.reference)
+
+    if (doc.exists()) await updateDoc(this.reference, data as UpdateData<T>)
+    else await setDoc(this.reference, data)
+
+    return this
+  }
+
+  async delete(): Promise<void> {
+    await deleteDoc(this.reference)
+  }
+
+  withConverter(params: {
+    toFirestore: (data: T) => ConnectDocumentData<T>
+    fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T
+  }): ConnectDocumentReference<T> {
+    this.reference = this.reference.withConverter({
+      toFirestore: (data: T) => params.toFirestore(data),
+      fromFirestore: (snapshot: QueryDocumentSnapshot<T>, options?: ConnectSnapshotOptions) =>
+        params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
+    })
+
+    return this
+  }
+}

package/src/infra/firebase/firestore/services/connect-firestore.service.ts

@@ -0,0 +1,21 @@
+import { Firestore } from 'firebase/firestore'
+
+import { ConnectDocumentData } from '../types'
+
+import { ConnectCollectionReference } from './connect-collection-reference'
+import { ConnectCollectionService } from './connect-collection.service'
+import { ConnectDocumentReference } from './connect-document-reference'
+import { ConnectDocumentService } from './connect-document.service'
+import { ConnectFirestore } from './connect-firestore'
+
+export class ConnectFirestoreService implements ConnectFirestore {
+  constructor(private firestore: Firestore) {}
+
+  getCollection<T extends ConnectDocumentData>(path: string): ConnectCollectionReference<T> {
+    return new ConnectCollectionService<T>(path, this.firestore)
+  }
+
+  getDocument<T extends ConnectDocumentData>(path: string): ConnectDocumentReference<T> {
+    return new ConnectDocumentService<T>(path, this.firestore)
+  }
+}

package/src/infra/firebase/firestore/services/connect-firestore.ts

@@ -0,0 +1,9 @@
+import { ConnectDocumentData } from '../types'
+
+import { ConnectCollectionReference } from './connect-collection-reference'
+import { ConnectDocumentReference } from './connect-document-reference'
+
+export interface ConnectFirestore {
+  getCollection<T extends ConnectDocumentData>(path: string): ConnectCollectionReference<T>
+  getDocument<T extends ConnectDocumentData>(path: string): ConnectDocumentReference<T>
+}

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

@@ -0,0 +1,6 @@
+export * from './connect-collection-reference'
+export * from './connect-collection.service'
+export * from './connect-document-reference'
+export * from './connect-document.service'
+export * from './connect-firestore'
+export * from './connect-firestore.service'

package/src/infra/firebase/firestore/types/connect-firestore/connect-document-data.type.ts

@@ -0,0 +1,3 @@
+export type ConnectDocumentData<T extends Record<string, any> = Record<string, any>> = {
+  [K in keyof T]?: any
+} & { id?: string }

package/src/infra/firebase/firestore/types/connect-firestore/connect-document-snapshot.type.ts

@@ -0,0 +1,9 @@
+import { ConnectDocumentData } from './connect-document-data.type'
+
+export type ConnectSnapshotOptions = { serverTimestamps?: 'estimate' | 'previous' | 'none' }
+export type ConnectDocumentSnapshot<T extends ConnectDocumentData = ConnectDocumentData> = {
+  isNotEmpty(): boolean
+  data(options?: ConnectSnapshotOptions): T
+  get(fieldPath: string): any
+  id: string
+}

package/src/infra/firebase/firestore/types/connect-firestore/connect-query-snapshot.type.ts

@@ -0,0 +1,8 @@
+import { ConnectDocumentData } from './connect-document-data.type'
+import { ConnectDocumentSnapshot } from './connect-document-snapshot.type'
+
+export type ConnectQuerySnapshot<T extends ConnectDocumentData> = {
+  docs: ConnectDocumentSnapshot<T>[]
+  size: number
+  empty: boolean
+}

package/src/infra/firebase/firestore/types/connect-firestore/connect-where-option.type.ts

@@ -0,0 +1,3 @@
+import { WhereFilterOp } from 'firebase/firestore'
+
+export type ConnectWhereOption = `${WhereFilterOp}`

package/src/infra/firebase/firestore/types/connect-firestore/index.ts

@@ -0,0 +1,4 @@
+export * from './connect-document-data.type'
+export * from './connect-document-snapshot.type'
+export * from './connect-query-snapshot.type'
+export * from './connect-where-option.type'

package/src/infra/firebase/firestore/types/firestore-interceptors.type.ts

@@ -0,0 +1,23 @@
+import {
+  ModelBaseStructure,
+  RepositoryFindFielters,
+  RepositoryLimitOptions,
+  RepositoryOrderBy,
+} from '../../../../domain'
+
+export type FirestoreIntertceptorRequestParams<TBase extends ModelBaseStructure, T = any> = {
+  instance?: TBase
+  find?: {
+    filters?: RepositoryFindFielters<TBase>
+    limits?: RepositoryLimitOptions<TBase>
+    orderBy?: RepositoryOrderBy<TBase>
+  }
+} & T
+
+export interface FirestoreInterceptors<TBase extends ModelBaseStructure> {
+  request?: <R>(
+    request: FirestoreIntertceptorRequestParams<TBase, R>,
+  ) => Promise<FirestoreIntertceptorRequestParams<TBase, R>>
+  response?<R, T>(response: TBase, request: FirestoreIntertceptorRequestParams<TBase, T>): Promise<TBase & R>
+  response?<R, T>(response: TBase[], request: FirestoreIntertceptorRequestParams<TBase, T>): Promise<TBase[] & R>
+}

package/src/infra/firebase/firestore/types/firestore-sub.repository.type.ts

@@ -0,0 +1,11 @@
+import { IdentifierModel, ModelBaseStructure } from '../../../../domain'
+
+import { FirestoreRepository } from './firestore.repository.type'
+
+export type FirestoreSubRepository<
+  Model extends ModelBaseStructure<Model>,
+  ParentModel extends ModelBaseStructure<ParentModel>,
+> = {
+  readonly parentRepository: FirestoreRepository<ParentModel>
+  parentIdField: IdentifierModel<Model>
+} & FirestoreRepository<Model>

package/src/infra/firebase/firestore/types/firestore.helpers.type.ts

@@ -0,0 +1,13 @@
+import { QueryDocumentSnapshot, QuerySnapshot } from 'firebase/firestore'
+
+import { ModelBaseStructure } from '../../../../domain'
+
+import { FirestoreSubRepository } from './firestore-sub.repository.type'
+import { FirestoreRepository } from './firestore.repository.type'
+
+export interface FirestoreHelpers {
+  toArray<T extends ModelBaseStructure<T>>(snapShot: QuerySnapshot<T> | Array<QueryDocumentSnapshot<T>>): Array<T>
+  isSubCollection<T extends ModelBaseStructure<T>, E extends ModelBaseStructure<E>>(
+    repository: FirestoreRepository<T> | FirestoreSubRepository<T, E>,
+  ): repository is FirestoreSubRepository<T, E>
+}

package/src/infra/firebase/firestore/types/firestore.repository.type.ts

@@ -0,0 +1,28 @@
+import {
+  BaseModelBuilder,
+  CacheConfig,
+  ModelBaseStructure,
+  NonFunctionAndIdentifierPropertyNames,
+} from '../../../../domain'
+import { DebugHelper } from '../../../../utils'
+import { FirestoreFieldType } from '../enums'
+import { ConnectCollectionReference } from '../services/connect-collection-reference'
+import { ConnectFirestore } from '../services/connect-firestore'
+
+import { ConnectDocumentData, ConnectDocumentSnapshot } from './connect-firestore'
+import { FirestoreInterceptors } from './firestore-interceptors.type'
+
+export type FirestoreRepository<Model extends ModelBaseStructure<Model>> = {
+  readonly firestore?: ConnectFirestore
+  collectionName: string
+  model: BaseModelBuilder<Model>
+  collection(path?: string): ConnectCollectionReference<Model>
+  fields?: Partial<Record<NonFunctionAndIdentifierPropertyNames<Model>, FirestoreFieldType>>
+  interceptors?: FirestoreInterceptors<Model>
+  logger: DebugHelper
+  buildModelInstance(): {
+    toFirestore: (data: Model) => ConnectDocumentData<Model>
+    fromFirestore: (snap: ConnectDocumentSnapshot<Model>) => Model
+  }
+  cache?: CacheConfig
+}

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

@@ -0,0 +1,5 @@
+export * from './connect-firestore'
+export * from './firestore-interceptors.type'
+export * from './firestore-sub.repository.type'
+export * from './firestore.helpers.type'
+export * from './firestore.repository.type'

package/src/infra/firebase/firestore/vo/connectBaseDocumentSnapshot.vo.ts

@@ -0,0 +1,25 @@
+import { DocumentSnapshot } from 'firebase/firestore'
+
+import { ConnectDocumentData, ConnectDocumentSnapshot, ConnectSnapshotOptions } from '../types'
+
+export class ConnectBaseDocumentSnapshot<T extends ConnectDocumentData = ConnectDocumentData>
+implements ConnectDocumentSnapshot<T>
+{
+  id: string
+
+  constructor(private readonly connectDocumentSnapshot: DocumentSnapshot<T>) {
+    this.id = connectDocumentSnapshot.id
+  }
+
+  isNotEmpty(): boolean {
+    return this.connectDocumentSnapshot.exists()
+  }
+
+  data(options?: ConnectSnapshotOptions): T {
+    return this.connectDocumentSnapshot.data(options)
+  }
+
+  get(fieldPath: string) {
+    return this.connectDocumentSnapshot.get(fieldPath)
+  }
+}

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

@@ -0,0 +1 @@
+export * from './connectBaseDocumentSnapshot.vo'

package/src/infra/firebase/index.ts

@@ -0,0 +1,3 @@
+export * from './auth'
+export * from './firestore'
+export * from './storage'

package/src/infra/firebase/storage/firebase-file-uploader.service.ts

@@ -0,0 +1,15 @@
+import { FirebaseStorage, StorageReference, ref, uploadBytes } from 'firebase/storage'
+
+import { FileUploaderService } from '../../../domain'
+
+export class FirebaseFileUploaderService implements FileUploaderService {
+  constructor(private storage: FirebaseStorage, private baseUrl: string) {}
+
+  async upload(path: string, file: Blob | Uint8Array | ArrayBuffer): Promise<string> {
+    const storageRef: StorageReference = ref(this.storage, path)
+
+    return uploadBytes(storageRef, file).then(
+      (reference) => `${this.baseUrl}/${reference.ref.bucket}/${reference.ref.fullPath}`,
+    )
+  }
+}

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

@@ -0,0 +1 @@
+export * from './firebase-file-uploader.service'

package/src/infra/hasura-graphql/enums/hasura-graphql-column-type.enum.ts

@@ -0,0 +1,11 @@
+export enum HasuraGraphQLColumnType {
+  Int = 'Int',
+  Float = 'Float',
+  Boolean = 'Boolean',
+  String = 'String',
+  DateTime = 'timestampz',
+  Json = 'json',
+  Jsonb = 'jsonb',
+  Enum = 'enum',
+  Uuid = 'uuid',
+}

package/src/infra/hasura-graphql/enums/hasura-graphql-where.enum.ts

@@ -0,0 +1,18 @@
+export enum HasuraGraphQLWhere {
+  EQUALS = '_eq',
+  GT = '_gt',
+  GTE = '_gte',
+  IN = '_in',
+  NOTIN = '_nin',
+  LT = '_lt',
+  LTE = '_lte',
+  LIKE = '_like',
+  ILIKE = '_ilike',
+  NOTLIKE = '_nlike',
+  ISNULL = '_is_null',
+  ISNOTNULL = '_is_null',
+  JSON_CONTAINS = '_contains',
+  JSON_HAS_KEYS_ANY = '_has_keys_any',
+  IREGEX = '_iregex',
+  REGEX = '_regex',
+}

package/src/infra/hasura-graphql/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './hasura-graphql-where.enum'
+export * from './hasura-graphql-column-type.enum'

package/src/infra/hasura-graphql/index.ts

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