@infrab4a/connect-nestjs 1.0.0-beta.0

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,531 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var connect = require('@infrab4a/connect');
+var common = require('@nestjs/common');
+var nestjsFirebase = require('nestjs-firebase');
+
+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 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);
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var NestFirestoreModule_1;
+exports.NestFirestoreModule = NestFirestoreModule_1 = class NestFirestoreModule {
+    static initializeApp(options) {
+        return {
+            module: NestFirestoreModule_1,
+            imports: [
+                nestjsFirebase.FirebaseModule.forRoot({
+                    googleApplicationCredential: options.firebase.googleApplicationCredential,
+                }),
+            ],
+        };
+    }
+};
+exports.NestFirestoreModule = NestFirestoreModule_1 = __decorate([
+    common.Module({
+        providers: [
+            {
+                provide: 'FirestoreOptions',
+                useFactory: (firestore) => ({
+                    firestore: new ConnectFirestoreService(firestore),
+                }),
+                inject: [nestjsFirebase.FirebaseConstants.FIREBASE_TOKEN],
+            },
+            {
+                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.NestFirestoreModule);
+
+const HASURA_OPTIONS = 'HASURA_OPTIONS';
+
+var NestHasuraGraphQLModule_1;
+exports.NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = class NestHasuraGraphQLModule {
+    static initializeApp(options) {
+        return {
+            module: NestHasuraGraphQLModule_1,
+            providers: [{ provide: HASURA_OPTIONS, useValue: 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.NestHasuraGraphQLModule);
+
+var NestConnectModule_1;
+exports.NestConnectModule = NestConnectModule_1 = class NestConnectModule {
+    static initializeApp(defaultShop, options) {
+        return {
+            module: NestConnectModule_1,
+            imports: [
+                nestjsFirebase.FirebaseModule.forRoot({
+                    googleApplicationCredential: options.firebase.googleApplicationCredential,
+                }),
+            ],
+        };
+    }
+};
+exports.NestConnectModule = NestConnectModule_1 = __decorate([
+    common.Module({
+        imports: [exports.NestFirestoreModule, exports.NestHasuraGraphQLModule],
+    })
+], exports.NestConnectModule);
+
+exports.ConnectCollectionService = ConnectCollectionService;
+exports.ConnectDocumentService = ConnectDocumentService;
+exports.ConnectFirestoreService = ConnectFirestoreService;

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.esm.js

@@ -0,0 +1,525 @@
+import { isEmpty, UserBeautyProfileFirestoreRepository, Buy2WinFirestoreRepository, CategoryFirestoreRepository, CheckoutFirestoreRepository, CheckoutSubscriptionFirestoreRepository, CouponFirestoreRepository, CampaignHashtagFirestoreRepository, CampaignDashboardFirestoreRepository, SubscriptionEditionFirestoreRepository, HomeFirestoreRepository, LeadFirestoreRepository, LegacyOrderFirestoreRepository, ShopMenuFirestoreRepository, OrderFirestoreRepository, PaymentFirestoreRepository, ProductFirestoreRepository, ShopSettingsFirestoreRepository, SubscriptionPaymentFirestoreRepository, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, SubscriptionFirestoreRepository, UserFirestoreRepository, UserAddressFirestoreRepository, UserPaymentMethodFirestoreRepository, SubscriptionMaterializationFirestoreRepository, SubscriptionSummaryFirestoreRepository, ProductVariantFirestoreRepository, CategoryHasuraGraphQLRepository, ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository, ProductReviewsHasuraGraphQLRepository, VariantHasuraGraphQLRepository, FilterOptionHasuraGraphQLRepository, FilterHasuraGraphQLRepository, CategoryCollectionChildrenHasuraGraphQLRepository, WishlistHasuraGraphQLRepository } from '@infrab4a/connect';
+import { Module } from '@nestjs/common';
+import { FirebaseConstants, FirebaseModule } from 'nestjs-firebase';
+
+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 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 (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);
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var NestFirestoreModule_1;
+let NestFirestoreModule = NestFirestoreModule_1 = class NestFirestoreModule {
+    static initializeApp(options) {
+        return {
+            module: NestFirestoreModule_1,
+            imports: [
+                FirebaseModule.forRoot({
+                    googleApplicationCredential: options.firebase.googleApplicationCredential,
+                }),
+            ],
+        };
+    }
+};
+NestFirestoreModule = NestFirestoreModule_1 = __decorate([
+    Module({
+        providers: [
+            {
+                provide: 'FirestoreOptions',
+                useFactory: (firestore) => ({
+                    firestore: new ConnectFirestoreService(firestore),
+                }),
+                inject: [FirebaseConstants.FIREBASE_TOKEN],
+            },
+            {
+                provide: 'BeautyProfileRepository',
+                useFactory: (config, userRepository) => {
+                    return new UserBeautyProfileFirestoreRepository(config, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'Buy2WinRepository',
+                useFactory: (options) => {
+                    return new Buy2WinFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: CategoryFirestoreRepository,
+                useFactory: (options) => {
+                    return new CategoryFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutRepository',
+                useFactory: (options) => {
+                    return new CheckoutFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CheckoutSubscriptionRepository',
+                useFactory: (options) => {
+                    return new CheckoutSubscriptionFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CouponRepository',
+                useFactory: (options) => {
+                    return new CouponFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignHashtagRepository',
+                useFactory: (options) => {
+                    return new CampaignHashtagFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'CampaignDashboardRepository',
+                useFactory: (options) => {
+                    return new CampaignDashboardFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'EditionRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new SubscriptionEditionFirestoreRepository(options, subscriptionRepository);
+                },
+                inject: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'HomeRepository',
+                useFactory: (options) => {
+                    return new HomeFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LeadRepository',
+                useFactory: (options) => {
+                    return new LeadFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'LegacyOrderRepository',
+                useFactory: (options) => {
+                    return new LegacyOrderFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopMenuRepository',
+                useFactory: (options) => {
+                    return new ShopMenuFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'OrderRepository',
+                useFactory: (options) => {
+                    return new OrderFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'PaymentRepository',
+                useFactory: (options) => {
+                    return new PaymentFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: ProductFirestoreRepository,
+                useFactory: (options) => {
+                    return new ProductFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'ShopSettingsRepository',
+                useFactory: (options) => {
+                    return new ShopSettingsFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionPaymentRepository',
+                useFactory: (options, subscriptionRepository) => {
+                    return new SubscriptionPaymentFirestoreRepository(options, subscriptionRepository);
+                },
+                inject: ['FirestoreOptions', 'SubscriptionRepository'],
+            },
+            {
+                provide: 'SubscriptionPlanRepository',
+                useFactory: (options) => {
+                    return new SubscriptionPlanFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionProductRepository',
+                useFactory: (options) => {
+                    return new SubscriptionProductFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionRepository',
+                useFactory: (options) => {
+                    return new SubscriptionFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserRepository',
+                useFactory: (options) => {
+                    return new UserFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'UserAddressRepository',
+                useFactory: (options, userRepository) => {
+                    return new UserAddressFirestoreRepository(options, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'UserPaymentMethodRepository',
+                useFactory: (options, userRepository) => {
+                    return new UserPaymentMethodFirestoreRepository(options, userRepository);
+                },
+                inject: ['FirestoreOptions', 'UserRepository'],
+            },
+            {
+                provide: 'SubscriptionMaterializationRepository',
+                useFactory: (options) => {
+                    return new SubscriptionMaterializationFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: 'SubscriptionSummaryRepository',
+                useFactory: (options) => {
+                    return new SubscriptionSummaryFirestoreRepository(options);
+                },
+                inject: ['FirestoreOptions'],
+            },
+            {
+                provide: ProductVariantFirestoreRepository,
+                useFactory: (options, productRepository) => {
+                    return new ProductVariantFirestoreRepository(options, productRepository);
+                },
+                inject: ['FirestoreOptions', ProductFirestoreRepository],
+            },
+        ],
+    })
+], NestFirestoreModule);
+
+const HASURA_OPTIONS = 'HASURA_OPTIONS';
+
+var NestHasuraGraphQLModule_1;
+let NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = class NestHasuraGraphQLModule {
+    static initializeApp(options) {
+        return {
+            module: NestHasuraGraphQLModule_1,
+            providers: [{ provide: HASURA_OPTIONS, useValue: options }],
+        };
+    }
+};
+NestHasuraGraphQLModule = NestHasuraGraphQLModule_1 = __decorate([
+    Module({
+        providers: [
+            {
+                provide: 'HasuraConfig',
+                useFactory: (options) => ({
+                    endpoint: options.endpoint,
+                    authOptions: options.credentials,
+                }),
+                inject: [HASURA_OPTIONS],
+            },
+            {
+                provide: 'CategoryRepository',
+                useExisting: CategoryHasuraGraphQLRepository,
+            },
+            {
+                provide: CategoryHasuraGraphQLRepository,
+                useFactory: (options, productRepository, categoryFilterRepository) => {
+                    return new CategoryHasuraGraphQLRepository(options, productRepository, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', ProductHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: 'ProductRepository',
+                useExisting: ProductHasuraGraphQLRepository,
+            },
+            {
+                provide: ProductHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new ProductHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'ProductReviewsRepository',
+                useExisting: ProductReviewsHasuraGraphQLRepository,
+            },
+            {
+                provide: ProductReviewsHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new ProductReviewsHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'VariantRepository',
+                useExisting: VariantHasuraGraphQLRepository,
+            },
+            {
+                provide: VariantHasuraGraphQLRepository,
+                useFactory: (hasuraConfig) => {
+                    return new VariantHasuraGraphQLRepository(hasuraConfig);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryFilterRepository',
+                useExisting: CategoryFilterHasuraGraphQLRepository,
+            },
+            {
+                provide: CategoryFilterHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new CategoryFilterHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterOptionRepository',
+                useExisting: FilterOptionHasuraGraphQLRepository,
+            },
+            {
+                provide: FilterOptionHasuraGraphQLRepository,
+                useFactory: (options) => {
+                    return new FilterOptionHasuraGraphQLRepository(options);
+                },
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'FilterRepository',
+                useExisting: FilterHasuraGraphQLRepository,
+            },
+            {
+                provide: FilterHasuraGraphQLRepository,
+                useFactory: (options, filterOptionRepository, categoryFilterRepository) => {
+                    return new FilterHasuraGraphQLRepository(options, filterOptionRepository, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', FilterOptionHasuraGraphQLRepository, CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: CategoryCollectionChildrenHasuraGraphQLRepository,
+                useFactory: (options) => new CategoryCollectionChildrenHasuraGraphQLRepository(options),
+                inject: ['HasuraConfig'],
+            },
+            {
+                provide: 'CategoryCollectionChildrenRepository',
+                useExisting: CategoryCollectionChildrenHasuraGraphQLRepository,
+            },
+            {
+                provide: WishlistHasuraGraphQLRepository,
+                useFactory: (options, categoryFilterRepository) => {
+                    return new WishlistHasuraGraphQLRepository(options, categoryFilterRepository);
+                },
+                inject: ['HasuraConfig', CategoryFilterHasuraGraphQLRepository],
+            },
+            {
+                provide: 'WishlistRepository',
+                useExisting: WishlistHasuraGraphQLRepository,
+            },
+        ],
+    })
+], NestHasuraGraphQLModule);
+
+var NestConnectModule_1;
+let NestConnectModule = NestConnectModule_1 = class NestConnectModule {
+    static initializeApp(defaultShop, options) {
+        return {
+            module: NestConnectModule_1,
+            imports: [
+                FirebaseModule.forRoot({
+                    googleApplicationCredential: options.firebase.googleApplicationCredential,
+                }),
+            ],
+        };
+    }
+};
+NestConnectModule = NestConnectModule_1 = __decorate([
+    Module({
+        imports: [NestFirestoreModule, NestHasuraGraphQLModule],
+    })
+], NestConnectModule);
+
+export { ConnectCollectionService, ConnectDocumentService, ConnectFirestoreService, NestConnectModule, NestFirestoreModule, NestHasuraGraphQLModule };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@infrab4a/connect-nestjs",
+  "version": "1.0.0-beta.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/B4AGroup/b4a-firebase-libs"
+  },
+  "peerDependencies": {
+    "@infrab4a/connect": "4.4.0-beta.9",
+    "@nestjs/common": "^10.3.3",
+    "@nestjs/core": "^10.3.3",
+    "firebase-admin": "^12.0.0"
+  },
+  "dependencies": {
+    "nestjs-firebase": "^10.4.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js"
+}

package/src/consts/hasura-options.const.d.ts

@@ -0,0 +1 @@
+export declare const HASURA_OPTIONS = "HASURA_OPTIONS";

package/src/consts/index.d.ts

@@ -0,0 +1 @@
+export * from './hasura-options.const';

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './infra';
+export * from './nest-connect.module';
+export * from './nest-firestore.module';
+export * from './nest-hasura-graphql.module';

package/src/infra/firebase/firestore/index.d.ts

@@ -0,0 +1,2 @@
+export * from './services';
+export * from './types';

package/src/infra/firebase/firestore/services/connect-collection-reference.d.ts

@@ -0,0 +1,19 @@
+import { ConnectDocumentData, ConnectDocumentSnapshot, ConnectQuerySnapshot, ConnectSnapshotOptions, ConnectWhereOption } from '@infrab4a/connect';
+import { ConnectDocumentReference } from './connect-document-reference';
+export interface ConnectCollectionReference<T extends ConnectDocumentData> {
+    add(data: Partial<T>, id?: string): Promise<ConnectDocumentReference<T>>;
+    where(attribute: string, operator: ConnectWhereOption, value: any): ConnectCollectionReference<T>;
+    order(attribute: string, order: 'asc' | 'desc'): ConnectCollectionReference<T>;
+    limit(quantity: number): ConnectCollectionReference<T>;
+    offset(offset: number): ConnectCollectionReference<T>;
+    fromStartAt(startAt: number): ConnectCollectionReference<T>;
+    fromStartAt(startAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>;
+    fromStartAfter(startAt: number): ConnectCollectionReference<T>;
+    fromStartAfter(startAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>;
+    withConverter(converter: {
+        toFirestore: (data: T) => ConnectDocumentData<T>;
+        fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T;
+    }): ConnectCollectionReference<T>;
+    getDoc(id?: string): ConnectDocumentReference<T>;
+    getDocs(): Promise<ConnectQuerySnapshot<T>>;
+}

package/src/infra/firebase/firestore/services/connect-collection.service.d.ts

@@ -0,0 +1,32 @@
+import { Firestore } from 'firebase-admin/firestore';
+import { ConnectDocumentData, ConnectDocumentSnapshot, ConnectQuerySnapshot, ConnectSnapshotOptions, ConnectWhereOption } from '@infrab4a/connect';
+import { ConnectCollectionReference } from './connect-collection-reference';
+import { ConnectDocumentReference } from './connect-document-reference';
+export declare class ConnectCollectionService<T extends ConnectDocumentData> implements ConnectCollectionReference<T> {
+    private readonly firestore;
+    private reference;
+    private query;
+    private orderBy;
+    private limitBy;
+    private offsetBy;
+    private statingAt;
+    private startingAfter;
+    private converter;
+    constructor(path: string, firestore: Firestore);
+    add(data: T, id?: string): Promise<ConnectDocumentReference<T>>;
+    getDocs(): Promise<ConnectQuerySnapshot<T>>;
+    getDoc(id?: string): ConnectDocumentReference<T>;
+    where(fieldPath: string, opStr: ConnectWhereOption, value: any): ConnectCollectionReference<T>;
+    order(attribute: string, order: 'asc' | 'desc'): ConnectCollectionReference<T>;
+    limit(quantity: number): ConnectCollectionReference<T>;
+    offset(offsetBy: number): ConnectCollectionReference<T>;
+    fromStartAt(startingAt: number): ConnectCollectionReference<T>;
+    fromStartAt(startingAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>;
+    fromStartAfter(startingAt: number): ConnectCollectionReference<T>;
+    fromStartAfter(startingAt: ConnectDocumentReference<T>): ConnectCollectionReference<T>;
+    withConverter(params: {
+        toFirestore: (data: T) => ConnectDocumentData<T>;
+        fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T;
+    }): ConnectCollectionReference<T>;
+    private save;
+}

package/src/infra/firebase/firestore/services/connect-document-reference.d.ts

@@ -0,0 +1,11 @@
+import { ConnectDocumentData, ConnectDocumentSnapshot, ConnectSnapshotOptions } from '@infrab4a/connect';
+export interface ConnectDocumentReference<T extends ConnectDocumentData> {
+    get(): Promise<ConnectDocumentSnapshot<T>>;
+    getId(): string;
+    save(data: T): Promise<ConnectDocumentReference<T>>;
+    delete(): Promise<void>;
+    withConverter(converter: {
+        toFirestore: (data: T) => ConnectDocumentData<T>;
+        fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T;
+    }): ConnectDocumentReference<T>;
+}

package/src/infra/firebase/firestore/services/connect-document.service.d.ts

@@ -0,0 +1,17 @@
+import { ConnectDocumentData, ConnectDocumentSnapshot, ConnectSnapshotOptions } from '@infrab4a/connect';
+import { Firestore } from 'firebase-admin/firestore';
+import { ConnectDocumentReference } from './connect-document-reference';
+export declare class ConnectDocumentService<T extends ConnectDocumentData> implements ConnectDocumentReference<T> {
+    private path;
+    private firestore;
+    private reference;
+    constructor(path: string, firestore: Firestore);
+    get(): Promise<ConnectDocumentSnapshot<T>>;
+    getId(): string;
+    save(data: T): Promise<ConnectDocumentReference<T>>;
+    delete(): Promise<void>;
+    withConverter(params: {
+        toFirestore: (data: T) => ConnectDocumentData<T>;
+        fromFirestore: (snapshot: ConnectDocumentSnapshot<T>, options?: ConnectSnapshotOptions) => T;
+    }): ConnectDocumentReference<T>;
+}

package/src/infra/firebase/firestore/services/connect-firestore.d.ts

@@ -0,0 +1,7 @@
+import { ConnectDocumentData } from '@infrab4a/connect';
+import { ConnectCollectionReference } from './connect-collection-reference';
+import { ConnectDocumentReference } from './connect-document-reference';
+export interface ConnectFirestore {
+    getCollection<T extends ConnectDocumentData>(path: string): ConnectCollectionReference<T>;
+    getDocument<T extends ConnectDocumentData>(path: string): ConnectDocumentReference<T>;
+}

package/src/infra/firebase/firestore/services/connect-firestore.service.d.ts

@@ -0,0 +1,11 @@
+import { Firestore } from 'firebase-admin/firestore';
+import { ConnectDocumentData } from '@infrab4a/connect';
+import { ConnectCollectionReference } from './connect-collection-reference';
+import { ConnectDocumentReference } from './connect-document-reference';
+import { ConnectFirestore } from './connect-firestore';
+export declare class ConnectFirestoreService implements ConnectFirestore {
+    private firestore;
+    constructor(firestore: Firestore);
+    getCollection<T extends ConnectDocumentData>(path: string): ConnectCollectionReference<T>;
+    getDocument<T extends ConnectDocumentData>(path: string): ConnectDocumentReference<T>;
+}

package/src/infra/firebase/firestore/services/index.d.ts

@@ -0,0 +1,6 @@
+export * from './connect-collection-reference';
+export * from './connect-collection.service';
+export * from './connect-document-reference';
+export * from './connect-document.service';
+export * from './connect-firestore';
+export * from './connect-firestore.service';

package/src/infra/firebase/firestore/types/connect-query-snapshot.type.d.ts

@@ -0,0 +1,4 @@
+import { ConnectDocumentData, ConnectDocumentSnapshot as ConnectDocumentSnapshotBase } from '@infrab4a/connect';
+export type ConnectDocumentSnapshot<T extends ConnectDocumentData = ConnectDocumentData> = ConnectDocumentSnapshotBase<T> & {
+    exists: boolean;
+};

package/src/infra/firebase/firestore/types/index.d.ts

@@ -0,0 +1 @@
+export * from './connect-query-snapshot.type';

package/src/infra/firebase/firestore/vo/connect-base-document-snapshot.vo.d.ts

@@ -0,0 +1,12 @@
+import { ConnectDocumentData, ConnectSnapshotOptions } from '@infrab4a/connect';
+import { DocumentSnapshot } from 'firebase-admin/firestore';
+import { ConnectDocumentSnapshot } from '../types';
+export declare class ConnectBaseDocumentSnapshot<T extends ConnectDocumentData = ConnectDocumentData> implements ConnectDocumentSnapshot<T> {
+    private readonly connectDocumentSnapshot;
+    id: string;
+    exists: boolean;
+    constructor(connectDocumentSnapshot: DocumentSnapshot<T>);
+    isNotEmpty(): boolean;
+    data(options?: ConnectSnapshotOptions): T;
+    get(fieldPath: string): any;
+}

package/src/infra/firebase/firestore/vo/index.d.ts

@@ -0,0 +1 @@
+export * from './connect-base-document-snapshot.vo';

package/src/infra/firebase/index.d.ts

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

package/src/infra/index.d.ts

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

package/src/nest-connect.module.d.ts

@@ -0,0 +1,9 @@
+import { Shops } from '@infrab4a/connect';
+import { DynamicModule } from '@nestjs/common';
+export declare class NestConnectModule {
+    static initializeApp(defaultShop: Shops, options: {
+        firebase: {
+            googleApplicationCredential: string;
+        };
+    }): DynamicModule;
+}

package/src/nest-firestore.module.d.ts

@@ -0,0 +1,10 @@
+import { FirestoreConstructorParams } from '@infrab4a/connect';
+import { DynamicModule } from '@nestjs/common';
+export type FirestoreOptions = Pick<FirestoreConstructorParams<any>, 'firestore' | 'interceptors'>;
+export declare class NestFirestoreModule {
+    static initializeApp(options: {
+        firebase: {
+            googleApplicationCredential: string;
+        };
+    }): DynamicModule;
+}

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

@@ -0,0 +1,12 @@
+import { HasuraGraphQLAuthOptions } from '@infrab4a/connect';
+import { DynamicModule } from '@nestjs/common';
+export type HasuraGraphQLOptions = {
+    endpoint: string;
+    credentials: HasuraGraphQLAuthOptions;
+};
+export declare class NestHasuraGraphQLModule {
+    static initializeApp(options: {
+        endpoint: string;
+        credentials: HasuraGraphQLAuthOptions;
+    }): DynamicModule;
+}