@infrab4a/connect 0.17.0-beta.0 → 0.17.0-beta.1

package/infra/elasticsearch/indexes/products-index.d.ts

@@ -5,7 +5,6 @@ export declare class ProductsIndex {
     constructor(adapter: AxiosAdapter<Product>);
     findById(ids: string[], options?: {
         hasStock: boolean;
-        stock?: number;
         size: number;
         shop: Shops;
     }): Promise<Product[]>;

package/infra/firebase/auth/authentication-firebase-auth.service.d.ts

@@ -1,9 +1,9 @@
-import firebase from 'firebase/app';
+import { Auth } from 'firebase/auth';
 import { AuthenticationService, BasicUserData, LoginAndPasswordParams } from '../../../domain';
 import { FirebaseUserWithId } from './types/firebase-user-with-id.type';
 export declare class AuthenticationFirebaseAuthService implements AuthenticationService {
     private readonly firebaseAuth;
-    constructor(firebaseAuth: firebase.auth.Auth);
+    constructor(firebaseAuth: Auth);
     signInWithEmailAndPassword(data: LoginAndPasswordParams): Promise<BasicUserData>;
     signInWithGoogle(): Promise<BasicUserData>;
     signOut(): Promise<void>;

package/infra/firebase/auth/register-firebase-auth.service.d.ts

@@ -1,8 +1,8 @@
-import firebase from 'firebase/app';
+import { Auth } from 'firebase/auth';
 import { RegisterParams, RegisterService } from '../../../domain';
 import { FirebaseUserWithId } from './types/firebase-user-with-id.type';
 export declare class RegisterFirebaseAuthService implements RegisterService {
     private readonly firebaseAuth;
-    constructor(firebaseAuth: firebase.auth.Auth);
+    constructor(firebaseAuth: Auth);
     register(params: RegisterParams): Promise<FirebaseUserWithId>;
 }

package/infra/firebase/auth/types/firebase-user-with-id.type.d.ts

@@ -1,3 +1,4 @@
-export declare type FirebaseUserWithId = firebase.User & {
+import { User } from 'firebase/auth';
+export declare type FirebaseUserWithId = User & {
     id: string;
 };

package/infra/firebase/firestore/mixins/with-create-firestore.mixin.d.ts

@@ -1,4 +1,4 @@
-import { DocumentReference } from '@firebase/firestore-types';
+import { DocumentReference } from 'firebase/firestore';
 import { BaseModelWithIdentifier } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
 import { MixinCtor } from '../../../../utils';
@@ -7,11 +7,11 @@ export declare const withCreateFirestore: <TBase extends BaseModelWithIdentifier
         create(data: Partial<TBase>): Promise<TBase>;
         save(data: TBase): Promise<DocumentReference<TBase>>;
         buildCollectionPathForAdd(identifiers: Partial<TBase>): string;
-        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
-        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
     };
 } & TMixinBase;

package/infra/firebase/firestore/mixins/with-crud-firestore.mixin.d.ts

@@ -6,24 +6,24 @@ export declare const withCrudFirestore: <TBase extends BaseModelWithIdentifier<T
         update(data: import("../../../../domain").RepositoryUpdateParams<TBase>): Promise<TBase>;
         buildCollectionPathForUpdate(identifiers: import("../../../../domain").RepositoryUpdateParams<TBase>): string;
         paramsToPlain(params: import("../../../../domain").RepositoryUpdateParams<TBase>): Partial<TBase>;
-        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
-        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
         get(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): Promise<TBase>;
         buildCollectionPathForGet(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): string;
-        find(filters?: import("../../../../domain").RepositoryFindFielters<TBase>[], limits?: import("../../../../domain").RepositoryLimitOptions<TBase>, orderBy?: import("../../../../domain").RepositoryOrderByList<TBase>): Promise<import("../../../../domain").RepositoryFindResult<TBase>>;
+        find(filters?: import("../../../../domain").RepositoryFindFielters<TBase>[], limitList?: import("../../../../domain").RepositoryLimitOptions<TBase>, orderByList?: import("../../../../domain").RepositoryOrderByList<TBase>): Promise<import("../../../../domain").RepositoryFindResult<TBase>>;
         buildCollectionPathForFind(filters: import("../../../../domain").RepositoryFindFielters<TBase>[]): string;
-        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<TBase> | import("@firebase/firestore-types").Query<TBase>, filter: import("../../../../domain").RepositoryFindFielters<TBase>) => import("@firebase/firestore-types").Query<TBase>;
-        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<TBase> | import("@firebase/firestore-types").Query<TBase>, fieldName: string | import("../../../../domain").NonFunctionPropertyNames<TBase>, options: import("../../../../domain").RepositoryFindFieltersOptions<TBase, import("../../../../domain").NonFunctionPropertyNames<TBase>>) => import("@firebase/firestore-types").Query<TBase>;
-        defineLimits(query: import("@firebase/firestore-types").CollectionReference<TBase> | import("@firebase/firestore-types").Query<TBase>, filters: import("../../../../domain").RepositoryFindFielters<TBase>[], limits: import("../../../../domain").RepositoryLimitOptions<TBase>): Promise<import("@firebase/firestore-types").Query<TBase>>;
+        makeFirestoreWhere: (filter: import("../../../../domain").RepositoryFindFielters<TBase>) => import("@firebase/firestore").QueryConstraint[];
+        buildWhereSentence: (fieldName: string | import("../../../../domain").NonFunctionPropertyNames<TBase>, options: import("../../../../domain").RepositoryFindFieltersOptions<TBase, import("../../../../domain").NonFunctionPropertyNames<TBase>>) => import("@firebase/firestore").QueryConstraint[];
+        defineLimits(filters: import("../../../../domain").RepositoryFindFielters<TBase>[], limits: import("../../../../domain").RepositoryLimitOptions<TBase>): Promise<import("@firebase/firestore").QueryConstraint[]>;
         calculateCount(data: TBase[], limits: import("../../../../domain").RepositoryLimitOptions<TBase>): number;
         delete(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): Promise<void>;
         buildCollectionPathForRemove(identifiers: import("../../../../domain").NonFunctionProperties<TBase>): string;
         create(data: Partial<TBase>): Promise<TBase>;
