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

package/dist/runtime/utils/core.js

@@ -0,0 +1,64 @@
+export {
+  FallbackError,
+  PopupBlockedError,
+  PopupClosedError,
+  UnsupportedFlowError,
+  SessionExpiredError,
+  NetworkError,
+  ServerError,
+  OidcError,
+  ProtocolError,
+  ConfigurationError,
+  InternalError,
+  throwTokenEndpointError,
+  throwHttpError,
+  assertWebAuthnCredential,
+  buildAuthorizationUrl,
+  buildCookieString,
+  buildEndSessionUrl,
+  createDefaultLogging,
+  createHttpClient,
+  createSession,
+  createState,
+  createWebAuthnCredential,
+  decodeBase64URL,
+  decodeJwt,
+  decryptString,
+  defaultOptions,
+  encodeBase64URL,
+  encryptString,
+  exchangeCode,
+  fetchFlowEntry,
+  finalizeLoginSession,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateJwt,
+  generateRandomHex,
+  getDefaultFlowState,
+  getDiscoveryDocument,
+  getSDKOptions,
+  getServerSDKOptions,
+  injectScript,
+  isSessionExpired,
+  loadSession,
+  parseCookieHeader,
+  parseState,
+  proxyResponse,
+  pushSetCookie,
+  flushSetCookies,
+  refreshToken,
+  revokeToken,
+  serializeCookie,
+  serializeSession,
+  serializeState,
+  submitLoginForm,
+  timestamp,
+  toSafeRedirect,
+  unflattenObject,
+  verifyIdToken,
+  verifyJwt,
+  DISALLOWED_PROXY_HEADERS,
+  RETURN_TO_COOKIE,
+  BACKCHANNEL_LOGOUT_EVENT,
+  DEFAULT_COOKIE_MAX_AGE
+} from "@strivacity/sdk-core/utils";

package/dist/runtime/utils/noop.d.ts

@@ -0,0 +1 @@
+export default function (): undefined;

package/dist/runtime/utils/noop.js

@@ -0,0 +1,3 @@
+export default function() {
+  return void 0;
+}

package/dist/types.d.mts

@@ -1,21 +1,9 @@
-export { type PopupFlow } from '@strivacity/sdk-core/flows/PopupFlow'
+import type { NuxtModule } from '@nuxt/schema'
 
-export { type RedirectFlow } from '@strivacity/sdk-core/flows/RedirectFlow'
+import type { default as Module } from './module.mjs'
 
-export { type NativeFlow } from '@strivacity/sdk-core/flows/NativeFlow'
-
-export { type HttpClient } from '@strivacity/sdk-core/utils/HttpClient'
-
-export { type DefaultLogging } from '@strivacity/sdk-core/utils/Logging'
-
-export { type LocalStorage } from '@strivacity/sdk-core/storages/LocalStorage'
-
-export { type SessionStorage } from '@strivacity/sdk-core/storages/SessionStorage'
-
-export { type createCredential, type getCredential } from '@strivacity/sdk-core/utils/credentials'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
 export { default } from './module.mjs'
 
-export { type ModuleOptions, type NativeContext, type NativeFlowContextValue, type NativeSDK, type PopupContext, type PopupSDK, type RedirectContext, type RedirectSDK, type Session } from './module.mjs'
-
-export * from '@strivacity/sdk-core'
+export * from '../dist/runtime/types.js'

package/eslint.config.mjs

@@ -0,0 +1,5 @@
+import { defineTsConfig } from '../../eslint.config.base.mjs';
+
+export default defineTsConfig({
+	ignores: ['**/.nuxt', '**/.output'],
+});

package/nuxt.config.ts

@@ -0,0 +1,5 @@
+import { defineNuxtConfig } from 'nuxt/config';
+
+export default defineNuxtConfig({
+	telemetry: false,
+});

package/package.json

