@logto/next 2.0.0 → 2.1.1

package/lib/edge/index.cjs

@@ -2,25 +2,76 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var NodeClient = require('@logto/node/edge');
+var edge = require('iron-session/edge');
 var client = require('../src/client.cjs');
-var index = require('./iron-session-edge/index.cjs');
-var NodeClient = require('@logto/node');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var NodeClient__default = /*#__PURE__*/_interopDefault(NodeClient);
 
 class LogtoClient extends client.default {
     constructor(config) {
         super(config, {
-            withIronSessionApiRoute: index.withIronSessionApiRoute,
-            withIronSessionSsr: index.withIronSessionSsr,
+            NodeClient: NodeClient__default.default,
         });
+        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await edge.getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signIn(redirectUri, interactionMode);
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await edge.getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signOut(redirectUri);
+            session.destroy();
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+                headers: {
+                    Location: redirectTo,
+                },
+            });
+            const session = await edge.getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            if (request.url) {
+                await nodeClient.handleSignInCallback(request.url);
+                await this.storage?.save();
+            }
+            return response;
+        };
+        this.handleUser = (configs) => async (request) => {
+            const context = await this.getLogtoContext(request, configs);
+            return new Response(JSON.stringify(context), {
+                status: 200,
+                headers: {
+                    'content-type': 'application/json',
+                },
+            });
+        };
+        this.getLogtoContext = async (request, config = {}) => {
+            const session = await edge.getIronSession(request, new Response(), this.ironSessionConfigs);
+            const context = await this.getLogtoUserFromRequest(session, config);
+            return context;
+        };
     }
 }
 
-Object.defineProperty(exports, 'ReservedScope', {
-    enumerable: true,
-    get: function () { return NodeClient.ReservedScope; }
-});
-Object.defineProperty(exports, 'UserScope', {
-    enumerable: true,
-    get: function () { return NodeClient.UserScope; }
-});
 exports.default = LogtoClient;

package/lib/edge/index.d.ts

@@ -1,7 +1,13 @@
+import { type GetContextParameters, type InteractionMode } from '@logto/node';
+import { type NextRequest } from 'next/server';
 import BaseClient from '../src/client';
 import type { LogtoNextConfig } from '../src/types.js';
-export { ReservedScope, UserScope } from '@logto/node';
 export type { LogtoContext, InteractionMode } from '@logto/node';
 export default class LogtoClient extends BaseClient {
     constructor(config: LogtoNextConfig);
+    handleSignIn: (redirectUri?: string, interactionMode?: InteractionMode) => (request: NextRequest) => Promise<Response>;
+    handleSignOut: (redirectUri?: string) => (request: NextRequest) => Promise<Response>;
+    handleSignInCallback: (redirectTo?: string) => (request: NextRequest) => Promise<Response>;
+    handleUser: (configs?: GetContextParameters) => (request: NextRequest) => Promise<Response>;
+    getLogtoContext: (request: NextRequest, config?: GetContextParameters) => Promise<import("@logto/node").LogtoContext>;
 }

package/lib/edge/index.js

@@ -1,13 +1,68 @@
+import NodeClient from '@logto/node/edge';
+import { getIronSession } from 'iron-session/edge';
 import LogtoNextBaseClient from '../src/client.js';
-import { withIronSessionApiRoute, withIronSessionSsr } from './iron-session-edge/index.js';
-export { ReservedScope, UserScope } from '@logto/node';
 
 class LogtoClient extends LogtoNextBaseClient {
     constructor(config) {
         super(config, {
-            withIronSessionApiRoute,
-            withIronSessionSsr,
+            NodeClient,
         });
+        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signIn(redirectUri, interactionMode);
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signOut(redirectUri);
+            session.destroy();
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+                headers: {
+                    Location: redirectTo,
+                },
+            });
+            const session = await getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            if (request.url) {
+                await nodeClient.handleSignInCallback(request.url);
+                await this.storage?.save();
+            }
+            return response;
+        };
+        this.handleUser = (configs) => async (request) => {
+            const context = await this.getLogtoContext(request, configs);
+            return new Response(JSON.stringify(context), {
+                status: 200,
+                headers: {
+                    'content-type': 'application/json',
+                },
+            });
+        };
+        this.getLogtoContext = async (request, config = {}) => {
+            const session = await getIronSession(request, new Response(), this.ironSessionConfigs);
+            const context = await this.getLogtoUserFromRequest(session, config);
+            return context;
+        };
     }
 }
 