-        save(data: TBase): Promise<import("@firebase/firestore-types").DocumentReference<TBase>>;
+        save(data: TBase): Promise<import("@firebase/firestore").DocumentReference<TBase>>;
         buildCollectionPathForAdd(identifiers: Partial<TBase>): string;
     };
 } & TMixinBase;

package/infra/firebase/firestore/mixins/with-delete-firestore.mixin.d.ts

@@ -5,11 +5,11 @@ export declare const withDeleteFirestore: <TBase extends BaseModelWithIdentifier
     new (...args: any[]): {
         delete(identifiers: NonFunctionProperties<TBase>): Promise<void>;
         buildCollectionPathForRemove(identifiers: NonFunctionProperties<TBase>): string;
-        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
-        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
     };
 } & TMixinBase;

package/infra/firebase/firestore/mixins/with-find-firestore.mixin.d.ts

@@ -1,20 +1,20 @@
-import { CollectionReference, Query } from '@firebase/firestore-types';
+import { CollectionReference, QueryConstraint } from 'firebase/firestore';
 import { BaseModelWithIdentifier, NonFunctionPropertyNames, RepositoryFindFielters, RepositoryFindFieltersOptions, RepositoryFindResult, RepositoryLimitOptions, RepositoryOrderByList } from '../../../../domain';
 import { FirestoreHelpers, FirestoreRepository } from '../types';
 import { MixinCtor } from '../../../../utils';
 export declare const withFindFirestore: <TBase extends BaseModelWithIdentifier<TBase>, TMixinBase extends MixinCtor<{}>>(MixinBase: MixinCtor<FirestoreRepository<TBase> & FirestoreHelpers> & TMixinBase) => {
     new (...args: any[]): {
-        find(filters?: RepositoryFindFielters<TBase>[], limits?: RepositoryLimitOptions<TBase>, orderBy?: RepositoryOrderByList<TBase>): Promise<RepositoryFindResult<TBase>>;
+        find(filters?: RepositoryFindFielters<TBase>[], limitList?: RepositoryLimitOptions<TBase>, orderByList?: RepositoryOrderByList<TBase>): Promise<RepositoryFindResult<TBase>>;
         buildCollectionPathForFind(filters: RepositoryFindFielters<TBase>[]): string;
-        makeFirestoreWhere: (queryReference: CollectionReference<TBase> | Query<TBase>, filter: RepositoryFindFielters<TBase>) => Query<TBase>;
-        buildWhereSentence: (queryReference: CollectionReference<TBase> | Query<TBase>, fieldName: string | NonFunctionPropertyNames<TBase>, options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>) => Query<TBase>;
-        defineLimits(query: CollectionReference<TBase> | Query<TBase>, filters: RepositoryFindFielters<TBase>[], limits: RepositoryLimitOptions<TBase>): Promise<Query<TBase>>;
+        makeFirestoreWhere: (filter: RepositoryFindFielters<TBase>) => QueryConstraint[];
+        buildWhereSentence: (fieldName: string | NonFunctionPropertyNames<TBase>, options: RepositoryFindFieltersOptions<TBase, NonFunctionPropertyNames<TBase>>) => QueryConstraint[];
+        defineLimits(filters: RepositoryFindFielters<TBase>[], limits: RepositoryLimitOptions<TBase>): Promise<QueryConstraint[]>;
         calculateCount(data: TBase[], limits: RepositoryLimitOptions<TBase>): number;
-        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
         collection(path?: string): CollectionReference<TBase>;
-        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
     };
 } & TMixinBase;