@@ -1,24 +1,50 @@
 {
   "name": "@strivacity/sdk-nuxt",
-  "version": "3.0.2",
-  "license": "MIT",
+  "version": "4.0.0-beta.0",
   "description": "Strivacity Nuxt SDK client",
+  "license": "MIT",
   "author": "strivacity <opensource@strivacity.com>",
   "repository": {
     "type": "git",
     "url": "https://github.com/Strivacity/sdk-js"
   },
   "type": "module",
-  "dependencies": {
-    "@strivacity/sdk-core": "3.0.2"
-  },
+  "sideEffects": false,
   "main": "./dist/module.mjs",
   "types": "./dist/types.d.mts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs",
       "default": "./dist/module.mjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./storages": {
+      "types": "./dist/runtime/storages/core.d.ts",
+      "import": "./dist/runtime/storages/core.js",
+      "default": "./dist/runtime/storages/core.js"
+    },
+    "./utils": {
+      "types": "./dist/runtime/utils/core.d.ts",
+      "import": "./dist/runtime/utils/core.js",
+      "default": "./dist/runtime/utils/core.js"
     }
+  },
+  "dependencies": {
+    "@strivacity/sdk-core": "4.0.0-beta.0"
+  },
+  "peerDependencies": {
+    "nuxt": ">=4.0"
   }
 }

package/project.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "name": "sdk-nuxt",
+  "projectType": "library",
+  "sourceRoot": "packages/sdk-nuxt/src",
+  "targets": {
+    "prepare": {
+      "executor": "nx:run-commands",
+      "options": {
+        "commands": [
+          {
+            "command": "nuxt-module-build build --stub --cwd packages/sdk-nuxt",
+            "forwardAllArgs": false
+          },
+          {
+            "command": "nuxt-module-build prepare --cwd packages/sdk-nuxt",
+            "forwardAllArgs": false
+          }
+        ],
+        "parallel": false
+      }
+    },
+    "build": {
+      "executor": "nx:run-commands",
+      "dependsOn": ["sdk-core:build", "prepare"],
+      "options": {
+        "commands": [
+          {
+            "command": "nuxt-module-build build --sourcemap --cwd packages/sdk-nuxt",
+            "forwardAllArgs": false
+          }
+        ]
+      }
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "dependsOn": ["build"],
+      "options": {
+        "cwd": "packages/sdk-nuxt",
+        "command": "vitest"
+      }
+    }
+  }
+}

package/src/module.ts

