@zhin.js/database 1.0.0

package/src/type/keyvalue/database.ts

@@ -0,0 +1,261 @@
+import { Database, Dialect } from '../../base';
+import { KeyValueModel } from './model.js';
+import { 
+  QueryParams, 
+  BuildQueryResult, 
+  KeyValueQueryResult, 
+  KeyValueOperationResult,
+  CreateQueryParams,
+  SelectQueryParams,
+  InsertQueryParams,
+  UpdateQueryParams,
+  DeleteQueryParams,
+  AlterQueryParams,
+  DropTableQueryParams,
+  DropIndexQueryParams
+} from '../../types.js';
+
+/**
+ * 键值数据库类
+ * 支持简单的键值对存储
+ */
+export class KeyValueDatabase<
+  D=any,
+  S extends Record<string, object> = Record<string, object>
+> extends Database<D, S, KeyValueQueryResult> {
+  
+  constructor(
+    dialect: Dialect<D,KeyValueQueryResult>,
+    schemas?: Database.Schemas<S>,
+  ) {
+    super(dialect, schemas);
+  }
+
+  protected async initialize(): Promise<void> {
+    // 键值数据库不需要预定义表结构
+    // 桶会在第一次使用时自动创建
+  }
+
+  /**
+   * 构建查询（重写基类方法）
+   */
+  buildQuery<U extends object = any>(params: QueryParams<U>): BuildQueryResult<KeyValueQueryResult> {
+    switch (params.type) {
+      case 'create':
+        return this.buildCreateQuery(params as CreateQueryParams<U>);
+      case 'select':
+        return this.buildSelectQuery(params as SelectQueryParams<U>);
+      case 'insert':
+        return this.buildInsertQuery(params as InsertQueryParams<U>);
+      case 'update':
+        return this.buildUpdateQuery(params as UpdateQueryParams<U>);
+      case 'delete':
+        return this.buildDeleteQuery(params as DeleteQueryParams<U>);
+      case 'alter':
+        return this.buildAlterQuery(params as AlterQueryParams<U>);
+      case 'drop_table':
+        return this.buildDropTableQuery(params as DropTableQueryParams<U>);
+      case 'drop_index':
+        return this.buildDropIndexQuery(params as DropIndexQueryParams);
+      default:
+        throw new Error(`Unsupported query type: ${(params as any).type}`);
+    }
+  }
+
+  /**
+   * 构建创建桶查询
+   */
+  protected buildCreateQuery<T extends object>(params: CreateQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'keys'
+      },
+      params: []
+    };
+  }
+
+  /**
+   * 构建查询键值查询
+   */
+  protected buildSelectQuery<T extends object>(params: SelectQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    // 键值数据库的查询通常是获取所有键或特定键
+    const query: KeyValueQueryResult = {
+      bucket: params.tableName,
+      operation: 'keys'
+    };
+
+    // 如果有条件，尝试提取键名
+    if (params.conditions) {
+      const key = this.extractKeyFromCondition(params.conditions);
+      if (key) {
+        query.operation = 'get';
+        query.key = key;
+      }
+    }
+
+    return {
+      query,
+      params: []
+    };
+  }
+
+  /**
+   * 构建插入键值查询
+   */
+  protected buildInsertQuery<T extends object>(params: InsertQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    const key = this.extractKeyFromData(params.data);
+    
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'set',
+        key: key || 'default',
+        value: params.data
+      },
+      params: [params.data]
+    };
+  }
+
+  /**
+   * 构建更新键值查询
+   */
+  protected buildUpdateQuery<T extends object>(params: UpdateQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    const key = this.extractKeyFromCondition(params.conditions);
+    
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'set',
+        key: key || 'default',
+        value: params.update
+      },
+      params: [params.update]
+    };
+  }
+
+  /**
+   * 构建删除键值查询
+   */
+  protected buildDeleteQuery<T extends object>(params: DeleteQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    const key = this.extractKeyFromCondition(params.conditions);
+    
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'delete',
+        key: key || 'default'
+      },
+      params: []
+    };
+  }
+
+  /**
+   * 构建修改桶查询
+   */
+  protected buildAlterQuery<T extends object>(params: AlterQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'keys'
+      },
+      params: [params.alterations]
+    };
+  }
+
+  /**
+   * 构建删除桶查询
+   */
+  protected buildDropTableQuery<T extends object>(params: DropTableQueryParams<T>): BuildQueryResult<KeyValueQueryResult> {
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'clear'
+      },
+      params: []
+    };
+  }
+
+  /**
+   * 构建删除索引查询
+   */
+  protected buildDropIndexQuery(params: DropIndexQueryParams): BuildQueryResult<KeyValueQueryResult> {
+    return {
+      query: {
+        bucket: params.tableName,
+        operation: 'keys'
+      },
+      params: [params.indexName]
+    };
+  }
+
+  /**
+   * 从条件中提取键名
+   */
+  private extractKeyFromCondition(condition: any): string | null {
+    if (typeof condition !== 'object' || condition === null) {
+      return null;
+    }
+
+    // 查找 key 字段
+    if ('key' in condition) {
+      return condition.key;
+    }
+
+    // 查找 id 字段
+    if ('id' in condition) {
+      return condition.id;
+    }
+
+    // 递归查找
+    for (const value of Object.values(condition)) {
+      if (typeof value === 'object' && value !== null) {
+        const result = this.extractKeyFromCondition(value);
+        if (result) return result;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 从数据中提取键名
+   */
+  private extractKeyFromData(data: any): string | null {
+    if (typeof data !== 'object' || data === null) {
+      return null;
+    }
+
+    // 查找 key 字段
+    if ('key' in data) {
+      return data.key;
+    }
+
+    // 查找 id 字段
+    if ('id' in data) {
+      return data.id;
+    }
+
+    return null;
+  }
+
+  /**
+   * 获取模型
+   */
+  model<T extends keyof S>(name: T): KeyValueModel<S[T], D> {
+    let model = this.models.get(name as string);
+    if (!model) {
+      model = new KeyValueModel(this as unknown as KeyValueDatabase<D>, name as string);
+      this.models.set(name as string, model);
+    }
+    return model as unknown as KeyValueModel<S[T], D>;
+  }
+
+  /**
+   * 获取所有模型名称
+   */
+  getModelNames(): string[] {
+    return Object.keys(this.schemas || {});
+  }
+}
+

package/src/type/keyvalue/model.ts

@@ -0,0 +1,339 @@
+import { Model, Dialect, Database } from '../../base';
+import { KeyValueDatabase } from './database.js';
+import { Condition, KeyValueQueryResult } from '../../types.js';
+
+/**
+ * 键值模型类
+ * 继承自 Model，提供键值数据库特有的操作
+ */
+export class KeyValueModel<T extends object = object, D=any> extends Model<D, T, KeyValueQueryResult> {
+  constructor(
+    database: KeyValueDatabase<D>,
+    name: string
+  ) {
+    super(database, name);
+  }
+
+  /**
+   * 设置键值对
+   */
+  async set(key: string, value: any, ttl?: number): Promise<void> {
+    await this.dialect.query({
+      operation: 'set',
+      bucket: this.name,
+      key,
+      value,
+      ttl,
+    });
+  }
+
+  /**
+   * 获取值
+   */
+  async get<V = any>(key: string): Promise<V | null> {
+    const results = await this.dialect.query(
+      {
+        operation: 'get',
+        bucket: this.name,
+        key,
+      },
+      [key]
+    );
+
+    if (results.length === 0) {
+      return null;
+    }
+
+    const row = results[0];
+    
+    // 检查是否过期
+    if (row.expires_at && Date.now() > row.expires_at) {
+      await this.deleteByKey(key);
+      return null;
+    }
+
+    return JSON.parse(row.value);
+  }
+
+  /**
+   * 删除键
+   */
+  async deleteByKey(key: string): Promise<boolean> {
+    const result = await this.dialect.query(
+      {
+        operation: 'delete',
+        bucket: this.name,
+        key,
+      },
+      [key]
+    );
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 检查键是否存在
+   */
+  async has(key: string): Promise<boolean> {
+    const results = await this.dialect.query(
+      {
+        operation: 'has',
+        bucket: this.name,
+        key,
+      },
+      [key, Date.now()]
+    );
+    return results.length > 0;
+  }
+
+  /**
+   * 获取所有键
+   */
+  async keys(): Promise<string[]> {
+    const results = await this.dialect.query(
+      {
+        operation: 'keys',
+        bucket: this.name,
+      },
+      [Date.now()]
+    );
+    return results.map((row: any) => row.key);
+  }
+
+  /**
+   * 获取所有值
+   */
+  async values<V = any>(): Promise<V[]> {
+    const results = await this.dialect.query(
+      {
+        operation: 'values',
+        bucket: this.name,
+      },
+      [Date.now()]
+    );
+    return results.map((row: any) => JSON.parse(row.value));
+  }
+
+  /**
+   * 获取所有键值对
+   */
+  async entries<V = any>(): Promise<Array<[string, V]>> {
+    const results = await this.dialect.query(
+      {
+        operation: 'entries',
+        bucket: this.name,
+      },
+      [Date.now()]
+    );
+    return results.map((row: any) => [row.key, JSON.parse(row.value)]);
+  }
+
+  /**
+   * 清空桶
+   */
+  async clear(): Promise<void> {
+    await this.dialect.query({
+      operation: 'clear',
+      bucket: this.name,
+    });
+  }
+
+  /**
+   * 获取桶大小
+   */
+  async size(): Promise<number> {
+    const results = await this.dialect.query(
+      {
+        operation: 'size',
+        bucket: this.name,
+      },
+      [Date.now()]
+    );
+    return results[0]?.count || 0;
+  }
+
+  /**
+   * 批量设置
+   */
+  async setMany(entries: Array<[string, any]>, ttl?: number): Promise<void> {
+    const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
+    
+    for (const [key, value] of entries) {
+      await this.dialect.query(
+        {
+          operation: 'set',
+          bucket: this.name,
+          key,
+          value,
+          ttl,
+        },
+        [key, JSON.stringify(value), expiresAt]
+      );
+    }
+  }
+
+  /**
+   * 设置过期时间
+   */
+  async expire(key: string, ttl: number): Promise<boolean> {
+    const expiresAt = Date.now() + ttl * 1000;
+    const result = await this.dialect.query(
+      {
+        operation: 'expire',
+        bucket: this.name,
+        key,
+        ttl,
+      },
+      [expiresAt, key]
+    );
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 获取剩余过期时间（秒）
+   */
+  async ttl(key: string): Promise<number | null> {
+    const results = await this.dialect.query(
+      {
+        operation: 'ttl',
+        bucket: this.name,
+        key,
+      },
+      [key]
+    );
+
+    if (results.length === 0) {
+      return null;
+    }
+
+    const expiresAt = results[0].expires_at;
+    if (!expiresAt) {
+      return -1; // 永不过期
+    }
+
+    const remaining = Math.ceil((expiresAt - Date.now()) / 1000);
+    return remaining > 0 ? remaining : 0;
+  }
+
+  /**
+   * 移除过期时间
+   */
+  async persist(key: string): Promise<boolean> {
+    const result = await this.dialect.query(
+      {
+        operation: 'persist',
+        bucket: this.name,
+        key,
+      },
+      [key]
+    );
+    return result.affectedRows > 0;
+  }
+
+  /**
+   * 清理过期键
+   */
+  async cleanup(): Promise<number> {
+    const result = await this.dialect.query(
+      {
+        operation: 'cleanup',
+        bucket: this.name,
+      },
+      [Date.now()]
+    );
+    return result.affectedRows;
+  }
+
+  /**
+   * 获取键的模式匹配
+   */
+  async keysByPattern(pattern: string): Promise<string[]> {
+    // 简单的通配符匹配，将 * 转换为 SQL 的 %
+    const sqlPattern = pattern.replace(/\*/g, '%');
+    const results = await this.dialect.query(
+      {
+        operation: 'keysByPattern',
+        bucket: this.name,
+        pattern: sqlPattern,
+      },
+      [sqlPattern, Date.now()]
+    );
+    return results.map((row: any) => row.key);
+  }
+
+  /**
+   * 原子操作：如果不存在则设置
+   */
+  async setIfNotExists(key: string, value: any, ttl?: number): Promise<boolean> {
+    const exists = await this.has(key);
+    if (exists) {
+      return false;
+    }
+    
+    await this.set(key, value, ttl);
+    return true;
+  }
+
+  /**
+   * 原子操作：如果存在则设置
+   */
+  async setIfExists(key: string, value: any, ttl?: number): Promise<boolean> {
+    const exists = await this.has(key);
+    if (!exists) {
+      return false;
+    }
+    
+    await this.set(key, value, ttl);
+    return true;
+  }
+
+  /**
+   * 原子操作：获取并设置
+   */
+  async getAndSet<V = any>(key: string, value: any, ttl?: number): Promise<V | null> {
+    const oldValue = await this.get<V>(key);
+    await this.set(key, value, ttl);
+    return oldValue;
+  }
+
+  /**
+   * 原子操作：删除并获取
+   */
+  async deleteAndGet<V = any>(key: string): Promise<V | null> {
+    const value = await this.get<V>(key);
+    if (value !== null) {
+      await this.deleteByKey(key);
+    }
+    return value;
+  }
+
+  // 实现 Model 的抽象方法
+
+  /**
+   * 创建数据（键值数据库的创建就是设置）
+   */
+  async create(data: T): Promise<T> {
+    // 键值数据库的创建需要特殊处理
+    throw new Error('KeyValue model does not support generic create. Use set() method instead.');
+  }
+
+  /**
+   * 查找单个数据
+   */
+  async selectOne(query: { key: string }): Promise<any> {
+    return this.get(query.key);
+  }
+
+  /**
+   * 统计数量
+   */
+  async count(): Promise<number> {
+    return this.size();
+  }
+
+  /**
+   * 检查是否存在
+   */
+  async exists(query: { key: string }): Promise<boolean> {
+    return this.has(query.key);
+  }
+}