@infrab4a/connect-nestjs 3.0.0-alpha.0 → 3.0.0-alpha.1

package/src/nest-firestore.module.ts

@@ -1,363 +0,0 @@
-import {
-  BeautyProfileRepository,
-  Buy2WinFirestoreRepository,
-  Buy2WinRepository,
-  CampaignDashboardFirestoreRepository,
-  CampaignDashboardRepository,
-  CampaignHashtagFirestoreRepository,
-  CampaignHashtagRepository,
-  CategoryFirestoreRepository,
-  CategoryRepository,
-  CheckoutFirestoreRepository,
-  CheckoutRepository,
-  CheckoutSubscriptionFirestoreRepository,
-  CheckoutSubscriptionRepository,
-  CouponFirestoreRepository,
-  CouponRepository,
-  EditionRepository,
-  FirestoreConstructorParams,
-  GroupFirestoreRepository,
-  GroupRepository,
-  HomeFirestoreRepository,
-  HomeRepository,
-  LeadFirestoreRepository,
-  LeadRepository,
-  LegacyOrderFirestoreRepository,
-  LegacyOrderRepository,
-  LogFirestoreRepository,
-  LogRepository,
-  OrderBlockedFirestoreRepository,
-  OrderBlockedRepository,
-  OrderFirestoreRepository,
-  OrderRepository,
-  PaymentFirestoreRepository,
-  PaymentRepository,
-  ProductFirestoreRepository,
-  ProductRepository,
-  ProductVariantFirestoreRepository,
-  SequenceFirestoreRepository,
-  ShopMenuFirestoreRepository,
-  ShopMenuRepository,
-  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 { DynamicModule, Module } from '@nestjs/common'
-import { FirebaseAdmin, FirebaseConstants, FirebaseModule } from 'nestjs-firebase'
-
-import { ConnectFirestoreService } from './infra'
-import { NestStorageModule } from './nest-storage.module'
-
-export type FirestoreOptions = Pick<FirestoreConstructorParams<any>, 'firestore' | 'interceptors'>
-
-@Module({
-  providers: [
-    {
-      provide: ConnectFirestoreService,
-      useFactory: (firebaseAdmin: FirebaseAdmin) => new ConnectFirestoreService(firebaseAdmin.firestore),
-      inject: [FirebaseConstants.FIREBASE_TOKEN],
-    },
-    {
-      provide: 'FirestoreOptions',
-      useFactory: (connectFirestoreService: ConnectFirestoreService): FirestoreOptions => ({
-        firestore: connectFirestoreService,
-      }),
-      inject: [ConnectFirestoreService],
-    },
-    {
-      provide: 'BeautyProfileRepository',
-      useFactory: (config: FirestoreOptions, userRepository: UserFirestoreRepository): BeautyProfileRepository => {
-        return new UserBeautyProfileFirestoreRepository(config, userRepository)
-      },
-      inject: ['FirestoreOptions', 'UserRepository'],
-    },
-    {
-      provide: 'Buy2WinRepository',
-      useFactory: (options: FirestoreOptions): Buy2WinRepository => {
-        return new Buy2WinFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: CategoryFirestoreRepository,
-      useFactory: (options: FirestoreOptions): CategoryRepository => {
-        return new CategoryFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CheckoutRepository',
-      useFactory: (options: FirestoreOptions): CheckoutRepository => {
-        return new CheckoutFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CheckoutSubscriptionRepository',
-      useFactory: (options: FirestoreOptions): CheckoutSubscriptionRepository => {
-        return new CheckoutSubscriptionFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CouponRepository',
-      useFactory: (options: FirestoreOptions): CouponRepository => {
-        return new CouponFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CampaignHashtagRepository',
-      useFactory: (options: FirestoreOptions): CampaignHashtagRepository => {
-        return new CampaignHashtagFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'CampaignDashboardRepository',
-      useFactory: (options: FirestoreOptions): CampaignDashboardRepository => {
-        return new CampaignDashboardFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'EditionRepository',
-      useFactory: (
-        options: FirestoreOptions,
-        subscriptionRepository: SubscriptionFirestoreRepository,
-      ): EditionRepository => {
-        return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository)
-      },
-      inject: ['FirestoreOptions', 'SubscriptionRepository'],
-    },
-    {
-      provide: 'GroupRepository',
-      useFactory: (options: FirestoreOptions): GroupRepository => {
-        return new GroupFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'HomeRepository',
-      useFactory: (options: FirestoreOptions): HomeRepository => {
-        return new HomeFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'LeadRepository',
-      useFactory: (options: FirestoreOptions): LeadRepository => {
-        return new LeadFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'LegacyOrderRepository',
-      useFactory: (options: FirestoreOptions): LegacyOrderRepository => {
-        return new LegacyOrderFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShopMenuRepository',
-      useFactory: (options: FirestoreOptions): ShopMenuRepository => {
-        return new ShopMenuFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'OrderRepository',
-      useFactory: (options: FirestoreOptions): OrderRepository => {
-        return new OrderFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'PaymentRepository',
-      useFactory: (options: FirestoreOptions): PaymentRepository => {
-        return new PaymentFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: ProductFirestoreRepository,
-      useFactory: (options: FirestoreOptions): ProductRepository => {
-        return new ProductFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'ShopSettingsRepository',
-      useFactory: (options: FirestoreOptions): ShopSettingsRepository => {
-        return new ShopSettingsFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionPaymentRepository',
-      useFactory: (
-        options: FirestoreOptions,
-        subscriptionRepository: SubscriptionFirestoreRepository,
-      ): SubscriptionPaymentRepository => {
-        return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository)
-      },
-      inject: ['FirestoreOptions', 'SubscriptionRepository'],
-    },
-    {
-      provide: 'SubscriptionPlanRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionPlanRepository => {
-        return new SubscriptionPlanFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionProductRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionProductRepository => {
-        return new SubscriptionProductFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionRepository => {
-        return new SubscriptionFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'UserRepository',
-      useFactory: (options: FirestoreOptions): UserRepository => {
-        return new UserFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'UserAddressRepository',
-      useFactory: (options: FirestoreOptions, userRepository: UserFirestoreRepository): UserAddressRepository => {
-        return new UserAddressFirestoreRepository(options, userRepository)
-      },
-      inject: ['FirestoreOptions', 'UserRepository'],
-    },
-    {
-      provide: 'UserPaymentMethodRepository',
-      useFactory: (options: FirestoreOptions, userRepository: UserFirestoreRepository): UserPaymentMethodRepository => {
-        return new UserPaymentMethodFirestoreRepository(options, userRepository)
-      },
-      inject: ['FirestoreOptions', 'UserRepository'],
-    },
-    {
-      provide: 'SubscriptionMaterializationRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionMaterializationRepository => {
-        return new SubscriptionMaterializationFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SubscriptionSummaryRepository',
-      useFactory: (options: FirestoreOptions): SubscriptionSummaryRepository => {
-        return new SubscriptionSummaryFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: ProductVariantFirestoreRepository,
-      useFactory: (options: FirestoreOptions, productRepository: ProductFirestoreRepository): VariantRepository => {
-        return new ProductVariantFirestoreRepository(options, productRepository)
-      },
-      inject: ['FirestoreOptions', ProductFirestoreRepository],
-    },
-    {
-      provide: 'OrderBlockedRepository',
-      useFactory: (options: FirestoreOptions): OrderBlockedRepository => {
-        return new OrderBlockedFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'LogRepository',
-      useFactory: (options: FirestoreOptions): LogRepository => {
-        return new LogFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-    {
-      provide: 'SequenceRepository',
-      useFactory: (options: FirestoreOptions): SequenceFirestoreRepository => {
-        return new SequenceFirestoreRepository(options)
-      },
-      inject: ['FirestoreOptions'],
-    },
-  ],
-  exports: [
-    'BeautyProfileRepository',
-    'Buy2WinRepository',
-    CategoryFirestoreRepository,
-    'CheckoutRepository',
-    'CheckoutSubscriptionRepository',
-    'CouponRepository',
-    'CampaignHashtagRepository',
-    'CampaignDashboardRepository',
-    'EditionRepository',
-    'GroupRepository',
-    'HomeRepository',
-    'LeadRepository',
-    'LegacyOrderRepository',
-    'ShopMenuRepository',
-    'OrderRepository',
-    'OrderBlockedRepository',
-    'PaymentRepository',
-    'SequenceRepository',
-    'LogRepository',
-    ProductFirestoreRepository,
-    'ShopSettingsRepository',
-    'SubscriptionPaymentRepository',
-    'SubscriptionPlanRepository',
-    'SubscriptionProductRepository',
-    'SubscriptionRepository',
-    'UserRepository',
-    'UserAddressRepository',
-    'UserPaymentMethodRepository',
-    'SubscriptionMaterializationRepository',
-    'SubscriptionSummaryRepository',
-    ProductVariantFirestoreRepository,
-    ConnectFirestoreService,
-  ],
-})
-export class NestFirestoreModule {
-  public static initializeApp(options: {
-    firebase: {
-      googleApplicationCredential: string
-    }
-  }): DynamicModule {
-    return {
-      module: NestFirestoreModule,
-      imports: [
-        FirebaseModule.forRoot({
-          googleApplicationCredential: options?.firebase?.googleApplicationCredential,
-        }),
-        NestStorageModule,
-      ],
-      exports: [FirebaseModule, NestStorageModule],
-    }
-  }
-}

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

@@ -1,227 +0,0 @@
-import {
-  CacheConfig,
-  CategoryCollectionChildrenHasuraGraphQLRepository,
-  CategoryFilterHasuraGraphQLRepository,
-  CategoryFilterRepository,
-  CategoryHasuraGraphQLRepository,
-  CategoryProductHasuraGraphQLRepository,
-  CategoryRepository,
-  FilterHasuraGraphQLRepository,
-  FilterOptionHasuraGraphQLRepository,
-  FilterOptionRepository,
-  FilterRepository,
-  HasuraConstructorParams,
-  HasuraGraphQLAuthOptions,
-  ProductErrors,
-  ProductErrorsHasuraGraphQLRepository,
-  ProductErrorsRepository,
-  ProductHasuraGraphQLRepository,
-  ProductRepository,
-  ProductReviewHasuraGraphQLRepository,
-  ProductReviewRepository,
-  ProductStockNotificationHasuraGraphQLRepository,
-  ProductStockNotificationRepository,
-  VariantHasuraGraphQLRepository,
-  VariantRepository,
-  WishlistHasuraGraphQLRepository,
-} from '@infrab4a/connect'
-import { DynamicModule, Module } from '@nestjs/common'
-
-import { HASURA_OPTIONS } from './consts'
-
-export type HasuraGraphQLOptions = { endpoint: string; credentials: HasuraGraphQLAuthOptions; cache?: CacheConfig }
-
-@Module({
-  providers: [
-    {
-      provide: 'HasuraConfig',
-      useFactory: (options: HasuraGraphQLOptions) => ({
-        endpoint: options.endpoint,
-        authOptions: options.credentials,
-        cache: options.cache,
-      }),
-      inject: [HASURA_OPTIONS],
-    },
-    {
-      provide: 'CategoryRepository',
-      useExisting: CategoryHasuraGraphQLRepository,
-    },
-    {
-      provide: CategoryHasuraGraphQLRepository,
-      useFactory: (
-        options: any,
-        productRepository: ProductHasuraGraphQLRepository,
-        categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
-      ): CategoryRepository => {
-        return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository)
-      },
-      inject: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-    },
-    {
-      provide: 'ProductRepository',
-      useExisting: ProductHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): ProductRepository => {
-        return new ProductHasuraGraphQLRepository(hasuraConfig)
-      },
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductReviewRepository',
-      useExisting: ProductReviewHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductReviewHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): ProductReviewRepository => {
-        return new ProductReviewHasuraGraphQLRepository(hasuraConfig)
-      },
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'VariantRepository',
-      useExisting: VariantHasuraGraphQLRepository,
-    },
-    {
-      provide: VariantHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): VariantRepository => {
-        return new VariantHasuraGraphQLRepository(hasuraConfig)
-      },
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'ProductStockNotificationRepository',
-      useExisting: ProductStockNotificationHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductStockNotificationHasuraGraphQLRepository,
-      useFactory: (hasuraConfig: any): ProductStockNotificationRepository => {
-        return new ProductStockNotificationHasuraGraphQLRepository(hasuraConfig)
-      },
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'CategoryFilterRepository',
-      useExisting: CategoryFilterHasuraGraphQLRepository,
-    },
-    {
-      provide: CategoryFilterHasuraGraphQLRepository,
-      useFactory: (options: any): CategoryFilterRepository => {
-        return new CategoryFilterHasuraGraphQLRepository(options)
-      },
-      inject: ['HasuraConfig'],
-    },
-
-    {
-      provide: 'FilterOptionRepository',
-      useExisting: FilterOptionHasuraGraphQLRepository,
-    },
-    {
-      provide: FilterOptionHasuraGraphQLRepository,
-      useFactory: (options: any): FilterOptionRepository => {
-        return new FilterOptionHasuraGraphQLRepository(options)
-      },
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'FilterRepository',
-      useExisting: FilterHasuraGraphQLRepository,
-    },
-    {
-      provide: FilterHasuraGraphQLRepository,
-      useFactory: (
-        options: any,
-        filterOptionRepository: FilterOptionHasuraGraphQLRepository,
-        categoryFilterRepository: CategoryFilterHasuraGraphQLRepository,
-      ): FilterRepository => {
-        return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository)
-      },
-      inject: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
-    },
-    {
-      provide: CategoryCollectionChildrenHasuraGraphQLRepository,
-      useFactory: (options: any): CategoryCollectionChildrenHasuraGraphQLRepository =>
-        new CategoryCollectionChildrenHasuraGraphQLRepository(options),
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'CategoryCollectionChildrenRepository',
-      useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
-    },
-    {
-      provide: CategoryProductHasuraGraphQLRepository,
-      useFactory: (options: any): CategoryProductHasuraGraphQLRepository => {
-        return new CategoryProductHasuraGraphQLRepository(options)
-      },
-      inject: ['HasuraConfig'],
-    },
-    {
-      provide: 'CategoryProductRepository',
-      useExisting: CategoryProductHasuraGraphQLRepository,
-    },
-    {
-      provide: WishlistHasuraGraphQLRepository,
-      useFactory: (
-        options: any,
-        categoryProductRepository: CategoryProductHasuraGraphQLRepository,
-      ): WishlistHasuraGraphQLRepository => {
-        return new WishlistHasuraGraphQLRepository(options, categoryProductRepository)
-      },
-      inject: ['HasuraConfig', CategoryProductHasuraGraphQLRepository],
-    },
-    {
-      provide: 'WishlistRepository',
-      useExisting: WishlistHasuraGraphQLRepository,
-    },
-    {
-      provide: ProductErrorsHasuraGraphQLRepository,
-      useFactory: (
-        options: HasuraConstructorParams<ProductErrors>,
-        productRepository: ProductHasuraGraphQLRepository,
-      ): ProductErrorsRepository => {
-        return new ProductErrorsHasuraGraphQLRepository(options, productRepository)
-      },
-      inject: ['HasuraConfig', ProductHasuraGraphQLRepository],
-    },
-    {
-      provide: 'ProductErrorsRepository',
-      useExisting: ProductErrorsHasuraGraphQLRepository,
-    },
-  ],
-  exports: [
-    'CategoryRepository',
-    CategoryHasuraGraphQLRepository,
-    'ProductRepository',
-    ProductHasuraGraphQLRepository,
-    'ProductReviewRepository',
-    ProductReviewHasuraGraphQLRepository,
-    'VariantRepository',
-    VariantHasuraGraphQLRepository,
-    'ProductStockNotificationRepository',
-    ProductStockNotificationHasuraGraphQLRepository,
-    'CategoryFilterRepository',
-    CategoryFilterHasuraGraphQLRepository,
-    'FilterOptionRepository',
-    FilterOptionHasuraGraphQLRepository,
-    'FilterRepository',
-    FilterHasuraGraphQLRepository,
-    'CategoryCollectionChildrenRepository',
-    CategoryCollectionChildrenHasuraGraphQLRepository,
-    'WishlistRepository',
-    WishlistHasuraGraphQLRepository,
-    'CategoryProductRepository',
-    CategoryProductHasuraGraphQLRepository,
-    'ProductErrorsRepository',
-    ProductErrorsHasuraGraphQLRepository,
-  ],
-})
-export class NestHasuraGraphQLModule {
-  public static initializeApp(options: { endpoint: string; credentials: HasuraGraphQLAuthOptions }): DynamicModule {
-    return {
-      module: NestHasuraGraphQLModule,
-      providers: [{ provide: HASURA_OPTIONS, useValue: options }],
-      exports: [HASURA_OPTIONS],
-    }
-  }
-}

package/src/nest-storage.module.ts

@@ -1,16 +0,0 @@
-import { Module } from '@nestjs/common'
-import { FirebaseAdmin, FirebaseConstants } from 'nestjs-firebase'
-
-import { FIREBASE_STORAGE } from './consts'
-
-@Module({
-  providers: [
-    {
-      provide: FIREBASE_STORAGE,
-      useFactory: (firebaseAdmin: FirebaseAdmin) => firebaseAdmin.storage,
-      inject: [FirebaseConstants.FIREBASE_TOKEN],
-    },
-  ],
-  exports: [FIREBASE_STORAGE],
-})
-export class NestStorageModule {}

package/src/nest-vertex-ai-search.module.ts

@@ -1,26 +0,0 @@
-import { ProductsVertexSearch } from '@infrab4a/connect'
-import { DynamicModule, Module } from '@nestjs/common'
-
-import { VERTEX_CONFIG } from './consts'
-import { DiscoveryEngineVertexAdapter, VertexConfig } from './infra'
-
-@Module({
-  providers: [
-    DiscoveryEngineVertexAdapter,
-    {
-      provide: ProductsVertexSearch,
-      useFactory: (adapter: DiscoveryEngineVertexAdapter): ProductsVertexSearch => new ProductsVertexSearch(adapter),
-      inject: [DiscoveryEngineVertexAdapter],
-    },
-  ],
-  exports: [ProductsVertexSearch],
-})
-export class NestVertexSeachModule {
-  public static initializeApp(options: VertexConfig): DynamicModule {
-    return {
-      module: NestVertexSeachModule,
-      providers: [{ provide: VERTEX_CONFIG, useValue: options }],
-      exports: [VERTEX_CONFIG],
-    }
-  }
-}

package/src/types/pagarme.d.ts

@@ -1,25 +0,0 @@
-// Declarações TypeScript personalizadas para o módulo 'pagarme'
-declare module 'pagarme' {
-  interface PagarmeClient {
-    transactions: {
-      create(payload: any): Promise<any>
-      find(query: { id: number }): Promise<any>
-    }
-    cards: {
-      find(query: any): Promise<any>
-      create(payload: any): Promise<any>
-    }
-    security: {
-      encrypt(payload: any): Promise<any>
-    }
-  }
-
-  interface PagarmeModule {
-    client: {
-      connect(options: { api_key: string }): Promise<PagarmeClient>
-    }
-  }
-
-  const pagarme: PagarmeModule
-  export = pagarme
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "declarationMap": true,
-    "inlineSources": true,
-    "noEmit": true
-  },
-  "exclude": [
-    "**/*.spec.ts"
-  ],
-  "references": [
-    { "path": "../connect" }
-  ],
-  "include": ["./src", "./src/types/**/*"]
-}

package/tsconfig.lib.json

@@ -1,7 +0,0 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false
-  }
-}

package/tsconfig.lib.prod.json

@@ -1,10 +0,0 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
-{
-  "extends": "./tsconfig.lib.json",
-  "compilerOptions": {
-    "declarationMap": false,
-    "importHelpers": true,
-    "target": "es2017",
-    "module": "es2020"
-  }
-}