@logto/next 1.1.2 → 2.0.0

package/lib/edge/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var client = require('../src/client.cjs');
+var index = require('./iron-session-edge/index.cjs');
+var NodeClient = require('@logto/node');
+
+class LogtoClient extends client.default {
+    constructor(config) {
+        super(config, {
+            withIronSessionApiRoute: index.withIronSessionApiRoute,
+            withIronSessionSsr: index.withIronSessionSsr,
+        });
+    }
+}
+
+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

@@ -0,0 +1,7 @@
+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);
+}

package/lib/edge/index.js

@@ -0,0 +1,14 @@
+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,
+        });
+    }
+}
+
+export { LogtoClient as default };

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

@@ -0,0 +1,36 @@
+'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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,30 @@
+'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

@@ -0,0 +1,9 @@
+/// <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

@@ -0,0 +1,27 @@
+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 };

package/lib/{index.js → src/client.cjs}

@@ -3,17 +3,17 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var NodeClient = require('@logto/node');
-var next = require('iron-session/next');
-var storage = require('./storage.js');
+var storage = require('./storage.cjs');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var NodeClient__default = /*#__PURE__*/_interopDefault(NodeClient);
 
-class LogtoClient {
-    constructor(config) {
+class LogtoNextBaseClient {
+    constructor(config, adapters) {
         this.config = config;
-        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => next.withIronSessionApiRoute(async (request, response) => {
+        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();
@@ -21,7 +21,7 @@ class LogtoClient {
                 response.redirect(this.navigateUrl);
             }
         }, this.ironSessionConfigs);
-        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => next.withIronSessionApiRoute(async (request, response) => {
+        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}`);
@@ -29,7 +29,7 @@ class LogtoClient {
                 response.redirect(redirectTo);
             }
         }, this.ironSessionConfigs);
-        this.handleSignOut = (redirectUri = this.config.baseUrl) => next.withIronSessionApiRoute(async (request, response) => {
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => this.adapters.withIronSessionApiRoute(async (request, response) => {
             const nodeClient = this.createNodeClient(request);
             await nodeClient.signOut(redirectUri);
             request.session.destroy();
@@ -60,13 +60,13 @@ class LogtoClient {
             }
             response.status(404).end();
         };
-        this.withLogtoApiRoute = (handler, config = {}) => next.withIronSessionApiRoute(async (request, response) => {
+        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 = {}) => next.withIronSessionSsr(async (context) => {
+        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 });
@@ -98,12 +98,4 @@ class LogtoClient {
     }
 }
 
-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;
+exports.default = LogtoNextBaseClient;

package/lib/{index.d.ts → src/client.d.ts}

@@ -1,13 +1,12 @@
 import type { GetContextParameters, InteractionMode } from '@logto/node';
 import type { GetServerSidePropsContext, GetServerSidePropsResult, NextApiHandler } from 'next';
-import type { LogtoNextConfig } from './types';
-export { ReservedScope, UserScope } from '@logto/node';
-export type { LogtoContext, InteractionMode } from '@logto/node';
-export default class LogtoClient {
+import type { Adapters, LogtoNextConfig } from './types';
+export default class LogtoNextBaseClient {
     private readonly config;
+    private readonly adapters;
     private navigateUrl?;
     private storage?;
-    constructor(config: LogtoNextConfig);
+    constructor(config: LogtoNextConfig, adapters: Adapters);
     handleSignIn: (redirectUri?: string, interactionMode?: InteractionMode) => NextApiHandler;
     handleSignInCallback: (redirectTo?: string) => NextApiHandler;
     handleSignOut: (redirectUri?: string) => NextApiHandler;

package/lib/{index.mjs → src/client.js}

@@ -1,12 +1,11 @@
 import NodeClient from '@logto/node';
-export { ReservedScope, UserScope } from '@logto/node';
-import { withIronSessionApiRoute, withIronSessionSsr } from 'iron-session/next';
-import NextStorage from './storage.mjs';
+import NextStorage from './storage.js';
 
-class LogtoClient {
-    constructor(config) {
+class LogtoNextBaseClient {
+    constructor(config, adapters) {
         this.config = config;
-        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => withIronSessionApiRoute(async (request, response) => {
+        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();
@@ -14,7 +13,7 @@ class LogtoClient {
                 response.redirect(this.navigateUrl);
             }
         }, this.ironSessionConfigs);
-        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => withIronSessionApiRoute(async (request, response) => {
+        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}`);
@@ -22,7 +21,7 @@ class LogtoClient {
                 response.redirect(redirectTo);
             }
         }, this.ironSessionConfigs);
-        this.handleSignOut = (redirectUri = this.config.baseUrl) => withIronSessionApiRoute(async (request, response) => {
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => this.adapters.withIronSessionApiRoute(async (request, response) => {
             const nodeClient = this.createNodeClient(request);
             await nodeClient.signOut(redirectUri);
             request.session.destroy();
@@ -53,13 +52,13 @@ class LogtoClient {
             }
             response.status(404).end();
         };
-        this.withLogtoApiRoute = (handler, config = {}) => withIronSessionApiRoute(async (request, response) => {
+        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 = {}) => withIronSessionSsr(async (context) => {
+        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 });
@@ -91,4 +90,4 @@ class LogtoClient {
     }
 }
 
-export { LogtoClient as default };
+export { LogtoNextBaseClient as default };

package/lib/src/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var next = require('iron-session/next');
+var client = require('./client.cjs');
+var NodeClient = require('@logto/node');
+
+class LogtoClient extends client.default {
+    constructor(config) {
+        super(config, {
+            withIronSessionApiRoute: next.withIronSessionApiRoute,
+            withIronSessionSsr: next.withIronSessionSsr,
+        });
+    }
+}
+
+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/src/index.d.ts

@@ -0,0 +1,7 @@
+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);
+}

package/lib/src/index.js

@@ -0,0 +1,14 @@
+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,
+        });
+    }
+}
+
+export { LogtoClient as default };

