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

package/testing/tests/server/plugin.spec.ts

@@ -0,0 +1,138 @@
+import type { NitroApp } from 'nitropack/types';
+import type { H3Event } from 'h3';
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createMockStorage, createServerOptions, getMockStorage } from '@strivacity/testing/mocks/sdk';
+import { createFakeH3Event } from '../../utils/http';
+
+beforeEach(() => {
+	vi.resetModules();
+});
+
+afterEach(() => {
+	vi.doUnmock('#imports');
+	vi.doUnmock('#strivacity-options-storage');
+	vi.doUnmock('#strivacity-options-stateStorage');
+	vi.doUnmock('#strivacity-options-logging');
+	vi.doUnmock('#strivacity-options-httpClient');
+});
+
+function createFakeNitroApp() {
+	const hook = vi.fn();
+
+	return { app: { hooks: { hook } } as unknown as NitroApp, hook };
+}
+
+async function installPlugin(strivacityConfig: Record<string, unknown>) {
+	vi.doMock('#imports', () => ({ useRuntimeConfig: () => ({ strivacity: strivacityConfig }) }));
+
+	const plugin = (await import('../../../src/runtime/server/plugins/auth.server')).default;
+	const { app, hook } = createFakeNitroApp();
+
+	plugin(app);
+
+	// setupAuthPlugin() is fired via `void` (not awaited) and chains several dynamic imports
+	// (the four '#strivacity-options-*' factories) before it registers the hook, which on a cold
+	// module cache (every test resets it) can outlast a single microtask tick.
+	await vi.waitFor(() => expect(hook).toHaveBeenCalled());
+	const requestHook = hook.mock.calls[0]?.[1] as ((event: H3Event) => void) | undefined;
+
+	return { hook, requestHook };
+}
+
+describe('auth.server nitro plugin', () => {
+	test('registers a "request" hook that wires a fully-shaped sdk onto the event context', async () => {
+		const storage = createMockStorage();
+		const stateStorage = createMockStorage();
+		const { hook, requestHook } = await installPlugin(createServerOptions({ storage, stateStorage }));
+
+		expect(hook).toHaveBeenCalledWith('request', expect.any(Function));
+
+		const event = { context: {} } as unknown as H3Event;
+		requestHook!(event);
+
+		const sdk = event.context.strivacity.sdk;
+		expect(sdk.options).toBeDefined();
+
+		for (const method of [
+			'getSession',
+			'updateSession',
+			'refreshSession',
+			'revokeSession',
+			'getEntrySession',
+			'completeLogin',
+			'logout',
+			'handleLogin',
+			'handleRegister',
+			'handleCallback',
+			'handleRefresh',
+			'handleRevoke',
+			'handleEntry',
+			'handleLogout',
+			'handleBackChannelLogout',
+			'handler',
+		] as const) {
+			expect(typeof sdk[method]).toBe('function');
+		}
+	});
+
+	test('delegates getSession/updateSession to the underlying base server sdk against the configured storage', async () => {
+		const storage = createMockStorage();
+		const stateStorage = createMockStorage();
+		const { requestHook } = await installPlugin(createServerOptions({ storage, stateStorage }));
+
+		const event = { context: {} } as unknown as H3Event;
+		requestHook!(event);
+		const sdk = event.context.strivacity.sdk;
+
+		await expect(sdk.getSession()).resolves.toBeNull();
+
+		const session = getMockStorage(storage).generateSession(undefined, null);
+		await sdk.updateSession(session);
+
+		await expect(sdk.getSession()).resolves.toEqual(session);
+	});
+
+	test('does not replace an sdk that a previous hook already wired onto the event context', async () => {
+		const { requestHook } = await installPlugin(createServerOptions({ storage: createMockStorage(), stateStorage: createMockStorage() }));
+
+		const existingSdk = { marker: 'existing' };
+		const event = { context: { strivacity: { sdk: existingSdk } } } as unknown as H3Event;
+		requestHook!(event);
+
+		expect(event.context.strivacity.sdk).toBe(existingSdk);
+	});
+
+	test('prefers a custom storage/stateStorage/logging/httpClient supplied through the #strivacity-options-* factories over the runtime config', async () => {
+		const customStorage = createMockStorage();
+		const customStateStorage = createMockStorage();
+		const customLogging = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+		const customHttpClient = { request: vi.fn(), sendTokenRequest: vi.fn() };
+
+		vi.doMock('#strivacity-options-storage', () => ({ default: () => customStorage }));
+		vi.doMock('#strivacity-options-stateStorage', () => ({ default: () => customStateStorage }));
+		vi.doMock('#strivacity-options-logging', () => ({ default: () => customLogging }));
+		vi.doMock('#strivacity-options-httpClient', () => ({ default: () => customHttpClient }));
+
+		const configuredStorage = createMockStorage();
+		const { requestHook } = await installPlugin(createServerOptions({ storage: configuredStorage, stateStorage: createMockStorage() }));
+
+		const event = { context: {} } as unknown as H3Event;
+		requestHook!(event);
+		const sdk = event.context.strivacity.sdk;
+
+		const session = getMockStorage(customStorage).generateSession(undefined, null);
+		await sdk.updateSession(session);
+
+		expect(getMockStorage(configuredStorage).keys()).toEqual([]);
+		await expect(sdk.getSession()).resolves.toEqual(session);
+	});
+
+	test('falls back to an encrypted cookie storage keyed by the configured secret when no storage is configured', async () => {
+		const { requestHook } = await installPlugin(createServerOptions({ storage: undefined, stateStorage: createMockStorage(), secret: 'secret' }));
+
+		const event = createFakeH3Event();
+
+		expect(() => requestHook!(event)).not.toThrow();
+		await expect(event.context.strivacity.sdk.getSession()).resolves.toBeNull();
+	});
+});

