skill-base 2.0.14 → 2.0.16

package/src/models/user.js

@@ -1,9 +1,18 @@
 const db = require('../database');
+const modelCache = require('../utils/model-cache');
+
+function queryById(id) {
+  return db.prepare('SELECT id, username, name, role, status, created_at, updated_at FROM users WHERE id = ?').get(id);
+}
 
 const UserModel = {
   // 根据 ID 查询用户
   findById(id) {
-    return db.prepare('SELECT id, username, name, role, status, created_at, updated_at FROM users WHERE id = ?').get(id);
+    return modelCache.remember(
+      modelCache.keys.userBasic(id),
+      () => queryById(id),
+      modelCache.refs.user
+    );
   },
 
   // 根据用户名查询（含 password_hash，用于登录验证）
@@ -14,7 +23,8 @@ const UserModel = {
   // 创建用户
   create(username, passwordHash, role = 'developer') {
     const result = db.prepare('INSERT INTO users (username, password_hash, role) VALUES (?, ?, ?)').run(username, passwordHash, role);
-    return this.findById(result.lastInsertRowid);
+    modelCache.invalidateUser(result.lastInsertRowid);
+    return queryById(result.lastInsertRowid);
   },
 
   // 列出用户（支持分页和搜索）
@@ -51,6 +61,9 @@ const UserModel = {
     const result = db.prepare(
       "UPDATE users SET username = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(username, id);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -59,6 +72,9 @@ const UserModel = {
     const result = db.prepare(
       "UPDATE users SET password_hash = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(passwordHash, id);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -81,6 +97,9 @@ const UserModel = {
     params.push(id);
     
     const result = db.prepare(`UPDATE users SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -89,6 +108,9 @@ const UserModel = {
     const result = db.prepare(
       "UPDATE users SET password_hash = ?, updated_at = datetime('now') WHERE id = ?"
     ).run(passwordHash, id);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   },
 
@@ -123,6 +145,9 @@ const UserModel = {
     params.push(id);
     
     const result = db.prepare(`UPDATE users SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+    if (result.changes > 0) {
+      modelCache.invalidateUser(id);
+    }
     return result.changes > 0;
   }
 };

package/src/models/version.js

@@ -1,4 +1,5 @@
 const db = require('../database');
+const modelCache = require('../utils/model-cache');
 
 const VersionModel = {
   // 创建新版本
@@ -7,6 +8,7 @@ const VersionModel = {
       INSERT INTO skill_versions (skill_id, version, changelog, zip_path, uploader_id, description)
       VALUES (?, ?, ?, ?, ?, ?)
     `).run(skillId, version, changelog || '', zipPath, uploaderId, description || '');
+    modelCache.invalidateSkill(skillId);
     return this.findById(result.lastInsertRowid);
   },
 
@@ -22,44 +24,60 @@ const VersionModel = {
 
   // 根据 skill_id 和 version 查询
   findByVersion(skillId, version) {
-    return db.prepare(`
-      SELECT sv.*, u.username as uploader_username, u.name as uploader_name
-      FROM skill_versions sv
-      LEFT JOIN users u ON sv.uploader_id = u.id
-      WHERE sv.skill_id = ? AND sv.version = ?
-    `).get(skillId, version);
+    return modelCache.remember(
+      modelCache.keys.skillVersion(skillId, version),
+      () => db.prepare(`
+        SELECT sv.*, u.username as uploader_username, u.name as uploader_name
+        FROM skill_versions sv
+        LEFT JOIN users u ON sv.uploader_id = u.id
+        WHERE sv.skill_id = ? AND sv.version = ?
+      `).get(skillId, version),
+      modelCache.refs.version
+    );
   },
 
   // 列出某 Skill 的所有版本（按创建时间倒序）
   listBySkillId(skillId) {
-    return db.prepare(`
-      SELECT sv.*, u.username as uploader_username, u.name as uploader_name
-      FROM skill_versions sv
-      LEFT JOIN users u ON sv.uploader_id = u.id
-      WHERE sv.skill_id = ?
-      ORDER BY sv.created_at DESC
-    `).all(skillId);
+    return modelCache.remember(
+      modelCache.keys.skillVersions(skillId),
+      () => db.prepare(`
+        SELECT sv.*, u.username as uploader_username, u.name as uploader_name
+        FROM skill_versions sv
+        LEFT JOIN users u ON sv.uploader_id = u.id
+        WHERE sv.skill_id = ?
+        ORDER BY sv.created_at DESC, sv.id DESC
+      `).all(skillId),
+      (versions) => modelCache.refs.versionList(skillId, versions)
+    );
   },
 
   // 获取某 Skill 的最新版本
   getLatest(skillId) {
-    return db.prepare(`
-      SELECT sv.*, u.username as uploader_username, u.name as uploader_name
-      FROM skill_versions sv
-      LEFT JOIN users u ON sv.uploader_id = u.id
-      WHERE sv.skill_id = ?
-      ORDER BY sv.created_at DESC
-      LIMIT 1
-    `).get(skillId);
+    return modelCache.remember(
+      modelCache.keys.skillLatest(skillId),
+      () => db.prepare(`
+        SELECT sv.*, u.username as uploader_username, u.name as uploader_name
+        FROM skill_versions sv
+        LEFT JOIN users u ON sv.uploader_id = u.id
+        WHERE sv.skill_id = ?
+        ORDER BY sv.created_at DESC, sv.id DESC
+        LIMIT 1
+      `).get(skillId),
+      modelCache.refs.version
+    );
   },
 
   // 更新版本描述和更新日志
   update(id, description, changelog) {
+    const existing = this.findById(id);
     db.prepare(`
       UPDATE skill_versions
       SET description = ?, changelog = ?
       WHERE id = ?
     `).run(description, changelog, id);
+    if (existing) {
+      modelCache.invalidateSkill(existing.skill_id);
+    }
     return this.findById(id);
   }
 };

package/src/routes/collaborators.js

@@ -1,6 +1,7 @@
 const db = require('../database');
 const { canManageSkill } = require('../utils/permission');
 const UserModel = require('../models/user');
+const { invalidateSkill } = require('../utils/model-cache');
 
 async function collaboratorsRoutes(fastify, options) {
 
@@ -84,6 +85,7 @@ async function collaboratorsRoutes(fastify, options) {
     const result = db.prepare(
       'INSERT INTO skill_collaborators (skill_id, user_id, role, created_by) VALUES (?, ?, ?, ?)'
     ).run(skill_id, targetUser.id, 'collaborator', request.user.id);
+    invalidateSkill(skill_id);
     
     return reply.code(201).send({
       ok: true,
@@ -129,6 +131,7 @@ async function collaboratorsRoutes(fastify, options) {
     
     db.prepare('DELETE FROM skill_collaborators WHERE skill_id = ? AND user_id = ?')
       .run(skill_id, parseInt(user_id));
+    invalidateSkill(skill_id);
     
     return reply.send({ ok: true, message: 'Collaborator removed' });
   });
@@ -192,6 +195,7 @@ async function collaboratorsRoutes(fastify, options) {
     });
     
     transferTx();
+    invalidateSkill(skill_id);
     
     return reply.send({
       ok: true,
@@ -239,6 +243,7 @@ async function collaboratorsRoutes(fastify, options) {
     });
     
     deleteSkillTx();
+    invalidateSkill(skill_id);
     
     // 删除文件系统中的文件
     const fs = require('fs');

package/src/routes/publish.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const db = require('../database');
 const SkillModel = require('../models/skill');
 const VersionModel = require('../models/version');
+const { invalidateSkill } = require('../utils/model-cache');
 const { ensureSkillDir, generateVersionNumber, getZipPath, getZipRelativePath } = require('../utils/zip');
 const { canPublishSkill } = require('../utils/permission');
 
@@ -96,6 +97,7 @@ async function publishRoutes(fastify, options) {
 
     // 更新 skill 的最新版本
     SkillModel.updateLatestVersion(skill_id, version);
+    invalidateSkill(skill_id);
 
     return {
       ok: true,

package/src/utils/lru-cache.js

@@ -0,0 +1,160 @@
+class LruCache {
+  constructor({ maxBytes = 50 * 1024 * 1024, defaultTtlMs = 0 } = {}) {
+    this.maxBytes = Number.isFinite(maxBytes) ? Math.max(0, Math.floor(maxBytes)) : 0;
+    this.defaultTtlMs = Number.isFinite(defaultTtlMs) ? Math.max(0, defaultTtlMs) : 0;
+    this.map = new Map();
+    this.totalBytes = 0;
+    this.hits = 0;
+    this.misses = 0;
+    this.evictions = 0;
+  }
+
+  static estimateSize(value) {
+    try {
+      const serialized = JSON.stringify(value);
+      return Buffer.byteLength(serialized === undefined ? 'null' : serialized, 'utf8');
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  has(key) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      return false;
+    }
+
+    if (this.#isExpired(entry)) {
+      this.#deleteEntry(key, entry);
+      return false;
+    }
+
+    return true;
+  }
+
+  get(key) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      this.misses += 1;
+      return undefined;
+    }
+
+    if (this.#isExpired(entry)) {
+      this.#deleteEntry(key, entry);
+      this.misses += 1;
+      return undefined;
+    }
+
+    this.map.delete(key);
+    this.map.set(key, entry);
+    this.hits += 1;
+    return entry.value;
+  }
+
+  set(key, value, options = {}) {
+    if (this.maxBytes <= 0) {
+      return false;
+    }
+
+    const size = Number.isFinite(options.size) ? Math.max(0, Math.floor(options.size)) : LruCache.estimateSize(value);
+    if (size > this.maxBytes) {
+      this.delete(key);
+      return false;
+    }
+
+    const ttlMs = Number.isFinite(options.ttlMs) ? Math.max(0, options.ttlMs) : this.defaultTtlMs;
+    const expiresAt = ttlMs > 0 ? Date.now() + ttlMs : null;
+    const entry = {
+      value,
+      size,
+      refs: new Set(options.refs || []),
+      expiresAt
+    };
+
+    const existing = this.map.get(key);
+    if (existing) {
+      this.#deleteEntry(key, existing);
+    }
+
+    this.map.set(key, entry);
+    this.totalBytes += size;
+    this.#evictIfNeeded();
+    return true;
+  }
+
+  delete(key) {
+    const entry = this.map.get(key);
+    if (!entry) {
+      return false;
+    }
+
+    this.#deleteEntry(key, entry);
+    return true;
+  }
+
+  clear() {
+    this.map.clear();
+    this.totalBytes = 0;
+  }
+
+  clearByPrefix(prefix) {
+    const keys = [];
+    for (const key of this.map.keys()) {
+      if (key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+
+    for (const key of keys) {
+      this.delete(key);
+    }
+
+    return keys.length;
+  }
+
+  clearByRef(ref) {
+    const keys = [];
+    for (const [key, entry] of this.map.entries()) {
+      if (entry.refs.has(ref)) {
+        keys.push(key);
+      }
+    }
+
+    for (const key of keys) {
+      this.delete(key);
+    }
+
+    return keys.length;
+  }
+
+  stats() {
+    return {
+      entries: this.map.size,
+      totalBytes: this.totalBytes,
+      maxBytes: this.maxBytes,
+      hits: this.hits,
+      misses: this.misses,
+      evictions: this.evictions
+    };
+  }
+
+  #isExpired(entry) {
+    return entry.expiresAt !== null && Date.now() > entry.expiresAt;
+  }
+
+  #deleteEntry(key, entry) {
+    this.map.delete(key);
+    this.totalBytes = Math.max(0, this.totalBytes - entry.size);
+  }
+
+  #evictIfNeeded() {
+    while (this.totalBytes > this.maxBytes && this.map.size > 0) {
+      const oldestKey = this.map.keys().next().value;
+      const oldestEntry = this.map.get(oldestKey);
+      this.#deleteEntry(oldestKey, oldestEntry);
+      this.evictions += 1;
+    }
+  }
+}
+
+module.exports = LruCache;

package/src/utils/model-cache.js

@@ -0,0 +1,158 @@
+const LruCache = require('./lru-cache');
+
+const DEFAULT_CACHE_MAX_MB = 50;
+
+function parseCacheMaxBytes() {
+  const raw = process.env.CACHE_MAX_MB;
+  if (raw === undefined || raw === null || raw === '') {
+    return DEFAULT_CACHE_MAX_MB * 1024 * 1024;
+  }
+
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_CACHE_MAX_MB * 1024 * 1024;
+  }
+
+  return Math.floor(parsed * 1024 * 1024);
+}
+
+const cache = new LruCache({ maxBytes: parseCacheMaxBytes() });
+
+function uniqueRefs(refs) {
+  return Array.from(new Set((refs || []).filter(Boolean)));
+}
+
+function remember(key, loader, refsBuilder, options = {}) {
+  const cachedValue = cache.get(key);
+  if (cachedValue !== undefined) {
+    return cachedValue;
+  }
+
+  const value = loader();
+  if (value === undefined) {
+    return value;
+  }
+
+  const refs = typeof refsBuilder === 'function' ? refsBuilder(value) : refsBuilder;
+  cache.set(key, value, {
+    refs: uniqueRefs(refs),
+    ttlMs: options.ttlMs
+  });
+  return value;
+}
+
+function skillKey(skillId) {
+  return `skill:${skillId}`;
+}
+
+function skillSearchKey(query) {
+  return `skill-search:${query || ''}`;
+}
+
+function skillExistsKey(skillId) {
+  return `skill-exists:${skillId}`;
+}
+
+function skillVersionsKey(skillId) {
+  return `skill-versions:${skillId}`;
+}
+
+function skillVersionKey(skillId, version) {
+  return `skill-version:${skillId}:${version}`;
+}
+
+function skillLatestKey(skillId) {
+  return `skill-latest:${skillId}`;
+}
+
+function userBasicKey(userId) {
+  return `user-basic:${userId}`;
+}
+
+function skillRefs(skill) {
+  if (!skill) {
+    return [];
+  }
+  return [`skill:${skill.id}`, `user:${skill.owner_id}`];
+}
+
+function skillSearchRefs(skills) {
+  const refs = ['collection:skill-search'];
+  for (const skill of skills || []) {
+    refs.push(...skillRefs(skill));
+  }
+  return refs;
+}
+
+function versionRefs(version) {
+  if (!version) {
+    return [];
+  }
+  return [
+    `skill:${version.skill_id}`,
+    `version:${version.skill_id}:${version.version}`,
+    `user:${version.uploader_id}`
+  ];
+}
+
+function versionListRefs(skillId, versions) {
+  const refs = [`skill:${skillId}`];
+  for (const version of versions || []) {
+    refs.push(...versionRefs(version));
+  }
+  return refs;
+}
+
+function userRefs(user) {
+  if (!user) {
+    return [];
+  }
+  return [`user:${user.id}`];
+}
+
+function invalidateSkill(skillId) {
+  cache.delete(skillKey(skillId));
+  cache.delete(skillExistsKey(skillId));
+  cache.delete(skillVersionsKey(skillId));
+  cache.delete(skillLatestKey(skillId));
+  cache.clearByPrefix(`skill-version:${skillId}:`);
+  cache.clearByRef(`skill:${skillId}`);
+  cache.clearByRef('collection:skill-search');
+}
+
+function invalidateUser(userId) {
+  cache.delete(userBasicKey(userId));
+  cache.clearByRef(`user:${userId}`);
+}
+
+function invalidateAllSkillSearches() {
+  cache.clearByRef('collection:skill-search');
+}
+
+function getStats() {
+  return cache.stats();
+}
+
+module.exports = {
+  remember,
+  getStats,
+  invalidateSkill,
+  invalidateUser,
+  invalidateAllSkillSearches,
+  keys: {
+    skill: skillKey,
+    skillSearch: skillSearchKey,
+    skillExists: skillExistsKey,
+    skillVersions: skillVersionsKey,
+    skillVersion: skillVersionKey,
+    skillLatest: skillLatestKey,
+    userBasic: userBasicKey
+  },
+  refs: {
+    skill: skillRefs,
+    skillSearch: skillSearchRefs,
+    version: versionRefs,
+    versionList: versionListRefs,
+    user: userRefs
+  }
+};