@quatrain/auth 1.1.17 → 1.1.20

package/LICENSE.md

@@ -0,0 +1,15 @@
+# LICENSE UPDATE NOTICE
+
+As of 01/01/2026, Quatrain Core is licensed under the **GNU Affero General Public License v3.0 (AGPL v3)**.
+Previous versions remain under the MIT License.
+
+## Why AGPL?
+
+We believe in open collaboration for the development ecosystem. The AGPL ensures that any modification or deployment of this BaaS stack, including over a network, benefits the entire community.
+
+## Commercial Services & Enterprise Usage
+
+We provide official deployment services, technical training, and certification for Quatrain Core.
+For organizations requiring a non-copyleft license (commercial license) or custom proprietary integrations, please contact the copyright holder: **Quatrain Technologies**.
+
+Copyright © 2024-2026 Quatrain Technologies. All Rights Reserved.

package/README.md

@@ -0,0 +1,32 @@
+# @quatrain/auth
+
+This package provides authentication and authorization abstractions for Quatrain applications. It defines a consistent interface for managing users, sessions, and tokens across different authentication providers.
+
+## Features
+
+-  **Abstract Adapter**: A common interface for authentication providers.
+-  **User Management**: Handles user registration, login, and profile updates.
+-  **Token Handling**: Manages JWT verification and refresh logic.
+-  **Middleware Integration**: Provides hooks for protecting backend routes.
+
+## Installation
+
+```bash
+npm install @quatrain/auth
+```
+
+## Usage
+
+This package is meant to be used with a concrete authentication adapter, such as `@quatrain/auth-firebase` or `@quatrain/auth-supabase`.
+
+```typescript
+import { Auth } from '@quatrain/auth'
+import { SupabaseAuthAdapter } from '@quatrain/auth-supabase'
+
+// Assuming an adapter has been added
+const user = await Auth.register({
+   email: 'user@example.com',
+   password: 'password123',
+})
+const token = await Auth.login('user@example.com', 'password123')
+```

package/lib/Auth.test.d.ts

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

package/lib/Auth.test.js