package/infra/firebase/firestore/mixins/with-firestore.mixin.d.ts

@@ -1,9 +1,9 @@
-import { CollectionReference, DocumentData, FirebaseFirestore, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { CollectionReference, DocumentData, Firestore, QueryDocumentSnapshot } from 'firebase/firestore';
 import { BaseModelBuilder, BaseModelWithIdentifier } from '../../../../domain';
 import { MixinCtor } from '../../../../utils';
 export declare const withFirestore: <TBase extends BaseModelWithIdentifier<TBase>>(MixinBase: MixinCtor) => {
     new (...args: Array<any>): {
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: BaseModelBuilder<TBase>;
         collection(path?: string): CollectionReference<TBase>;

package/infra/firebase/firestore/mixins/with-get-firestore.mixin.d.ts

@@ -5,11 +5,11 @@ export declare const withGetFirestore: <TBase extends BaseModelWithIdentifier<TB
     new (...args: any[]): {
         get(identifiers: NonFunctionProperties<TBase>): Promise<TBase>;
         buildCollectionPathForGet(identifiers: NonFunctionProperties<TBase>): string;
-        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
-        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
     };
 } & TMixinBase;

package/infra/firebase/firestore/mixins/with-helpers.mixin.d.ts

@@ -1,4 +1,4 @@
-import { QuerySnapshot, QueryDocumentSnapshot } from '@firebase/firestore-types';
+import { QuerySnapshot, QueryDocumentSnapshot } from 'firebase/firestore';
 import { BaseModelWithIdentifier } from '../../../../domain';
 import { FirestoreRepository, FirestoreSubRepository } from '../types';
 import { MixinCtor } from '../../../../utils';

package/infra/firebase/firestore/mixins/with-sub-collection.mixin.d.ts

@@ -1,4 +1,4 @@
-import { CollectionReference, FirebaseFirestore } from '@firebase/firestore-types';
+import { CollectionReference } from 'firebase/firestore';
 import { BaseModelWithIdentifier, NonFunctionPropertyNames } from '../../../../domain';
 import { FirestoreRepository } from '../types';
 import { MixinCtor } from '../../../../utils';
@@ -7,7 +7,7 @@ export declare const withSubCollection: <TBase extends BaseModelWithIdentifier<T
         readonly parentRepository: FirestoreRepository<TBaseParent>;
         parentIdField: NonFunctionPropertyNames<TBase>;
         collection(path?: string): CollectionReference<TBase>;
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
     };

package/infra/firebase/firestore/mixins/with-update-firestore.mixin.d.ts

@@ -6,11 +6,11 @@ export declare const withUpdateFirestore: <TBase extends BaseModelWithIdentifier
         update(data: RepositoryUpdateParams<TBase>): Promise<TBase>;
         buildCollectionPathForUpdate(identifiers: RepositoryUpdateParams<TBase>): string;
         paramsToPlain(params: RepositoryUpdateParams<TBase>): Partial<TBase>;
-        readonly firestore?: import("@firebase/firestore-types").FirebaseFirestore;
+        readonly firestore?: import("@firebase/firestore").Firestore;
         collectionName: string;
         model: import("../../../../domain").BaseModelBuilder<TBase>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<TBase>;
-        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<TBase>;
+        toArray<T extends BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends BaseModelWithIdentifier<T_1>>(repository: FirestoreRepository<T_1>): repository is import("../types").FirestoreSubRepository<T_1, BaseModelWithIdentifier<{}>>;
     };
 } & TMixinBase;

package/infra/firebase/firestore/repositories/catalog/category-firestore.repository.d.ts

@@ -1,4 +1,4 @@
-import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Firestore } from 'firebase/firestore';
 import { Category, CategoryRepository, Product, Shops } from '../../../../../domain';
 import { ProductsIndex } from '../../../../elasticsearch';
 declare const CategoryFirestoreRepository_base: {
@@ -6,60 +6,55 @@ declare const CategoryFirestoreRepository_base: {
         update(data: import("../../../../../domain").RepositoryUpdateParams<Category>): Promise<Category>;
         buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Category>): string;
         paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Category>): Partial<Category>;
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Category>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Category>;
-        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Category>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
         get(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): Promise<Category>;
         buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): string;
-        find(filters?: import("../../../../../domain").RepositoryFindFielters<Category>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Category>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Category>): Promise<import("../../../../../domain").RepositoryFindResult<Category>>;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Category>[], limitList?: import("../../../../../domain").RepositoryLimitOptions<Category>, orderByList?: import("../../../../../domain").RepositoryOrderByList<Category>): Promise<import("../../../../../domain").RepositoryFindResult<Category>>;
         buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Category>[]): string;
-        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Category> | import("@firebase/firestore-types").Query<Category>, filter: import("../../../../../domain").RepositoryFindFielters<Category>) => import("@firebase/firestore-types").Query<Category>;
-        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Category> | import("@firebase/firestore-types").Query<Category>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Category, import("../../../../../domain").NonFunctionPropertyNames<Category>>) => import("@firebase/firestore-types").Query<Category>;
-        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Category> | import("@firebase/firestore-types").Query<Category>, filters: import("../../../../../domain").RepositoryFindFielters<Category>[], limits: import("../../../../../domain").RepositoryLimitOptions<Category>): Promise<import("@firebase/firestore-types").Query<Category>>;
+        makeFirestoreWhere: (filter: import("../../../../../domain").RepositoryFindFielters<Category>) => import("@firebase/firestore").QueryConstraint[];
+        buildWhereSentence: (fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Category, import("../../../../../domain").NonFunctionPropertyNames<Category>>) => import("@firebase/firestore").QueryConstraint[];
+        defineLimits(filters: import("../../../../../domain").RepositoryFindFielters<Category>[], limits: import("../../../../../domain").RepositoryLimitOptions<Category>): Promise<import("@firebase/firestore").QueryConstraint[]>;
         calculateCount(data: Category[], limits: import("../../../../../domain").RepositoryLimitOptions<Category>): number;
         delete(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): Promise<void>;
         buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Category>): string;
         create(data: Partial<Category>): Promise<Category>;
