nestjs-firebase-admin 0.3.4 → 0.3.5

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './modules/admin/admin.module';
 export * from './modules/admin/admin.service';
+export * from './modules/admin/database.service';
 export * from './modules/admin/interfaces';
 export * from './modules/admin/types';

package/dist/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./modules/admin/admin.module"), exports);
 __exportStar(require("./modules/admin/admin.service"), exports);
+__exportStar(require("./modules/admin/database.service"), exports);
 __exportStar(require("./modules/admin/interfaces"), exports);
 __exportStar(require("./modules/admin/types"), exports);

package/dist/modules/admin/admin.module.d.ts

@@ -1,16 +1,7 @@
-import { DynamicModule, Provider, Type } from '@nestjs/common';
-import type { AdminModuleAsyncOptions, AdminModuleOptionsFactory } from './interfaces';
+import { DynamicModule } from '@nestjs/common';
+import type { AdminModuleAsyncOptions } from './interfaces';
 import type { AdminModuleOptions } from './types';
 export declare class AdminModule {
     static register(options: AdminModuleOptions): DynamicModule;
-    static registerAsync(options: AdminModuleAsyncOptions): {
-        module: typeof AdminModule;
-        imports: (Type<any> | DynamicModule | Promise<DynamicModule> | import("@nestjs/common").ForwardReference<any>)[] | undefined;
-        providers: (Provider | {
-            provide: Type<AdminModuleOptionsFactory> | undefined;
-            useClass: Type<AdminModuleOptionsFactory> | undefined;
-        })[];
-    };
-    private static createAsyncProviders;
-    private static createAsyncOptionsProvider;
+    static registerAsync(options: AdminModuleAsyncOptions): DynamicModule;
 }

package/dist/modules/admin/admin.module.js

@@ -14,16 +14,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var AdminModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminModule = void 0;
 const common_1 = require("@nestjs/common");
 const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const firebase_admin_1 = __importDefault(require("firebase-admin"));
 const admin_constants_1 = require("./admin.constants");
 const admin_service_1 = require("./admin.service");
 const database_service_1 = require("./database.service");
 let AdminModule = AdminModule_1 = class AdminModule {
     static register(options) {
+        const firebaseApp = firebase_admin_1.default.initializeApp(Object.assign(Object.assign({}, options), { credential: firebase_admin_1.default.credential.cert(options.credential) }));
         return {
             module: AdminModule_1,
             providers: [
@@ -32,58 +37,82 @@ let AdminModule = AdminModule_1 = class AdminModule {
                     useValue: options,
                 },
                 {
-                    provide: admin_constants_1.ADMIN_MODULE_ID,
-                    useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
-                },
-            ],
-        };
-    }
-    static registerAsync(options) {
-        return {
-            module: AdminModule_1,
-            imports: options.imports,
-            providers: [
-                ...this.createAsyncProviders(options),
-                {
-                    provide: admin_constants_1.FIREBASE_ADMIN_INSTANCE_TOKEN,
-                    useFactory: (options) => options,
-                    inject: [admin_constants_1.ADMIN_MODULE_OPTIONS],
+                    provide: 'FIREBASE_ADMIN_APP',
+                    useValue: firebaseApp,
                 },
                 {
                     provide: admin_constants_1.ADMIN_MODULE_ID,
                     useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
                 },
-                ...(options.extraProviders || []),
             ],
         };
     }
-    static createAsyncProviders(options) {
-        if (options.useExisting || options.useFactory) {
-            return [this.createAsyncOptionsProvider(options)];
+    static registerAsync(options) {
+        const providers = [];
+        if (options.useFactory) {
+            const factory = options.useFactory;
+            providers.push({
+                provide: admin_constants_1.FIREBASE_ADMIN_INSTANCE_TOKEN,
+                useFactory: factory,
+                inject: options.inject || [],
+            });
+            providers.push({
+                provide: 'FIREBASE_ADMIN_APP',
+                useFactory: (...args) => __awaiter(this, void 0, void 0, function* () {
+                    const config = yield factory(...args);
+                    return firebase_admin_1.default.initializeApp(Object.assign(Object.assign({}, config), { credential: firebase_admin_1.default.credential.cert(config.credential) }));
+                }),
+                inject: options.inject || [],
+            });
+        }
+        else if (options.useExisting) {
+            providers.push({
+                provide: admin_constants_1.FIREBASE_ADMIN_INSTANCE_TOKEN,
+                useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () {
+                    const config = yield optionsFactory.createAdminOptions();
+                    return config;
+                }),
+                inject: [options.useExisting],
+            });
+            providers.push({
+                provide: 'FIREBASE_ADMIN_APP',
+                useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () {
+                    const config = yield optionsFactory.createAdminOptions();
+                    return firebase_admin_1.default.initializeApp(Object.assign(Object.assign({}, config), { credential: firebase_admin_1.default.credential.cert(config.credential) }));
+                }),
+                inject: [options.useExisting],
+            });
         }
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
+        else if (options.useClass) {
+            providers.push({
                 provide: options.useClass,
                 useClass: options.useClass,
-            },
-        ];
-    }
-    static createAsyncOptionsProvider(options) {
-        if (options.useFactory) {
-            return {
-                provide: admin_constants_1.ADMIN_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || [],
-            };
+            });
+            providers.push({
+                provide: admin_constants_1.FIREBASE_ADMIN_INSTANCE_TOKEN,
+                useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () {
+                    const config = yield optionsFactory.createAdminOptions();
+                    return config;
+                }),
+                inject: [options.useClass],
+            });
+            providers.push({
+                provide: 'FIREBASE_ADMIN_APP',
+                useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () {
+                    const config = yield optionsFactory.createAdminOptions();
+                    return firebase_admin_1.default.initializeApp(Object.assign(Object.assign({}, config), { credential: firebase_admin_1.default.credential.cert(config.credential) }));
+                }),
+                inject: [options.useClass],
+            });
+        }
+        else {
+            throw new Error('One of useFactory, useExisting, or useClass must be provided in AdminModuleAsyncOptions');
         }
         return {
-            provide: admin_constants_1.ADMIN_MODULE_OPTIONS,
-            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return optionsFactory.createAdminOptions(); }),
-            inject: [
-                (options.useExisting ||
-                    options.useClass),
-            ],
+            module: AdminModule_1,
+            imports: options.imports,
+            providers,
+            exports: [admin_service_1.AdminService],
         };
     }
 };

