@siran/auth-core 0.9.0 → 0.14.1

package/tests/application/policies/password-present.policy.test.ts

@@ -0,0 +1,55 @@
+import { PasswordPresentPolicy } from '@application/policies/password-present.policy.js';
+import { describe, expect, it } from 'vitest';
+
+describe('PasswordPresentPolicy', () => {
+  it('should return false when policy is disabled', async () => {
+    const policy = new PasswordPresentPolicy(false);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: '',
+    };
+
+    expect(await policy.isActive(method)).toBe(false);
+  });
+
+  it('should return true when policy is enabled and password is present', async () => {
+    const policy = new PasswordPresentPolicy(true);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: 'password123',
+    };
+
+    expect(await policy.isActive(method)).toBe(true);
+    expect(await policy.check(method)).toBe(true);
+  });
+
+  it('should return false when policy is enabled but password is missing', async () => {
+    const policy = new PasswordPresentPolicy(true);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: '',
+    };
+
+    expect(await policy.isActive(method)).toBe(true);
+    expect(await policy.check(method)).toBe(false);
+  });
+
+  it('should return false for non-password methods', async () => {
+    const policy = new PasswordPresentPolicy(true);
+    const otpMethod = {
+      type: 'otp' as const,
+      identifier: 'test@example.com',
+      code: '123456',
+    };
+
+    expect(await policy.isActive(otpMethod)).toBe(false);
+  });
+
+  it('should have correct error code', () => {
+    const policy = new PasswordPresentPolicy(true);
+    expect(policy.code).toBe('MISSING_PASSWORD');
+  });
+});

package/tests/application/policies/password-strength.policy.test.ts

@@ -0,0 +1,66 @@
+import { PasswordStrengthPolicy } from '@application/policies/password-strength.policy.js';
+import { describe, expect, it } from 'vitest';
+
+describe('PasswordStrengthPolicy', () => {
+  it('should return false when policy is disabled', async () => {
+    const policy = new PasswordStrengthPolicy(false);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: 'weak',
+    };
+
+    expect(await policy.isActive(method)).toBe(false);
+  });
+
+  it('should return true when policy is enabled and password meets minimum length', async () => {
+    const policy = new PasswordStrengthPolicy(true, 6);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: 'strong123',
+    };
+
+    expect(await policy.isActive(method)).toBe(true);
+    expect(await policy.check(method)).toBe(true);
+  });
+
+  it('should return false when policy is enabled but password is too short', async () => {
+    const policy = new PasswordStrengthPolicy(true, 12);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: 'short',
+    };
+
+    expect(await policy.isActive(method)).toBe(true);
+    expect(await policy.check(method)).toBe(false);
+  });
+
+  it('should use default minimum length of 8', async () => {
+    const policy = new PasswordStrengthPolicy(true);
+    const method = {
+      type: 'password' as const,
+      identifier: 'test@example.com',
+      password: '1234567', // 7 chars
+    };
+
+    expect(await policy.check(method)).toBe(false);
+  });
+
+  it('should return true for non-password methods', async () => {
+    const policy = new PasswordStrengthPolicy(true, 8);
+    const otpMethod = {
+      type: 'otp' as const,
+      identifier: 'test@example.com',
+      code: '123456',
+    };
+
+    expect(await policy.isActive(otpMethod)).toBe(false);
+  });
+
+  it('should have correct error code', () => {
+    const policy = new PasswordStrengthPolicy(true, 8);
+    expect(policy.code).toBe('WEAK_PASSWORD');
+  });
+});

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

