@zhin.js/database 1.0.0

package/src/base/dialect.ts

@@ -0,0 +1,76 @@
+import { 
+  QueryParams, 
+  BuildQueryResult, 
+  CreateQueryParams, 
+  SelectQueryParams, 
+  InsertQueryParams, 
+  UpdateQueryParams, 
+  DeleteQueryParams, 
+  AlterQueryParams, 
+  DropTableQueryParams, 
+  DropIndexQueryParams,
+  AddSchema,
+  ModifySchema,
+  DropSchema,
+  Condition,
+  isCreateQuery,
+  isSelectQuery,
+  isInsertQuery,
+  isUpdateQuery,
+  isDeleteQuery,
+  isAlterQuery,
+  isDropTableQuery,
+  isDropIndexQuery,
+  Column,
+} from '../types.js';
+
+// ============================================================================
+// Database Dialect Interface
+// ============================================================================
+
+
+// ============================================================================
+// SQL Builder Base Class
+// ============================================================================
+
+export abstract class Dialect<T,Q> {
+  public readonly name: string;
+  public readonly config: T;
+  
+  protected constructor(name: string, config: T) {
+    this.name = name;
+    this.config = config;
+  }
+  
+  // Abstract methods that must be implemented by concrete dialects
+  abstract isConnected(): boolean;
+  abstract connect(): Promise<void>;
+  abstract disconnect(): Promise<void>;
+  abstract healthCheck(): Promise<boolean>;
+  abstract query<U = any>(query: Q, params?: any[]): Promise<U>;
+  abstract mapColumnType(type: string): string;
+  abstract quoteIdentifier(identifier: string): string;
+  abstract getParameterPlaceholder(index: number): string;
+  abstract getStatementTerminator(): string;
+  abstract formatBoolean(value: boolean): string;
+  abstract formatDate(value: Date): string;
+  abstract formatJson(value: any): string;
+  abstract escapeString(value: string): string;
+  abstract formatDefaultValue(value: any): string;
+  abstract formatLimit(limit: number): string;
+  abstract formatOffset(offset: number): string;
+  abstract formatLimitOffset(limit: number, offset: number): string;
+  abstract formatCreateTable(tableName: string, columns: string[]): string;
+  abstract formatAlterTable(tableName: string, alterations: string[]): string;
+  abstract formatDropTable(tableName: string, ifExists?: boolean): string;
+  abstract formatDropIndex(indexName: string, tableName: string, ifExists?: boolean): string;
+  abstract dispose(): Promise<void>;
+}
+export namespace Dialect {
+  export type Creator<D,Q> = (config: D) => Dialect<D,Q>;
+  export type Constructor<D,Q> = new (config: D) => Dialect<D,Q>;
+  export type Factory<D,Q> = Creator<D,Q> | Constructor<D,Q>;
+  export function isConstructor<D,Q>(fn: Factory<D,Q>): fn is Constructor<D,Q> {
+    return fn.prototype && fn.prototype.constructor === fn;
+  }
+}

package/src/base/index.ts

@@ -0,0 +1,5 @@
+export * from './dialect.js';
+export * from './database.js';
+export * from './model.js';
+export * from './thenable.js';
+export * from './query-classes.js';

package/src/base/model.ts