@@ -0,0 +1,182 @@
+"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 Auth_1 = require("./Auth");
+const MockAuthAdapter_1 = require("./MockAuthAdapter");
+describe('Auth', () => {
+    let mockAdapter1;
+    let mockAdapter2;
+    beforeEach(() => {
+        // Reset providers before each test
+        ;
+        Auth_1.Auth._providers = {};
+        Auth_1.Auth.defaultProvider = 'default';
+        // Create fresh mock adapters
+        mockAdapter1 = new MockAuthAdapter_1.MockAuthAdapter({ debug: false });
+        mockAdapter2 = new MockAuthAdapter_1.MockAuthAdapter({ debug: false });
+    });
+    afterEach(() => {
+        // Clean up
+        mockAdapter1 === null || mockAdapter1 === void 0 ? void 0 : mockAdapter1.clearAll();
+        mockAdapter2 === null || mockAdapter2 === void 0 ? void 0 : mockAdapter2.clearAll();
+    });
+    describe('AuthAction enum', () => {
+        it('should have correct action values', () => {
+            expect(Auth_1.AuthAction.SIGNIN).toBe('signin');
+            expect(Auth_1.AuthAction.SIGNUP).toBe('signup');
+            expect(Auth_1.AuthAction.SIGNOUT).toBe('signout');
+        });
+    });
+    describe('addProvider', () => {
+        it('should add a provider with an alias', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'test-provider');
+            const provider = Auth_1.Auth.getProvider('test-provider');
+            expect(provider).toBe(mockAdapter1);
+        });
+        it('should add multiple providers with different aliases', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'provider1');
+            Auth_1.Auth.addProvider(mockAdapter2, 'provider2');
+            const provider1 = Auth_1.Auth.getProvider('provider1');
+            const provider2 = Auth_1.Auth.getProvider('provider2');
+            expect(provider1).toBe(mockAdapter1);
+            expect(provider2).toBe(mockAdapter2);
+        });
+        it('should set default provider when setDefault is true', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'custom-provider', true);
+            expect(Auth_1.Auth.defaultProvider).toBe('custom-provider');
+            const provider = Auth_1.Auth.getProvider(); // Should use default
+            expect(provider).toBe(mockAdapter1);
+        });
+        it('should not change default provider when setDefault is false', () => {
+            const originalDefault = Auth_1.Auth.defaultProvider;
+            Auth_1.Auth.addProvider(mockAdapter1, 'custom-provider', false);
+            expect(Auth_1.Auth.defaultProvider).toBe(originalDefault);
+        });
+        it('should allow overriding an existing provider', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'provider');
+            Auth_1.Auth.addProvider(mockAdapter2, 'provider');
+            const provider = Auth_1.Auth.getProvider('provider');
+            expect(provider).toBe(mockAdapter2);
+        });
+    });
+    describe('getProvider', () => {
+        it('should return the correct provider by alias', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'test-provider');
+            const provider = Auth_1.Auth.getProvider('test-provider');
+            expect(provider).toBe(mockAdapter1);
+        });
+        it('should return the default provider when no alias is specified', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'default', true);
+            const provider = Auth_1.Auth.getProvider();
+            expect(provider).toBe(mockAdapter1);
+        });
+        it('should throw error when provider alias does not exist', () => {
+            expect(() => {
+                Auth_1.Auth.getProvider('non-existent');
+            }).toThrow("Unknown provider alias: 'non-existent'");
+        });
+        it('should throw error when getting default provider that does not exist', () => {
+            expect(() => {
+                Auth_1.Auth.getProvider();
+            }).toThrow("Unknown provider alias: 'default'");
+        });
+        it('should be type-safe with generic parameter', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'typed-provider');
+            const provider = Auth_1.Auth.getProvider('typed-provider');
+            expect(provider).toBeInstanceOf(MockAuthAdapter_1.MockAuthAdapter);
+        });
+    });
+    describe('defaultProvider', () => {
+        it('should have a default value of "default"', () => {
+            expect(Auth_1.Auth.defaultProvider).toBe('default');
+        });
+        it('should allow changing the default provider', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'new-default', true);
+            expect(Auth_1.Auth.defaultProvider).toBe('new-default');
+        });
+    });
+    describe('ERROR_EMAIL_EXISTS constant', () => {
+        it('should have correct error message', () => {
+            expect(Auth_1.Auth.ERROR_EMAIL_EXISTS).toBe('User email already exists');
+        });
+    });
+    describe('Integration with MockAuthAdapter', () => {
+        it('should work with adapter methods', () => __awaiter(void 0, void 0, void 0, function* () {
+            Auth_1.Auth.addProvider(mockAdapter1, 'test');
+            const provider = Auth_1.Auth.getProvider('test');
+            const mockUser = {
+                _: { email: 'test@example.com' },
+                name: 'Test User',
+            };
+            const result = yield provider.register(mockUser, 'password123');
+            expect(result.success).toBe(true);
+            expect(result.user._.email).toBe('test@example.com');
+        }));
+        it('should maintain separate state between providers', () => __awaiter(void 0, void 0, void 0, function* () {
+            Auth_1.Auth.addProvider(mockAdapter1, 'provider1');
+            Auth_1.Auth.addProvider(mockAdapter2, 'provider2');
+            const adapter1 = Auth_1.Auth.getProvider('provider1');
+            const adapter2 = Auth_1.Auth.getProvider('provider2');
+            const user1 = {
+                _: { email: 'user1@example.com' },
+                name: 'User 1',
+            };
+            const user2 = {
+                _: { email: 'user2@example.com' },
+                name: 'User 2',
+            };
+            yield adapter1.register(user1, 'password1');
+            yield adapter2.register(user2, 'password2');
+            expect(adapter1.getUserByEmail('user1@example.com')).toBeDefined();
+            expect(adapter1.getUserByEmail('user2@example.com')).toBeUndefined();
+            expect(adapter2.getUserByEmail('user2@example.com')).toBeDefined();
+            expect(adapter2.getUserByEmail('user1@example.com')).toBeUndefined();
+        }));
+    });
+    describe('AuthParameters', () => {
+        it('should accept valid parameters when creating adapter', () => {
+            const params = {
+                host: 'https://auth.example.com',
+                alias: 'example-auth',
+                debug: true,
+                config: { timeout: 5000 },
+                fixtures: { users: [] },
+            };
+            const adapter = new MockAuthAdapter_1.MockAuthAdapter(params);
+            expect(adapter.getParam('host')).toBe('https://auth.example.com');
+            expect(adapter.getParam('debug')).toBe(true);
+            expect(adapter.getParam('config')).toEqual({ timeout: 5000 });
+        });
+        it('should work with empty parameters', () => {
+            const adapter = new MockAuthAdapter_1.MockAuthAdapter();
+            expect(adapter.getParam('host')).toBeUndefined();
+            expect(adapter.getParam('debug')).toBeUndefined();
+        });
+    });
+    describe('Provider registry behavior', () => {
+        it('should maintain providers across multiple operations', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'persistent');
+            // Multiple get operations
+            const provider1 = Auth_1.Auth.getProvider('persistent');
+            const provider2 = Auth_1.Auth.getProvider('persistent');
+            expect(provider1).toBe(provider2);
+            expect(provider1).toBe(mockAdapter1);
+        });
+        it('should handle switching default provider multiple times', () => {
+            Auth_1.Auth.addProvider(mockAdapter1, 'provider1', true);
+            expect(Auth_1.Auth.defaultProvider).toBe('provider1');
+            Auth_1.Auth.addProvider(mockAdapter2, 'provider2', true);
+            expect(Auth_1.Auth.defaultProvider).toBe('provider2');
+            const defaultProvider = Auth_1.Auth.getProvider();
+            expect(defaultProvider).toBe(mockAdapter2);
+        });
+    });
+});

