iron-session 2.0.0-alpha.9 → 6.0.2

package/next/index.test.ts

@@ -0,0 +1,184 @@
+import {
+  GetServerSidePropsContext,
+  NextApiRequest,
+  NextApiResponse,
+} from "next";
+import { withIronSessionApiRoute, withIronSessionSsr } from ".";
+const password = "Gbm49ATjnqnkCCCdhV4uDBhbfnPqsCW0";
+const cookieName = "test";
+
+// same structure as other tests otherwise linting will fail because you can have only one per running eslint
+declare module "iron-session" {
+  interface IronSessionData {
+    user?: { id: number; meta?: string };
+    admin?: boolean;
+  }
+}
+
+test("withIronSessionApiRoute: req.session exists", async () => {
+  const wrappedHandler = withIronSessionApiRoute(
+    function handler(req) {
+      expect(req.session).toMatchInlineSnapshot(`Object {}`);
+    },
+    {
+      password,
+      cookieName,
+    },
+  );
+
+  await wrappedHandler(getDefaultReq(), getDefaultRes());
+});
+
+test("withIronSessionApiRoute: req.session.save creates a cookie", async () => {
+  const wrappedHandler = withIronSessionApiRoute(
+    async function handler(req, res) {
+      expect(req.session).toMatchInlineSnapshot(`Object {}`);
+      req.session.user = { id: 200 };
+      await req.session.save();
+      const headerName = (res.setHeader as jest.Mock).mock.calls[0][0];
+      expect(headerName).toMatchInlineSnapshot(`"set-cookie"`);
+
+      const headerValue = (res.setHeader as jest.Mock).mock.calls[0][1];
+      expect(Array.isArray(headerValue)).toBe(true);
+      expect(headerValue).toHaveLength(1);
+
+      const cookie = headerValue[0];
+      const seal = cookie.split(";")[0].split("=")[1];
+      expect(seal).toHaveLength(265);
+
+      const cookieParams = cookie.split(";").slice(1).join(";");
+      expect(cookieParams).toMatchInlineSnapshot(
+        `" Max-Age=1295940; Path=/; HttpOnly; Secure; SameSite=Lax"`,
+      );
+    },
+    {
+      password,
+      cookieName,
+    },
+  );
+
+  await wrappedHandler(getDefaultReq(), getDefaultRes());
+});
+
+test("withIronSessionApiRoute: req.session.destroy removes the cookie", async () => {
+  const wrappedHandler = withIronSessionApiRoute(
+    async function handler(req, res) {
+      req.session.user = { id: 300 };
+      await req.session.save();
+      expect(req.session).toMatchInlineSnapshot(`
+        Object {
+          "user": Object {
+            "id": 300,
+          },
+        }
+      `);
+      req.session.destroy();
+      expect(req.session).toMatchInlineSnapshot(`Object {}`);
+      expect((res.setHeader as jest.Mock).mock.calls[1]).toMatchInlineSnapshot(`
+        Array [
+          "set-cookie",
+          Array [
+            "test=; Max-Age=0; Path=/; HttpOnly; Secure; SameSite=Lax",
+          ],
+        ]
+      `);
+    },
+    {
+      password,
+      cookieName,
+    },
+  );
+
+  await wrappedHandler(getDefaultReq(), getDefaultRes());
+});
+
+test("withIronSessionApiRoute: full session rewrite works too", async () => {
+  const wrappedHandler = withIronSessionApiRoute(
+    async function handler(req) {
+      req.session.user = { id: 200 };
+      await req.session.save();
+      expect(req.session).toMatchInlineSnapshot(`
+        Object {
+          "user": Object {
+            "id": 200,
+          },
+        }
+      `);
+      // @ts-ignore TypeScript warns about save and destroy not being here,
+      // so this example is most probably to catch misuage of the API and because it works the same as destructuring code wise
+      req.session = {
+        admin: true,
+      };
+      expect(req.session).toMatchInlineSnapshot(`
+        Object {
+          "admin": true,
+        }
+      `);
+    },
+    {
+      password,
+      cookieName,
+    },
+  );
+
+  await wrappedHandler(getDefaultReq(), getDefaultRes());
+});
+
+test("withIronSessionApiRoute: req.session can be overridden, save and destroy will stay", async () => {
+  const wrappedHandler = withIronSessionApiRoute(
+    async function handler(req) {
+      req.session = {
+        ...req.session,
+        user: { id: 400 },
+      };
+      await req.session.save();
+      expect(req.session).toMatchInlineSnapshot(`
+        Object {
+          "user": Object {
+            "id": 400,
+          },
+        }
+      `);
+    },
+    {
+      password,
+      cookieName,
+    },
+  );
+
+  await wrappedHandler(getDefaultReq(), getDefaultRes());
+});
+
+test("withIronSessionSsr: req.session exists", async () => {
+  const getServerSideProps = withIronSessionSsr(
+    async function getServerSideProps({ req }) {
+      expect(req.session).toMatchInlineSnapshot(`Object {}`);
+      return { props: {} };
+    },
+    {
+      password,
+      cookieName,
+    },
+  );
+
+  await getServerSideProps({
+    req: getDefaultReq(),
+    res: getDefaultRes(),
+  } as unknown as GetServerSidePropsContext);
+});
+
+function getDefaultReq() {
+  return {
+    headers: {},
+    socket: {
+      encrypted: true,
+    },
+  } as unknown as NextApiRequest;
+}
+
+function getDefaultRes() {
+  return {
+    getHeader: jest.fn(),
+    setHeader: jest.fn(),
+  } as unknown as NextApiResponse;
+}

