@logto/react-router 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Silverhand
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# Logto React Router SDK
+
+[![Version](https://img.shields.io/npm/v/@logto/react-router)](https://www.npmjs.com/package/@logto/react-router)
+[![Build Status](https://github.com/logto-io/js/actions/workflows/main.yml/badge.svg)](https://github.com/logto-io/js/actions/workflows/main.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/logto-io/js)](https://app.codecov.io/gh/logto-io/js?branch=master)
+
+The Logto React Router SDK written in TypeScript.
+
+> **Note:** This SDK has been migrated from Remix to React Router. For detailed migration guide, please refer to the [official React Router migration documentation](https://reactrouter.com/upgrading/remix).
+
+## Installation
+
+**Note:** This package requires Node.js version 20 or higher.
+
+### Using npm
+
+```bash
+npm install @logto/react-router
+```
+
+### Using yarn
+
+```bash
+yarn add @logto/react-router
+```
+
+### Using pnpm
+
+```bash
+pnpm add @logto/react-router
+```
+
+## Usage
+
+Before initializing the SDK, we have to create a `SessionStorage` instance which takes care of the session persistence. In our case, we want to use a cookie-based session:
+
+```ts
+// services/auth.server.ts
+import { makeLogtoReactRouter } from '@logto/react-router';
+import { createCookieSessionStorage } from 'react-router';
+
+const sessionStorage = createCookieSessionStorage({
+  cookie: {
+    name: 'logto-session',
+    maxAge: 14 * 24 * 60 * 60,
+    secrets: ['secr3tSession'],
+  },
+});
+
+export const logto = makeLogtoReactRouter(
+  {
+    endpoint: process.env.LOGTO_ENDPOINT!,
+    appId: process.env.LOGTO_APP_ID!,
+    appSecret: process.env.LOGTO_APP_SECRET!,
+    baseUrl: process.env.LOGTO_BASE_URL!,
+  },
+  { sessionStorage }
+);
+```
+
+Whereas the environment variables reflect the respective configuration of the application in Logto.
+
+### Setup file-based routing
+
+```ts
+// app/routes.ts
+import { type RouteConfig } from '@react-router/dev/routes';
+import { flatRoutes } from '@react-router/fs-routes';
+
+export default flatRoutes() satisfies RouteConfig;
+```
+
+This will generate the routes for you based on the files in the `app/routes` directory.
+
+### Mounting the authentication route handlers
+
+The SDK ships with a convenient function that mounts the authentication routes: sign-in, sign-in callback and the sign-out route. Create a file `routes/api.logto.$action.ts`
+
+```ts
+// routes/api.logto.$action.ts
+
+import { logto } from '../../services/auth.server';
+
+export const loader = logto.handleAuthRoutes({
+  'sign-in': {
+    path: '/api/logto/sign-in',
+    redirectBackTo: '/api/logto/callback',
+  },
+  'sign-in-callback': {
+    path: '/api/logto/callback',
+    redirectBackTo: '/',
+  },
+  'sign-out': {
+    path: '/api/logto/sign-out',
+    redirectBackTo: '/',
+  },
+  'sign-up': {
+    path: '/api/logto/sign-up',
+    redirectBackTo: '/api/logto/callback',
+  },
+});
+```
+
+As you can see, the mount process is configurable and you can adjust it for your particular route structure. The whole URL path structure can be customized via the passed configuration object.
+
+When mounting the routes as described above, you can navigate your browser to `/api/logto/sign-in` and you should be redirected to your Logto instance where you have to authenticate then.
+
+### Get the authentication context
+
+A typical use case is to fetch the _authentication context_ which contains information about the respective user. With that information, it is possible to decide if the user is authenticated or not. The SDK exposes a function that can be used in a React Router `loader` function:
+
+```ts
+// app/routes/_index.tsx
+import { type LogtoContext } from '@logto/react-router';
+import { Link, type LoaderFunctionArgs } from 'react-router';
+
+import { logto } from '../../services/auth.server';
+
+type LoaderResponse = {
+  readonly context: LogtoContext;
+};
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const context = await logto.getContext({ getAccessToken: false })(request);
+
+  if (!context.isAuthenticated) {
+    return redirect('/api/logto/sign-in');
+  }
+
+  return { context };
+};
+
+const Home = ({ loaderData }: { readonly loaderData: LoaderResponse }) => {
+  const { context } = loaderData;
+  const { isAuthenticated, claims } = context;
+
+  return <div>Protected Route.</div>;
+};
+```
+
+## Resources
+
+[![Website](https://img.shields.io/badge/website-logto.io-8262F8.svg)](https://logto.io/)
+[![Discord](https://img.shields.io/discord/965845662535147551?logo=discord&logoColor=ffffff&color=7389D8&cacheSeconds=600)](https://discord.gg/UEPaF3j5e6)

package/lib/framework/get-cookie-header-from-request.d.ts

@@ -0,0 +1 @@
+export declare const getCookieHeaderFromRequest: (request: Request) => string | null;

package/lib/framework/get-cookie-header-from-request.js

@@ -0,0 +1,3 @@
+const getCookieHeaderFromRequest = (request) => request.headers.get('Cookie');
+
+export { getCookieHeaderFromRequest };

package/lib/framework/mocks.d.ts

@@ -0,0 +1,25 @@
+import type { Session, SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter, LogtoContext } from '../infrastructure/logto/index.js';
+export declare const getContext: import("vitest").Mock<() => Promise<{
+    context: LogtoContext;
+}>>;
+export declare const storage: import("../infrastructure/logto/create-storage.js").LogtoStorage;
+export declare const handleSignIn: import("vitest").Mock<() => Promise<{
+    session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+    navigateToUrl: string;
+}>>;
+export declare const handleSignInCallback: import("vitest").Mock<() => Promise<{
+    session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+}>>;
+export declare const handleSignOut: import("vitest").Mock<() => Promise<{
+    navigateToUrl: string;
+}>>;
+export declare const handleSignUp: import("vitest").Mock<() => Promise<{
+    session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+    navigateToUrl: string;
+}>>;
+export declare const createLogtoAdapter: CreateLogtoAdapter;
+export declare const commitSession: import("vitest").Mock<(session: Session) => Promise<string>>;
+export declare const destroySession: import("vitest").Mock<(...args: any[]) => any>;
+export declare const getSession: import("vitest").Mock<(...args: any[]) => any>;
+export declare const sessionStorage: SessionStorage;

package/lib/framework/mocks.js

@@ -0,0 +1,50 @@
+import { createSession } from 'react-router';
+import { createStorage } from '../infrastructure/logto/create-storage.js';
+const context = {
+    isAuthenticated: true,
+    claims: {
+        email: 'test@test.io',
+        aud: '',
+        exp: 1_665_684_317,
+        iat: 1_665_684_318,
+        iss: '',
+        sub: '',
+    },
+};
+export const getContext = vi.fn(async () => ({
+    context,
+}));
+const session = createSession();
+export const storage = createStorage(session);
+export const handleSignIn = vi.fn(async () => ({
+    session,
+    navigateToUrl: '/success-handle-sign-in',
+}));
+export const handleSignInCallback = vi.fn(async () => ({
+    session,
+}));
+export const handleSignOut = vi.fn(async () => ({
+    navigateToUrl: '/success-handle-sign-out',
+}));
+export const handleSignUp = vi.fn(async () => ({
+    session,
+    navigateToUrl: '/success-handle-sign-up',
+}));
+export const createLogtoAdapter = vi.fn((session) => {
+    return {
+        handleSignIn,
+        handleSignInCallback,
+        handleSignOut,
+        handleSignUp,
+        getContext,
+    };
+});
+// eslint-disable-next-line no-restricted-syntax
+export const commitSession = vi.fn(async (session) => session.data);
+export const destroySession = vi.fn();
+export const getSession = vi.fn();
+export const sessionStorage = {
+    commitSession,
+    destroySession,
+    getSession,
+};

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+import type { GetContextParameters, LogtoConfig } from '@logto/node';
+import type { SessionStorage } from 'react-router';
+type Config = Readonly<LogtoConfig> & {
+    readonly baseUrl: string;
+};
+export declare const makeLogtoReactRouter: (config: Config, deps: {
+    sessionStorage: SessionStorage;
+}) => Readonly<{
+    handleAuthRoutes: (dto: {
+        "sign-in": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+        "sign-in-callback": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+        "sign-out": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+        "sign-up": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+    }) => import("react-router").LoaderFunction;
+    getContext: (dto: GetContextParameters) => (request: Request) => Promise<import("@logto/node").LogtoContext>;
+}>;
+export type { AccessTokenClaims, IdTokenClaims, LogtoContext, InteractionMode, LogtoErrorCode, UserInfoResponse, } from '@logto/node';
+export { LogtoError, LogtoRequestError, LogtoClientError, OidcError, Prompt, ReservedScope, UserScope, organizationUrnPrefix, buildOrganizationUrn, getOrganizationIdFromUrn, PersistKey, } from '@logto/node';

package/lib/index.js

@@ -0,0 +1,23 @@
+import { makeLogtoAdapter } from './infrastructure/logto/index.js';
+import { makeGetContext } from './useCases/getContext/index.js';
+import { makeHandleAuthRoutes } from './useCases/handleAuthRoutes/index.js';
+export { LogtoClientError, LogtoError, LogtoRequestError, OidcError, PersistKey, Prompt, ReservedScope, UserScope, buildOrganizationUrn, getOrganizationIdFromUrn, organizationUrnPrefix } from '@logto/node';
+
+const makeLogtoReactRouter = (config, deps) => {
+    const { sessionStorage } = deps;
+    const { baseUrl } = config;
+    const createLogtoAdapter = makeLogtoAdapter(config);
+    return Object.freeze({
+        handleAuthRoutes: makeHandleAuthRoutes({
+            baseUrl,
+            createLogtoAdapter,
+            sessionStorage,
+        }),
+        getContext: (dto) => makeGetContext(dto, {
+            createLogtoAdapter,
+            sessionStorage,
+        }),
+    });
+};
+
+export { makeLogtoReactRouter };

package/lib/infrastructure/logto/create-client.d.ts

@@ -0,0 +1,6 @@
+import type { LogtoConfig } from '@logto/node';
+import LogtoClient from '@logto/node';
+import type { LogtoStorage } from './create-storage.js';
+export declare const makeLogtoClient: (config: LogtoConfig, storage: LogtoStorage) => (navigate?: (url: string) => void) => LogtoClient;
+export type CreateLogtoClient = ReturnType<typeof makeLogtoClient>;
+export { type LogtoConfig } from '@logto/node';

package/lib/infrastructure/logto/create-client.js

@@ -0,0 +1,11 @@
+import LogtoClient from '@logto/node';
+
+const makeLogtoClient = (config, storage) => 
+// Have to deactivate the eslint rule here as the `LogtoClient`
+// awaits a `navigate` function.
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+(navigate = () => { }) => {
+    return new LogtoClient(config, { storage, navigate });
+};
+
+export { makeLogtoClient };

package/lib/infrastructure/logto/create-client.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/infrastructure/logto/create-client.spec.js

@@ -0,0 +1,16 @@
+import { createSession } from 'react-router';
+import { makeLogtoClient } from './create-client.js';
+import { createStorage } from './create-storage.js';
+const config = {
+    appId: 'app_id_value',
+    endpoint: 'https://logto.dev',
+};
+describe('infrastructure:logto:createClient', () => {
+    it('creates an instance without crash', () => {
+        expect(() => {
+            const storage = createStorage(createSession());
+            const createLogtoClient = makeLogtoClient(config, storage);
+            createLogtoClient();
+        }).not.toThrow();
+    });
+});

package/lib/infrastructure/logto/create-storage.d.ts

@@ -0,0 +1,14 @@
+import type { Storage, StorageKey } from '@logto/node';
+import type { Session } from 'react-router';
+declare class LogtoStorage implements Storage<StorageKey> {
+    private readonly properties;
+    static readonly fromSession: (session: Session) => LogtoStorage;
+    readonly session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+    private constructor();
+    readonly setItem: (key: StorageKey, value: string) => Promise<void>;
+    readonly getItem: (key: StorageKey) => Promise<string | null>;
+    readonly removeItem: (key: StorageKey) => Promise<void>;
+    readonly save: () => Promise<void>;
+}
+export declare const createStorage: (session: Session) => LogtoStorage;
+export type { LogtoStorage };

package/lib/infrastructure/logto/create-storage.js

@@ -0,0 +1,28 @@
+class LogtoStorage {
+    static { this.fromSession = (session) => {
+        return new LogtoStorage({ session });
+    }; }
+    constructor(properties) {
+        this.properties = properties;
+        this.session = this.properties.session;
+        this.setItem = async (key, value) => {
+            this.session.set(key, value);
+        };
+        this.getItem = async (key) => {
+            const itemExists = this.session.has(key);
+            if (!itemExists) {
+                return null;
+            }
+            return String(this.session.get(key));
+        };
+        this.removeItem = async (key) => {
+            this.session.unset(key);
+        };
+        this.save = async () => {
+            // Not required as the persistence happens in the integration layer
+        };
+    }
+}
+const createStorage = (session) => LogtoStorage.fromSession(session);
+
+export { createStorage };

package/lib/infrastructure/logto/create-storage.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/infrastructure/logto/create-storage.spec.js

@@ -0,0 +1,39 @@
+import { createSession } from 'react-router';
+import { createStorage } from './create-storage.js';
+describe('infrastructure:logto:createStorage', () => {
+    it('can create a LogtoStorage instance', async () => {
+        const session = createSession();
+        const storage = createStorage(session);
+        expect(storage.constructor.name).toBe('LogtoStorage');
+    });
+    it('can set items', async () => {
+        const session = createSession();
+        const storage = createStorage(session);
+        await storage.setItem('idToken', 'a');
+        await storage.setItem('accessToken', 'b');
+        await storage.setItem('refreshToken', 'c');
+        await storage.setItem('signInSession', 'd');
+        expect(session.data.idToken).toBe('a');
+        expect(session.data.accessToken).toBe('b');
+        expect(session.data.refreshToken).toBe('c');
+        expect(session.data.signInSession).toBe('d');
+    });
+    it('can remove items', async () => {
+        const session = createSession();
+        const storage = createStorage(session);
+        await storage.setItem('idToken', 'a');
+        await storage.setItem('accessToken', 'b');
+        await storage.removeItem('accessToken');
+        expect(session.data.idToken).toBe('a');
+        expect(session.data.accessToken).toBeUndefined();
+    });
+    it('can get items', async () => {
+        const session = createSession();
+        const storage = createStorage(session);
+        await storage.setItem('accessToken', 'b');
+        const accessToken = await storage.getItem('accessToken');
+        const refreshToken = await storage.getItem('refreshToken');
+        expect(accessToken).toBe('b');
+        expect(refreshToken).toBeNull();
+    });
+});

package/lib/infrastructure/logto/get-context.d.ts

@@ -0,0 +1,11 @@
+import type { GetContextParameters, LogtoContext } from '@logto/node';
+import type { CreateLogtoClient } from './create-client.js';
+import type { LogtoStorage } from './create-storage.js';
+type GetContextResponse = {
+    readonly context: LogtoContext;
+};
+export declare const makeGetContext: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: GetContextParameters) => Promise<GetContextResponse>;
+export {};

package/lib/infrastructure/logto/get-context.js

@@ -0,0 +1,10 @@
+const makeGetContext = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const client = createClient();
+    const context = await client.getContext(request);
+    return {
+        context,
+    };
+};
+
+export { makeGetContext };

package/lib/infrastructure/logto/handle-sign-in-callback.d.ts

@@ -0,0 +1,14 @@
+import type { Session } from 'react-router';
+import type { CreateLogtoClient } from './create-client.js';
+import type { LogtoStorage } from './create-storage.js';
+type HandleSignInCallbackRequest = {
+    callbackUri: string;
+};
+type HandleSignInCallbackResponse = {
+    readonly session: Session;
+};
+export declare const makeHandleSignInCallback: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignInCallbackRequest) => Promise<HandleSignInCallbackResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-in-callback.js

@@ -0,0 +1,10 @@
+const makeHandleSignInCallback = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const client = createClient();
+    await client.handleSignInCallback(request.callbackUri);
+    return {
+        session: storage.session,
+    };
+};
+
+export { makeHandleSignInCallback };

package/lib/infrastructure/logto/handle-sign-in.d.ts

@@ -0,0 +1,15 @@
+import type { Session } from 'react-router';
+import type { CreateLogtoClient } from './create-client.js';
+import type { LogtoStorage } from './create-storage.js';
+type HandleSignInRequest = {
+    readonly redirectUri: string;
+};
+type HandleSignInResponse = {
+    readonly session: Session;
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignIn: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignInRequest) => Promise<HandleSignInResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-in.js

@@ -0,0 +1,28 @@
+class HandleSignInCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignInCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-in';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signIn(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignIn = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const command = HandleSignInCommand.fromDependencies({ createClient });
+    const { navigateToUrl } = await command.execute(request);
+    return {
+        session: storage.session,
+        navigateToUrl,
+    };
+};
+
+export { makeHandleSignIn };

package/lib/infrastructure/logto/handle-sign-out.d.ts

@@ -0,0 +1,11 @@
+import type { CreateLogtoClient } from './create-client.js';
+type HandleSignOutRequest = {
+    readonly redirectUri: string;
+};
+type HandleSignOutResponse = {
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignOut: (deps: {
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignOutRequest) => Promise<HandleSignOutResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-out.js

@@ -0,0 +1,24 @@
+class HandleSignOutCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignOutCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-in';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signOut(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignOut = (deps) => async (request) => {
+    const { createClient } = deps;
+    const command = HandleSignOutCommand.fromDependencies({ createClient });
+    return command.execute(request);
+};
+
+export { makeHandleSignOut };

package/lib/infrastructure/logto/handle-sign-up.d.ts

@@ -0,0 +1,15 @@
+import type { Session } from 'react-router';
+import type { CreateLogtoClient } from './create-client.js';
+import type { LogtoStorage } from './create-storage.js';
+type HandleSignUpRequest = {
+    readonly redirectUri: string;
+};
+type HandleSignUpResponse = {
+    readonly session: Session;
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignUp: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignUpRequest) => Promise<HandleSignUpResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-up.js

@@ -0,0 +1,28 @@
+class HandleSignUpCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignUpCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-up';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signIn({ redirectUri: request.redirectUri, interactionMode: 'signUp' });
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignUp = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const command = HandleSignUpCommand.fromDependencies({ createClient });
+    const { navigateToUrl } = await command.execute(request);
+    return {
+        session: storage.session,
+        navigateToUrl,
+    };
+};
+
+export { makeHandleSignUp };

package/lib/infrastructure/logto/index.d.ts

@@ -0,0 +1,32 @@
+import type { LogtoConfig } from '@logto/node';
+import type { Session } from 'react-router';
+type MakeLogtoAdapterConfiguration = LogtoConfig;
+export declare const makeLogtoAdapter: (config: MakeLogtoAdapterConfiguration) => (session: Session) => {
+    handleSignIn: (request: {
+        readonly redirectUri: string;
+    }) => Promise<{
+        readonly session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+        readonly navigateToUrl: string;
+    }>;
+    handleSignInCallback: (request: {
+        callbackUri: string;
+    }) => Promise<{
+        readonly session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+    }>;
+    handleSignOut: (request: {
+        readonly redirectUri: string;
+    }) => Promise<{
+        readonly navigateToUrl: string;
+    }>;
+    handleSignUp: (request: {
+        readonly redirectUri: string;
+    }) => Promise<{
+        readonly session: Session<import("react-router").SessionData, import("react-router").SessionData>;
+        readonly navigateToUrl: string;
+    }>;
+    getContext: (request: import("@logto/node").GetContextParameters) => Promise<{
+        readonly context: import("@logto/node").LogtoContext;
+    }>;
+};
+export type CreateLogtoAdapter = ReturnType<typeof makeLogtoAdapter>;
+export { type LogtoContext } from '@logto/node';