package/lib/MockAuthAdapter.d.ts

@@ -0,0 +1,24 @@
+import { AbstractAuthAdapter } from './AbstractAuthAdapter';
+import { User } from '@quatrain/backend';
+import { AuthParameters } from './Auth';
+/**
+ * Mock Authentication Adapter for testing purposes
+ */
+export declare class MockAuthAdapter extends AbstractAuthAdapter {
+    private registeredUsers;
+    private tokens;
+    private refreshTokens;
+    constructor(params?: AuthParameters);
+    register(user: User, clearPassword?: string): Promise<any>;
+    signup(login: string, password: string): Promise<any>;
+    signout(user: User): Promise<any>;
+    update(user: User, updatable: any): Promise<any>;
+    delete(user: User): Promise<any>;
+    getAuthToken(token: string): any;
+    refreshToken(refreshToken: string): Promise<any>;
+    revokeAuthToken(token: string): any;
+    setCustomUserClaims(id: string, claims: any): any;
+    clearAll(): void;
+    getUserByEmail(email: string): User | undefined;
+    hasToken(token: string): boolean;
+}

package/lib/MockAuthAdapter.js

@@ -0,0 +1,154 @@
+"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 });
+exports.MockAuthAdapter = void 0;
+const AbstractAuthAdapter_1 = require("./AbstractAuthAdapter");
+/**
+ * Mock Authentication Adapter for testing purposes
+ */
+class MockAuthAdapter extends AbstractAuthAdapter_1.AbstractAuthAdapter {
+    constructor(params = {}) {
+        super(params);
+        this.registeredUsers = new Map();
+        this.tokens = new Map();
+        this.refreshTokens = new Map();
+    }
+    register(user, clearPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.registeredUsers.has(user._.email)) {
+                throw new Error('User email already exists');
+            }
+            this.registeredUsers.set(user._.email, user);
+            return { success: true, user };
+        });
+    }
+    signup(login, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = this.registeredUsers.get(login);
+            if (!user) {
+                throw new Error('User not found');
+            }
+            const token = `mock-token-${Date.now()}`;
+            const refreshToken = `mock-refresh-token-${Date.now()}`;
+            this.tokens.set(token, { user, timestamp: Date.now() });
+            this.refreshTokens.set(refreshToken, token);
+            return {
+                success: true,
+                token,
+                refreshToken,
+                user,
+            };
+        });
+    }
+    signout(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Remove all tokens associated with this user
+            for (const [token, data] of this.tokens.entries()) {
+                if (data.user._.email === user._.email) {
+                    this.tokens.delete(token);
+                }
+            }
+            return { success: true };
+        });
+    }
+    update(user, updatable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingUser = this.registeredUsers.get(user._.email);
+            if (!existingUser) {
+                throw new Error('User not found');
+            }
+            const updatedUser = Object.assign(Object.assign({}, existingUser), updatable);
+            this.registeredUsers.set(user._.email, updatedUser);
+            return { success: true, user: updatedUser };
+        });
+    }
+    delete(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.registeredUsers.has(user._.email)) {
+                throw new Error('User not found');
+            }
+            this.registeredUsers.delete(user._.email);
+            yield this.signout(user);
+            return { success: true };
+        });
+    }
+    getAuthToken(token) {
+        const tokenData = this.tokens.get(token);
+        if (!tokenData) {
+            throw new Error('Invalid token');
+        }
+        return tokenData;
+    }
+    refreshToken(refreshToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oldToken = this.refreshTokens.get(refreshToken);
+            if (!oldToken) {
+                throw new Error('Invalid refresh token');
+            }
+            const tokenData = this.tokens.get(oldToken);
+            if (!tokenData) {
+                throw new Error('Token not found');
+            }
+            // Generate new tokens
+            const newToken = `mock-token-${Date.now()}`;
+            const newRefreshToken = `mock-refresh-token-${Date.now()}`;
+            // Remove old tokens
+            this.tokens.delete(oldToken);
+            this.refreshTokens.delete(refreshToken);
+            // Add new tokens
+            this.tokens.set(newToken, tokenData);
+            this.refreshTokens.set(newRefreshToken, newToken);
+            return {
+                success: true,
+                token: newToken,
+                refreshToken: newRefreshToken,
+            };
+        });
+    }
+    revokeAuthToken(token) {
+        if (!this.tokens.has(token)) {
+            throw new Error('Token not found');
+        }
+        this.tokens.delete(token);
+        // Remove associated refresh token
+        for (const [refreshToken, associatedToken,] of this.refreshTokens.entries()) {
+            if (associatedToken === token) {
+                this.refreshTokens.delete(refreshToken);
+                break;
+            }
+        }
+        return { success: true };
+    }
+    setCustomUserClaims(id, claims) {
+        // Find user by id and set custom claims
+        for (const [email, user] of this.registeredUsers.entries()) {
+            if (user._.id === id) {
+                ;
+                user.customClaims = claims;
+                return { success: true, claims };
+            }
+        }
+        throw new Error('User not found');
+    }
+    // Helper methods for testing
+    clearAll() {
+        this.registeredUsers.clear();
+        this.tokens.clear();
+        this.refreshTokens.clear();
+    }
+    getUserByEmail(email) {
+        return this.registeredUsers.get(email);
+    }
+    hasToken(token) {
+        return this.tokens.has(token);
+    }
+}
+exports.MockAuthAdapter = MockAuthAdapter;