package/next/index.ts

@@ -0,0 +1,49 @@
+import type {
+  NextApiHandler,
+  GetServerSidePropsContext,
+  GetServerSidePropsResult,
+} from "next";
+import type { IronSessionOptions } from "iron-session";
+import { getIronSession } from "iron-session";
+import getPropertyDescriptorForReqSession from "../src/getPropertyDescriptorForReqSession";
+
+export function withIronSessionApiRoute(
+  handler: NextApiHandler,
+  options: IronSessionOptions,
+): NextApiHandler {
+  return async function nextApiHandlerWrappedWithIronSession(req, res) {
+    const session = await getIronSession(req, res, options);
+
+    // 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();
+    Object.defineProperty(
+      req,
+      "session",
+      getPropertyDescriptorForReqSession(session),
+    );
+    return handler(req, res);
+  };
+}
+
+export function withIronSessionSsr<
+  P extends { [key: string]: unknown } = { [key: string]: unknown },
+>(
+  handler: (
+    context: GetServerSidePropsContext,
+  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,
+  options: IronSessionOptions,
+) {
+  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(
+    context: GetServerSidePropsContext,
+  ) {
+    const session = await getIronSession(context.req, context.res, options);
+    Object.defineProperty(
+      context.req,
+      "session",
+      getPropertyDescriptorForReqSession(session),
+    );
+    return handler(context);
+  };
+}

package/next/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "..",
+    "outDir": "./dist"
+  },
+  "include": ["./*.ts"]
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "iron-session",
-  "version": "2.0.0-alpha.9",
+  "version": "6.0.2",
+  "description": "Node.js stateless session utility using signed and encrypted cookies to store data. Works with Next.js, Express, NestJs, Fastify, and any Node.js HTTP framework.",
   "license": "MIT",
   "author": "Vincent Voyer <vincent@codeagain.com>",
-  "type": "module",
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
@@ -14,95 +14,130 @@
       "import": "./next/dist/index.mjs",
       "require": "./next/dist/index.js",
       "types": "./next/dist/index.d.ts"
