@quatrain/auth 1.1.20 → 1.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@quatrain/auth",
-   "version": "1.1.20",
+   "version": "1.1.21",
    "license": "AGPL-3.0-only",
    "description": "Auth adapters commons",
    "main": "lib/index.js",
@@ -14,7 +14,7 @@
    ],
    "author": "Quatrain Développement SAS <developers@quatrain.com>",
    "dependencies": {
-      "@quatrain/backend": "^1.1.26",
+      "@quatrain/backend": "^1.1.27",
       "@quatrain/core": "^1.1.43"
    },
    "devDependencies": {

package/lib/AbstractAuthAdapter.d.ts

@@ -1,22 +0,0 @@
-import { AuthParameters, AuthParametersKeys } from './Auth';
-import { User } from '@quatrain/backend';
-import { AuthInterface } from './types/AuthInterface';
-export declare abstract class AbstractAuthAdapter implements AuthInterface {
-    static UserClass: typeof User;
-    protected _alias: string;
-    protected _params: AuthParameters;
-    constructor(params?: AuthParameters);
-    setParam(key: AuthParametersKeys, value: any): void;
-    getParam(key: AuthParametersKeys): any;
-    set alias(alias: string);
-    get alias(): string;
-    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/lib/AbstractAuthAdapter.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractAuthAdapter = void 0;
-const backend_1 = require("@quatrain/backend");
-class AbstractAuthAdapter {
-    constructor(params = {}) {
-        this._alias = '';
-        this._params = {};
-        this._params = params;
-    }
-    setParam(key, value) {
-        this._params[key] = value;
-    }
-    getParam(key) {
-        return this._params[key];
-    }
-    set alias(alias) {
-        this._alias = alias;
-    }
-    get alias() {
-        return this._alias;
-    }
-}
-exports.AbstractAuthAdapter = AbstractAuthAdapter;
-AbstractAuthAdapter.UserClass = backend_1.User;

package/lib/Auth.d.ts

@@ -1,36 +0,0 @@
-import { Core } from '@quatrain/core';
-import { AbstractAuthAdapter } from './AbstractAuthAdapter';
-import Middleware from './middlewares/AuthMiddleware';
-export declare 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 declare class Auth extends Core {
-    static defaultProvider: string;
-    static logger: any;
-    static ERROR_EMAIL_EXISTS: string;
-    protected static _providers: AuthRegistry<any>;
-    static addProvider(provider: AbstractAuthAdapter, alias: string, setDefault?: boolean): void;
-    static getProvider<T extends AbstractAuthAdapter>(alias?: string): T;
-}

package/lib/Auth.js

@@ -1,33 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Auth = exports.AuthAction = void 0;
-const core_1 = require("@quatrain/core");
-var AuthAction;
-(function (AuthAction) {
-    AuthAction["SIGNIN"] = "signin";
-    AuthAction["SIGNUP"] = "signup";
-    AuthAction["SIGNOUT"] = "signout";
-})(AuthAction || (exports.AuthAction = AuthAction = {}));
-class Auth extends core_1.Core {
-    static addProvider(provider, alias, setDefault = false) {
-        this._providers[alias] = provider;
-        if (setDefault) {
-            this.defaultProvider = alias;
-        }
-    }
-    static getProvider(alias = this.defaultProvider) {
-        if (this._providers[alias]) {
-            return this._providers[alias];
-        }
-        else {
-            throw new Error(`Unknown provider alias: '${alias}'`);
-        }
-    }
-}
-exports.Auth = Auth;
-_a = Auth;
-Auth.defaultProvider = 'default';
-Auth.logger = _a.addLogger('Auth');
-Auth.ERROR_EMAIL_EXISTS = `User email already exists`;
-Auth._providers = {};

package/lib/Auth.test.d.ts

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

package/lib/Auth.test.js

@@ -1,182 +0,0 @@
-"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/AuthenticationError.d.ts

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

package/lib/AuthenticationError.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthenticationError = void 0;
-class AuthenticationError extends Error {
-}
-exports.AuthenticationError = AuthenticationError;

package/lib/MockAuthAdapter.d.ts

@@ -1,24 +0,0 @@
-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

@@ -1,154 +0,0 @@
-"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/lib/index.d.ts

@@ -1,5 +0,0 @@
-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/lib/index.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthenticationError = exports.AbstractAuthAdapter = exports.AuthAction = exports.Auth = void 0;
-const Auth_1 = require("./Auth");
-Object.defineProperty(exports, "Auth", { enumerable: true, get: function () { return Auth_1.Auth; } });
-Object.defineProperty(exports, "AuthAction", { enumerable: true, get: function () { return Auth_1.AuthAction; } });
-const AbstractAuthAdapter_1 = require("./AbstractAuthAdapter");
-Object.defineProperty(exports, "AbstractAuthAdapter", { enumerable: true, get: function () { return AbstractAuthAdapter_1.AbstractAuthAdapter; } });
-const AuthenticationError_1 = require("./AuthenticationError");
-Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return AuthenticationError_1.AuthenticationError; } });

package/lib/middlewares/AbstractAuthMiddleware.js

@@ -1 +0,0 @@
-"use strict";

package/lib/middlewares/AuthMiddleware.d.ts

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

package/lib/middlewares/AuthMiddleware.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/AuthInterface.d.ts

@@ -1,10 +0,0 @@
-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>;
-}

package/lib/types/AuthInterface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });