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

package/eslint.config.js

@@ -0,0 +1,18 @@
+const baseConfig = require('../../eslint.config.js')
+
+module.exports = [
+  ...baseConfig,
+  {
+    files: ['**/*.ts'],
+    languageOptions: {
+      parserOptions: {
+        project: './tsconfig.json',
+      },
+    },
+    rules: {
+      // Regras específicas para o projeto connect-angular
+      // Relaxar algumas regras para componentes Angular
+      '@typescript-eslint/explicit-member-accessibility': 'off',
+    },
+  },
+]

package/index.ts

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

package/karma.conf.js

@@ -0,0 +1,32 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage-istanbul-reporter'),
+      require('@angular-devkit/build-angular/plugins/karma'),
+    ],
+    client: {
+      clearContext: false, // leave Jasmine Spec Runner output visible in browser
+    },
+    coverageIstanbulReporter: {
+      dir: require('path').join(__dirname, '../../coverage/connect-angular'),
+      reports: ['html', 'lcovonly', 'text-summary'],
+      fixWebpackSourcePaths: true,
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true,
+  })
+}

package/ng-package.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/connect-angular",
+  "lib": {
+    "entryFile": "src/index.ts"
+  },
+  "allowedNonPeerDependencies": ["js-cookie", "ts-custom-error", "@infrab4a/connect"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrab4a/connect-angular",
-  "version": "5.1.0",
+  "version": "6.0.0-alpha.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
@@ -9,35 +9,17 @@
     "url": "https://github.com/B4AGroup/b4a-firebase-libs"
   },
   "peerDependencies": {
-    "@angular/common": "^17.0.0",
-    "@angular/core": "^17.0.0",
-    "@angular/fire": "^17.0.0-next.0",
-    "@infrab4a/connect": "^4.9.0-beta.0",
+    "@angular/common": "^15.1.4",
+    "@angular/core": "^15.1.4",
+    "@angular/fire": "7.5.0",
+    "@infrab4a/connect": "6.0.0-alpha.0",
+    "class-transformer": "^0.5.1",
     "js-cookie": "^3.0.1",
-    "rxjs": "^7.8.1"
+    "rxjs": "^6.6.7",
+    "ts-custom-error": "^3.3.1"
   },
   "dependencies": {
     "js-cookie": "^3.0.1",
     "tslib": "^2.4.0"
-  },
-  "module": "fesm2015/infrab4a-connect-angular.mjs",
-  "es2020": "fesm2020/infrab4a-connect-angular.mjs",
-  "esm2020": "esm2020/infrab4a-connect-angular.mjs",
-  "fesm2020": "fesm2020/infrab4a-connect-angular.mjs",
-  "fesm2015": "fesm2015/infrab4a-connect-angular.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "esm2020": "./esm2020/infrab4a-connect-angular.mjs",
-      "es2020": "./fesm2020/infrab4a-connect-angular.mjs",
-      "es2015": "./fesm2015/infrab4a-connect-angular.mjs",
-      "node": "./fesm2015/infrab4a-connect-angular.mjs",
-      "default": "./fesm2020/infrab4a-connect-angular.mjs"
-    }
-  },
-  "sideEffects": false
-}
+  }
+}

package/project.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "name": "connect-angular",
+  "projectType": "library",
+  "sourceRoot": "projects/connect-angular/src",
+  "prefix": "infrab4a",
+  "tags": ["type:lib", "scope:publishable", "framework:angular"],
+  "targets": {
+    "build": {
+      "executor": "@angular-devkit/build-angular:ng-packagr",
+      "options": {
+        "tsConfig": "projects/connect-angular/tsconfig.lib.json",
+        "project": "projects/connect-angular/ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "projects/connect-angular/tsconfig.lib.prod.json"
+        }
+      },
+      "outputs": ["{workspaceRoot}/dist/connect-angular"]
+    },
+    "test": {
+      "executor": "@angular-devkit/build-angular:karma",
+      "options": {
+        "main": "projects/connect-angular/src/test.ts",
+        "tsConfig": "projects/connect-angular/tsconfig.spec.json",
+        "karmaConfig": "projects/connect-angular/karma.conf.js"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "options": {
+        "lintFilePatterns": ["projects/connect-angular/**/*.ts"]
+      }
+    }
+  }
+}

package/src/angular-connect.module.ts

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

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

@@ -0,0 +1,101 @@
+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 },
+      ],
+    }
+  }
+}