iron-session 6.0.5 → 6.1.0

package/README.md

@@ -417,6 +417,22 @@ export default async function sendEmailRoute(req, res) {
 }
 ```
 
+The default `ttl` for such seals is 14 days. To specify a `ttl`, provide it in seconds like so:
+
+```ts
+const fifteenMinutesInSeconds = 15 * 60;
+
+const seal = await sealData(
+  {
+    userId: user.id,
+  },
+  {
+    password: "complex_password_at_least_32_characters_long",
+    ttl: fifteenMinutesInSeconds,
+  },
+);
+```
+
 **Login the user automatically and redirect:**
 
 ```ts
@@ -570,7 +586,7 @@ Only two options are required: `password` and `cookieName`. Everything else is a
 }
 ```
 
-### Next.js: withIronSessionApiRoute(handler, ironOptions)
+### Next.js: withIronSessionApiRoute(handler, ironOptions | (req: NextApiRequest, res: NextApiResponse) => IronSessionOptions | Promise\<IronSessionOptions\>)
 
 Wraps a [Next.js API Route](https://nextjs.org/docs/api-routes/dynamic-api-routes) and adds a `session` object to the request.
 
@@ -590,9 +606,30 @@ export default withIronSessionApiRoute(
     },
   },
 );
+
+// You can also pass an async or sync function which takes request and response object and return IronSessionOptions
+export default withIronSessionApiRoute(
+  function userRoute(req, res) {
+    res.send({ user: req.session.user });
+  },
+  (req, res) => {
+    // Infer max cookie from request
+    const maxCookieAge = getMaxCookieAge(req);
+    return {
+      cookieName: "myapp_cookiename",
+      password: "complex_password_at_least_32_characters_long",
+      // secure: true should be used in production (HTTPS) but can't be used in development (HTTP)
+      cookieOptions: {
+        // setMaxCookie age here.
+        maxCookieAge,
+        secure: process.env.NODE_ENV === "production",
+      },
+    };
+  },
+);
 ```
 
-### Next.js: withIronSessionSsr(handler, ironOptions)
+### Next.js: withIronSessionSsr(handler, ironOptions | (req: IncomingMessage, res: ServerResponse) => IronSessionOptions | Promise\<IronSessionOptions\>)
 
 Wraps a [Next.js getServerSideProps](https://nextjs.org/docs/basic-features/data-fetching#getserversideprops-server-side-rendering) and adds a `session` object to the request of the context.
 
@@ -616,6 +653,27 @@ export const getServerSideProps = withIronSessionSsr(
     },
   },
 );
