nestjs-firebase-admin 0.2.3 → 0.3.4

package/.nvmrc

@@ -1 +1 @@
-lts/hydrogen
+lts/jod

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Hebert F Barros
+Copyright (c) 2025 Hebert F Barros
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -11,11 +11,17 @@
 [![Free. Built on open source. Runs everywhere.](https://img.shields.io/badge/VS_Code-0078D4?style=flat&logo=visual%20studio%20code&logoColor=white)](https://code.visualstudio.com/)
 [![GitHub Actions](https://img.shields.io/badge/github%20actions-%232671E5.svg?style=flat&logo=githubactions&logoColor=white)](https://github.com/hebertcisco/nestjs-firebase-admin/actions)
 
-> Firebase Admin SDK for Nestjs :fire:
+> Firebase Admin SDK for NestJS :fire:
+
+## Requirements
+
+- **Node.js**: >= 20
+- **NPM**: >= 10
+- **NestJS**: >= 7.0.0
 
 ## Installation
 
-> Install with yarn or npm: `yarn` or `npm`:
+Install the package using `yarn`, `npm`, or `pnpm`:
 
 ```bash
 # yarn
@@ -32,17 +38,15 @@ npm i nestjs-firebase-admin --save
 pnpm add nestjs-firebase-admin --save
 ```
 
-### Usage example
+## Usage Example
+
+Here is an example of how to configure the `AdminModule` in NestJS:
 
 ```ts
 // common.module.ts
 import { Module } from '@nestjs/common';
-
-import { TypeOrmModule } from '@nestjs/typeorm';
 import { AdminModule } from 'nestjs-firebase-admin';
 
-import { CommonService } from './common.service';
-
 @Module({
   imports: [
     AdminModule.register({
@@ -54,20 +58,147 @@ import { CommonService } from './common.service';
       databaseURL: 'https://my-project-id.firebaseio.com',
     }),
   ],
-  providers: [CommonService],
 })
 export class CommonModule {}
 ```
 
-## 🤝 Contributing
+### Asynchronous Registration
+
+If you need asynchronous configuration, use the `registerAsync` method:
+
+```ts
+import { Module } from '@nestjs/common';
+import { AdminModule } from 'nestjs-firebase-admin';
+
+@Module({
+  imports: [
+    AdminModule.registerAsync({
+      useFactory: async () => ({
+        credential: {
+          projectId: 'my-project-id',
+          clientEmail: 'my-client-email',
+          privateKey: 'my-private-key',
+        },
+        databaseURL: 'https://my-project-id.firebaseio.com',
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## DatabaseService
+
+The `DatabaseService` provides a clean and type-safe interface for interacting with the Firebase Realtime Database. This service is automatically injected when you import the `AdminModule`.
+
+### Features
+
+- Full CRUD operations (Create, Read, Update, Delete)
+- TypeScript type support
+- Asynchronous methods with Promises
+- Database reference handling
+- List operations with unique keys
+
+### Usage Example
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from 'nestjs-firebase-admin';
+
+@Injectable()
+export class UsersService {
+  constructor(private readonly databaseService: DatabaseService) {}
+
+  // Get data from a path
+  async getUser(userId: string) {
+    return this.databaseService.get<User>(`users/${userId}`);
+  }
+
+  // Set data at a path
+  async createUser(userId: string, userData: User) {
+    await this.databaseService.set(`users/${userId}`, userData);
+  }
+
+  // Update specific fields
+  async updateUser(userId: string, updates: Partial<User>) {
+    await this.databaseService.update(`users/${userId}`, updates);
+  }
+
+  // Remove data
+  async deleteUser(userId: string) {
+    await this.databaseService.remove(`users/${userId}`);
+  }
+
+  // Add to a list
+  async addUser(userData: User) {
+    const newKey = await this.databaseService.push('users', userData);
+    return newKey;
+  }
+
+  // Get a database reference
+  async getUsersRef() {
+    return this.databaseService.ref('users');
+  }
+}
+```
+
+### Available Methods
+
+| Method | Description | Documentation |
+|--------|-------------|---------------|
+| `ref(path)` | Gets a reference to a specific path | [Firebase Ref](https://firebase.google.com/docs/database/admin/retrieve-data#section-queries) |
+| `get<T>(path)` | Retrieves data from a specific path | [Read Data](https://firebase.google.com/docs/database/admin/retrieve-data#section-read-once) |
+| `set<T>(path, data)` | Sets data at a specific path | [Set Data](https://firebase.google.com/docs/database/admin/save-data#section-set) |
+| `update<T>(path, data)` | Updates specific fields at a path | [Update Data](https://firebase.google.com/docs/database/admin/save-data#section-update) |
+| `remove(path)` | Removes data from a specific path | [Delete Data](https://firebase.google.com/docs/database/admin/save-data#section-delete) |
+| `push<T>(path, data)` | Adds data to a list | [Push Data](https://firebase.google.com/docs/database/admin/save-data#section-push) |
+
+## Testing
+
+To run tests, use the following commands:
+
+### Unit Tests
+
+```bash
+npm test
+```
+
+### Coverage Tests
+
+```bash
+npm run test:cov
+```
+
+### Watch Mode Tests
+
+```bash
+npm run test:watch
+```
+
+### Debug Tests
+
+```bash
+npm run test:debug
+```
+
+## Available Scripts
+
+The available scripts in `package.json` include:
+
+- **Build**: `npm run build`
+- **Lint**: `npm run lint`
+- **Format**: `npm run format`
+- **Release**: `npm run release`
+
+## Contributing
 
-Contributions, issues and feature requests are welcome!<br />Feel free to check [issues page](issues).
+Contributions, issues, and feature requests are welcome!<br />Feel free to check the [issues page](https://github.com/hebertcisco/nestjs-firebase-admin/issues).
 
-## Show your support
+## Show Your Support
 
 Give a ⭐️ if this project helped you!
 
-Or buy me a coffee 🙌🏾
+Or buy the author a coffee 🙌🏾
 
 <a href="https://www.buymeacoffee.com/hebertcisco">
     <img src="https://img.buymeacoffee.com/button-api/?text=Buy me a coffee&emoji=&slug=hebertcisco&button_colour=FFDD00&font_colour=000000&font_family=Inter&outline_colour=000000&coffee_colour=ffffff" />
@@ -75,5 +206,4 @@ Or buy me a coffee 🙌🏾
 
 ## 📝 License
 
-Copyright © 2024 [Hebert F Barros](https://github.com/hebertcisco).<br />
-This project is [MIT](LICENSE) licensed.
+This project is under the [MIT](LICENSE) license.

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

@@ -21,6 +21,7 @@ const common_1 = require("@nestjs/common");
 const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
 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) {
         return {
@@ -89,7 +90,7 @@ let AdminModule = AdminModule_1 = class AdminModule {
 exports.AdminModule = AdminModule;
 exports.AdminModule = AdminModule = AdminModule_1 = __decorate([
     (0, common_1.Module)({
-        providers: [admin_service_1.AdminService],
-        exports: [admin_service_1.AdminService],
+        providers: [admin_service_1.AdminService, database_service_1.DatabaseService],
+        exports: [admin_service_1.AdminService, database_service_1.DatabaseService],
     })
 ], AdminModule);

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Observable } from 'rxjs';
 import Admin from 'firebase-admin';
 import type { App } from 'firebase-admin/app';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,244 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const admin_service_1 = require("./admin.service");
+const node_http_1 = require("node:http");
+const rxjs_1 = require("rxjs");
+const FIREBASE_ADMIN_INSTANCE_TOKEN = 'FIREBASE_ADMIN_INSTANCE_TOKEN';
+jest.mock('firebase-admin/app', () => {
+    return {
+        getApp: jest.fn().mockReturnValue({ name: 'app-name', options: {} }),
+        getApps: jest.fn().mockReturnValue([{ name: 'app-name', options: {} }]),
+        deleteApp: jest.fn().mockResolvedValue(undefined),
+        applicationDefault: jest.fn().mockReturnValue('default-credential'),
+    };
+});
+jest.mock('firebase-admin', () => {
+    return {
+        initializeApp: jest.fn().mockReturnValue({ name: 'app-name', options: {} }),
+        credential: {
+            cert: jest.fn().mockReturnValue('mocked-credential'),
+        },
+    };
+});
+const firebaseAdmin = jest.requireMock('firebase-admin');
+const firebaseAdminApp = jest.requireMock('firebase-admin/app');
+describe('AdminService', () => {
+    let service;
+    const mockOptions = {
+        credential: {
+            projectId: 'mock-project',
+            clientEmail: 'mock@example.com',
+            privateKey: 'mock-key',
+        },
+        databaseURL: 'https://mock-project.firebaseio.com',
+        storageBucket: 'mock-project.appspot.com',
+        projectId: 'mock-project',
+    };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        jest.clearAllMocks();
+        const module = yield testing_1.Test.createTestingModule({
+            providers: [
+                admin_service_1.AdminService,
+                {
+                    provide: FIREBASE_ADMIN_INSTANCE_TOKEN,
+                    useValue: mockOptions,
+                },
+            ],
+        }).compile();
+        service = module.get(admin_service_1.AdminService);
+    }));
+    it('must be defined', () => {
+        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);
+        });
+    });
+    describe('applicationDefault', () => {
+        it('should return default credentials with no arguments', () => {
+            const result = service.applicationDefault();
+            expect(firebaseAdminApp.applicationDefault).toHaveBeenCalledWith(undefined);
+            expect(result).toBe('default-credential');
+        });
+        it('must pass HTTP agent when provided', () => {
+            const httpAgent = new node_http_1.Agent();
+            const result = service.applicationDefault(httpAgent);
+            expect(firebaseAdminApp.applicationDefault).toHaveBeenCalledWith(httpAgent);
+            expect(result).toBe('default-credential');
+        });
+    });
+    describe('deleteApp', () => {
+        it('should call deleteApp function with the given app', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockApp = { name: 'app-to-delete' };
+            yield service.deleteApp(mockApp);
+            expect(firebaseAdminApp.deleteApp).toHaveBeenCalledWith(mockApp);
+        }));
+        it('should return a resolved promise', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockApp = { name: 'app-to-delete' };
+            yield expect(service.deleteApp(mockApp)).resolves.toBeUndefined();
+        }));
+        it('should propagate errors from deleteApp', () => __awaiter(void 0, void 0, void 0, function* () {
+            firebaseAdminApp.deleteApp.mockRejectedValueOnce(new Error('Delete error'));
+            const mockApp = { name: 'app-with-error' };
+            yield expect(service.deleteApp(mockApp)).rejects.toThrow('Delete error');
+        }));
+    });
+    describe('getApps', () => {
+        it('should return all initialized apps', () => {
+            const mockApps = [{ name: 'app1' }, { name: 'app2' }];
+            firebaseAdminApp.getApps.mockReturnValueOnce(mockApps);
+            const result = service.getApps;
+            expect(firebaseAdminApp.getApps).toHaveBeenCalled();
+            expect(result).toEqual(mockApps);
+        });
+        it('should return an empty array when there are no apps', () => {
+            firebaseAdminApp.getApps.mockReturnValueOnce([]);
+            const result = service.getApps;
+            expect(result).toEqual([]);
+        });
+    });
+    describe('getApp', () => {
+        it('should return the default app', () => {
+            const mockApp = { name: 'default-app' };
+            firebaseAdminApp.getApp.mockReturnValueOnce(mockApp);
+            const result = service.getApp;
+            expect(firebaseAdminApp.getApp).toHaveBeenCalled();
+            expect(result).toEqual(mockApp);
+        });
+        it('must propagate getApp errors', () => {
+            firebaseAdminApp.getApp.mockImplementationOnce(() => {
+                throw new Error('App not found');
+            });
+            expect(() => service.getApp).toThrow('App not found');
+        });
+    });
+    describe('admin', () => {
+        it('should return Firebase Admin SDK instance', () => {
+            const adminModule = service.admin();
+            expect(adminModule).toBeDefined();
+            expect(adminModule.initializeApp).toBe(firebaseAdmin.initializeApp);
+            expect(adminModule.credential.cert).toBe(firebaseAdmin.credential.cert);
+        });
+    });
+    describe('initializeAppObservable', () => {
+        it('must return an Observable with the app instance', () => {
+            return new Promise(done => {
+                const observable = service.initializeAppObservable();
+                expect(observable).toBeInstanceOf(rxjs_1.Observable);
+                observable.subscribe({
+                    next: (app) => {
+                        expect(app).toBeDefined();
+                        expect(app).toEqual(service.appRef);
+                    },
+                    complete: () => {
+                        done();
+                    },
+                    error: (_err) => {
+                        done();
+                    },
+                });
+            });
+        });
+        it('must complete the Observable after issuing the app', () => {
+            return new Promise(done => {
+                const completeSpy = jest.fn();
+                service.initializeAppObservable().subscribe({
+                    next: () => { },
+                    complete: () => {
+                        completeSpy();
+                        expect(completeSpy).toHaveBeenCalledTimes(1);
+                        done();
+                    },
+                    error: (_err) => {
+                        done();
+                    },
+                });
+            });
+        });
+        it('must return a valid cleanup function when unsubscribing', () => {
+            const observable = service.initializeAppObservable();
+            const subscription = observable.subscribe(() => { });
+            expect(() => subscription.unsubscribe()).not.toThrow();
+        });
+    });
+    describe('appRef', () => {
+        it('should return the result of initializeApp', () => {
+            const mockApp = { name: 'initialized-app' };
+            firebaseAdmin.initializeApp.mockReturnValueOnce(mockApp);
+            const result = service.appRef;
+            expect(firebaseAdmin.initializeApp).toHaveBeenCalled();
+            expect(result).toEqual(mockApp);
+        });
+    });
+    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);
+            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');
+        });
+    });
+    describe('complex use cases', () => {
+        it('should allow you to get an app and then delete it', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockApp = { name: 'app-to-manage' };
+            firebaseAdminApp.getApp.mockReturnValueOnce(mockApp);
+            const app = service.getApp;
+            yield service.deleteApp(app);
+            expect(firebaseAdminApp.getApp).toHaveBeenCalled();
+            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);
+        });
+        it('should be defined', () => {
+            expect(service).toBeDefined();
+        });
+        it('should return an array of apps', () => {
+            expect(service.getApps).toBeInstanceOf(Array);
+        });
+        it('should return an app', () => {
+            expect(service.getApp).toBeInstanceOf(Object);
+        });
+        it('should return an app reference', () => {
+            expect(service.appRef).toBeInstanceOf(Object);
+        });
+        it('should return an observable of an app', () => {
+            expect(service.initializeAppObservable()).toBeInstanceOf(Object);
+        });
+        it('should return a credential', () => {
+            expect(service.applicationDefault()).toBe('default-credential');
+        });
+    });
+});

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