package/package.json

@@ -1,40 +1,38 @@
 {
-  "name": "@quatrain/auth",
-  "version": "1.1.17",
-  "license": "MIT",
-  "description": "Auth adapters commons",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib/",
-    "README.md"
-  ],
-  "author": "Quatrain Développement SAS <developers@quatrain.com>",
-  "dependencies": {
-    "@quatrain/backend": "^1.1.20",
-    "@quatrain/core": "^1.1.19"
-  },
-  "devDependencies": {
-    "@tsconfig/recommended": "^1.0.1",
-    "@types/jest": "^27.0.3",
-    "@types/node": "^22.10.1",
-    "jest": "^27.4.7",
-    "jest-node-exports-resolver": "^1.1.6",
-    "jest-serial-runner": "^1.2.1",
-    "trace-unhandled": "^2.0.1",
-    "ts-jest": "^27.1.2",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.1.5"
-  },
-  "scripts": {
-    "test-ci": "jest --runInBand",
-    "build": "tsc",
-    "wbuild": "tsc --watch",
-    "bump-to": "yarn version",
-    "hash": "node ../../bin/hashFolder.js",
-    "hash:persist": "yarn hash  > .hash_latest.txt",
-    "hash:compare": "yarn hash > .hash_newest.txt && cmp -s .hash_latest.txt .hash_newest.txt",
-    "publish": "yarn hash:compare || yarn publish:process",
-    "publish:process": "yarn version patch && yarn build && yarn npm publish --access public && yarn hash:persist"
-  }
-}
+   "name": "@quatrain/auth",
+   "version": "1.1.20",
+   "license": "AGPL-3.0-only",
+   "description": "Auth adapters commons",
+   "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>",
+   "dependencies": {
+      "@quatrain/backend": "^1.1.26",
+      "@quatrain/core": "^1.1.43"
+   },
+   "devDependencies": {
+      "@tsconfig/recommended": "^1.0.1",
+      "@types/jest": "^27.0.3",
+      "@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": "^27.1.2",
+      "ts-node": "^10.9.1",
+      "typescript": "^5.1.5"
+   },
+   "scripts": {
+      "test-ci": "jest --runInBand",
+      "build": "tsc",
+      "wbuild": "tsc --watch",
+      "bump-to": "yarn version"
+   }
+}

