@strivacity/sdk-angular 3.0.3 → 4.0.0-beta.0

package/src/types/index.ts

@@ -0,0 +1,47 @@
+import type { SDKInitConfig, NativeFlowMessage, NativeParams, SessionData } from '@strivacity/sdk-core/types';
+import type { initFlow } from '@strivacity/sdk-core';
+import type { FallbackError } from '@strivacity/sdk-core/utils';
+
+export * from '@strivacity/sdk-core/types';
+
+/**
+ * Configuration used to initialize the Strivacity SDK on the client (browser) side.
+ */
+export type AngularSDKInitConfig = SDKInitConfig;
+
+/**
+ * The concrete SDK flow instance returned by `initFlow`, matching the configured `mode`.
+ */
+export type SDKInstance = ReturnType<typeof initFlow>;
+
+export type NativeLoginOptions = {
+	/**
+	 * Optional parameters to be passed to the login session request. These parameters will be sent to the `authorizationUri` endpoint.
+	 */
+	params?: NativeParams;
+
+	/**
+	 * Called when the user successfully completes the login flow.
+	 */
+	onLogin?: (session: SessionData) => void | Promise<void>;
+
+	/**
+	 * Called when the fallback flow is triggered, typically due to an error or unsupported environment.
+	 */
+	onFallback?: (error: FallbackError) => void | Promise<void>;
+
+	/**
+	 * Called when the login flow is closed by the user.
+	 */
+	onClose?: () => void | Promise<void>;
+
+	/**
+	 * Called when an error occurs during the login session initialization or flow.
+	 */
+	onError?: (error: Error) => void | Promise<void>;
+
+	/**
+	 * Called when a global message is received during the login flow.
+	 */
+	onGlobalMessage?: (message: NativeFlowMessage) => void | Promise<void>;
+};

package/src/types/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "./index.ts"
+  }
+}

package/testing/setup.ts

@@ -0,0 +1,10 @@
+import '@angular/compiler';
+import { afterEach } from 'vitest';
+import { getTestBed } from '@angular/core/testing';
+import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';
+
+getTestBed().initTestEnvironment(BrowserTestingModule, platformBrowserTesting());
+
+afterEach(() => {
+	getTestBed().resetTestingModule();
+});

package/testing/tests/auth.service.spec.ts