@@ -0,0 +1,10 @@
+export declare class DatabaseService {
+    private database;
+    constructor();
+    ref(path: string): import("@firebase/database-types").Reference;
+    get<T>(path: string): Promise<T>;
+    set<T>(path: string, data: T): Promise<void>;
+    update<T>(path: string, data: Partial<T>): Promise<void>;
+    remove(path: string): Promise<void>;
+    push<T>(path: string, data: T): Promise<string>;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+const common_1 = require("@nestjs/common");
+const database_1 = require("firebase-admin/database");
+let DatabaseService = class DatabaseService {
+    constructor() {
+        this.database = (0, database_1.getDatabase)();
+    }
+    ref(path) {
+        return this.database.ref(path);
+    }
+    get(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield this.database.ref(path).get();
+            return snapshot.val();
+        });
+    }
+    set(path, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.database.ref(path).set(data);
+        });
+    }
+    update(path, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.database.ref(path).update(data);
+        });
+    }
+    remove(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.database.ref(path).remove();
+        });
+    }
+    push(path, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ref = yield this.database.ref(path).push(data);
+            return ref.key || '';
+        });
+    }
+};
+exports.DatabaseService = DatabaseService;
+exports.DatabaseService = DatabaseService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], DatabaseService);

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,235 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const database_service_1 = require("./database.service");
+const DatabaseService_mock_1 = require("../../tests/mocks/DatabaseService.mock");
+describe('DatabaseService', () => {
+    let service;
+    let mockService;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        const module = yield testing_1.Test.createTestingModule({
+            providers: [
+                {
+                    provide: database_service_1.DatabaseService,
+                    useClass: DatabaseService_mock_1.DatabaseServiceMock,
+                },
+            ],
+        }).compile();
+        service = module.get(database_service_1.DatabaseService);
+        mockService = service;
+    }));
+    afterEach(() => {
+        if (mockService.resetMocks) {
+            mockService.resetMocks();
+        }
+    });
+    it('should be defined', () => {
+        expect(service).toBeDefined();
+    });
+    describe('ref', () => {
+        it('should return a database reference', () => {
+            const ref = service.ref('test-path');
+            expect(ref).toBeDefined();
+            expect(ref.get).toBeDefined();
+            expect(ref.set).toBeDefined();
+            expect(ref.update).toBeDefined();
+            expect(ref.remove).toBeDefined();
+            expect(ref.push).toBeDefined();
+        });
+        it('should handle different path formats', () => {
+            const ref1 = service.ref('users/123/profile');
+            expect(ref1).toBeDefined();
+            const ref2 = service.ref('');
+            expect(ref2).toBeDefined();
+            const ref3 = service.ref('users/user.name@example.com');
+            expect(ref3).toBeDefined();
+        });
+    });
+    describe('get', () => {
+        it('should get data from a path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const data = yield service.get('test-path');
+            expect(data).toBe('mock-data');
+        }));
+        it('should handle non-existent paths', () => __awaiter(void 0, void 0, void 0, function* () {
+            const data = yield service.get('non-existent-path');
+            expect(data).toBe('mock-data');
+        }));
+        it('should handle error during data retrieval', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('error-path');
+            mockRef.get = jest.fn().mockRejectedValue(new Error('Database error'));
+            yield expect(service.get('error-path')).rejects.toThrow('Database error');
+        }));
+        it('should call get method with correct path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const path = 'test/specific/path';
+            const spyRef = jest.spyOn(service, 'ref');
+            yield service.get(path);
+            expect(spyRef).toHaveBeenCalledWith(path);
+        }));
+        it('should handle null value response', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('null-path');
+            mockRef.get = jest.fn().mockResolvedValue({ val: () => null });
+            const result = yield service.get('null-path');
+            expect(result).toBeNull();
+        }));
+    });
+    describe('set', () => {
+        it('should set data at a path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { name: 'test' };
+            yield expect(service.set('test-path', testData)).resolves.not.toThrow();
+        }));
+        it('should handle complex data structures', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = {
+                name: 'test',
+                nested: {
+                    field: 'value',
+                    array: [1, 2, 3],
+                },
+            };
+            yield expect(service.set('test-path', testData)).resolves.not.toThrow();
+        }));
+        it('should handle error during set operation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('error-path');
+            mockRef.set = jest.fn().mockRejectedValue(new Error('Permission denied'));
+            yield expect(service.set('error-path', { test: 'data' })).rejects.toThrow('Permission denied');
+        }));
+        it('should call set method with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const path = 'users/123';
+            const data = { name: 'John Doe', age: 30 };
+            const refSpy = jest.spyOn(service, 'ref');
+            const setSpy = jest.spyOn(service.ref(path), 'set');
+            yield service.set(path, data);
+            expect(refSpy).toHaveBeenCalledWith(path);
+            expect(setSpy).toHaveBeenCalledWith(data);
+        }));
+        it('should set primitive data types', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(service.set('string-path', 'test-string')).resolves.not.toThrow();
+            yield expect(service.set('number-path', 42)).resolves.not.toThrow();
+            yield expect(service.set('bool-path', true)).resolves.not.toThrow();
+            yield expect(service.set('null-path', null)).resolves.not.toThrow();
+        }));
+    });
+    describe('update', () => {
+        it('should update data at a path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { name: 'updated' };
+            yield expect(service.update('test-path', testData)).resolves.not.toThrow();
+        }));
+        it('should handle partial updates', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { 'nested.field': 'new-value' };
+            yield expect(service.update('test-path', testData)).resolves.not.toThrow();
+        }));
+        it('should handle error during update operation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('error-path');
+            mockRef.update = jest.fn().mockRejectedValue(new Error('Update failed'));
+            yield expect(service.update('error-path', { name: 'test' })).rejects.toThrow('Update failed');
+        }));
+        it('should call update method with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const path = 'users/profile';
+            const data = { lastActive: Date.now(), status: 'online' };
+            const refSpy = jest.spyOn(service, 'ref');
+            const updateSpy = jest.spyOn(service.ref(path), 'update');
+            yield service.update(path, data);
+            expect(refSpy).toHaveBeenCalledWith(path);
+            expect(updateSpy).toHaveBeenCalledWith(data);
+        }));
+        it('should update with empty object', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(service.update('test-path', {})).resolves.not.toThrow();
+        }));
+    });
+    describe('remove', () => {
+        it('should remove data at a path', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(service.remove('test-path')).resolves.not.toThrow();
+        }));
+        it('should handle non-existent paths', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(service.remove('non-existent-path')).resolves.not.toThrow();
+        }));
+        it('should handle error during remove operation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('error-path');
+            mockRef.remove = jest.fn().mockRejectedValue(new Error('Delete failed'));
+            yield expect(service.remove('error-path')).rejects.toThrow('Delete failed');
+        }));
+        it('should call remove method with correct path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const path = 'users/123/sessions';
+            const refSpy = jest.spyOn(service, 'ref');
+            const removeSpy = jest.spyOn(service.ref(path), 'remove');
+            yield service.remove(path);
+            expect(refSpy).toHaveBeenCalledWith(path);
+            expect(removeSpy).toHaveBeenCalled();
+        }));
+    });
+    describe('push', () => {
+        it('should push data to a path and return a key', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { name: 'new-item' };
+            const key = yield service.push('test-path', testData);
+            expect(key).toBe('mock-key');
+        }));
+        it('should handle empty key case', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('test-path');
+            mockRef.push = jest.fn().mockResolvedValue({ key: null });
+            const testData = { name: 'new-item' };
+            const key = yield service.push('test-path', testData);
+            expect(key).toBe('');
+        }));
+        it('should handle error during push operation', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockRef = service.ref('error-path');
+            mockRef.push = jest.fn().mockRejectedValue(new Error('Push failed'));
+            yield expect(service.push('error-path', { name: 'test' })).rejects.toThrow('Push failed');
+        }));
+        it('should call push method with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const path = 'messages';
+            const data = { text: 'Hello world', timestamp: Date.now() };
+            const refSpy = jest.spyOn(service, 'ref');
+            const pushSpy = jest.spyOn(service.ref(path), 'push');
+            yield service.push(path, data);
+            expect(refSpy).toHaveBeenCalledWith(path);
+            expect(pushSpy).toHaveBeenCalledWith(data);
+        }));
+        it('should push different data types', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(service.push('list/objects', { id: 1 })).resolves.toBe('mock-key');
+            yield expect(service.push('list/arrays', [1, 2, 3])).resolves.toBe('mock-key');
+            yield expect(service.push('list/strings', 'test string')).resolves.toBe('mock-key');
+            yield expect(service.push('list/numbers', 42)).resolves.toBe('mock-key');
+        }));
+    });
+    describe('combined operations', () => {
+        it('should perform get and update operations sequentially', () => __awaiter(void 0, void 0, void 0, function* () {
+            const path = 'users/profile';
+            const getSpy = jest.spyOn(service, 'get');
+            const updateSpy = jest.spyOn(service, 'update');
+            const data = yield service.get(path);
+            yield service.update(path, { lastAccess: Date.now() });
+            expect(getSpy).toHaveBeenCalledWith(path);
+            expect(updateSpy).toHaveBeenCalled();
+        }));
+        it('should perform push and then get the pushed data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const basePath = 'posts';
+            const postData = { title: 'Test Post', content: 'Content' };
+            const key = yield service.push(basePath, postData);
+            expect(key).toBe('mock-key');
+            const path = `${basePath}/${key}`;
+            const getSpy = jest.spyOn(service, 'get');
+            yield service.get(path);
+            expect(getSpy).toHaveBeenCalledWith(path);
+        }));
+        it('should handle transaction-like operations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const itemPath = 'items/123';
+            const itemData = { name: 'Updated Item', updated: true };
+            const refPath = 'users/456/items/123';
+            const refData = { updated: true, timestamp: Date.now() };
+            const setSpy = jest.spyOn(service, 'set');
+            const updateSpy = jest.spyOn(service, 'update');
+            yield service.set(itemPath, itemData);
+            yield service.update(refPath, refData);
+            expect(setSpy).toHaveBeenCalledWith(itemPath, itemData);
+            expect(updateSpy).toHaveBeenCalledWith(refPath, refData);
+        }));
+    });
+});

