@strivacity/sdk-svelte 3.0.2 → 4.0.0-beta.0

package/testing/tests/components.spec.ts

@@ -0,0 +1,183 @@
+import type { StyAuthProviderProps, RedirectFlow } from '../../src/types';
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { initFlow } from '@strivacity/sdk-core';
+import { flushPromises } from '@strivacity/testing/mocks/common';
+import { createMockFlow } from '@strivacity/testing/mocks/sdk';
+import { mountAuthProvider, settle, unmount } from '../utils/mount';
+
+vi.mock('@strivacity/sdk-core', async (importOriginal) => ({
+	...(await importOriginal<typeof import('@strivacity/sdk-core')>()),
+	initFlow: vi.fn(),
+}));
+
+const options: StyAuthProviderProps['options'] = {
+	mode: 'redirect',
+	issuer: 'https://brandtegrity.io',
+	clientId: 'client-id',
+	redirectUri: 'https://brandtegrity.io/callback',
+};
+
+describe('createStyAuthProvider', () => {
+	beforeEach(() => {
+		vi.mocked(initFlow).mockReset();
+	});
+
+	test('initializes the underlying flow through core sdk initFlow with the given options', async () => {
+		const flow = createMockFlow<RedirectFlow>();
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		await mountAuthProvider(options);
+
+		expect(initFlow).toHaveBeenCalledTimes(1);
+		expect(initFlow).toHaveBeenCalledWith(options);
+	});
+
+	test('subscribes to all sdk events on mount and disposes the subscription on unmount', async () => {
+		const dispose = vi.fn();
+		const flow = createMockFlow<RedirectFlow>({ subscribeToAllEvents: vi.fn().mockReturnValue({ dispose }) });
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		const { instance } = await mountAuthProvider(options);
+
+		expect(flow.subscribeToAllEvents).toHaveBeenCalledTimes(1);
+		expect(flow.subscribeToAllEvents).toHaveBeenCalledWith(expect.any(Function));
+
+		await unmount(instance as never);
+
+		expect(dispose).toHaveBeenCalledTimes(1);
+	});
+
+	test('provides its context to descendant components via useStrivacity', async () => {
+		const flow = createMockFlow<RedirectFlow>();
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		const { instance } = await mountAuthProvider(options);
+
+		expect(instance.getChildContextValue()?.sdk).toBe(flow);
+	});
+
+	test.each([
+		['init', [], undefined],
+		['subscribeToEvent', ['loggedIn', vi.fn()], { dispose: vi.fn() }],
+		['checkAuthentication', [{ autoRefresh: false }], true],
+		['tokenExchange', [{ code: 'abc' }], undefined],
+		['handleCallback', ['https://brandtegrity.io/callback?code=abc'], undefined],
+		['refresh', [], undefined],
+		['revoke', [], undefined],
+		['logout', [{ postLogoutRedirectUri: 'https://brandtegrity.io' }], undefined],
+		['login', [{ scopes: ['openid'] }], undefined],
+		['register', [{ scopes: ['openid'] }], undefined],
+		['entry', ['https://brandtegrity.io/entry'], undefined],
+	] as const)('%s calls through to the flow instance returned by core sdk', async (method, args, resolvedValue) => {
+		const flow = createMockFlow<RedirectFlow>({ [method]: vi.fn().mockReturnValue(resolvedValue) });
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		const { instance } = await mountAuthProvider(options);
+		const context = instance.getContextValue();
+
+		const result = await (context[method] as (...a: Array<unknown>) => unknown)(...args);
+
+		expect(flow[method as keyof RedirectFlow]).toHaveBeenCalledWith(...args);
+		expect(result).toEqual(resolvedValue);
+	});
+
+	test('subscribeToAllEvents on the context calls through to the flow instance', async () => {
+		const callback = vi.fn();
+		const disposeResult = { dispose: vi.fn() };
+		const flow = createMockFlow<RedirectFlow>();
+		vi.mocked(flow.subscribeToAllEvents).mockReturnValue(disposeResult);
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		const { instance } = await mountAuthProvider(options);
+		// the mount-time subscription happens first; this is the caller-facing pass-through
+		const result = instance.getContextValue().subscribeToAllEvents(callback);
+
+		expect(flow.subscribeToAllEvents).toHaveBeenLastCalledWith(callback);
+		expect(result).toBe(disposeResult);
+	});
+
+	test('exposes reactive state 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,
+		});
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		const { instance } = await mountAuthProvider(options);
+		const context = instance.getContextValue();
+
+		expect(context.loading).toBe(false);
+		expect(context.isAuthenticated).toBe(true);
+		expect(context.language).toBe('hu-HU');
+		expect(context.idTokenClaims).toEqual({ sub: 'user-1' });
+		expect(context.accessToken).toBe('access-token');
+		expect(context.refreshToken).toBe('refresh-token');
+		expect(context.accessTokenExpired).toBe(false);
+		expect(context.accessTokenExpirationDate).toBe(1234);
+	});
+
+	test('reactive state updates when the flow emits an event', async () => {
+		const subscribeToAllEvents = vi.fn().mockReturnValue({ dispose: vi.fn() });
+		const flow = createMockFlow<RedirectFlow>({ subscribeToAllEvents });
+		vi.mocked(initFlow).mockReturnValue(flow as never);
+
+		const { instance } = await mountAuthProvider(options);
+		const context = instance.getContextValue();
+
+		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(context.language).toBe('de-DE');
+		expect(context.accessToken).toBe('new-token');
+		expect(context.isAuthenticated).toBe(true);
+	});
+
+	describe('session seeding', () => {
+		test('assigns the given session to the flow instance once known', async () => {
+			const flow = createMockFlow<RedirectFlow>();
+			vi.mocked(initFlow).mockReturnValue(flow as never);
+			const session = { access_token: 'access-token' } as never;
+
+			await mountAuthProvider(options, session);
+
+			// $state proxies assigned objects, so the flow ends up holding a reactive proxy of `session` rather than
+			// the exact same reference; compare by value instead.
+			expect(flow.session).toEqual(session);
+		});
+
+		test('reacts to the session getter changing after mount', async () => {
+			const flow = createMockFlow<RedirectFlow>();
+			vi.mocked(initFlow).mockReturnValue(flow as never);
+
+			const { instance } = await mountAuthProvider(options, null);
+			expect(flow.session).toBeNull();
+
+			const newSession = { access_token: 'new-access-token' } as never;
+			instance.setSession(newSession);
+			await settle();
+
+			expect(flow.session).toEqual(newSession);
+		});
+
+		test('does not assign a falsy session to the flow instance', async () => {
+			const flow = createMockFlow<RedirectFlow>();
+			vi.mocked(initFlow).mockReturnValue(flow as never);
+
+			await mountAuthProvider(options, null);
+
+			expect(flow.session).toBeNull();
+		});
+	});
+});