@@ -0,0 +1,236 @@
+import type { RedirectFlow } from '../../src/types';
+import { PLATFORM_ID, TransferState, inject } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { initFlow } from '@strivacity/sdk-core';
+import { StrivacityAuthService } from '../../src/lib/services/auth.service';
+import { STRIVACITY_SDK } from '../../src/lib/utils';
+import { SESSION_TRANSFER_KEY } from '../../src/server/session';
+import { flushPromises } from '@strivacity/testing/mocks/common';
+import { createMockFlow, createOptions } from '@strivacity/testing/mocks/sdk';
+import { mountWithProviders } from '../utils/testbed';
+
+vi.mock('@strivacity/sdk-core', async (importOriginal) => ({
+	...(await importOriginal<typeof import('@strivacity/sdk-core')>()),
+	initFlow: vi.fn(),
+}));
+
+function configure(flow: RedirectFlow, optionsOverrides: Record<string, unknown> = {}, extraProviders: Array<unknown> = []) {
+	vi.mocked(initFlow).mockReturnValue(flow as never);
+
+	const options = createOptions(optionsOverrides) as never;
+
+	TestBed.configureTestingModule({
+		providers: [{ provide: STRIVACITY_SDK, useValue: options }, StrivacityAuthService, ...(extraProviders as [])],
+	});
+
+	return { authService: TestBed.inject(StrivacityAuthService), options };
+}
+
+beforeEach(() => {
+	vi.mocked(initFlow).mockReset();
+});
+
+describe('StrivacityAuthService', () => {
+	test('initializes the underlying flow through core sdk initFlow with the config injected via STRIVACITY_SDK', () => {
+		const flow = createMockFlow<RedirectFlow>();
+		const { options } = configure(flow);
+
+		expect(initFlow).toHaveBeenCalledTimes(1);
+		expect(initFlow).toHaveBeenCalledWith(options);
+	});
+
+	test('exposes signals seeded from the flow instance after the initial session update settles', async () => {
+		const flow = createMockFlow<RedirectFlow>({
+			isAuthenticated: Promise.resolve(true),
+			language: 'hu-HU',
+			idTokenClaims: { sub: 'user-1' },
+			accessToken: 'access-token',
+			refreshToken: 'refresh-token',
+			accessTokenExpired: false,
+			accessTokenExpirationDate: 1234,
+		});
+		const { authService } = configure(flow);
+
+		expect(authService.loading()).toBe(true);
+
+		await flushPromises();
+
+		expect(authService.loading()).toBe(false);
+		expect(authService.isAuthenticated()).toBe(true);
+		expect(authService.language()).toBe('hu-HU');
+		expect(authService.idTokenClaims()).toEqual({ sub: 'user-1' });
+		expect(authService.accessToken()).toBe('access-token');
+		expect(authService.refreshToken()).toBe('refresh-token');
+		expect(authService.accessTokenExpired()).toBe(false);
+		expect(authService.accessTokenExpirationDate()).toBe(1234);
+	});
+
+	test('falls back null-ish flow values to the signals default (null) rather than storing them verbatim', async () => {
+		const flow = createMockFlow<RedirectFlow>({
+			idTokenClaims: undefined,
+			accessToken: undefined,
+			refreshToken: undefined,
+			accessTokenExpirationDate: undefined,
+		});
+		const { authService } = configure(flow);
+
+		await flushPromises();
+
+		expect(authService.idTokenClaims()).toBeNull();
+		expect(authService.accessToken()).toBeNull();
+		expect(authService.refreshToken()).toBeNull();
+		expect(authService.accessTokenExpirationDate()).toBeNull();
+	});
+
+	test('updates signals when the flow emits an event through subscribeToAllEvents', async () => {
+		const subscribeToAllEvents = vi.fn().mockReturnValue({ dispose: vi.fn() });
+		const flow = createMockFlow<RedirectFlow>({ subscribeToAllEvents });
+		const { authService } = configure(flow);
+		await flushPromises();
+
+		const onEvent = subscribeToAllEvents.mock.calls[0][0] as () => Promise<void>;
+		const mutableFlow = flow as unknown as { language: string; accessToken: string | null; isAuthenticated: Promise<boolean> };
+
+		mutableFlow.language = 'de-DE';
+		mutableFlow.accessToken = 'new-token';
+		mutableFlow.isAuthenticated = Promise.resolve(true);
+
+		await onEvent();
+		await flushPromises();
+
+		expect(authService.language()).toBe('de-DE');
+		expect(authService.accessToken()).toBe('new-token');
+		expect(authService.isAuthenticated()).toBe(true);
+	});
+
+	test('subscribeToAllEvents is subscribed to once on construction, wiring the internal signal-update callback', async () => {
+		const flow = createMockFlow<RedirectFlow>();
+		configure(flow);
+		await flushPromises();
+
+		expect(flow.subscribeToAllEvents).toHaveBeenCalledTimes(1);
+		expect(flow.subscribeToAllEvents).toHaveBeenCalledWith(expect.any(Function));
+	});
+
+	describe('SSR session hydration via TransferState', () => {
+		test('does not touch TransferState when serverSessionUri is not configured', () => {
+			const flow = createMockFlow<RedirectFlow>({ session: null });
+			const { authService } = configure(flow, { serverSessionUri: false });
+			const transferState = TestBed.inject(TransferState);
+
+			expect(transferState.hasKey(SESSION_TRANSFER_KEY)).toBe(false);
+			expect(authService.sdk.session).toBeNull();
+		});
+
+		test('leaves the flow untouched when serverSessionUri is configured but no session was transferred', () => {
+			const flow = createMockFlow<RedirectFlow>({ session: null });
+			const { authService } = configure(flow, { serverSessionUri: 'https://brandtegrity.io/session' }, [{ provide: PLATFORM_ID, useValue: 'browser' }]);
+
+			expect(authService.sdk.session).toBeNull();
+		});
+
+		test('hydrates the flow session from TransferState and removes the key when running in the browser', () => {
+			const flow = createMockFlow<RedirectFlow>({ session: null });
+			const session = { access_token: 'transferred-token' };
+
+			vi.mocked(initFlow).mockReturnValue(flow as never);
+			TestBed.configureTestingModule({
+				providers: [
+					{ provide: STRIVACITY_SDK, useValue: createOptions({ serverSessionUri: 'https://brandtegrity.io/session' }) },
+					{ provide: PLATFORM_ID, useValue: 'browser' },
+					StrivacityAuthService,
+				],
+			});
+
+			// setting the transferred value before the first inject() matters: StrivacityAuthService only reads it once, in its constructor
+			const transferState = TestBed.inject(TransferState);
+			transferState.set(SESSION_TRANSFER_KEY, session);
+
+			const authService = TestBed.inject(StrivacityAuthService);
+
+			expect(authService.sdk.session).toBe(session);
+			// the browser is done with the transferred value once hydrated - keeping it around would leak stale session data into TransferState's serialized snapshot
+			expect(transferState.hasKey(SESSION_TRANSFER_KEY)).toBe(false);
+		});
+
+		test('hydrates the flow session from TransferState but keeps the key when running on the server', () => {
+			const flow = createMockFlow<RedirectFlow>({ session: null });
+			const session = { access_token: 'transferred-token' };
+
+			vi.mocked(initFlow).mockReturnValue(flow as never);
+			TestBed.configureTestingModule({
+				providers: [
+					{ provide: STRIVACITY_SDK, useValue: createOptions({ serverSessionUri: 'https://brandtegrity.io/session' }) },
+					{ provide: PLATFORM_ID, useValue: 'server' },
+					StrivacityAuthService,
+				],
+			});
+
+			const transferState = TestBed.inject(TransferState);
+			transferState.set(SESSION_TRANSFER_KEY, session);
+
+			const authService = TestBed.inject(StrivacityAuthService);
+
+			expect(authService.sdk.session).toBe(session);
+			expect(transferState.hasKey(SESSION_TRANSFER_KEY)).toBe(true);
+		});
+	});
+
+	test('disposes the subscribeToAllEvents subscription when the owning injector is destroyed', () => {
+		const dispose = vi.fn();
+		const flow = createMockFlow<RedirectFlow>({ subscribeToAllEvents: vi.fn().mockReturnValue({ dispose }) });
+
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+		TestBed.configureTestingModule({ providers: [{ provide: STRIVACITY_SDK, useValue: createOptions() }] });
+
+		// StrivacityAuthService must be provided at the component's own injector (not the TestBed module injector) for
+		// fixture.destroy() to actually tear down the injector that owns its DestroyRef - see mountWithProviders' docstring.
+		const { destroy } = mountWithProviders([StrivacityAuthService], () => inject(StrivacityAuthService));
+
+		expect(flow.subscribeToAllEvents).toHaveBeenCalledTimes(1);
+		expect(dispose).not.toHaveBeenCalled();
+
+		destroy();
+
+		expect(dispose).toHaveBeenCalledTimes(1);
+	});
+
+	test.each([
+		['init', []],
+		['subscribeToEvent', ['loggedIn', vi.fn()]],
+		['checkAuthentication', [{ autoRefresh: false }]],
+		['tokenExchange', [{ code: 'abc' }]],
+		['handleCallback', ['https://brandtegrity.io/callback?code=abc']],
+		['refresh', []],
+		['revoke', []],
+		['logout', [{ postLogoutRedirectUri: 'https://brandtegrity.io' }]],
+		['login', [{ scopes: ['openid'] }]],
+		['register', [{ scopes: ['openid'] }]],
+		['entry', ['https://brandtegrity.io/entry']],
+	] as const)('%s calls through to the underlying flow instance with the same arguments and return value', async (method, args) => {
+		const resolvedValue = { ok: true };
+		const flow = createMockFlow<RedirectFlow>({ [method]: vi.fn().mockResolvedValue(resolvedValue) });
+		const { authService } = configure(flow);
+
+		const result = await (authService[method as keyof StrivacityAuthService] as (...a: Array<unknown>) => unknown)(...(args as Array<unknown>));
+
+		expect(flow[method as keyof RedirectFlow]).toHaveBeenCalledWith(...args);
+		expect(result).toEqual(resolvedValue);
+	});
+
+	test('subscribeToAllEvents on the service calls through to the flow instance for the caller-facing subscription', async () => {
+		const callback = vi.fn();
+		const disposeResult = { dispose: vi.fn() };
+		const flow = createMockFlow<RedirectFlow>();
+		vi.mocked(flow.subscribeToAllEvents).mockReturnValue(disposeResult);
+
+		const { authService } = configure(flow);
+		await flushPromises();
+
+		const result = authService.subscribeToAllEvents(callback);
+
+		expect(flow.subscribeToAllEvents).toHaveBeenLastCalledWith(callback);
+		expect(result).toBe(disposeResult);
+	});
+});