package/lib/src/client.cjs

@@ -2,80 +2,16 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var NodeClient = require('@logto/node');
 var storage = require('./storage.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var NodeClient__default = /*#__PURE__*/_interopDefault(NodeClient);
-
 class LogtoNextBaseClient {
     constructor(config, adapters) {
         this.config = config;
         this.adapters = adapters;
-        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
-            await nodeClient.signIn(redirectUri, interactionMode);
-            await this.storage?.save();
-            if (this.navigateUrl) {
-                response.redirect(this.navigateUrl);
-            }
-        }, this.ironSessionConfigs);
-        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
-            if (request.url) {
-                await nodeClient.handleSignInCallback(`${this.config.baseUrl}${request.url}`);
-                await this.storage?.save();
-                response.redirect(redirectTo);
-            }
-        }, this.ironSessionConfigs);
-        this.handleSignOut = (redirectUri = this.config.baseUrl) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
-            await nodeClient.signOut(redirectUri);
-            request.session.destroy();
-            await this.storage?.save();
-            if (this.navigateUrl) {
-                response.redirect(this.navigateUrl);
-            }
-        }, this.ironSessionConfigs);
-        this.handleUser = (configs) => this.withLogtoApiRoute((request, response) => {
-            response.json(request.user);
-        }, configs);
-        this.handleAuthRoutes = (configs) => (request, response) => {
-            const { action } = request.query;
-            if (action === 'sign-in') {
-                return this.handleSignIn()(request, response);
-            }
-            if (action === 'sign-up') {
-                return this.handleSignIn(undefined, 'signUp')(request, response);
-            }
-            if (action === 'sign-in-callback') {
-                return this.handleSignInCallback()(request, response);
-            }
-            if (action === 'sign-out') {
-                return this.handleSignOut()(request, response);
-            }
-            if (action === 'user') {
-                return this.handleUser(configs)(request, response);
-            }
-            response.status(404).end();
-        };
-        this.withLogtoApiRoute = (handler, config = {}) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const user = await this.getLogtoUserFromRequest(request, config);
-            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-            Object.defineProperty(request, 'user', { enumerable: true, get: () => user });
-            return handler(request, response);
-        }, this.ironSessionConfigs);
-        this.withLogtoSsr = (handler, configs = {}) => this.adapters.withIronSessionSsr(async (context) => {
-            const user = await this.getLogtoUserFromRequest(context.req, configs);
-            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-            Object.defineProperty(context.req, 'user', { enumerable: true, get: () => user });
-            return handler(context);
-        }, this.ironSessionConfigs);
     }