package/testing/tests/errors.spec.ts

@@ -0,0 +1,10 @@
+import { test, expect } from 'vitest';
+import * as svelteErrors from '../../src/errors';
+import * as coreErrors from '@strivacity/sdk-core/utils/errors';
+
+test('re-exports error classes from the core sdk', () => {
+	const coreKeys = Object.keys(coreErrors);
+
+	expect(coreKeys.length).toBeGreaterThan(0);
+	expect(Object.keys(svelteErrors).sort()).toEqual(coreKeys.sort());
+});

package/testing/tests/hooks.spec.ts

@@ -0,0 +1,275 @@
+import type { SDKContext, NativeFlow, NativeFlowState, SessionData } from '../../src/types';
+import { describe, test, expect, vi } from 'vitest';
+import { FallbackError } from '@strivacity/sdk-core/utils/errors';
+import { flushPromises } from '@strivacity/testing/mocks/common';
+import { createMockFlow } from '@strivacity/testing/mocks/sdk';
+import {
+	mountStrivacityConsumer,
+	mountStrivacityConsumerWithoutProvider,
+	mountNativeLoginContextConsumerWithoutProvider,
+	mountWithNativeLogin,
+} from '../utils/mount';
+
+describe('useStrivacity', () => {
+	test('throws when used outside of a Strivacity SDK provider', () => {
+		expect(() => {
+			mountStrivacityConsumerWithoutProvider();
+		}).toThrow('Missing SDK context');
+	});
+
+	test('resolves to the context provided by an ancestor createStyAuthProvider/setContext call', async () => {
+		const sdk = {} as NativeFlow;
+		const context = { sdk } as unknown as SDKContext<NativeFlow>;
+
+		const { instance } = await mountStrivacityConsumer(context);
+
+		expect(instance.getContextValue().sdk).toBe(sdk);
+	});
+});
+
+describe('useNativeLoginContext', () => {
+	test('throws when used outside of a native login session', () => {
+		expect(() => {
+			mountNativeLoginContextConsumerWithoutProvider();
+		}).toThrow('Missing SDK native login context');
+	});
+
+	test('resolves to the same context object provided by an ancestor useNativeLogin call', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const { login, getChildContext } = await mountWithNativeLogin(sdk);
+
+		const injected = getChildContext();
+
+		expect(injected?.state).toBe(login.state);
+		expect(injected?.loading).toBe(login.loading);
+		expect(injected?.forms).toBe(login.forms);
+		expect(injected?.messages).toBe(login.messages);
+		expect(injected?.submitForm).toBe(login.submitForm);
+	});
+});
+
+describe('useNativeLogin', () => {
+	test('initializes the sdk and starts a session on mount, defaulting params to an empty object', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		await mountWithNativeLogin(sdk);
+
+		expect(sdk.init).toHaveBeenCalledTimes(1);
+		expect(sdk.startSession).toHaveBeenCalledWith({});
+	});
+
+	test('forwards the given login params to sdk.startSession', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		await mountWithNativeLogin(sdk, { params: { sessionId: 'session-1', language: 'hu-HU' } });
+
+		expect(sdk.startSession).toHaveBeenCalledWith({ sessionId: 'session-1', language: 'hu-HU' });
+	});
+
+	test('is loading until sdk.startSession resolves with a state that has no pending finalizeUrl', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+		const { login } = await mountWithNativeLogin(sdk);
+
+		expect(login.loading).toBe(false);
+	});
+
+	test('stays loading forever if sdk.startSession resolves with no state at all', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue(undefined);
+		const { login } = await mountWithNativeLogin(sdk);
+
+		expect(login.loading).toBe(true);
+	});
+
+	test('applies the returned flow state: resets per-form data, routes the global message, and keeps per-widget messages', async () => {
+		const state: NativeFlowState = {
+			hostedUrl: 'https://brandtegrity.io/hosted',
+			screen: 'identifier',
+			forms: [{ id: 'form1', type: 'form', widgets: [] }],
+			messages: {
+				global: { type: 'info', text: 'Welcome' },
+				form1: { field1: { type: 'error', text: 'Required' } },
+			},
+		};
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue(state);
+		const onGlobalMessage = vi.fn();
+
+		const { login } = await mountWithNativeLogin(sdk, { onGlobalMessage });
+
+		expect(onGlobalMessage).toHaveBeenCalledWith({ type: 'info', text: 'Welcome' });
+		expect(login.forms).toEqual({ form1: {} });
+		expect(login.messages).toEqual({ form1: { field1: { type: 'error', text: 'Required' } } });
+		expect(login.state).toEqual(state);
+	});
+
+	test('keeps loading while a finalizeUrl is still pending', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		vi.mocked(sdk.startSession).mockResolvedValue({ finalizeUrl: 'https://brandtegrity.io/finalize' });
+
+		const { login } = await mountWithNativeLogin(sdk);
+
+		expect(login.loading).toBe(true);
+	});
+
+	test('calls onLogin and leaves the tracked state untouched when the sdk already has a session', async () => {
+		const session = { access_token: 'access-token' } as unknown as SessionData;
+		const sdk = createMockFlow<NativeFlow>({ session });
+		vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+		const onLogin = vi.fn();
+
+		const { login } = await mountWithNativeLogin(sdk, { onLogin });
+
+		expect(onLogin).toHaveBeenCalledWith(session);
+		expect(login.state).toEqual({});
+	});
+
+	test('routes a FallbackError from sdk.startSession to onFallback and logs it', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const fallbackError = new FallbackError(new URL('https://brandtegrity.io/hosted'));
+		vi.mocked(sdk.startSession).mockRejectedValue(fallbackError);
+		const onFallback = vi.fn();
+
+		const { login } = await mountWithNativeLogin(sdk, { onFallback });
+
+		expect(onFallback).toHaveBeenCalledWith(fallbackError);
+		expect(sdk.logging!.error).toHaveBeenCalledWith('Fallback error occurred', fallbackError);
+		expect(login.loading).toBe(true);
+	});
+
+	test('routes a non-fallback error from sdk.startSession to onError and logs it', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const error = new Error('network down');
+		vi.mocked(sdk.startSession).mockRejectedValue(error);
+		const onError = vi.fn();
+
+		await mountWithNativeLogin(sdk, { onError });
+
+		expect(onError).toHaveBeenCalledWith(error);
+		expect(sdk.logging!.error).toHaveBeenCalledWith('Error starting session', error);
+	});
+
+	describe('submitForm', () => {
+		test('unflattens the tracked form values and calls through to sdk.submitForm', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			const initialForms = [{ id: 'form1', type: 'form' as const, widgets: [] }];
+			vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier', forms: initialForms });
+			vi.mocked(sdk.submitForm).mockResolvedValue({ screen: 'done' });
+
+			const { login } = await mountWithNativeLogin(sdk);
+
+			login.setFormValue('form1', 'address.city', 'Budapest');
+			login.setFormValue('form1', 'address.zip', '');
+
+			await login.submitForm('form1');
+			await flushPromises();
+
+			expect(sdk.submitForm).toHaveBeenCalledWith('form1', { address: { city: 'Budapest', zip: null } });
+			// unspecified fields on the new state fall back to what was already tracked (except messages, which always resets)
+			expect(login.state).toEqual({
+				hostedUrl: undefined,
+				finalizeUrl: undefined,
+				screen: 'done',
+				forms: initialForms,
+				layout: undefined,
+				messages: {},
+				branding: undefined,
+			});
+		});
+
+		test('uses a given custom body instead of the tracked form values', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			vi.mocked(sdk.submitForm).mockResolvedValue({ screen: 'done' });
+
+			const { login } = await mountWithNativeLogin(sdk);
+
+			await login.submitForm('form1', { raw: true });
+
+			expect(sdk.submitForm).toHaveBeenCalledWith('form1', { raw: true });
+		});
+
+		test('routes a FallbackError to onFallback', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			const fallbackError = new FallbackError(new URL('https://brandtegrity.io/hosted'));
+			vi.mocked(sdk.submitForm).mockRejectedValue(fallbackError);
+			const onFallback = vi.fn();
+
+			const { login } = await mountWithNativeLogin(sdk, { onFallback });
+
+			await login.submitForm('form1');
+
+			expect(onFallback).toHaveBeenCalledWith(fallbackError);
+			expect(sdk.logging!.error).toHaveBeenCalledWith('Fallback error occurred', fallbackError);
+		});
+
+		test('routes a non-fallback error to onError', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			const error = new Error('submit failed');
+			vi.mocked(sdk.submitForm).mockRejectedValue(error);
+			const onError = vi.fn();
+
+			const { login } = await mountWithNativeLogin(sdk, { onError });
+
+			await login.submitForm('form1');
+
+			expect(onError).toHaveBeenCalledWith(error);
+			expect(sdk.logging!.error).toHaveBeenCalledWith('Error submitting form', error);
+		});
+	});
+
+	test('setFormValue coerces empty strings to null and lazily creates the form bucket', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const { login } = await mountWithNativeLogin(sdk);
+
+		login.setFormValue('newForm', 'field', 'value');
+		login.setFormValue('newForm', 'other', '');
+
+		expect(login.forms.newForm).toEqual({ field: 'value', other: null });
+	});
+
+	test('setMessage lazily creates the message bucket for a form', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const { login } = await mountWithNativeLogin(sdk);
+
+		login.setMessage('newForm', 'field', { type: 'error', text: 'Required' });
+
+		expect(login.messages.newForm).toEqual({ field: { type: 'error', text: 'Required' } });
+	});
+
+	describe('triggerFallback', () => {
+		test('throws when no hosted URL is known yet', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			vi.mocked(sdk.startSession).mockResolvedValue({ screen: 'identifier' });
+			const { login } = await mountWithNativeLogin(sdk);
+
+			expect(() => login.triggerFallback()).toThrow('No hosted URL provided');
+			expect(sdk.logging!.error).toHaveBeenCalledWith('Fallback error', expect.any(Error));
+		});
+
+		test('calls onFallback with a FallbackError built from the known hosted URL', async () => {
+			const sdk = createMockFlow<NativeFlow>();
+			vi.mocked(sdk.startSession).mockResolvedValue({ hostedUrl: 'https://brandtegrity.io/hosted', screen: 'identifier' });
+			const onFallback = vi.fn();
+
+			const { login } = await mountWithNativeLogin(sdk, { onFallback });
+
+			login.triggerFallback('manual trigger');
+
+			expect(sdk.logging!.warn).toHaveBeenCalledWith('Triggering fallback due to: manual trigger');
+			expect(onFallback).toHaveBeenCalledWith(expect.any(FallbackError));
+			// triggerFallback builds the FallbackError's url from svelte/reactivity's SvelteURL rather than the plain URL constructor;
+			// it still compares equal to a plain URL through its string form.
+			expect((onFallback.mock.calls[0][0] as FallbackError).url.toString()).toBe('https://brandtegrity.io/hosted');
+		});
+	});
+
+	test('triggerClose calls onClose and logs', async () => {
+		const sdk = createMockFlow<NativeFlow>();
+		const onClose = vi.fn();
+		const { login } = await mountWithNativeLogin(sdk, { onClose });
+
+		login.triggerClose();
+
+		expect(onClose).toHaveBeenCalledTimes(1);
+		expect(sdk.logging!.debug).toHaveBeenCalledWith('Triggering close');
+	});
+});

