@eggjs/session 4.0.1 → 5.0.0-beta.17

package/README.md

@@ -1,8 +1,6 @@
 # @eggjs/session
 
 [![NPM version][npm-image]][npm-url]
-[![Node.js CI](https://github.com/eggjs/session/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/session/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![Known Vulnerabilities][snyk-image]][snyk-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/session.svg?style=flat)](https://nodejs.org/en/download/)
@@ -11,8 +9,6 @@
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/session.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/session
-[codecov-image]: https://codecov.io/gh/eggjs/session/branch/master/graph/badge.svg
-[codecov-url]: https://codecov.io/gh/eggjs/session
 [snyk-image]: https://snyk.io/test/npm/@eggjs/session/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/@eggjs/session
 [download-image]: https://img.shields.io/npm/dm/@eggjs/session.svg?style=flat-square
@@ -41,69 +37,69 @@ egg-session support external store, you can store your sessions in redis, memcac
 
 For example, if you want to store session in redis, you must:
 
-1. Dependent [@eggjs/redis](https://github.com/eggjs/redis)
+1. Dependent [@eggjs/redis](https://github.com/eggjs/egg/tree/next/plugins/redis)
 
-  ```bash
-  npm i --save @eggjs/redis
-  ```
+```bash
+npm i --save @eggjs/redis
+```
 
 2. Import `@eggjs/redis` as a plugin and set the configuration
 
-  ```js
-  // config/plugin.js
-  exports.redis = {
-    enable: true,
-    package: '@eggjs/redis',
-  };
-  ```
+```js
+// config/plugin.js
+exports.redis = {
+  enable: true,
+  package: '@eggjs/redis',
+};
+```
 
-  ```js
-  // config/config.default.js
-  exports.redis = {
-    // your redis configurations
-  };
-  ```
+```js
+// config/config.default.js
+exports.redis = {
+  // your redis configurations
+};
+```
 
 3. Implement a session store with redis
 
-  ```js
-  // app.js
-
-  module.exports = app => {
-    // set redis session store
-    // session store must have 3 methods
-    // define sessionStore in `app.js` so you can access `app.redis`
-    app.sessionStore = {
-      async get(key) {
-        const res = await app.redis.get(key);
-        if (!res) return null;
-        return JSON.parse(res);
-      },
-
-      async set(key, value, maxAge) {
-        // maxAge not present means session cookies
-        // we can't exactly know the maxAge and just set an appropriate value like one day
-        if (!maxAge) maxAge = 24 * 60 * 60 * 1000;
-        value = JSON.stringify(value);
-        await app.redis.set(key, value, 'PX', maxAge);
-      },
-
-      async destroy(key) {
-        await app.redis.del(key);
-      },
-    };
-
-    // session store can be a session store class
-    // app.sessionStore = class Store {
-    //   constructor(app) {
-    //     this.app = app;
-    //   }
-    //   async get() {}
-    //   async set() {}
-    //   async destroy() {}
-    // };
+```js
+// app.js
+
+module.exports = app => {
+  // set redis session store
+  // session store must have 3 methods
+  // define sessionStore in `app.js` so you can access `app.redis`
+  app.sessionStore = {
+    async get(key) {
+      const res = await app.redis.get(key);
+      if (!res) return null;
+      return JSON.parse(res);
+    },
+
+    async set(key, value, maxAge) {
+      // maxAge not present means session cookies
+      // we can't exactly know the maxAge and just set an appropriate value like one day
+      if (!maxAge) maxAge = 24 * 60 * 60 * 1000;
+      value = JSON.stringify(value);
+      await app.redis.set(key, value, 'PX', maxAge);
+    },
+
+    async destroy(key) {
+      await app.redis.del(key);
+    },
   };
-  ```
+
+  // session store can be a session store class
+  // app.sessionStore = class Store {
+  //   constructor(app) {
+  //     this.app = app;
+  //   }
+  //   async get() {}
+  //   async set() {}
+  //   async destroy() {}
+  // };
+};
+```
 
 Once you use external session store, session is strong dependent on your external store, you can't access session if your external store is down. **Use external session stores only if necessary, avoid use session as a cache, keep session lean and stored by cookie!**
 
@@ -111,13 +107,13 @@ Once you use external session store, session is strong dependent on your externa
 
 Support all configurations in [koa-session](https://github.com/koajs/session).
 
-* logValue
+- logValue
 
 ```bash
 Support not to print the session value when session event trigger log. Default to be true.
 ```
 
-[View the default configurations](https://github.com/eggjs/egg-session/blob/master/config/config.default.js)
+[View the default configurations](https://github.com/eggjs/egg/tree/next/plugins/session/src/config/config.default.ts)
 
 ## Questions & Suggestions
 
@@ -129,6 +125,6 @@ Please open an issue [here](https://github.com/eggjs/egg/issues).
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/session)](https://github.com/eggjs/session/graphs/contributors)
+[![Contributors](https://contrib.rocks/image?repo=eggjs/egg)](https://github.com/eggjs/egg/graphs/contributors)
 
 Made with [contributors-img](https://contrib.rocks).

package/dist/app/extend/application.d.ts

@@ -0,0 +1,37 @@
+import { SessionConfig } from "../../config/config.default.js";
+import { Application } from "egg";
+
+//#region src/app/extend/application.d.ts
+type SessionStore = Required<SessionConfig>['store'];
+type SessionStoreOrAppSessionStoreClass = SessionStore | {
+  new (app: Application): SessionStore;
+};
+declare class SessionApplication extends Application {
+  /**
+   * set session external store
+   *
+   * ```js
+   * app.sessionStore = {
+   *   get(key): Promise<unknown>,
+   *   set(key, data): Promise<void>,
+   *   destroy(key): Promise<void>,
+   * };
+   *
+   * app.sessionStore = class SessionStore {
+   *   constructor(app) {
+   *   }
+   *   get(key): Promise<unknown>,
+   *   set(key, data): Promise<void>,
+   *   destroy(key): Promise<void>,
+   * }
+   * ```
+   * @param {Class|Object} store session store class or instance
+   */
+  set sessionStore(store: SessionStoreOrAppSessionStoreClass | null | undefined);
+  /**
+   * get sessionStore instance
+   */
+  get sessionStore(): SessionStore | undefined;
+}
+//#endregion
+export { SessionStore, SessionStoreOrAppSessionStoreClass, SessionApplication as default };

package/dist/app/extend/application.js

@@ -0,0 +1,48 @@
+import assert from "node:assert";
+import { Application } from "egg";
+
+//#region src/app/extend/application.ts
+var SessionApplication = class extends Application {
+	/**
+	* set session external store
+	*
+	* ```js
+	* app.sessionStore = {
+	*   get(key): Promise<unknown>,
+	*   set(key, data): Promise<void>,
+	*   destroy(key): Promise<void>,
+	* };
+	*
+	* app.sessionStore = class SessionStore {
+	*   constructor(app) {
+	*   }
+	*   get(key): Promise<unknown>,
+	*   set(key, data): Promise<void>,
+	*   destroy(key): Promise<void>,
+	* }
+	* ```
+	* @param {Class|Object} store session store class or instance
+	*/
+	set sessionStore(store) {
+		if (this.config.session.store && this.config.env !== "unittest") this.coreLogger.warn("[@eggjs/session] sessionStore already exists and will be overwrite");
+		if (!store) {
+			this.config.session.store = void 0;
+			this.coreLogger.info("[@eggjs/session] sessionStore is disabled");
+			return;
+		}
+		if (typeof store === "function") store = new store(this);
+		assert(typeof store.get === "function", "store.get must be function");
+		assert(typeof store.set === "function", "store.set must be function");
+		assert(typeof store.destroy === "function", "store.destroy must be function");
+		this.config.session.store = store;
+	}
+	/**
+	* get sessionStore instance
+	*/
+	get sessionStore() {
+		return this.config.session.store;
+	}
+};
+
+//#endregion
+export { SessionApplication as default };

package/dist/app/middleware/session.d.ts

@@ -0,0 +1,2 @@
+import { createSession } from "koa-session";
+export { createSession as default };

package/dist/app/middleware/session.js

@@ -0,0 +1,7 @@
+import { createSession } from "koa-session";
+
+//#region src/app/middleware/session.ts
+var session_default = createSession;
+
+//#endregion
+export { session_default as default };

package/dist/app.d.ts

@@ -0,0 +1,10 @@
+import { Application, ILifecycleBoot } from "egg";
+
+//#region src/app.d.ts
+declare class AppBoot implements ILifecycleBoot {
+  private readonly app;
+  constructor(app: Application);
+  configWillLoad(): void;
+}
+//#endregion
+export { AppBoot as default };

package/dist/app.js

@@ -0,0 +1,27 @@
+import { SessionConfig } from "./config/config.default.js";
+
+//#region src/app.ts
+var AppBoot = class {
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	configWillLoad() {
+		const app = this.app;
+		SessionConfig.parse(app.config.session);
+		if (!app.config.session.httpOnly) app.coreLogger.warn("[@eggjs/session]: please set `config.session.httpOnly` to true. It is very dangerous if session can read by client JavaScript.");
+		app.config.coreMiddleware.push("session");
+		app.on("session:missed", ({ ctx, key }) => {
+			ctx.coreLogger.warn("[session][missed] key(%s)", key);
+		});
+		app.on("session:expired", ({ ctx, key, value }) => {
+			ctx.coreLogger.warn("[session][expired] key(%s) value(%j)", key, app.config.session.logValue ? value : "");
+		});
+		app.on("session:invalid", ({ ctx, key, value }) => {
+			ctx.coreLogger.warn("[session][invalid] key(%s) value(%j)", key, app.config.session.logValue ? value : "");
+		});
+	}
+};
+
+//#endregion
+export { AppBoot as default };

package/dist/config/config.default.d.ts

@@ -0,0 +1,209 @@
+import z from "zod";
+
+//#region src/config/config.default.d.ts
+declare const SessionConfig: z.ZodObject<{
+  key: z.ZodDefault<z.ZodString>;
+  maxAge: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"session">]>>;
+  autoCommit: z.ZodDefault<z.ZodBoolean>;
+  overwrite: z.ZodDefault<z.ZodBoolean>;
+  httpOnly: z.ZodDefault<z.ZodBoolean>;
+  signed: z.ZodDefault<z.ZodBoolean>;
+  rolling: z.ZodDefault<z.ZodBoolean>;
+  renew: z.ZodDefault<z.ZodBoolean>;
+  secure: z.ZodOptional<z.ZodBoolean>;
+  sameSite: z.ZodOptional<z.ZodString>;
+  externalKey: z.ZodOptional<z.ZodObject<{
+    get: z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodString>;
+    set: z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodString], z.ZodUnknown>, z.ZodVoid>;
+  }, "strip", z.ZodTypeAny, {
+    set: (args_0: any, args_1: string, ...args: unknown[]) => void;
+    get: (args_0: any, ...args: unknown[]) => string;
+  }, {
+    set: (args_0: any, args_1: string, ...args: unknown[]) => void;
+    get: (args_0: any, ...args: unknown[]) => string;
+  }>>;
+  store: z.ZodOptional<z.ZodObject<{
+    get: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodNumber, z.ZodObject<{
+      rolling: z.ZodBoolean;
+      ctx: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+      rolling: boolean;
+      ctx?: any;
+    }, {
+      rolling: boolean;
+      ctx?: any;
+    }>], z.ZodUnknown>, z.ZodPromise<z.ZodAny>>;
+    set: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny, z.ZodNumber, z.ZodObject<{
+      rolling: z.ZodBoolean;
+      changed: z.ZodBoolean;
+      ctx: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+      rolling: boolean;
+      changed: boolean;
+      ctx?: any;
+    }, {
+      rolling: boolean;
+      changed: boolean;
+      ctx?: any;
+    }>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    destroy: z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodObject<{
+      ctx: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+      ctx?: any;
+    }, {
+      ctx?: any;
+    }>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+  }, "strip", z.ZodTypeAny, {
+    set: (args_0: string, args_1: any, args_2: number, args_3: {
+      rolling: boolean;
+      changed: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+    get: (args_0: string, args_1: number, args_2: {
+      rolling: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<any>;
+    destroy: (args_0: string, args_1: {
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+  }, {
+    set: (args_0: string, args_1: any, args_2: number, args_3: {
+      rolling: boolean;
+      changed: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+    get: (args_0: string, args_1: number, args_2: {
+      rolling: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<any>;
+    destroy: (args_0: string, args_1: {
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+  }>>;
+  ContextStore: z.ZodOptional<z.ZodAny>;
+  encode: z.ZodDefault<z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodString>>>;
+  decode: z.ZodDefault<z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodAny>>;
+  genid: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodString>>;
+  prefix: z.ZodOptional<z.ZodString>;
+  valid: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodAny], z.ZodUnknown>, z.ZodAny>>;
+  beforeSave: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
+} & {
+  logValue: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+  logValue: boolean;
+  key: string;
+  autoCommit: boolean;
+  overwrite: boolean;
+  httpOnly: boolean;
+  signed: boolean;
+  rolling: boolean;
+  renew: boolean;
+  encode: (args_0: any, ...args: unknown[]) => string;
+  decode: (args_0: string, ...args: unknown[]) => any;
+  maxAge?: number | "session" | undefined;
+  secure?: boolean | undefined;
+  sameSite?: string | undefined;
+  externalKey?: {
+    set: (args_0: any, args_1: string, ...args: unknown[]) => void;
+    get: (args_0: any, ...args: unknown[]) => string;
+  } | undefined;
+  store?: {
+    set: (args_0: string, args_1: any, args_2: number, args_3: {
+      rolling: boolean;
+      changed: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+    get: (args_0: string, args_1: number, args_2: {
+      rolling: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<any>;
+    destroy: (args_0: string, args_1: {
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+  } | undefined;
+  ContextStore?: any;
+  genid?: ((args_0: any, ...args: unknown[]) => string) | undefined;
+  prefix?: string | undefined;
+  valid?: ((args_0: any, args_1: any, ...args: unknown[]) => any) | undefined;
+  beforeSave?: ((args_0: any, args_1: any, ...args: unknown[]) => void) | undefined;
+}, {
+  logValue?: boolean | undefined;
+  key?: string | undefined;
+  maxAge?: number | "session" | undefined;
+  autoCommit?: boolean | undefined;
+  overwrite?: boolean | undefined;
+  httpOnly?: boolean | undefined;
+  signed?: boolean | undefined;
+  rolling?: boolean | undefined;
+  renew?: boolean | undefined;
+  secure?: boolean | undefined;
+  sameSite?: string | undefined;
+  externalKey?: {
+    set: (args_0: any, args_1: string, ...args: unknown[]) => void;
+    get: (args_0: any, ...args: unknown[]) => string;
+  } | undefined;
+  store?: {
+    set: (args_0: string, args_1: any, args_2: number, args_3: {
+      rolling: boolean;
+      changed: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+    get: (args_0: string, args_1: number, args_2: {
+      rolling: boolean;
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<any>;
+    destroy: (args_0: string, args_1: {
+      ctx?: any;
+    }, ...args: unknown[]) => Promise<void>;
+  } | undefined;
+  ContextStore?: any;
+  encode?: ((args_0: any, ...args: unknown[]) => string) | undefined;
+  decode?: ((args_0: string, ...args: unknown[]) => any) | undefined;
+  genid?: ((args_0: any, ...args: unknown[]) => string) | undefined;
+  prefix?: string | undefined;
+  valid?: ((args_0: any, args_1: any, ...args: unknown[]) => any) | undefined;
+  beforeSave?: ((args_0: any, args_1: any, ...args: unknown[]) => void) | undefined;
+}>;
+type SessionConfig = z.infer<typeof SessionConfig>;
+declare const _default: {
+  session: {
+    logValue: boolean;
+    key: string;
+    autoCommit: boolean;
+    overwrite: boolean;
+    httpOnly: boolean;
+    signed: boolean;
+    rolling: boolean;
+    renew: boolean;
+    encode: (args_0: any, ...args: unknown[]) => string;
+    decode: (args_0: string, ...args: unknown[]) => any;
+    maxAge?: number | "session" | undefined;
+    secure?: boolean | undefined;
+    sameSite?: string | undefined;
+    externalKey?: {
+      set: (args_0: any, args_1: string, ...args: unknown[]) => void;
+      get: (args_0: any, ...args: unknown[]) => string;
+    } | undefined;
+    store?: {
+      set: (args_0: string, args_1: any, args_2: number, args_3: {
+        rolling: boolean;
+        changed: boolean;
+        ctx?: any;
+      }, ...args: unknown[]) => Promise<void>;
+      get: (args_0: string, args_1: number, args_2: {
+        rolling: boolean;
+        ctx?: any;
+      }, ...args: unknown[]) => Promise<any>;
+      destroy: (args_0: string, args_1: {
+        ctx?: any;
+      }, ...args: unknown[]) => Promise<void>;
+    } | undefined;
+    ContextStore?: any;
+    genid?: ((args_0: any, ...args: unknown[]) => string) | undefined;
+    prefix?: string | undefined;
+    valid?: ((args_0: any, args_1: any, ...args: unknown[]) => any) | undefined;
+    beforeSave?: ((args_0: any, args_1: any, ...args: unknown[]) => void) | undefined;
+  };
+};
+//#endregion
+export { SessionConfig, _default as default };

package/dist/config/config.default.js

@@ -0,0 +1,14 @@
+import z from "zod";
+import { SessionOptions } from "koa-session";
+
+//#region src/config/config.default.ts
+const SessionConfig = SessionOptions.extend({ logValue: z.boolean().default(true) });
+var config_default_default = { session: SessionConfig.parse({
+	maxAge: 24 * 3600 * 1e3,
+	key: "EGG_SESS",
+	httpOnly: true,
+	encrypt: true
+}) };
+
+//#endregion
+export { SessionConfig, config_default_default as default };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { SessionConfig } from "./config/config.default.js";
+export { SessionConfig };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { SessionConfig } from "./config/config.default.js";
+import "./app/extend/application.js";
+
+export { SessionConfig };

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+import { SessionConfig } from "./config/config.default.js";
+import { SessionStore, SessionStoreOrAppSessionStoreClass } from "./app/extend/application.js";
+
+//#region src/types.d.ts
+declare module 'egg' {
+  interface EggAppConfig {
+    session: SessionConfig;
+  }
+  interface Application {
+    set sessionStore(store: SessionStoreOrAppSessionStoreClass | null | undefined);
+    get sessionStore(): SessionStore | undefined;
+  }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {  };