@quatrain/auth-firebase 1.1.16 → 1.1.17

package/dist/FirebaseAuthAdapter.d.ts

@@ -0,0 +1,20 @@
+import { User } from '@quatrain/backend';
+import { AbstractAuthAdapter, AuthParameters } from '@quatrain/auth';
+import { UpdateRequest } from 'firebase-admin/auth';
+export declare class FirebaseAuthAdapter extends AbstractAuthAdapter {
+    constructor(params?: AuthParameters);
+    /**
+     * Register new user in authentication
+     * @param user
+     * @returns user unique id
+     */
+    register(user: User, clearPassword?: string): Promise<string>;
+    getAuthToken(bearer: string): Promise<import("firebase-admin/auth").DecodedIdToken>;
+    signup(login: string, password: string): Promise<void>;
+    signout(user: User): Promise<any>;
+    update(user: User, updatable: UpdateRequest): Promise<any>;
+    delete(user: User): Promise<any>;
+    revokeAuthToken(token: string): Promise<void>;
+    setCustomUserClaims(id: string, claims: any): Promise<void>;
+    refreshToken(refreshToken: string): Promise<any>;
+}

package/dist/FirebaseAuthAdapter.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.FirebaseAuthAdapter = void 0;
+const auth_1 = require("@quatrain/auth");
+const auth_2 = require("firebase-admin/auth");
+const app_1 = require("firebase-admin/app");
+const nativeFetch = __importStar(require("node-fetch-native"));
+class FirebaseAuthAdapter extends auth_1.AbstractAuthAdapter {
+    constructor(params = {}) {
+        super(params);
+        if ((0, app_1.getApps)().length === 0) {
+            (0, app_1.initializeApp)(params.config);
+        }
+    }
+    /**
+     * Register new user in authentication
+     * @param user
+     * @returns user unique id
+     */
+    register(user, clearPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { name: displayName, email, phone: phoneNumber, password, disabled = false, } = user._;
+                const authData = {
+                    uid: user.uid,
+                    email,
+                    phoneNumber,
+                    password: clearPassword || password,
+                    disabled,
+                    displayName,
+                };
+                auth_1.Auth.log(`[FAA] Adding user '${displayName}'`);
+                const userRecord = yield (0, auth_2.getAuth)().createUser(authData);
+                return userRecord.uid;
+            }
+            catch (err) {
+                throw new auth_1.AuthenticationError(err.message);
+            }
+        });
+    }
+    getAuthToken(bearer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, auth_2.getAuth)().verifyIdToken(bearer);
+        });
+    }
+    signup(login, password) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    signout(user) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    update(user, updatable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            auth_1.Auth.log('auth data to update', JSON.stringify(updatable));
+            try {
+                if (Object.keys(updatable).length > 0) {
+                    auth_1.Auth.log(`Updating ${updatable.displayName} Auth record`);
+                    yield (0, auth_2.getAuth)().updateUser(user.uid, updatable);
+                }
+            }
+            catch (e) { }
+        });
+    }
+    delete(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, auth_2.getAuth)().deleteUser(user.uid);
+        });
+    }
+    revokeAuthToken(token) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    setCustomUserClaims(id, claims) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    refreshToken(refreshToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._params.config.apiKey) {
+                auth_1.Auth.warn(`Can't get refresh token, no API key provided`);
+                return {};
+            }
+            const response = yield nativeFetch.fetch(`https://securetoken.googleapis.com/v1/token?key=${this._params.config.apiKey}`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: refreshToken,
+                }),
+                headers: { 'Content-Type': 'application/json' }, //, crossdomain: true },
+            });
+            const data = response.json();
+            return data;
+        });
+    }
+}
+exports.FirebaseAuthAdapter = FirebaseAuthAdapter;

package/dist/FirebaseAuthAdapter.test.d.ts

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

package/dist/FirebaseAuthAdapter.test.js