package/src/AbstractAuthAdapter.ts

@@ -0,0 +1,47 @@
+import { AuthParameters, AuthParametersKeys } from './Auth'
+import { User } from '@quatrain/backend'
+import { AuthInterface } from './types/AuthInterface'
+
+export abstract class AbstractAuthAdapter implements AuthInterface {
+   static UserClass = User
+   protected _alias: string = ''
+   protected _params: AuthParameters = {}
+
+   constructor(params: AuthParameters = {}) {
+      this._params = params
+   }
+
+   setParam(key: AuthParametersKeys, value: any) {
+      this._params[key] = value
+   }
+
+   getParam(key: AuthParametersKeys) {
+      return this._params[key]
+   }
+
+   set alias(alias: string) {
+      this._alias = alias
+   }
+
+   get alias() {
+      return this._alias
+   }
+
+   abstract register(user: User, clearPassword?: string): Promise<any>
+
+   abstract signup(login: string, password: string): Promise<any>
+
+   abstract signout(user: User): Promise<any>
+
+   abstract update(user: User, updatable: any): Promise<any>
+
+   abstract delete(user: User): Promise<any>
+
+   abstract getAuthToken(token: string): any
+
+   abstract refreshToken(refreshToken: string): Promise<any>
+
+   abstract revokeAuthToken(token: string): any
+
+   abstract setCustomUserClaims(id: string, claims: any): any
+}

package/src/Auth.test.ts

