@multiplatform.one/keycloak 0.7.14 → 0.7.16

package/src/provider/AfterAuth.tsx

@@ -0,0 +1,63 @@
+/**
+ * File: /src/provider/AfterAuth.tsx
+ * Project: @multiplatform.one/keycloak
+ * File Created: 10-01-2024 12:41:33
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useEffect } from 'react';
+import type { PropsWithChildren } from 'react';
+import { useAuthConfig } from '../hooks';
+import { useAuthState, persist } from '../state';
+import { useKeycloak } from '../keycloak';
+
+export interface AfterAuthProps extends PropsWithChildren {}
+
+const logger = console;
+
+export function AfterAuth({ children }: AfterAuthProps) {
+  const authConfig = useAuthConfig();
+  const authState = useAuthState();
+  const keycloak = useKeycloak();
+
+  useEffect(() => {
+    if (!persist || !keycloak?.authenticated) return;
+    if (keycloak.token) {
+      authState.setToken(keycloak.token);
+      if (keycloak.idToken) authState.setIdToken(keycloak.idToken);
+      if (keycloak.refreshToken) authState.setRefreshToken(keycloak.refreshToken);
+    }
+  }, [keycloak?.authenticated, keycloak?.token, keycloak?.idToken, keycloak?.refreshToken]);
+
+  useEffect(() => {
+    if (authConfig.debug && keycloak?.token) logger.debug('token', keycloak.token);
+  }, [keycloak?.token]);
+
+  useEffect(() => {
+    if (authConfig.debug && keycloak?.idToken) logger.debug('idToken', keycloak.idToken);
+  }, [keycloak?.idToken]);
+
+  useEffect(() => {
+    if (authConfig.debug && keycloak?.refreshToken) logger.debug('refreshToken', keycloak.refreshToken);
+  }, [keycloak?.refreshToken]);
+
+  useEffect(() => {
+    if (keycloak?.authenticated) logger.debug('authenticated', keycloak.authenticated);
+  }, [keycloak?.authenticated]);
+
+  return <>{children}</>;
+}

package/src/provider/{keycloakProvider.native.tsx → AuthProvider/AuthProvider.native.tsx}

@@ -1,10 +1,10 @@
 /**
- * File: /src/provider/keycloakProvider.native.tsx
+ * File: /src/provider/AuthProvider/AuthProvider.native.tsx
  * Project: @multiplatform.one/keycloak
- * File Created: 22-06-2023 10:07:56
+ * File Created: 09-01-2024 11:29:20
  * Author: Clay Risser
  * -----
- * BitSpur (c) Copyright 2021 - 2023
+ * BitSpur (c) Copyright 2021 - 2024
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,22 +20,14 @@
  */
 
 import React from 'react';
-import type { FC } from 'react';
-import type { KeycloakConfig } from '@bitspur/keycloak-js';
-import type { KeycloakProviderProps } from './keycloakProvider';
-import { AfterAuth } from './afterAuth';
+import type { AuthProviderProps } from './AuthProvider';
+import { AfterAuth } from '../AfterAuth';
 import { KeycloakProvider as ExpoKeycloakProvider } from 'expo-keycloak-auth';
 
-export const KeycloakProvider: FC<KeycloakProviderProps> = ({ children, keycloakConfig }: KeycloakProviderProps) => {
-  const clonedKeycloakConfig = {
-    ...(keycloakConfig as Omit<KeycloakConfig, 'baseUrl'>),
-    url: keycloakConfig.url,
-  };
-  // @ts-ignore
-  delete keycloakConfig.baseUrl;
+export function AuthProvider({ children, keycloakConfig }: AuthProviderProps) {
   return (
-    <ExpoKeycloakProvider {...clonedKeycloakConfig}>
+    <ExpoKeycloakProvider {...keycloakConfig}>
       <AfterAuth>{children}</AfterAuth>
     </ExpoKeycloakProvider>
   );
-};
+}

