@descope/angular-sdk 0.0.0-next-cc7eda17-20231228 → 0.0.0-next-8c050e76-20231228

package/projects/angular-sdk/src/lib/components/sign-up-or-in-flow/sign-up-or-in-flow.component.spec.ts

@@ -1,53 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-import { SignUpOrInFlowComponent } from './sign-up-or-in-flow.component';
-import { DescopeComponent } from '../descope/descope.component';
-import { ngMocks } from 'ng-mocks';
-import createSdk from '@descope/web-js-sdk';
-import { DescopeAuthConfig } from '../../types/types';
-import mocked = jest.mocked;
-
-jest.mock('@descope/web-js-sdk');
-jest.mock('@descope/web-component', () => {
-	return jest.fn(() => {
-		// Create a mock DOM element
-		return document.createElement('descope-wc');
-	});
-});
-describe('SignUpOrInFlowComponent', () => {
-	let component: SignUpOrInFlowComponent;
-	let fixture: ComponentFixture<SignUpOrInFlowComponent>;
-	let mockedCreateSdk: jest.Mock;
-
-	beforeEach(() => {
-		mockedCreateSdk = mocked(createSdk);
-
-		mockedCreateSdk.mockReturnValue({
-			onSessionTokenChange: jest.fn(),
-			onUserChange: jest.fn()
-		});
-
-		TestBed.configureTestingModule({
-			providers: [
-				DescopeAuthConfig,
-				{
-					provide: DescopeAuthConfig,
-					useValue: {
-						projectId: 'someProject'
-					}
-				}
-			]
-		});
-
-		fixture = TestBed.createComponent(SignUpOrInFlowComponent);
-		component = fixture.componentInstance;
-		fixture.detectChanges();
-	});
-
-	it('should create and be correctly configured', () => {
-		expect(component).toBeTruthy();
-		const mockComponent = ngMocks.find<DescopeComponent>(
-			'[flowId=sign-up-or-in]'
-		).componentInstance;
-		expect(mockComponent.flowId).toStrictEqual('sign-up-or-in');
-	});
-});

package/projects/angular-sdk/src/lib/components/sign-up-or-in-flow/sign-up-or-in-flow.component.ts

@@ -1,32 +0,0 @@
-import { Component, EventEmitter, Input, Output } from '@angular/core';
-import { ILogger } from '@descope/web-component';
-import { DescopeComponent } from '../descope/descope.component';
-import { DescopeAuthConfig } from '../../types/types';
-
-@Component({
-	selector: 'descope-sign-up-or-in-flow',
-	standalone: true,
-	imports: [DescopeComponent],
-	templateUrl: './sign-up-or-in-flow.component.html'
-})
-export class SignUpOrInFlowComponent {
-	projectId: string;
-
-	@Input() locale: string;
-	@Input() theme: 'light' | 'dark' | 'os';
-	@Input() tenant: string;
-	@Input() telemetryKey: string;
-	@Input() redirectUrl: string;
-	@Input() autoFocus: true | false | 'skipFirstScreen';
-
-	@Input() debug: boolean;
-	@Input() errorTransformer: (error: { text: string; type: string }) => string;
-	@Input() logger: ILogger;
-
-	@Output() success: EventEmitter<void> = new EventEmitter<void>();
-	@Output() error: EventEmitter<void> = new EventEmitter<void>();
-
-	constructor(descopeConfig: DescopeAuthConfig) {
-		this.projectId = descopeConfig.projectId;
-	}
-}

package/projects/angular-sdk/src/lib/descope-auth.module.ts

