@infrab4a/connect-nestjs 1.1.0-beta.9 → 1.1.1

package/index.cjs.js

@@ -48,697 +48,710 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-exports.NativeElasticSearchAdapter = class NativeElasticSearchAdapter {
-    constructor(config) {
-        this.logger = connect.DebugHelper.from(this);
-        try {
-            this.client = !connect.isEmpty(config.cloud.id) && !connect.isEmpty(config.auth.apiKey) && new elasticsearch.Client(config);
-        }
-        catch (error) {
-            this.logger.error({ req: config, res: error });
-            throw error;
-        }
-    }
-    async get(index, id) {
-        const logger = this.logger.with('get');
-        const req = { index, id };
-        try {
-            const data = await this.client.get({ index, id });
-            logger.log({ req, res: data });
-            return data._source;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : `${index}/${id} not found`;
-            logger.log({ req, res: error });
-            throw new connect.NotFoundError(message);
-        }
-    }
-    async query(index, query) {
-        const logger = this.logger.with('query');
-        const params = {
-            index,
-            query,
-        };
-        try {
-            const result = await this.client.search(params);
-            const res = {
-                total: result.hits.total,
-                hits: result.hits.hits,
-            };
-            logger.log({ req: params, res });
-            return res;
-        }
-        catch (error) {
-            logger.error({ req: params, res: error });
-            throw error;
-        }
-    }
-    async save(index, data) {
-        const logger = this.logger.with('save');
-        const req = {
-            index,
-            id: data.identifiersFields.length > 1
-                ? JSON.stringify(data.identifier)
-                : Object.values(data.identifier).shift().toString(),
-            document: data.toPlain(),
-        };
-        try {
-            await this.client.index(req);
-            logger.log({ req, res: undefined });
-        }
-        catch (error) {
-            logger.error({ req, res: error });
-            throw error;
-        }
-    }
-    async update(index, id, data) {
-        const logger = this.logger.with('update');
-        const req = {
-            index,
-            id,
-            doc: data,
-        };
-        try {
-            await this.client.update(req);
-            logger.log({ req, res: undefined });
-        }
-        catch (error) {
-            logger.error({ req, res: error });
-            throw error;
-        }
-    }
-    async delete(index, id) {
-        const logger = this.logger.with('delete');
-        const req = {
-            index,
-            id,
-        };
-        try {
-            await this.client.delete(req);
-            logger.log({ req, res: undefined });
-        }
-        catch (error) {
-            logger.error({ req, res: error });
-            throw error;
-        }
-    }
-};
-exports.NativeElasticSearchAdapter = __decorate([
-    common.Injectable(),
-    __param(0, common.Inject(ES_CONFIG)),
-    __metadata("design:paramtypes", [Object])
+exports.NativeElasticSearchAdapter = class NativeElasticSearchAdapter {
+    constructor(config) {
+        this.logger = connect.DebugHelper.from(this);
+        try {
+            this.client = !connect.isEmpty(config.cloud.id) && !connect.isEmpty(config.auth.apiKey) && new elasticsearch.Client(config);
+        }
+        catch (error) {
+            this.logger.error({ req: config, res: error });
+            throw error;
+        }
+    }
+    async get(index, id) {
+        const logger = this.logger.with('get');
+        const req = { index, id };
+        try {
+            const data = await this.client.get({ index, id });
+            logger.log({ req, res: data });
+            return data._source;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : `${index}/${id} not found`;
+            logger.log({ req, res: error });
+            throw new connect.NotFoundError(message);
+        }
+    }
+    async query(index, query) {
+        const logger = this.logger.with('query');
+        const params = {
+            index,
+            query,
+        };
+        try {
+            const result = await this.client.search(params);
+            const res = {
+                total: result.hits.total,
+                hits: result.hits.hits,
+            };
+            logger.log({ req: params, res });
+            return res;
+        }
+        catch (error) {
+            logger.error({ req: params, res: error });
+            throw error;
+        }
+    }
+    async save(index, data) {
+        const logger = this.logger.with('save');
+        const req = {
+            index,
+            id: data.identifiersFields.length > 1
+                ? JSON.stringify(data.identifier)
+                : Object.values(data.identifier).shift().toString(),
+            document: data.toPlain(),
+        };
+        try {
+            const res = await this.client.index(req);
+            logger.log({ req, res });
+        }
+        catch (error) {
+            logger.error({ req, res: error });
+            throw error;
+        }
+    }
+    async update(index, id, data) {
+        const logger = this.logger.with('update');
+        const req = {
+            index,
+            id,
+            doc: data,
+        };
+        try {
+            await this.client.update(req);
+            logger.log({ req, res: undefined });
+        }
+        catch (error) {
+            logger.error({ req, res: error });
+            throw error;
+        }
+    }
+    async delete(index, id) {
+        const logger = this.logger.with('delete');
+        const req = {
+            index,
+            id,
+        };
+        try {
+            await this.client.delete(req);
+            logger.log({ req, res: undefined });
+        }
+        catch (error) {
+            logger.error({ req, res: error });
+            throw error;
+        }
+    }
+};
+exports.NativeElasticSearchAdapter = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(ES_CONFIG)),
+    __metadata("design:paramtypes", [Object])
 ], exports.NativeElasticSearchAdapter);
 
