mm_session 1.5.2 → 1.5.3

package/lib/session.js

@@ -1,28 +1,67 @@
 const { Store } = require('./store.js');
+const { Helper } = require('./helper.js');
+
+if (!$.dict) {
+  // 增加字典
+  $.dict = {};
+}
 
 /**
  * Session类
  */
 class Session {
+  /**
+   * 默认配置
+   */
+  static config = {
+    // 密钥
+    encrypt_key: $.config?.encrypt_key ? $.config.encrypt_key : 'mm'.md5().substring(0, 16),
+    // session存储在缓存中的key前缀，默认'mm:uuid'
+    key_prefix: $.dict.session_id || 'mm:uuid',
+    // session ID存储在cookie中的字段名，默认'mm:uuid'
+    cookie_token: $.dict.cookie_token || 'mm:uuid',
+    // HTTP请求头中用于传递session ID的字段名，默认'x-auth-token'
+    header_token: $.dict.header_token || 'x-auth-token',
+    // session ID过期时间，单位秒，默认7天
+    uuid_expire: $.dict.uuid_expire || 60 * 60 * 24 * 7,
+    // session过期时间，单位秒，默认2小时
+    max_age: 60 * 60 * 2,
+    // 过期token处理选项：'reject'（拒绝访问）或'allow'（允许访问缓存）
+    expired_handling: 'reject',
+  };
+
   /**
    * 构造函数
    * @param {object} config 配置选项
    */
   constructor(config = {}) {
-    this.config = {
-      key: $.dict.session_id || 'mm:uuid',
-      ...config
-    };
-    
-    this._store = new Store();
+    this.config = { ...Session.config };
+    this.setConfig(config);
+    this._init();
   }
 }
 
+/**
+ * 设置session配置
+ * @param {object} config 配置选项
+ */
+Session.prototype.setConfig = function (config) {
+  $.push(this.config, config);
+};
+
+/**
+ * 初始化session存储和助手
+ */
+Session.prototype._init = function () {
+  this._store = new Store(this.config.key_prefix);
+  this._helper = new Helper();
+};
+
 /**
  * 初始化session存储
  * @param {Store} store session存储实例
  */
