@yanit/jsondb 0.1.1

package/src/Operators.ts

@@ -0,0 +1,375 @@
+/**
+ * 查询和操作符实现
+ */
+
+import { getNestedValue, isType, setNestedValue, deleteNestedValue } from './Utils.js';
+
+/**
+ * 比较操作符
+ */
+export const comparisonOperators = {
+  $eq: (value: unknown, queryValue: unknown): boolean => value === queryValue,
+
+  $ne: (value: unknown, queryValue: unknown): boolean => value !== queryValue,
+
+  $gt: (value: unknown, queryValue: unknown): boolean => value > queryValue,
+
+  $gte: (value: unknown, queryValue: unknown): boolean => value >= queryValue,
+
+  $lt: (value: unknown, queryValue: unknown): boolean => value < queryValue,
+
+  $lte: (value: unknown, queryValue: unknown): boolean => value <= queryValue,
+
+  $in: (value: unknown, queryValue: unknown): boolean => {
+    if (!Array.isArray(queryValue)) {
+      throw new Error('$in 操作符需要数组');
+    }
+    return queryValue.includes(value);
+  },
+
+  $nin: (value: unknown, queryValue: unknown): boolean => {
+    if (!Array.isArray(queryValue)) {
+      throw new Error('$nin 操作符需要数组');
+    }
+    return !queryValue.includes(value);
+  }
+};
+
+/**
+ * 逻辑操作符
+ */
+export const logicalOperators = {
+  $and: (doc: Record<string, unknown>, conditions: Record<string, unknown>[]): boolean => {
+    if (!Array.isArray(conditions)) {
+      throw new Error('$and 操作符需要数组');
+    }
+    return conditions.every(condition => matchQuery(doc, condition));
+  },
+
+  $or: (doc: Record<string, unknown>, conditions: Record<string, unknown>[]): boolean => {
+    if (!Array.isArray(conditions)) {
+      throw new Error('$or 操作符需要数组');
+    }
+    return conditions.some(condition => matchQuery(doc, condition));
+  },
+
+  $nor: (doc: Record<string, unknown>, conditions: Record<string, unknown>[]): boolean => {
+    if (!Array.isArray(conditions)) {
+      throw new Error('$nor 操作符需要数组');
+    }
+    return !conditions.some(condition => matchQuery(doc, condition));
+  },
+
+  $not: (doc: Record<string, unknown>, condition: Record<string, unknown>, field?: string): boolean => {
+    return !matchField(doc, field!, condition);
+  }
+};
+
+/**
+ * 元素操作符
+ */
+export const elementOperators = {
+  $exists: (value: unknown, queryValue: boolean): boolean => {
+    return queryValue ? value !== undefined : value === undefined;
+  },
+
+  $type: (value: unknown, queryValue: string): boolean => {
+    return isType(value, queryValue);
+  }
+};
+
+/**
+ * 数组操作符
+ */
+export const arrayOperators = {
+  $all: (value: unknown, queryValue: unknown[]): boolean => {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    if (!Array.isArray(queryValue)) {
+      throw new Error('$all 操作符需要数组');
+    }
+    return queryValue.every(item => value.includes(item));
+  },
+
+  $elemMatch: (value: unknown, queryValue: Record<string, unknown> | unknown): boolean => {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    // 处理数组元素匹配
+    return value.some(item => {
+      // 如果 queryValue 是对象，需要匹配所有条件
+      if (typeof queryValue === 'object' && queryValue !== null) {
+        for (const [key, condition] of Object.entries(queryValue)) {
+          const itemValue = (item as Record<string, unknown>)[key] !== undefined 
+            ? (item as Record<string, unknown>)[key] 
+            : (typeof key === 'string' && (item as Record<string, unknown>)[key] !== undefined 
+                ? (item as Record<string, unknown>)[key] 
+                : undefined);
+          if (typeof condition === 'object' && condition !== null) {
+            // 处理操作符条件
+            for (const [op, opValue] of Object.entries(condition)) {
+              if (op === '$gte' && !(itemValue >= opValue)) return false;
+              if (op === '$lte' && !(itemValue <= opValue)) return false;
+              if (op === '$gt' && !(itemValue > opValue)) return false;
+              if (op === '$lt' && !(itemValue < opValue)) return false;
+              if (op === '$eq' && !(itemValue === opValue)) return false;
+              if (op === '$ne' && !(itemValue !== opValue)) return false;
+            }
+          } else if (itemValue !== condition) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return item === queryValue;
+    });
+  },
+
+  $size: (value: unknown, queryValue: number): boolean => {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    return value.length === queryValue;
+  }
+};
+
+/**
+ * 正则表达式操作符
+ */
+export function matchRegex(value: unknown, options: { $regex: string | RegExp; $options?: string }): boolean {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  const { $regex, $options = '' } = options;
+
+  try {
+    const regex = typeof $regex === 'string' ? new RegExp($regex, $options) : $regex;
+    return regex.test(value);
+  } catch (e) {
+    throw new Error(`无效的正则表达式：${$regex}`);
+  }
+}
+
+/**
+ * 匹配字段值
+ */
+function matchField(doc: Record<string, unknown>, field: string, condition: unknown): boolean {
+  const value = getNestedValue(doc, field);
+
+  // 如果条件是普通值，直接比较
+  if (!condition || typeof condition !== 'object') {
+    return value === condition;
+  }
+
+  // 处理操作符
+  let hasOperatorMatch = false;
+
+  for (const [operator, queryValue] of Object.entries(condition as Record<string, unknown>)) {
+    if (operator.startsWith('$')) {
+      // $options 是 $regex 的修饰符，跳过
+      if (operator === '$options') {
+        continue;
+      }
+
+      hasOperatorMatch = true;
+      let result: boolean;
+
+      // 比较操作符
+      if (comparisonOperators[operator]) {
+        result = comparisonOperators[operator](value, queryValue);
+      }
+      // 元素操作符
+      else if (elementOperators[operator]) {
+        result = elementOperators[operator](value, queryValue);
+      }
+      // 数组操作符
+      else if (arrayOperators[operator]) {
+        result = arrayOperators[operator](value, queryValue);
+      }
+      // 正则操作符
+      else if (operator === '$regex') {
+        result = matchRegex(value, condition as { $regex: string | RegExp; $options?: string });
+      }
+      // 未知操作符
+      else {
+        throw new Error(`未知操作符：${operator}`);
+      }
+
+      if (!result) {
+        return false;
+      }
+    }
+  }
+
+  // 如果没有操作符匹配，直接比较值
+  if (!hasOperatorMatch) {
+    return value === condition;
+  }
+
+  return true;
+}
+
+/**
+ * 匹配查询条件
+ */
+export function matchQuery(doc: Record<string, unknown>, query: Record<string, unknown>): boolean {
+  if (!query || typeof query !== 'object') {
+    return true;
+  }
+
+  for (const [key, condition] of Object.entries(query)) {
+    // 逻辑操作符
+    if (key.startsWith('$')) {
+      if (logicalOperators[key]) {
+        const result = logicalOperators[key](doc, condition as Record<string, unknown>[]);
+        if (!result) {
+          return false;
+        }
+      } else {
+        throw new Error(`未知逻辑操作符：${key}`);
+      }
+    } else {
+      // 字段匹配
+      const result = matchField(doc, key, condition);
+      if (!result) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+/**
+ * 更新操作符实现
+ */
+export const updateOperators = {
+  $set: (doc: Record<string, unknown>, updates: Record<string, unknown>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      setNestedValue(doc, path, value);
+    }
+  },
+
+  $unset: (doc: Record<string, unknown>, paths: Record<string, unknown>): void => {
+    for (const path of Object.keys(paths)) {
+      deleteNestedValue(doc, path);
+    }
+  },
+
+  $inc: (doc: Record<string, unknown>, updates: Record<string, number>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as number || 0;
+      setNestedValue(doc, path, currentValue + value);
+    }
+  },
+
+  $mul: (doc: Record<string, unknown>, updates: Record<string, number>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as number || 1;
+      setNestedValue(doc, path, currentValue * value);
+    }
+  },
+
+  $rename: (doc: Record<string, unknown>, renames: Record<string, string>): void => {
+    for (const [oldPath, newPath] of Object.entries(renames)) {
+      const value = getNestedValue(doc, oldPath);
+      if (value !== undefined) {
+        setNestedValue(doc, newPath, value);
+        deleteNestedValue(doc, oldPath);
+      }
+    }
+  },
+
+  $setOnInsert: (doc: Record<string, unknown>, updates: Record<string, unknown>, isInsert: boolean): void => {
+    if (isInsert) {
+      updateOperators.$set(doc, updates);
+    }
+  },
+
+  $min: (doc: Record<string, unknown>, updates: Record<string, number>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as number;
+      if (currentValue === undefined || value < currentValue) {
+        setNestedValue(doc, path, value);
+      }
+    }
+  },
+
+  $max: (doc: Record<string, unknown>, updates: Record<string, number>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as number;
+      if (currentValue === undefined || value > currentValue) {
+        setNestedValue(doc, path, value);
+      }
+    }
+  },
+
+  $push: (doc: Record<string, unknown>, updates: Record<string, unknown>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as unknown[];
+      const array = Array.isArray(currentValue) ? currentValue : [];
+      setNestedValue(doc, path, [...array, value]);
+    }
+  },
+
+  $pop: (doc: Record<string, unknown>, updates: Record<string, number>): void => {
+    for (const [path, direction] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as unknown[];
+      if (Array.isArray(currentValue) && currentValue.length > 0) {
+        if (direction === 1) {
+          setNestedValue(doc, path, currentValue.slice(0, -1));
+        } else if (direction === -1) {
+          setNestedValue(doc, path, currentValue.slice(1));
+        }
+      }
+    }
+  },
+
+  $pull: (doc: Record<string, unknown>, updates: Record<string, unknown>): void => {
+    for (const [path, condition] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as unknown[];
+      if (Array.isArray(currentValue)) {
+        const filtered = currentValue.filter(item => {
+          if (typeof condition === 'object') {
+            return !matchQuery(item as Record<string, unknown>, condition as Record<string, unknown>);
+          }
+          return item !== condition;
+        });
+        setNestedValue(doc, path, filtered);
+      }
+    }
+  },
+
+  $addToSet: (doc: Record<string, unknown>, updates: Record<string, unknown>): void => {
+    for (const [path, value] of Object.entries(updates)) {
+      const currentValue = getNestedValue(doc, path) as unknown[];
+      const array = Array.isArray(currentValue) ? currentValue : [];
+      if (!array.some(item => JSON.stringify(item) === JSON.stringify(value))) {
+        setNestedValue(doc, path, [...array, value]);
+      }
+    }
+  }
+};
+
+/**
+ * 应用更新到文档
+ */
+export function applyUpdate(doc: Record<string, unknown>, update: Record<string, unknown>, isInsert = false): Record<string, unknown> {
+  const result = JSON.parse(JSON.stringify(doc)) as Record<string, unknown>;
+
+  for (const [operator, updates] of Object.entries(update)) {
+    if (!operator.startsWith('$')) {
+      throw new Error('更新操作必须使用操作符');
+    }
+
+    if (updateOperators[operator]) {
+      updateOperators[operator](result, updates as Record<string, unknown>, isInsert);
+    } else {
+      throw new Error(`未知更新操作符：${operator}`);
+    }
+  }
+
+  return result;
+}

