@siran/auth-core 0.1.1 → 0.9.0

package/.vscode/settings.json

@@ -0,0 +1,21 @@
+{
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.codeActionsOnSave": {
+    "source.fixAll": "explicit",
+    "source.organizeImports": "explicit",
+    "source.fixAll.eslint": "explicit"
+  },
+  "eslint.enable": true,
+  "eslint.run": "onSave",
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact"
+  ],
+  "editor.tabSize": 2,
+  "editor.detectIndentation": false,
+  "editor.insertSpaces": true,
+  "editor.formatOnSaveMode": "file",
+}

package/CHANGELOG.md

@@ -1,3 +1,98 @@
+## 0.9.0 (2026-01-24)
+
+### 🚀 Features
+
+- Introduce AuthEngine and related components for enhanced authentication flow ([fe11cd9](https://github.com/narisraz/auth/commit/fe11cd9))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.8.1 (2026-01-24)
+
+### 🩹 Fixes
+
+- Update error handling in registerUser to include violatedPolicies ([80c2363](https://github.com/narisraz/auth/commit/80c2363))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.8.0 (2026-01-24)
+
+### 🚀 Features
+
+- Enhance AuthResult and PreRegisterPolicy for detailed error reporting ([492bf1a](https://github.com/narisraz/auth/commit/492bf1a))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.7.0 (2026-01-24)
+
+### 🚀 Features
+
+- Add isActive method to PreRegisterPolicy and update user registration logic ([2fdb3d3](https://github.com/narisraz/auth/commit/2fdb3d3))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.6.0 (2026-01-24)
+
+### 🚀 Features
+
+- Enhance user registration with pre-register policy validation ([6ae97bb](https://github.com/narisraz/auth/commit/6ae97bb))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.5.0 (2026-01-24)
+
+### 🚀 Features
+
+- Add user existence check to registration process ([cd6e3b9](https://github.com/narisraz/auth/commit/cd6e3b9))
+
+### 🩹 Fixes
+
+- Restore export of authenticate-user use case in index file ([aec572f](https://github.com/narisraz/auth/commit/aec572f))
+- Update user registration tests for accurate assertions ([5c0e047](https://github.com/narisraz/auth/commit/5c0e047))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.4.0 (2026-01-23)
+
+### 🚀 Features
+
+- Introduce AuthPreferencesService for flexible account verification handling ([63490c6](https://github.com/narisraz/auth/commit/63490c6))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.3.0 (2026-01-23)
+
+### 🚀 Features
+
+- Extend authentication logic to include account verification status ([e7d5ffa](https://github.com/narisraz/auth/commit/e7d5ffa))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
+## 0.2.0 (2026-01-23)
+
+### 🚀 Features
+
+- Enhance user authentication to handle account status ([0188b61](https://github.com/narisraz/auth/commit/0188b61))
+
+### ❤️ Thank You
+
+- Naris Razafimahatratra
+
 ## 0.1.1 (2026-01-23)
 
 ### 🩹 Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siran/auth-core",
-  "version": "0.1.1",
+  "version": "0.9.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/application/ports/auth-preference-service.port.ts

@@ -0,0 +1,9 @@
+export type AuthPreferences = {
+  allowLoginWithNotVerifiedAccount: boolean;
+  allowDuplicatedAccount: boolean;
+};
+
+export interface AuthPreferencesServicePort {
+  getAuthPreferences(): Promise<AuthPreferences>;
+}
+

package/src/application/ports/auth-service.port.ts

@@ -6,15 +6,23 @@ export type AuthMethod =
   | { type: "magic_link"; token: string }
   | { type: "oauth"; provider: "google" | "github" | "apple" | "facebook"; code: string };
 
-export type AuthErrorCode = "INVALID_CREDENTIALS" | "ACCOUNT_DISABLED" | "ACCOUNT_LOCKED";
+export type AuthErrorCode =
+  | "INVALID_CREDENTIALS"
+  | "ACCOUNT_DISABLED"
+  | "ACCOUNT_NOT_VERIFIED"
+  | "ACCOUNT_LOCKED"
+  | "PRE_REGISTER_POLICY_VIOLATED";
 
-export type AuthResult =
-  | { ok: true; user: UserAccount }
-  | { ok: false; error: AuthErrorCode };
+export type AuthResultSuccess = { ok: true; user: UserAccount };
+export type AuthResultFailure = { ok: false; error: AuthErrorCode; violatedPolicies: string[] };
+
+export type AuthResult = AuthResultSuccess | AuthResultFailure;
 
 export interface AuthServicePort {
   authenticate(method: AuthMethod): Promise<AuthResult>;
+  register(method: AuthMethod): Promise<AuthResult>;
   logout(): Promise<void>;
+  userExists(method: AuthMethod): Promise<boolean>;
 }
 
 

package/src/application/ports/pre-register-policy.port.ts

@@ -0,0 +1,7 @@
+import { AuthMethod } from "./auth-service.port.js";
+
+export interface PreRegisterPolicy {
+  code: string;
+  check: (method: AuthMethod) => Promise<boolean>;
+  isActive: (method: AuthMethod) => Promise<boolean>;
+}

package/src/application/services/account-already-exists.service.ts

@@ -0,0 +1,20 @@
+
+import { AuthMethod, AuthServicePort } from "@application/ports/auth-service.port.js";
+import { PreRegisterPolicy } from "@application/ports/pre-register-policy.port.js";
+
+export class AccountAlreadyExistsPolicy implements PreRegisterPolicy {
+  constructor(
+    private readonly authService: AuthServicePort,
+    private readonly enabled: boolean,
+  ) { }
+
+  code: string = 'ACCOUNT_ALREADY_EXISTS';
+
+  async check(method: AuthMethod): Promise<boolean> {
+    return this.authService.userExists(method);
+  }
+
+  async isActive(method: AuthMethod): Promise<boolean> {
+    return this.enabled;
+  }
+}

package/src/application/use-cases/authenticate-user.ts

@@ -1,8 +1,21 @@
+import { AuthPreferencesServicePort } from "@application/ports/auth-preference-service.port.js";
+import type { AuthMethod, AuthResult } from "@application/ports/auth-service.port.js";
 import { AuthServicePort } from "@application/ports/auth-service.port.js";
-import type { AuthMethod } from "@application/ports/auth-service.port.js";
 
 
 export const authenticateUser =
-  (authService: AuthServicePort) =>
-  (method: AuthMethod) =>
-    authService.authenticate(method);
+  (authService: AuthServicePort, authPreferencesService: AuthPreferencesServicePort) =>
+    async (method: AuthMethod): Promise<AuthResult> => {
+      const result = await authService.authenticate(method);
+      if (!result.ok) {
+        return { ok: false, error: result.error, violatedPolicies: [] };
+      }
+      if (result.user.status === 'disabled') {
+        return { ok: false, error: 'ACCOUNT_DISABLED', violatedPolicies: [] };
+      }
+      const preferences = await authPreferencesService.getAuthPreferences();
+      if (!result.user.isVerified && !preferences.allowLoginWithNotVerifiedAccount) {
+        return { ok: false, error: 'ACCOUNT_NOT_VERIFIED', violatedPolicies: [] };
+      }
+      return { ok: true, user: result.user };
+    }

package/src/application/use-cases/register-user.ts

@@ -0,0 +1,28 @@
+import { AuthMethod, AuthResult, AuthServicePort } from "@application/ports/auth-service.port.js";
+import { PreRegisterPolicy } from "@application/ports/pre-register-policy.port.js";
+
+export const registerUser =
+  (authService: AuthServicePort, policies: PreRegisterPolicy[]) =>
+    async (method: AuthMethod): Promise<AuthResult> => {
+      const activePolicies = await Promise.all(policies
+        .map(async policy => ({
+          isActive: await policy.isActive(method),
+          value: policy,
+        }))
+      );
+      const results = await Promise.all(activePolicies
+        .filter(policy => policy.isActive)
+        .map(async policy => ({
+          code: policy.value.code,
+          ok: await policy.value.check(method),
+        })));
+      const violdatedPolicies = results.filter(result => !result.ok);
+      if (violdatedPolicies.length > 0) {
+        return {
+          ok: false,
+          error: 'PRE_REGISTER_POLICY_VIOLATED',
+          violatedPolicies: violdatedPolicies.map(result => result.code)
+        };
+      }
+      return authService.register(method);
+    };

package/src/auth-engine.factory.ts

@@ -0,0 +1,28 @@
+import { AuthPreferencesServicePort } from "@application/ports/auth-preference-service.port.js";
+import { AuthServicePort } from "@application/ports/auth-service.port.js";
+import { PreRegisterPolicy } from "@application/ports/pre-register-policy.port.js";
+import { AccountAlreadyExistsPolicy } from "@application/services/account-already-exists.service.js";
+import { authenticateUser } from "@application/use-cases/authenticate-user.js";
+import { registerUser } from "@application/use-cases/register-user.js";
+import { AuthEngine } from "@root/auth-engine.js";
+
+export class AuthEngineFactory {
+  static async create(
+    authService: AuthServicePort,
+    authPreferencesService: AuthPreferencesServicePort,
+    basePolicies: PreRegisterPolicy[],
+  ): Promise<AuthEngine> {
+    const preferences = await authPreferencesService.getAuthPreferences();
+
+    const policies = [
+      ...basePolicies,
+      new AccountAlreadyExistsPolicy(authService, !preferences.allowDuplicatedAccount),
+    ];
+
+    return new AuthEngine({
+      register: registerUser(authService, policies),
+      authenticate: authenticateUser(authService, authPreferencesService),
+      logout: () => authService.logout(),
+    });
+  }
+}

package/src/auth-engine.ts

@@ -0,0 +1,25 @@
+import { AuthMethod, AuthResult } from "@application/ports/auth-service.port.js";
+
+export interface AuthActions {
+  register(method: AuthMethod): Promise<AuthResult>;
+  authenticate(method: AuthMethod): Promise<AuthResult>;
+  logout(): Promise<void>;
+}
+
+export class AuthEngine implements AuthActions {
+  constructor(
+    private readonly useCases: AuthActions,
+  ) { }
+
+  async register(method: AuthMethod): Promise<AuthResult> {
+    return this.useCases.register(method);
+  }
+
+  async authenticate(method: AuthMethod): Promise<AuthResult> {
+    return await this.useCases.authenticate(method);
+  }
+
+  async logout(): Promise<void> {
+    return await this.useCases.logout();
+  }
+}

package/src/domain/user-account.ts

@@ -1,22 +1,16 @@
 export type UserStatus = "active" | "disabled" | "lockedTemporarily";
 
-export type UserRole = "parent" | "staff" | "admin" | "student" | "teacher";
-
 /**
  * Domaine: compte utilisateur Sekoliko.
  * Indépendant de toute technologie (pas de dépendance à Supabase ou React).
  */
 export interface UserAccount {
   id: string;
-  establishmentIds: string[];
   displayName: string;
-  firstName?: string;
-  lastName?: string;
-  contactEmail: string;
   status: UserStatus;
-  roles: UserRole[];
-  failedLoginAttempts: number;
-  lastFailedLoginAt: Date | null;
+  failedLoginAttempts?: number;
+  lastFailedLoginAt?: Date | null;
+  isVerified?: boolean;
 }
 
 export const canLogin = (user: UserAccount): boolean =>

package/src/index.ts

@@ -2,10 +2,15 @@
  * Domain
  */
 export * from '@domain/user-account.js';
-export * from '@domain/session.js';
 
 /**
  * Application
  */
-export * from '@application/use-cases/authenticate-user.js';
 export * from '@application/ports/auth-service.port.js';
+export * from '@application/ports/pre-register-policy.port.js';
+
+/**
+ * Auth Engine
+ */
+export * from '@root/auth-engine.factory.js';
+export * from '@root/auth-engine.js';

package/tests/application/ports/auth-preferences-service.port.mock.ts

@@ -0,0 +1,14 @@
+import { AuthPreferences, AuthPreferencesServicePort } from "@application/ports/auth-preference-service.port.js";
+import { vi } from "vitest";
+
+interface AuthPreferencesServiceMock {
+    getAuthPreferences?: () => Promise<AuthPreferences>;
+}
+
+export function createAuthPreferencesServiceMock(
+    authPreferencesService?: AuthPreferencesServiceMock,
+): AuthPreferencesServicePort {
+    return {
+        getAuthPreferences: authPreferencesService?.getAuthPreferences ?? vi.fn().mockResolvedValue({ allowLoginWithNotVerifiedAccount: false }),
+    };
+}

package/tests/application/ports/auth-service.port.mock.ts

@@ -0,0 +1,21 @@
+import { AuthMethod, AuthResult, AuthServicePort } from "@application/ports/auth-service.port.js";
+import { UserAccount } from "@domain/user-account.js";
+import { vi } from "vitest";
+
+const activeUser: UserAccount = { id: '1', displayName: 'test@test.com', status: 'active', isVerified: true };
+
+interface AuthServiceMock {
+  authenticate?: (method: AuthMethod) => Promise<AuthResult>;
+  register?: (method: AuthMethod) => Promise<AuthResult>;
+  logout?: () => Promise<void>;
+  userExists?: (method: AuthMethod) => Promise<boolean>;
+}
+
+export function createAuthServiceMock(authService?: AuthServiceMock): AuthServicePort {
+  return {
+    authenticate: authService?.authenticate ?? vi.fn().mockResolvedValue({ ok: true, user: activeUser }),
+    logout: authService?.logout ?? vi.fn().mockResolvedValue(undefined),
+    register: authService?.register ?? vi.fn().mockResolvedValue({ ok: true, user: activeUser }),
+    userExists: authService?.userExists ?? vi.fn().mockResolvedValue(false),
+  };
+}

package/tests/application/ports/pre-register-policy.port.mock.ts

@@ -0,0 +1,16 @@
+import { AuthMethod } from "@application/ports/auth-service.port.js";
+import { PreRegisterPolicy } from "@application/ports/pre-register-policy.port.js";
+
+export interface PreRegisterPolicyMock {
+  check?: (method: AuthMethod) => Promise<boolean>;
+  isActive?: (method: AuthMethod) => Promise<boolean>;
+  code?: string;
+}
+
+export function createPreRegisterPolicyMock(preRegisterPolicy?: PreRegisterPolicyMock): PreRegisterPolicy {
+  return {
+    check: preRegisterPolicy?.check ?? vi.fn().mockResolvedValue(true),
+    isActive: preRegisterPolicy?.isActive ?? vi.fn().mockResolvedValue(false),
+    code: preRegisterPolicy?.code ?? 'POLICY_ERROR',
+  };
+}

package/tests/application/use-cases/authenticate-user.test.ts

@@ -1,25 +1,72 @@
 import { authenticateUser } from "@application/use-cases/authenticate-user.js";
-import { AuthServicePort } from "@application/ports/auth-service.port.js";
+import { createAuthPreferencesServiceMock } from "@tests/application/ports/auth-preferences-service.port.mock.js";
+import { createAuthServiceMock } from "@tests/application/ports/auth-service.port.mock.js";
+import { inactiveUser, notVerifiedUser } from "@tests/domain/user-account.data.js";
 import { describe, expect, it, vi } from "vitest";
 
 describe('AuthenticateUser', () => {
   it('should authenticate a user', async () => {
-    const authService: AuthServicePort = {
-      authenticate: vi.fn().mockResolvedValue({ ok: true, user: { id: '1', email: 'test@test.com' } }),
-      logout: vi.fn().mockResolvedValue(undefined),
-    };
-    const loginUser = authenticateUser(authService);
-    const user = await loginUser({ type: 'password', identifier: 'test@test.com', password: 'test' });
-    expect(user).toEqual({ ok: true, user: { id: '1', email: 'test@test.com' } });
+    // Given
+    const authService = createAuthServiceMock();
+    const authPreferencesService = createAuthPreferencesServiceMock();
+    const loginUser = authenticateUser(authService, authPreferencesService);
+    // When
+    const result = await loginUser({ type: 'password', identifier: 'test@test.com', password: 'test' });
+    // Then
+    expect(result.ok).toBe(true);
   });
 
   it('should return an error if the authentication fails', async () => {
-    const authService: AuthServicePort = {
+    // Given
+    const authService = createAuthServiceMock({
       authenticate: vi.fn().mockResolvedValue({ ok: false, error: 'INVALID_CREDENTIALS' }),
-      logout: vi.fn().mockResolvedValue(undefined),
-    };
-    const loginUser = authenticateUser(authService);
+    });
+    const authPreferencesService = createAuthPreferencesServiceMock();
+    // When
+    const loginUser = authenticateUser(authService, authPreferencesService);
+    const user = await loginUser({ type: 'password', identifier: 'test@test.com', password: 'test' });
+    // Then
+    expect(user).toEqual({ ok: false, error: 'INVALID_CREDENTIALS', violatedPolicies: [] });
+  });
+
+  it('should not be possible to authenticate with deactivated account', async () => {
+    // Given
+    const authService = createAuthServiceMock({
+      authenticate: vi.fn().mockResolvedValue({ ok: true, user: inactiveUser }),
+    });
+    const authPreferencesService = createAuthPreferencesServiceMock();
+    // When
+    const loginUser = authenticateUser(authService, authPreferencesService);
     const user = await loginUser({ type: 'password', identifier: 'test@test.com', password: 'test' });
-    expect(user).toEqual({ ok: false, error: 'INVALID_CREDENTIALS' });
+    // Then
+    expect(user).toEqual({ ok: false, error: 'ACCOUNT_DISABLED', violatedPolicies: [] });
+  });
+
+  it('should not be possible to authenticate with not verified account', async () => {
+    // Given
+    const authService = createAuthServiceMock({
+      authenticate: vi.fn().mockResolvedValue({ ok: true, user: notVerifiedUser }),
+    });
+    const authPreferencesService = createAuthPreferencesServiceMock();
+    // When
+    const loginUser = authenticateUser(authService, authPreferencesService);
+    // Then
+    const result = await loginUser({ type: 'password', identifier: 'test@test.com', password: 'test' });
+    expect(result).toEqual({ ok: false, error: 'ACCOUNT_NOT_VERIFIED', violatedPolicies: [] });
+  });
+
+  it('should be possible to authenticate with not verified account if unckeched in settings', async () => {
+    // Given
+    const authService = createAuthServiceMock({
+      authenticate: vi.fn().mockResolvedValue({ ok: true, user: notVerifiedUser }),
+    });
+    const authPreferencesService = createAuthPreferencesServiceMock({
+      getAuthPreferences: vi.fn().mockResolvedValue({ allowLoginWithNotVerifiedAccount: true }),
+    });
+    // When
+    const loginUser = authenticateUser(authService, authPreferencesService);
+    // Then
+    const result = await loginUser({ type: 'password', identifier: 'test@test.com', password: 'test' });
+    expect(result.ok).toEqual(true);
   });
-});
+});

package/tests/application/use-cases/register-user.test.ts

@@ -0,0 +1,89 @@
+import { AuthMethod, AuthResultFailure } from "@application/ports/auth-service.port.js";
+import { registerUser } from "@application/use-cases/register-user.js";
+import { createAuthServiceMock } from "@tests/application/ports/auth-service.port.mock.js";
+import { createPreRegisterPolicyMock } from "@tests/application/ports/pre-register-policy.port.mock.js";
+import { describe, expect, it } from "vitest";
+
+describe('RegisterUser', () => {
+  it('should register a user', async () => {
+    // Given
+    const authService = createAuthServiceMock();
+    const policy = createPreRegisterPolicyMock();
+    const signUpUser = registerUser(authService, [policy]);
+    // When
+    const result = await signUpUser(
+      { type: 'password', identifier: 'test@test.com', password: 'test' },
+    );
+    // Then
+    expect(result.ok).toBe(true);
+  });
+
+  it('should fail to register a user if a pre-register policy is violated', async () => {
+    // Given
+    const authService = createAuthServiceMock();
+    const policy = createPreRegisterPolicyMock({
+      code: 'POLICY_ERROR',
+      check: vi.fn().mockResolvedValue(false),
+      isActive: vi.fn().mockResolvedValue(true),
+    });
+    const method: AuthMethod = { type: 'password', identifier: 'test@test.com', password: 'test' };
+    const signUpUser = registerUser(authService, [policy]);
+    // When
+    const result = await signUpUser(method);
+    // Then
+    expect(policy.check).toHaveBeenCalledWith(method);
+    expect(authService.register).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      ok: false,
+      error: 'PRE_REGISTER_POLICY_VIOLATED',
+      violatedPolicies: ['POLICY_ERROR']
+    } as AuthResultFailure);
+  });
+
+  it('should fail to register a user if active pre-register policies are violated', async () => {
+    // Given
+    const authService = createAuthServiceMock();
+    const policy1 = createPreRegisterPolicyMock({
+      code: 'POLICY_1_ERROR',
+      check: vi.fn().mockResolvedValue(false),
+      isActive: vi.fn().mockResolvedValue(false),
+    });
+    const policy2 = createPreRegisterPolicyMock({
+      code: 'POLICY_2_ERROR',
+      check: vi.fn().mockResolvedValue(false),
+      isActive: vi.fn().mockResolvedValue(true),
+    });
+    const method: AuthMethod = { type: 'password', identifier: 'test@test.com', password: 'test' };
+    const signUpUser = registerUser(authService, [policy1, policy2]);
+    // When
+    const result = await signUpUser(method);
+    // Then
+    expect(policy1.isActive).toHaveBeenCalledWith(method);
+    expect(policy2.isActive).toHaveBeenCalledWith(method);
+    expect(policy1.check).not.toHaveBeenCalled();
+    expect(policy2.check).toHaveBeenCalledWith(method);
+    expect(authService.register).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      ok: false,
+      error: 'PRE_REGISTER_POLICY_VIOLATED',
+      violatedPolicies: ['POLICY_2_ERROR']
+    } as AuthResultFailure);
+  });
+
+  it('should register a user if the pre-register policy is deactivated', async () => {
+    // Given
+    const authService = createAuthServiceMock();
+    const policy = createPreRegisterPolicyMock({
+      isActive: vi.fn().mockResolvedValue(false),
+    });
+    const method: AuthMethod = { type: 'password', identifier: 'test@test.com', password: 'test' };
+    const signUpUser = registerUser(authService, [policy]);
+    // When
+    const result = await signUpUser(method);
+    // Then
+    expect(policy.isActive).toHaveBeenCalledWith(method);
+    expect(policy.check).not.toHaveBeenCalled();
+    expect(authService.register).toHaveBeenCalledWith(method);
+    expect(result).toEqual({ ok: true, user: { id: '1', displayName: 'test@test.com', status: 'active', isVerified: true } });
+  });
+});

package/tests/domain/user-account.data.ts

@@ -0,0 +1,5 @@
+import { UserAccount } from "@domain/user-account.js";
+
+export const activeUser: UserAccount = { id: '1', displayName: 'test@test.com', status: 'active', isVerified: true };
+export const inactiveUser: UserAccount = { id: '1', displayName: 'test@test.com', status: 'disabled', isVerified: true };
+export const notVerifiedUser: UserAccount = { id: '1', displayName: 'test@test.com', status: 'active', isVerified: false };

package/tsconfig.lib.json

@@ -7,6 +7,8 @@
     "paths": {
       "@domain/*": ["src/domain/*"],
       "@application/*": ["src/application/*"],
+      "@infrastructure/*": ["src/infrastructure/*"],
+      "@root/*": ["src/*"],
     },
     "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
     "emitDeclarationOnly": true,

package/tsconfig.spec.json

@@ -4,7 +4,9 @@
     "baseUrl": ".",
     "paths": {
       "@domain/*": ["src/domain/*"],
-      "@application/*": ["src/application/*"]
+      "@application/*": ["src/application/*"],
+      "@infrastructure/*": ["src/infrastructure/*"],
+      "@tests/*": ["tests/*"]
     },
     "outDir": "./out-tsc/vitest",
     "types": [
@@ -30,6 +32,16 @@
     "tests/**/*.test.jsx",
     "tests/**/*.spec.jsx",
     "tests/**/*.d.ts",
+    "tests/**/*.mock.ts",
+    "tests/**/*.mock.tsx",
+    "tests/**/*.mock.js",
+    "tests/**/*.mock.jsx",
+    "tests/**/*.mock.d.ts",
+    "tests/**/*.mock.json",
+    "tests/**/*.mock.yaml",
+    "tests/**/*.mock.yml",
+    "tests/**/*.mock.xml",
+    "tests/**/*.data.ts",
   ],
   "references": [
     {

package/vite.config.mts

@@ -1,7 +1,7 @@
 /// <reference types='vitest' />
+import * as path from 'path';
 import { defineConfig } from 'vite';
 import dts from 'vite-plugin-dts';
-import * as path from 'path';
 import tsconfigPaths from 'vite-tsconfig-paths';
 
 export default defineConfig(() => ({
@@ -18,6 +18,9 @@ export default defineConfig(() => ({
     alias: {
       '@domain': path.resolve(__dirname, 'src/domain'),
       '@application': path.resolve(__dirname, 'src/application'),
+      '@infrastructure': path.resolve(__dirname, 'src/infrastructure'),
+      '@root': path.resolve(__dirname, 'src'),
+      '@tests': path.resolve(__dirname, 'tests'),
     },
   },
   // Uncomment this if you are using workers.

package/src/domain/session.ts

@@ -1,16 +0,0 @@
-/**
- * Domaine: session utilisateur Sekoliko.
- * Ne contient pas de détails d’implémentation (cookies, tokens, etc.).
- */
-export interface Session {
-  id: string;
-  userId: string;
-  createdAt: Date;
-  lastActivityAt: Date;
-  expiresAt: Date;
-}
-
-export const isSessionActive = (session: Session, now: Date = new Date()): boolean =>
-  now < session.expiresAt;
-
-