-        save(data: Category): Promise<import("@firebase/firestore-types").DocumentReference<Category>>;
+        save(data: Category): Promise<import("@firebase/firestore").DocumentReference<Category>>;
         buildCollectionPathForAdd(identifiers: Partial<Category>): string;
     };
 } & {
     new (...args: any[]): {
-        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore").QuerySnapshot<T_2> | import("@firebase/firestore").QueryDocumentSnapshot<T_2>[]): T_2[];
         isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
     };
 } & {
     new (...args: any[]): {
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Category>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Category>;
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Category>;
         buildModelInstance(): {
-            toFirestore: (data: Category) => import("@firebase/firestore-types").DocumentData;
-            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Category>) => Category;
+            toFirestore: (data: Category) => import("@firebase/firestore").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore").QueryDocumentSnapshot<Category>) => Category;
         };
     };
 };
 export declare class CategoryFirestoreRepository extends CategoryFirestoreRepository_base implements CategoryRepository {
-    readonly firestore: FirebaseFirestore;
+    readonly firestore: Firestore;
     private readonly productsIndex;
-    constructor(firestore: FirebaseFirestore, productsIndex: ProductsIndex);
+    constructor(firestore: Firestore, productsIndex: ProductsIndex);
     getCategoryBySlug(slug: string, shop: Shops): Promise<Category>;
-    getCategoriesForHome(categoryIds: string[], { limit, stock }?: {
-        limit?: number;
-        hasStock?: boolean;
-        stock?: number;
-    }): Promise<{
+    getCategoriesForHome(categoryIds: string[], limit?: number): Promise<{
         category: Category;
         products: Product[];
     }[]>;
     mountCategory(category: Category, options?: {
         limit?: number;
         hasStock?: boolean;
-        stock?: number;
     }): Promise<Product[]>;
 }
 export {};

package/infra/firebase/firestore/repositories/catalog/product-firestore.repository.d.ts

@@ -1,50 +1,50 @@
-import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Firestore } from 'firebase/firestore';
 import { Product, ProductRepository, Shops } from '../../../../../domain';
 declare const ProductFirestoreRepository_base: {
     new (...args: any[]): {
         update(data: import("../../../../../domain").RepositoryUpdateParams<Product>): Promise<Product>;
         buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Product>): string;
         paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Product>): Partial<Product>;
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Product>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
-        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Product>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
         get(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<Product>;
         buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
-        find(filters?: import("../../../../../domain").RepositoryFindFielters<Product>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Product>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Product>): Promise<import("../../../../../domain").RepositoryFindResult<Product>>;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Product>[], limitList?: import("../../../../../domain").RepositoryLimitOptions<Product>, orderByList?: import("../../../../../domain").RepositoryOrderByList<Product>): Promise<import("../../../../../domain").RepositoryFindResult<Product>>;
         buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Product>[]): string;