@@ -1,46 +0,0 @@
-import {
-	CUSTOM_ELEMENTS_SCHEMA,
-	ModuleWithProviders,
-	NgModule,
-	Optional,
-	SkipSelf
-} from '@angular/core';
-import { DescopeComponent } from './components/descope/descope.component';
-import { SignInFlowComponent } from './components/sign-in-flow/sign-in-flow.component';
-import { SignUpFlowComponent } from './components/sign-up-flow/sign-up-flow.component';
-import { SignUpOrInFlowComponent } from './components/sign-up-or-in-flow/sign-up-or-in-flow.component';
-import { DescopeAuthConfig } from './types/types';
-
-@NgModule({
-	schemas: [CUSTOM_ELEMENTS_SCHEMA],
-	imports: [
-		DescopeComponent,
-		SignInFlowComponent,
-		SignUpFlowComponent,
-		SignUpOrInFlowComponent
-	],
-	exports: [
-		DescopeComponent,
-		SignInFlowComponent,
-		SignUpFlowComponent,
-		SignUpOrInFlowComponent
-	]
-})
-export class DescopeAuthModule {
-	constructor(@Optional() @SkipSelf() parentModule?: DescopeAuthModule) {
-		if (parentModule) {
-			throw new Error(
-				'DescopeAuthModule is already loaded. Import it only once'
-			);
-		}
-	}
-
-	static forRoot(
-		config?: DescopeAuthConfig
-	): ModuleWithProviders<DescopeAuthModule> {
-		return {
-			ngModule: DescopeAuthModule,
-			providers: [{ provide: DescopeAuthConfig, useValue: config }]
-		};
-	}
-}

package/projects/angular-sdk/src/lib/services/descope-auth.guard.spec.ts

@@ -1,76 +0,0 @@
-import { delay, Observable } from 'rxjs';
-import { ActivatedRoute, Router } from '@angular/router';
-import { descopeAuthGuard } from './descope-auth.guard';
-import { fakeAsync, TestBed, tick } from '@angular/core/testing';
-import { RouterTestingModule } from '@angular/router/testing';
-import { DescopeAuthService } from './descope-auth.service';
-
-describe('descopeAuthGuard', () => {
-	const authServiceMock = {
-		isAuthenticated: jest.fn()
-	};
-
-	const routerMock = {
-		navigate: jest.fn()
-	};
-
-	beforeEach(async () => {
-		await TestBed.configureTestingModule({
-			imports: [RouterTestingModule],
-			providers: [
-				{
-					provide: Router,
-					useValue: routerMock
-				},
-				{
-					provide: DescopeAuthService,
-					useValue: authServiceMock
-				},
-				{
-					provide: ActivatedRoute,
-					useValue: {
-						snapshot: {
-							data: {
-								descopeFallbackUrl: '/fallback'
-							}
-						}
-					}
-				}
-			]
-		});
-	});
-
-	it('return true if authenticated', fakeAsync(() => {
-		const activatedRoute = TestBed.inject(ActivatedRoute);
-		authServiceMock.isAuthenticated.mockReturnValue(true);
-		const guardResponse = TestBed.runInInjectionContext(() => {
-			return descopeAuthGuard(activatedRoute.snapshot) as Observable<boolean>;
-		});
-
-		let guardOutput = null;
-		guardResponse
-			.pipe(delay(100))
-			.subscribe((response) => (guardOutput = response));
-		tick(100);
-
-		expect(guardOutput).toBeTruthy();
-	}));
-
-	it('navigate to fallbackUrl when not auth', fakeAsync(() => {
-		const activatedRoute = TestBed.inject(ActivatedRoute);
-		authServiceMock.isAuthenticated.mockReturnValue(false);
-		routerMock.navigate.mockReturnValue([]);
-		const guardResponse = TestBed.runInInjectionContext(() => {
-			return descopeAuthGuard(activatedRoute.snapshot) as Observable<boolean>;
-		});
-
-		let guardOutput = null;
-		guardResponse
-			.pipe(delay(100))
-			.subscribe((response) => (guardOutput = response));
-		tick(100);
-
-		expect(guardOutput).toBeFalsy();
-		expect(routerMock.navigate).toHaveBeenCalledWith(['/fallback']);
-	}));
-});

package/projects/angular-sdk/src/lib/services/descope-auth.guard.ts