+    },
+    "./express": {
+      "import": "./express/dist/index.mjs",
+      "require": "./express/dist/index.js",
+      "types": "./express/dist/index.d.ts"
     }
   },
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "next/dist"
-  ],
-  "workspaces": [
-    "examples/next.js",
-    "examples/next.js-typescript"
+    "dist/",
+    "next/",
+    "express/"
   ],
   "scripts": {
-    "build": "rimraf dist/ next/dist && tsup src/index.ts && tsup next/index.ts -d next/dist",
-    "lint": "eslint . && (cd examples/next.js && npm run lint) && (cd examples/next.js-typescript && npm run lint)",
-    "prepublishOnly": "npm run build",
-    "test": "jest --coverage && npm run lint"
+    "build": "npm run build:clean && npm run build:src && npm run build:next && npm run build:express",
+    "build:clean": "rimraf dist/ next/dist express/dist",
+    "build:express": "tsup express/index.ts -d express/dist",
+    "build:next": "tsup next/index.ts -d next/dist",
+    "build:src": "tsup src/index.ts",
+    "installExamples": "(cd examples/express && npm ci) && (cd examples/next.js && npm ci) && (cd examples/next.js-typescript && npm ci)",
+    "lint": "eslint --ext ts,js,jsx,tsx src/ next/ express/ examples/",
+    "prepublishOnly": "npm run build && cp next/dist/* next/ && cp express/dist/* express/",
+    "postpublish": "rm next/*.d.ts next/*.js next/*.map next/*.mjs && rm express/*.d.ts express/*.js express/*.map express/*.mjs",
+    "test": "jest --coverage --ci && npm run installExamples && npm run lint && tsc --noEmit && npm run build && npm run build:clean",
+    "watch": "npm run build:clean && concurrently \"npm:watch:*\"",
+    "watch:express": "tsup express/index.ts -d express/dist --watch express/index.ts",
+    "watch:next": "tsup next/index.ts -d next/dist --watch next/index.ts",
+    "watch:src": "tsup src/index.ts --watch src/index.ts"
   },
   "prettier": {
     "trailingComma": "all"
   },
   "eslintConfig": {
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-      "ecmaVersion": 2021,
-      "sourceType": "module"
-    },
-    "plugins": [
-      "@typescript-eslint"
-    ],
     "extends": [
-      "eslint:recommended",
-      "plugin:@typescript-eslint/recommended"
+      "eslint:recommended"
     ],