package/dist/modules/admin/admin.service.d.ts

@@ -5,7 +5,9 @@ import type { Agent } from 'node:http';
 import type { AdminModuleOptions } from './types';
 export declare class AdminService {
     protected readonly options: AdminModuleOptions;
-    constructor(options: AdminModuleOptions);
+    private readonly firebaseApp;
+    private readonly app;
+    constructor(options: AdminModuleOptions, firebaseApp: App);
     applicationDefault(httpAgent?: Agent): import("firebase-admin/app").Credential;
     deleteApp(app: App): Promise<void>;
     get getApps(): App[];

package/dist/modules/admin/admin.service.js

@@ -22,9 +22,10 @@ const app_1 = require("firebase-admin/app");
 const firebase_admin_1 = __importDefault(require("firebase-admin"));
 const admin_constants_1 = require("./admin.constants");
 let AdminService = class AdminService {
-    constructor(options) {
+    constructor(options, firebaseApp) {
         this.options = options;
-        firebase_admin_1.default.initializeApp(Object.assign(Object.assign({}, this.options), { credential: firebase_admin_1.default.credential.cert(this.options.credential) }));
+        this.firebaseApp = firebaseApp;
+        this.app = firebaseApp;
     }
     applicationDefault(httpAgent) {
         return (0, app_1.applicationDefault)(httpAgent);
@@ -54,15 +55,16 @@ let AdminService = class AdminService {
         });
     }
     get appRef() {
-        return this.initializeApp();
+        return this.app;
     }
     initializeApp() {
-        return this.admin().initializeApp(Object.assign(Object.assign({}, this.options), { credential: firebase_admin_1.default.credential.cert(this.options.credential) }));
+        return this.app;
     }
 };
 exports.AdminService = AdminService;
 exports.AdminService = AdminService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(admin_constants_1.FIREBASE_ADMIN_INSTANCE_TOKEN)),
-    __metadata("design:paramtypes", [Object])
+    __param(1, (0, common_1.Inject)('FIREBASE_ADMIN_APP')),
+    __metadata("design:paramtypes", [Object, Object])
 ], AdminService);

package/dist/modules/admin/admin.service.spec.js