-        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filter: import("../../../../../domain").RepositoryFindFielters<Product>) => import("@firebase/firestore-types").Query<Product>;
-        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Product, import("../../../../../domain").NonFunctionPropertyNames<Product>>) => import("@firebase/firestore-types").Query<Product>;
-        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filters: import("../../../../../domain").RepositoryFindFielters<Product>[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): Promise<import("@firebase/firestore-types").Query<Product>>;
+        makeFirestoreWhere: (filter: import("../../../../../domain").RepositoryFindFielters<Product>) => import("@firebase/firestore").QueryConstraint[];
+        buildWhereSentence: (fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Product, import("../../../../../domain").NonFunctionPropertyNames<Product>>) => import("@firebase/firestore").QueryConstraint[];
+        defineLimits(filters: import("../../../../../domain").RepositoryFindFielters<Product>[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): Promise<import("@firebase/firestore").QueryConstraint[]>;
         calculateCount(data: Product[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): number;
         delete(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<void>;
         buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
         create(data: Partial<Product>): Promise<Product>;
-        save(data: Product): Promise<import("@firebase/firestore-types").DocumentReference<Product>>;
+        save(data: Product): Promise<import("@firebase/firestore").DocumentReference<Product>>;
         buildCollectionPathForAdd(identifiers: Partial<Product>): string;
     };
 } & {
     new (...args: any[]): {
-        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore").QuerySnapshot<T_2> | import("@firebase/firestore").QueryDocumentSnapshot<T_2>[]): T_2[];
         isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
     };
 } & {
     new (...args: any[]): {
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Product>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Product>;
         buildModelInstance(): {
-            toFirestore: (data: Product) => import("@firebase/firestore-types").DocumentData;
-            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Product>) => Product;
+            toFirestore: (data: Product) => import("@firebase/firestore").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore").QueryDocumentSnapshot<Product>) => Product;
         };
     };
 };
 export declare class ProductFirestoreRepository extends ProductFirestoreRepository_base implements ProductRepository {
-    readonly firestore: FirebaseFirestore;
-    constructor(firestore: FirebaseFirestore);
+    readonly firestore: Firestore;
+    constructor(firestore: Firestore);
     getBySlug(slug: string, shop: Shops): Promise<Product>;
 }
 export {};

package/infra/firebase/firestore/repositories/catalog/product-variant-firestore.repository.d.ts

@@ -1,12 +1,12 @@
-import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Firestore } from 'firebase/firestore';
 import { Product, Variant, VariantRepository } from '../../../../../domain';
 import { ProductFirestoreRepository } from './product-firestore.repository';
 declare const ProductVariantFirestoreRepository_base: {
     new (...args: any[]): {
         readonly parentRepository: import("@infrab4a/connect").FirestoreRepository<Product>;
         parentIdField: import("../../../../../domain").NonFunctionPropertyNames<Variant>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Variant>;
-        readonly firestore?: FirebaseFirestore;
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Variant>;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Variant>;
     };
@@ -15,46 +15,46 @@ declare const ProductVariantFirestoreRepository_base: {
         update(data: import("../../../../../domain").RepositoryUpdateParams<Variant>): Promise<Variant>;
         buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Variant>): string;
         paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Variant>): Partial<Variant>;
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Variant>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Variant>;
-        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Variant>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
         get(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): Promise<Variant>;
         buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): string;
-        find(filters?: import("../../../../../domain").RepositoryFindFielters<Variant>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Variant>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Variant>): Promise<import("../../../../../domain").RepositoryFindResult<Variant>>;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Variant>[], limitList?: import("../../../../../domain").RepositoryLimitOptions<Variant>, orderByList?: import("../../../../../domain").RepositoryOrderByList<Variant>): Promise<import("../../../../../domain").RepositoryFindResult<Variant>>;
         buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Variant>[]): string;
-        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Variant> | import("@firebase/firestore-types").Query<Variant>, filter: import("../../../../../domain").RepositoryFindFielters<Variant>) => import("@firebase/firestore-types").Query<Variant>;
-        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Variant> | import("@firebase/firestore-types").Query<Variant>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Variant, import("../../../../../domain").NonFunctionPropertyNames<Variant>>) => import("@firebase/firestore-types").Query<Variant>;
-        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Variant> | import("@firebase/firestore-types").Query<Variant>, filters: import("../../../../../domain").RepositoryFindFielters<Variant>[], limits: import("../../../../../domain").RepositoryLimitOptions<Variant>): Promise<import("@firebase/firestore-types").Query<Variant>>;
+        makeFirestoreWhere: (filter: import("../../../../../domain").RepositoryFindFielters<Variant>) => import("@firebase/firestore").QueryConstraint[];
+        buildWhereSentence: (fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Variant, import("../../../../../domain").NonFunctionPropertyNames<Variant>>) => import("@firebase/firestore").QueryConstraint[];
+        defineLimits(filters: import("../../../../../domain").RepositoryFindFielters<Variant>[], limits: import("../../../../../domain").RepositoryLimitOptions<Variant>): Promise<import("@firebase/firestore").QueryConstraint[]>;
         calculateCount(data: Variant[], limits: import("../../../../../domain").RepositoryLimitOptions<Variant>): number;
         delete(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): Promise<void>;
         buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Variant>): string;
         create(data: Partial<Variant>): Promise<Variant>;