@@ -0,0 +1,89 @@
+import type { Database } from './database.js';
+import type { Dialect } from './dialect.js';
+import { AlterSchema, Condition } from '../types.js';
+import * as QueryClasses from './query-classes.js';
+
+
+/**
+ * 基础模型抽象类
+ * 定义所有模型类型的通用接口和行为
+ */
+export abstract class Model<C=any,O extends object = object,Q = string> {
+  constructor(
+    public readonly database: Database<C, any, Q>,
+    public readonly name: string
+  ) {}
+
+  /**
+   * 获取数据库方言
+   */
+  get dialect(): Dialect<C,Q> {
+    return this.database.dialect;
+  }
+
+  /**
+   * 获取数据库是否已启动
+   */
+  get isStarted(): boolean {
+    return this.database.isStarted;
+  }
+
+  /**
+   * 获取模型名称
+   */
+  get modelName(): string {
+    return this.name;
+  }
+
+  alter(alterations: AlterSchema<O>): QueryClasses.Alteration<O, C, Q> {
+    return this.database.alter<O>(this.name, alterations);
+  }
+  select<K extends keyof O>(...fields: Array<K>): QueryClasses.Selection<Pick<O, K>, K, C, Q> {
+    return this.database.select<O, K>(this.name, fields);
+  }
+  
+  insert(data: O): QueryClasses.Insertion<O, C, Q> {
+    return this.database.insert<O>(this.name, data);
+  }
+  
+  update(update: Partial<O>): QueryClasses.Updation<O, C, Q> {
+    return this.database.update<O>(this.name, update);
+  }
+  
+  delete(condition: Condition<O>): QueryClasses.Deletion<O, C, Q> {
+    return this.database.delete<O>(this.name, condition);
+  }
+  /**
+   * 验证查询条件
+   */
+  protected validateQuery(query: any): boolean {
+    return query !== null && query !== undefined;
+  }
+
+  /**
+   * 验证数据
+   */
+  protected validateData(data: any): boolean {
+    return data !== null && data !== undefined;
+  }
+
+  /**
+   * 处理错误
+   */
+  protected handleError(error: Error, operation: string): never {
+    const message = `Model ${this.name} ${operation} failed: ${error.message}`;
+    throw new Error(message);
+  }
+}
+
+/**
+ * 模型信息接口
+ */
+export interface ModelInfo {
+  name: string;
+  databaseName: string;
+  dialectName: string;
+  isStarted: boolean;
+  modelCount: number;
+}
+

package/src/base/query-classes.ts

@@ -0,0 +1,217 @@
+import type { Database } from './database.js';
+import type { Dialect } from './dialect.js';
+import { ThenableQuery } from './thenable.js';
+import { QueryParams, AlterSchema, Condition, Ordering, Schema } from '../types.js';
+
+export class Alteration<T extends object, C = any, D = string> extends ThenableQuery<void, C, D> {
+  constructor(
+    database: Database<C, Record<string, object>, D>,
+    private readonly tableName: string,
+    private readonly alterations: AlterSchema<T>
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'alter',
+      tableName: this.tableName,
+      alterations: this.alterations
+    };
+  }
+}
+
+export class DroppingTable<T extends object = any, C = any, D = string> extends ThenableQuery<number, C, D> {
+  private conditions: Condition<T> = {};
+  
+  constructor(
+    database: Database<C, Record<string, object>, any>, 
+    private readonly tableName: string
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  where(query: Condition<T>): this {
+    this.conditions = { ...this.conditions, ...query };
+    return this;
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'drop_table',
+      tableName: this.tableName,
+      conditions: this.conditions
+    };
+  }
+}
+
+export class DroppingIndex<C = any, D = string> extends ThenableQuery<number, C, D> {
+  private conditions: Condition<any> = {};
+  
+  constructor(
+    database: Database<C, Record<string, object>, D>,
+    private readonly indexName: string,
+    private readonly tableName: string
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  where(query: Condition<any>): this {
+    this.conditions = { ...this.conditions, ...query };
+    return this;
+  }
+  
+  protected getQueryParams(): QueryParams<any> {
+    return {
+      type: 'drop_index',
+      tableName: this.tableName,
+      indexName: this.indexName,
+      conditions: this.conditions
+    };
+  }
+}
+
+export class Creation<T extends object, C = any, D = string> extends ThenableQuery<void, C, D> {
+  constructor(
+    database: Database<C, Record<string, object>, D>,
+    private readonly tableName: string,
+    private readonly schema: Schema<T>
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'create',
+      tableName: this.tableName,
+      schema: this.schema
+    };
+  }
+}
+
+export class Selection<
+  T extends object,
+  K extends keyof T,
+  C = any,
+  D = string
+> extends ThenableQuery<Pick<T, K>[], C, D> {
+  private conditions: Condition<T> = {};
+  private groupings: (keyof T)[] = [];
+  private orderings: Ordering<T>[] = [];
+  private limitCount?: number;
+  private offsetCount?: number;
+  
+  constructor(
+    database: Database<C, Record<string, object>, D>,
+    private readonly modelName: string,
+    private readonly fields: Array<K>
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  where(query: Condition<T>): this {
+    this.conditions = { ...this.conditions, ...query };
+    return this;
+  }
+  
+  groupBy(...fields: (keyof T)[]): this {
+    this.groupings.push(...fields);
+    return this;
+  }
+  
+  orderBy(field: keyof T, direction: "ASC" | "DESC" = "ASC"): this {
+    this.orderings.push({ field, direction });
+    return this;
+  }
+  
+  limit(count: number): this {
+    this.limitCount = count;
+    return this;
+  }
+  
+  offset(count: number): this {
+    this.offsetCount = count;
+    return this;
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'select',
+      tableName: this.modelName,
+      fields: this.fields,
+      conditions: this.conditions,
+      groupings: this.groupings,
+      orderings: this.orderings,
+      limitCount: this.limitCount,
+      offsetCount: this.offsetCount
+    };
+  }
+}
+
+export class Insertion<T extends object, C = any, D = string> extends ThenableQuery<T, C, D> {
+  constructor(
+    database: Database<C, Record<string, object>, D>, 
+    private readonly modelName: string, 
+    private readonly data: T
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'insert',
+      tableName: this.modelName,
+      data: this.data
+    };
+  }
+}
+
+export class Updation<T extends object, C = any, D = string> extends ThenableQuery<number, C, D> {
+  private conditions: Condition<T> = {};
+  
+  constructor(
+    database: Database<C, Record<string, object>, D>,
+    private readonly modelName: string,
+    private readonly update: Partial<T>
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  where(query: Condition<T>): this {
+    this.conditions = { ...this.conditions, ...query };
+    return this;
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'update',
+      tableName: this.modelName,
+      update: this.update,
+      conditions: this.conditions
+    };
+  }
+}
+
+export class Deletion<T extends object = any, C = any, D = string> extends ThenableQuery<number, C, D> {
+  private conditions: Condition<T> = {};
+  
+  constructor(
+    database: Database<C, Record<string, object>, D>, 
+    private readonly modelName: string
+  ) {
+    super(database, database.dialect as Dialect<C, D>);
+  }
+  
+  where(query: Condition<T>): this {
+    this.conditions = { ...this.conditions, ...query };
+    return this;
+  }
+  
+  protected getQueryParams(): QueryParams<T> {
+    return {
+      type: 'delete',
+      tableName: this.modelName,
+      conditions: this.conditions
+    };
+  }
+}