@@ -8,7 +8,6 @@ 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 {
@@ -16,6 +15,5 @@ export function createAuthServiceMock(authService?: AuthServiceMock): AuthServic
     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/services/composite-auth.mock.ts

@@ -0,0 +1,18 @@
+import { AuthServicePort } from '@application/ports/auth-service.port.js';
+import { vi } from 'vitest';
+
+export function createPasswordAdapterMock(): AuthServicePort {
+  return {
+    authenticate: vi.fn(),
+    register: vi.fn(),
+    logout: vi.fn(),
+  };
+}
+
+export function createOAuthAdapterMock(): AuthServicePort {
+  return {
+    authenticate: vi.fn(),
+    register: vi.fn(),
+    logout: vi.fn(),
+  };
+}

package/tests/application/services/composite-auth.test.ts

@@ -0,0 +1,162 @@
+import type { AuthServicePort } from '@application/ports/auth-service.port.js';
+import { CompositeAuthService } from '@application/services/composite-auth.service.js';
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  createOAuthAdapterMock,
+  createPasswordAdapterMock,
+} from '../services/composite-auth.mock.js';
+
+describe('CompositeAuthService', () => {
+  let compositeAuthService: CompositeAuthService;
+  let mockPasswordAdapter: AuthServicePort;
+  let mockOAuthAdapter: AuthServicePort;
+
+  beforeEach(() => {
+    mockPasswordAdapter = createPasswordAdapterMock();
+    mockOAuthAdapter = createOAuthAdapterMock();
+
+    compositeAuthService = new CompositeAuthService({
+      password: mockPasswordAdapter,
+      oauth: mockOAuthAdapter,
+    });
+  });
+
+  it('should create composite service with method-based config', () => {
+    expect(compositeAuthService).toBeDefined();
+    expect(compositeAuthService.getMethodConfig()).toEqual({
+      password: mockPasswordAdapter,
+      oauth: mockOAuthAdapter,
+    });
+  });
+
+  it('should authenticate with password adapter', async () => {
+    const mockUser = {
+      id: 'test-id',
+      displayName: 'Test User',
+      status: 'active' as const,
+      isVerified: true,
+    };
+
+    (mockPasswordAdapter.authenticate as any).mockResolvedValue({
+      ok: true,
+      user: mockUser,
+    });
+
+    const result = await compositeAuthService.authenticate({
+      type: 'password',
+      identifier: 'test@example.com',
+      password: 'password',
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.user).toEqual(mockUser);
+    }
+    expect(mockPasswordAdapter.authenticate).toHaveBeenCalled();
+    expect(mockOAuthAdapter.authenticate).not.toHaveBeenCalled();
+  });
+
+  it('should authenticate with oauth adapter', async () => {
+    const mockUser = {
+      id: 'test-id',
+      displayName: 'Test User',
+      status: 'active' as const,
+      isVerified: true,
+    };
+
+    (mockOAuthAdapter.authenticate as any).mockResolvedValue({
+      ok: true,
+      user: mockUser,
+    });
+
+    const result = await compositeAuthService.authenticate({
+      type: 'oauth',
+      provider: 'google',
+      code: 'auth-code',
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.user).toEqual(mockUser);
+    }
+    expect(mockOAuthAdapter.authenticate).toHaveBeenCalled();
+    expect(mockPasswordAdapter.authenticate).not.toHaveBeenCalled();
+  });
+
+  it('should validate magic link token format', async () => {
+    const result = await compositeAuthService.authenticate({
+      type: 'magic_link',
+      token: 'short', // Too short
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBe('ADAPTER_UNAVAILABLE'); // No magic_link adapter configured
+    }
+  });
+
+  it('should return error for unsupported auth method', async () => {
+    const result = await compositeAuthService.authenticate({
+      type: 'unknown_method' as any, // Unsupported method type
+      token: 'magic-token',
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBe('ADAPTER_UNAVAILABLE');
+    }
+  });
+
+  it('should handle register with correct adapter', async () => {
+    const mockUser = {
+      id: 'test-id',
+      displayName: 'Test User',
+      status: 'active' as const,
+      isVerified: true,
+    };
+
+    (mockPasswordAdapter.register as any).mockResolvedValue({
+      ok: true,
+      user: mockUser,
+    });
+
+    const result = await compositeAuthService.register({
+      type: 'password',
+      identifier: 'test@example.com',
+      password: 'password',
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.user).toEqual(mockUser);
+    }
+    expect(mockPasswordAdapter.register).toHaveBeenCalled();
+  });
+
+  it('should validate OTP code format', async () => {
+    const result = await compositeAuthService.authenticate({
+      type: 'otp',
+      identifier: 'test@example.com',
+      code: '123', // Too short
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBe('ADAPTER_UNAVAILABLE'); // No OTP adapter configured
+    }
+  });
+
+  it('should demonstrate exact requested syntax', () => {
+    // This is exactly how the user wants to use it:
+    const engine = new CompositeAuthService({
+      password: createPasswordAdapterMock(),
+      oauth: createOAuthAdapterMock(),
+    });
+
+    expect(engine).toBeDefined();
+    expect(engine.getMethodConfig()).toEqual({
+      password: expect.any(Object),
+      oauth: expect.any(Object),
+    });
+  });
+});

package/tsconfig.lib.json

@@ -8,7 +8,7 @@
       "@domain/*": ["src/domain/*"],
       "@application/*": ["src/application/*"],
       "@infrastructure/*": ["src/infrastructure/*"],
-      "@root/*": ["src/*"],
+      "@root/*": ["src/*"]
     },
     "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
     "emitDeclarationOnly": true,
@@ -29,6 +29,7 @@
     "src/**/*.test.js",
     "src/**/*.spec.js",
     "src/**/*.test.jsx",
-    "src/**/*.spec.jsx"
+    "src/**/*.spec.jsx",
+    "src/**/*.example.ts"
   ]
 }

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

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