mm_session 1.5.1 → 1.5.3

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);
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_session",
-    "version": "1.5.1",
+    "version": "1.5.3",
     "description": "这是超级美眉session函数模块，用于web服务端session缓存",
     "main": "index.js",
     "scripts": {
@@ -29,12 +29,11 @@
         "url": "https://gitee.com/qiuwenwu91/mm_session/issues"
     },
     "homepage": "https://gitee.com/qiuwenwu91/mm_session#readme",
-    "dependencies": {
-        "mm_cachebase": "^1.9.2"
-    },
     "devDependencies": {
         "eslint-plugin-jsdoc": "^61.5.0",
-        "eslint-plugin-naming-convention": "^0.1.3",
-        "mm_eslint": "^1.0.3"
+        "mm_eslint": "^1.0.8"
+    },
+    "dependencies": {
+        "mm_cache": "^1.4.7"
     }
 }

package/test.js

@@ -1,190 +1,328 @@
-const { Session, Store } = require('./index.js');
+'use strict';
 
-String.prototype.aes_encode = function(key) {
-  // 简单的AES编码模拟
-  return Buffer.from(this).toString('base64') + '_' + key.substring(0, 8);
-};
+const { session, Session, Store } = require('./index.js');
 
-// 模拟Koa应用
-class MockKoaApp {
-  constructor() {
-    this.middlewares = [];
-  }
-
-  use(middleware) {
-    this.middlewares.push(middleware);
-  }
-
-  async handleRequest(ctx) {
-    // 执行中间件链
-    const executeMiddleware = async (index) => {
-      if (index < this.middlewares.length) {
-        const middleware = this.middlewares[index];
-        await middleware(ctx, () => executeMiddleware(index + 1));
-      }
-    };
-    
-    await executeMiddleware(0);
-  }
-}
-
-// 模拟Koa的上下文对象
+/**
+ * 模拟Koa上下文对象
+ * @class MockContext
+ * @param {object} headers HTTP请求头
+ * @param {object} cookies cookie数据
+ */
 class MockContext {
-  constructor() {
-    this.cookies = new MockCookies();
-    this.headers = {};
+  /**
+   * 构造函数
+   * @param {object} headers HTTP请求头
+   * @param {object} cookies cookie数据
+   */
+  constructor(headers = {}, cookies = {}) {
+    this.headers = headers;
+    this._cookies = cookies;
     this.ip = '127.0.0.1';
-    this.request = {
-      header: {
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+    this.body = null;
+    this.status = null;
+
+    // 模拟cookies对象
+    this.cookies = {
+      get: (name) => {
+        return this._cookies[name] || null;
+      },
+      set: (name, value, options = {}) => {
+        this._cookies[name] = value;
       }
     };
-    this.session = null;
   }
 }
 
-// 模拟Koa的cookies对象
-class MockCookies {
-  constructor() {
-    this._cookies = new Map();
-  }
+/**
+ * 模拟Koa next函数
+ * @returns {Promise<void>} 空Promise
+ */
+const mock_next = () => Promise.resolve();
 
-  get(key, options) {
-    return this._cookies.get(key);
-  }
+/**
+ * 测试基本session中间件功能
+ * @returns {Promise<void>} 测试结果
+ */
+async function testBasicSession() {
+  console.log('1. 测试基本session中间件功能');
+  try {
+    const session_mw = session();
+    const ctx = new MockContext();
+
+    await session_mw(ctx, mock_next);
 
-  set(key, value, options) {
-    if (value === null) {
-      this._cookies.delete(key);
+    if (ctx.session) {
+      console.log('✓ session对象创建成功');
+      console.log('✓ session ID:', ctx.session.getId());
     } else {
-      this._cookies.set(key, value);
+      console.log('✗ session对象创建失败');
     }
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
   }
 }
 
-// 测试session模块
-async function testSession() {
-  console.log('开始测试session模块...\n');
-
+/**
+ * 测试session数据读写功能
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionDataRW() {
+  console.log('\n2. 测试session数据读写功能');
   try {
-    // 测试1: 创建Session实例
-    console.log('测试1: 创建Session实例');
-    const session = new Session({
-      key: 'test_session',
-      max_age: 3600
+    const session_mw = session();
+    const ctx = new MockContext();
+
+    await session_mw(ctx, async () => {
+      // 在中间件中设置session数据
+      ctx.session.user_id = 123;
+      ctx.session.username = 'testuser';
+      ctx.session.is_logged_in = true;
     });
-    console.log('✅ Session实例创建成功\n');
 
-    // 测试2: 创建Koa应用并注册中间件
-    console.log('测试2: 创建Koa应用并注册中间件');
-    const app = new MockKoaApp();
-    
-    // 使用Koa标准方式注册session中间件
-    app.use(session.middleware());
-    
-    // 添加一个业务中间件来测试session功能
-    app.use(async (ctx, next) => {
-      // 测试session数据操作
-      if (!ctx.session.user_id) {
-        ctx.session.user_id = 123;
-        ctx.session.username = 'test_user';
-      }
-      
-      await next();
+    console.log('✓ session数据设置成功');
+    console.log('  - user_id:', ctx.session.user_id);
+    console.log('  - username:', ctx.session.username);
+    console.log('  - is_logged_in:', ctx.session.is_logged_in);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 创建测试session
+ * @param {Function} session_mw session中间件
+ * @returns {Promise<object>} 包含session ID和上下文的对象
+ */
+async function createTestSession(session_mw) {
+  const ctx1 = new MockContext();
+
+  // 使用标准的中间件调用方式，确保保存逻辑被执行
+  await session_mw(ctx1, async () => {
+    // 在next()函数中设置session数据
+    ctx1.session.test_data = 'persistent_data';
+    // 强制标记session为已修改状态
+    ctx1.session._modified = true;
+
+    // 调试：检查session对象在设置数据后的状态
+    console.log('  - 第一次请求session对象状态:', {
+      uuid: ctx1.session.uuid,
+      test_data: ctx1.session.test_data,
+      _modified: ctx1.session._modified,
+      _is_new: ctx1.session._is_new
     });
     
-    console.log('✅ Koa应用创建成功，中间件注册完成\n');
+    // 调试：检查session是否被标记为已修改
+    console.log('  - session._modified标志:', ctx1.session._modified);
+  });
 
-    // 测试3: 测试新session创建
-    console.log('测试3: 测试新session创建');
-    const ctx1 = new MockContext();
-    
-    await app.handleRequest(ctx1);
-    
-    // 等待session保存完成（模拟异步保存过程）
-    await new Promise(resolve => setTimeout(resolve, 50));
-    
-    if (ctx1.session) {
-      console.log('✅ 新session创建成功');
-      console.log('   session对象:', typeof ctx1.session);
-      console.log('   user_id:', ctx1.session.user_id);
-      console.log('   username:', ctx1.session.username);
-    } else {
-      throw new Error('session创建失败');
+  // 调试：检查第一次请求后session是否被正确保存
+  console.log('  - 第一次请求后检查session._modified标志:', ctx1.session._modified);
+
+  const session_id = ctx1.session.getId();
+  console.log('✓ 第一次请求session ID:', session_id);
+
+  return { ctx1, session_id };
+}
+
+/**
+ * 验证session恢复结果
+ * @param {object} ctx2 第二次请求的上下文
+ * @param {string} session_id session ID
+ * @returns {Promise<boolean>} 恢复是否成功
+ */
+async function verifySessionRecover(ctx2, session_id) {
+  if (ctx2.session && ctx2.session.test_data === 'persistent_data') {
+    console.log('✓ session数据恢复成功');
+    return true;
+  } else {
+    console.log('✗ session数据恢复失败');
+    console.log('  - ctx2.session:', ctx2.session);
+    if (ctx2.session) {
+      console.log('  - test_data:', ctx2.session.test_data);
+      console.log('  - session ID是否匹配:', ctx2.session.uuid === session_id);
+
+      // 调试：直接检查存储中是否有数据
+      const store = new Store();
+      const stored_data = await store.get(session_id);
+      console.log('  - 存储中的数据:', stored_data);
+
+      // 调试：检查第一次请求后存储中的数据
+      const stored_data_first = await store.get(session_id);
+      console.log('  - 第一次请求后存储中的数据:', stored_data_first);
     }
+    return false;
+  }
+}
 
-    // 测试4: 测试session保存和读取
-    console.log('\n测试4: 测试session保存和读取');
+/**
+ * 测试从cookie中恢复session
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionRecovery() {
+  console.log('\n3. 测试从cookie中恢复session');
+  try {
+    const session_mw = session();
     
-    // 检查cookie是否设置
-    const sessionCookie = ctx1.cookies.get('test_session');
-    if (sessionCookie) {
-      console.log('✅ session保存成功，cookie已设置');
-      console.log('   session ID:', sessionCookie);
-    } else {
-      console.log('⚠️  session保存但cookie未设置');
-    }
+    // 创建测试session
+    const { session_id } = await createTestSession(session_mw);
 
-    // 测试5: 测试session读取（模拟有cookie的情况）
-    console.log('\n测试5: 测试session读取');
+    // 第二次请求使用相同的session ID（通过cookie传递）
     const ctx2 = new MockContext();
-    
-    // 设置cookie模拟已有session
-    if (sessionCookie) {
-      ctx2.cookies.set('test_session', sessionCookie);
-    }
-    
-    await app.handleRequest(ctx2);
-    
-    if (ctx2.session) {
-      console.log('✅ session读取成功');
-      console.log('   session对象存在');
-      console.log('   user_id:', ctx2.session.user_id);
-      console.log('   username:', ctx2.session.username);
+    ctx2.cookies['mm:uuid'] = session_id;
+
+    await session_mw(ctx2, mock_next);
+
+    // 验证恢复结果
+    await verifySessionRecover(ctx2, session_id);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试session刷新功能
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionRefresh() {
+  console.log('\n4. 测试session刷新功能');
+  try {
+    const session_mw = session();
+    const ctx = new MockContext();
+
+    await session_mw(ctx, async () => {
+      ctx.session.original_data = 'original';
+      ctx.session.refresh(); // 刷新session
+    });
+
+    console.log('✓ session刷新功能正常');
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试自定义配置
+ * @returns {Promise<void>} 测试结果
+ */
+async function testCustomConfig() {
+  console.log('\n5. 测试自定义配置');
+  try {
+    const custom_cfg = {
+      key_prefix: 'custom:session',
+      cookie_token: 'custom_token',
+      max_age: 3600 // 1小时
+    };
+
+    const session_mw = session(custom_cfg);
+    const ctx = new MockContext();
+
+    await session_mw(ctx, mock_next);
+
+    console.log('✓ 自定义配置生效');
+    console.log('  - session ID长度:', ctx.session.getId().length);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试Session类直接使用
+ * @returns {Promise<void>} 测试结果
+ */
+async function testSessionClass() {
+  console.log('\n6. 测试Session类直接使用');
+  try {
+    const sess = new Session();
+    const ctx = new MockContext();
+
+    const session_obj = await sess.get(ctx);
+    console.log('✓ Session类get方法正常');
+    console.log('  - 获取的session对象:', session_obj);
+
+    // 测试保存session
+    await sess.save(ctx, session_obj);
+    console.log('✓ Session类save方法正常');
+
+    // 测试生成session ID
+    const new_sess_id = sess.genId(ctx);
+    console.log('✓ Session类genId方法正常');
+    console.log('  - 生成的session ID:', new_sess_id);
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
+
+/**
+ * 测试Store类
+ * @returns {Promise<void>} 测试结果
+ */
+async function testStoreClass() {
+  console.log('\n7. 测试Store类');
+  try {
+    const store = new Store('test_prefix');
+    const test_data = { key: 'value', number: 42 };
+
+    // 测试设置数据
+    await store.set('test_key', test_data, 60);
+    console.log('✓ Store类set方法正常');
+
+    // 测试获取数据
+    const ret_data = await store.get('test_key');
+    if (ret_data && ret_data.key === 'value') {
+      console.log('✓ Store类get方法正常');
+      console.log('  - 获取的数据:', ret_data);
     } else {
-      console.log('⚠️  session读取失败（可能是新session）');
+      console.log('✗ Store类get方法异常');
     }
 
-    // 测试6: 测试Store类
-    console.log('\n测试6: 测试Store类');
-    const store = new Store('test');
-    
-    // 模拟获取session ID
-    const sessionId = await store.getID(ctx1);
-    console.log('✅ Store类测试成功');
-    console.log('   生成的session ID:', sessionId);
-
-    // 测试7: 测试session销毁
-    console.log('\n测试7: 测试session销毁');
-    const ctx3 = new MockContext();
-    
-    // 添加一个中间件来测试session销毁
-    const destroyApp = new MockKoaApp();
-    destroyApp.use(session.middleware());
-    destroyApp.use(async (ctx, next) => {
-      // 设置session为null触发销毁
-      ctx.session = null;
-      await next();
-    });
-    
-    await destroyApp.handleRequest(ctx3);
-    console.log('✅ session销毁逻辑测试完成');
+    // 测试删除数据
+    store.del('test_key');
+    console.log('✓ Store类del方法正常');
+  } catch (err) {
+    console.log('✗ 测试失败:', err.message);
+  }
+}
 
-    console.log('\n🎉 所有测试通过！session模块功能正常。');
+/**
+ * 测试session中间件
+ */
+async function testSession() {
+  console.log('=== 开始测试session中间件 ===\n');
 
-  } catch (error) {
-    console.error('❌ 测试失败:', error.message);
-    console.error(error.stack);
+  await testBasicSession();
+  await testSessionDataRW();
+  await testSessionRecovery();
+  await testSessionRefresh();
+  await testCustomConfig();
+  await testSessionClass();
+  await testStoreClass();
+
+  console.log('\n=== session中间件测试完成 ===');
+}
+
+/**
+ * 运行测试
+ */
+async function runTests() {
+  try {
+    await testSession();
+  } catch (err) {
+    console.error('测试执行出错:', err);
   }
 }
 
-// 运行测试
+// 如果直接运行此文件，则执行测试
 if (require.main === module) {
-  testSession().catch(console.error);
+  runTests();
 }
 
+setTimeout(() => {
+  process.exit(0);
+}, 5000);
+
 module.exports = {
   MockContext,
-  MockCookies,
-  testSession
+  mock_next,
+  testSession,
+  runTests
 };