@@ -0,0 +1,216 @@
+import { Auth, AuthAction, AuthParameters } from './Auth'
+import { MockAuthAdapter } from './MockAuthAdapter'
+import { User } from '@quatrain/backend'
+
+describe('Auth', () => {
+   let mockAdapter1: MockAuthAdapter
+   let mockAdapter2: MockAuthAdapter
+
+   beforeEach(() => {
+      // Reset providers before each test
+      ;(Auth as any)._providers = {}
+      Auth.defaultProvider = 'default'
+
+      // Create fresh mock adapters
+      mockAdapter1 = new MockAuthAdapter({ debug: false })
+      mockAdapter2 = new MockAuthAdapter({ debug: false })
+   })
+
+   afterEach(() => {
+      // Clean up
+      mockAdapter1?.clearAll()
+      mockAdapter2?.clearAll()
+   })
+
+   describe('AuthAction enum', () => {
+      it('should have correct action values', () => {
+         expect(AuthAction.SIGNIN).toBe('signin')
+         expect(AuthAction.SIGNUP).toBe('signup')
+         expect(AuthAction.SIGNOUT).toBe('signout')
+      })
+   })
+
+   describe('addProvider', () => {
+      it('should add a provider with an alias', () => {
+         Auth.addProvider(mockAdapter1, 'test-provider')
+
+         const provider = Auth.getProvider('test-provider')
+         expect(provider).toBe(mockAdapter1)
+      })
+
+      it('should add multiple providers with different aliases', () => {
+         Auth.addProvider(mockAdapter1, 'provider1')
+         Auth.addProvider(mockAdapter2, 'provider2')
+
+         const provider1 = Auth.getProvider('provider1')
+         const provider2 = Auth.getProvider('provider2')
+
+         expect(provider1).toBe(mockAdapter1)
+         expect(provider2).toBe(mockAdapter2)
+      })
+
+      it('should set default provider when setDefault is true', () => {
+         Auth.addProvider(mockAdapter1, 'custom-provider', true)
+
+         expect(Auth.defaultProvider).toBe('custom-provider')
+         const provider = Auth.getProvider() // Should use default
+         expect(provider).toBe(mockAdapter1)
+      })
+
+      it('should not change default provider when setDefault is false', () => {
+         const originalDefault = Auth.defaultProvider
+         Auth.addProvider(mockAdapter1, 'custom-provider', false)
+
+         expect(Auth.defaultProvider).toBe(originalDefault)
+      })
+
+      it('should allow overriding an existing provider', () => {
+         Auth.addProvider(mockAdapter1, 'provider')
+         Auth.addProvider(mockAdapter2, 'provider')
+
+         const provider = Auth.getProvider('provider')
+         expect(provider).toBe(mockAdapter2)
+      })
+   })
+
+   describe('getProvider', () => {
+      it('should return the correct provider by alias', () => {
+         Auth.addProvider(mockAdapter1, 'test-provider')
+
+         const provider = Auth.getProvider('test-provider')
+         expect(provider).toBe(mockAdapter1)
+      })
+
+      it('should return the default provider when no alias is specified', () => {
+         Auth.addProvider(mockAdapter1, 'default', true)
+
+         const provider = Auth.getProvider()
+         expect(provider).toBe(mockAdapter1)
+      })
+
+      it('should throw error when provider alias does not exist', () => {
+         expect(() => {
+            Auth.getProvider('non-existent')
+         }).toThrow("Unknown provider alias: 'non-existent'")
+      })
+
+      it('should throw error when getting default provider that does not exist', () => {
+         expect(() => {
+            Auth.getProvider()
+         }).toThrow("Unknown provider alias: 'default'")
+      })
+
+      it('should be type-safe with generic parameter', () => {
+         Auth.addProvider(mockAdapter1, 'typed-provider')
+
+         const provider = Auth.getProvider<MockAuthAdapter>('typed-provider')
+         expect(provider).toBeInstanceOf(MockAuthAdapter)
+      })
+   })
+
+   describe('defaultProvider', () => {
+      it('should have a default value of "default"', () => {
+         expect(Auth.defaultProvider).toBe('default')
+      })
+
+      it('should allow changing the default provider', () => {
+         Auth.addProvider(mockAdapter1, 'new-default', true)
+         expect(Auth.defaultProvider).toBe('new-default')
+      })
+   })
+
+   describe('ERROR_EMAIL_EXISTS constant', () => {
+      it('should have correct error message', () => {
+         expect(Auth.ERROR_EMAIL_EXISTS).toBe('User email already exists')
+      })
+   })
+
+   describe('Integration with MockAuthAdapter', () => {
+      it('should work with adapter methods', async () => {
+         Auth.addProvider(mockAdapter1, 'test')
+         const provider = Auth.getProvider<MockAuthAdapter>('test')
+
+         const mockUser = {
+            _: { email: 'test@example.com' },
+            name: 'Test User',
+         } as unknown as User
+
+         const result = await provider.register(mockUser, 'password123')
+         expect(result.success).toBe(true)
+         expect(result.user._.email).toBe('test@example.com')
+      })
+
+      it('should maintain separate state between providers', async () => {
+         Auth.addProvider(mockAdapter1, 'provider1')
+         Auth.addProvider(mockAdapter2, 'provider2')
+
+         const adapter1 = Auth.getProvider<MockAuthAdapter>('provider1')
+         const adapter2 = Auth.getProvider<MockAuthAdapter>('provider2')
+
+         const user1 = {
+            _: { email: 'user1@example.com' },
+            name: 'User 1',
+         } as unknown as User
+         const user2 = {
+            _: { email: 'user2@example.com' },
+            name: 'User 2',
+         } as unknown as User
+
+         await adapter1.register(user1, 'password1')
+         await adapter2.register(user2, 'password2')
+
+         expect(adapter1.getUserByEmail('user1@example.com')).toBeDefined()
+         expect(adapter1.getUserByEmail('user2@example.com')).toBeUndefined()
+
+         expect(adapter2.getUserByEmail('user2@example.com')).toBeDefined()
+         expect(adapter2.getUserByEmail('user1@example.com')).toBeUndefined()
+      })
+   })
+
+   describe('AuthParameters', () => {
+      it('should accept valid parameters when creating adapter', () => {
+         const params: AuthParameters = {
+            host: 'https://auth.example.com',
+            alias: 'example-auth',
+            debug: true,
+            config: { timeout: 5000 },
+            fixtures: { users: [] },
+         }
+
+         const adapter = new MockAuthAdapter(params)
+         expect(adapter.getParam('host')).toBe('https://auth.example.com')
+         expect(adapter.getParam('debug')).toBe(true)
+         expect(adapter.getParam('config')).toEqual({ timeout: 5000 })
+      })
+
+      it('should work with empty parameters', () => {
+         const adapter = new MockAuthAdapter()
+         expect(adapter.getParam('host')).toBeUndefined()
+         expect(adapter.getParam('debug')).toBeUndefined()
+      })
+   })
+
+   describe('Provider registry behavior', () => {
+      it('should maintain providers across multiple operations', () => {
+         Auth.addProvider(mockAdapter1, 'persistent')
+
+         // Multiple get operations
+         const provider1 = Auth.getProvider('persistent')
+         const provider2 = Auth.getProvider('persistent')
+
+         expect(provider1).toBe(provider2)
+         expect(provider1).toBe(mockAdapter1)
+      })
+
+      it('should handle switching default provider multiple times', () => {
+         Auth.addProvider(mockAdapter1, 'provider1', true)
+         expect(Auth.defaultProvider).toBe('provider1')
+
+         Auth.addProvider(mockAdapter2, 'provider2', true)
+         expect(Auth.defaultProvider).toBe('provider2')
+
+         const defaultProvider = Auth.getProvider()
+         expect(defaultProvider).toBe(mockAdapter2)
+      })
+   })
+})

