@infrab4a/connect-angular 5.8.12 → 5.8.13

package/src/angular-firestore.module.ts

@@ -1,416 +0,0 @@
-import { isPlatformBrowser, isPlatformServer } from '@angular/common'
-import { Injector, ModuleWithProviders, NgModule, PLATFORM_ID } from '@angular/core'
-import { FirebaseApp, FirebaseOptions } from '@angular/fire/app'
-import { Firestore, initializeFirestore, memoryLocalCache, provideFirestore } from '@angular/fire/firestore'
-import {
-  AxiosElasticSearchConfig,
-  BeautyProfileRepository,
-  BrandCategoryFirestoreRepository,
-  BrandCategoryRepository,
-  Buy2WinFirestoreRepository,
-  Buy2WinRepository,
-  CampaignDashboardFirestoreRepository,
-  CampaignDashboardRepository,
-  CampaignHashtagFirestoreRepository,
-  CampaignHashtagRepository,
-  CategoryFirestoreRepository,
-  CategoryRepository,
-  CheckoutFirestoreRepository,
-  CheckoutRepository,
-  CheckoutSubscriptionFirestoreRepository,
-  CheckoutSubscriptionRepository,
-  ConnectFirestoreService,
-  CouponFirestoreRepository,
-  CouponRepository,
-  EditionRepository,
-  FirestoreConstructorParams,
-  FirestoreIntertceptorRequestParams,
-  GroupFirestoreRepository,
-  GroupRepository,
-  HomeFirestoreRepository,
-  HomeRepository,
-  LeadFirestoreRepository,
-  LeadRepository,
-  LegacyOrderFirestoreRepository,
-  LegacyOrderRepository,
-  LogFirestoreRepository,
-  LogRepository,
-  OrderBlockedFirestoreRepository,
-  OrderBlockedRepository,
-  OrderFirestoreRepository,
-  OrderRepository,
-  PaymentFirestoreRepository,
-  PaymentRepository,
-  ProductFirestoreRepository,
-  ProductRepository,
-  ProductVariantFirestoreRepository,
-  SequenceFirestoreRepository,
-  ShopConfigsFirestoreRepository,
-  ShopConfigsRepository,
-  ShopMenuFirestoreRepository,
-  ShopMenuRepository,
-  ShoppingRecurrenceEditionFirestoreRepository,
-  ShoppingRecurrenceEditionRepository,
-  ShoppingRecurrenceErrorLogFirestoreRepository,
-  ShoppingRecurrenceErrorLogRepository,
-  ShoppingRecurrenceFirestoreRepository,
-  ShoppingRecurrenceRepository,
-  ShopSettingsFirestoreRepository,
-  ShopSettingsRepository,
-  SubscriptionEditionFirestoreRepository,
-  SubscriptionFirestoreRepository,
-  SubscriptionMaterializationFirestoreRepository,
-  SubscriptionMaterializationRepository,
-  SubscriptionPaymentFirestoreRepository,
-  SubscriptionPaymentRepository,
-  SubscriptionPlanFirestoreRepository,
-  SubscriptionPlanRepository,
-  SubscriptionProductFirestoreRepository,
-  SubscriptionProductRepository,
-  SubscriptionRepository,
-  SubscriptionSummaryFirestoreRepository,
-  SubscriptionSummaryRepository,
-  UserAddressFirestoreRepository,
-  UserAddressRepository,
-  UserBeautyProfileFirestoreRepository,
-  UserFirestoreRepository,
-  UserPaymentMethodFirestoreRepository,
-  UserPaymentMethodRepository,
-  UserRepository,
-  VariantRepository,
-} from '@infrab4a/connect'
-
-import { AngularElasticSeachModule } from './angular-elastic-search.module'
-import { ES_CONFIG, FIREBASE_APP_NAME, FIREBASE_OPTIONS } from './consts'
-import { MobileOperationSystemCheckerHelper } from './helpers'
-import { FirebaseAppConfig } from './types'
-
-export type FirestoreOptions = Pick<FirestoreConstructorParams<any>, 'firestore' | 'interceptors'>
-
-@NgModule({
-  imports: [
-    AngularElasticSeachModule,
-    provideFirestore((injector: Injector) => {
-      const platformId = injector.get(PLATFORM_ID)
-
-      if (isPlatformServer(platformId) || !MobileOperationSystemCheckerHelper.isAppleDevice())
-        return initializeFirestore(injector.get(FirebaseApp), {
-          ignoreUndefinedProperties: true,
-        })
-
-      const firestore = initializeFirestore(injector.get(FirebaseApp), {
-        experimentalForceLongPolling: true,
-        ignoreUndefinedProperties: true,
-        localCache: memoryLocalCache(),
-      })
-
-      return firestore
-    }),
-  ],
-  providers: [
-    {
-      provide: 'FirestoreOptions',
-      useFactory: (firestore: Firestore, platformId: string): FirestoreOptions => ({
-        firestore: new ConnectFirestoreService(firestore),
-        interceptors: {
-          request: (request: FirestoreIntertceptorRequestParams<any> & { interval: ReturnType<typeof setTimeout> }) => {
-            if (isPlatformBrowser(platformId)) return request
-
-            const interval = setInterval(() => {}, 100)
-
-            request.interval = interval
-
-            return request
-          },
-          response: (
-            response: any,
-            request: FirestoreIntertceptorRequestParams<any> & { interval: ReturnType<typeof setTimeout> },
-          ) => {
-            if (isPlatformBrowser(platformId)) return response
-
-            clearInterval(request.interval)
-
-            return response
-          },
-        },
-      }),
-      deps: [Firestore, PLATFORM_ID],
-    },
-    {
-      provide: 'BeautyProfileRepository',
-      useFactory: (config: FirestoreOptions, userRepository: UserFirestoreRepository): BeautyProfileRepository => {
-        return new UserBeautyProfileFirestoreRepository(config, userRepository)
-      },
-      deps: ['FirestoreOptions', 'UserRepository'],
-    },
-    {
-      provide: 'Buy2WinRepository',
-      useFactory: (options: FirestoreOptions): Buy2WinRepository => {
-        return new Buy2WinFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: CategoryFirestoreRepository,
-      useFactory: (options: FirestoreOptions): CategoryRepository => {
-        return new CategoryFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CheckoutRepository',
-      useFactory: (options: FirestoreOptions): CheckoutRepository => {
-        return new CheckoutFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CheckoutSubscriptionRepository',
-      useFactory: (options: FirestoreOptions): CheckoutSubscriptionRepository => {
-        return new CheckoutSubscriptionFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CouponRepository',
-      useFactory: (options: FirestoreOptions): CouponRepository => {
-        return new CouponFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CampaignHashtagRepository',
-      useFactory: (options: FirestoreOptions): CampaignHashtagRepository => {
-        return new CampaignHashtagFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CampaignDashboardRepository',
-      useFactory: (options: FirestoreOptions): CampaignDashboardRepository => {
-        return new CampaignDashboardFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'EditionRepository',
-      useFactory: (
-        options: FirestoreOptions,
-        subscriptionRepository: SubscriptionFirestoreRepository,
-      ): EditionRepository => {
-        return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository)
-      },
-      deps: ['FirestoreOptions', 'SubscriptionRepository'],
-    },
-    {
-      provide: 'GroupRepository',
-      useFactory: (options: FirestoreOptions): GroupRepository => {
-        return new GroupFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'HomeRepository',
-      useFactory: (options: FirestoreOptions): HomeRepository => {
-        return new HomeFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'LeadRepository',
-      useFactory: (options: FirestoreOptions): LeadRepository => {
-        return new LeadFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'LegacyOrderRepository',
-      useFactory: (options: FirestoreOptions): LegacyOrderRepository => {
-        return new LegacyOrderFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShopMenuRepository',
-      useFactory: (options: FirestoreOptions): ShopMenuRepository => {
-        return new ShopMenuFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'OrderRepository',
-      useFactory: (options: FirestoreOptions): OrderRepository => {
-        return new OrderFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'PaymentRepository',
-      useFactory: (options: FirestoreOptions): PaymentRepository => {
-        return new PaymentFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShoppingRecurrenceRepository',
-      useFactory: (options: FirestoreOptions): ShoppingRecurrenceRepository => {
-        return new ShoppingRecurrenceFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShoppingRecurrenceEditionRepository',
-      useFactory: (options: FirestoreOptions): ShoppingRecurrenceEditionRepository => {
-        return new ShoppingRecurrenceEditionFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShoppingRecurrenceErrorLogRepository',
-      useFactory: (options: FirestoreOptions): ShoppingRecurrenceErrorLogRepository => {
-        return new ShoppingRecurrenceErrorLogFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: ProductFirestoreRepository,
-      useFactory: (options: FirestoreOptions): ProductRepository => {
-        return new ProductFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShopSettingsRepository',
-      useFactory: (options: FirestoreOptions): ShopSettingsRepository => {
-        return new ShopSettingsFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionPaymentRepository',
-      useFactory: (
-        options: FirestoreOptions,
-        subscriptionRepository: SubscriptionFirestoreRepository,
-      ): SubscriptionPaymentRepository => {
-        return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository)
-      },
-      deps: ['FirestoreOptions', 'SubscriptionRepository'],
-    },
-    {
-      provide: 'SubscriptionPlanRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionPlanRepository => {
-        return new SubscriptionPlanFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionProductRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionProductRepository => {
-        return new SubscriptionProductFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionRepository => {
-        return new SubscriptionFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'UserRepository',
-      useFactory: (options: FirestoreOptions): UserRepository => {
-        return new UserFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'UserAddressRepository',
-      useFactory: (options: FirestoreOptions, userRepository: UserFirestoreRepository): UserAddressRepository => {
-        return new UserAddressFirestoreRepository(options, userRepository)
-      },
-      deps: ['FirestoreOptions', 'UserRepository'],
-    },
-    {
-      provide: 'UserPaymentMethodRepository',
-      useFactory: (options: FirestoreOptions, userRepository: UserFirestoreRepository): UserPaymentMethodRepository => {
-        return new UserPaymentMethodFirestoreRepository(options, userRepository)
-      },
-      deps: ['FirestoreOptions', 'UserRepository'],
-    },
-    {
-      provide: 'SubscriptionMaterializationRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionMaterializationRepository => {
-        return new SubscriptionMaterializationFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionSummaryRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionSummaryRepository => {
-        return new SubscriptionSummaryFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: ProductVariantFirestoreRepository,
-      useFactory: (options: FirestoreOptions, productRepository: ProductFirestoreRepository): VariantRepository => {
-        return new ProductVariantFirestoreRepository(options, productRepository)
-      },
-      deps: ['FirestoreOptions', ProductFirestoreRepository],
-    },
-    {
-      provide: 'OrderBlockedRepository',
-      useFactory: (options: FirestoreOptions): OrderBlockedRepository => {
-        return new OrderBlockedFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'LogRepository',
-      useFactory: (options: FirestoreOptions): LogRepository => {
-        return new LogFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SequenceRepository',
-      useFactory: (options: FirestoreOptions): SequenceFirestoreRepository => {
-        return new SequenceFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'BrandCategoryRepository',
-      useFactory: (options: FirestoreOptions): BrandCategoryRepository => {
-        return new BrandCategoryFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShopConfigsRepository',
-      useFactory: (options: FirestoreOptions): ShopConfigsRepository => {
-        return new ShopConfigsFirestoreRepository(options)
-      },
-      deps: ['FirestoreOptions'],
-    },
-  ],
-})
-export class AngularFirestoreModule {
-  static initializeApp(
-    options: {
-      firebase: FirebaseOptions
-      elasticSearch: AxiosElasticSearchConfig
-    },
-    nameOrConfig?: string | FirebaseAppConfig,
-  ): ModuleWithProviders<AngularFirestoreModule> {
-    return {
-      ngModule: AngularFirestoreModule,
-      providers: [
-        { provide: FIREBASE_OPTIONS, useValue: options.firebase },
-        { provide: FIREBASE_APP_NAME, useValue: nameOrConfig },
-        { provide: ES_CONFIG, useValue: options.elasticSearch },
-      ],
-    }
-  }
-}

package/src/angular-hasura-graphql.module.ts

@@ -1,269 +0,0 @@
-import { isPlatformBrowser } from '@angular/common'
-import { ModuleWithProviders, NgModule, PLATFORM_ID } from '@angular/core'
-import {
-  CacheConfig,
-  CategoryCollectionChildrenHasuraGraphQLRepository,
-  CategoryFilterHasuraGraphQLRepository,
-  CategoryFilterRepository,
-  CategoryHasuraGraphQLRepository,
-  CategoryProductHasuraGraphQLRepository,
-  CategoryRepository,
-  FilterHasuraGraphQLRepository,
-  FilterOptionHasuraGraphQLRepository,
-  FilterOptionRepository,
-  FilterRepository,
-  GraphQLParams,
-  HasuraConstructorParams,
-  HasuraGraphQLAuthOptions,
-  ProductCatalogHasuraGraphQLRepository,
-  ProductErrors,
-  ProductErrorsHasuraGraphQLRepository,
-  ProductErrorsRepository,
-  ProductGroupHasuraGraphQLRepository,
-  ProductHasuraGraphQLRepository,
-  ProductPriceLogHasuraGraphQLRepository,
-  ProductRepository,
-  ProductReviewHasuraGraphQLRepository,
-  ProductReviewRepository,
-  ProductStockEntryHasuraGraphQLRepository,
-  ProductStockEntryRepository,
-  ProductStockNotificationHasuraGraphQLRepository,
-  ProductStockNotificationRepository,
-  resolveCacheConfig,
-  VariantHasuraGraphQLRepository,
-  VariantRepository,
-  WishlistHasuraGraphQLRepository,
-} from '@infrab4a/connect'
-
-import { HASURA_OPTIONS } from './consts'
-
-export type HasuraGraphQLOptions = { endpoint: string; credentials?: HasuraGraphQLAuthOptions; cache?: CacheConfig }
-
-@NgModule({
-  providers: [
-    {
-      provide: 'HasuraConfig',
-      useFactory: (options: HasuraGraphQLOptions, platformId: string) => ({
-        endpoint: options.endpoint,
-        authOptions: options.credentials,
-        cache: resolveCacheConfig(options.cache),
-        interceptors: {
-          request: (request: GraphQLParams<any> & { interval: ReturnType<typeof setTimeout> }) => {
-            if (isPlatformBrowser(platformId)) return request
-
-            const interval = setInterval(() => {}, 100)
-
-            request.interval = interval
-
-            return request
-          },
-          response: (response: any, request: GraphQLParams<any> & { interval: ReturnType<typeof setTimeout> }) => {
-            if (isPlatformBrowser(platformId)) return response
-
-            clearInterval(request.interval)
-
-            return response
-          },
-        },
-      }),
-      deps: [HASURA_OPTIONS, PLATFORM_ID],
-    },
-    {
-      provide: 'CategoryRepository',
-      useExisting: CategoryHasuraGraphQLRepository,
-    },
-    {
-      provide: CategoryHasuraGraphQLRepository,
-      useFactory: (
-        options: any,
-        productRepository: ProductHasuraGraphQLRepository,
-        categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
-      ): CategoryRepository => {
-        return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository)
-      },
-      deps: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-    },
-    {
-      provide: 'ProductRepository',
-      useExisting: ProductHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): ProductRepository => {
-        return new ProductHasuraGraphQLRepository(hasuraConfig)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductReviewRepository',
-      useExisting: ProductReviewHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductReviewHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): ProductReviewRepository => {
-        return new ProductReviewHasuraGraphQLRepository(hasuraConfig)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'VariantRepository',
-      useExisting: VariantHasuraGraphQLRepository,
-    },
-    {
-      provide: VariantHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): VariantRepository => {
-        return new VariantHasuraGraphQLRepository(hasuraConfig)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductStockNotificationRepository',
-      useExisting: ProductStockNotificationHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductStockNotificationHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): ProductStockNotificationRepository => {
-        return new ProductStockNotificationHasuraGraphQLRepository(hasuraConfig)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'CategoryFilterRepository',
-      useExisting: CategoryFilterHasuraGraphQLRepository,
-    },
-    {
-      provide: CategoryFilterHasuraGraphQLRepository,
-      useFactory: (options: any): CategoryFilterRepository => {
-        return new CategoryFilterHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'FilterOptionRepository',
-      useExisting: FilterOptionHasuraGraphQLRepository,
-    },
-    {
-      provide: FilterOptionHasuraGraphQLRepository,
-      useFactory: (options: any): FilterOptionRepository => {
-        return new FilterOptionHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'FilterRepository',
-      useExisting: FilterHasuraGraphQLRepository,
-    },
-    {
-      provide: FilterHasuraGraphQLRepository,
-      useFactory: (
-        options: any,
-        filterOptionRepository: FilterOptionHasuraGraphQLRepository,
-        categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
-      ): FilterRepository => {
-        return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository)
-      },
-      deps: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-    },
-    {
-      provide: CategoryCollectionChildrenHasuraGraphQLRepository,
-      useFactory: (options: any): CategoryCollectionChildrenHasuraGraphQLRepository =>
-        new CategoryCollectionChildrenHasuraGraphQLRepository(options),
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'CategoryCollectionChildrenRepository',
-      useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-    },
-    {
-      provide: CategoryProductHasuraGraphQLRepository,
-      useFactory: (options: any): CategoryProductHasuraGraphQLRepository => {
-        return new CategoryProductHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'CategoryProductRepository',
-      useExisting: CategoryProductHasuraGraphQLRepository,
-    },
-    {
-      provide: WishlistHasuraGraphQLRepository,
-      useFactory: (
-        options: any,
-        categoryProductRepository: CategoryProductHasuraGraphQLRepository,
-      ): WishlistHasuraGraphQLRepository => {
-        return new WishlistHasuraGraphQLRepository(options, categoryProductRepository)
-      },
-      deps: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
-    },
-    {
-      provide: 'WishlistRepository',
-      useExisting: WishlistHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductErrorsHasuraGraphQLRepository,
-      useFactory: (
-        options: HasuraConstructorParams<ProductErrors>,
-        productRepository: ProductHasuraGraphQLRepository,
-      ): ProductErrorsRepository => {
-        return new ProductErrorsHasuraGraphQLRepository(options, productRepository)
-      },
-      deps: ['HasuraConfig', ProductHasuraGraphQLRepository],
-    },
-    {
-      provide: 'ProductErrorsRepository',
-      useExisting: ProductErrorsHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductCatalogHasuraGraphQLRepository,
-      useFactory: (options: any): ProductCatalogHasuraGraphQLRepository => {
-        return new ProductCatalogHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductCatalogRepository',
-      useExisting: ProductCatalogHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductStockEntryHasuraGraphQLRepository,
-      useFactory: (options: any): ProductStockEntryRepository => {
-        return new ProductStockEntryHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductStockEntryRepository',
-      useExisting: ProductStockEntryHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductGroupHasuraGraphQLRepository,
-      useFactory: (options: any): ProductGroupHasuraGraphQLRepository => {
-        return new ProductGroupHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductGroupRepository',
-      useExisting: ProductGroupHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductPriceLogHasuraGraphQLRepository,
-      useFactory: (options: any): ProductPriceLogHasuraGraphQLRepository => {
-        return new ProductPriceLogHasuraGraphQLRepository(options)
-      },
-      deps: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductPriceLogRepository',
-      useExisting: ProductPriceLogHasuraGraphQLRepository,
-    },
-  ],
-})
-export class AngularHasuraGraphQLModule {
-  static initializeApp(options: HasuraGraphQLOptions): ModuleWithProviders<AngularHasuraGraphQLModule> {
-    return {
-      ngModule: AngularHasuraGraphQLModule,
-      providers: [{ provide: HASURA_OPTIONS, useValue: options }],
-    }
-  }
-}

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

@@ -1,23 +0,0 @@
-import { ModuleWithProviders, NgModule } from '@angular/core'
-import { ProductsVertexSearch, VertexAxiosAdapter, VertexSearchConfig } from '@infrab4a/connect'
-
-import { VERTEX_CONFIG } from './consts'
-
-@NgModule({
-  providers: [
-    {
-      provide: ProductsVertexSearch,
-      useFactory: (configuration: VertexSearchConfig): ProductsVertexSearch =>
-        new ProductsVertexSearch(new VertexAxiosAdapter(configuration)),
-      deps: [VERTEX_CONFIG],
-    },
-  ],
-})
-export class AngularVertexSeachModule {
-  static initializeApp(options: VertexSearchConfig): ModuleWithProviders<AngularVertexSeachModule> {
-    return {
-      ngModule: AngularVertexSeachModule,
-      providers: [{ provide: VERTEX_CONFIG, useValue: options }],
-    }
-  }
-}

package/src/consts/backend-url.const.ts

@@ -1 +0,0 @@
-export const BACKEND_URL = 'BACKEND_URL'