-class ConnectBaseDocumentSnapshot {
-    constructor(connectDocumentSnapshot) {
-        this.connectDocumentSnapshot = connectDocumentSnapshot;
-        this.id = connectDocumentSnapshot.id;
-    }
-    isNotEmpty() {
-        return this.connectDocumentSnapshot.exists;
-    }
-    data(options) {
-        return this.connectDocumentSnapshot.data();
-    }
-    get(fieldPath) {
-        return this.connectDocumentSnapshot.get(fieldPath);
-    }
+class ConnectBaseDocumentSnapshot {
+    constructor(connectDocumentSnapshot) {
+        this.connectDocumentSnapshot = connectDocumentSnapshot;
+        this.id = connectDocumentSnapshot.id;
+    }
+    isNotEmpty() {
+        return this.connectDocumentSnapshot.exists;
+    }
+    data(options) {
+        return this.connectDocumentSnapshot.data();
+    }
+    get(fieldPath) {
+        return this.connectDocumentSnapshot.get(fieldPath);
+    }
 }
 
-class ConnectDocumentService {
-    constructor(path, firestore) {
-        this.path = path;
-        this.firestore = firestore;
-        this.reference = this.firestore.doc(this.path).withConverter({
-            toFirestore: (data) => data,
-            fromFirestore: (snapshot) => {
-                return Object.assign({ id: snapshot.id }, snapshot.data());
-            },
-        });
-    }
-    async get() {
-        return new ConnectBaseDocumentSnapshot(await this.reference.get());
-    }
-    getId() {
-        return this.reference.id;
-    }
-    async save(data) {
-        if (this.reference)
-            this.reference.update(data);
-        else
-            await this.reference.create(data);
-        return this;
-    }
-    async delete() {
-        await this.reference.delete();
-    }
-    withConverter(params) {
-        this.reference = this.reference.withConverter({
-            toFirestore: (data) => params.toFirestore(data),
-            fromFirestore: (snapshot, options) => params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
-        });
-        return this;
-    }
+class ConnectDocumentService {
+    constructor(path, firestore) {
+        this.path = path;
+        this.firestore = firestore;
+        this.reference = this.firestore.doc(this.path).withConverter({
+            toFirestore: (data) => data,
+            fromFirestore: (snapshot) => {
+                return Object.assign({ id: snapshot.id }, snapshot.data());
+            },
+        });
+    }
+    async get() {
+        return new ConnectBaseDocumentSnapshot(await this.reference.get());
+    }
+    getId() {
+        return this.reference.id;
+    }
+    async save(data) {
+        if (this.reference)
+            this.reference.update(data);
+        else
+            await this.reference.create(data);
+        return this;
+    }
+    async delete() {
+        await this.reference.delete();
+    }
+    withConverter(params) {
+        this.reference = this.reference.withConverter({
+            toFirestore: (data) => params.toFirestore(data),
+            fromFirestore: (snapshot, options) => params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
+        });
+        return this;
+    }
 }
 
-class ConnectCollectionService {
-    constructor(path, firestore) {
-        this.firestore = firestore;
-        this.reference = firestore.collection(path).withConverter({
-            toFirestore: (data) => data,
-            fromFirestore: (snapshot) => {
-                return Object.assign({ id: snapshot.id }, snapshot.data());
-            },
-        });
-    }
-    async add(data, id) {
-        const newDoc = await this.save(data, id);
-        return new ConnectDocumentService(newDoc.path, this.firestore).withConverter(this.converter);
-    }
-    async getDocs() {
-        let query = this.query ? this.query : this.reference;
-        query = this.orderBy ? query.orderBy(this.orderBy.fieldPath, this.orderBy.directionStr) : query;
-        query = this.statingAt ? query.startAt(this.statingAt) : query;
-        query = this.startingAfter ? query.startAfter(this.startingAfter) : query;
-        query = this.offsetBy ? query.offset(this.offsetBy) : query;
-        query = this.limitBy ? query.limit(this.limitBy) : query;
-        return query.get().then((docs) => ({
-            empty: docs.empty,
-            size: docs.size,
-            docs: docs.docs.map((doc) => new ConnectBaseDocumentSnapshot(doc)),
-        }));
-    }
-    getDoc(id) {
-        return new ConnectDocumentService(`${this.reference.path}/${id}`, this.firestore).withConverter(this.converter);
-    }
-    where(fieldPath, opStr, value) {
-        this.query = this.query ? this.query.where(fieldPath, opStr, value) : this.reference.where(fieldPath, opStr, value);
-        return this;
-    }
-    order(attribute, order) {
-        this.orderBy = { fieldPath: attribute, directionStr: order };
-        return this;
-    }
-    limit(quantity) {
-        this.limitBy = quantity;
-        return this;
-    }
-    offset(offsetBy) {
-        this.offsetBy = offsetBy;
-        return this;
-    }
-    fromStartAt(startingAt) {
-        this.statingAt = startingAt;
-        return this;
-    }
-    fromStartAfter(startingAt) {
-        this.startingAfter = startingAt;
-        return this;
-    }
-    withConverter(params) {
-        this.converter = params;
-        this.reference = this.reference.withConverter({
-            toFirestore: (data) => params.toFirestore(data),
-            fromFirestore: (snapshot, options) => params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
-        });
-        return this;
-    }
-    async save(data, id) {
-        if (connect.isEmpty(id))
-            return this.reference.add(data);
-        const docRef = this.reference.doc(id);
-        await docRef.update(data);
-        return docRef;
-    }
+class ConnectCollectionService {
+    constructor(path, firestore) {
+        this.firestore = firestore;
+        this.reference = firestore.collection(path).withConverter({
+            toFirestore: (data) => data,
+            fromFirestore: (snapshot) => {
+                return Object.assign({ id: snapshot.id }, snapshot.data());
+            },
+        });
+    }
+    async add(data, id) {
+        const newDoc = await this.save(data, id);
+        return new ConnectDocumentService(newDoc.path, this.firestore).withConverter(this.converter);
+    }
+    async getDocs() {
+        let query = this.query ? this.query : this.reference;
+        query = this.orderBy ? query.orderBy(this.orderBy.fieldPath, this.orderBy.directionStr) : query;
+        query = this.statingAt ? query.startAt(this.statingAt) : query;
+        query = this.startingAfter ? query.startAfter(this.startingAfter) : query;
+        query = this.offsetBy ? query.offset(this.offsetBy) : query;
+        query = this.limitBy ? query.limit(this.limitBy) : query;
+        return query.get().then((docs) => ({
+            empty: docs.empty,
+            size: docs.size,
+            docs: docs.docs.map((doc) => new ConnectBaseDocumentSnapshot(doc)),
+        }));
+    }
+    getDoc(id) {
+        return new ConnectDocumentService(`${this.reference.path}/${id}`, this.firestore).withConverter(this.converter);
+    }
+    where(fieldPath, opStr, value) {
+        this.query = this.query ? this.query.where(fieldPath, opStr, value) : this.reference.where(fieldPath, opStr, value);
+        return this;
+    }
+    order(attribute, order) {
+        this.orderBy = { fieldPath: attribute, directionStr: order };
+        return this;
+    }
+    limit(quantity) {
+        this.limitBy = quantity;
+        return this;
+    }
+    offset(offsetBy) {
+        this.offsetBy = offsetBy;
+        return this;
+    }
+    fromStartAt(startingAt) {
+        this.statingAt = startingAt;
+        return this;
+    }
+    fromStartAfter(startingAt) {
+        this.startingAfter = startingAt;
+        return this;
+    }
+    withConverter(params) {
+        this.converter = params;
+        this.reference = this.reference.withConverter({
+            toFirestore: (data) => params.toFirestore(data),
+            fromFirestore: (snapshot, options) => params.fromFirestore(new ConnectBaseDocumentSnapshot(snapshot), options),
+        });
+        return this;
+    }
+    async save(data, id) {
+        if (connect.isEmpty(id))
+            return this.reference.add(data);
+        const docRef = this.reference.doc(id);
+        await docRef.update(data);
+        return docRef;
+    }
 }
 
-class ConnectFirestoreService {
-    constructor(firestore) {
-        this.firestore = firestore;
-    }
-    getCollection(path) {
-        return new ConnectCollectionService(path, this.firestore);
-    }
-    getDocument(path) {
-        return new ConnectDocumentService(path, this.firestore);
-    }
+class ConnectFirestoreService {
+    constructor(firestore) {
+        this.firestore = firestore;
+    }
+    getCollection(path) {
+        return new ConnectCollectionService(path, this.firestore);
+    }
+    getDocument(path) {
+        return new ConnectDocumentService(path, this.firestore);
+    }
 }
 
-var NestElasticSeachModule_1;
-exports.NestElasticSeachModule = NestElasticSeachModule_1 = class NestElasticSeachModule {
-    static initializeApp(options) {
-        return {
-            module: NestElasticSeachModule_1,
-            providers: [{ provide: ES_CONFIG, useValue: options }],
-            exports: [ES_CONFIG],
-        };
-    }
-};
-exports.NestElasticSeachModule = NestElasticSeachModule_1 = __decorate([
-    common.Module({
-        providers: [
-            exports.NativeElasticSearchAdapter,
-            {
-                provide: connect.ProductsIndex,
-                useFactory: (adapter) => new connect.ProductsIndex(adapter),
-                inject: [exports.NativeElasticSearchAdapter],
-            },
-        ],
-        exports: [connect.ProductsIndex],
-    })
+var NestElasticSeachModule_1;
+exports.NestElasticSeachModule = NestElasticSeachModule_1 = class NestElasticSeachModule {
+    static initializeApp(options) {
+        return {
+            module: NestElasticSeachModule_1,
+            providers: [{ provide: ES_CONFIG, useValue: options }],
+            exports: [ES_CONFIG],
+        };
+    }
+};
+exports.NestElasticSeachModule = NestElasticSeachModule_1 = __decorate([
+    common.Module({
+        providers: [
+            exports.NativeElasticSearchAdapter,
+            {
+                provide: connect.ProductsIndex,
+                useFactory: (adapter) => new connect.ProductsIndex(adapter),
+                inject: [exports.NativeElasticSearchAdapter],
+            },
+        ],
+        exports: [connect.ProductsIndex],
+    })
 ], exports.NestElasticSeachModule);
 
-exports.NestStorageModule = class NestStorageModule {
-};
-exports.NestStorageModule = __decorate([
-    common.Module({
-        providers: [
-            {
-                provide: FIREBASE_STORAGE,
-                useFactory: (firebaseAdmin) => firebaseAdmin.storage,
-                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
-            },
-        ],
-        exports: [FIREBASE_STORAGE],
-    })
+exports.NestStorageModule = class NestStorageModule {
+};
+exports.NestStorageModule = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: FIREBASE_STORAGE,
+                useFactory: (firebaseAdmin) => firebaseAdmin.storage,
+                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
+            },
+        ],
+        exports: [FIREBASE_STORAGE],
+    })
 ], exports.NestStorageModule);
 
-var NestFirestoreModule_1;
-exports.NestFirestoreModule = NestFirestoreModule_1 = class NestFirestoreModule {
-    static initializeApp(options) {
-        var _a;
-        return {
-            module: NestFirestoreModule_1,
-            imports: [
-                nestjsFirebase.FirebaseModule.forRoot({
-                    googleApplicationCredential: (_a = options === null || options === void 0 ? void 0 : options.firebase) === null || _a === void 0 ? void 0 : _a.googleApplicationCredential,
-                }),
-                exports.NestStorageModule,
-            ],
-            exports: [nestjsFirebase.FirebaseModule, exports.NestStorageModule],
-        };
-    }
-};
-exports.NestFirestoreModule = NestFirestoreModule_1 = __decorate([
-    common.Module({
-        providers: [
-            {
-                provide: ConnectFirestoreService,
-                useFactory: (firebaseAdmin) => new ConnectFirestoreService(firebaseAdmin.firestore),
-                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
-            },
-            {
-                provide: 'FirestoreOptions',
-                useFactory: (connectFirestoreService) => ({
-                    firestore: connectFirestoreService,
-                }),
-                inject: [ConnectFirestoreService],
-            },
-            {
-                provide: 'BeautyProfileRepository',
-                useFactory: (config, userRepository) => {
-                    return new connect.UserBeautyProfileFirestoreRepository(config, userRepository);
-                },
-                inject: ['FirestoreOptions', 'UserRepository'],
-            },
-            {
-                provide: 'Buy2WinRepository',
-                useFactory: (options) => {
-                    return new connect.Buy2WinFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: connect.CategoryFirestoreRepository,
-                useFactory: (options) => {
-                    return new connect.CategoryFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'CheckoutRepository',
-                useFactory: (options) => {
-                    return new connect.CheckoutFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'CheckoutSubscriptionRepository',
-                useFactory: (options) => {
-                    return new connect.CheckoutSubscriptionFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'CouponRepository',
-                useFactory: (options) => {
-                    return new connect.CouponFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'CampaignHashtagRepository',
-                useFactory: (options) => {
-                    return new connect.CampaignHashtagFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'CampaignDashboardRepository',
-                useFactory: (options) => {
-                    return new connect.CampaignDashboardFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'EditionRepository',
-                useFactory: (options, subscriptionRepository) => {
-                    return new connect.SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
-                },
-                inject: ['FirestoreOptions', 'SubscriptionRepository'],
-            },
-            {
-                provide: 'HomeRepository',
-                useFactory: (options) => {
-                    return new connect.HomeFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'LeadRepository',
-                useFactory: (options) => {
-                    return new connect.LeadFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'LegacyOrderRepository',
-                useFactory: (options) => {
-                    return new connect.LegacyOrderFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'ShopMenuRepository',
-                useFactory: (options) => {
-                    return new connect.ShopMenuFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'OrderRepository',
-                useFactory: (options) => {
-                    return new connect.OrderFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'PaymentRepository',
-                useFactory: (options) => {
-                    return new connect.PaymentFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: connect.ProductFirestoreRepository,
-                useFactory: (options) => {
-                    return new connect.ProductFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'ShopSettingsRepository',
-                useFactory: (options) => {
-                    return new connect.ShopSettingsFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'SubscriptionPaymentRepository',
-                useFactory: (options, subscriptionRepository) => {
-                    return new connect.SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
-                },
-                inject: ['FirestoreOptions', 'SubscriptionRepository'],
-            },
-            {
-                provide: 'SubscriptionPlanRepository',
-                useFactory: (options) => {
-                    return new connect.SubscriptionPlanFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'SubscriptionProductRepository',
-                useFactory: (options) => {
-                    return new connect.SubscriptionProductFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'SubscriptionRepository',
-                useFactory: (options) => {
-                    return new connect.SubscriptionFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'UserRepository',
-                useFactory: (options) => {
-                    return new connect.UserFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'UserAddressRepository',
-                useFactory: (options, userRepository) => {
-                    return new connect.UserAddressFirestoreRepository(options, userRepository);
-                },
-                inject: ['FirestoreOptions', 'UserRepository'],
-            },
-            {
-                provide: 'UserPaymentMethodRepository',
-                useFactory: (options, userRepository) => {
-                    return new connect.UserPaymentMethodFirestoreRepository(options, userRepository);
-                },
-                inject: ['FirestoreOptions', 'UserRepository'],
-            },
-            {
-                provide: 'SubscriptionMaterializationRepository',
-                useFactory: (options) => {
-                    return new connect.SubscriptionMaterializationFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: 'SubscriptionSummaryRepository',
-                useFactory: (options) => {
-                    return new connect.SubscriptionSummaryFirestoreRepository(options);
-                },
-                inject: ['FirestoreOptions'],
-            },
-            {
-                provide: connect.ProductVariantFirestoreRepository,
-                useFactory: (options, productRepository) => {
-                    return new connect.ProductVariantFirestoreRepository(options, productRepository);
-                },
-                inject: ['FirestoreOptions', connect.ProductFirestoreRepository],
-            },
-        ],
-        exports: [
-            'BeautyProfileRepository',
-            'Buy2WinRepository',
-            connect.CategoryFirestoreRepository,
-            'CheckoutRepository',
-            'CheckoutSubscriptionRepository',
-            'CouponRepository',
-            'CampaignHashtagRepository',
-            'CampaignDashboardRepository',
-            'EditionRepository',
-            'HomeRepository',
-            'LeadRepository',
-            'LegacyOrderRepository',
-            'ShopMenuRepository',
-            'OrderRepository',
-            'PaymentRepository',
-            connect.ProductFirestoreRepository,
-            'ShopSettingsRepository',
-            'SubscriptionPaymentRepository',
-            'SubscriptionPlanRepository',
-            'SubscriptionProductRepository',
-            'SubscriptionRepository',
-            'UserRepository',
-            'UserAddressRepository',
-            'UserPaymentMethodRepository',
-            'SubscriptionMaterializationRepository',
-            'SubscriptionSummaryRepository',
-            connect.ProductVariantFirestoreRepository,
-            ConnectFirestoreService,
-        ],
-    })
+var NestFirestoreModule_1;
+exports.NestFirestoreModule = NestFirestoreModule_1 = class NestFirestoreModule {
+    static initializeApp(options) {
+        var _a;
+        return {
+            module: NestFirestoreModule_1,
+            imports: [
+                nestjsFirebase.FirebaseModule.forRoot({
+                    googleApplicationCredential: (_a = options === null || options === void 0 ? void 0 : options.firebase) === null || _a === void 0 ? void 0 : _a.googleApplicationCredential,
+                }),
+                exports.NestStorageModule,
+            ],
+            exports: [nestjsFirebase.FirebaseModule, exports.NestStorageModule],
+        };
+    }
+};
+exports.NestFirestoreModule = NestFirestoreModule_1 = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: ConnectFirestoreService,
+                useFactory: (firebaseAdmin) => new ConnectFirestoreService(firebaseAdmin.firestore),
+                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
+            },
+            {
+                provide: 'FirestoreOptions',
+                useFactory: (connectFirestoreService) => ({
+                    firestore: connectFirestoreService,
+                }),
+                inject: [ConnectFirestoreService],
+            },
+            {
+                provide: 'BeautyProfileRepository',
+                useFactory: (config, userRepository) => {
+                    return new connect.UserBeautyProfileFirestoreRepository(config, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'Buy2WinRepository',
+                useFactory: (options) => {
+                    return new connect.Buy2WinFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: connect.CategoryFirestoreRepository,
+                useFactory: (options) => {
+                    return new connect.CategoryFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutRepository',
+                useFactory: (options) => {
+                    return new connect.CheckoutFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutSubscriptionRepository',
+                useFactory: (options) => {
+                    return new connect.CheckoutSubscriptionFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CouponRepository',
+                useFactory: (options) => {
+                    return new connect.CouponFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignHashtagRepository',
+                useFactory: (options) => {
+                    return new connect.CampaignHashtagFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignDashboardRepository',
+                useFactory: (options) => {
+                    return new connect.CampaignDashboardFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'EditionRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new connect.SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
+                },
+                inject: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'HomeRepository',
+                useFactory: (options) => {
+                    return new connect.HomeFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LeadRepository',
+                useFactory: (options) => {
+                    return new connect.LeadFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LegacyOrderRepository',
+                useFactory: (options) => {
+                    return new connect.LegacyOrderFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopMenuRepository',
+                useFactory: (options) => {
+                    return new connect.ShopMenuFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'OrderRepository',
+                useFactory: (options) => {
+                    return new connect.OrderFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'PaymentRepository',
+                useFactory: (options) => {
+                    return new connect.PaymentFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: connect.ProductFirestoreRepository,
+                useFactory: (options) => {
+                    return new connect.ProductFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopSettingsRepository',
+                useFactory: (options) => {
+                    return new connect.ShopSettingsFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionPaymentRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new connect.SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
+                },
+                inject: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'SubscriptionPlanRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionPlanFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionProductRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionProductFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserRepository',
+                useFactory: (options) => {
+                    return new connect.UserFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserAddressRepository',
+                useFactory: (options, userRepository) => {
+                    return new connect.UserAddressFirestoreRepository(options, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'UserPaymentMethodRepository',
+                useFactory: (options, userRepository) => {
+                    return new connect.UserPaymentMethodFirestoreRepository(options, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'SubscriptionMaterializationRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionMaterializationFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionSummaryRepository',
+                useFactory: (options) => {
+                    return new connect.SubscriptionSummaryFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: connect.ProductVariantFirestoreRepository,
+                useFactory: (options, productRepository) => {
+                    return new connect.ProductVariantFirestoreRepository(options, productRepository);
+                },
+                inject: ['FirestoreOptions', connect.ProductFirestoreRepository],
+            },
+        ],
+        exports: [
+            'BeautyProfileRepository',
+            'Buy2WinRepository',
+            connect.CategoryFirestoreRepository,
+            'CheckoutRepository',
+            'CheckoutSubscriptionRepository',
+            'CouponRepository',
+            'CampaignHashtagRepository',
+            'CampaignDashboardRepository',
+            'EditionRepository',
+            'HomeRepository',
+            'LeadRepository',
+            'LegacyOrderRepository',
+            'ShopMenuRepository',
+            'OrderRepository',
+            'PaymentRepository',
+            connect.ProductFirestoreRepository,
+            'ShopSettingsRepository',
+            'SubscriptionPaymentRepository',
+            'SubscriptionPlanRepository',
+            'SubscriptionProductRepository',
+            'SubscriptionRepository',
+            'UserRepository',
+            'UserAddressRepository',
+            'UserPaymentMethodRepository',
+            'SubscriptionMaterializationRepository',
+            'SubscriptionSummaryRepository',
+            connect.ProductVariantFirestoreRepository,
+            ConnectFirestoreService,
+        ],
+    })
 ], exports.NestFirestoreModule);
 
-var NestHasuraGraphQLModule_1;
-exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = class NestHasuraGraphQLModule {
-    static initializeApp(options) {
-        return {
-            module: NestHasuraGraphQLModule_1,
-            providers: [{ provide: HASURA_OPTIONS, useValue: options }],
-            exports: [HASURA_OPTIONS],
-        };
-    }
-};
-exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = __decorate([
-    common.Module({
-        providers: [
-            {
-                provide: 'HasuraConfig',
-                useFactory: (options) => ({
-                    endpoint: options.endpoint,
-                    authOptions: options.credentials,
-                }),
-                inject: [HASURA_OPTIONS],
-            },
-            {
-                provide: 'CategoryRepository',
-                useExisting: connect.CategoryHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.CategoryHasuraGraphQLRepository,
-                useFactory: (options, productRepository, categoryFilterRepository) => {
-                    return new connect.CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
-                },
-                inject: ['HasuraConfig', connect.ProductHasuraGraphQLRepository, connect.CategoryFilterHasuraGraphQLRepository],
-            },
-            {
-                provide: 'ProductRepository',
-                useExisting: connect.ProductHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.ProductHasuraGraphQLRepository,
-                useFactory: (hasuraConfig) => {
-                    return new connect.ProductHasuraGraphQLRepository(hasuraConfig);
-                },
-                inject: ['HasuraConfig'],
-            },
-            {
-                provide: 'ProductReviewsRepository',
-                useExisting: connect.ProductReviewsHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.ProductReviewsHasuraGraphQLRepository,
-                useFactory: (hasuraConfig) => {
-                    return new connect.ProductReviewsHasuraGraphQLRepository(hasuraConfig);
-                },
-                inject: ['HasuraConfig'],
-            },
-            {
-                provide: 'VariantRepository',
-                useExisting: connect.VariantHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.VariantHasuraGraphQLRepository,
-                useFactory: (hasuraConfig) => {
-                    return new connect.VariantHasuraGraphQLRepository(hasuraConfig);
-                },
-                inject: ['HasuraConfig'],
-            },
-            {
-                provide: 'CategoryFilterRepository',
-                useExisting: connect.CategoryFilterHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.CategoryFilterHasuraGraphQLRepository,
-                useFactory: (options) => {
-                    return new connect.CategoryFilterHasuraGraphQLRepository(options);
-                },
-                inject: ['HasuraConfig'],
-            },
-            {
-                provide: 'FilterOptionRepository',
-                useExisting: connect.FilterOptionHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.FilterOptionHasuraGraphQLRepository,
-                useFactory: (options) => {
-                    return new connect.FilterOptionHasuraGraphQLRepository(options);
-                },
-                inject: ['HasuraConfig'],
-            },
-            {
-                provide: 'FilterRepository',
-                useExisting: connect.FilterHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.FilterHasuraGraphQLRepository,
-                useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
-                    return new connect.FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
-                },
-                inject: ['HasuraConfig', connect.FilterOptionHasuraGraphQLRepository, connect.CategoryFilterHasuraGraphQLRepository],
-            },
-            {
-                provide: connect.CategoryCollectionChildrenHasuraGraphQLRepository,
-                useFactory: (options) => new connect.CategoryCollectionChildrenHasuraGraphQLRepository(options),
-                inject: ['HasuraConfig'],
-            },
-            {
-                provide: 'CategoryCollectionChildrenRepository',
-                useExisting: connect.CategoryCollectionChildrenHasuraGraphQLRepository,
-            },
-            {
-                provide: connect.WishlistHasuraGraphQLRepository,
-                useFactory: (options, categoryFilterRepository) => {
-                    return new connect.WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
-                },
-                inject: ['HasuraConfig', connect.CategoryFilterHasuraGraphQLRepository],
-            },
-            {
-                provide: 'WishlistRepository',
-                useExisting: connect.WishlistHasuraGraphQLRepository,
-            },
-        ],
-        exports: [
-            'CategoryRepository',
-            connect.CategoryHasuraGraphQLRepository,
-            'ProductRepository',
-            connect.ProductHasuraGraphQLRepository,
-            'ProductReviewsRepository',
-            connect.ProductReviewsHasuraGraphQLRepository,
-            'VariantRepository',
-            connect.VariantHasuraGraphQLRepository,
-            'CategoryFilterRepository',
-            connect.CategoryFilterHasuraGraphQLRepository,
-            'FilterOptionRepository',
-            connect.FilterOptionHasuraGraphQLRepository,
-            'FilterRepository',
-            connect.FilterHasuraGraphQLRepository,
-            'CategoryCollectionChildrenRepository',
-            connect.CategoryCollectionChildrenHasuraGraphQLRepository,
-            'WishlistRepository',
-            connect.WishlistHasuraGraphQLRepository,
-        ],
-    })
+var NestHasuraGraphQLModule_1;
+exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = class NestHasuraGraphQLModule {
+    static initializeApp(options) {
+        return {
+            module: NestHasuraGraphQLModule_1,
+            providers: [{ provide: HASURA_OPTIONS, useValue: options }],
+            exports: [HASURA_OPTIONS],
+        };
+    }
+};
+exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: 'HasuraConfig',
+                useFactory: (options) => ({
+                    endpoint: options.endpoint,
+                    authOptions: options.credentials,
+                }),
+                inject: [HASURA_OPTIONS],
+            },
+            {
+                provide: 'CategoryRepository',
+                useExisting: connect.CategoryHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.CategoryHasuraGraphQLRepository,
+                useFactory: (options, productRepository, categoryFilterRepository) => {
+                    return new connect.CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', connect.ProductHasuraGraphQLRepository, connect.CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: 'ProductRepository',
+                useExisting: connect.ProductHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.ProductHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductReviewsRepository',
+                useExisting: connect.ProductReviewsHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductReviewsHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.ProductReviewsHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'VariantRepository',
+                useExisting: connect.VariantHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.VariantHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.VariantHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductStockNotificationRepository',
+                useExisting: connect.ProductStockNotificationHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.ProductStockNotificationHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new connect.ProductStockNotificationHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryFilterRepository',
+                useExisting: connect.CategoryFilterHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.CategoryFilterHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new connect.CategoryFilterHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterOptionRepository',
+                useExisting: connect.FilterOptionHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.FilterOptionHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new connect.FilterOptionHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterRepository',
+                useExisting: connect.FilterHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.FilterHasuraGraphQLRepository,
+                useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
+                    return new connect.FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', connect.FilterOptionHasuraGraphQLRepository, connect.CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: connect.CategoryCollectionChildrenHasuraGraphQLRepository,
+                useFactory: (options) => new connect.CategoryCollectionChildrenHasuraGraphQLRepository(options),
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryCollectionChildrenRepository',
+                useExisting: connect.CategoryCollectionChildrenHasuraGraphQLRepository,
+            },
+            {
+                provide: connect.WishlistHasuraGraphQLRepository,
+                useFactory: (options, categoryFilterRepository) => {
+                    return new connect.WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', connect.CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: 'WishlistRepository',
+                useExisting: connect.WishlistHasuraGraphQLRepository,
+            },
+        ],
+        exports: [
+            'CategoryRepository',
+            connect.CategoryHasuraGraphQLRepository,
+            'ProductRepository',
+            connect.ProductHasuraGraphQLRepository,
+            'ProductReviewsRepository',
+            connect.ProductReviewsHasuraGraphQLRepository,
+            'VariantRepository',
+            connect.VariantHasuraGraphQLRepository,
+            'ProductStockNotificationRepository',
+            connect.ProductStockNotificationHasuraGraphQLRepository,
+            'CategoryFilterRepository',
+            connect.CategoryFilterHasuraGraphQLRepository,
+            'FilterOptionRepository',
+            connect.FilterOptionHasuraGraphQLRepository,
+            'FilterRepository',
+            connect.FilterHasuraGraphQLRepository,
+            'CategoryCollectionChildrenRepository',
+            connect.CategoryCollectionChildrenHasuraGraphQLRepository,
+            'WishlistRepository',
+            connect.WishlistHasuraGraphQLRepository,
+        ],
+    })
 ], exports.NestHasuraGraphQLModule);
 
-var NestConnectModule_1;
-exports.NestConnectModule = NestConnectModule_1 = class NestConnectModule {
-    static initializeApp(options) {
-        return {
-            module: NestConnectModule_1,
-            imports: [
-                ...(options.firebase ? [exports.NestFirestoreModule.initializeApp({ firebase: options.firebase })] : []),
-                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [exports.NestHasuraGraphQLModule.initializeApp(options.hasura)]),
-                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [exports.NestElasticSeachModule.initializeApp(options.elasticSearch)]),
-            ],
-            exports: [
-                ...(options.firebase ? [exports.NestFirestoreModule] : []),
-                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [exports.NestHasuraGraphQLModule]),
-                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [exports.NestElasticSeachModule]),
-            ],
-        };
-    }
-};
-exports.NestConnectModule = NestConnectModule_1 = __decorate([
-    common.Module({})
+var NestConnectModule_1;
+exports.NestConnectModule = NestConnectModule_1 = class NestConnectModule {
+    static initializeApp(options) {
+        return {
+            module: NestConnectModule_1,
+            imports: [
+                ...(options.firebase ? [exports.NestFirestoreModule.initializeApp({ firebase: options.firebase })] : []),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [exports.NestHasuraGraphQLModule.initializeApp(options.hasura)]),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [exports.NestElasticSeachModule.initializeApp(options.elasticSearch)]),
+            ],
+            exports: [
+                ...(options.firebase ? [exports.NestFirestoreModule] : []),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.hasura) ? [] : [exports.NestHasuraGraphQLModule]),
+                ...(connect.isNil(options === null || options === void 0 ? void 0 : options.elasticSearch) ? [] : [exports.NestElasticSeachModule]),
+            ],
+        };
+    }
+};
+exports.NestConnectModule = NestConnectModule_1 = __decorate([
+    common.Module({})
 ], exports.NestConnectModule);
 
 exports.ConnectCollectionService = ConnectCollectionService;