-    "rules": {
-      "@typescript-eslint/ban-ts-comment": [
-        "warn",
-        {
-          "ts-ignore": "allow-with-description"
+    "overrides": [
+      {
+        "files": [
+          "**/*.ts",
+          "**/*.tsx"
+        ],
+        "parser": "@typescript-eslint/parser",
+        "plugins": [
+          "@typescript-eslint"
+        ],
+        "extends": [
+          "eslint:recommended",
+          "plugin:@typescript-eslint/recommended"
+        ],
+        "rules": {
+          "@typescript-eslint/ban-ts-comment": [
+            "warn",
+            {
+              "ts-ignore": "allow-with-description"
+            }
+          ]
         }
-      ]
-    }
+      },
+      {
+        "files": "**/*.js",
+        "env": {
+          "node": true
+        },
+        "parser": "espree",
+        "parserOptions": {
+          "ecmaVersion": 2019
+        }
+      }
+    ]
   },
   "jest": {
-    "collectCoverageFrom": [
-      "src/*.ts",
-      "next/*.ts"
-    ],
-    "coverageProvider": "v8",
-    "coverageReporters": [
-      "text"
-    ],
     "transform": {
-      ".ts$": [
-        "@swc-node/jest",
+      "^.+\\.(t|j)sx?$": [
+        "@swc/jest",
         {
+          "sourceMaps": true,
           "jsc": {
-            "minify": false
+            "parser": {
+              "syntax": "typescript"
+            },
+            "paths": {
+              "iron-session": [
+                "../src/index.ts"
+              ]
+            }
           }
         }
       ]
     }
   },
   "dependencies": {
+    "@hapi/iron": "^6.0.0",
     "@types/cookie": "^0.4.0",
-    "@types/node": "^16.11.1",
-    "cookie": "^0.4.1",
-    "iron-store": "^1.3.5"
+    "@types/express": "^4.17.13",
+    "@types/node": "^16.11.6",
+    "cookie": "^0.4.1"
   },
   "devDependencies": {
-    "@swc-node/jest": "1.3.3",
+    "@swc/core": "1.2.106",
+    "@swc/jest": "0.2.5",
     "@tsconfig/node12": "1.0.9",
     "@types/jest": "27.0.2",
-    "@typescript-eslint/eslint-plugin": "5.1.0",
-    "@typescript-eslint/parser": "5.1.0",
-    "eslint": "8.0.1",
+    "@typescript-eslint/eslint-plugin": "5.3.0",
+    "@typescript-eslint/parser": "5.3.0",
+    "concurrently": "6.3.0",
+    "eslint": "8.1.0",
     "jest": "27.3.1",
-    "jest-date-mock": "1.0.8",
     "prettier": "2.4.1",
     "prettier-plugin-packagejson": "2.2.13",
     "rimraf": "3.0.2",
-    "tsup": "5.4.1",
+    "tsup": "5.6.0",
     "typescript": "4.4.4"
   },
   "peerDependencies": {
+    "express": ">=4",
     "next": ">=10"
   },
   "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
     "next": {
       "optional": true
     }

package/dist/index.cjs

@@ -1,127 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  __markAsModule(target);
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toModule = (module2) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-
-// src/index.ts
-__export(exports, {
-  getIronSession: () => getIronSession
-});
-var import_iron_store = __toModule(require("iron-store"));
-var import_cookie = __toModule(require("cookie"));
-var timestampSkewSec = 60;
-var defaultOptions = {
-  ttl: 15 * 24 * 3600,
-  cookieOptions: {
-    httpOnly: true,
-    secure: true,
-    sameSite: "lax",
-    path: "/"
-  }
-};
-async function getIronSession(req, res, userOptions) {
-  var _a, _b;
-  if (!req || !res || !userOptions || !userOptions.cookieName || !userOptions.password) {
-    throw new Error(`iron-session: Bad usage. Minimum usage is const session = await getIronSession(req, res, { cookieName: "...", password: "...". Check the usage here: https://github.com/vvo/iron-session`);
-  }
-  const passwordAsAnArray = Array.isArray(userOptions.password) ? userOptions.password : [{ id: 1, password: userOptions.password }];
-  passwordAsAnArray.forEach(({ password }) => {
-    if (password.length < 32) {
-      throw new Error(`iron-session: Bad usage. Password must be at least 32 characters long.`);
-    }
-  });
-  const options = {
-    ...defaultOptions,
-    ...userOptions,
-    cookieOptions: {
-      ...defaultOptions.cookieOptions,
-      ...userOptions.cookieOptions || {}
-    }
-  };
-  if (options.ttl === 0) {
-    options.ttl = 2147483647;
-  }
-  options.cookieOptions.maxAge = computeCookieMaxAge((_b = (_a = userOptions.cookieOptions) == null ? void 0 : _a.maxAge) != null ? _b : options.ttl);
-  const store = await getOrCreateStore({
-    sealed: import_cookie.default.parse(req.headers.cookie || "")[options.cookieName],
-    password: passwordAsAnArray,
-    ttl: options.ttl * 1e3
-  });
-  return {
-    set: store.set,
-    get: store.get,
-    unset: store.unset,
-    async save() {
-      const seal = await store.seal();
-      const cookieValue = import_cookie.default.serialize(options.cookieName, seal, options.cookieOptions);
-      if (cookieValue.length > 4096) {
-        throw new Error(`iron-session: Cookie length is too big ${cookieValue.length}, browsers will refuse it. Try to remove some data.`);
-      }
-      addToCookies(cookieValue, res);
-      return cookieValue;
-    },
-    destroy() {
-      store.clear();
-      const cookieValue = import_cookie.default.serialize(options.cookieName, "", {
-        ...options.cookieOptions,
-        maxAge: 0
-      });
-      addToCookies(cookieValue, res);
-    }
-  };
-}
-function addToCookies(cookieValue, res) {
-  var _a;
-  let existingSetCookie = (_a = res.getHeader("set-cookie")) != null ? _a : [];
-  if (typeof existingSetCookie === "string") {
-    existingSetCookie = [existingSetCookie];
-  }
-  res.setHeader("set-cookie", [...existingSetCookie, cookieValue]);
-}
-function computeCookieMaxAge(ttl) {
-  return ttl - timestampSkewSec;
-}
-async function getOrCreateStore({
-  sealed,
-  password,
-  ttl
-}) {
-  try {
-    return await (0, import_iron_store.default)({
-      sealed,
-      password,
-      ttl
-    });
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message === "Expired seal" || error.message === "Bad hmac value" || error.message === "Cannot find password: ") {
-        return await (0, import_iron_store.default)({ password, ttl });
-      }
-    }
-    throw error;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getIronSession
-});
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/index.ts"],
-  "sourcesContent": ["import ironStore from \"iron-store\";\nimport cookie, { CookieSerializeOptions } from \"cookie\";\nimport type { IncomingMessage, ServerResponse } from \"http\";\n\n// default time allowed to check for iron seal validity when ttl passed\n// see https://hapi.dev/family/iron/api/?v=6.0.0#options\nconst timestampSkewSec = 60;\n\ntype password = string | { id: number; password: string }[];\n\nconst defaultOptions: {\n  ttl: number;\n  cookieOptions: CookieSerializeOptions;\n} = {\n  ttl: 15 * 24 * 3600,\n  cookieOptions: {\n    httpOnly: true,\n    secure: true,\n    sameSite: \"lax\",\n    path: \"/\",\n  },\n};\n\nexport interface IronSessionOptions {\n  cookieName: string;\n  password: password;\n  ttl?: number;\n  cookieOptions?: CookieSerializeOptions;\n}\n\nexport interface IronSession {\n  set: <T = unknown>(name: string, value: T) => T;\n  get: <T = unknown>(name: string) => T | undefined;\n  unset: (name: string) => void;\n  destroy: () => void;\n  save: () => Promise<string>;\n}\n\nexport async function getIronSession<\n  RequestType extends IncomingMessage,\n  ResponseType extends ServerResponse,\n>(req: RequestType, res: ResponseType, userOptions: IronSessionOptions) {\n  if (\n    !req ||\n    !res ||\n    !userOptions ||\n    !userOptions.cookieName ||\n    !userOptions.password\n  ) {\n    throw new Error(\n      `iron-session: Bad usage. Minimum usage is const session = await getIronSession(req, res, { cookieName: \"...\", password: \"...\". Check the usage here: https://github.com/vvo/iron-session`,\n    );\n  }\n\n  const passwordAsAnArray = Array.isArray(userOptions.password)\n    ? userOptions.password\n    : [{ id: 1, password: userOptions.password }];\n\n  passwordAsAnArray.forEach(({ password }) => {\n    if (password.length < 32) {\n      throw new Error(\n        `iron-session: Bad usage. Password must be at least 32 characters long.`,\n      );\n    }\n  });\n\n  const options: Required<IronSessionOptions> = {\n    ...defaultOptions,\n    ...userOptions,\n    cookieOptions: {\n      ...defaultOptions.cookieOptions,\n      ...(userOptions.cookieOptions || {}),\n    },\n  };\n\n  if (options.ttl === 0) {\n    // ttl = 0 means no expiration\n    // but in reality cookies have to expire (can't have no max-age)\n    // 2147483647 is the max value for max-age in cookies\n    // see https://stackoverflow.com/a/11685301/147079\n    options.ttl = 2147483647;\n  }\n\n  options.cookieOptions.maxAge = computeCookieMaxAge(\n    userOptions.cookieOptions?.maxAge ?? options.ttl,\n  );\n\n  const store = await getOrCreateStore({\n    sealed: cookie.parse(req.headers.cookie || \"\")[options.cookieName],\n    password: passwordAsAnArray,\n    ttl: options.ttl * 1000,\n  });\n\n  return {\n    set: store.set,\n    get: store.get,\n    unset: store.unset,\n    async save() {\n      const seal = await store.seal();\n      const cookieValue = cookie.serialize(\n        options.cookieName,\n        seal,\n        options.cookieOptions,\n      );\n\n      if (cookieValue.length > 4096) {\n        throw new Error(\n          `iron-session: Cookie length is too big ${cookieValue.length}, browsers will refuse it. Try to remove some data.`,\n        );\n      }\n\n      addToCookies(cookieValue, res);\n      return cookieValue;\n    },\n    destroy() {\n      store.clear();\n      const cookieValue = cookie.serialize(options.cookieName, \"\", {\n        ...options.cookieOptions,\n        maxAge: 0,\n      });\n      addToCookies(cookieValue, res);\n    },\n  };\n}\n\nfunction addToCookies(cookieValue: string, res: ServerResponse) {\n  let existingSetCookie =\n    (res.getHeader(\"set-cookie\") as string[] | string) ?? [];\n  if (typeof existingSetCookie === \"string\") {\n    existingSetCookie = [existingSetCookie];\n  }\n  res.setHeader(\"set-cookie\", [...existingSetCookie, cookieValue]);\n}\n\nfunction computeCookieMaxAge(ttl: number) {\n  // The next line makes sure browser will expire cookies before seals are considered expired by the server.\n  // It also allows for clock difference of 60 seconds maximum between server and clients.\n  // It also makes sure to expire the cookie immediately when value is 0\n  return ttl - timestampSkewSec;\n}\n\nasync function getOrCreateStore({\n  sealed,\n  password,\n  ttl,\n}: {\n  sealed: string;\n  password: password;\n  ttl: number;\n}) {\n  try {\n    return await ironStore({\n      sealed,\n      password,\n      ttl,\n    });\n  } catch (error) {\n    if (error instanceof Error) {\n      if (\n        error.message === \"Expired seal\" ||\n        error.message === \"Bad hmac value\" ||\n        error.message === \"Cannot find password: \"\n      ) {\n        // if seal expired or\n        // if seal is not valid (encrypted using a different password, when passwords are updated) or\n        // if we can't find back the password in the seal\n        // then we just start a new session over\n        return await ironStore({ password, ttl });\n      }\n    }\n\n    throw error;\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA,wBAAsB;AACtB,oBAA+C;AAK/C,IAAM,mBAAmB;AAIzB,IAAM,iBAGF;AAAA,EACF,KAAK,KAAK,KAAK;AAAA,EACf,eAAe;AAAA,IACb,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,MAAM;AAAA;AAAA;AAmBV,8BAGE,KAAkB,KAAmB,aAAiC;AAzCxE;AA0CE,MACE,CAAC,OACD,CAAC,OACD,CAAC,eACD,CAAC,YAAY,cACb,CAAC,YAAY,UACb;AACA,UAAM,IAAI,MACR;AAAA;AAIJ,QAAM,oBAAoB,MAAM,QAAQ,YAAY,YAChD,YAAY,WACZ,CAAC,EAAE,IAAI,GAAG,UAAU,YAAY;AAEpC,oBAAkB,QAAQ,CAAC,EAAE,eAAe;AAC1C,QAAI,SAAS,SAAS,IAAI;AACxB,YAAM,IAAI,MACR;AAAA;AAAA;AAKN,QAAM,UAAwC;AAAA,OACzC;AAAA,OACA;AAAA,IACH,eAAe;AAAA,SACV,eAAe;AAAA,SACd,YAAY,iBAAiB;AAAA;AAAA;AAIrC,MAAI,QAAQ,QAAQ,GAAG;AAKrB,YAAQ,MAAM;AAAA;AAGhB,UAAQ,cAAc,SAAS,oBAC7B,wBAAY,kBAAZ,mBAA2B,WAA3B,YAAqC,QAAQ;AAG/C,QAAM,QAAQ,MAAM,iBAAiB;AAAA,IACnC,QAAQ,sBAAO,MAAM,IAAI,QAAQ,UAAU,IAAI,QAAQ;AAAA,IACvD,UAAU;AAAA,IACV,KAAK,QAAQ,MAAM;AAAA;AAGrB,SAAO;AAAA,IACL,KAAK,MAAM;AAAA,IACX,KAAK,MAAM;AAAA,IACX,OAAO,MAAM;AAAA,UACP,OAAO;AACX,YAAM,OAAO,MAAM,MAAM;AACzB,YAAM,cAAc,sBAAO,UACzB,QAAQ,YACR,MACA,QAAQ;AAGV,UAAI,YAAY,SAAS,MAAM;AAC7B,cAAM,IAAI,MACR,0CAA0C,YAAY;AAAA;AAI1D,mBAAa,aAAa;AAC1B,aAAO;AAAA;AAAA,IAET,UAAU;AACR,YAAM;AACN,YAAM,cAAc,sBAAO,UAAU,QAAQ,YAAY,IAAI;AAAA,WACxD,QAAQ;AAAA,QACX,QAAQ;AAAA;AAEV,mBAAa,aAAa;AAAA;AAAA;AAAA;AAKhC,sBAAsB,aAAqB,KAAqB;AA7HhE;AA8HE,MAAI,oBACD,UAAI,UAAU,kBAAd,YAAqD;AACxD,MAAI,OAAO,sBAAsB,UAAU;AACzC,wBAAoB,CAAC;AAAA;AAEvB,MAAI,UAAU,cAAc,CAAC,GAAG,mBAAmB;AAAA;AAGrD,6BAA6B,KAAa;AAIxC,SAAO,MAAM;AAAA;AAGf,gCAAgC;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,GAKC;AACD,MAAI;AACF,WAAO,MAAM,+BAAU;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA;AAAA,WAEK,OAAP;AACA,QAAI,iBAAiB,OAAO;AAC1B,UACE,MAAM,YAAY,kBAClB,MAAM,YAAY,oBAClB,MAAM,YAAY,0BAClB;AAKA,eAAO,MAAM,+BAAU,EAAE,UAAU;AAAA;AAAA;AAIvC,UAAM;AAAA;AAAA;",
-  "names": []
-}