@@ -46,6 +46,9 @@ describe('AdminService', () => {
     };
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         jest.clearAllMocks();
+        const mockApp = { name: 'app-name', options: {} };
+        firebaseAdmin.initializeApp.mockReturnValue(mockApp);
+        firebaseAdmin.credential.cert.mockReturnValue('mocked-credential');
         const module = yield testing_1.Test.createTestingModule({
             providers: [
                 admin_service_1.AdminService,
@@ -53,6 +56,10 @@ describe('AdminService', () => {
                     provide: FIREBASE_ADMIN_INSTANCE_TOKEN,
                     useValue: mockOptions,
                 },
+                {
+                    provide: 'FIREBASE_ADMIN_APP',
+                    useValue: mockApp,
+                },
             ],
         }).compile();
         service = module.get(admin_service_1.AdminService);
@@ -61,11 +68,8 @@ describe('AdminService', () => {
         expect(service).toBeDefined();
     });
     describe('constructor', () => {
-        it('must initialize the Firebase Admin SDK with the provided options', () => {
-            expect(firebaseAdmin.initializeApp).toHaveBeenCalledWith(Object.assign(Object.assign({}, mockOptions), { credential: 'mocked-credential' }));
-        });
-        it('must pass the correct credentials to the cert method', () => {
-            expect(firebaseAdmin.credential.cert).toHaveBeenCalledWith(mockOptions.credential);
+        it('must store the injected Firebase Admin app', () => {
+            expect(service.appRef).toEqual({ name: 'app-name', options: {} });
         });
     });
     describe('applicationDefault', () => {
@@ -142,7 +146,7 @@ describe('AdminService', () => {
                 observable.subscribe({
                     next: (app) => {
                         expect(app).toBeDefined();
-                        expect(app).toEqual(service.appRef);
+                        expect(app).toEqual({ name: 'app-name', options: {} });
                     },
                     complete: () => {
                         done();
@@ -176,31 +180,15 @@ describe('AdminService', () => {
         });
     });
     describe('appRef', () => {
-        it('should return the result of initializeApp', () => {
-            const mockApp = { name: 'initialized-app' };
-            firebaseAdmin.initializeApp.mockReturnValueOnce(mockApp);
+        it('should return the injected app instance', () => {
             const result = service.appRef;
-            expect(firebaseAdmin.initializeApp).toHaveBeenCalled();
-            expect(result).toEqual(mockApp);
+            expect(result).toEqual({ name: 'app-name', options: {} });
         });
     });
     describe('initializeApp', () => {
-        it('should call initializeApp from Admin SDK with correct options', () => {
-            firebaseAdmin.initializeApp.mockClear();
-            service.initializeApp();
-            expect(firebaseAdmin.initializeApp).toHaveBeenCalledWith(Object.assign(Object.assign({}, mockOptions), { credential: 'mocked-credential' }));
-        });
-        it('should return the initialized app instance', () => {
-            const mockApp = { name: 'new-app', options: {} };
-            firebaseAdmin.initializeApp.mockReturnValueOnce(mockApp);
+        it('should return the injected app instance', () => {
             const result = service.initializeApp();
-            expect(result).toEqual(mockApp);
-        });
-        it('must propagate initializeApp errors', () => {
-            firebaseAdmin.initializeApp.mockImplementationOnce(() => {
-                throw new Error('Initialization error');
-            });
-            expect(() => service.initializeApp()).toThrow('Initialization error');
+            expect(result).toEqual({ name: 'app-name', options: {} });
         });
     });
     describe('complex use cases', () => {
@@ -213,14 +201,10 @@ describe('AdminService', () => {
             expect(firebaseAdminApp.deleteApp).toHaveBeenCalledWith(mockApp);
         }));
         it('should return the same app when appRef is called multiple times in a row', () => {
-            const mockApp = { name: 'reused-app' };
-            firebaseAdmin.initializeApp.mockClear();
-            firebaseAdmin.initializeApp.mockReturnValue(mockApp);
-            const app1 = service.appRef;
-            const app2 = service.appRef;
-            expect(app1).toBe(mockApp);
-            expect(app2).toBe(mockApp);
-            expect(firebaseAdmin.initializeApp).toHaveBeenCalledTimes(2);
+            const firstCall = service.appRef;
+            const secondCall = service.appRef;
+            expect(firstCall).toBe(secondCall);
+            expect(firstCall).toEqual({ name: 'app-name', options: {} });
         });
         it('should be defined', () => {
             expect(service).toBeDefined();

package/dist/modules/admin/database.service.d.ts

@@ -1,6 +1,11 @@
+import type { AdminModuleOptions } from './types';
+import { App } from 'firebase-admin/app';
 export declare class DatabaseService {
+    protected readonly options: AdminModuleOptions;
+    private readonly firebaseApp;
+    private app;
     private database;
-    constructor();
+    constructor(options: AdminModuleOptions, firebaseApp: App);
     ref(path: string): import("@firebase/database-types").Reference;
     get<T>(path: string): Promise<T>;
     set<T>(path: string, data: T): Promise<void>;

package/dist/modules/admin/database.service.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -21,8 +24,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseService = void 0;
 const common_1 = require("@nestjs/common");
 const database_1 = require("firebase-admin/database");
+const admin_constants_1 = require("./admin.constants");
 let DatabaseService = class DatabaseService {
-    constructor() {
+    constructor(options, firebaseApp) {
+        this.options = options;
+        this.firebaseApp = firebaseApp;
+        this.app = firebaseApp;
         this.database = (0, database_1.getDatabase)();
     }
     ref(path) {
@@ -59,5 +66,7 @@ let DatabaseService = class DatabaseService {
 exports.DatabaseService = DatabaseService;
 exports.DatabaseService = DatabaseService = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [])
+    __param(0, (0, common_1.Inject)(admin_constants_1.FIREBASE_ADMIN_INSTANCE_TOKEN)),
+    __param(1, (0, common_1.Inject)('FIREBASE_ADMIN_APP')),
+    __metadata("design:paramtypes", [Object, Object])
 ], DatabaseService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-firebase-admin",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Firebase Admin SDK for Nestjs",
   "author": "Hebert Cisco",
   "license": "MIT",
@@ -8,6 +8,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
+    "start:debug": "nest start --debug --watch",
     "build": "npx tsc",
     "prebuild": "rimraf dist",
     "format": "npx prettier --write \"{lib,test}/**/*.ts\"",