-        save(data: Variant): Promise<import("@firebase/firestore-types").DocumentReference<Variant>>;
+        save(data: Variant): Promise<import("@firebase/firestore").DocumentReference<Variant>>;
         buildCollectionPathForAdd(identifiers: Partial<Variant>): string;
     };
 } & {
     new (...args: any[]): {
-        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore").QuerySnapshot<T_2> | import("@firebase/firestore").QueryDocumentSnapshot<T_2>[]): T_2[];
         isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
     };
 } & {
     new (...args: any[]): {
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Variant>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Variant>;
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Variant>;
         buildModelInstance(): {
-            toFirestore: (data: Variant) => import("@firebase/firestore-types").DocumentData;
-            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Variant>) => Variant;
+            toFirestore: (data: Variant) => import("@firebase/firestore").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore").QueryDocumentSnapshot<Variant>) => Variant;
         };
     };
 };
 export declare class ProductVariantFirestoreRepository extends ProductVariantFirestoreRepository_base implements VariantRepository {
-    readonly firestore: FirebaseFirestore;
+    readonly firestore: Firestore;
     readonly parentRepository: ProductFirestoreRepository;
-    constructor(firestore: FirebaseFirestore, parentRepository: ProductFirestoreRepository);
+    constructor(firestore: Firestore, parentRepository: ProductFirestoreRepository);
 }
 export {};

package/infra/firebase/firestore/repositories/catalog/subscription-product-firestore.repository.d.ts