-Session.prototype.init = function(store) {
+Session.prototype.init = function (store) {
   if (store) {
     this._store = store;
   }
@@ -32,30 +71,79 @@ Session.prototype.init = function(store) {
  * 创建session中间件
  * @returns {Function} 中间件函数
  */
-Session.prototype.middleware = function() {
-  return async (ctx, next) => {
-    await this._handle(ctx, next);
+Session.prototype.middleware = function () {
+  var self = this;
+
+  return async function (ctx, next) {
+    await self._handle(ctx, next);
   };
 };
 
 /**
- * 处理session逻辑
+ * 获取session对象
  * @param {object} ctx HTTP上下文
- * @param {Function} next 下一个中间件
+ * @returns {object} session对象
  */
-Session.prototype._handle = async function(ctx, next) {
-  let uuid = this._get(ctx);
-  let need_refresh = false;
+Session.prototype.get = async function (ctx) {
+  // 获取协议头信息
+  let { ip, user_agent } = this._getHeaderInfo(ctx);
+  // 获取session ID
+  let session_id = this.getId(ctx);
+
+  // 验证session ID标识的有效性
+  if (session_id) {
+    let is_valid = await this._checkSessionId(session_id, ip, user_agent);
+    if (!is_valid) {
+      // token验证失败，返回null创建新session
+      session_id = null;
+    }
+  }
 
-  ctx.session = await this._init(ctx, uuid, need_refresh);
+  // 获取session对象
+  let session = await this._get(session_id);
 
-  this._add(ctx, need_refresh);
+  if (!session.uuid) {
+    session.uuid = this._genId(ip, user_agent);
+  }
+  // 创建session代理对象
+  ctx.session = this._create(session);
+  // 追加方法
+  this._addMethod(ctx);
+  return ctx.session;
+};
 
+/**
+ * 处理session逻辑
+ * @param {object} ctx HTTP上下文
+ * @param {Function} next 下一个中间件
+ */
+Session.prototype._handle = async function (ctx, next) {
+  console.log('  - _handle方法开始执行');
+  let session_id = await this.get(ctx);
+
+  // 执行业务逻辑（包括登录/退出）
+  console.log('  - 执行next()之前');
   await next();
+  console.log('  - 执行next()之后');
 
-  this._cleanup(ctx);
+  // 保存session（基于session是否被修改）
+  console.log('  - 准备调用save方法');
+  await this._save(ctx, session_id);
+  console.log('  - save方法执行完成');
+};
 
-  await this._save(ctx, uuid, need_refresh);
+/**
+ * 获取协议头信息
+ * @param {object} ctx HTTP上下文
+ * @returns {object} session信息
+ */
+Session.prototype._getHeaderInfo = function (ctx) {
+  let ip = ctx.ip || '127.0.0.1';
+  let user_agent = ctx.headers['user-agent'] || 'mm';
+  return {
+    ip,
+    user_agent
+  };
 };
 
 /**
@@ -63,59 +151,84 @@ Session.prototype._handle = async function(ctx, next) {
  * @param {object} ctx HTTP上下文
  * @returns {string} session ID
  */
-Session.prototype._get = function(ctx) {
-  let uuid = ctx.cookies.get(this.config.key, this.config.config);
-  if (!uuid) {
-    uuid = ctx.headers[$.dict.token];
+Session.prototype.getId = function (ctx) {
+  // 先尝试从cookie中获取session ID
+  let session_id = ctx.cookies.get(this.config.cookie_token, this.config.options);
+  if (!session_id) {
+    // 如果cookie中没有，尝试从header中获取
+    session_id = ctx.headers[this.config.header_token];
   }
-  return uuid;
+  return session_id;
 };
 
 /**
- * 初始化session
- * @param {object} ctx HTTP上下文
- * @param {string} uuid session ID
- * @param {boolean} need_refresh 是否需要刷新
- * @returns {object} session对象
+ * 生成session ID
+ * @param {string} ip 客户端IP地址
+ * @param {string} user_agent 用户代理字符串
+ * @returns {string} 生成的session ID
  */
-Session.prototype._init = async function(ctx, uuid, need_refresh) {
-  if (!uuid) {
-    return this._new(ctx);
-  }
+Session.prototype._genId = function (ip, user_agent) {
+  return this._helper.genId(this.config.encrypt_key, ip, user_agent, this.config.uuid_expire);
+};
 
-  let session = await this._store.get(uuid);
-  let result = { session, uuid, need_refresh };
+/**
+ * 生成session ID
+ * @param {object} ctx HTTP上下文
+ * @returns {string} session ID
+ */
+Session.prototype.genId = function (ctx) {
+  let { ip, user_agent } = this._getHeaderInfo(ctx);
+  return this._genId(ip, user_agent);
+};
 
-  if (session == null) {
-    result.uuid = await this._store.getID(ctx);
-    result.need_refresh = true;
+/**
+ * 初始化session
+ * 
+ * @param {string} session_id session ID
+ * @returns {object} session对象
+ */
+Session.prototype._get = async function (session_id) {
+  let session;
+  if (session_id) {
+    var data = await this._store.get(session_id);
+    // 如果session不存在，创建新session
+    if (data) {
+      session = data;
+      // 现有session，设置标志位
+      session._is_new = false;
+      session._modified = false;
+    }
   }
-
-  if (typeof session !== 'object' || session == null) {
-    result.session = this._new(ctx);
+  if (!session) {
+    session = {
+      _is_new: true,      // 新session标志
+      _modified: false    // 修改标志
+    };
   }
-
-  return result.session;
+  // 设置session的uuid属性
+  session.uuid = session_id;
+  return session;
 };
 
 /**
  * 创建新session
- * @param {object} ctx HTTP上下文
+ * @param {object} session session对象
  * @returns {Proxy} session代理对象
  */
-Session.prototype._new = function(ctx) {
-  return new Proxy({}, {
-    set: (obj, prop, value) => {
-      const new_obj = { ...obj };
-      new_obj[prop] = value;
-      
-      if (!new_obj.uuid) {
-        this._store.getID(ctx).then((uuid) => {
-          new_obj.uuid = uuid;
-        });
+Session.prototype._create = function (session) {
+  // 使用Proxy监听session修改
+  return new Proxy(session, {
+    set: function (target, property, value) {
+      // 内部属性不触发修改标记
+      if (property.startsWith('_')) {
+        Reflect.set(target, property, value);
+        return true;
       }
-      
-      Object.assign(obj, new_obj);
+
+      Reflect.set(target, property, value);
+      // 普通属性被设置时标记为已修改
+      Reflect.set(target, '_modified', true);
+      return true;
     }
   });
 };
@@ -123,22 +236,25 @@ Session.prototype._new = function(ctx) {
 /**
  * 添加session方法
  * @param {object} ctx HTTP上下文
- * @param {boolean} _need_refresh 是否需要刷新
  */
-Session.prototype._add = function(ctx, _need_refresh) {
+Session.prototype._addMethod = function (ctx) {
   /**
    * 刷新session
    */
   ctx.session.refresh = () => {
     // 刷新标记在外部处理
+    ctx.session._modified = true;
   };
 
   /**
    * 获取session ID
    * @returns {string} session ID
    */
-  ctx.session.getID = () => {
-    return ctx.cookies.get(this.config.key, this.config.config);
+  ctx.session.getId = () => {
+    if (!ctx.session.uuid) {
+      ctx.session.uuid = this.genId(ctx);
+    }
+    return ctx.session.uuid;
   };
 };
 
@@ -146,98 +262,150 @@ Session.prototype._add = function(ctx, _need_refresh) {
  * 清理session
  * @param {object} ctx HTTP上下文
  */
-Session.prototype._cleanup = function(ctx) {
-  if (ctx.session && 'refresh' in ctx.session) {
-    delete ctx.session.refresh;
+Session.prototype._cleanup = function (ctx) {
+  if (ctx.session) {
+    delete ctx.session._is_new;
+    delete ctx.session._modified;
   }
 };
 
 /**
- * 保存session
+ * 提取session数据（私有方法）
  * @param {object} ctx HTTP上下文
- * @param {string} uuid session ID
- * @param {boolean} need_refresh 是否需要刷新
+ * @returns {object} 提取的session数据
  */
-Session.prototype._save = async function(ctx, uuid, need_refresh) {
-  if (!this._shouldSave(ctx, uuid, need_refresh)) {
-    return;
-  }
-
-  if (this._shouldDestroySession(ctx, uuid)) {
-    await this._destroySession(ctx, uuid);
-    return;
-  }
-
-  let sid = await this._saveSession(ctx, uuid);
+Session.prototype._extractSessionData = function (ctx) {
+  const session_to_save = {};
+  
+  // 使用Reflect.ownKeys确保正确枚举Proxy对象的所有属性
+  const keys = Reflect.ownKeys(ctx.session);
+  console.log('  - 保存前session对象属性列表:', keys);
   
-  if (this._shouldSetCookie(uuid, sid, need_refresh)) {
-    this._setCookie(ctx, sid);
+  for (const key of keys) {
+    // 跳过Symbol类型的属性
+    if (typeof key === 'symbol') {
+      console.log(`  - 跳过Symbol属性: ${key.toString()}`);
+      continue;
+    }
+    
+    // 跳过函数属性和内部属性
+    if (typeof ctx.session[key] !== 'function' && !key.startsWith('_')) {
+      session_to_save[key] = ctx.session[key];
+      console.log(`  - 保存属性到session_to_save: ${key} = ${ctx.session[key]}`);
+    } else {
+      console.log(`  - 跳过属性: ${key} (类型: ${typeof ctx.session[key]})`);
+    }
   }
+  
+  return session_to_save;
 };
 
 /**
- * 判断是否需要保存session
+ * 处理cookie设置（私有方法）
  * @param {object} ctx HTTP上下文
- * @param {string} _uuid session ID
- * @param {boolean} need_refresh 是否需要刷新
- * @returns {boolean} 是否需要保存
+ * @param {string} session_id session ID
  */
-Session.prototype._shouldSave = function(ctx, _uuid, need_refresh) {
-  // 如果session为null，不需要保存
-  if (ctx.session === null) {
-    return false;
+Session.prototype._handleCookie = async function (ctx, session_id) {
+  if (ctx.session.uuid !== session_id) {
+    // 如果session ID改变，需要更新cookie
+    await this._store.del(session_id);
+    this._setCookie(ctx, ctx.session.uuid);
   }
-  
-  // 如果需要刷新，总是保存
-  if (need_refresh) {
-    return true;
+  else if (ctx.session._is_new) {
+    // 新session，设置cookie
+    this._setCookie(ctx, ctx.session.uuid);
   }
-  
-  // 对于新session或修改过的session，需要保存
-  // 这里简化逻辑，总是返回true以确保session被保存
-  return true;
 };
 
 /**
- * 判断是否需要销毁session
+ * 保存session（私有方法）
  * @param {object} ctx HTTP上下文
- * @param {string} uuid session ID
- * @returns {boolean} 是否需要销毁
+ * @param {string} session_id session ID
+ * @returns {Promise<void>} 保存结果
  */
-Session.prototype._shouldDestroySession = function(ctx, uuid) {
-  return uuid && !ctx.session;
+Session.prototype._save = async function (ctx, session_id) {
+  // 如果session不存在，直接删除session
+  if (!ctx.session) {
+    await this._delSession(ctx, session_id);
+    return;
+  }
+
+  console.log('  - save方法: 检查session._modified标志:', ctx.session._modified);
+  
+  // 如果session被修改过，需要保存
+  if (ctx.session._modified) {
+    await this._handleCookie(ctx, session_id);
+    
+    // 提取session数据
+    const session_to_save = this._extractSessionData(ctx);
+    
+    console.log('  - 保存前的session_to_save对象:', session_to_save);
+    
+    // 保存内部属性（_is_new和_modified）
+    if (ctx.session._is_new !== undefined) {
+      session_to_save._is_new = ctx.session._is_new;
+    }
+    if (ctx.session._modified !== undefined) {
+      session_to_save._modified = ctx.session._modified;
+    }
+    
+    console.log('  - 保存内部属性后的session_to_save对象:', session_to_save);
+    
+    // 清理session
+    this._cleanup(ctx);
+    
+    console.log('  - 清理session后的session_to_save对象:', session_to_save);
+    
+    // 保存session到存储
+    return await this._store.set(ctx.session.uuid, session_to_save, this.config.max_age || 7200);
+  }
 };
 
 /**
- * 销毁session
+ * 保存session（公开方法）
  * @param {object} ctx HTTP上下文
- * @param {string} uuid session ID
+ * @param {string|object} session_id_or_obj session ID或session对象
+ * @returns {Promise<void>} 保存结果
  */
-Session.prototype._destroySession = async function(ctx, uuid) {
-  await this._store.destroy(uuid, ctx);
-  ctx.cookies.set(this.config.key, null);
+Session.prototype.save = async function (ctx, session_id_or_obj) {
+  let session_id;
+  
+  if (typeof session_id_or_obj === 'string') {
+    // 如果传入的是session ID字符串
+    session_id = session_id_or_obj;
+  } else if (session_id_or_obj && typeof session_id_or_obj.getId === 'function') {
+    // 如果传入的是session对象
+    session_id = session_id_or_obj.getId();
+  } else {
+    // 如果传入的是undefined或null，尝试从ctx.session获取
+    if (ctx.session && ctx.session.getId) {
+      session_id = ctx.session.getId();
+    } else {
+      throw new TypeError('无效的session参数');
+    }
+  }
+  
+  return await this._save(ctx, session_id);
 };
 
 /**
- * 保存session到存储
+ * 销毁session
  * @param {object} ctx HTTP上下文
- * @param {string} uuid session ID
- * @returns {string} 新的session ID
+ * @param {string} session_id session ID
  */
-Session.prototype._saveSession = async function(ctx, uuid) {
-  let o = { ...this.config.config, uuid: ctx.session.uuid || uuid};
-  return await this._store.set(ctx.session, o, ctx);
+Session.prototype._delSession = async function (ctx, session_id) {
+  ctx.cookies.set(this.config.cookie_token, null);
+  this._store.del(session_id).catch();
 };
 
 /**
  * 判断是否需要设置cookie
- * @param {string} uuid 原session ID
+ * @param {string} session_id 原session ID
  * @param {string} sid 新session ID
- * @param {boolean} need_refresh 是否需要刷新
  * @returns {boolean} 是否需要设置cookie
  */
-Session.prototype._shouldSetCookie = function(uuid, sid, need_refresh) {
-  return !uuid || uuid !== sid || need_refresh;
+Session.prototype._shouldSetCookie = function (session_id, sid) {
+  return !session_id || session_id !== sid;
 };
 
 /**
@@ -245,15 +413,62 @@ Session.prototype._shouldSetCookie = function(uuid, sid, need_refresh) {
  * @param {object} ctx HTTP上下文
  * @param {string} sid session ID
  */
-Session.prototype._setCookie = function(ctx, sid) {
-  let cg = { ...this.config.config};
+Session.prototype._setCookie = function (ctx, sid) {
+  let cg = { ...this.config.config };
   if (cg.max_age) {
     cg.maxAge = cg.max_age * 1000;
     delete cg.max_age;
   }
-  ctx.cookies.set(this.config.key, sid, cg);
+  ctx.cookies.set(this.config.cookie_token, sid, cg);
 };
 
-module.exports = {
-  Session
+/**
+ * 验证token时效性
+ * @param {number} end_time token过期时间戳
+ * @returns {boolean} 是否过期
+ */
+Session.prototype._verifyExpiration = async function (end_time) {
+  var current_time = Date.parse(new Date()) / 1000;
+  return current_time > end_time;
 };
+
+/**
+ * 完整的token验证流程
+ * @param {string} session_id session ID
+ * @param {string} client_ip 客户端IP
+ * @param {string} client_ua 客户端UA字符串
+ * @returns {boolean} 是否验证通过
+ */
+Session.prototype._checkSessionId = async function (session_id, client_ip, client_ua) {
+  try {
+    // 解码session_id
+    var data = this._helper.aesDecode(session_id, 
+      this.config.encrypt_key, this._helper._getSecret(client_ua));
+    if (!data) return false;
+    let { ip, end_time } = data;
+    // 验证IP
+    if (ip !== client_ip) return false;
+
+    // 验证时效性
+    var is_expired = await this._verifyExpiration(end_time);
+    if (is_expired) {
+      if (this.config.expired_handling !== 'allow') {
+        return false;
+      }
+    }
+    
+    // 所有验证通过
+    return true;
+  } catch (err) {
+    $.log.debug('Session ID验证错误:', err);
+    return false;
+  }
+};
+
+module.exports = {
+  Session,
+  session: function (options) {
+    let sess = new Session(options);
+    return sess.middleware();
+  }
+};

package/lib/store.js

@@ -1,7 +1,7 @@
-const { CacheBase } = require('mm_cachebase');
+const { Cache } = require('mm_cache');
 
 if (!$.cache) {
-  $.cache = new CacheBase();
+  $.cache = new Cache();
 }
 
 /**
@@ -21,34 +21,17 @@ class Store {
   }
 }
 
-/**
- * 获取session ID
- * @param {object} ctx HTTP上下文
- * @returns {string} session ID
- */
-Store.prototype.getID = async function(ctx) {
-  var header = ctx.request.header;
-  var user_agent = header['user-agent'];
-  if (!user_agent) {
-    user_agent = 'mm';
-  }
-  var start_hash = user_agent.md5().substring(0, 32);
-  var time_stamp = Date.parse(new Date()) / 1000;
-  var uuid = (ctx.ip + '_' + time_stamp).aes_encode(start_hash);
-  return uuid;
-};
-
 /**
  * 获取session缓存
  * @param {string} uuid 客户端唯一ID
  * @returns {object|null} session对象或null
  */
-Store.prototype.get = async function(uuid) {
+Store.prototype.get = async function (uuid) {
   if (!$.cache.has(this.key + uuid)) return undefined;
   // 我们正在解码数据来自我们的srote, 我们假定它是在储存之前
   var val = await $.cache.get(this.key + uuid);
   if (val) {
-    if (typeof(val) == 'string') {
+    if (typeof (val) == 'string') {
       return JSON.parse(val);
     }
     return val;
@@ -59,44 +42,32 @@ Store.prototype.get = async function(uuid) {
 
 /**
  * 设置session到缓存
+ * @param {string} uuid session ID
  * @param {object} session session对象
- * @param {object} options 配置选项
- * @param {string} options.uuid 客户端唯一表示ID
- * @param {number} options.max_age 最大寿命
- * @param {object} ctx HTTP请求上下文
+ * @param {number} max_age 最大寿命（秒）
  * @returns {string} session ID
  */
-Store.prototype.set = async function(session, {
-  uuid,
-  max_age
-} = {}, ctx) {
-  let session_uuid = uuid;
-  let session_max_age = max_age;
-  
-  if (!session_uuid) {
-    session_uuid = await this.getID(ctx);
-  }
-  if (!session_max_age) {
-    session_max_age = 7200;
-  }
-  
+Store.prototype.set = async function (uuid, session, max_age = 7200) {
   let session_str = session;
   try {
-    if (typeof(session_str) == 'object') {
+    console.log('  - Store.set接收到的session对象:', session);
+    if (typeof (session_str) == 'object') {
       session_str = JSON.stringify(session_str);
+      console.log('  - JSON序列化后的session:', session_str);
     }
-    await $.cache.set(this.key + session_uuid, session_str, session_max_age);
+    
+    await $.cache.set(this.key + uuid, session_str, max_age);
   } catch (err) {
     $.log.debug('Set session error:', err);
   }
-  return session_uuid;
+  return uuid;
 };
 
 /**
- * 销毁缓存
+ * 删除缓存
  * @param {string} uuid 客户端唯一ID
  */
-Store.prototype.destroy = function(uuid) {
+Store.prototype.del = function (uuid) {
   $.cache.del(this.key + uuid);
 };