package/testing/tests/server/routes.spec.ts

@@ -0,0 +1,34 @@
+import type { H3Event } from 'h3';
+import { test, expect, vi } from 'vitest';
+import loginHandler from '../../../src/runtime/server/api/auth/login.get';
+import registerHandler from '../../../src/runtime/server/api/auth/register.get';
+import callbackHandler from '../../../src/runtime/server/api/auth/callback.get';
+import refreshHandler from '../../../src/runtime/server/api/auth/refresh.get';
+import revokeHandler from '../../../src/runtime/server/api/auth/revoke.get';
+import entryHandler from '../../../src/runtime/server/api/auth/entry.get';
+import logoutHandler from '../../../src/runtime/server/api/auth/logout.get';
+import backchannelLogoutHandler from '../../../src/runtime/server/api/auth/backchannel-logout.get';
+
+function createFakeEvent(sdk: Record<string, ReturnType<typeof vi.fn>>): H3Event {
+	return { context: { strivacity: { sdk } } } as unknown as H3Event;
+}
+
+test.each([
+	['login.get', loginHandler, 'handleLogin'],
+	['register.get', registerHandler, 'handleRegister'],
+	['callback.get', callbackHandler, 'handleCallback'],
+	['refresh.get', refreshHandler, 'handleRefresh'],
+	['revoke.get', revokeHandler, 'handleRevoke'],
+	['entry.get', entryHandler, 'handleEntry'],
+	['logout.get', logoutHandler, 'handleLogout'],
+	['backchannel-logout.get', backchannelLogoutHandler, 'handleBackChannelLogout'],
+] as const)('%s dispatches to sdk.%s with the event', async (_name, handler, sdkMethod) => {
+	const response = new Response(null, { status: 204 });
+	const sdk = { [sdkMethod]: vi.fn().mockResolvedValue(response) };
+	const event = createFakeEvent(sdk);
+
+	const result = await handler(event);
+
+	expect(sdk[sdkMethod]).toHaveBeenCalledWith(event);
+	expect(result).toBe(response);
+});

package/testing/tests/server/use-strivacity.spec.ts