package/dist/modules/admin/interfaces/admin-module.interface.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/admin/interfaces/admin-module.interface.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('AdminModuleOptionsFactory', () => {
+    it('should define a method to create admin options', () => {
+        class TestFactory {
+            createAdminOptions() {
+                return { credential: { projectId: 'test' } };
+            }
+        }
+        const factory = new TestFactory();
+        expect(factory.createAdminOptions()).toEqual({
+            credential: { projectId: 'test' },
+        });
+    });
+});
+describe('AdminModuleAsyncOptions', () => {
+    it('should allow useExisting, useClass, or useFactory for async options', () => {
+        const asyncOptions = {
+            useFactory: () => __awaiter(void 0, void 0, void 0, function* () { return ({ credential: { projectId: 'test' } }); }),
+            inject: [],
+        };
+        expect(asyncOptions.useFactory).toBeDefined();
+        expect(asyncOptions.inject).toEqual([]);
+    });
+    it('should support extraProviders', () => {
+        const extraProvider = { provide: 'TEST', useValue: 'value' };
+        const asyncOptions = {
+            useFactory: () => __awaiter(void 0, void 0, void 0, function* () { return ({ credential: { projectId: 'test' } }); }),
+            inject: [],
+            extraProviders: [extraProvider],
+        };
+        expect(asyncOptions.extraProviders).toContain(extraProvider);
+    });
+});