package/src/Auth.ts

@@ -0,0 +1,67 @@
+import { Core } from '@quatrain/core'
+import { AbstractAuthAdapter } from './AbstractAuthAdapter'
+import Middleware from './middlewares/AuthMiddleware'
+
+export enum AuthAction {
+   SIGNIN = 'signin',
+   SIGNUP = 'signup',
+   SIGNOUT = 'signout',
+}
+
+/**
+ * Authentication Parameters acceptable keys
+ */
+export type AuthParametersKeys =
+   | 'host'
+   | 'alias'
+   | 'middlewares'
+   | 'config'
+   | 'fixtures'
+   | 'debug'
+
+/**
+ * Backend parameters interface
+ */
+export interface AuthParameters {
+   host?: string
+   alias?: string
+   middlewares?: Middleware[]
+   config?: any
+   fixtures?: any
+   debug?: boolean
+}
+
+export interface AuthAdapter extends AbstractAuthAdapter {}
+
+export type AuthRegistry<T extends AbstractAuthAdapter> = { [x: string]: T }
+
+export class Auth extends Core {
+   static defaultProvider = 'default'
+   static logger = this.addLogger('Auth')
+
+
+   static ERROR_EMAIL_EXISTS = `User email already exists`
+
+   protected static _providers: AuthRegistry<any> = {}
+
+   static addProvider(
+      provider: AbstractAuthAdapter,
+      alias: string,
+      setDefault: boolean = false
+   ) {
+      this._providers[alias] = provider
+      if (setDefault) {
+         this.defaultProvider = alias
+      }
+   }
+
+   static getProvider<T extends AbstractAuthAdapter>(
+      alias: string = this.defaultProvider
+   ): T {
+      if (this._providers[alias]) {
+         return this._providers[alias]
+      } else {
+         throw new Error(`Unknown provider alias: '${alias}'`)
+      }
+   }
+}

package/src/AuthenticationError.ts

@@ -0,0 +1 @@
+export class AuthenticationError extends Error {}

package/src/MockAuthAdapter.ts