package/next/dist/index.cjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../index.ts"],
-  "sourcesContent": ["import type {\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n  NextApiRequest,\n  NextApiResponse,\n} from \"next\";\nimport type { IronSession, IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\n\nexport interface NextApiRequestWithIronSession extends NextApiRequest {\n  session: IronSession;\n}\n\nexport declare type NextApiHandlerWithIronSession<T = unknown> = (\n  req: NextApiRequestWithIronSession,\n  res: NextApiResponse<T>,\n) => void | Promise<void>;\n\ninterface NextGetSeverSideContextWithIronSession\n  extends GetServerSidePropsContext {\n  req: NextApiRequestWithIronSession;\n}\n\nexport declare type NextGetServerSidePropsHandlerWithIronSession<P> = (\n  context: NextGetSeverSideContextWithIronSession,\n) => Promise<GetServerSidePropsResult<P>>;\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandlerWithIronSession,\n  options: IronSessionOptions,\n): NextApiHandlerWithIronSession {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    req.session = await getIronSession(req, res, options);\n    return handler(req, res);\n  };\n}\n\nexport function withIronSessionSsr<P>(\n  handler: NextGetServerSidePropsHandlerWithIronSession<P>,\n  options: IronSessionOptions,\n): NextGetServerSidePropsHandlerWithIronSession<P> {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: NextGetSeverSideContextWithIronSession,\n  ) {\n    context.req.session = await getIronSession(\n      context.req,\n      context.res,\n      options,\n    );\n    return handler(context);\n  };\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAOA,0BAA+B;AAoBxB,iCACL,SACA,SAC+B;AAC/B,SAAO,oDAAoD,KAAK,KAAK;AACnE,QAAI,UAAU,MAAM,wCAAe,KAAK,KAAK;AAC7C,WAAO,QAAQ,KAAK;AAAA;AAAA;AAIjB,4BACL,SACA,SACiD;AACjD,SAAO,mEACL,SACA;AACA,YAAQ,IAAI,UAAU,MAAM,wCAC1B,QAAQ,KACR,QAAQ,KACR;AAEF,WAAO,QAAQ;AAAA;AAAA;",
-  "names": []
-}