@@ -0,0 +1,303 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 FirebaseAuthAdapter_1 = require("./FirebaseAuthAdapter");
+const auth_1 = require("@quatrain/auth");
+const auth_2 = require("firebase-admin/auth");
+const app_1 = require("firebase-admin/app");
+const nativeFetch = __importStar(require("node-fetch-native"));
+// Mock the dependencies
+jest.mock('firebase-admin/auth');
+jest.mock('firebase-admin/app');
+jest.mock('node-fetch-native');
+describe('FirebaseAuthAdapter', () => {
+    let adapter;
+    let mockAuth;
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+        // Mock Firebase Admin SDK
+        mockAuth = {
+            createUser: jest.fn(),
+            verifyIdToken: jest.fn(),
+            updateUser: jest.fn(),
+            deleteUser: jest.fn(),
+        };
+        auth_2.getAuth.mockReturnValue(mockAuth);
+        app_1.getApps.mockReturnValue([]);
+        // Create adapter instance
+        adapter = new FirebaseAuthAdapter_1.FirebaseAuthAdapter({
+            config: {
+                projectId: 'test-project',
+                apiKey: 'test-api-key',
+            },
+        });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('Constructor', () => {
+        it('should initialize Firebase app when no apps exist', () => {
+            expect(app_1.getApps).toHaveBeenCalled();
+            expect(app_1.initializeApp).toHaveBeenCalledWith({
+                projectId: 'test-project',
+                apiKey: 'test-api-key',
+            });
+        });
+        it('should not initialize Firebase app when app already exists', () => {
+            ;
+            app_1.getApps.mockReturnValue([{ name: 'existing-app' }]);
+            new FirebaseAuthAdapter_1.FirebaseAuthAdapter({
+                config: {
+                    projectId: 'test-project',
+                },
+            });
+            // initializeApp should still be called once from the first adapter creation
+            expect(app_1.initializeApp).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('register()', () => {
+        const mockUser = {
+            uid: 'user-123',
+            _: {
+                name: 'John Doe',
+                email: 'john@example.com',
+                phone: '+1234567890',
+                password: 'hashed-password',
+                disabled: false,
+            },
+        };
+        it('should successfully register a new user', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockUserRecord = {
+                uid: 'user-123',
+                email: 'john@example.com',
+            };
+            mockAuth.createUser.mockResolvedValue(mockUserRecord);
+            const result = yield adapter.register(mockUser, 'clearPassword123');
+            expect(mockAuth.createUser).toHaveBeenCalledWith({
+                uid: 'user-123',
+                email: 'john@example.com',
+                phoneNumber: '+1234567890',
+                password: 'clearPassword123',
+                disabled: false,
+                displayName: 'John Doe',
+            });
+            expect(result).toBe('user-123');
+        }));
+        it('should use hashed password when clearPassword is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockUserRecord = {
+                uid: 'user-123',
+                email: 'john@example.com',
+            };
+            mockAuth.createUser.mockResolvedValue(mockUserRecord);
+            yield adapter.register(mockUser);
+            expect(mockAuth.createUser).toHaveBeenCalledWith({
+                uid: 'user-123',
+                email: 'john@example.com',
+                phoneNumber: '+1234567890',
+                password: 'hashed-password',
+                disabled: false,
+                displayName: 'John Doe',
+            });
+        }));
+        it('should handle user with default disabled value', () => __awaiter(void 0, void 0, void 0, function* () {
+            const userWithoutDisabled = {
+                uid: 'user-456',
+                _: {
+                    name: 'Jane Doe',
+                    email: 'jane@example.com',
+                    phone: '+0987654321',
+                    password: 'password456',
+                },
+            };
+            mockAuth.createUser.mockResolvedValue({ uid: 'user-456' });
+            yield adapter.register(userWithoutDisabled, 'password');
+            const createUserCall = mockAuth.createUser.mock.calls[0][0];
+            expect(createUserCall.disabled).toBe(false);
+        }));
+        it('should throw AuthenticationError on Firebase error', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockAuth.createUser.mockRejectedValue(new Error('Email already exists'));
+            yield expect(adapter.register(mockUser, 'password')).rejects.toThrow(auth_1.AuthenticationError);
+            yield expect(adapter.register(mockUser, 'password')).rejects.toThrow('Email already exists');
+        }));
+    });
+    describe('getAuthToken()', () => {
+        it('should successfully verify auth token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockDecodedToken = {
+                uid: 'user-123',
+                email: 'test@example.com',
+                iat: Date.now(),
+            };
+            mockAuth.verifyIdToken.mockResolvedValue(mockDecodedToken);
+            const result = yield adapter.getAuthToken('bearer-token-123');
+            expect(mockAuth.verifyIdToken).toHaveBeenCalledWith('bearer-token-123');
+            expect(result).toEqual(mockDecodedToken);
+        }));
+        it('should throw error when token is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockAuth.verifyIdToken.mockRejectedValue(new Error('Invalid token'));
+            yield expect(adapter.getAuthToken('invalid-token')).rejects.toThrow('Invalid token');
+        }));
+    });
+    describe('update()', () => {
+        const mockUser = {
+            uid: 'user-123',
+            _: {
+                email: 'test@example.com',
+            },
+        };
+        it('should successfully update user', () => __awaiter(void 0, void 0, void 0, function* () {
+            const updatable = {
+                email: 'newemail@example.com',
+                displayName: 'New Name',
+            };
+            mockAuth.updateUser.mockResolvedValue({});
+            yield adapter.update(mockUser, updatable);
+            expect(mockAuth.updateUser).toHaveBeenCalledWith('user-123', updatable);
+        }));
+        it('should skip update when updatable is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield adapter.update(mockUser, {});
+            expect(mockAuth.updateUser).not.toHaveBeenCalled();
+        }));
+        it('should silently handle errors during update', () => __awaiter(void 0, void 0, void 0, function* () {
+            const updatable = { displayName: 'New Name' };
+            mockAuth.updateUser.mockRejectedValue(new Error('Update failed'));
+            // Should not throw
+            yield expect(adapter.update(mockUser, updatable)).resolves.toBeUndefined();
+            expect(mockAuth.updateUser).toHaveBeenCalledWith('user-123', updatable);
+        }));
+    });
+    describe('delete()', () => {
+        const mockUser = {
+            uid: 'user-123',
+        };
+        it('should successfully delete user', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockAuth.deleteUser.mockResolvedValue(undefined);
+            yield adapter.delete(mockUser);
+            expect(mockAuth.deleteUser).toHaveBeenCalledWith('user-123');
+        }));
+        it('should throw error on deletion failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockAuth.deleteUser.mockRejectedValue(new Error('User not found'));
+            yield expect(adapter.delete(mockUser)).rejects.toThrow('User not found');
+        }));
+    });
+    describe('refreshToken()', () => {
+        it('should successfully refresh token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                access_token: 'new-access-token',
+                refresh_token: 'new-refresh-token',
+                expires_in: 3600,
+            };
+            const mockFetchResponse = {
+                json: jest.fn().mockResolvedValue(mockResponse),
+            };
+            nativeFetch.fetch.mockResolvedValue(mockFetchResponse);
+            const result = yield adapter.refreshToken('old-refresh-token');
+            expect(nativeFetch.fetch).toHaveBeenCalledWith('https://securetoken.googleapis.com/v1/token?key=test-api-key', {
+                method: 'POST',
+                body: JSON.stringify({
+                    grant_type: 'refresh_token',
+                    refresh_token: 'old-refresh-token',
+                }),
+                headers: { 'Content-Type': 'application/json' },
+            });
+            // Note: Implementation doesn't await json(), so result is a promise
+            const resultValue = yield result;
+            expect(resultValue).toEqual(mockResponse);
+        }));
+        it('should return empty object when API key is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapterWithoutKey = new FirebaseAuthAdapter_1.FirebaseAuthAdapter({
+                config: {
+                    projectId: 'test-project',
+                },
+            });
+            const result = yield adapterWithoutKey.refreshToken('refresh-token');
+            expect(result).toEqual({});
+            expect(nativeFetch.fetch).not.toHaveBeenCalled();
+        }));
+        it('should construct correct URL with API key', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFetchResponse = {
+                json: jest.fn().mockResolvedValue({}),
+            };
+            nativeFetch.fetch.mockResolvedValue(mockFetchResponse);
+            yield adapter.refreshToken('refresh-token');
+            const callArgs = nativeFetch.fetch.mock.calls[0];
+            expect(callArgs[0]).toBe('https://securetoken.googleapis.com/v1/token?key=test-api-key');
+        }));
+    });
+    describe('Unimplemented Methods (Stubs)', () => {
+        describe('signup()', () => {
+            it('should have signup method defined', () => {
+                expect(adapter.signup).toBeDefined();
+                expect(typeof adapter.signup).toBe('function');
+            });
+            it('should return undefined (not implemented)', () => __awaiter(void 0, void 0, void 0, function* () {
+                const result = yield adapter.signup('test@example.com', 'password');
+                expect(result).toBeUndefined();
+            }));
+        });
+        describe('signout()', () => {
+            it('should have signout method defined', () => {
+                expect(adapter.signout).toBeDefined();
+                expect(typeof adapter.signout).toBe('function');
+            });
+            it('should return undefined (not implemented)', () => __awaiter(void 0, void 0, void 0, function* () {
+                const mockUser = { uid: 'user-123' };
+                const result = yield adapter.signout(mockUser);
+                expect(result).toBeUndefined();
+            }));
+        });
+        describe('revokeAuthToken()', () => {
+            it('should have revokeAuthToken method defined', () => {
+                expect(adapter.revokeAuthToken).toBeDefined();
+                expect(typeof adapter.revokeAuthToken).toBe('function');
+            });
+            it('should return undefined (not implemented)', () => __awaiter(void 0, void 0, void 0, function* () {
+                const result = yield adapter.revokeAuthToken('token-123');
+                expect(result).toBeUndefined();
+            }));
+        });
+        describe('setCustomUserClaims()', () => {
+            it('should have setCustomUserClaims method defined', () => {
+                expect(adapter.setCustomUserClaims).toBeDefined();
+                expect(typeof adapter.setCustomUserClaims).toBe('function');
+            });
+            it('should return undefined (not implemented)', () => __awaiter(void 0, void 0, void 0, function* () {
+                const result = yield adapter.setCustomUserClaims('user-123', {
+                    role: 'admin',
+                });
+                expect(result).toBeUndefined();
+            }));
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { FirebaseAuthAdapter } from './FirebaseAuthAdapter';
+export { FirebaseAuthAdapter };

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseAuthAdapter = void 0;
+const FirebaseAuthAdapter_1 = require("./FirebaseAuthAdapter");
+Object.defineProperty(exports, "FirebaseAuthAdapter", { enumerable: true, get: function () { return FirebaseAuthAdapter_1.FirebaseAuthAdapter; } });

package/package.json

@@ -1,43 +1,43 @@
 {
-   "name": "@quatrain/auth-firebase",
-   "version": "1.1.16",
-   "license": "AGPL-3.0-only",
-   "main": "lib/index.js",
-   "types": "lib/index.d.ts",
-   "bun": "src/index.ts",
-   "files": [
-      "LICENSE.md",
-      "src/",
-      "lib/",
-      "README.md"
-   ],
-   "author": "Quatrain Développement SAS <developers@quatrain.com>",
-   "peerDependencies": {
-      "@quatrain/core": "^1.1.43"
-   },
-   "dependencies": {
-      "@quatrain/auth": "^1.1.21",
-      "@quatrain/backend": "^1.1.27",
-      "@quatrain/core": "^1.1.43",
-      "firebase-admin": "^13.0.1",
-      "node-fetch-native": "^1.6.4"
-   },
-   "devDependencies": {
-      "@tsconfig/recommended": "^1.0.1",
-      "@types/jest": "^30.0.0",
-      "@types/node": "^22.10.1",
-      "jest": "^30.2.0",
-      "jest-node-exports-resolver": "^1.1.6",
-      "jest-serial-runner": "^1.2.1",
-      "trace-unhandled": "^2.0.1",
-      "ts-jest": "^29.4.1",
-      "ts-node": "^10.9.1",
-      "typescript": "^5.2.2"
-   },
-   "scripts": {
-      "test-ci": "jest --runInBand",
-      "build": "tsc",
-      "wbuild": "tsc --watch",
-      "bump-to": "yarn version"
-   }
-}
+  "name": "@quatrain/auth-firebase",
+  "version": "1.1.17",
+  "license": "AGPL-3.0-only",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
+  "files": [
+    "LICENSE.md",
+    "src/",
+    "dist/",
+    "README.md"
+  ],
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "peerDependencies": {
+    "@quatrain/core": "^1.1.44"
+  },
+  "dependencies": {
+    "@quatrain/auth": "^1.1.22",
+    "@quatrain/backend": "^1.1.28",
+    "@quatrain/core": "^1.1.44",
+    "firebase-admin": "^13.0.1",
+    "node-fetch-native": "^1.6.4"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.10.1",
+    "jest": "^30.2.0",
+    "jest-node-exports-resolver": "^1.1.6",
+    "jest-serial-runner": "^1.2.1",
+    "trace-unhandled": "^2.0.1",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "test-ci": "jest --runInBand",
+    "build": "tsc",
+    "wbuild": "tsc --watch",
+    "bump-to": "yarn version"
+  }
+}