@@ -0,0 +1,107 @@
+import type { NuxtServerSDKInitConfig } from './runtime/types';
+import {
+	defineNuxtModule,
+	resolvePath,
+	createResolver,
+	addImportsDir,
+	addServerImportsDir,
+	addServerHandler,
+	addServerPlugin,
+	addRouteMiddleware,
+} from '@nuxt/kit';
+
+export type * from './runtime/types';
+
+export default defineNuxtModule<NuxtServerSDKInitConfig>({
+	meta: {
+		name: '@strivacity/sdk-nuxt',
+		configKey: 'strivacity',
+	},
+	setup: async (options, nuxt) => {
+		const resolver = createResolver(import.meta.url);
+
+		if (!options.authUrlPrefix) {
+			options.authUrlPrefix = '/auth';
+		}
+		if (typeof options.serverSessionUri === 'undefined') {
+			options.serverSessionUri = `${options.authUrlPrefix}/login`;
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		const { secret, storageFactoryPath, stateStorageFactoryPath, loggingFactoryPath, httpClientFactoryPath, ...publicOptions } = options;
+		const noop = resolver.resolve('./runtime/utils/noop');
+
+		nuxt.options.runtimeConfig.strivacity = options;
+		nuxt.options.runtimeConfig.public.strivacity = publicOptions;
+		nuxt.options.alias = nuxt.options.alias || {};
+		nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
+
+		const loggingPath = options.loggingFactoryPath ? await resolvePath(options.loggingFactoryPath) : noop;
+		const httpClientPath = options.httpClientFactoryPath ? await resolvePath(options.httpClientFactoryPath) : noop;
+		const storagePath = options.storageFactoryPath ? await resolvePath(options.storageFactoryPath) : noop;
+		const stateStoragePath = options.stateStorageFactoryPath ? await resolvePath(options.stateStorageFactoryPath) : noop;
+
+		nuxt.options.alias['#strivacity-options-logging'] = loggingPath;
+		nuxt.options.alias['#strivacity-options-httpClient'] = httpClientPath;
+		nuxt.options.alias['#strivacity-options-storage'] = storagePath;
+		nuxt.options.alias['#strivacity-options-stateStorage'] = stateStoragePath;
+		nuxt.options.nitro.alias['#strivacity-options-logging'] = loggingPath;
+		nuxt.options.nitro.alias['#strivacity-options-httpClient'] = httpClientPath;
+		nuxt.options.nitro.alias['#strivacity-options-storage'] = storagePath;
+		nuxt.options.nitro.alias['#strivacity-options-stateStorage'] = stateStoragePath;
+
+		addImportsDir(resolver.resolve('./runtime/composables'));
+		addImportsDir(resolver.resolve('./runtime/storages'));
+		addImportsDir(resolver.resolve('./runtime/utils'));
+
+		if (options.serverSessionUri) {
+			addServerImportsDir(resolver.resolve('./runtime/server/composables'));
+			addServerImportsDir(resolver.resolve('./runtime/server/utils'));
+			addServerImportsDir(resolver.resolve('./runtime/storages'));
+
+			addServerPlugin(resolver.resolve('./runtime/server/plugins/auth.server'));
+			addRouteMiddleware({ name: 'strivacity', path: resolver.resolve('./runtime/middleware/auth.server'), global: true });
+
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/login`,
+				handler: resolver.resolve('./runtime/server/api/auth/login.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/register`,
+				handler: resolver.resolve('./runtime/server/api/auth/register.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/callback`,
+				handler: resolver.resolve('./runtime/server/api/auth/callback.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/refresh`,
+				handler: resolver.resolve('./runtime/server/api/auth/refresh.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/revoke`,
+				handler: resolver.resolve('./runtime/server/api/auth/revoke.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/entry`,
+				handler: resolver.resolve('./runtime/server/api/auth/entry.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/logout`,
+				handler: resolver.resolve('./runtime/server/api/auth/logout.get'),
+			});
+			addServerHandler({
+				method: 'get',
+				route: `${options.authUrlPrefix}/backchannel-logout`,
+				handler: resolver.resolve('./runtime/server/api/auth/backchannel-logout.get'),
+			});
+		}
+	},
+});

package/src/runtime/composables/use-native-login-context.ts

@@ -0,0 +1,20 @@
+import { inject, type InjectionKey } from 'vue';
+import type { LoginContext } from '../types';
+
+export const STRIVACITY_LOGIN_CONTEXT: InjectionKey<LoginContext> = Symbol('strivacity-login-context');
+
+/**
+ * A composable to access the Strivacity SDK context specifically for native login flow.
+ *
+ * @returns {LoginContext} - The native flow context.
+ * @throws {Error} - If the Strivacity SDK context is not found.
+ */
+export const useNativeLoginContext = (): LoginContext => {
+	const context = inject<LoginContext>(STRIVACITY_LOGIN_CONTEXT);
+
+	if (!context) {
+		throw new Error('Missing SDK native login context');
+	}
+
+	return context;
+};

package/src/runtime/composables/use-native-login.ts

@@ -0,0 +1,182 @@
+import type { NativeFlow, NativeParams, NativeFlowState, NativeFlowMessage } from '@strivacity/sdk-core/types';
+import type { LoginContext, UseNativeLoginOptions } from '../types';
+import { STRIVACITY_LOGIN_CONTEXT, type useNativeLoginContext } from './use-native-login-context';
+import { provide, ref, onMounted, onUnmounted } from 'vue';
+import { FallbackError } from '@strivacity/sdk-core/utils/errors';
+import { unflattenObject } from '@strivacity/sdk-core/utils';
+import { useStrivacity } from './use-strivacity';
+
+/**
+ * A composable that manages a native login flow session.
+ *
+ * @param {UseNativeLoginOptions} [options] - Optional options for the login session.
+ * @returns {LoginContext} - The native flow context.
+ * @throws {Error} - If the Strivacity SDK context is not found.
+ */
+export function useNativeLogin(options: UseNativeLoginOptions = {}): ReturnType<typeof useNativeLoginContext> {
+	const abortController = new AbortController();
+	const { sdk } = useStrivacity<NativeFlow>();
+
+	const loading = ref<boolean>(true);
+	const forms = ref<Record<string, Record<string, unknown>>>({});
+	const messages = ref<Record<string, Record<string, NativeFlowMessage>>>({});
+	const state = ref<Partial<NativeFlowState>>({});
+
+	onMounted(async () => {
+		await sdk.init();
+
+		try {
+			await startSession(options.params);
+		} catch (error) {
+			if (error instanceof DOMException && error.name === 'AbortError') {
+				return;
+			}
+
+			sdk.logging?.error('Error fetching authorization URI', error as Error);
+			void options.onError?.(error as Error);
+			loading.value = false;
+		}
+	});
+
+	onUnmounted(() => abortController.abort());
+
+	function handleResponse(nextState: Partial<NativeFlowState>) {
+		if (sdk.session) {
+			return void options.onLogin?.(sdk.session);
+		}
+
+		const newState: NativeFlowState = {
+			hostedUrl: nextState?.hostedUrl ?? state.value.hostedUrl,
+			finalizeUrl: nextState?.finalizeUrl ?? state.value.finalizeUrl,
+			screen: nextState?.screen ?? state.value.screen,
+			forms: nextState?.forms ?? state.value.forms,
+			layout: nextState?.layout ?? state.value.layout,
+			messages: nextState?.messages ?? {},
+			branding: nextState?.branding ?? state.value.branding,
+		};
+
+		if (newState.screen !== state.value.screen) {
+			forms.value = {};
+			messages.value = {};
+
+			for (const form of newState.forms ?? []) {
+				forms.value[form.id] = {};
+				messages.value[form.id] = {};
+			}
+		} else {
+			sdk.logging?.info(`Updating screen: ${newState.screen}`);
+		}
+
+		for (const formId of Object.keys(newState.messages ?? {})) {
+			if (formId === 'global') {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+				void options.onGlobalMessage?.(newState.messages?.global!);
+			} else {
+				messages.value[formId] = newState.messages![formId] ?? {};
+			}
+		}
+
+		state.value = newState;
+
+		if (!newState.finalizeUrl) {
+			loading.value = false;
+		}
+	}
+
+	async function startSession(loginParams: NativeParams = {}) {
+		try {
+			loading.value = true;
+
+			const nextState = await sdk.startSession(loginParams);
+
+			if (nextState) {
+				handleResponse(nextState);
+			}
+		} catch (error) {
+			if (error instanceof FallbackError) {
+				sdk.logging?.error('Fallback error occurred', error);
+				void options.onFallback?.(error);
+			} else {
+				sdk.logging?.error('Error starting session', error as Error);
+				void options.onError?.(error as Error);
+			}
+		}
+	}
+
+	function triggerFallback(message?: string) {
+		sdk.logging?.warn(message ? `Triggering fallback due to: ${message}` : 'Triggering fallback');
+
+		if (!state.value.hostedUrl) {
+			const error = new Error('No hosted URL provided');
+			sdk.logging?.error('Fallback error', error);
+			throw error;
+		}
+
+		void options.onFallback?.(new FallbackError(new URL(state.value.hostedUrl)));
+	}
+
+	function triggerClose() {
+		sdk.logging?.debug('Triggering close');
+		void options.onClose?.();
+	}
+
+	async function submitForm(formId: string, customBody?: Record<string, unknown>) {
+		try {
+			loading.value = true;
+
+			const nextState = await sdk.submitForm(formId, customBody ?? unflattenObject(forms.value[formId] ?? {}));
+
+			if (nextState) {
+				handleResponse(nextState);
+			}
+		} catch (error) {
+			if (error instanceof FallbackError) {
+				sdk.logging?.error('Fallback error occurred', error);
+				void options.onFallback?.(error);
+			} else {
+				sdk.logging?.error('Error submitting form', error as Error);
+				void options.onError?.(error as Error);
+			}
+		}
+	}
+
+	function setFormValue(formId: string, widgetId: string, value: unknown) {
+		if (forms.value[formId] === undefined) {
+			forms.value[formId] = {};
+		}
+
+		forms.value[formId][widgetId] = value === '' ? null : value;
+	}
+
+	function setMessage(formId: string, widgetId: string, value: NativeFlowMessage) {
+		if (messages.value[formId] === undefined) {
+			messages.value[formId] = {};
+		}
+
+		messages.value[formId][widgetId] = value;
+	}
+
+	provide<LoginContext>(STRIVACITY_LOGIN_CONTEXT, {
+		loading,
+		forms,
+		messages,
+		state,
+		triggerFallback,
+		triggerClose,
+		submitForm,
+		setFormValue,
+		setMessage,
+	});
+
+	return {
+		loading,
+		forms,
+		messages,
+		state,
+		triggerFallback,
+		triggerClose,
+		submitForm,
+		setFormValue,
+		setMessage,
+	};
+}

package/src/runtime/composables/use-session.ts

@@ -0,0 +1,10 @@
+import type { SessionData } from '@strivacity/sdk-core/types';
+import type { Ref } from '#imports';
+import { useState } from '#imports';
+
+/**
+ * A composable to access the Strivacity SDK session data.
+ *
+ * @returns {Ref<SessionData | undefined>} A ref containing the Strivacity SDK session data or undefined if not available.
+ */
+export const useSession = (): Ref<SessionData | undefined> => useState<SessionData | undefined>('strivacity_session', () => undefined);

package/src/runtime/composables/use-strivacity.ts

@@ -0,0 +1,95 @@
+import type { EmbeddedFlow, IdTokenClaims, NativeFlow, PopupFlow, RedirectFlow } from '@strivacity/sdk-core/types';
+import type { SDKContext } from '../types';
+import { ref } from 'vue';
+import { initFlow } from '@strivacity/sdk-core';
+import { useRuntimeConfig } from '#app';
+import { useSession } from './use-session';
+import createLogging from '#strivacity-options-logging';
+import createHttpClient from '#strivacity-options-httpClient';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let sdk: any;
+
+const loadingRef = ref<boolean>(true);
+const languageRef = ref<string>(globalThis.navigator?.language ?? 'en-US');
+const isAuthenticatedRef = ref<boolean>(false);
+const idTokenClaimsRef = ref<IdTokenClaims | null>(null);
+const accessTokenRef = ref<string | null>(null);
+const refreshTokenRef = ref<string | null>(null);
+const accessTokenExpiredRef = ref<boolean>(true);
+const accessTokenExpirationDateRef = ref<number | null>(null);
+
+const updateSession = async () => {
+	const authenticated = await sdk.isAuthenticated;
+
+	if (loadingRef.value) {
+		loadingRef.value = false;
+	}
+	if (sdk.language !== languageRef.value) {
+		languageRef.value = sdk.language;
+	}
+	if (authenticated !== isAuthenticatedRef.value) {
+		isAuthenticatedRef.value = authenticated;
+	}
+	if (sdk.idTokenClaims !== idTokenClaimsRef.value) {
+		idTokenClaimsRef.value = sdk.idTokenClaims || null;
+	}
+	if (sdk.accessToken !== accessTokenRef.value) {
+		accessTokenRef.value = sdk.accessToken || null;
+	}
+	if (sdk.refreshToken !== refreshTokenRef.value) {
+		refreshTokenRef.value = sdk.refreshToken || null;
+	}
+	if (sdk.accessTokenExpired !== accessTokenExpiredRef.value) {
+		accessTokenExpiredRef.value = sdk.accessTokenExpired;
+	}
+	if (sdk.accessTokenExpirationDate !== accessTokenExpirationDateRef.value) {
+		accessTokenExpirationDateRef.value = sdk.accessTokenExpirationDate || null;
+	}
+};
+
+/**
+ * A composable to access the Strivacity SDK context.
+ *
+ * @template T - The type of the Strivacity SDK flow (RedirectFlow, PopupFlow, NativeFlow, or EmbeddedFlow).
+ * @returns {SDKContext<T>} The Strivacity SDK context.
+ */
+export const useStrivacity = <
+	T extends RedirectFlow | PopupFlow | NativeFlow | EmbeddedFlow = RedirectFlow | PopupFlow | NativeFlow | EmbeddedFlow,
+>(): SDKContext<T> => {
+	if (!sdk) {
+		sdk = initFlow({
+			...useRuntimeConfig().public.strivacity,
+			logging: createLogging ? createLogging() : undefined,
+			httpClient: createHttpClient ? createHttpClient() : undefined,
+		});
+		sdk.subscribeToAllEvents(updateSession);
+
+		sdk.session = useSession().value;
+		void updateSession();
+	}
+
+	return {
+		sdk,
+		loading: loadingRef,
+		language: languageRef,
+		isAuthenticated: isAuthenticatedRef,
+		idTokenClaims: idTokenClaimsRef,
+		accessToken: accessTokenRef,
+		refreshToken: refreshTokenRef,
+		accessTokenExpired: accessTokenExpiredRef,
+		accessTokenExpirationDate: accessTokenExpirationDateRef,
+		init: () => sdk.init(),
+		subscribeToEvent: ((...args: Parameters<typeof sdk.subscribeToEvent>) => sdk.subscribeToEvent(...args)) as typeof sdk.subscribeToEvent,
+		subscribeToAllEvents: (...args: Parameters<typeof sdk.subscribeToAllEvents>) => sdk.subscribeToAllEvents(...args),
+		checkAuthentication: (...args: Parameters<typeof sdk.checkAuthentication>) => sdk.checkAuthentication(...args),
+		tokenExchange: (...args: Parameters<typeof sdk.tokenExchange>) => sdk.tokenExchange(...args),
+		handleCallback: (...args: Parameters<typeof sdk.handleCallback>) => sdk.handleCallback(...args),
+		refresh: () => sdk.refresh(),
+		revoke: () => sdk.revoke(),
+		logout: (...args: Parameters<typeof sdk.logout>) => sdk.logout(...args),
+		login: (...args: Parameters<typeof sdk.login>) => sdk.login(...args),
+		register: (...args: Parameters<typeof sdk.register>) => sdk.register(...args),
+		entry: (...args: Parameters<typeof sdk.entry>) => sdk.entry(...args),
+	};
+};

package/src/runtime/middleware/auth.server.ts

@@ -0,0 +1,16 @@
+import { defineNuxtRouteMiddleware, useNuxtApp } from '#imports';
+import { useSession } from '../composables/use-session';
+
+export default defineNuxtRouteMiddleware(async () => {
+	if (!import.meta.server) {
+		return;
+	}
+
+	const app = useNuxtApp();
+	const h3Event = app.ssrContext!.event;
+
+	const { useStrivacity } = await import('../server/composables/use-strivacity');
+	const sdk = useStrivacity(h3Event);
+
+	useSession().value = (await sdk.getSession()) ?? undefined;
+});

package/src/runtime/server/api/auth/backchannel-logout.get.ts

@@ -0,0 +1,3 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleBackChannelLogout(event));

package/src/runtime/server/api/auth/callback.get.ts

@@ -0,0 +1,3 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleCallback(event));

package/src/runtime/server/api/auth/entry.get.ts

@@ -0,0 +1,3 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleEntry(event));

package/src/runtime/server/api/auth/login.get.ts

@@ -0,0 +1,3 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleLogin(event));

package/src/runtime/server/api/auth/logout.get.ts

@@ -0,0 +1,3 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleLogout(event));

package/src/runtime/server/api/auth/refresh.get.ts

@@ -0,0 +1,3 @@
+import { defineEventHandler } from 'h3';
+
+export default defineEventHandler((event) => event.context.strivacity.sdk.handleRefresh(event));