@@ -0,0 +1,22 @@
+import type { H3Event } from 'h3';
+import { describe, test, expect } from 'vitest';
+import { useStrivacity } from '../../../src/runtime/server/composables/use-strivacity';
+
+describe('useStrivacity (server composable)', () => {
+	test('returns the sdk instance wired onto the event context by the auth.server nitro plugin', () => {
+		const sdk = { getSession: () => Promise.resolve(null) };
+		const event = { context: { strivacity: { sdk } } } as unknown as H3Event;
+
+		expect(useStrivacity(event)).toBe(sdk);
+	});
+
+	test('throws when called without an event', () => {
+		expect(() => useStrivacity(undefined as unknown as H3Event)).toThrow('useStrivacity() can not be called without passing an H3Event instance.');
+	});
+
+	// NOTE: the "throws when called from the client" guard (`if (import.meta.client)`) can't be
+	// exercised here - import.meta.client is only ever set to a truthy compile-time constant by
+	// Nuxt's own Vite plugin during a real build, which this bare vitest config doesn't run.
+	// import.meta.client is falsy in this harness, i.e. it always presents as "server", which is
+	// the environment this composable is actually meant to run in.
+});

package/testing/tests/storages-default.spec.ts

@@ -0,0 +1,151 @@
+import { describe, test, expect } from 'vitest';
+import { createEncryptedCookieStorage, createSessionIdCookieStorage } from '../../src/runtime/storages/default';
+import { createServerMemoryStorage } from '@strivacity/sdk-core/storages';
+import { flushSetCookies } from '@strivacity/sdk-core/utils';
+import { createFakeH3Event, getResponseCookies } from '../utils/http';
+
+function extractCookieHeader(cookies: Array<string>): string {
+	return cookies.map((cookie) => cookie.split(';')[0]).join('; ');
+}
+
+describe('createEncryptedCookieStorage', () => {
+	test('returns null for a key with no cookie at all', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+		const event = createFakeH3Event();
+
+		await expect(storage.get('sty.session', event)).resolves.toBeNull();
+	});
+
+	test('returns null/undefined and is a no-op when no event is provided to get/set/delete', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+
+		await expect(storage.get('sty.session', undefined)).resolves.toBeNull();
+		await expect(storage.set('sty.session', 'value', undefined)).resolves.toBeUndefined();
+		await expect(storage.delete('sty.session', undefined)).resolves.toBeUndefined();
+	});
+
+	test('round-trips a small value through a single encrypted cookie', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+		const outgoing = createFakeH3Event();
+
+		await storage.set('sty.session', 'small-value', outgoing);
+
+		const cookies = getResponseCookies(outgoing);
+		expect(cookies).toHaveLength(1);
+		expect(cookies[0]).toContain('sty.session=');
+
+		const incoming = createFakeH3Event(extractCookieHeader(cookies));
+
+		await expect(storage.get('sty.session', incoming)).resolves.toBe('small-value');
+	});
+
+	test('chunks a value larger than the cookie chunk size across multiple numbered cookies and reassembles it on read', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+		const outgoing = createFakeH3Event();
+		const largeValue = 'x'.repeat(10_000);
+
+		await storage.set('sty.session', largeValue, outgoing);
+
+		const cookies = getResponseCookies(outgoing);
+		expect(cookies.length).toBeGreaterThan(1);
+		expect(cookies.some((cookie) => cookie.startsWith('sty.session.0='))).toBe(true);
+		// set() always clears the base "sty.session" cookie first (via deleteCookie), so a Max-Age=0
+		// expiry for it is expected here; it must not carry an actual value alongside the chunks.
+		expect(cookies.some((cookie) => cookie.startsWith('sty.session=') && cookie.includes('Max-Age=0'))).toBe(true);
+
+		const incoming = createFakeH3Event(extractCookieHeader(cookies));
+
+		await expect(storage.get('sty.session', incoming)).resolves.toBe(largeValue);
+	});
+
+	test('first clears any previously set chunk cookie(s) for the key before writing a smaller value (avoids leaving stale chunks behind)', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+		const first = createFakeH3Event();
+
+		await storage.set('sty.session', 'x'.repeat(10_000), first);
+
+		// deleteCookie/setCookie only ever see the *incoming request's* cookies, so detecting (and
+		// clearing) the previous chunk cookies requires a fresh event carrying them as a real
+		// round-trip would - a second set() on the very same (response-only) event never can.
+		const second = createFakeH3Event(extractCookieHeader(getResponseCookies(first)));
+		await storage.set('sty.session', 'small-value-again', second);
+
+		const cookies = getResponseCookies(second);
+		const chunkCookies = cookies.filter((cookie) => cookie.startsWith('sty.session.'));
+		expect(chunkCookies.length).toBeGreaterThan(0);
+		expect(chunkCookies.every((cookie) => cookie.includes('Max-Age=0'))).toBe(true);
+
+		const incoming = createFakeH3Event(extractCookieHeader(cookies));
+		await expect(storage.get('sty.session', incoming)).resolves.toBe('small-value-again');
+	});
+
+	test('deletes the unchunked cookie and every numbered chunk cookie present on the incoming request', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+		const outgoing = createFakeH3Event();
+		await storage.set('sty.session', 'x'.repeat(10_000), outgoing);
+
+		// simulate the browser round-tripping the chunk cookies back on the delete request
+		const deleteEvent = createFakeH3Event(extractCookieHeader(getResponseCookies(outgoing)));
+		await storage.delete('sty.session', deleteEvent);
+
+		const expiredCookies = getResponseCookies(deleteEvent);
+		expect(expiredCookies.some((cookie) => cookie.startsWith('sty.session=') && cookie.includes('Max-Age=0'))).toBe(true);
+		expect(expiredCookies.some((cookie) => cookie.startsWith('sty.session.0=') && cookie.includes('Max-Age=0'))).toBe(true);
+		expect(expiredCookies.some((cookie) => cookie.startsWith('sty.session.1=') && cookie.includes('Max-Age=0'))).toBe(true);
+	});
+
+	test('deleting a key with no cookie at all still just expires the base cookie, without throwing', async () => {
+		const storage = createEncryptedCookieStorage('secret');
+		const event = createFakeH3Event();
+
+		await expect(storage.delete('sty.session', event)).resolves.toBeUndefined();
+		expect(getResponseCookies(event)[0]).toContain('Max-Age=0');
+	});
+
+	test('applies default cookie attributes (httpOnly, secure, lax) and honors overrides', async () => {
+		const defaultStorage = createEncryptedCookieStorage('secret');
+		const defaultEvent = createFakeH3Event();
+		await defaultStorage.set('sty.session', 'value', defaultEvent);
+		const [defaultCookie] = getResponseCookies(defaultEvent);
+
+		expect(defaultCookie).toContain('HttpOnly');
+		expect(defaultCookie).toContain('Secure');
+		expect(defaultCookie).toContain('SameSite=Lax');
+		expect(defaultCookie).toContain('Path=/');
+
+		const customStorage = createEncryptedCookieStorage('secret', { defaultCookieOptions: { sameSite: 'strict', maxAge: 60 } });
+		const customEvent = createFakeH3Event();
+		await customStorage.set('sty.session', 'value', customEvent);
+		const [customCookie] = getResponseCookies(customEvent);
+
+		expect(customCookie).toContain('SameSite=Strict');
+		expect(customCookie).toContain('Max-Age=60');
+	});
+});
+
+describe('createSessionIdCookieStorage', () => {
+	test('adapts the H3Event into a Request for the underlying core session-id cookie storage, round-tripping get/set through it', async () => {
+		const underlying = createServerMemoryStorage();
+		const storage = createSessionIdCookieStorage(underlying);
+		const outgoing = createFakeH3Event();
+
+		await storage.set('key', 'value', outgoing);
+
+		// createSessionIdCookieStorage (core) queues its Set-Cookie header in an internal cookie jar
+		// keyed by the event object, rather than writing through h3's response headers the way
+		// createEncryptedCookieStorage does - flushSetCookies() is how it's meant to be drained.
+		const response = flushSetCookies(outgoing, new Response());
+		const setCookie = response.headers.get('set-cookie');
+		expect(setCookie).toBeTruthy();
+
+		const incoming = createFakeH3Event(setCookie!.split(';')[0]);
+
+		await expect(storage.get('key', incoming)).resolves.toBe('value');
+	});
+
+	test('returns null when the incoming event carries no session-id cookie', async () => {
+		const storage = createSessionIdCookieStorage(createServerMemoryStorage());
+
+		await expect(storage.get('key', createFakeH3Event())).resolves.toBeNull();
+	});
+});