+
+// You can also pass an async or sync function which takes request and response object and return IronSessionOptions
+export const getServerSideProps = withIronSessionSsr(
+  async function getServerSideProps({ req }) {
+    return {
+      props: {
+        user: req.session.user,
+      },
+    };
+  },
+  (req, res) => {
+    return {
+      cookieName: "myapp_cookiename",
+      password: "complex_password_at_least_32_characters_long",
+      // secure: true should be used in production (HTTPS) but can't be used in development (HTTP)
+      cookieOptions: {
+        secure: process.env.NODE_ENV === "production",
+      },
+    };
+  },
+);
 ```
 
 ### Express: ironSession(ironOptions)

package/next/dist/index.d.ts

@@ -1,11 +1,14 @@
-import { NextApiHandler, GetServerSidePropsContext, GetServerSidePropsResult } from 'next';
+import { NextApiHandler, GetServerSidePropsContext, GetServerSidePropsResult, NextApiRequest, NextApiResponse } from 'next';
 import { IronSessionOptions } from 'iron-session';
+import { IncomingMessage, ServerResponse } from 'http';
 
-declare function withIronSessionApiRoute(handler: NextApiHandler, options: IronSessionOptions): NextApiHandler;
+declare type GetIronSessionApiOptions = (request: NextApiRequest, response: NextApiResponse) => Promise<IronSessionOptions> | IronSessionOptions;
+declare function withIronSessionApiRoute(handler: NextApiHandler, options: IronSessionOptions | GetIronSessionApiOptions): NextApiHandler;
+declare type GetIronSessionSSROptions = (request: IncomingMessage, response: ServerResponse) => Promise<IronSessionOptions> | IronSessionOptions;
 declare function withIronSessionSsr<P extends {
     [key: string]: unknown;
 } = {
     [key: string]: unknown;
-}>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, options: IronSessionOptions): (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
+}>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, options: IronSessionOptions | GetIronSessionSSROptions): (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
 
 export { withIronSessionApiRoute, withIronSessionSsr };

package/next/dist/index.js

@@ -54,6 +54,9 @@ function getPropertyDescriptorForReqSession(session) {
 // next/index.ts
 function withIronSessionApiRoute(handler, options) {
   return async function nextApiHandlerWrappedWithIronSession(req, res) {
+    if (options instanceof Function) {
+      options = await options(req, res);
+    }
     const session = await (0, import_iron_session.getIronSession)(req, res, options);
     Object.defineProperty(req, "session", getPropertyDescriptorForReqSession(session));
     return handler(req, res);
@@ -61,6 +64,9 @@ function withIronSessionApiRoute(handler, options) {
 }
 function withIronSessionSsr(handler, options) {
   return async function nextGetServerSidePropsHandlerWrappedWithIronSession(context) {
+    if (options instanceof Function) {
+      options = await options(context.req, context.res);
+    }
     const session = await (0, import_iron_session.getIronSession)(context.req, context.res, options);
     Object.defineProperty(context.req, "session", getPropertyDescriptorForReqSession(session));
     return handler(context);

package/next/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../index.ts", "../../src/getPropertyDescriptorForReqSession.ts"],
-  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAMA,0BAA+B;;;ACJhB,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADdtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AACnE,UAAM,UAAU,MAAM,wCAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAIjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AACA,UAAM,UAAU,MAAM,wCAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
+  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n  NextApiRequest,\n  NextApiResponse,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\nimport { IncomingMessage, ServerResponse } from \"http\";\n\n// Argument types based on getIronSession function\ntype GetIronSessionApiOptions = (\n  request: NextApiRequest,\n  response: NextApiResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions | GetIronSessionApiOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(req, res);\n    }\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\n// Argument type based on the SSR context\ntype GetIronSessionSSROptions = (\n  request: IncomingMessage,\n  response: ServerResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions | GetIronSessionSSROptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(context.req, context.res);\n    }\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAQA,0BAA+B;;;ACNhB,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADLtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AAEnE,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,KAAK;AAAA;AAE/B,UAAM,UAAU,MAAM,wCAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAUjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AAEA,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,QAAQ,KAAK,QAAQ;AAAA;AAE/C,UAAM,UAAU,MAAM,wCAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
   "names": []
 }

package/next/dist/index.mjs

@@ -26,6 +26,9 @@ function getPropertyDescriptorForReqSession(session) {
 // next/index.ts
 function withIronSessionApiRoute(handler, options) {
   return async function nextApiHandlerWrappedWithIronSession(req, res) {
+    if (options instanceof Function) {
+      options = await options(req, res);
+    }
     const session = await getIronSession(req, res, options);
     Object.defineProperty(req, "session", getPropertyDescriptorForReqSession(session));
     return handler(req, res);
@@ -33,6 +36,9 @@ function withIronSessionApiRoute(handler, options) {
 }
 function withIronSessionSsr(handler, options) {
   return async function nextGetServerSidePropsHandlerWrappedWithIronSession(context) {
+    if (options instanceof Function) {
+      options = await options(context.req, context.res);
+    }
     const session = await getIronSession(context.req, context.res, options);
     Object.defineProperty(context.req, "session", getPropertyDescriptorForReqSession(session));
     return handler(context);

package/next/dist/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../index.ts", "../../src/getPropertyDescriptorForReqSession.ts"],
-  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
-  "mappings": ";AAMA;;;ACJe,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADdtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AACnE,UAAM,UAAU,MAAM,eAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAIjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AACA,UAAM,UAAU,MAAM,eAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
+  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n  NextApiRequest,\n  NextApiResponse,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\nimport { IncomingMessage, ServerResponse } from \"http\";\n\n// Argument types based on getIronSession function\ntype GetIronSessionApiOptions = (\n  request: NextApiRequest,\n  response: NextApiResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions | GetIronSessionApiOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(req, res);\n    }\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\n// Argument type based on the SSR context\ntype GetIronSessionSSROptions = (\n  request: IncomingMessage,\n  response: ServerResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions | GetIronSessionSSROptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(context.req, context.res);\n    }\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
+  "mappings": ";AAQA;;;ACNe,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADLtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AAEnE,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,KAAK;AAAA;AAE/B,UAAM,UAAU,MAAM,eAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAUjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AAEA,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,QAAQ,KAAK,QAAQ;AAAA;AAE/C,UAAM,UAAU,MAAM,eAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
   "names": []
 }

package/next/index.d.ts

@@ -1,11 +1,14 @@
-import { NextApiHandler, GetServerSidePropsContext, GetServerSidePropsResult } from 'next';
+import { NextApiHandler, GetServerSidePropsContext, GetServerSidePropsResult, NextApiRequest, NextApiResponse } from 'next';
 import { IronSessionOptions } from 'iron-session';
+import { IncomingMessage, ServerResponse } from 'http';
 
-declare function withIronSessionApiRoute(handler: NextApiHandler, options: IronSessionOptions): NextApiHandler;
+declare type GetIronSessionApiOptions = (request: NextApiRequest, response: NextApiResponse) => Promise<IronSessionOptions> | IronSessionOptions;
+declare function withIronSessionApiRoute(handler: NextApiHandler, options: IronSessionOptions | GetIronSessionApiOptions): NextApiHandler;
+declare type GetIronSessionSSROptions = (request: IncomingMessage, response: ServerResponse) => Promise<IronSessionOptions> | IronSessionOptions;
 declare function withIronSessionSsr<P extends {
     [key: string]: unknown;
 } = {
     [key: string]: unknown;
-}>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, options: IronSessionOptions): (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
+}>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, options: IronSessionOptions | GetIronSessionSSROptions): (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
 
 export { withIronSessionApiRoute, withIronSessionSsr };

package/next/index.js

@@ -54,6 +54,9 @@ function getPropertyDescriptorForReqSession(session) {
 // next/index.ts
 function withIronSessionApiRoute(handler, options) {
   return async function nextApiHandlerWrappedWithIronSession(req, res) {
+    if (options instanceof Function) {
+      options = await options(req, res);
+    }
     const session = await (0, import_iron_session.getIronSession)(req, res, options);
     Object.defineProperty(req, "session", getPropertyDescriptorForReqSession(session));
     return handler(req, res);
@@ -61,6 +64,9 @@ function withIronSessionApiRoute(handler, options) {
 }
 function withIronSessionSsr(handler, options) {
   return async function nextGetServerSidePropsHandlerWrappedWithIronSession(context) {
+    if (options instanceof Function) {
+      options = await options(context.req, context.res);
+    }
     const session = await (0, import_iron_session.getIronSession)(context.req, context.res, options);
     Object.defineProperty(context.req, "session", getPropertyDescriptorForReqSession(session));
     return handler(context);

package/next/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../index.ts", "../../src/getPropertyDescriptorForReqSession.ts"],
-  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAMA,0BAA+B;;;ACJhB,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADdtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AACnE,UAAM,UAAU,MAAM,wCAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAIjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AACA,UAAM,UAAU,MAAM,wCAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
+  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n  NextApiRequest,\n  NextApiResponse,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\nimport { IncomingMessage, ServerResponse } from \"http\";\n\n// Argument types based on getIronSession function\ntype GetIronSessionApiOptions = (\n  request: NextApiRequest,\n  response: NextApiResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions | GetIronSessionApiOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(req, res);\n    }\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\n// Argument type based on the SSR context\ntype GetIronSessionSSROptions = (\n  request: IncomingMessage,\n  response: ServerResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions | GetIronSessionSSROptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(context.req, context.res);\n    }\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAQA,0BAA+B;;;ACNhB,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADLtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AAEnE,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,KAAK;AAAA;AAE/B,UAAM,UAAU,MAAM,wCAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAUjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AAEA,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,QAAQ,KAAK,QAAQ;AAAA;AAE/C,UAAM,UAAU,MAAM,wCAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
   "names": []
 }

package/next/index.mjs

@@ -26,6 +26,9 @@ function getPropertyDescriptorForReqSession(session) {
 // next/index.ts
 function withIronSessionApiRoute(handler, options) {
   return async function nextApiHandlerWrappedWithIronSession(req, res) {
+    if (options instanceof Function) {
+      options = await options(req, res);
+    }
     const session = await getIronSession(req, res, options);
     Object.defineProperty(req, "session", getPropertyDescriptorForReqSession(session));
     return handler(req, res);
@@ -33,6 +36,9 @@ function withIronSessionApiRoute(handler, options) {
 }
 function withIronSessionSsr(handler, options) {
   return async function nextGetServerSidePropsHandlerWrappedWithIronSession(context) {
+    if (options instanceof Function) {
+      options = await options(context.req, context.res);
+    }
     const session = await getIronSession(context.req, context.res, options);
     Object.defineProperty(context.req, "session", getPropertyDescriptorForReqSession(session));
     return handler(context);

package/next/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../index.ts", "../../src/getPropertyDescriptorForReqSession.ts"],
-  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
-  "mappings": ";AAMA;;;ACJe,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADdtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AACnE,UAAM,UAAU,MAAM,eAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAIjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AACA,UAAM,UAAU,MAAM,eAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
+  "sourcesContent": ["import type {\n  NextApiHandler,\n  GetServerSidePropsContext,\n  GetServerSidePropsResult,\n  NextApiRequest,\n  NextApiResponse,\n} from \"next\";\nimport type { IronSessionOptions } from \"iron-session\";\nimport { getIronSession } from \"iron-session\";\nimport getPropertyDescriptorForReqSession from \"../src/getPropertyDescriptorForReqSession\";\nimport { IncomingMessage, ServerResponse } from \"http\";\n\n// Argument types based on getIronSession function\ntype GetIronSessionApiOptions = (\n  request: NextApiRequest,\n  response: NextApiResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionApiRoute(\n  handler: NextApiHandler,\n  options: IronSessionOptions | GetIronSessionApiOptions,\n): NextApiHandler {\n  return async function nextApiHandlerWrappedWithIronSession(req, res) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(req, res);\n    }\n    const session = await getIronSession(req, res, options);\n\n    // we define req.session as being enumerable (so console.log(req) shows it)\n    // and we also want to allow people to do:\n    // req.session = { admin: true }; or req.session = {...req.session, admin: true};\n    // req.session.save();\n    Object.defineProperty(\n      req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(req, res);\n  };\n}\n\n// Argument type based on the SSR context\ntype GetIronSessionSSROptions = (\n  request: IncomingMessage,\n  response: ServerResponse,\n) => Promise<IronSessionOptions> | IronSessionOptions;\n\nexport function withIronSessionSsr<\n  P extends { [key: string]: unknown } = { [key: string]: unknown },\n>(\n  handler: (\n    context: GetServerSidePropsContext,\n  ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,\n  options: IronSessionOptions | GetIronSessionSSROptions,\n) {\n  return async function nextGetServerSidePropsHandlerWrappedWithIronSession(\n    context: GetServerSidePropsContext,\n  ) {\n    // If options is a function, call it and assign the results back.\n    if (options instanceof Function) {\n      options = await options(context.req, context.res);\n    }\n    const session = await getIronSession(context.req, context.res, options);\n    Object.defineProperty(\n      context.req,\n      \"session\",\n      getPropertyDescriptorForReqSession(session),\n    );\n    return handler(context);\n  };\n}\n", "import type { IronSession } from \".\";\n\nexport default function getPropertyDescriptorForReqSession(\n  session: IronSession,\n): PropertyDescriptor {\n  return {\n    enumerable: true,\n    get() {\n      return session;\n    },\n    set(value) {\n      const keys = Object.keys(value);\n      const currentKeys = Object.keys(session);\n\n      currentKeys.forEach((key) => {\n        if (!keys.includes(key)) {\n          // @ts-ignore See comment in IronSessionData interface\n          delete session[key];\n        }\n      });\n\n      keys.forEach((key) => {\n        // @ts-ignore See comment in IronSessionData interface\n        session[key] = value[key];\n      });\n    },\n  };\n}\n"],
+  "mappings": ";AAQA;;;ACNe,4CACb,SACoB;AACpB,SAAO;AAAA,IACL,YAAY;AAAA,IACZ,MAAM;AACJ,aAAO;AAAA;AAAA,IAET,IAAI,OAAO;AACT,YAAM,OAAO,OAAO,KAAK;AACzB,YAAM,cAAc,OAAO,KAAK;AAEhC,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,YAAI,CAAC,KAAK,SAAS,MAAM;AAEvB,iBAAO,QAAQ;AAAA;AAAA;AAInB,WAAK,QAAQ,CAAC,QAAQ;AAEpB,gBAAQ,OAAO,MAAM;AAAA;AAAA;AAAA;AAAA;;;ADLtB,iCACL,SACA,SACgB;AAChB,SAAO,oDAAoD,KAAK,KAAK;AAEnE,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,KAAK;AAAA;AAE/B,UAAM,UAAU,MAAM,eAAe,KAAK,KAAK;AAM/C,WAAO,eACL,KACA,WACA,mCAAmC;AAErC,WAAO,QAAQ,KAAK;AAAA;AAAA;AAUjB,4BAGL,SAGA,SACA;AACA,SAAO,mEACL,SACA;AAEA,QAAI,mBAAmB,UAAU;AAC/B,gBAAU,MAAM,QAAQ,QAAQ,KAAK,QAAQ;AAAA;AAE/C,UAAM,UAAU,MAAM,eAAe,QAAQ,KAAK,QAAQ,KAAK;AAC/D,WAAO,eACL,QAAQ,KACR,WACA,mCAAmC;AAErC,WAAO,QAAQ;AAAA;AAAA;",
   "names": []
 }

package/next/index.test.ts

@@ -60,6 +60,31 @@ test("withIronSessionApiRoute: req.session.save creates a cookie", async () => {
   await wrappedHandler(getDefaultReq(), getDefaultRes());
 });
 
+test("withIconSessionApiRoute: IronSessionOptions passed as a function works correctly", async () => {
+  const wrappedHandler = withIronSessionApiRoute(
+    async function handler(req, res) {
+      req.session.user = { id: 200 };
+      await req.session.save();
+      const headerValue = (res.setHeader as jest.Mock).mock.calls[0][1];
+      const cookie = headerValue[0];
+      const cookieParams = cookie.split(";").slice(1).join(";");
+      const cookieName = cookie.split("=")[0];
+
+      expect(cookieParams).toMatchInlineSnapshot(
+        `" Max-Age=60; Path=/; HttpOnly; Secure; SameSite=Lax"`,
+      );
+      expect(cookieName).toBe("dynamic-cookie-name");
+    },
+    () => ({
+      cookieName: "dynamic-cookie-name",
+      password,
+      ttl: 120,
+    }),
+  );
+
+  await wrappedHandler(getDefaultReq(), getDefaultRes());
+});
+
 test("withIronSessionApiRoute: req.session.destroy removes the cookie", async () => {
   const wrappedHandler = withIronSessionApiRoute(
     async function handler(req, res) {

package/next/index.ts

@@ -2,16 +2,29 @@ import type {
   NextApiHandler,
   GetServerSidePropsContext,
   GetServerSidePropsResult,
+  NextApiRequest,
+  NextApiResponse,
 } from "next";
 import type { IronSessionOptions } from "iron-session";
 import { getIronSession } from "iron-session";
 import getPropertyDescriptorForReqSession from "../src/getPropertyDescriptorForReqSession";
+import { IncomingMessage, ServerResponse } from "http";
+
+// Argument types based on getIronSession function
+type GetIronSessionApiOptions = (
+  request: NextApiRequest,
+  response: NextApiResponse,
+) => Promise<IronSessionOptions> | IronSessionOptions;
 
 export function withIronSessionApiRoute(
   handler: NextApiHandler,
-  options: IronSessionOptions,
+  options: IronSessionOptions | GetIronSessionApiOptions,
 ): NextApiHandler {
   return async function nextApiHandlerWrappedWithIronSession(req, res) {
+    // If options is a function, call it and assign the results back.
+    if (options instanceof Function) {
+      options = await options(req, res);
+    }
     const session = await getIronSession(req, res, options);
 
     // we define req.session as being enumerable (so console.log(req) shows it)
@@ -27,17 +40,27 @@ export function withIronSessionApiRoute(
   };
 }
 
+// Argument type based on the SSR context
+type GetIronSessionSSROptions = (
+  request: IncomingMessage,
+  response: ServerResponse,
+) => Promise<IronSessionOptions> | IronSessionOptions;
+
 export function withIronSessionSsr<
   P extends { [key: string]: unknown } = { [key: string]: unknown },
 >(
   handler: (
     context: GetServerSidePropsContext,
   ) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>,
-  options: IronSessionOptions,
+  options: IronSessionOptions | GetIronSessionSSROptions,
 ) {
   return async function nextGetServerSidePropsHandlerWrappedWithIronSession(
     context: GetServerSidePropsContext,
   ) {
+    // If options is a function, call it and assign the results back.
+    if (options instanceof Function) {
+      options = await options(context.req, context.res);
+    }
     const session = await getIronSession(context.req, context.res, options);
     Object.defineProperty(
       context.req,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iron-session",
-  "version": "6.0.5",
+  "version": "6.1.0",
   "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.",
   "keywords": [
     "Next.js",
@@ -125,23 +125,23 @@
     "@types/cookie": "^0.4.0",
     "@types/express": "^4.17.13",
     "@types/node": "^16.11.7",
-    "cookie": "^0.4.1"
+    "cookie": "^0.4.2"
   },
   "devDependencies": {
-    "@swc/core": "^1.2.107",
-    "@swc/jest": "0.2.5",
+    "@swc/core": "^1.2.156",
+    "@swc/jest": "^0.2.20",
     "@tsconfig/node12": "1.0.9",
-    "@types/jest": "27.0.2",
-    "@typescript-eslint/eslint-plugin": "5.3.0",
-    "@typescript-eslint/parser": "^5.3.1",
-    "concurrently": "6.3.0",
-    "eslint": "^8.2.0",
-    "jest": "27.3.1",
-    "prettier": "2.4.1",
-    "prettier-plugin-packagejson": "2.2.13",
+    "@types/jest": "^27.4.1",
+    "@typescript-eslint/eslint-plugin": "^5.15.0",
+    "@typescript-eslint/parser": "^5.15.0",
+    "concurrently": "^7.0.0",
+    "eslint": "^8.11.0",
+    "jest": "^27.5.1",
+    "prettier": "^2.6.0",
+    "prettier-plugin-packagejson": "^2.2.16",
     "rimraf": "3.0.2",
     "tsup": "5.6.0",
-    "typescript": "4.4.4"
+    "typescript": "^4.6.2"
   },
   "peerDependencies": {
     "express": ">=4",