@@ -1,16 +0,0 @@
-import { inject } from '@angular/core';
-
-import { DescopeAuthService } from './descope-auth.service';
-import { ActivatedRouteSnapshot, Router } from '@angular/router';
-import { from, of } from 'rxjs';
-
-export const descopeAuthGuard = (route: ActivatedRouteSnapshot) => {
-	const authService = inject(DescopeAuthService);
-	const router = inject(Router);
-	const fallbackUrl = route.data['descopeFallbackUrl'];
-	const isAuthenticated = authService.isAuthenticated();
-	if (!isAuthenticated && !!fallbackUrl) {
-		return from(router.navigate([fallbackUrl]));
-	}
-	return of(isAuthenticated);
-};

package/projects/angular-sdk/src/lib/services/descope-auth.service.spec.ts

@@ -1,264 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-
-import { DescopeAuthService } from './descope-auth.service';
-import createSdk from '@descope/web-js-sdk';
-import mocked = jest.mocked;
-import { DescopeAuthConfig } from '../types/types';
-import { of, take, toArray } from 'rxjs';
-
-jest.mock('@descope/web-js-sdk');
-
-describe('DescopeAuthService', () => {
-	let service: DescopeAuthService;
-	let mockedCreateSdk: jest.Mock;
-	let windowSpy: jest.SpyInstance;
-	const onSessionTokenChangeSpy = jest.fn();
-	const onUserChangeSpy = jest.fn();
-	const getSessionTokenSpy = jest.fn();
-	const getRefreshTokenSpy = jest.fn();
-	const getJwtPermissionsSpy = jest.fn();
-	const getJwtRolesSpy = jest.fn();
-	const meSpy = jest.fn();
-	const refreshSpy = jest.fn();
-	const mockConfig: DescopeAuthConfig = {
-		projectId: 'someProject'
-	};
-
-	beforeEach(() => {
-		mockedCreateSdk = mocked(createSdk);
-		windowSpy = jest.spyOn(window, 'window', 'get');
-
-		mockedCreateSdk.mockReturnValue({
-			onSessionTokenChange: onSessionTokenChangeSpy,
-			onUserChange: onUserChangeSpy,
-			getSessionToken: getSessionTokenSpy,
-			getRefreshToken: getRefreshTokenSpy,
-			getJwtPermissions: getJwtPermissionsSpy,
-			getJwtRoles: getJwtRolesSpy,
-			me: meSpy,
-			refresh: refreshSpy
-		});
-
-		onSessionTokenChangeSpy.mockImplementation((fn) => fn());
-		onUserChangeSpy.mockImplementation((fn) => fn());
-
-		TestBed.configureTestingModule({
-			providers: [
-				DescopeAuthConfig,
-				{ provide: DescopeAuthConfig, useValue: mockConfig }
-			]
-		});
-		service = TestBed.inject(DescopeAuthService);
-	});
-
-	afterEach(() => {
-		getSessionTokenSpy.mockReset();
-		getRefreshTokenSpy.mockReset();
-		getJwtPermissionsSpy.mockReset();
-		getJwtRolesSpy.mockReset();
-	});
-
-	it('should be created', () => {
-		expect(service).toBeTruthy();
-		expect(mockedCreateSdk).toHaveBeenCalledWith(
-			expect.objectContaining(mockConfig)
-		);
-		expect(onSessionTokenChangeSpy).toHaveBeenCalled();
-		expect(onUserChangeSpy).toHaveBeenCalled();
-	});
-
-	describe('getSessionToken', () => {
-		it('should call getSessionToken from sdk', () => {
-			const token = 'abcd';
-			getSessionTokenSpy.mockReturnValueOnce(token);
-			const result = service.getSessionToken();
-			expect(getSessionTokenSpy).toHaveBeenCalled();
-			expect(result).toStrictEqual(token);
-		});
-
-		it('should warn when using getSessionToken in non browser environment', () => {
-			const warnSpy = jest.spyOn(console, 'warn');
-			windowSpy.mockImplementationOnce(() => undefined);
-
-			service.getSessionToken();
-
-			expect(warnSpy).toHaveBeenCalledWith(
-				'Get session token is not supported in SSR'
-			);
-			expect(getSessionTokenSpy).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('getRefreshToken', () => {
-		it('should call getRefreshToken from sdk', () => {
-			const token = 'abcd';
-			getRefreshTokenSpy.mockReturnValueOnce(token);
-			const result = service.getRefreshToken();
-			expect(getRefreshTokenSpy).toHaveBeenCalled();
-			expect(result).toStrictEqual(token);
-		});
-
-		it('should warn when using getRefreshToken in non browser environment', () => {
-			const warnSpy = jest.spyOn(console, 'warn');
-			windowSpy.mockImplementationOnce(() => undefined);
-
-			service.getRefreshToken();
-
-			expect(warnSpy).toHaveBeenCalledWith(
-				'Get refresh token is not supported in SSR'
-			);
-			expect(getRefreshTokenSpy).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('getJwtPermissions', () => {
-		it('should return permissions for token from sdk', () => {
-			const permissions = ['edit'];
-			getJwtPermissionsSpy.mockReturnValueOnce(permissions);
-			const result = service.getJwtPermissions('token');
-			expect(getJwtPermissionsSpy).toHaveBeenCalledWith('token', undefined);
-			expect(result).toStrictEqual(permissions);
-		});
-
-		it('should return empty array and log error when there is no token', () => {
-			const errorSpy = jest.spyOn(console, 'error');
-			getSessionTokenSpy.mockReturnValueOnce(null);
-			const result = service.getJwtPermissions();
-			expect(errorSpy).toHaveBeenCalledWith(
-				'Could not get JWT Permissions - not authenticated'
-			);
-			expect(getJwtPermissionsSpy).not.toHaveBeenCalled();
-			expect(result).toStrictEqual([]);
-		});
-	});
-
-	describe('getJwtRoles', () => {
-		it('should return roles for token from sdk', () => {
-			const roles = ['admin'];
-			getJwtRolesSpy.mockReturnValueOnce(roles);
-			const result = service.getJwtRoles('token');
-			expect(getJwtRolesSpy).toHaveBeenCalledWith('token', undefined);
-			expect(result).toStrictEqual(roles);
-		});
-
-		it('should return empty array and log error when there is no token', () => {
-			const errorSpy = jest.spyOn(console, 'error');
-			getSessionTokenSpy.mockReturnValueOnce(null);
-			const result = service.getJwtRoles();
-			expect(errorSpy).toHaveBeenCalledWith(
-				'Could not get JWT Roles - not authenticated'
-			);
-			expect(getJwtRolesSpy).not.toHaveBeenCalled();
-			expect(result).toStrictEqual([]);
-		});
-	});
-
-	describe('refreshSession', () => {
-		it('correctly handle descopeSession stream when session is successfully refreshed', (done: jest.DoneCallback) => {
-			refreshSpy.mockReturnValueOnce(
-				of({ ok: true, data: { sessionJwt: 'newToken' } })
-			);
-			// Taking 4 values from stream: first is initial value, next 3 are the result of refreshSession
-			service.session$.pipe(take(4), toArray()).subscribe({
-				next: (result) => {
-					expect(result.slice(1)).toStrictEqual([
-						{
-							isAuthenticated: false,
-							isSessionLoading: true,
-							sessionToken: undefined
-						},
-						{
-							isAuthenticated: true,
-							isSessionLoading: true,
-							sessionToken: 'newToken'
-						},
-						{
-							isAuthenticated: true,
-							isSessionLoading: false,
-							sessionToken: 'newToken'
-						}
-					]);
-					expect(service.isAuthenticated()).toBeTruthy();
-					done();
-				},
-				error: (err) => {
-					done.fail(err);
-				}
-			});
-			service.refreshSession().subscribe();
-		});
-
-		it('correctly handle descopeSession stream when refresh session failed', (done: jest.DoneCallback) => {
-			refreshSpy.mockReturnValueOnce(
-				of({ ok: false, data: { sessionJwt: 'newToken' } })
-			);
-			// Taking 4 values from stream: first is initial value, next 3 are the result of refreshSession
-			service.session$.pipe(take(4), toArray()).subscribe({
-				next: (result) => {
-					expect(result.slice(1)).toStrictEqual([
-						{
-							isAuthenticated: false,
-							isSessionLoading: true,
-							sessionToken: undefined
-						},
-						{
-							isAuthenticated: false,
-							isSessionLoading: true,
-							sessionToken: ''
-						},
-						{
-							isAuthenticated: false,
-							isSessionLoading: false,
-							sessionToken: ''
-						}
-					]);
-					expect(service.isAuthenticated()).toBeFalsy();
-					done();
-				},
-				error: (err) => {
-					done.fail(err);
-				}
-			});
-			service.refreshSession().subscribe();
-		});
-	});
-
-	describe('refreshUser', () => {
-		it('correctly handle descopeUser stream when user is successfully refreshed', (done: jest.DoneCallback) => {
-			meSpy.mockReturnValueOnce(of({ ok: true, data: { name: 'test' } }));
-			// Taking 4 values from stream: first is initial value, next 3 are the result of refreshUser
-			service.user$.pipe(take(4), toArray()).subscribe({
-				next: (result) => {
-					expect(result.slice(1)).toStrictEqual([
-						{ isUserLoading: true, user: undefined },
-						{ isUserLoading: true, user: { name: 'test' } },
-						{ isUserLoading: false, user: { name: 'test' } }
-					]);
-					done();
-				},
-				error: (err) => {
-					done.fail(err);
-				}
-			});
-			service.refreshUser().subscribe();
-		});
-
-		it('correctly handle descopeUser stream when refresh session failed', (done: jest.DoneCallback) => {
-			meSpy.mockReturnValueOnce(of({ ok: false }));
-			// Taking 3 values from stream: first is initial value, next 2 are the result of refreshUser
-			service.user$.pipe(take(3), toArray()).subscribe({
-				next: (result) => {
-					expect(result.slice(1)).toStrictEqual([
-						{ isUserLoading: true, user: undefined },
-						{ isUserLoading: false, user: undefined }
-					]);
-					done();
-				},
-				error: (err) => {
-					done.fail(err);
-				}
-			});
-			service.refreshUser().subscribe();
-		});
-	});
-});

package/projects/angular-sdk/src/lib/services/descope-auth.service.ts

@@ -1,176 +0,0 @@
-import { Injectable } from '@angular/core';
-import type { UserResponse } from '@descope/web-js-sdk';
-import createSdk from '@descope/web-js-sdk';
-import { BehaviorSubject, finalize, Observable, tap } from 'rxjs';
-import { observabilify, Observablefied } from '../utils/helpers';
-import { baseHeaders, isBrowser } from '../utils/constants';
-import { DescopeAuthConfig } from '../types/types';
-
-type DescopeSDK = ReturnType<typeof createSdk>;
-type AngularDescopeSDK = Observablefied<DescopeSDK>;
-
-export interface DescopeSession {
-	isAuthenticated: boolean;
-	isSessionLoading: boolean;
-	sessionToken: string | null;
-}
-
-export type DescopeUser = { user?: UserResponse; isUserLoading: boolean };
-
-@Injectable({
-	providedIn: 'root'
-})
-export class DescopeAuthService {
-	public descopeSdk: AngularDescopeSDK;
-	private readonly sessionSubject: BehaviorSubject<DescopeSession>;
-	private readonly userSubject: BehaviorSubject<DescopeUser>;
-	readonly session$: Observable<DescopeSession>;
-	readonly user$: Observable<DescopeUser>;
-
-	constructor(config: DescopeAuthConfig) {
-		this.descopeSdk = observabilify<DescopeSDK>(
-			createSdk({
-				...config,
-				persistTokens: isBrowser() as true,
-				autoRefresh: isBrowser() as true,
-				baseHeaders
-			})
-		);
-
-		this.sessionSubject = new BehaviorSubject<DescopeSession>({
-			isAuthenticated: false,
-			isSessionLoading: false,
-			sessionToken: ''
-		});
-		this.session$ = this.sessionSubject.asObservable();
-		this.userSubject = new BehaviorSubject<DescopeUser>({
-			isUserLoading: false
-		});
-		this.user$ = this.userSubject.asObservable();
-		this.descopeSdk.onSessionTokenChange(this.setSession.bind(this));
-		this.descopeSdk.onUserChange(this.setUser.bind(this));
-	}
-
-	refreshSession() {
-		const beforeRefreshSession = this.sessionSubject.value;
-		this.sessionSubject.next({
-			...beforeRefreshSession,
-			isSessionLoading: true
-		});
-		return this.descopeSdk.refresh().pipe(
-			tap((data) => {
-				const afterRequestSession = this.sessionSubject.value;
-				if (data.ok && data.data) {
-					this.sessionSubject.next({
-						...afterRequestSession,
-						sessionToken: data.data.sessionJwt,
-						isAuthenticated: !!data.data.sessionJwt
-					});
-				} else {
-					this.sessionSubject.next({
-						...afterRequestSession,
-						sessionToken: '',
-						isAuthenticated: false
-					});
-				}
-			}),
-			finalize(() => {
-				const afterRefreshSession = this.sessionSubject.value;
-				this.sessionSubject.next({
-					...afterRefreshSession,
-					isSessionLoading: false
-				});
-			})
-		);
-	}
-
-	refreshUser() {
-		const beforeRefreshUser = this.userSubject.value;
-		this.userSubject.next({
-			...beforeRefreshUser,
-			isUserLoading: true
-		});
-		return this.descopeSdk.me().pipe(
-			tap((data) => {
-				const afterRequestUser = this.userSubject.value;
-				if (data.data) {
-					this.userSubject.next({
-						...afterRequestUser,
-						user: {
-							...data.data
-						}
-					});
-				}
-			}),
-			finalize(() => {
-				const afterRefreshUser = this.userSubject.value;
-				this.userSubject.next({
-					...afterRefreshUser,
-					isUserLoading: false
-				});
-			})
-		);
-	}
-
-	getSessionToken() {
-		if (isBrowser()) {
-			return (
-				this.descopeSdk as AngularDescopeSDK & {
-					getSessionToken: () => string | null;
-				}
-			).getSessionToken();
-		}
-		console.warn('Get session token is not supported in SSR');
-		return '';
-	}
-
-	getRefreshToken() {
-		if (isBrowser()) {
-			return (
-				this.descopeSdk as AngularDescopeSDK & {
-					getRefreshToken: () => string | null;
-				}
-			).getRefreshToken();
-		}
-		this.descopeSdk.getJwtPermissions;
-		console.warn('Get refresh token is not supported in SSR');
-		return '';
-	}
-
-	getJwtPermissions(token = this.getSessionToken(), tenant?: string) {
-		if (token === null) {
-			console.error('Could not get JWT Permissions - not authenticated');
-			return [];
-		}
-		return this.descopeSdk.getJwtPermissions(token, tenant);
-	}
-
-	getJwtRoles(token = this.getSessionToken(), tenant?: string) {
-		if (token === null) {
-			console.error('Could not get JWT Roles - not authenticated');
-			return [];
-		}
-		return this.descopeSdk.getJwtRoles(token, tenant);
-	}
-
-	isAuthenticated() {
-		return this.sessionSubject.value.isAuthenticated;
-	}
-
-	private setSession(sessionToken: string | null) {
-		const currentSession = this.sessionSubject.value;
-		this.sessionSubject.next({
-			sessionToken,
-			isAuthenticated: !!sessionToken,
-			isSessionLoading: currentSession.isSessionLoading
-		});
-	}
-
-	private setUser(user: UserResponse) {
-		const currentUser = this.userSubject.value;
-		this.userSubject.next({
-			isUserLoading: currentUser.isUserLoading,
-			user
-		});
-	}
-}