package/src/QueryCache.js

@@ -0,0 +1,190 @@
+/**
+ * 查询结果缓存模块
+ * 缓存相同查询的结果，提升重复查询性能
+ */
+
+import { createHash } from 'crypto';
+
+/**
+ * 查询缓存类
+ */
+export class QueryCache {
+  constructor(options = {}) {
+    this.maxSize = options.maxSize || 1000; // 最大缓存条目数
+    this.ttl = options.ttl || 60000; // 默认 1 分钟过期
+    this.cache = new Map();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  
+  /**
+   * 生成查询缓存键
+   * @param {string} collection - 集合名
+   * @param {Object} query - 查询条件
+   * @param {Object} options - 查询选项
+   * @returns {string} 缓存键
+   */
+  generateKey(collection, query, options = {}) {
+    const keyData = JSON.stringify({
+      collection,
+      query,
+      options: {
+        sort: options.sort,
+        limit: options.limit,
+        skip: options.skip,
+        projection: options.projection
+      }
+    });
+    
+    return createHash('sha256').update(keyData).digest('hex');
+  }
+  
+  /**
+   * 获取缓存
+   * @param {string} key - 缓存键
+   * @returns {any|null} 缓存的数据或 null
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+    
+    // 检查是否过期
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.misses++;
+      return null;
+    }
+    
+    // 更新访问时间（LRU）
+    entry.lastAccessed = Date.now();
+    this.hits++;
+    
+    return entry.data;
+  }
+  
+  /**
+   * 设置缓存
+   * @param {string} key - 缓存键
+   * @param {any} data - 数据
+   * @param {number} ttl - 过期时间（毫秒）
+   */
+  set(key, data, ttl) {
+    // 如果缓存已满，删除最久未使用的条目
+    if (this.cache.size >= this.maxSize) {
+      this._evictOldest();
+    }
+    
+    this.cache.set(key, {
+      data,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + (ttl || this.ttl),
+      lastAccessed: Date.now()
+    });
+  }
+  
+  /**
+   * 删除缓存
+   * @param {string} key - 缓存键
+   */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  
+  /**
+   * 删除与集合相关的所有缓存
+   * @param {string} collection - 集合名
+   */
+  invalidateCollection(collection) {
+    for (const [key, entry] of this.cache.entries()) {
+      if (key.includes(collection)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  
+  /**
+   * 删除最久未使用的条目（LRU）
+   * @private
+   */
+  _evictOldest() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.lastAccessed < oldestTime) {
+        oldestTime = entry.lastAccessed;
+        oldestKey = key;
+      }
+    }
+    
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+    }
+  }
+  
+  /**
+   * 获取缓存统计
+   * @returns {Object} 统计信息
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? ((this.hits / total) * 100).toFixed(2) + '%' : '0%',
+      ttl: this.ttl
+    };
+  }
+}
+
+/**
+ * 全局查询缓存实例
+ */
+export const globalQueryCache = new QueryCache({
+  maxSize: 500,
+  ttl: 30000 // 30 秒
+});
+
+/**
+ * 缓存查询装饰器
+ * @param {Function} queryFn - 查询函数
+ * @param {Object} options - 选项
+ * @returns {Function} 装饰后的查询函数
+ */
+export function cacheQuery(queryFn, options = {}) {
+  const cache = options.cache || globalQueryCache;
+  const ttl = options.ttl;
+  
+  return async function(collection, query, queryOptions) {
+    const key = cache.generateKey(collection.name, query, queryOptions);
+    
+    // 尝试从缓存获取
+    const cached = cache.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    
+    // 执行查询
+    const result = await queryFn.call(this, collection, query, queryOptions);
+    
+    // 存入缓存
+    cache.set(key, result, ttl);
+    
+    return result;
+  };
+}