@zhin.js/database 1.0.0

package/src/dialects/sqlite.ts

@@ -0,0 +1,233 @@
+import {Dialect} from "../base";
+import {Registry} from "../registry";
+import {Database} from "../base";
+import {Column} from "../types";
+import {RelatedDatabase} from "../type/related/database";
+
+
+export interface SQLiteDialectConfig {
+  filename: string;
+  mode?:string
+}
+
+export class SQLiteDialect extends Dialect<SQLiteDialectConfig, string> {
+  private db: any = null;
+
+  constructor(config: SQLiteDialectConfig) {
+    super('sqlite', config);
+  }
+
+  // Connection management
+  isConnected(): boolean {
+    return this.db !== null;
+  }
+
+  async connect(): Promise<void> {
+    try {
+      const { default: sqlite3 } = await import('sqlite3');
+      this.db = new sqlite3.Database(this.config.filename);
+    } catch (error) {
+      console.error('forgot install sqlite3 ?');
+      throw new Error(`SQLite 连接失败: ${error}`);
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    this.db = null;
+  }
+
+  async healthCheck(): Promise<boolean> {
+    return this.isConnected();
+  }
+
+  async query<U = any>(sql: string, params?: any[]): Promise<U> {
+    return new Promise((resolve, reject) => {
+      this.db.all(sql, params, (err: any, rows: any) => {
+        if (err) {
+          reject(err);
+        } else {
+          // 对查询结果进行后处理，移除多余的引号
+          const processedRows = this.processQueryResults(rows);
+          resolve(processedRows as U);
+        }
+      });
+      this.db.get(sql, params, (err: any, row: any) => {
+        if (err) {
+          reject(err);
+        } else {
+          // 对单行结果进行后处理
+          const processedRow = this.processQueryResults(row);
+          resolve(processedRow as U);
+        }
+      });
+    });
+  }
+
+  /**
+   * 处理查询结果，移除字符串字段的多余引号
+   */
+  private processQueryResults(data: any): any {
+    if (!data) return data;
+    
+    if (Array.isArray(data)) {
+      return data.map(row => this.processRowData(row));
+    } else if (typeof data === 'object') {
+      return this.processRowData(data);
+    }
+    
+    return data;
+  }
+
+  /**
+   * 处理单行数据
+   */
+  private processRowData(row: any): any {
+    if (!row || typeof row !== 'object') return row;
+    
+    const processedRow: any = {};
+    
+    for (const [key, value] of Object.entries(row)) {
+      processedRow[key] = this.processFieldValue(value);
+    }
+    
+    return processedRow;
+  }
+
+  /**
+   * 处理字段值，移除多余的引号并解析 JSON
+   */
+  private processFieldValue(value: any): any {
+    if (typeof value !== 'string') return value;
+    
+    // 移除字符串两端的引号（如果存在）
+    if ((value.startsWith("'") && value.endsWith("'")) || 
+        (value.startsWith('"') && value.endsWith('"'))) {
+      const unquoted = value.slice(1, -1);
+      
+      // 尝试解析为 JSON（用于 json 类型字段）
+      if (unquoted.startsWith('{') || unquoted.startsWith('[')) {
+        try {
+          return JSON.parse(unquoted);
+        } catch {
+          // 如果解析失败，返回去除引号的字符串
+          return unquoted;
+        }
+      }
+      
+      return unquoted;
+    }
+    
+    return value;
+  }
+
+  async dispose(): Promise<void> {
+    if (this.db) {
+      await this.db.close();
+      this.db = null;
+    }
+  }
+
+  // SQL generation methods
+  mapColumnType(type: string): string {
+    const typeMap: Record<string, string> = {
+      'text': 'TEXT',
+      'integer': 'INTEGER',
+      'float': 'REAL',
+      'boolean': 'INTEGER',
+      'date': 'TEXT',
+      'json': 'TEXT'
+    };
+    return typeMap[type.toLowerCase()] || 'TEXT';
+  }
+  
+  quoteIdentifier(identifier: string): string {
+    return `"${identifier}"`;
+  }
+  
+  getParameterPlaceholder(index: number): string {
+    return '?';
+  }
+  
+  getStatementTerminator(): string {
+    return ';';
+  }
+  
+  formatBoolean(value: boolean): string {
+    return value ? '1' : '0';
+  }
+  
+  formatDate(value: Date): string {
+    return `'${value.toISOString()}'`;
+  }
+  
+  formatJson(value: any): string {
+    return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+  }
+  
+  escapeString(value: string): string {
+    return value.replace(/'/g, "''");
+  }
+  
+  formatDefaultValue(value: any): string {
+    if (typeof value === 'string') {
+      return `'${this.escapeString(value)}'`;
+    } else if (typeof value === 'number' || typeof value === 'boolean') {
+      return value.toString();
+    } else if (value instanceof Date) {
+      return this.formatDate(value);
+    } else if (value === null) {
+      return 'NULL';
+    } else if (typeof value === 'object') {
+      return this.formatJson(value);
+    } else {
+      throw new Error(`Unsupported default value type: ${typeof value}`);
+    }
+  }
+  
+  formatLimit(limit: number): string {
+    return `LIMIT ${limit}`;
+  }
+  
+  formatOffset(offset: number): string {
+    return `OFFSET ${offset}`;
+  }
+  
+  formatLimitOffset(limit: number, offset: number): string {
+    return `LIMIT ${limit} OFFSET ${offset}`;
+  }
+  
+  formatCreateTable(tableName: string, columns: string[]): string {
+    return `CREATE TABLE IF NOT EXISTS ${this.quoteIdentifier(tableName)} (${columns.join(', ')})`;
+  }
+  
+  formatColumnDefinition(field: string, column: Column<any>): string {
+    const name = this.quoteIdentifier(String(field));
+    const type = this.mapColumnType(column.type);
+    const length = column.length ? `(${column.length})` : '';
+    const nullable = column.nullable === false ? ' NOT NULL' : '';
+    const primary = column.primary ? ' PRIMARY KEY' : '';
+    const unique = column.unique ? ' UNIQUE' : '';
+    const defaultVal = column.default !== undefined 
+      ? ` DEFAULT ${this.formatDefaultValue(column.default)}` 
+      : '';
+    
+    return `${name} ${type}${length}${primary}${unique}${nullable}${defaultVal}`;
+  }
+  
+  formatAlterTable(tableName: string, alterations: string[]): string {
+    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ${alterations.join(', ')}`;
+  }
+  
+  formatDropTable(tableName: string, ifExists?: boolean): string {
+    const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+    return `DROP TABLE ${ifExistsClause}${this.quoteIdentifier(tableName)}`;
+  }
+  
+  formatDropIndex(indexName: string, tableName: string, ifExists?: boolean): string {
+    const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+    return `DROP INDEX ${ifExistsClause}${this.quoteIdentifier(indexName)}`;
+  }
+}
+Registry.register('sqlite', (config: SQLiteDialectConfig, schemas?: Database.Schemas<Record<string, object>>) => {
+  return new RelatedDatabase(new SQLiteDialect(config), schemas);
+});

package/src/index.ts

@@ -0,0 +1,20 @@
+export * from './types.js';
+export * from './base/model.js';
+export * from './base/dialect.js';
+export * from './base/database.js';
+export * from './type/related/database.js';
+export * from './type/related/model.js';
+export * from './type/document/database.js';
+export * from './type/document/model.js';
+export * from './type/keyvalue/database.js';
+export * from './type/keyvalue/model.js';
+export * from './registry.js';
+export * from './dialects/memory.js';
+export * from './dialects/mysql.js';
+export * from './dialects/pg.js';
+export * from './dialects/redis.js';
+export * from './dialects/sqlite.js';
+export * from './dialects/mongodb.js';
+
+
+

package/src/registry.ts

@@ -0,0 +1,59 @@
+import { Database } from './base/database.js';
+import type {MongoDBDialectConfig} from './dialects/mongodb';
+import {RelatedDatabase} from "./type/related/database";
+import {MemoryConfig} from "./types";
+import {DocumentDatabase} from "./type/document/database";
+import {MySQLDialectConfig} from "./dialects/mysql";
+import {PostgreSQLDialectConfig} from "./dialects/pg";
+import {RedisDialectConfig} from "./dialects/redis";
+import {SQLiteDialectConfig} from "./dialects/sqlite";
+import {KeyValueDatabase} from "./type/keyvalue/database";
+
+/**
+ * 数据库注册表接口
+ * 支持模块声明扩展
+ */
+export interface Databases<S extends Record<string, object> = Record<string, object>> {
+  memory: RelatedDatabase<MemoryConfig,S>;
+  mongodb: DocumentDatabase<MongoDBDialectConfig,S>;
+  mysql: RelatedDatabase<MySQLDialectConfig,S>;
+  pg: RelatedDatabase<PostgreSQLDialectConfig,S>;
+  redis: KeyValueDatabase<RedisDialectConfig,S>;
+  sqlite: RelatedDatabase<SQLiteDialectConfig>;
+}
+
+/**
+ * 数据库注册表命名空间
+ */
+export type Creator<D, S extends Record<string, object>> = (config: D, schemas?: Database.Schemas<S>) => Database<any, S, any>;
+export type Constructor<D, S extends Record<string, object>> = new (config: D, schemas?: Database.Schemas<S>) => Database<any, S, any>;
+export type Factory<D, S extends Record<string, object>> = Creator<any, S> | Constructor<any, S>;
+
+export namespace Registry {
+  export const factories=new Map();
+  export type Config<T extends Database<any, any, any>> = T extends Database<infer D, any, any> ? D: any;
+  export type DatabaseType = 'related' | 'document' | 'keyvalue';
+  
+  export function register<D extends string, S extends Record<string, object>>(
+    dialect: D, 
+    factory: Factory<any, S>
+  ): void {
+    factories.set(dialect, factory as Factory<any, S>);
+  }
+  
+  export function create<D extends string, S extends Record<string, object>>(
+    dialect: D,
+    config: any,
+    schemas?: Database.Schemas<S>
+  ): any {
+    const factory = factories.get(dialect) as Factory<any, S> | undefined;
+    if (!factory) {
+      throw new Error(`database dialect ${dialect} not registered`);
+    }
+    return (isConstructor(factory) ? new factory(config, schemas) : factory(config, schemas)) as any;
+  }
+  
+  export function isConstructor<D, S extends Record<string, object>>(fn: Factory<D, S>): fn is Constructor<D, S> {
+    return fn.prototype && fn.prototype.constructor === fn;
+  }
+}

package/src/type/document/database.ts

@@ -0,0 +1,283 @@
+import { Database, Dialect } from '../../base';
+import { DocumentModel } from './model.js';
+import { 
+  QueryParams, 
+  BuildQueryResult, 
+  DocumentQueryResult, 
+  CreateQueryParams,
+  SelectQueryParams,
+  InsertQueryParams,
+  UpdateQueryParams,
+  DeleteQueryParams,
+  AlterQueryParams,
+  DropTableQueryParams,
+  DropIndexQueryParams
+} from '../../types.js';
+
+/**
+ * 文档型数据库类
+ * 支持集合、文档的文档型数据模型
+ */
+export class DocumentDatabase<
+  D = any,
+  S extends Record<string, object> = Record<string, object>
+> extends Database<D, S, DocumentQueryResult> {
+  
+  constructor(
+    dialect: Dialect<D,DocumentQueryResult>,
+    schemas?: Database.Schemas<S>,
+  ) {
+    super(dialect, schemas);
+  }
+
+  protected async initialize(): Promise<void> {
+    // 文档数据库不需要预定义表结构
+    // 集合会在第一次使用时自动创建
+  }
+
+  /**
+   * 构建查询（重写基类方法）
+   */
+  buildQuery<U extends object = any>(params: QueryParams<U>): BuildQueryResult<DocumentQueryResult> {
+    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<DocumentQueryResult> {
+    return {
+      query: {
+        collection: params.tableName,
+        filter: {},
+        projection: {}
+      },
+      params: []
+    };
+  }
+
+  /**
+   * 构建查询文档查询
+   */
+  protected buildSelectQuery<T extends object>(params: SelectQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+    const filter: Record<string, any> = {};
+    
+    // 转换条件为文档查询格式
+    if (params.conditions) {
+      this.convertConditionToFilter(params.conditions, filter);
+    }
+
+    const query: DocumentQueryResult = {
+      collection: params.tableName,
+      filter
+    };
+
+    if (params.orderings) {
+      query.sort = {};
+      for (const order of params.orderings) {
+        query.sort[order.field as string] = order.direction === 'ASC' ? 1 : -1;
+      }
+    }
+
+    if (params.limitCount) {
+      query.limit = params.limitCount;
+    }
+
+    if (params.offsetCount) {
+      query.skip = params.offsetCount;
+    }
+
+    if (params.fields && params.fields.length > 0) {
+      query.projection = {};
+      for (const field of params.fields) {
+        query.projection[field as string] = 1;
+      }
+    }
+
+    return {
+      query,
+      params: []
+    };
+  }
+
+  /**
+   * 构建插入文档查询
+   */
+  protected buildInsertQuery<T extends object>(params: InsertQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+    return {
+      query: {
+        collection: params.tableName,
+        filter: {},
+        projection: {}
+      },
+      params: [params.data]
+    };
+  }
+
+  /**
+   * 构建更新文档查询
+   */
+  protected buildUpdateQuery<T extends object>(params: UpdateQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+    const filter: Record<string, any> = {};
+    
+    if (params.conditions) {
+      this.convertConditionToFilter(params.conditions, filter);
+    }
+
+    return {
+      query: {
+        collection: params.tableName,
+        filter,
+        projection: {}
+      },
+      params: [params.update]
+    };
+  }
+
+  /**
+   * 构建删除文档查询
+   */
+  protected buildDeleteQuery<T extends object>(params: DeleteQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+    const filter: Record<string, any> = {};
+    
+    if (params.conditions) {
+      this.convertConditionToFilter(params.conditions, filter);
+    }
+
+    return {
+      query: {
+        collection: params.tableName,
+        filter,
+        projection: {}
+      },
+      params: []
+    };
+  }
+
+  /**
+   * 构建修改集合查询
+   */
+  protected buildAlterQuery<T extends object>(params: AlterQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+    return {
+      query: {
+        collection: params.tableName,
+        filter: {},
+        projection: {}
+      },
+      params: [params.alterations]
+    };
+  }
+
+  /**
+   * 构建删除集合查询
+   */
+  protected buildDropTableQuery<T extends object>(params: DropTableQueryParams<T>): BuildQueryResult<DocumentQueryResult> {
+    return {
+      query: {
+        collection: params.tableName,
+        filter: {},
+        projection: {}
+      },
+      params: []
+    };
+  }
+
+  /**
+   * 构建删除索引查询
+   */
+  protected buildDropIndexQuery(params: DropIndexQueryParams): BuildQueryResult<DocumentQueryResult> {
+    return {
+      query: {
+        collection: params.tableName,
+        filter: {},
+        projection: {}
+      },
+      params: [params.indexName]
+    };
+  }
+
+  /**
+   * 转换条件为文档查询格式
+   */
+  private convertConditionToFilter(condition: any, filter: Record<string, any>): void {
+    if (typeof condition !== 'object' || condition === null) {
+      return;
+    }
+
+    for (const [key, value] of Object.entries(condition)) {
+      if (key.startsWith('$')) {
+        // 逻辑操作符
+        if (key === '$and' && Array.isArray(value)) {
+          filter.$and = value.map(cond => {
+            const subFilter: Record<string, any> = {};
+            this.convertConditionToFilter(cond, subFilter);
+            return subFilter;
+          });
+        } else if (key === '$or' && Array.isArray(value)) {
+          filter.$or = value.map(cond => {
+            const subFilter: Record<string, any> = {};
+            this.convertConditionToFilter(cond, subFilter);
+            return subFilter;
+          });
+        } else if (key === '$not') {
+          const subFilter: Record<string, any> = {};
+          this.convertConditionToFilter(value, subFilter);
+          filter.$not = subFilter;
+        }
+      } else if (typeof value === 'object' && value !== null) {
+        // 比较操作符
+        const fieldFilter: Record<string, any> = {};
+        for (const [op, opValue] of Object.entries(value)) {
+          if (op.startsWith('$')) {
+            fieldFilter[op] = opValue;
+          } else {
+            fieldFilter.$eq = value;
+          }
+        }
+        filter[key] = Object.keys(fieldFilter).length > 0 ? fieldFilter : value;
+      } else {
+        // 简单相等
+        filter[key] = { $eq: value };
+      }
+    }
+  }
+
+  /**
+   * 获取模型
+   */
+  model<T extends keyof S>(name: T): DocumentModel<S[T], D> {
+    let model = this.models.get(name as string);
+    if (!model) {
+      model = new DocumentModel(this as unknown as DocumentDatabase<D>, name as string);
+      this.models.set(name as string, model);
+    }
+    return model as unknown as DocumentModel<S[T], D>;
+  }
+
+  /**
+   * 获取所有模型名称
+   */
+  getModelNames(): string[] {
+    return Object.keys(this.schemas || {});
+  }
+}
+

package/src/type/document/model.ts

@@ -0,0 +1,86 @@
+import { Model} from '../../base';
+import { DocumentDatabase } from './database.js';
+import { DocumentQueryResult, Condition } from '../../types.js';
+
+/**
+ * 文档型模型类
+ * 继承自 Model，提供文档型数据库特有的操作
+ */
+export class DocumentModel<T extends object = object, D =any> extends Model<D, T, DocumentQueryResult> {
+  constructor(
+    database: DocumentDatabase<D>,
+    name: string
+  ) {
+    super(database, name);
+  }
+
+  /**
+   * 创建文档
+   */
+  async create(document: T): Promise<T & { _id: string }>;
+  async create(documents: T[]): Promise<(T & { _id: string })[]>;
+  async create(documents: T | T[]): Promise<(T & { _id: string }) | (T & { _id: string })[]> {
+    const isArray = Array.isArray(documents);
+    const docs = isArray ? documents : [documents];
+    
+    const results = [];
+    for (const doc of docs) {
+      const _id = this.generateId();
+      const docWithId = { ...doc, _id };
+      
+      await this.dialect.query(
+        {
+          operation: 'insertOne',
+          filter: {},
+          projection: {},
+          collection: this.name,
+        },
+        [docWithId]
+      );
+      results.push(docWithId);
+    }
+    
+    return isArray ? results : results[0];
+  }
+
+  /**
+   * 查找单个文档
+   */
+  async selectOne<K extends keyof T>(...fields: Array<K>): Promise<(Pick<T, K> & { _id: string }) | null> {
+    const results = await this.select(...fields).limit(1);
+    return results.length > 0 ? results[0] as (Pick<T, K> & { _id: string }) : null;
+  }
+
+  /**
+   * 根据ID查找文档
+   */
+  async selectById(id: string){
+    return this.select('_id' as any).where({
+      _id: id,
+    }).limit(1).then((results: any) => results[0] || null);
+  }
+  /**
+   * 根据ID更新文档
+   */
+  async updateById(id: string, update: Partial<T>): Promise<number> {
+    return this.update(update).where({
+      _id: id,
+    } as Condition<T>)
+  }
+
+  /**
+   * 根据ID删除文档
+   */
+  async deleteById(id: string): Promise<number> {
+    return this.delete({
+      _id: id,
+    } as Condition<T>)
+  }
+
+  /**
+   * 生成文档ID
+   */
+  private generateId(): string {
+    return Math.random().toString(36).substr(2, 9) + Date.now().toString(36);
+  }
+}