@@ -0,0 +1,162 @@
+import { AbstractAuthAdapter } from './AbstractAuthAdapter'
+import { User } from '@quatrain/backend'
+import { AuthParameters } from './Auth'
+
+/**
+ * Mock Authentication Adapter for testing purposes
+ */
+export class MockAuthAdapter extends AbstractAuthAdapter {
+   private registeredUsers: Map<string, User> = new Map()
+   private tokens: Map<string, any> = new Map()
+   private refreshTokens: Map<string, string> = new Map()
+
+   constructor(params: AuthParameters = {}) {
+      super(params)
+   }
+
+   async register(user: User, clearPassword?: string): Promise<any> {
+      if (this.registeredUsers.has(user._.email)) {
+         throw new Error('User email already exists')
+      }
+      this.registeredUsers.set(user._.email, user)
+      return { success: true, user }
+   }
+
+   async signup(login: string, password: string): Promise<any> {
+      const user = this.registeredUsers.get(login)
+      if (!user) {
+         throw new Error('User not found')
+      }
+
+      const token = `mock-token-${Date.now()}`
+      const refreshToken = `mock-refresh-token-${Date.now()}`
+
+      this.tokens.set(token, { user, timestamp: Date.now() })
+      this.refreshTokens.set(refreshToken, token)
+
+      return {
+         success: true,
+         token,
+         refreshToken,
+         user,
+      }
+   }
+
+   async signout(user: User): Promise<any> {
+      // Remove all tokens associated with this user
+      for (const [token, data] of this.tokens.entries()) {
+         if (data.user._.email === user._.email) {
+            this.tokens.delete(token)
+         }
+      }
+      return { success: true }
+   }
+
+   async update(user: User, updatable: any): Promise<any> {
+      const existingUser = this.registeredUsers.get(user._.email)
+      if (!existingUser) {
+         throw new Error('User not found')
+      }
+
+      const updatedUser = { ...existingUser, ...updatable }
+      this.registeredUsers.set(user._.email, updatedUser)
+
+      return { success: true, user: updatedUser }
+   }
+
+   async delete(user: User): Promise<any> {
+      if (!this.registeredUsers.has(user._.email)) {
+         throw new Error('User not found')
+      }
+
+      this.registeredUsers.delete(user._.email)
+      await this.signout(user)
+
+      return { success: true }
+   }
+
+   getAuthToken(token: string): any {
+      const tokenData = this.tokens.get(token)
+      if (!tokenData) {
+         throw new Error('Invalid token')
+      }
+      return tokenData
+   }
+
+   async refreshToken(refreshToken: string): Promise<any> {
+      const oldToken = this.refreshTokens.get(refreshToken)
+      if (!oldToken) {
+         throw new Error('Invalid refresh token')
+      }
+
+      const tokenData = this.tokens.get(oldToken)
+      if (!tokenData) {
+         throw new Error('Token not found')
+      }
+
+      // Generate new tokens
+      const newToken = `mock-token-${Date.now()}`
+      const newRefreshToken = `mock-refresh-token-${Date.now()}`
+
+      // Remove old tokens
+      this.tokens.delete(oldToken)
+      this.refreshTokens.delete(refreshToken)
+
+      // Add new tokens
+      this.tokens.set(newToken, tokenData)
+      this.refreshTokens.set(newRefreshToken, newToken)
+
+      return {
+         success: true,
+         token: newToken,
+         refreshToken: newRefreshToken,
+      }
+   }
+
+   revokeAuthToken(token: string): any {
+      if (!this.tokens.has(token)) {
+         throw new Error('Token not found')
+      }
+
+      this.tokens.delete(token)
+
+      // Remove associated refresh token
+      for (const [
+         refreshToken,
+         associatedToken,
+      ] of this.refreshTokens.entries()) {
+         if (associatedToken === token) {
+            this.refreshTokens.delete(refreshToken)
+            break
+         }
+      }
+
+      return { success: true }
+   }
+
+   setCustomUserClaims(id: string, claims: any): any {
+      // Find user by id and set custom claims
+      for (const [email, user] of this.registeredUsers.entries()) {
+         if ((user as any)._.id === id) {
+            ;(user as any).customClaims = claims
+            return { success: true, claims }
+         }
+      }
+      throw new Error('User not found')
+   }
+
+   // Helper methods for testing
+   clearAll(): void {
+      this.registeredUsers.clear()
+      this.tokens.clear()
+      this.refreshTokens.clear()
+   }
+
+   getUserByEmail(email: string): User | undefined {
+      return this.registeredUsers.get(email)
+   }
+
+   hasToken(token: string): boolean {
+      return this.tokens.has(token)
+   }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+import { Auth, AuthAction, AuthParameters, AuthParametersKeys } from './Auth'
+import { AbstractAuthAdapter } from './AbstractAuthAdapter'
+import { AuthInterface } from './types/AuthInterface'
+import { AuthenticationError } from './AuthenticationError'
+
+export {
+   Auth,
+   AuthAction,
+   AuthParameters,
+   AuthParametersKeys,
+   AuthInterface,
+   AbstractAuthAdapter,
+   AuthenticationError,
+}

package/src/middlewares/AuthMiddleware.ts

@@ -0,0 +1,6 @@
+import { AuthAction } from '../Auth'
+import { User } from '@quatrain/backend'
+
+export default interface AuthMiddleware {
+   execute: (user: User, action: AuthAction) => void
+}

package/src/types/AuthInterface.ts

@@ -0,0 +1,17 @@
+import { User } from '@quatrain/core'
+
+export interface AuthInterface {
+   register(user: User): Promise<any>
+
+   signup(login: string, password: string): Promise<any>
+
+   signout(user: User): Promise<any>
+
+   update(user: User, updatable: any): Promise<any>
+
+   delete(user: User): Promise<any>
+
+   getAuthToken(token: string): any
+
+   refreshToken(refreshToken: string): Promise<any>
+}