@@ -1,49 +1,49 @@
-import { FirebaseFirestore } from '@firebase/firestore-types';
+import { Firestore } from 'firebase/firestore';
 import { Product, SubscriptionProductRepository } from '../../../../../domain';
 declare const SubscriptionProductFirestoreRepository_base: {
     new (...args: any[]): {
         update(data: import("../../../../../domain").RepositoryUpdateParams<Product>): Promise<Product>;
         buildCollectionPathForUpdate(identifiers: import("../../../../../domain").RepositoryUpdateParams<Product>): string;
         paramsToPlain(params: import("../../../../../domain").RepositoryUpdateParams<Product>): Partial<Product>;
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Product>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
-        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T> | import("@firebase/firestore-types").QueryDocumentSnapshot<T>[]): T[];
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Product>;
+        toArray<T extends import("../../../../../domain").BaseModelWithIdentifier<T>>(snapShot: import("@firebase/firestore").QuerySnapshot<T> | import("@firebase/firestore").QueryDocumentSnapshot<T>[]): T[];
         isSubCollection<T_1 extends import("../../../../../domain").BaseModelWithIdentifier<T_1>>(repository: import("@infrab4a/connect").FirestoreRepository<T_1>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_1, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
         get(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<Product>;
         buildCollectionPathForGet(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
-        find(filters?: import("../../../../../domain").RepositoryFindFielters<Product>[], limits?: import("../../../../../domain").RepositoryLimitOptions<Product>, orderBy?: import("../../../../../domain").RepositoryOrderByList<Product>): Promise<import("../../../../../domain").RepositoryFindResult<Product>>;
+        find(filters?: import("../../../../../domain").RepositoryFindFielters<Product>[], limitList?: import("../../../../../domain").RepositoryLimitOptions<Product>, orderByList?: import("../../../../../domain").RepositoryOrderByList<Product>): Promise<import("../../../../../domain").RepositoryFindResult<Product>>;
         buildCollectionPathForFind(filters: import("../../../../../domain").RepositoryFindFielters<Product>[]): string;
-        makeFirestoreWhere: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filter: import("../../../../../domain").RepositoryFindFielters<Product>) => import("@firebase/firestore-types").Query<Product>;
-        buildWhereSentence: (queryReference: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Product, import("../../../../../domain").NonFunctionPropertyNames<Product>>) => import("@firebase/firestore-types").Query<Product>;
-        defineLimits(query: import("@firebase/firestore-types").CollectionReference<Product> | import("@firebase/firestore-types").Query<Product>, filters: import("../../../../../domain").RepositoryFindFielters<Product>[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): Promise<import("@firebase/firestore-types").Query<Product>>;
+        makeFirestoreWhere: (filter: import("../../../../../domain").RepositoryFindFielters<Product>) => import("@firebase/firestore").QueryConstraint[];
+        buildWhereSentence: (fieldName: string, options: import("../../../../../domain").RepositoryFindFieltersOptions<Product, import("../../../../../domain").NonFunctionPropertyNames<Product>>) => import("@firebase/firestore").QueryConstraint[];
+        defineLimits(filters: import("../../../../../domain").RepositoryFindFielters<Product>[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): Promise<import("@firebase/firestore").QueryConstraint[]>;
         calculateCount(data: Product[], limits: import("../../../../../domain").RepositoryLimitOptions<Product>): number;
         delete(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): Promise<void>;
         buildCollectionPathForRemove(identifiers: import("../../../../../domain").NonFunctionProperties<Product>): string;
         create(data: Partial<Product>): Promise<Product>;
-        save(data: Product): Promise<import("@firebase/firestore-types").DocumentReference<Product>>;
+        save(data: Product): Promise<import("@firebase/firestore").DocumentReference<Product>>;
         buildCollectionPathForAdd(identifiers: Partial<Product>): string;
     };
 } & {
     new (...args: any[]): {
-        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore-types").QuerySnapshot<T_2> | import("@firebase/firestore-types").QueryDocumentSnapshot<T_2>[]): T_2[];
+        toArray<T_2 extends import("../../../../../domain").BaseModelWithIdentifier<T_2>>(snapShot: import("@firebase/firestore").QuerySnapshot<T_2> | import("@firebase/firestore").QueryDocumentSnapshot<T_2>[]): T_2[];
         isSubCollection<T_3 extends import("../../../../../domain").BaseModelWithIdentifier<T_3>>(repository: import("@infrab4a/connect").FirestoreRepository<T_3>): repository is import("@infrab4a/connect").FirestoreSubRepository<T_3, import("../../../../../domain").BaseModelWithIdentifier<{}>>;
     };
 } & {
     new (...args: any[]): {
-        readonly firestore?: FirebaseFirestore;
+        readonly firestore?: Firestore;
         collectionName: string;
         model: import("../../../../../domain").BaseModelBuilder<Product>;
-        collection(path?: string): import("@firebase/firestore-types").CollectionReference<Product>;
+        collection(path?: string): import("@firebase/firestore").CollectionReference<Product>;
         buildModelInstance(): {
-            toFirestore: (data: Product) => import("@firebase/firestore-types").DocumentData;
-            fromFirestore: (snap: import("@firebase/firestore-types").QueryDocumentSnapshot<Product>) => Product;
+            toFirestore: (data: Product) => import("@firebase/firestore").DocumentData;
+            fromFirestore: (snap: import("@firebase/firestore").QueryDocumentSnapshot<Product>) => Product;
         };
     };
 };
 export declare class SubscriptionProductFirestoreRepository extends SubscriptionProductFirestoreRepository_base implements SubscriptionProductRepository {
-    readonly firestore: FirebaseFirestore;
-    constructor(firestore: FirebaseFirestore);
+    readonly firestore: Firestore;
+    constructor(firestore: Firestore);
 }
 export {};