package/testing/tests/storages.spec.ts

@@ -0,0 +1,16 @@
+import { test, expect } from 'vitest';
+import * as nuxtStorages from '../../src/runtime/storages/core';
+import * as coreStorages from '@strivacity/sdk-core/storages';
+
+test('re-exports the client-safe storages from the core sdk', () => {
+	const coreKeys = Object.keys(coreStorages);
+
+	expect(coreKeys.length).toBeGreaterThan(0);
+
+	for (const key of Object.keys(nuxtStorages)) {
+		expect(coreKeys).toContain(key);
+	}
+
+	expect(nuxtStorages).not.toHaveProperty('createSessionIdCookieStorage');
+	expect(nuxtStorages).not.toHaveProperty('createEncryptedCookieStorage');
+});

package/testing/tests/utils.spec.ts

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

package/testing/utils/common.ts

@@ -0,0 +1,33 @@
+import type { App } from 'vue';
+import type { NativeFlow } from '@strivacity/sdk-core/types';
+import type { LoginContext, UseNativeLoginOptions } from '../../src/runtime/types';
+import { vi } from 'vitest';
+import { createApp } from 'vue';
+
+/**
+ * Points the mocked core `initFlow` at the given flow instance. Must be called before dynamically
+ * importing a composable that (transitively) calls `initFlow`, and after `vi.resetModules()` -
+ * resetting the module registry recreates the `@strivacity/sdk-core` mock (and its `initFlow`
+ * mock function) from scratch, so the previous test's `mockReturnValue` no longer applies.
+ */
+export async function mockInitFlow<T>(flow: T): Promise<void> {
+	const core = await import('@strivacity/sdk-core');
+	vi.mocked(core.initFlow).mockReturnValue(flow as never);
+}
+
+export async function mountWithNativeLogin(flow: NativeFlow, options: UseNativeLoginOptions = {}): Promise<{ app: App; login: LoginContext }> {
+	await mockInitFlow(flow);
+
+	const { useNativeLogin } = await import('../../src/runtime/composables/use-native-login');
+	let login!: LoginContext;
+	const app = createApp({
+		setup() {
+			login = useNativeLogin(options);
+
+			return () => null;
+		},
+	});
+	app.mount(document.createElement('div'));
+
+	return { app, login };
+}