package/testing/tests/index.spec.ts

@@ -0,0 +1,199 @@
+import { describe, test, expect } from 'vitest';
+import * as clientIndex from '../../src/client/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',
+			'createStyAuthProvider',
+			'STRIVACITY_SDK',
+			'STRIVACITY_LOGIN_CONTEXT',
+			'useStrivacity',
+			'useNativeLoginContext',
+			'useNativeLogin',
+			'COOKIE_CHUNK_SIZE',
+			'COOKIE_CONTEXT',
+			'createCacheAPIStorage',
+			'createEncryptedCookieStorage',
+			'createIndexedDBStorage',
+			'createLocalStorage',
+			'createMemoryStorage',
+			'createServerMemoryStorage',
+			'createServerStateStorage',
+			'createSessionIdCookieStorage',
+			'createSessionStorage',
+			'createWorkerStorage',
+			'handleWorkerStorageRequests',
+			'AlgorithmTypeList',
+			'GrantTypeList',
+			'ResponseModeList',
+			'ResponseTypeList',
+			'SubjectTypeList',
+			'TokenEndpointAuthMethodList',
+		];
+
+		expect(Object.keys(clientIndex)).toEqual(expectedExports);
+	});
+});
+
+describe('server', () => {
+	test('should export the correct things', () => {
+		const expectedExports = [
+			'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',
+			'createServerSDK',
+			'createSessionIdCookieStorage',
+			'COOKIE_CHUNK_SIZE',
+			'COOKIE_CONTEXT',
+			'createCacheAPIStorage',
+			'createEncryptedCookieStorage',
+			'createIndexedDBStorage',
+			'createLocalStorage',
+			'createMemoryStorage',
+			'createServerMemoryStorage',
+			'createServerStateStorage',
+			'createSessionStorage',
+			'createWorkerStorage',
+			'handleWorkerStorageRequests',
+			'AlgorithmTypeList',
+			'GrantTypeList',
+			'ResponseModeList',
+			'ResponseTypeList',
+			'SubjectTypeList',
+			'TokenEndpointAuthMethodList',
+		];
+
+		expect(Object.keys(serverIndex)).toEqual(expectedExports);
+	});
+});