package/src/provider/{keycloakProvider.tsx → AuthProvider/AuthProvider.tsx}

@@ -1,10 +1,10 @@
 /**
- * File: /src/provider/keycloakProvider.tsx
+ * File: /src/provider/AuthProvider/AuthProvider.tsx
  * Project: @multiplatform.one/keycloak
- * File Created: 22-06-2023 10:07:56
+ * File Created: 09-01-2024 11:29:20
  * Author: Clay Risser
  * -----
- * BitSpur (c) Copyright 2021 - 2023
+ * BitSpur (c) Copyright 2021 - 2024
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,62 +19,56 @@
  * limitations under the License.
  */
 
-import Keycloak from '@bitspur/keycloak-js';
-import React, { useMemo, useEffect, useState, useCallback } from 'react';
-import type { AuthClientEvent, AuthClientError, AuthClientTokens } from '@bitspur/react-keycloak-core';
-import type { KeycloakInitOptions, KeycloakConfig } from '@bitspur/keycloak-js';
-import type { ReactNode, ComponentType } from 'react';
-import { AfterAuth } from './afterAuth';
+import KeycloakClient from 'keycloak-js';
+import React, { useEffect, useMemo, useState } from 'react';
+import type { KeycloakConfig, KeycloakInitOptions } from 'keycloak-js';
+import type { PropsWithChildren } from 'react';
+import type { SessionProviderProps } from 'next-auth/react';
+import { AfterAuth } from '../AfterAuth';
+import { Keycloak } from '../../keycloak';
+import { KeycloakContext } from '../../keycloak/context';
 import { MultiPlatform } from 'multiplatform.one';
-import { ReactKeycloakProvider } from '@bitspur/react-keycloak-web';
-import { SSRKeycloakProvider, SSRCookies } from '@bitspur/react-keycloak-ssr';
-import { useAuthConfig } from '../hooks/useAuthConfig';
-import { useAuthState } from '../state';
+import { SessionProvider } from 'next-auth/react';
+import { persist, useAuthState } from '../../state';
+import { useAuthConfig } from '../../hooks';
 import { useRouter } from 'next/router';
-import { validToken } from '../util';
+import { validToken } from '../../token';
 