package/testing/utils/http.ts

@@ -0,0 +1,58 @@
+import type { H3Event } from 'h3';
+import { vi } from 'vitest';
+
+/**
+ * Builds a minimal fake H3Event backed by a real Node-style req/res pair, since h3's
+ * getCookie/setCookie/deleteCookie read and write through `event.node.req`/`event.node.res`
+ * rather than through any adapter, and there is no lighter public h3 test helper for this.
+ */
+export function createFakeH3Event(cookieHeader = ''): H3Event {
+	const responseHeaders = new Map<string, string | Array<string>>();
+
+	const res = {
+		setHeader: vi.fn((name: string, value: string | Array<string>) => responseHeaders.set(name, value)),
+		getHeader: vi.fn((name: string) => responseHeaders.get(name)),
+		removeHeader: vi.fn((name: string) => responseHeaders.delete(name)),
+		appendHeader: vi.fn((name: string, value: string) => {
+			const existing = responseHeaders.get(name);
+
+			if (existing === undefined) {
+				responseHeaders.set(name, value);
+			} else {
+				responseHeaders.set(name, ([] as Array<string>).concat(existing, value));
+			}
+		}),
+	};
+
+	// toWebRequest() (used by createSessionIdCookieStorage) builds a Request from `event.headers` via
+	// `new Request(url, { headers })`. Under vitest's happy-dom environment that constructor silently
+	// drops the "cookie" header (a forbidden request header per the Fetch spec, unlike real Node's own
+	// fetch implementation, which preserves it) - so it's set here via `.set()` on an already-constructed
+	// Request instead, then exposed through `event.web.request`, which toWebRequest() returns as-is
+	// without reconstructing.
+	const webRequest = new Request('http://localhost/');
+	if (cookieHeader) {
+		webRequest.headers.set('cookie', cookieHeader);
+	}
+
+	return {
+		node: { req: { url: '/', method: 'GET', headers: { cookie: cookieHeader } }, res },
+		context: {},
+		path: '/',
+		method: 'GET',
+		headers: webRequest.headers,
+		web: { request: webRequest },
+	} as unknown as H3Event;
+}
+
+export function getResponseCookies(event: H3Event): Array<string> {
+	const setCookie = (event as unknown as { node: { res: { getHeader: (name: string) => string | Array<string> | undefined } } }).node.res.getHeader(
+		'set-cookie',
+	);
+
+	if (!setCookie) {
+		return [];
+	}
+
+	return Array.isArray(setCookie) ? setCookie : [setCookie];
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.nuxt/tsconfig.json"
+}