package/src/base/thenable.ts

@@ -0,0 +1,54 @@
+import type { Database } from "./database.js";
+import type { Dialect } from "./dialect.js";
+import { QueryParams } from "../types.js";
+
+
+export abstract class ThenableQuery<T = any,C=any,D=string>
+  implements PromiseLike<T>, AsyncIterable<T>
+{
+  protected constructor(protected readonly database: Database<C,Record<string, object>,D>,protected readonly dialect: Dialect<C,D>) {}
+  
+  // Abstract method to get query parameters
+  protected abstract getQueryParams(): QueryParams;
+  [Symbol.toStringTag] = 'ThenableQuery';
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | undefined
+      | null
+  ): Promise<TResult1 | TResult2> {
+    const params = this.getQueryParams();
+    const { query, params: queryParams } = this.database.buildQuery(params);
+    return this.dialect.query<T>(query, queryParams).then(onfulfilled, onrejected);
+  }
+  
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | undefined
+      | null
+  ): Promise<any | TResult> {
+    const params = this.getQueryParams();
+    const { query, params: queryParams } = this.database.buildQuery(params);
+    return this.dialect.query(query, queryParams).catch(onrejected);
+  }
+  
+  finally(onfinally?: (() => void) | undefined | null): Promise<any> {
+    const params = this.getQueryParams();
+    const { query, params: queryParams } = this.database.buildQuery(params);
+    return this.dialect.query(query, queryParams).finally(onfinally);
+  }
+  
+  async *[Symbol.asyncIterator](): AsyncIterator<T, void, unknown> {
+    const params = this.getQueryParams();
+    const { query, params: queryParams } = this.database.buildQuery(params);
+    const rows = await this.dialect.query(query, queryParams);
+    for (const row of Array.isArray(rows) ? rows : [rows]) {
+      yield row;
+    }
+  }
+}