package/lib/{types.d.ts → src/types.d.ts}

@@ -1,5 +1,6 @@
 import type { LogtoConfig } 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;
@@ -17,3 +18,7 @@ export type LogtoNextConfig = LogtoConfig & {
     cookieSecure: boolean;
     baseUrl: string;
 };
+export type Adapters = {
+    withIronSessionApiRoute: typeof withIronSessionApiRoute;
+    withIronSessionSsr: typeof withIronSessionSsr;
+};

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@logto/next",
-  "version": "1.1.2",
-  "source": "./src/index.ts",
-  "main": "./lib/index.js",
+  "version": "2.0.0",
+  "type": "module",
+  "main": "./lib/src/index.cjs",
+  "module": "./lib/src/index.js",
+  "types": "./lib/src/index.d.ts",
   "exports": {
-    "require": "./lib/index.js",
-    "import": "./lib/index.mjs"
+    ".": {
+      "require": "./lib/src/index.cjs",
+      "import": "./lib/src/index.js",
+      "types": "./lib/src/index.d.ts"
+    },
+    "./edge": {
+      "require": "./lib/edge/index.cjs",
+      "import": "./lib/edge/index.js",
+      "types": "./lib/edge/index.d.ts"
+    }
   },
-  "module": "./lib/index.mjs",
-  "types": "./lib/index.d.ts",
   "files": [
     "lib"
   ],
@@ -18,25 +26,14 @@
     "url": "https://github.com/logto-io/js.git",
     "directory": "packages/next"
   },
-  "scripts": {
-    "dev:tsc": "tsc -p tsconfig.build.json -w --preserveWatchOutput",
-    "precommit": "lint-staged",
-    "check": "tsc --noEmit",
-    "build": "rm -rf lib/ && tsc -p tsconfig.build.json --noEmit && rollup -c",
-    "lint": "eslint --ext .ts src",
-    "test": "jest",
-    "test:coverage": "jest --silent --coverage",
-    "prepack": "pnpm test"
-  },
   "dependencies": {
-    "@logto/node": "^1.1.2",
-    "iron-session": "^6.1.3"
+    "@logto/node": "^2.0.0",
+    "iron-session": "^6.3.1"
   },
   "devDependencies": {
-    "@jest/types": "^29.5.0",
-    "@silverhand/eslint-config": "^2.0.0",
-    "@silverhand/ts-config": "^1.0.0",
-    "@silverhand/ts-config-react": "^2.0.0",
+    "@silverhand/eslint-config": "^3.0.1",
+    "@silverhand/ts-config": "^3.0.0",
+    "@silverhand/ts-config-react": "^3.0.0",
     "@swc/core": "^1.3.50",
     "@swc/jest": "^0.2.24",
     "@types/jest": "^29.5.0",
@@ -56,19 +53,22 @@
     "next": ">=12"
   },
   "eslintConfig": {
-    "extends": "@silverhand"
+    "extends": "@silverhand",
+    "rules": {
+      "unicorn/prefer-node-protocol": "off"
+    }
   },
   "prettier": "@silverhand/eslint-config/.prettierrc",
   "publishConfig": {
     "access": "public"
   },
-  "targets": {
-    "main": {
-      "context": "node",
-      "engines": {
-        "node": ">=18.12.0"
-      }
-    }
-  },
-  "gitHead": "9e9a8b0887ef67baa7c3c564590bb06e7801d03e"
-}
+  "scripts": {
+    "dev:tsc": "tsc -p tsconfig.build.json -w --preserveWatchOutput",
+    "precommit": "lint-staged",
+    "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:coverage": "node test.cjs && jest --silent --coverage"
+  }
+}