package/vite.config.mts

@@ -0,0 +1,20 @@
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from 'vitest/config';
+import { getVitestConfig } from '@strivacity/testing/vitest/config';
+
+// Nuxt's virtual/auto-import modules (#app, #imports, #strivacity-options-*) only exist inside a
+// running Nuxt dev/build context. Point them at local stubs so plain Vite/vitest can resolve the
+// bare specifiers at transform time; individual tests can still vi.mock() over these stubs.
+export default defineConfig({
+	test: getVitestConfig('nuxt'),
+	resolve: {
+		alias: {
+			'#app': fileURLToPath(new URL('./testing/stubs/app.ts', import.meta.url)),
+			'#imports': fileURLToPath(new URL('./testing/stubs/imports.ts', import.meta.url)),
+			'#strivacity-options-logging': fileURLToPath(new URL('./testing/stubs/options-logging.ts', import.meta.url)),
+			'#strivacity-options-httpClient': fileURLToPath(new URL('./testing/stubs/options-httpClient.ts', import.meta.url)),
+			'#strivacity-options-storage': fileURLToPath(new URL('./testing/stubs/options-storage.ts', import.meta.url)),
+			'#strivacity-options-stateStorage': fileURLToPath(new URL('./testing/stubs/options-stateStorage.ts', import.meta.url)),
+		},
+	},
+});

package/.nuxt/strivacity-sdk-logging.d.ts

@@ -1,13 +0,0 @@
-
-import type { SDKLogging } from '@strivacity/sdk-core';
-
-declare class CustomLogging implements SDKLogging {
-	xEventId: string | undefined;
-
-	debug(message: string): void;
-	info(message: string): void;
-	warn(message: string): void;
-	error(message: string, error: Error): void;
-}
-
-export default CustomLogging

package/.nuxt/strivacity-sdk-logging.mjs

@@ -1 +0,0 @@
-export default undefined

package/.nuxt/strivacity-sdk-storage.d.ts

@@ -1,10 +0,0 @@
-
-import type { SDKStorage } from '@strivacity/sdk-core';
-
-declare class CustomStorage implements SDKStorage {
-	get(key: string): Promise<string | null>;
-	delete(key: string): Promise<void>;
-	set(key: string, value: string): Promise<void>;
-}
-
-export default CustomStorage

package/.nuxt/strivacity-sdk-storage.mjs

@@ -1 +0,0 @@
-export default class l{async get(e){return await Promise.resolve(globalThis?.window?.localStorage?.getItem(e))}async delete(e){await Promise.resolve(globalThis?.window?.localStorage.removeItem(e))}async set(e,o){await Promise.resolve(globalThis?.window?.localStorage.setItem(e,o))}}

package/dist/runtime/composables.d.ts