package/testing/tests/index.spec.ts

@@ -0,0 +1,193 @@
+import { describe, test, expect } from 'vitest';
+import * as clientIndex from '../../src/index';
+import * as serverIndex from '../../src/server/index';
+
+describe('client', () => {
+	test('should export the correct things', () => {
+		const expectedExports = [
+			'createBaseFlow',
+			'createEmbeddedFlow',
+			'createNativeFlow',
+			'createPopupFlow',
+			'createRedirectFlow',
+			'popupCallbackHandler',
+			'popupUrlHandler',
+			'redirectCallbackHandler',
+			'redirectUrlHandler',
+			'BACKCHANNEL_LOGOUT_EVENT',
+			'ConfigurationError',
+			'DEFAULT_COOKIE_MAX_AGE',
+			'DISALLOWED_PROXY_HEADERS',
+			'FallbackError',
+			'InternalError',
+			'NetworkError',
+			'OidcError',
+			'PopupBlockedError',
+			'PopupClosedError',
+			'ProtocolError',
+			'RETURN_TO_COOKIE',
+			'ServerError',
+			'SessionExpiredError',
+			'UnsupportedFlowError',
+			'assertWebAuthnCredential',
+			'buildAuthorizationUrl',
+			'buildCookieString',
+			'buildEndSessionUrl',
+			'createDefaultLogging',
+			'createHttpClient',
+			'createSession',
+			'createState',
+			'createWebAuthnCredential',
+			'decodeBase64URL',
+			'decodeJwt',
+			'decryptString',
+			'defaultOptions',
+			'encodeBase64URL',
+			'encryptString',
+			'exchangeCode',
+			'fetchFlowEntry',
+			'finalizeLoginSession',
+			'flushSetCookies',
+			'generateCodeChallenge',
+			'generateCodeVerifier',
+			'generateJwt',
+			'generateRandomHex',
+			'getDefaultFlowState',
+			'getDiscoveryDocument',
+			'getSDKOptions',
+			'getServerSDKOptions',
+			'injectScript',
+			'isSessionExpired',
+			'loadSession',
+			'parseCookieHeader',
+			'parseState',
+			'proxyResponse',
+			'pushSetCookie',
+			'refreshToken',
+			'revokeToken',
+			'serializeCookie',
+			'serializeSession',
+			'serializeState',
+			'submitLoginForm',
+			'throwHttpError',
+			'throwTokenEndpointError',
+			'timestamp',
+			'toSafeRedirect',
+			'unflattenObject',
+			'verifyIdToken',
+			'verifyJwt',
+			'StrivacityAuthService',
+			'StrivacityNativeLoginService',
+			'COOKIE_CONTEXT',
+			'COOKIE_CHUNK_SIZE',
+			'createCacheAPIStorage',
+			'createIndexedDBStorage',
+			'createLocalStorage',
+			'createMemoryStorage',
+			'createServerMemoryStorage',
+			'createSessionStorage',
+			'createWorkerStorage',
+			'handleWorkerStorageRequests',
+			'STRIVACITY_SDK',
+			'provideStrivacity',
+			'StrivacityAuthModule',
+		];
+
+		expect(Object.keys(clientIndex)).toEqual(expectedExports);
+	});
+});
+
+describe('server', () => {
+	test('should export the correct things', () => {
+		const expectedExports = [
+			'ConfigurationError',
+			'FallbackError',
+			'InternalError',
+			'NetworkError',
+			'OidcError',
+			'PopupBlockedError',
+			'PopupClosedError',
+			'ProtocolError',
+			'ServerError',
+			'SessionExpiredError',
+			'UnsupportedFlowError',
+			'throwHttpError',
+			'throwTokenEndpointError',
+			'createServerSDK',
+			'SESSION_TRANSFER_KEY',
+			'provideStrivacityServerSession',
+			'createSessionIdCookieStorage',
+			'COOKIE_CHUNK_SIZE',
+			'COOKIE_CONTEXT',
+			'createCacheAPIStorage',
+			'createEncryptedCookieStorage',
+			'createIndexedDBStorage',
+			'createLocalStorage',
+			'createMemoryStorage',
+			'createServerMemoryStorage',
+			'createServerStateStorage',
+			'createSessionStorage',
+			'createWorkerStorage',
+			'handleWorkerStorageRequests',
+			'AlgorithmTypeList',
+			'GrantTypeList',
+			'ResponseModeList',
+			'ResponseTypeList',
+			'SubjectTypeList',
+			'TokenEndpointAuthMethodList',
+			'toWebRequest',
+			'applyResponse',
+			'BACKCHANNEL_LOGOUT_EVENT',
+			'DEFAULT_COOKIE_MAX_AGE',
+			'DISALLOWED_PROXY_HEADERS',
+			'RETURN_TO_COOKIE',
+			'assertWebAuthnCredential',
+			'buildAuthorizationUrl',
+			'buildCookieString',
+			'buildEndSessionUrl',
+			'createDefaultLogging',
+			'createHttpClient',
+			'createSession',
+			'createState',
+			'createWebAuthnCredential',
+			'decodeBase64URL',
+			'decodeJwt',
+			'decryptString',
+			'defaultOptions',
+			'encodeBase64URL',
+			'encryptString',
+			'exchangeCode',
+			'fetchFlowEntry',
+			'finalizeLoginSession',
+			'flushSetCookies',
+			'generateCodeChallenge',
+			'generateCodeVerifier',
+			'generateJwt',
+			'generateRandomHex',
+			'getDefaultFlowState',
+			'getDiscoveryDocument',
+			'getSDKOptions',
+			'getServerSDKOptions',
+			'injectScript',
+			'isSessionExpired',
+			'loadSession',
+			'parseCookieHeader',
+			'parseState',
+			'proxyResponse',
+			'pushSetCookie',
+			'refreshToken',
+			'revokeToken',
+			'serializeCookie',
+			'serializeSession',
+			'serializeState',
+			'submitLoginForm',
+			'timestamp',
+			'toSafeRedirect',
+			'unflattenObject',
+			'verifyIdToken',
+			'verifyJwt',
+		];
+
+		expect(Object.keys(serverIndex)).toEqual(expectedExports);
+	});
+});