@infrab4a/connect-angular 6.0.0-alpha.0 → 6.0.0-beta.0

package/src/angular-connect.module.ts

@@ -1,256 +0,0 @@
-import { Injector, ModuleWithProviders, NgModule, Type } from '@angular/core'
-import { FirebaseApp, FirebaseOptions, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app'
-import { AppCheckOptions, initializeAppCheck, provideAppCheck } from '@angular/fire/app-check'
-import { getStorage, provideStorage, Storage } from '@angular/fire/storage'
-import {
-  AxiosElasticSearchConfig,
-  FileUploaderService,
-  FirebaseFileUploaderService,
-  isNil,
-  ProductsVertexSearch,
-  Shops,
-  UpdateUserImage,
-  UserRepository,
-  VertexSearchConfig,
-} from '@infrab4a/connect'
-
-import { AngularElasticSeachModule } from './angular-elastic-search.module'
-import { AngularFirebaseAuthModule } from './angular-firebase-auth.module'
-import { AngularFirestoreModule } from './angular-firestore.module'
-import { AngularHasuraGraphQLModule, HasuraGraphQLOptions } from './angular-hasura-graphql.module'
-import { AngularVertexSeachModule } from './angular-vertex-search.module'
-import {
-  APP_CHECK_PROVIDER,
-  BACKEND_URL,
-  CATEGORY_STRUCTURE,
-  DEFAULT_SHOP,
-  ES_CONFIG,
-  FIREBASE_APP_NAME,
-  FIREBASE_OPTIONS,
-  HASURA_OPTIONS,
-  PERSISTENCE_PROVIDER,
-  VERTEX_CONFIG,
-} from './consts'
-import { STORAGE_BASE_URL } from './consts/storage-base-url.const'
-import { CookieDataPersistence, DataPersistence } from './persistence'
-import {
-  AuthService,
-  CartService,
-  CatalogService,
-  CategoryService,
-  CheckoutService,
-  CheckoutSubscriptionService,
-  CouponService,
-  HomeShopService,
-  OrderService,
-  WishlistService,
-} from './services'
-import { CartServicesFacade } from './services/cart'
-import { NewCategoryStructureAdapter, OldCategoryStructureAdapter } from './services/catalog/adapters'
-import { CatalogSearchContext } from './services/catalog/context/catalog-search.context'
-import {
-  CatalogServiceFacade,
-  CatalogStrategiesFacade,
-  CategoryRepositoryFacade,
-  CategoryServiceFacade,
-  ProductCatalogFacade,
-} from './services/catalog/facades'
-import {
-  BrandManagerHelper,
-  CatalogFilterHelper,
-  CatalogSortHelper,
-  ProductFieldsHelper,
-} from './services/catalog/helpers'
-import {
-  CatalogHelpersService,
-  CatalogOperationsFacade,
-  CatalogRepositoryService,
-  ProductManagementFacade,
-} from './services/catalog/services'
-import { CategorySearchStrategy, ProfileSearchStrategy, TermSearchStrategy } from './services/catalog/strategies'
-import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './services/checkout'
-import { CouponRepositoriesFacade } from './services/coupon'
-import { HomeShopRepositoriesFacade } from './services/home-shop'
-import { ConfigurationFacade } from './services/shared'
-import { FirebaseAppConfig } from './types'
-
-@NgModule({
-  imports: [
-    provideFirebaseApp((injector: Injector) => {
-      const appName = injector.get<string>(FIREBASE_APP_NAME)
-
-      try {
-        const app = appName ? getApp(appName) : getApp()
-
-        return app
-      } catch (error) {
-        console.warn('Firebase app not found, initializing new app')
-
-        if (error instanceof Error) console.error(error.message)
-
-        return initializeApp(injector.get(FIREBASE_OPTIONS), appName)
-      }
-    }),
-    provideAppCheck((injector: Injector) => {
-      const app = injector.get(FirebaseApp)
-
-      try {
-        const provider = injector.get<AppCheckOptions['provider']>(APP_CHECK_PROVIDER)
-
-        if (provider)
-          return initializeAppCheck(app, {
-            provider,
-            isTokenAutoRefreshEnabled: true,
-          })
-      } catch (error) {
-        if (error instanceof Error) console.error(error.message)
-
-        return
-      }
-    }),
-    provideStorage((injector: Injector) => getStorage(injector.get(FirebaseApp))),
-    AngularElasticSeachModule,
-    AngularVertexSeachModule,
-    AngularFirebaseAuthModule,
-    AngularFirestoreModule,
-    AngularHasuraGraphQLModule,
-  ],
-  providers: [
-    AuthService,
-    CartService,
-    CatalogService,
-    CategoryService,
-    CheckoutService,
-    CheckoutSubscriptionService,
-    CouponService,
-    HomeShopService,
-    OrderService,
-    WishlistService,
-    ConfigurationFacade,
-    CartServicesFacade,
-    CheckoutRepositoriesFacade,
-    CheckoutDependenciesFacade,
-    CategoryRepositoryFacade,
-    ProductCatalogFacade,
-    CatalogServiceFacade,
-    CategoryServiceFacade,
-    CatalogStrategiesFacade,
-    CatalogOperationsFacade,
-    ProductManagementFacade,
-    {
-      provide: 'ProductServicesFacade',
-      useFactory: (productStockNotificationRepository: any, categoryRepository: any, productSearch: any) => ({
-        productStockNotificationRepository,
-        categoryRepository,
-        productSearch,
-      }),
-      deps: ['ProductStockNotificationRepository', 'CategoryRepository', 'ProductSearch'],
-    },
-    CatalogFilterHelper,
-    CatalogSortHelper,
-    ProductFieldsHelper,
-    BrandManagerHelper,
-    CatalogRepositoryService,
-    CatalogHelpersService,
-    CategorySearchStrategy,
-    TermSearchStrategy,
-    ProfileSearchStrategy,
-    CatalogSearchContext,
-    {
-      provide: UpdateUserImage,
-      useFactory: (userRepository: UserRepository, fileUploader: FileUploaderService) => {
-        return new UpdateUserImage(userRepository, fileUploader)
-      },
-      deps: ['UserRepository', 'FileUploaderService'],
-    },
-    {
-      provide: 'FileUploaderService',
-      useFactory: (storage: Storage, baseUrl: string) => {
-        return new FirebaseFileUploaderService(storage, baseUrl)
-      },
-      deps: [Storage, STORAGE_BASE_URL],
-    },
-    {
-      provide: 'ProductSearch',
-      useExisting: ProductsVertexSearch,
-    },
-    CouponRepositoriesFacade,
-    HomeShopRepositoriesFacade,
-  ],
-})
-export class AngularConnectModule {
-  static initializeApp(
-    defaultShop: Shops,
-    options: {
-      firebase?: FirebaseOptions
-      elasticSearch?: AxiosElasticSearchConfig
-      vertexConfig?: VertexSearchConfig
-      hasura: HasuraGraphQLOptions
-      backendUrl: string
-      oldCategoryStructure?: boolean
-      storageBaseUrl?: string
-      persistenceProvider?: Type<DataPersistence>
-      appCheckProvider?: AppCheckOptions['provider']
-    },
-    nameOrConfig?: string | FirebaseAppConfig,
-  ): ModuleWithProviders<AngularConnectModule> {
-    return {
-      ngModule: AngularConnectModule,
-      providers: [
-        ...this.buildCoreProviders(nameOrConfig, options),
-        ...this.buildConditionalProviders(defaultShop, options),
-      ],
-    }
-  }
-
-  private static buildCoreProviders(
-    nameOrConfig: string | FirebaseAppConfig,
-    options: {
-      appCheckProvider?: AppCheckOptions['provider']
-      oldCategoryStructure?: boolean
-      persistenceProvider?: Type<DataPersistence>
-    },
-  ) {
-    return [
-      { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
-      { provide: APP_CHECK_PROVIDER, useValue: options.appCheckProvider },
-      {
-        provide: CATEGORY_STRUCTURE,
-        useClass: this.selectCategoryStructureAdapter(options.oldCategoryStructure),
-      },
-      { provide: PERSISTENCE_PROVIDER, useClass: options?.persistenceProvider || CookieDataPersistence },
-    ]
-  }
-
-  private static buildConditionalProviders(
-    defaultShop: Shops,
-    options: {
-      firebase?: FirebaseOptions
-      elasticSearch?: AxiosElasticSearchConfig
-      vertexConfig?: VertexSearchConfig
-      hasura: HasuraGraphQLOptions
-      backendUrl: string
-      storageBaseUrl?: string
-    },
-  ) {
-    return [
-      ...this.createProviderIfExists(DEFAULT_SHOP, defaultShop),
-      ...this.createProviderIfExists(FIREBASE_OPTIONS, options.firebase),
-      ...this.createProviderIfExists(ES_CONFIG, options.elasticSearch),
-      ...this.createProviderIfExists(VERTEX_CONFIG, options.vertexConfig),
-      ...this.createProviderIfExists(HASURA_OPTIONS, options.hasura),
-      ...this.createProviderIfExists(BACKEND_URL, options.backendUrl),
-      ...this.createProviderIfExists(STORAGE_BASE_URL, options.storageBaseUrl),
-    ]
-  }
-
-  private static selectCategoryStructureAdapter(oldCategoryStructure?: boolean) {
-    return isNil(oldCategoryStructure) || oldCategoryStructure
-      ? OldCategoryStructureAdapter
-      : NewCategoryStructureAdapter
-  }
-
-  private static createProviderIfExists(token: any, value: any) {
-    return isNil(value) ? [] : [{ provide: token, useValue: value }]
-  }
-}

package/src/angular-elastic-search.module.ts

@@ -1,23 +0,0 @@
-import { ModuleWithProviders, NgModule } from '@angular/core'
-import { AxiosAdapter, AxiosElasticSearchConfig, ProductsIndex } from '@infrab4a/connect'
-
-import { ES_CONFIG } from './consts/es-config.const'
-
-@NgModule({
-  providers: [
-    {
-      provide: ProductsIndex,
-      useFactory: (configuration: AxiosElasticSearchConfig): ProductsIndex =>
-        new ProductsIndex(new AxiosAdapter(configuration)),
-      deps: [ES_CONFIG],
-    },
-  ],
-})
-export class AngularElasticSeachModule {
-  static initializeApp(options: AxiosElasticSearchConfig): ModuleWithProviders<AngularElasticSeachModule> {
-    return {
-      ngModule: AngularElasticSeachModule,
-      providers: [{ provide: ES_CONFIG, useValue: options }],
-    }
-  }
-}

package/src/angular-firebase-auth.module.ts

@@ -1,101 +0,0 @@
-import { Injector, ModuleWithProviders, NgModule } from '@angular/core'
-import { FirebaseApp, FirebaseOptions } from '@angular/fire/app'
-import {
-  Auth,
-  browserLocalPersistence,
-  browserSessionPersistence,
-  getAuth,
-  indexedDBLocalPersistence,
-  initializeAuth,
-  provideAuth,
-} from '@angular/fire/auth'
-import {
-  Authentication,
-  AuthenticationFirebaseAuthService,
-  AuthenticationService,
-  RecoveryPassword,
-  Register,
-  RegisterFirebaseAuthService,
-  RegisterService,
-  SignOut,
-  UserRepository,
-} from '@infrab4a/connect'
-
-import { FIREBASE_APP_NAME, FIREBASE_OPTIONS } from './consts'
-import { FirebaseAppConfig } from './types'
-
-@NgModule({
-  imports: [
-    provideAuth((injector: Injector) => {
-      const app = injector.get(FirebaseApp)
-
-      try {
-        return initializeAuth(app, {
-          persistence: [indexedDBLocalPersistence, browserLocalPersistence, browserSessionPersistence],
-        })
-      } catch (error) {
-        if (error instanceof Error) console.error('Error initializing auth', error.message)
-
-        return getAuth(app)
-      }
-    }),
-  ],
-  providers: [
-    {
-      provide: 'Authentication',
-      useFactory: (authenticationService: AuthenticationService, userRepository: UserRepository): Authentication => {
-        return new Authentication(authenticationService, userRepository)
-      },
-      deps: ['AuthenticationService', 'UserRepository'],
-    },
-    {
-      provide: 'AuthenticationService',
-      useFactory: (angularFireAuth: Auth): AuthenticationService => {
-        return new AuthenticationFirebaseAuthService(angularFireAuth)
-      },
-      deps: [Auth],
-    },
-    {
-      provide: 'Register',
-      useFactory: (registerService: RegisterService, userRepository: UserRepository): Register => {
-        return new Register(registerService, userRepository)
-      },
-      deps: ['RegisterService', 'UserRepository'],
-    },
-    {
-      provide: 'RegisterService',
-      useFactory: (angularFireAuth: Auth): RegisterService => {
-        return new RegisterFirebaseAuthService(angularFireAuth)
-      },
-      deps: [Auth],
-    },
-    {
-      provide: 'SignOut',
-      useFactory: (authenticationService: AuthenticationService): SignOut => {
-        return new SignOut(authenticationService)
-      },
-      deps: ['AuthenticationService'],
-    },
-    {
-      provide: 'RecoveryPassword',
-      useFactory: (authenticationService: AuthenticationService): RecoveryPassword => {
-        return new RecoveryPassword(authenticationService)
-      },
-      deps: ['AuthenticationService'],
-    },
-  ],
-})
-export class AngularFirebaseAuthModule {
-  static initializeApp(
-    options: FirebaseOptions,
-    nameOrConfig?: string | FirebaseAppConfig,
-  ): ModuleWithProviders<AngularFirebaseAuthModule> {
-    return {
-      ngModule: AngularFirebaseAuthModule,
-      providers: [
-        { provide: FIREBASE_OPTIONS, useValue: options },
-        { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
-      ],
-    }
-  }
-}