@logto/remix 1.1.0 → 1.1.2

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,5 @@
+'use strict';
+
+const getCookieHeaderFromRequest = (request) => request.headers.get('Cookie');
+
+exports.getCookieHeaderFromRequest = getCookieHeaderFromRequest;

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

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

package/lib/framework/mocks.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="jest" />
+import type { Session, SessionStorage } from '@remix-run/node';
+import type { CreateLogtoAdapter, LogtoContext } from '../infrastructure/logto';
+export declare const getContext: jest.Mock<Promise<{
+    context: LogtoContext;
+}>, []>;
+export declare const storage: import("../infrastructure/logto/create-storage").LogtoStorage;
+export declare const handleSignIn: jest.Mock<Promise<{
+    session: Session;
+    navigateToUrl: string;
+}>, []>;
+export declare const handleSignInCallback: jest.Mock<Promise<{
+    session: Session;
+}>, []>;
+export declare const handleSignOut: jest.Mock<Promise<{
+    navigateToUrl: string;
+}>, []>;
+export declare const createLogtoAdapter: CreateLogtoAdapter;
+export declare const commitSession: jest.Mock<Promise<string>, [session: Session]>;
+export declare const destroySession: jest.Mock<any, any>;
+export declare const getSession: jest.Mock<any, any>;
+export declare const sessionStorage: SessionStorage;

package/lib/index.d.ts

@@ -1,11 +1,9 @@
-import { GetContextParameters, LogtoConfig } from "@logto/node";
-import { SessionStorage } from "@remix-run/node";
-export { type LogtoConfig } from '@logto/node';
-export { type LogtoContext } from '@logto/node';
+import type { GetContextParameters, LogtoConfig } from '@logto/node';
+import type { SessionStorage } from '@remix-run/node';
 type Config = Readonly<LogtoConfig> & {
     readonly baseUrl: string;
 };