-    createNodeClient(request) {
-        this.storage = new storage.default(request);
-        return new NodeClient__default.default(this.config, {
+    createNodeClient(session) {
+        this.storage = new storage.default(session);
+        return new this.adapters.NodeClient(this.config, {
             storage: this.storage,
             navigate: (url) => {
                 this.navigateUrl = url;
@@ -92,8 +28,8 @@ class LogtoNextBaseClient {
             },
         };
     }
-    async getLogtoUserFromRequest(request, configs) {
-        const nodeClient = this.createNodeClient(request);
+    async getLogtoUserFromRequest(session, configs) {
+        const nodeClient = this.createNodeClient(session);
         return nodeClient.getContext(configs);
     }
 }

package/lib/src/client.d.ts

@@ -1,20 +1,21 @@
-import type { GetContextParameters, InteractionMode } from '@logto/node';
-import type { GetServerSidePropsContext, GetServerSidePropsResult, NextApiHandler } from 'next';
+import type { GetContextParameters } from '@logto/node';
+import { type IronSession } from 'iron-session';
+import NextStorage from './storage';
 import type { Adapters, LogtoNextConfig } from './types';
 export default class LogtoNextBaseClient {
-    private readonly config;
-    private readonly adapters;
-    private navigateUrl?;
-    private storage?;
+    protected readonly config: LogtoNextConfig;
+    protected readonly adapters: Adapters;
+    protected navigateUrl?: string;
+    protected storage?: NextStorage;
     constructor(config: LogtoNextConfig, adapters: Adapters);
-    handleSignIn: (redirectUri?: string, interactionMode?: InteractionMode) => NextApiHandler;
-    handleSignInCallback: (redirectTo?: string) => NextApiHandler;
-    handleSignOut: (redirectUri?: string) => NextApiHandler;
-    handleUser: (configs?: GetContextParameters) => NextApiHandler;
-    handleAuthRoutes: (configs?: GetContextParameters) => NextApiHandler;
-    withLogtoApiRoute: (handler: NextApiHandler, config?: GetContextParameters) => NextApiHandler;
-    withLogtoSsr: <P extends Record<string, unknown> = Record<string, unknown>>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, configs?: GetContextParameters) => (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
-    private createNodeClient;
-    private get ironSessionConfigs();
-    private getLogtoUserFromRequest;
+    protected createNodeClient(session: IronSession): import("@logto/node").default;
+    protected get ironSessionConfigs(): {
+        cookieName: string;
+        password: string;
+        cookieOptions: {
+            secure: boolean;
+            maxAge: number;
+        };
+    };
+    protected getLogtoUserFromRequest(session: IronSession, configs: GetContextParameters): Promise<import("@logto/node").LogtoContext>;
 }

package/lib/src/client.js

@@ -1,73 +1,13 @@
-import NodeClient from '@logto/node';
 import NextStorage from './storage.js';
 
 class LogtoNextBaseClient {
     constructor(config, adapters) {
         this.config = config;
         this.adapters = adapters;
-        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
-            await nodeClient.signIn(redirectUri, interactionMode);
-            await this.storage?.save();
-            if (this.navigateUrl) {
-                response.redirect(this.navigateUrl);
-            }
-        }, this.ironSessionConfigs);
-        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
-            if (request.url) {
-                await nodeClient.handleSignInCallback(`${this.config.baseUrl}${request.url}`);
-                await this.storage?.save();
-                response.redirect(redirectTo);
-            }
-        }, this.ironSessionConfigs);
-        this.handleSignOut = (redirectUri = this.config.baseUrl) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
-            await nodeClient.signOut(redirectUri);
-            request.session.destroy();
-            await this.storage?.save();
-            if (this.navigateUrl) {
-                response.redirect(this.navigateUrl);
-            }
-        }, this.ironSessionConfigs);
-        this.handleUser = (configs) => this.withLogtoApiRoute((request, response) => {
-            response.json(request.user);
-        }, configs);
-        this.handleAuthRoutes = (configs) => (request, response) => {
-            const { action } = request.query;
-            if (action === 'sign-in') {
-                return this.handleSignIn()(request, response);
-            }
-            if (action === 'sign-up') {
-                return this.handleSignIn(undefined, 'signUp')(request, response);
-            }
-            if (action === 'sign-in-callback') {
-                return this.handleSignInCallback()(request, response);
-            }
-            if (action === 'sign-out') {
-                return this.handleSignOut()(request, response);
-            }
-            if (action === 'user') {
-                return this.handleUser(configs)(request, response);
-            }
-            response.status(404).end();
-        };
-        this.withLogtoApiRoute = (handler, config = {}) => this.adapters.withIronSessionApiRoute(async (request, response) => {
-            const user = await this.getLogtoUserFromRequest(request, config);
-            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-            Object.defineProperty(request, 'user', { enumerable: true, get: () => user });
-            return handler(request, response);
-        }, this.ironSessionConfigs);
-        this.withLogtoSsr = (handler, configs = {}) => this.adapters.withIronSessionSsr(async (context) => {
-            const user = await this.getLogtoUserFromRequest(context.req, configs);
-            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-            Object.defineProperty(context.req, 'user', { enumerable: true, get: () => user });
-            return handler(context);
-        }, this.ironSessionConfigs);
     }