-export interface KeycloakProviderProps {
-  children: ReactNode;
-  cookies?: unknown;
-  keycloakConfig: KeycloakConfig;
+export interface AuthProviderProps extends PropsWithChildren {
+  keycloakConfig?: KeycloakConfig;
   keycloakInitOptions?: KeycloakInitOptions;
-  loadingComponent?: ComponentType;
-  onEvent?: (eventType: AuthClientEvent, error?: AuthClientError) => void;
-  onTokens?: (tokens: AuthClientTokens) => void;
+  sessionProvider?: Omit<SessionProviderProps, 'children'>;
 }
 
 const logger = console;
 
-export function KeycloakProvider({
-  children,
-  cookies,
-  keycloakConfig,
-  keycloakInitOptions,
-  loadingComponent,
-  onEvent,
-  onTokens,
-}: KeycloakProviderProps) {
-  const { debug, ensureFreshness, persist, messageHandlerKeys, ssr } = useAuthConfig();
-  const authState = useAuthState();
-  const LoadingComponent = loadingComponent || (() => <>{debug ? 'authenticating' : null}</>);
+export function AuthProvider({ children, sessionProvider, keycloakInitOptions, keycloakConfig }: AuthProviderProps) {
+  const { debug, messageHandlerKeys } = useAuthConfig();
   const { query } = MultiPlatform.isNext ? useRouter() : { query: {} };
-  const [refreshToken, setRefreshToken] = useState<string | boolean>(
+  const authState = useAuthState();
+  const [keycloak, setKeycloak] = useState<Keycloak>();
+  const [refreshToken, setRefreshToken] = useState<string | boolean | undefined>(
     validToken(
-      (ensureFreshness &&
-        (('refreshToken' in query && (query.refreshToken?.toString() || true)) ||
-          (persist && authState.refreshToken))) ||
-        false,
+      MultiPlatform.isIframe
+        ? ('refreshToken' in query && (query.refreshToken?.toString() || true)) ||
+            (persist && authState.refreshToken) ||
+            false
+        : undefined,
     ),
   );
-  const [idToken, setIdToken] = useState<string | boolean>(
+  const [token, setToken] = useState<string | boolean | undefined>(
     validToken(
-      ('idToken' in query && (query.idToken?.toString() || true)) || (persist && authState.idToken) || false,
+      MultiPlatform.isIframe
+        ? ('token' in query && (query.token?.toString() || true)) || (persist && authState.token) || false
+        : undefined,
       refreshToken,
     ),
   );
-  const [token, setToken] = useState<string | boolean>(
+  const [idToken, setIdToken] = useState<string | boolean | undefined>(
     validToken(
-      ('token' in query && (query.token?.toString() || true)) || (persist && authState.token) || false,
+      MultiPlatform.isIframe
+        ? ('idToken' in query && (query.idToken?.toString() || true)) || (persist && authState.idToken) || false
+        : undefined,
       refreshToken,
     ),
   );
@@ -188,28 +182,20 @@ export function KeycloakProvider({
     };
   }, []);
 
-  const handleEvent = useCallback((eventType: AuthClientEvent, error?: AuthClientError) => {
-    if (error) {
-      if (typeof error === 'string') throw new Error(error);
-      const err: Error & { errorDescription?: string } = new Error(error.error);
-      err.errorDescription = error.error_description;
-      throw err;
-    }
-    if (onEvent) onEvent(eventType, error);
-  }, []);
-
-  const keycloak = useMemo(
+  const keycloakClient = useMemo(
     () =>
-      typeof window !== 'undefined' &&
-      new Keycloak({
-        url: keycloakConfig.url,
-        realm: keycloakConfig.realm,
-        clientId: keycloakConfig.clientId,
-      }),
-    [keycloakInitOptions, token, refreshToken, idToken],
+      MultiPlatform.isIframe && keycloakConfig
+        ? new KeycloakClient({
+            url: keycloakConfig.url,
+            realm: keycloakConfig.realm,
+            clientId: keycloakConfig.clientId,
+          })
+        : undefined,
+    [keycloakInitOptions, keycloakConfig, token, refreshToken, idToken],
   );
 
   const initOptions = useMemo(() => {
+    if (!MultiPlatform.isIframe) return;
     const initOptions = {
       ...defaultKeycloakInitOptions,
       ...keycloakInitOptions,
@@ -227,45 +213,46 @@ export function KeycloakProvider({
       initOptions.onLoad = undefined;
     }
     return initOptions;
-  }, [keycloakInitOptions, token, refreshToken, idToken]);
+  }, [keycloakInitOptions, token, idToken, refreshToken]);
+
+  useEffect(() => {
+    function onError() {
+      if (keycloakClient && initOptions) setKeycloak(new Keycloak(keycloakClient));
+    }
+    function onUpdate() {
+      if (keycloakClient && initOptions) setKeycloak(new Keycloak(keycloakClient));
+    }
+    if (keycloakClient && initOptions) {
+      (async () => {
+        keycloakClient.onAuthError = onError;
+        keycloakClient.onAuthLogout = onUpdate;
+        keycloakClient.onAuthRefreshError = onError;
+        keycloakClient.onAuthRefreshSuccess = onUpdate;
+        keycloakClient.onAuthSuccess = onUpdate;
+        keycloakClient.onReady = onUpdate;
+        keycloakClient.onTokenExpired = async () => {
+          try {
+            await keycloakClient.updateToken(5);
+          } catch (err) {
+            setKeycloak(new Keycloak());
+          }
+        };
+        const authenticated = await keycloakClient.init(initOptions);
+        setKeycloak(new Keycloak(authenticated ? keycloakClient : undefined));
+      })();
+    }
+  }, []);
 
-  if (token === true || idToken === true || refreshToken === true) return <LoadingComponent />;
-  if (cookies && ssr) {
-    return (
-      // @ts-ignore
-      <SSRKeycloakProvider
-        LoadingComponent={<LoadingComponent />}
-        autoRefreshToken={initOptions.checkLoginIframe}
-        initOptions={initOptions}
-        onEvent={handleEvent}
-        onTokens={onTokens}
-        persistor={SSRCookies(cookies)}
-        keycloakConfig={{
-          clientId: keycloakConfig.clientId,
-          realm: keycloakConfig.realm,
-          url: keycloakConfig.url,
-        }}
-      >
-        <AfterAuth>{children}</AfterAuth>
-      </SSRKeycloakProvider>
-    );
-  }
-  if (!keycloak) return <LoadingComponent />;
   return (
-    <ReactKeycloakProvider
-      LoadingComponent={<LoadingComponent />}
-      authClient={keycloak}
-      autoRefreshToken={initOptions.checkLoginIframe}
-      initOptions={initOptions}
-      onEvent={handleEvent}
-      onTokens={onTokens}
-    >
-      <AfterAuth>{children}</AfterAuth>
-    </ReactKeycloakProvider>
+    <SessionProvider {...sessionProvider}>
+      <KeycloakContext.Provider value={keycloak}>
+        <AfterAuth>{children}</AfterAuth>
+      </KeycloakContext.Provider>
+    </SessionProvider>
   );
 }
 
-export const defaultKeycloakInitOptions: KeycloakInitOptions = {
+const defaultKeycloakInitOptions: KeycloakInitOptions = {
   checkLoginIframe: true,
   checkLoginIframeInterval: 5,
   enableLogging: false,

package/{lib/@types/expoKeycloakAuth.d.d.ts → src/provider/AuthProvider/index.ts}

@@ -1,10 +1,10 @@
 /*
- *  File: /src/@types/expoKeycloakAuth.d.ts
+ *  File: /src/provider/AuthProvider/index.ts
  *  Project: @multiplatform.one/keycloak
- *  File Created: 22-06-2023 10:07:56
+ *  File Created: 10-01-2024 13:43:20
  *  Author: Clay Risser
  *  -----
- *  BitSpur (c) Copyright 2021 - 2023
+ *  BitSpur (c) Copyright 2021 - 2024
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -19,7 +19,4 @@
  *  limitations under the License.
  */
 
-declare module 'expo-keycloak-auth' {
-  export function useKeycloak(): any;
-  export const KeycloakProvider: any;
-}
+export * from './AuthProvider';

package/src/provider/KeycloakProvider.tsx

@@ -0,0 +1,53 @@
+/**
+ * File: /src/provider/KeycloakProvider.tsx
+ * Project: @multiplatform.one/keycloak
+ * File Created: 10-01-2024 13:56:05
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2021 - 2024
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { useMemo } from 'react';
+import type { AuthConfig } from '../authConfig';
+import type { PropsWithChildren } from 'react';
+import type { Session } from 'next-auth';
+import { AuthConfigContext } from '../authConfig';
+import { AuthProvider } from './AuthProvider';
+
+export interface KeycloakProviderProps extends PropsWithChildren, AuthConfig {
+  baseUrl?: string;
+  clientId?: string;
+  realm?: string;
+  session?: Session;
+}
+
+export function KeycloakProvider({ children, debug, realm, clientId, baseUrl, session }: KeycloakProviderProps) {
+  const authConfig = useMemo(() => ({ debug }), [debug]);
+
+  return (
+    <AuthConfigContext.Provider value={authConfig}>
+      <AuthProvider
+        sessionProvider={{ session }}
+        keycloakConfig={{
+          realm: realm || 'main',
+          clientId: clientId || 'app',
+          url: baseUrl,
+        }}
+      >
+        {children}
+      </AuthProvider>
+    </AuthConfigContext.Provider>
+  );
+}

package/src/{hooks/useCurrentRouteName/index.native.ts → provider/index.ts}

@@ -1,10 +1,10 @@
 /*
- *  File: /src/hooks/useCurrentRouteName/index.native.ts
+ *  File: /src/provider/index.ts
  *  Project: @multiplatform.one/keycloak
- *  File Created: 22-06-2023 10:07:56
+ *  File Created: 09-01-2024 11:29:13
  *  Author: Clay Risser
  *  -----
- *  BitSpur (c) Copyright 2021 - 2023
+ *  BitSpur (c) Copyright 2021 - 2024
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -19,11 +19,6 @@
  *  limitations under the License.
  */
 
-import { MultiPlatform } from 'multiplatform.one';
-import { useRoute } from '@react-navigation/native';
-
-export function useCurrentRouteName() {
-  if (MultiPlatform.isStorybook) return null;
-  const route = useRoute();
-  return route.name;
-}
+export * from './AfterAuth';
+export * from './AuthProvider';
+export * from './KeycloakProvider';

package/src/routes.ts

@@ -0,0 +1,163 @@
+/*
+ *  File: /src/routes.ts
+ *  Project: @multiplatform.one/keycloak
+ *  File Created: 09-01-2024 11:32:46
+ *  Author: Clay Risser
+ *  -----
+ *  BitSpur (c) Copyright 2021 - 2024
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+import type { AccessTokenParsed } from './token';
+import type { AuthOptions, CallbacksOptions } from 'next-auth';
+import type { JWT } from 'next-auth/jwt';
+import type { OAuthUserConfig } from 'next-auth/providers';
+import type { Session } from './session';
+import { getServerSession } from 'next-auth';
+import { jwtDecode } from 'jwt-decode';
+
+const KeycloakProvider = require('next-auth/providers/keycloak').default;
+const NextAuth = require('next-auth').default;
+const NextResponse = require('next/server').NextResponse;
+
+const logger = console;
+let _nextAuth: AuthOptions | undefined;
+
+export function createAuthHandler(options: CreateAuthHandlerOptions = {}) {
+  const handler = NextAuth(createAuthOptions(options));
+  return {
+    GET: handler,
+    POST: handler,
+  };
+}
+
+export function createLogoutHandler(options: CreateAuthHandlerOptions = {}) {
+  return {
+    async GET() {
+      const idToken = ((await getServerSession(createAuthOptions(options))) as Session)?.idToken;
+      if (idToken) {
+        try {
+          await fetch(
+            `${process.env.KEYCLOAK_BASE_URL}/realms/${
+              process.env.KEYCLOAK_REALM || 'master'
+            }/protocol/openid-connect/logout?id_token_hint=${idToken}&post_logout_redirect_uri=${encodeURIComponent(
+              process.env.NEXTAUTH_URL || '',
+            )}`,
+            { method: 'GET' },
+          );
+        } catch (err) {
+          logger.error(err);
+          return new NextResponse(null, { status: 500 });
+        }
+      }
+      return new NextResponse();
+    },
+  };
+}
+
+function createAuthOptions(options: CreateAuthHandlerOptions = {}) {
+  if (_nextAuth) return _nextAuth;
+  _nextAuth = {
+    ...options.nextAuth,
+    providers: [
+      KeycloakProvider({
+        clientId: process.env.KEYCLOAK_CLIENT_ID || '',
+        clientSecret: process.env.KEYCLOAK_CLIENT_SECRET || '',
+        issuer: `${process.env.KEYCLOAK_BASE_URL}/realms/${process.env.KEYCLOAK_REALM || 'master'}`,
+        ...options.keycloakProvider,
+      }),
+      ...(options.nextAuth?.providers || []),
+    ],
+    callbacks: {
+      ...options.nextAuth?.callbacks,
+      async jwt(params) {
+        if (typeof options.nextAuth?.callbacks?.jwt === 'function') {
+          return options.nextAuth?.callbacks.jwt(params);
+        }
+        const { token, account } = params;
+        if (account) {
+          const decoded = jwtDecode(account.access_token || '') as AccessTokenParsed;
+          token.decoded = decoded;
+          token.accessToken = account.access_token;
+          token.idToken = account.id_token;
+          token.expiresAt = account.expires_at;
+          token.refreshToken = account.refresh_token;
+          token.roles = decoded.realm_access?.roles;
+          return token;
+        } else if (Math.floor(Date.now() / 1000) < Number(token.expiresAt)) {
+          return token;
+        } else {
+          try {
+            return refreshAccessToken(token as NextToken);
+          } catch (err) {
+            return { ...token, err };
+          }
+        }
+      },
+      async session(params) {
+        if (typeof options.nextAuth?.callbacks?.session === 'function') {
+          return options.nextAuth.callbacks.session(params);
+        }
+        const { session: nextSession, token: nextToken } = params;
+        const session = nextSession as Session;
+        const token = nextToken as NextToken;
+        if (token.accessToken) session.accessToken = token.accessToken;
+        if (token.idToken) session.idToken = token.idToken;
+        session.err = token.err;
+        return session;
+      },
+    } as CallbacksOptions,
+  } as AuthOptions;
+  return _nextAuth;
+}
+
+async function refreshAccessToken(nextToken: NextToken) {
+  const res = await fetch(process.env.REFRESH_TOKEN_URL || '', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: new URLSearchParams({
+      client_id: process.env.KEYCLOAK_CLIENT_ID || '',
+      client_secret: process.env.KEYCLOAK_CLIENT_SECRET || '',
+      grant_type: 'refresh_token',
+      refresh_token: nextToken.refreshToken,
+    }),
+  });
+  const refreshToken = await res.json();
+  if (!res.ok) throw refreshToken;
+  return {
+    ...nextToken,
+    accessToken: refreshToken.access_token,
+    decoded: jwtDecode(refreshToken.access_token),
+    expiresAt: Math.floor(Date.now() / 1000) + Number(refreshToken.expires_in),
+    idToken: refreshToken.id_token,
+    refreshToken: refreshToken.refresh_token,
+  };
+}
+
+export interface CreateAuthHandlerOptions {
+  keycloakProvider?: Partial<OAuthUserConfig<any>>;
+  nextAuth?: AuthOptions;
+}
+
+export interface NextToken extends JWT {
+  accessToken?: string;
+  decoded: AccessTokenParsed;
+  err?: Error;
+  expiresAt: number;
+  idToken?: string;
+  refreshToken: string;
+  roles: string[];
+}

package/src/session/index.ts

@@ -0,0 +1,22 @@
+/*
+ *  File: /src/session/index.ts
+ *  Project: @multiplatform.one/keycloak
+ *  File Created: 11-01-2024 02:47:42
+ *  Author: Clay Risser
+ *  -----
+ *  BitSpur (c) Copyright 2021 - 2024
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+export * from './session';

package/src/session/session.native.ts

@@ -0,0 +1,31 @@
+/*
+ *  File: /src/session/session.native.ts
+ *  Project: @multiplatform.one/keycloak
+ *  File Created: 10-01-2024 02:31:26
+ *  Author: Clay Risser
+ *  -----
+ *  BitSpur (c) Copyright 2021 - 2024
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+import type { SessionContextValue } from './session';
+import type { UseSessionOptions } from 'next-auth/react';
+
+export async function getSession() {
+  return null;
+}
+
+export function useSession<R extends boolean>(_options?: UseSessionOptions<R>): SessionContextValue<R> {
+  return {};
+}