-export const makeLogtoRemix: (config: Config, deps: {
+export declare const makeLogtoRemix: (config: Config, deps: {
     sessionStorage: SessionStorage;
 }) => Readonly<{
     handleAuthRoutes: (dto: {
@@ -25,5 +23,3 @@ export const makeLogtoRemix: (config: Config, deps: {
     getContext: (dto: GetContextParameters) => (request: Request) => Promise<import("@logto/node").LogtoContext>;
 }>;
 export { type LogtoContext } from '@logto/node';
-
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,487 +1,24 @@
-var $1UY29$logtonode = require("@logto/node");
-var $1UY29$remixrunnode = require("@remix-run/node");
+'use strict';
 
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
-}
-function $parcel$interopDefault(a) {
-  return a && a.__esModule ? a.default : a;
-}
+var index$2 = require('./infrastructure/logto/index.js');
+var index$1 = require('./useCases/getContext/index.js');
+var index = require('./useCases/handleAuthRoutes/index.js');
 
-$parcel$export(module.exports, "makeLogtoRemix", () => $d280ab1184950f89$export$502a4d54d411a9fd);
-
-const $432ba72d919a1e72$export$60d790dda55ffee6 = (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 (0, ($parcel$interopDefault($1UY29$logtonode)))(config, {
-            storage: storage,
-            navigate: navigate
-        });
-    };
-
-
-class $0039633e49290279$var$LogtoStorage {
-    static fromSession = (session)=>{
-        return new $0039633e49290279$var$LogtoStorage({
-            session: 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 $0039633e49290279$export$d184a47a971dd4b9 = (session)=>$0039633e49290279$var$LogtoStorage.fromSession(session);
-
-
-const $9d7cd9eac4864785$export$f4d9bb4cf5d2b40c = (deps)=>async (request)=>{
-        const { storage: storage , createClient: createClient  } = deps;
-        const client = createClient();
-        const context = await client.getContext(request);
-        return {
-            context: context
-        };
-    };
-
-
-class $b6b640b5dde7b3d1$var$HandleSignInCommand {
-    static fromDependencies = (dependencies)=>new $b6b640b5dde7b3d1$var$HandleSignInCommand({
-            createClient: dependencies.createClient
-        });
-    constructor(properties){
-        this.properties = properties;
-        this.navigateToUrl = "/api/sign-in";
-    }
-    async execute(request) {
-        const { createClient: createClient  } = this.properties;
-        const client = createClient((url)=>{
-            this.navigateToUrl = url;
-        });
-        await client.signIn(request.redirectUri);
-        return {
-            navigateToUrl: this.navigateToUrl
-        };
-    }
-}
-const $b6b640b5dde7b3d1$export$3c00ad1b716e9134 = (deps)=>async (request)=>{
-        const { storage: storage , createClient: createClient  } = deps;
-        const command = $b6b640b5dde7b3d1$var$HandleSignInCommand.fromDependencies({
-            createClient: createClient
-        });
-        const { navigateToUrl: navigateToUrl  } = await command.execute(request);
-        return {
-            session: storage.session,
-            navigateToUrl: navigateToUrl
-        };
-    };
-
-
-const $ba5c5a17c0470429$export$9c07365b51e93ba3 = (deps)=>async (request)=>{
-        const { storage: storage , createClient: createClient  } = deps;
-        const client = createClient();
-        await client.handleSignInCallback(request.callbackUri);
-        return {
-            session: storage.session
-        };
-    };
-
-
-class $56983c96c6292b7b$var$HandleSignOutCommand {
-    static fromDependencies = (dependencies)=>new $56983c96c6292b7b$var$HandleSignOutCommand({
-            createClient: dependencies.createClient
-        });
-    constructor(properties){
-        this.properties = properties;
-        this.navigateToUrl = "/api/sign-in";
-    }
-    async execute(request) {
-        const { createClient: createClient  } = this.properties;
-        const client = createClient((url)=>{
-            this.navigateToUrl = url;
-        });
-        await client.signOut(request.redirectUri);
-        return {
-            navigateToUrl: this.navigateToUrl
-        };
-    }
-}
-const $56983c96c6292b7b$export$89f18ff1488dade0 = (deps)=>async (request)=>{
-        const { createClient: createClient  } = deps;
-        const command = $56983c96c6292b7b$var$HandleSignOutCommand.fromDependencies({
-            createClient: createClient
-        });
-        return command.execute(request);
-    };
-
-
-const $a4e270a96c0fa97a$export$5e1ab578feca185a = (config)=>(session)=>{
-        const storage = (0, $0039633e49290279$export$d184a47a971dd4b9)(session);
-        const createClient = (0, $432ba72d919a1e72$export$60d790dda55ffee6)(config, storage);
-        return {
-            handleSignIn: (0, $b6b640b5dde7b3d1$export$3c00ad1b716e9134)({
-                storage: storage,
-                createClient: createClient
-            }),
-            handleSignInCallback: (0, $ba5c5a17c0470429$export$9c07365b51e93ba3)({
-                storage: storage,
-                createClient: createClient
-            }),
-            handleSignOut: (0, $56983c96c6292b7b$export$89f18ff1488dade0)({
-                createClient: createClient
-            }),
-            getContext: (0, $9d7cd9eac4864785$export$f4d9bb4cf5d2b40c)({
-                storage: storage,
-                createClient: createClient
-            })
-        };
-    };
-
-
-const $a8afe3841584871e$export$5c6fae4c79d686e4 = (request)=>request.headers.get("Cookie");
-
-
-class $5ea2bffde4379db3$export$32386402b3f0a45 {
-    static fromDto = (dto)=>new $5ea2bffde4379db3$export$32386402b3f0a45(dto);
-    constructor(properties){
-        this.properties = properties;
-        this.useCase = this.properties.useCase;
-        this.execute = async (request)=>{
-            const cookieHeader = (0, $a8afe3841584871e$export$5c6fae4c79d686e4)(request);
-            const result = await this.useCase({
-                cookieHeader: cookieHeader ?? undefined,
-                ...this.properties
-            });
-            return result.context;
-        };
-    }
-}
-
-
-const $b710f2274063a387$export$53ae38c062671653 = (deps)=>async (request)=>{
-        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
-        const session = await sessionStorage.getSession(request.cookieHeader);
-        const logto = createLogtoAdapter(session);
-        const response = await logto.getContext(request);
-        return {
-            context: response.context
-        };
-    };
-
-
-const $10ac017bdfe3e60c$export$f4d9bb4cf5d2b40c = (dto, deps)=>async (request)=>{
-        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
-        const useCase = (0, $b710f2274063a387$export$53ae38c062671653)({
-            createLogtoAdapter: createLogtoAdapter,
-            sessionStorage: sessionStorage
-        });
-        const controller = (0, $5ea2bffde4379db3$export$32386402b3f0a45).fromDto({
-            useCase: useCase,
-            ...dto
-        });
-        return controller.execute(request);
-    };
-
-
-
-
-class $29dab4b4aca0abe0$export$8bb8370a824a554b {
-    static fromDto = (dto)=>new $29dab4b4aca0abe0$export$8bb8370a824a554b({
-            useCase: dto.useCase,
-            redirectUri: dto.redirectUri
-        });
-    constructor(properties){
-        this.properties = properties;
-        this.useCase = this.properties.useCase;
-        this.redirectUri = this.properties.redirectUri;
-        this.execute = async (request)=>{
-            const cookieHeader = (0, $a8afe3841584871e$export$5c6fae4c79d686e4)(request);
-            const { redirectUri: redirectUri  } = this;
-            const result = await this.useCase({
-                cookieHeader: cookieHeader ?? undefined,
-                redirectUri: redirectUri
-            });
-            return (0, $1UY29$remixrunnode.redirect)(result.navigateToUrl, {
-                headers: {
-                    "Set-Cookie": result.cookieHeader
-                }
-            });
-        };
-    }
-}
-
-
-const $c230f3a04bd8ec78$export$463099392e1e6404 = (deps)=>async (request)=>{
-        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
-        const session = await sessionStorage.getSession(request.cookieHeader);
-        const logto = createLogtoAdapter(session);
-        const response = await logto.handleSignIn({
-            redirectUri: request.redirectUri
-        });
-        const cookieHeader = await sessionStorage.commitSession(response.session);
-        return {
-            cookieHeader: cookieHeader,
-            navigateToUrl: response.navigateToUrl
-        };
-    };
-
-
-const $7d87cb1bafa09779$export$3c00ad1b716e9134 = (dto, deps)=>async (request)=>{
-        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
-        const useCase = (0, $c230f3a04bd8ec78$export$463099392e1e6404)({
-            createLogtoAdapter: createLogtoAdapter,
-            sessionStorage: sessionStorage
-        });
-        const controller = (0, $29dab4b4aca0abe0$export$8bb8370a824a554b).fromDto({
-            useCase: useCase,
-            redirectUri: dto.redirectBackTo
-        });
-        return controller.execute(request);
-    };
-
-
-
-
-class $bacebc5f40652238$export$144a9ac3253d5e56 extends Error {
-    static becauseNoCookieHeaderPresent = ()=>new $bacebc5f40652238$export$144a9ac3253d5e56({
-            code: 1665388541,
-            message: `The authentication sign-in callback route can't be accessed without a valid cookie.`
-        });
-    constructor(properties){
-        super(`#[${properties.code}] ${properties.message}`);
-        this.properties = properties;
-        this.code = this.properties.code;
-        this.cause = this.properties.cause;
-        this.plainMessage = this.properties.message;
-    }
-}
-
-
-class $c35099547b1a0858$export$c8d670afaf17c618 {
-    static fromDto = (dto)=>new $c35099547b1a0858$export$c8d670afaf17c618({
-            useCase: dto.useCase,
-            redirectUri: dto.redirectUri
-        });
-    constructor(properties){
-        this.properties = properties;
-        this.useCase = this.properties.useCase;
-        this.redirectUri = this.properties.redirectUri;
-        this.execute = async (request)=>{
-            const cookieHeader = (0, $a8afe3841584871e$export$5c6fae4c79d686e4)(request);
-            if (!cookieHeader) throw (0, $bacebc5f40652238$export$144a9ac3253d5e56).becauseNoCookieHeaderPresent();
-            // In some scenarios, like performing the sign-in callback within a Gitpod
-            // environment, the load balancer rewrites the URL and uses `http` as the
-            // protocol. Here, we make sure that when the `x-forwarded-proto` HTTP header
-            // is present, we will replace `http` with `https` in the `callbackUri`.
-            const isForwardedHttpsTraffic = request.headers.get("x-forwarded-proto") === "https";
-            const callbackUri = isForwardedHttpsTraffic ? request.url.replace("http", "https") : request.url;
-            const result = await this.useCase({
-                cookieHeader: cookieHeader,
-                callbackUri: callbackUri
-            });
-            return (0, $1UY29$remixrunnode.redirect)(this.redirectUri, {
-                headers: {
-                    "Set-Cookie": result.cookieHeader
-                }
-            });
-        };
-    }
-}
-
-
-const $3ae3cea103e3f353$export$22e357c661ee13a4 = (deps)=>async (request)=>{
-        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
-        const session = await sessionStorage.getSession(request.cookieHeader);
-        const logto = createLogtoAdapter(session);
-        const response = await logto.handleSignInCallback({
-            callbackUri: request.callbackUri
-        });
-        const cookieHeader = await sessionStorage.commitSession(response.session);
-        return {
-            cookieHeader: cookieHeader
-        };
-    };
-
-
-const $4df2ab785be2e3b0$export$9c07365b51e93ba3 = (dto, deps)=>async (request)=>{
-        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
-        const useCase = (0, $3ae3cea103e3f353$export$22e357c661ee13a4)({
-            createLogtoAdapter: createLogtoAdapter,
-            sessionStorage: sessionStorage
-        });
-        const controller = (0, $c35099547b1a0858$export$c8d670afaf17c618).fromDto({
-            useCase: useCase,
-            redirectUri: dto.redirectBackTo
-        });
-        return controller.execute(request);
-    };
-
-
-
-
-class $b7dcd894e0be6905$export$e01614cfebe90908 extends Error {
-    static becauseNoCookieHeaderPresent = ()=>new $b7dcd894e0be6905$export$e01614cfebe90908({
-            code: 1665388713,
-            message: `The authentication sign-out route can't be accessed without a valid cookie.`
-        });
-    constructor(properties){
-        super(`#[${properties.code}] ${properties.message}`);
-        this.properties = properties;
-        this.code = this.properties.code;
-        this.cause = this.properties.cause;
-        this.plainMessage = this.properties.message;
-    }
-}
-
-
-class $1791a93b2ba8efd2$export$543cea0b68ca8887 {
-    static fromDto = (dto)=>new $1791a93b2ba8efd2$export$543cea0b68ca8887({
-            useCase: dto.useCase,
-            redirectUri: dto.redirectUri
-        });
-    constructor(properties){
-        this.properties = properties;
-        this.useCase = this.properties.useCase;
-        this.redirectUri = this.properties.redirectUri;
-        this.execute = async (request)=>{
-            const cookieHeader = (0, $a8afe3841584871e$export$5c6fae4c79d686e4)(request);
-            if (!cookieHeader) throw (0, $b7dcd894e0be6905$export$e01614cfebe90908).becauseNoCookieHeaderPresent();
-            const result = await this.useCase({
-                cookieHeader: cookieHeader,
-                redirectUri: this.redirectUri
-            });
-            return (0, $1UY29$remixrunnode.redirect)(result.navigateToUrl, {
-                headers: {
-                    "Set-Cookie": result.cookieHeader
-                }
-            });
-        };
-    }
-}
-
-
-const $fb309dcd4b062524$export$8ccb0e4b7ccc1fc4 = (deps)=>async (request)=>{
-        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
-        const session = await sessionStorage.getSession(request.cookieHeader);
-        const logto = createLogtoAdapter(session);
-        const response = await logto.handleSignOut({
-            redirectUri: request.redirectUri
-        });
-        const cookieHeader = await sessionStorage.destroySession(session);
-        return {
-            cookieHeader: cookieHeader,
-            navigateToUrl: response.navigateToUrl
-        };
-    };
-
-
-const $af9527187f2d8283$export$89f18ff1488dade0 = (dto, deps)=>async (request)=>{
-        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
-        const useCase = (0, $fb309dcd4b062524$export$8ccb0e4b7ccc1fc4)({
-            createLogtoAdapter: createLogtoAdapter,
-            sessionStorage: sessionStorage
-        });
-        const controller = (0, $1791a93b2ba8efd2$export$543cea0b68ca8887).fromDto({
-            useCase: useCase,
-            redirectUri: dto.redirectBackTo
-        });
-        return controller.execute(request);
-    };
-
-
-class $39dd7d8d62a3df87$export$fcbf49abe9908796 extends Error {
-    static becauseNoConfigForPath = (anticipatedPath)=>new $39dd7d8d62a3df87$export$fcbf49abe9908796({
-            code: 1665388277,
-            message: `No configuration available for path "${anticipatedPath}".`
-        });
-    static becauseOfUnknownRoute = (anticipatedConfigKey)=>new $39dd7d8d62a3df87$export$fcbf49abe9908796({
-            code: 1665388278,
-            message: `The config key "${anticipatedConfigKey}" is invalid.`
-        });
-    constructor(properties){
-        super(`#[${properties.code}] ${properties.message}`);
-        this.properties = properties;
-        this.code = this.properties.code;
-        this.cause = this.properties.cause;
-        this.plainMessage = this.properties.message;
-    }
-}
-
-
-const $85c2f13c6554a877$export$d6e32a8c2b1ad7f3 = (deps)=>(dto)=>async ({ request: request  })=>{
-            const anticipatedPath = new URL(request.url).pathname;
-            /* eslint-disable no-restricted-syntax */ const configKey = Object.keys(dto).find((type)=>dto[type].path === anticipatedPath);
-            const configExists = Boolean(configKey);
-            /* eslint-enable no-restricted-syntax */ if (!configExists) throw (0, $39dd7d8d62a3df87$export$fcbf49abe9908796).becauseNoConfigForPath(anticipatedPath);
-            const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter , baseUrl: baseUrl  } = deps;
-            const config = dto[configKey];
-            switch(configKey){
-                case "sign-in":
-                    {
-                        const handler = (0, $7d87cb1bafa09779$export$3c00ad1b716e9134)({
-                            redirectBackTo: `${baseUrl}${config.redirectBackTo}`
-                        }, {
-                            sessionStorage: sessionStorage,
-                            createLogtoAdapter: createLogtoAdapter
-                        });
-                        return handler(request);
-                    }
-                case "sign-in-callback":
-                    {
-                        const handler = (0, $4df2ab785be2e3b0$export$9c07365b51e93ba3)({
-                            redirectBackTo: `${baseUrl}${config.redirectBackTo}`
-                        }, {
-                            sessionStorage: sessionStorage,
-                            createLogtoAdapter: createLogtoAdapter
-                        });
-                        return handler(request);
-                    }
-                case "sign-out":
-                    {
-                        const handler = (0, $af9527187f2d8283$export$89f18ff1488dade0)({
-                            redirectBackTo: `${baseUrl}${config.redirectBackTo}`
-                        }, {
-                            sessionStorage: sessionStorage,
-                            createLogtoAdapter: createLogtoAdapter
-                        });
-                        return handler(request);
-                    }
-                default:
-                    throw (0, $39dd7d8d62a3df87$export$fcbf49abe9908796).becauseOfUnknownRoute(configKey);
-            }
-        };
-
-
-const $d280ab1184950f89$export$502a4d54d411a9fd = (config, deps)=>{
-    const { sessionStorage: sessionStorage  } = deps;
-    const { baseUrl: baseUrl  } = config;
-    const createLogtoAdapter = (0, $a4e270a96c0fa97a$export$5e1ab578feca185a)(config);
+const makeLogtoRemix = (config, deps) => {
+    const { sessionStorage } = deps;
+    const { baseUrl } = config;
+    const createLogtoAdapter = index$2.makeLogtoAdapter(config);
     return Object.freeze({
-        handleAuthRoutes: (0, $85c2f13c6554a877$export$d6e32a8c2b1ad7f3)({
-            baseUrl: baseUrl,
-            createLogtoAdapter: createLogtoAdapter,
-            sessionStorage: sessionStorage
+        handleAuthRoutes: index.makeHandleAuthRoutes({
+            baseUrl,
+            createLogtoAdapter,
+            sessionStorage,
+        }),
+        getContext: (dto) => index$1.makeGetContext(dto, {
+            createLogtoAdapter,
+            sessionStorage,
         }),
-        getContext: (dto)=>(0, $10ac017bdfe3e60c$export$f4d9bb4cf5d2b40c)(dto, {
-                createLogtoAdapter: createLogtoAdapter,
-                sessionStorage: sessionStorage
-            })
     });
 };
 
-
-//# sourceMappingURL=index.js.map
+exports.makeLogtoRemix = makeLogtoRemix;

package/lib/index.mjs

@@ -0,0 +1,22 @@
+import { makeLogtoAdapter } from './infrastructure/logto/index.mjs';
+import { makeGetContext } from './useCases/getContext/index.mjs';
+import { makeHandleAuthRoutes } from './useCases/handleAuthRoutes/index.mjs';
+
+const makeLogtoRemix = (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 { makeLogtoRemix };

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';
+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,17 @@
+'use strict';
+
+var LogtoClient = require('@logto/node');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var LogtoClient__default = /*#__PURE__*/_interopDefault(LogtoClient);
+
+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__default.default(config, { storage, navigate });
+};
+
+exports.makeLogtoClient = makeLogtoClient;

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

@@ -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-storage.d.ts

@@ -0,0 +1,14 @@
+import type { Storage, StorageKey } from '@logto/node';
+import type { Session } from '@remix-run/node';
+declare class LogtoStorage implements Storage {
+    private readonly properties;
+    static readonly fromSession: (session: Session) => LogtoStorage;
+    readonly session: Session;
+    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,30 @@
+'use strict';
+
+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);
+
+exports.createStorage = createStorage;