-    createNodeClient(request) {
-        this.storage = new NextStorage(request);
-        return new NodeClient(this.config, {
+    createNodeClient(session) {
+        this.storage = new NextStorage(session);
+        return new this.adapters.NodeClient(this.config, {
             storage: this.storage,
             navigate: (url) => {
                 this.navigateUrl = url;
@@ -84,8 +24,8 @@ class LogtoNextBaseClient {
             },
         };
     }
-    async getLogtoUserFromRequest(request, configs) {
-        const nodeClient = this.createNodeClient(request);
+    async getLogtoUserFromRequest(session, configs) {
+        const nodeClient = this.createNodeClient(session);
         return nodeClient.getContext(configs);
     }
 }

package/lib/src/index.cjs

@@ -2,16 +2,78 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var NodeClient = require('@logto/node');
 var next = require('iron-session/next');
 var client = require('./client.cjs');
-var NodeClient = require('@logto/node');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var NodeClient__default = /*#__PURE__*/_interopDefault(NodeClient);
 
 class LogtoClient extends client.default {
     constructor(config) {
         super(config, {
-            withIronSessionApiRoute: next.withIronSessionApiRoute,
-            withIronSessionSsr: next.withIronSessionSsr,
+            NodeClient: NodeClient__default.default,
         });
+        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => next.withIronSessionApiRoute(async (request, response) => {
+            const nodeClient = this.createNodeClient(request.session);
+            await nodeClient.signIn(redirectUri, interactionMode);
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.redirect(this.navigateUrl);
+            }
+        }, this.ironSessionConfigs);
+        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => next.withIronSessionApiRoute(async (request, response) => {
+            const nodeClient = this.createNodeClient(request.session);
+            if (request.url) {
+                await nodeClient.handleSignInCallback(`${this.config.baseUrl}${request.url}`);
+                await this.storage?.save();
+                response.redirect(redirectTo);
+            }
+        }, this.ironSessionConfigs);
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => next.withIronSessionApiRoute(async (request, response) => {
+            const nodeClient = this.createNodeClient(request.session);
+            await nodeClient.signOut(redirectUri);
+            request.session.destroy();
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.redirect(this.navigateUrl);
+            }
+        }, this.ironSessionConfigs);
+        this.handleUser = (configs) => this.withLogtoApiRoute((request, response) => {
+            response.json(request.user);
+        }, configs);
+        this.handleAuthRoutes = (configs) => (request, response) => {
+            const { action } = request.query;
+            if (action === 'sign-in') {
+                return this.handleSignIn()(request, response);
+            }
+            if (action === 'sign-up') {
+                return this.handleSignIn(undefined, 'signUp')(request, response);
+            }
+            if (action === 'sign-in-callback') {
+                return this.handleSignInCallback()(request, response);
+            }
+            if (action === 'sign-out') {
+                return this.handleSignOut()(request, response);
+            }
+            if (action === 'user') {
+                return this.handleUser(configs)(request, response);
+            }
+            response.status(404).end();
+        };
+        this.withLogtoApiRoute = (handler, config = {}) => next.withIronSessionApiRoute(async (request, response) => {
+            const user = await this.getLogtoUserFromRequest(request.session, config);
+            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
+            Object.defineProperty(request, 'user', { enumerable: true, get: () => user });
+            return handler(request, response);
+        }, this.ironSessionConfigs);
+        this.withLogtoSsr = (handler, configs = {}) => next.withIronSessionSsr(async (context) => {
+            const user = await this.getLogtoUserFromRequest(context.req.session, configs);
+            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
+            Object.defineProperty(context.req, 'user', { enumerable: true, get: () => user });
+            return handler(context);
+        }, this.ironSessionConfigs);
     }
 }
 

package/lib/src/index.d.ts

@@ -1,7 +1,16 @@
+import { type GetContextParameters, type InteractionMode } from '@logto/node';
+import { type GetServerSidePropsResult, type GetServerSidePropsContext, type NextApiHandler } from 'next';
 import LogtoNextBaseClient from './client.js';
 import type { LogtoNextConfig } from './types.js';
 export { ReservedScope, UserScope } from '@logto/node';
 export type { LogtoContext, InteractionMode } from '@logto/node';
 export default class LogtoClient extends LogtoNextBaseClient {
     constructor(config: LogtoNextConfig);
+    handleSignIn: (redirectUri?: string, interactionMode?: InteractionMode) => NextApiHandler;
+    handleSignInCallback: (redirectTo?: string) => NextApiHandler;
+    handleSignOut: (redirectUri?: string) => NextApiHandler;
+    handleUser: (configs?: GetContextParameters) => NextApiHandler;
+    handleAuthRoutes: (configs?: GetContextParameters) => NextApiHandler;
+    withLogtoApiRoute: (handler: NextApiHandler, config?: GetContextParameters) => NextApiHandler;
+    withLogtoSsr: <P extends Record<string, unknown> = Record<string, unknown>>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, configs?: GetContextParameters) => (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
 }

package/lib/src/index.js

@@ -1,13 +1,72 @@
+import NodeClient from '@logto/node';
+export { ReservedScope, UserScope } from '@logto/node';
 import { withIronSessionApiRoute, withIronSessionSsr } from 'iron-session/next';
 import LogtoNextBaseClient from './client.js';
-export { ReservedScope, UserScope } from '@logto/node';
 
 class LogtoClient extends LogtoNextBaseClient {
     constructor(config) {
         super(config, {
-            withIronSessionApiRoute,
-            withIronSessionSsr,
+            NodeClient,
         });
+        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => withIronSessionApiRoute(async (request, response) => {
+            const nodeClient = this.createNodeClient(request.session);
+            await nodeClient.signIn(redirectUri, interactionMode);
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.redirect(this.navigateUrl);
+            }
+        }, this.ironSessionConfigs);
+        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => withIronSessionApiRoute(async (request, response) => {
+            const nodeClient = this.createNodeClient(request.session);
+            if (request.url) {
+                await nodeClient.handleSignInCallback(`${this.config.baseUrl}${request.url}`);
+                await this.storage?.save();
+                response.redirect(redirectTo);
+            }
+        }, this.ironSessionConfigs);
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => withIronSessionApiRoute(async (request, response) => {
+            const nodeClient = this.createNodeClient(request.session);
+            await nodeClient.signOut(redirectUri);
+            request.session.destroy();
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.redirect(this.navigateUrl);
+            }
+        }, this.ironSessionConfigs);
+        this.handleUser = (configs) => this.withLogtoApiRoute((request, response) => {
+            response.json(request.user);
+        }, configs);
+        this.handleAuthRoutes = (configs) => (request, response) => {
+            const { action } = request.query;
+            if (action === 'sign-in') {
+                return this.handleSignIn()(request, response);
+            }
+            if (action === 'sign-up') {
+                return this.handleSignIn(undefined, 'signUp')(request, response);
+            }
+            if (action === 'sign-in-callback') {
+                return this.handleSignInCallback()(request, response);
+            }
+            if (action === 'sign-out') {
+                return this.handleSignOut()(request, response);
+            }
+            if (action === 'user') {
+                return this.handleUser(configs)(request, response);
+            }
+            response.status(404).end();
+        };
+        this.withLogtoApiRoute = (handler, config = {}) => withIronSessionApiRoute(async (request, response) => {
+            const user = await this.getLogtoUserFromRequest(request.session, config);
+            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
+            Object.defineProperty(request, 'user', { enumerable: true, get: () => user });
+            return handler(request, response);
+        }, this.ironSessionConfigs);
+        this.withLogtoSsr = (handler, configs = {}) => withIronSessionSsr(async (context) => {
+            const user = await this.getLogtoUserFromRequest(context.req.session, configs);
+            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
+            Object.defineProperty(context.req, 'user', { enumerable: true, get: () => user });
+            return handler(context);
+        }, this.ironSessionConfigs);
     }
 }
 

package/lib/src/storage.cjs

@@ -3,30 +3,30 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class NextStorage {
-    constructor(request) {
-        this.request = request;
+    constructor(session) {
+        this.session = session;
         this.sessionChanged = false;
     }
     async setItem(key, value) {
-        this.request.session[key] = value;
+        this.session[key] = value;
         this.sessionChanged = true;
     }
     async getItem(key) {
-        const value = this.request.session[key];
+        const value = this.session[key];
         if (value === undefined) {
             return null;
         }
         return String(value);
     }
     async removeItem(key) {
-        this.request.session[key] = undefined;
+        this.session[key] = undefined;
         this.sessionChanged = true;
     }
     async save() {
         if (!this.sessionChanged) {
             return;
         }
-        await this.request.session.save();
+        await this.session.save();
         this.sessionChanged = false;
     }
 }

package/lib/src/storage.d.ts

@@ -1,9 +1,9 @@
-import type { IncomingMessage } from 'http';
 import type { Storage, StorageKey } from '@logto/node';
+import { type IronSession } from 'iron-session';
 export default class NextStorage implements Storage {
-    private readonly request;
+    private readonly session;
     private sessionChanged;
-    constructor(request: IncomingMessage);
+    constructor(session: IronSession);
     setItem(key: StorageKey, value: string): Promise<void>;
     getItem(key: StorageKey): Promise<string | null>;
     removeItem(key: StorageKey): Promise<void>;

package/lib/src/storage.js

@@ -1,28 +1,28 @@
 class NextStorage {
-    constructor(request) {
-        this.request = request;
+    constructor(session) {
+        this.session = session;
         this.sessionChanged = false;
     }
     async setItem(key, value) {
-        this.request.session[key] = value;
+        this.session[key] = value;
         this.sessionChanged = true;
     }
     async getItem(key) {
-        const value = this.request.session[key];
+        const value = this.session[key];
         if (value === undefined) {
             return null;
         }
         return String(value);
     }
     async removeItem(key) {
-        this.request.session[key] = undefined;
+        this.session[key] = undefined;
         this.sessionChanged = true;
     }
     async save() {
         if (!this.sessionChanged) {
             return;
         }
-        await this.request.session.save();
+        await this.session.save();
         this.sessionChanged = false;
     }
 }

package/lib/src/types.d.ts

@@ -1,6 +1,6 @@
 import type { LogtoConfig } from '@logto/node';
+import type NodeClient from '@logto/node';
 import type { IronSession } from 'iron-session';
-import type { withIronSessionApiRoute, withIronSessionSsr } from 'iron-session/next';
 import type { NextApiRequest } from 'next';
 export type NextRequestWithIronSession = NextApiRequest & {
     session: IronSession;
@@ -19,6 +19,5 @@ export type LogtoNextConfig = LogtoConfig & {
     baseUrl: string;
 };
 export type Adapters = {
-    withIronSessionApiRoute: typeof withIronSessionApiRoute;
-    withIronSessionSsr: typeof withIronSessionSsr;
+    NodeClient: typeof NodeClient;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/next",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "type": "module",
   "main": "./lib/src/index.cjs",
   "module": "./lib/src/index.js",
@@ -27,7 +27,7 @@
     "directory": "packages/next"
   },
   "dependencies": {
-    "@logto/node": "^2.0.0",
+    "@logto/node": "^2.1.1",
     "iron-session": "^6.3.1"
   },
   "devDependencies": {
@@ -42,11 +42,11 @@
     "jest-location-mock": "^1.0.9",
     "jest-matcher-specific-error": "^1.0.0",
     "lint-staged": "^13.0.0",
-    "next": "^12.2.2",
+    "next": "^13.0.4",
     "next-test-api-route-handler": "^3.1.6",
     "prettier": "^2.8.7",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
@@ -68,7 +68,7 @@
     "check": "tsc --noEmit",
     "build": "rm -rf lib/ && tsc -p tsconfig.build.json --noEmit && rollup -c",
     "lint": "eslint --ext .ts src",
-    "test": "node test.cjs && jest",
+    "test": "jest",
     "test:coverage": "node test.cjs && jest --silent --coverage"
   }
 }

package/lib/edge/iron-session-edge/get-property-descriptor-for-request-session.cjs

@@ -1,36 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function getPropertyDescriptorForRequestSession(session) {
-    return {
-        enumerable: true,
-        get() {
-            return session;
-        },
-        set(value) {
-            const keys = Object.keys(value);
-            const currentKeys = Object.keys(session);
-            for (const key of currentKeys) {
-                if (!keys.includes(key)) {
-                    /* eslint-disable @typescript-eslint/no-dynamic-delete */
-                    /* eslint-disable @silverhand/fp/no-delete */
-                    // @ts-expect-error See comment in IronSessionData interface
-                    delete session[key];
-                    /* eslint-enable @silverhand/fp/no-delete */
-                    /* eslint-enable @typescript-eslint/no-dynamic-delete */
-                }
-            }
-            for (const key of keys) {
-                /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-                /* eslint-disable @silverhand/fp/no-mutation */
-                // @ts-expect-error See comment in IronSessionData interface
-                session[key] = value[key];
-                /* eslint-enable @silverhand/fp/no-mutation */
-                /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-            }
-        },
-    };
-}
-
-exports.default = getPropertyDescriptorForRequestSession;

package/lib/edge/iron-session-edge/get-property-descriptor-for-request-session.d.ts

@@ -1,2 +0,0 @@
-import type { IronSession } from 'iron-session';
-export default function getPropertyDescriptorForRequestSession(session: IronSession): PropertyDescriptor;

package/lib/edge/iron-session-edge/get-property-descriptor-for-request-session.js

@@ -1,32 +0,0 @@
-function getPropertyDescriptorForRequestSession(session) {
-    return {
-        enumerable: true,
-        get() {
-            return session;
-        },
-        set(value) {
-            const keys = Object.keys(value);
-            const currentKeys = Object.keys(session);
-            for (const key of currentKeys) {
-                if (!keys.includes(key)) {
-                    /* eslint-disable @typescript-eslint/no-dynamic-delete */
-                    /* eslint-disable @silverhand/fp/no-delete */
-                    // @ts-expect-error See comment in IronSessionData interface
-                    delete session[key];
-                    /* eslint-enable @silverhand/fp/no-delete */
-                    /* eslint-enable @typescript-eslint/no-dynamic-delete */
-                }
-            }
-            for (const key of keys) {
-                /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-                /* eslint-disable @silverhand/fp/no-mutation */
-                // @ts-expect-error See comment in IronSessionData interface
-                session[key] = value[key];
-                /* eslint-enable @silverhand/fp/no-mutation */
-                /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-            }
-        },
-    };
-}
-
-export { getPropertyDescriptorForRequestSession as default };

package/lib/edge/iron-session-edge/index.cjs

@@ -1,30 +0,0 @@
-'use strict';
-
-var edge = require('iron-session/edge');
-var getPropertyDescriptorForRequestSession = require('./get-property-descriptor-for-request-session.cjs');
-
-function withIronSessionApiRoute(handler, options) {
-    return async (request, response) => {
-        const sessionOptions = options instanceof Function ? await options(request, response) : options;
-        const session = await edge.getIronSession(request, response, sessionOptions);
-        // We define req.session as being enumerable (so console.log(req) shows it)
-        // and we also want to allow people to do:
-        // req.session = { admin: true }; or req.session = {...req.session, admin: true};
-        // req.session.save();
-        // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-        Object.defineProperty(request, 'session', getPropertyDescriptorForRequestSession.default(session));
-        return handler(request, response);
-    };
-}
-function withIronSessionSsr(handler, options) {
-    return async (context) => {
-        const sessionOptions = options instanceof Function ? await options(context.req, context.res) : options;
-        const session = await edge.getIronSession(context.req, context.res, sessionOptions);
-        // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-        Object.defineProperty(context.req, 'session', getPropertyDescriptorForRequestSession.default(session));
-        return handler(context);
-    };
-}
-
-exports.withIronSessionApiRoute = withIronSessionApiRoute;
-exports.withIronSessionSsr = withIronSessionSsr;

package/lib/edge/iron-session-edge/index.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="node" />
-import type { IncomingMessage, ServerResponse } from 'http';
-import type { IronSessionOptions } from 'iron-session';
-import type { NextApiHandler, GetServerSidePropsContext, GetServerSidePropsResult, NextApiRequest, NextApiResponse } from 'next';
-type GetIronSessionApiOptions = (request: NextApiRequest, response: NextApiResponse) => Promise<IronSessionOptions> | IronSessionOptions;
-export declare function withIronSessionApiRoute(handler: NextApiHandler, options: IronSessionOptions | GetIronSessionApiOptions): NextApiHandler;
-type GetIronSessionSsrOptions = (request: IncomingMessage, response: ServerResponse) => Promise<IronSessionOptions> | IronSessionOptions;
-export declare function withIronSessionSsr<P extends Record<string, unknown> = Record<string, unknown>>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, options: IronSessionOptions | GetIronSessionSsrOptions): (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
-export {};

package/lib/edge/iron-session-edge/index.js

@@ -1,27 +0,0 @@
-import { getIronSession } from 'iron-session/edge';
-import getPropertyDescriptorForRequestSession from './get-property-descriptor-for-request-session.js';
-
-function withIronSessionApiRoute(handler, options) {
-    return async (request, response) => {
-        const sessionOptions = options instanceof Function ? await options(request, response) : options;
-        const session = await getIronSession(request, response, sessionOptions);
-        // We define req.session as being enumerable (so console.log(req) shows it)
-        // and we also want to allow people to do:
-        // req.session = { admin: true }; or req.session = {...req.session, admin: true};
-        // req.session.save();
-        // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-        Object.defineProperty(request, 'session', getPropertyDescriptorForRequestSession(session));
-        return handler(request, response);
-    };
-}
-function withIronSessionSsr(handler, options) {
-    return async (context) => {
-        const sessionOptions = options instanceof Function ? await options(context.req, context.res) : options;
-        const session = await getIronSession(context.req, context.res, sessionOptions);
-        // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-        Object.defineProperty(context.req, 'session', getPropertyDescriptorForRequestSession(session));
-        return handler(context);
-    };
-}
-
-export { withIronSessionApiRoute, withIronSessionSsr };