@@ -1,12 +0,0 @@
-import type { PopupContext, RedirectContext, NativeContext } from '../types.js';
-export { createCredential, getCredential } from '@strivacity/sdk-core/utils/credentials';
-/**
- * Retrieves the Strivacity SDK context for Popup or Redirect flows.
- *
- * @template T The type of context, either PopupContext or RedirectContext.
- *
- * @throws {Error} If the Strivacity SDK context is not found.
- *
- * @returns {T} The Strivacity SDK context, typed as either PopupContext or RedirectContext or NativeContext.
- */
-export declare const useStrivacity: <T extends PopupContext | RedirectContext | NativeContext>() => T;

package/dist/runtime/composables.js

@@ -1,83 +0,0 @@
-import StorageClass from "#build/strivacity-sdk-storage";
-import LoggingClass from "#build/strivacity-sdk-logging";
-import { ref, useRuntimeConfig } from "#imports";
-import { initFlow } from "@strivacity/sdk-core";
-export { createCredential, getCredential } from "@strivacity/sdk-core/utils/credentials";
-const loadingRef = ref(true);
-const optionsRef = ref({});
-const isAuthenticatedRef = ref(false);
-const idTokenClaimsRef = ref(null);
-const accessTokenRef = ref(null);
-const refreshTokenRef = ref(null);
-const accessTokenExpiredRef = ref(true);
-const accessTokenExpirationDateRef = ref(null);
-let sdk;
-const updateSession = async () => {
-  isAuthenticatedRef.value = await sdk.isAuthenticated;
-  idTokenClaimsRef.value = sdk.idTokenClaims || null;
-  accessTokenRef.value = sdk.accessToken || null;
-  refreshTokenRef.value = sdk.refreshToken || null;
-  accessTokenExpiredRef.value = sdk.accessTokenExpired;
-  accessTokenExpirationDateRef.value = sdk.accessTokenExpirationDate || null;
-  if (loadingRef.value) {
-    loadingRef.value = false;
-  }
-};
-export const useStrivacity = () => {
-  if (!sdk) {
-    sdk = initFlow({ ...useRuntimeConfig().public.strivacity, storage: StorageClass, logging: LoggingClass });
-    optionsRef.value = sdk.options;
-    sdk.subscribeToEvent("init", updateSession);
-    sdk.subscribeToEvent("loggedIn", updateSession);
-    sdk.subscribeToEvent("sessionLoaded", updateSession);
-    sdk.subscribeToEvent("tokenRefreshed", updateSession);
-    sdk.subscribeToEvent("tokenRefreshFailed", updateSession);
-    sdk.subscribeToEvent("logoutInitiated", updateSession);
-    sdk.subscribeToEvent("tokenRevoked", updateSession);
-    sdk.subscribeToEvent("tokenRevokeFailed", updateSession);
-  }
-  return {
-    sdk,
-    loading: loadingRef,
-    options: optionsRef,
-    isAuthenticated: isAuthenticatedRef,
-    idTokenClaims: idTokenClaimsRef,
-    accessToken: accessTokenRef,
-    refreshToken: refreshTokenRef,
-    accessTokenExpired: accessTokenExpiredRef,
-    accessTokenExpirationDate: accessTokenExpirationDateRef,
-    login: async (options) => {
-      if (sdk.options.mode === "native") {
-        return sdk.login(options);
-      }
-      await sdk.login(options);
-      await updateSession();
-    },
-    register: async (options) => {
-      if (sdk.options.mode === "native") {
-        return sdk.register(options);
-      }
-      await sdk.register(options);
-      await updateSession();
-    },
-    refresh: async () => {
-      await sdk.refresh();
-      await updateSession();
-    },
-    entry: async (url) => {
-      return await sdk.entry(url);
-    },
-    revoke: async () => {
-      await sdk.revoke();
-      await updateSession();
-    },
-    logout: async (options) => {
-      await sdk.logout(options);
-      await updateSession();
-    },
-    handleCallback: async (url) => {
-      await sdk.handleCallback(url);
-      await updateSession();
-    }
-  };
-};