package/dist/modules/admin/types/admin.type.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { Agent } from 'node:http';
 import type { ServiceAccount } from 'firebase-admin/app';
 export type AdminConfig = {

package/dist/modules/admin/types/admin.type.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/admin/types/admin.type.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('Admin Types', () => {
+    it('should define AdminConfig with required and optional properties', () => {
+        const config = {
+            credential: {
+                projectId: 'test-project',
+                clientEmail: 'test@example.com',
+                privateKey: 'test-key',
+            },
+            databaseURL: 'https://test.firebaseio.com',
+            storageBucket: 'test-bucket',
+            projectId: 'test-project-id',
+            httpAgent: undefined,
+        };
+        expect(config.credential.projectId).toBe('test-project');
+        expect(config.databaseURL).toBe('https://test.firebaseio.com');
+        expect(config.storageBucket).toBe('test-bucket');
+        expect(config.projectId).toBe('test-project-id');
+        expect(config.httpAgent).toBeUndefined();
+    });
+    it('should define AdminModuleOptions as an alias for AdminConfig', () => {
+        const options = {
+            credential: {
+                projectId: 'test-project',
+                clientEmail: 'test@example.com',
+                privateKey: 'test-key',
+            },
+        };
+        expect(options.credential.projectId).toBe('test-project');
+        expect(options.credential.clientEmail).toBe('test@example.com');
+        expect(options.credential.privateKey).toBe('test-key');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-firebase-admin",
-  "version": "0.2.3",
+  "version": "0.3.4",
   "description": "Firebase Admin SDK for Nestjs",
   "author": "Hebert Cisco",
   "license": "MIT",
@@ -30,55 +30,45 @@
     "postversion": "git push && git push --tags"
   },
   "dependencies": {
-    "@nestjs/common": "10.2.8",
-    "@nestjs/core": "10.4.3",
-    "@nestjs/platform-express": "10.4.5",
-    "firebase-admin": "12.0.0",
-    "nest-shared": "^5.0.3"
+    "@nestjs/common": "10.4.17",
+    "@nestjs/core": "10.4.13",
+    "@nestjs/platform-express": "10.4.13",
+    "firebase-admin": "12.7.0",
+    "nest-shared": "^5.0.6"
   },
   "engines": {
-    "node": ">=16",
-    "npm": ">=8"
+    "node": ">=20",
+    "npm": ">=10"
   },
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "cpu": [
-    "x64",
-    "arm",
-    "!mips"
-  ],
   "devDependencies": {
-    "@commitlint/cli": "18.2.0",
-    "@commitlint/config-angular": "18.1.0",
-    "@nestjs/testing": "10.2.8",
-    "@types/jest": "29.5.7",
-    "@types/node": "20.8.10",
-    "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^6.4.1",
-    "@typescript-eslint/parser": "^6.4.1",
-    "eslint": "8.52.0",
-    "eslint-config-prettier": "9.0.0",
-    "eslint-plugin-import": "2.29.0",
-    "eslint-plugin-jest": "^27.2.3",
-    "eslint-plugin-prettier": "^5.0.0",
+    "@commitlint/cli": "18.6.1",
+    "@commitlint/config-angular": "18.6.1",
+    "@nestjs/testing": "10.4.13",
+    "@types/jest": "29.5.14",
+    "@types/node": "20.17.9",
+    "@types/supertest": "^2.0.16",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "8.57.1",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.31.0",
+    "eslint-plugin-jest": "^27.9.0",
+    "eslint-plugin-prettier": "^5.2.1",
     "husky": "8.0.3",
     "jest": "29.7.0",
-    "lint-staged": "15.0.2",
-    "prettier": "^3.0.2",
-    "reflect-metadata": "0.1.13",
-    "release-it": "16.2.1",
-    "rimraf": "5.0.5",
+    "lint-staged": "15.2.10",
+    "prettier": "^3.4.2",
+    "reflect-metadata": "0.2.2",
+    "release-it": "16.3.0",
+    "rimraf": "5.0.10",
     "rxjs": "7.8.1",
-    "supertest": "^6.3.3",
-    "ts-jest": "29.1.1",
-    "typescript": "5.2.2"
+    "supertest": "^7.1.0",
+    "ts-jest": "29.2.5",
+    "typescript": "5.7.2"
   },
   "peerDependencies": {
     "@nestjs/common": "^7.0.0 || ^8.0.0 || ^9.2.1 || ^10.2.1",
-    "reflect-metadata": "^0.1.12",
+    "reflect-metadata": "^0.2.2",
     "rxjs": "^6.0.0 || ^7.0.0"
   },
   "lint-staged": {