@aiao/rxdb-adapter-sqlite 0.0.1

package/README.md

@@ -0,0 +1 @@
+# rxdb-adapter-sqlite

package/RxDBAdapterSqlite.d.ts

@@ -0,0 +1,66 @@
+import { EntityType, IRepository, IRxDBAdapter, RxDB, RxDBAdapterLocalBase, TransactionFun } from '@aiao/rxdb';
+import { Observable } from 'rxjs';
+import { ADAPTER_NAME, SqliteOptions, SqliteResult } from './sqlite.interface';
+import { SQLiteCompatibleType } from './wa-sqlite';
+/**
+ * SQLite Adapter
+ */
+export declare class RxDBAdapterSqlite extends RxDBAdapterLocalBase implements IRxDBAdapter {
+    #private;
+    readonly options: SqliteOptions;
+    name: string;
+    /**
+     * 数据库版本
+     */
+    version$: Observable<string>;
+    constructor(rxdb: RxDB, options: SqliteOptions);
+    /**
+     * 连接 wab sqlite
+     */
+    connect(): Observable<this>;
+    /**
+     * 断开连接
+     */
+    disconnect(): Promise<void>;
+    /**
+     * 获取版本
+     */
+    version(): Promise<string>;
+    /**
+     * 获取实体仓库
+     * @param entity 实体类
+     */
+    getRepository<T extends EntityType, RT extends IRepository<T>>(entity: T): RT;
+    /**
+     * 判断表是否存在
+     * @param EntityType
+     */
+    isTableExisted<T extends EntityType>(EntityType: T): Promise<boolean>;
+    /**
+     * 判断表是否存在
+     * @param EntityType
+     */
+    isTableExisted$<T extends EntityType>(EntityType: T): Observable<boolean>;
+    /**
+     * 创建 table
+     * @param EntityType
+     */
+    createTable<T extends EntityType>(EntityType: T): Promise<boolean>;
+    /**
+     * 执行 sql
+     * @param sql
+     * @param bindings
+     */
+    execute(sql: string, bindings?: SQLiteCompatibleType[]): Observable<SqliteResult>;
+    /**
+     * 处理事务
+     * @param callback
+     */
+    transaction<T extends TransactionFun>(callback: T): ReturnType<T>;
+    transaction$<T extends TransactionFun>(callback: T): Observable<Awaited<ReturnType<T>>>;
+}
+declare module '@aiao/rxdb' {
+    interface RxDBAdapters {
+        [ADAPTER_NAME]: RxDBAdapterSqlite;
+    }
+}

package/SqliteClient.d.ts

@@ -0,0 +1,19 @@
+import { LoadModuleOptions, SqliteResult } from './sqlite.interface';
+import { SQLiteCompatibleType } from './wa-sqlite';
+export interface ISqliteClient {
+    init(dbName: string, options: LoadModuleOptions): Promise<void>;
+    execute(sql: string, bindings?: SQLiteCompatibleType[]): Promise<SqliteResult>;
+    disconnect(): Promise<void>;
+    version(): Promise<string>;
+}
+/**
+ * sqlite 客户端
+ */
+export declare class SqliteClient implements ISqliteClient {
+    #private;
+    protected changeChanel?: BroadcastChannel | null;
+    init(dbName: string, options: LoadModuleOptions): Promise<void>;
+    version(): Promise<string>;
+    disconnect(): Promise<void>;
+    execute(sql: string, bindings?: SQLiteCompatibleType[]): Promise<SqliteResult>;
+}

package/SqliteRepository.d.ts

@@ -0,0 +1,23 @@
+import { CountOptions, EntityType, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetOptions, IRepository, MutationType, RuleGroup, UUID } from '@aiao/rxdb';
+import { Observable } from 'rxjs';
+import { SqliteRepositoryBase } from './SqliteRepositoryBase';
+/**
+ * 操作 entity 仓库
+ */
+export declare class SqliteRepository<T extends EntityType> extends SqliteRepositoryBase<T> implements IRepository<T> {
+    #private;
+    get(id: UUID, options?: GetOptions): Observable<InstanceType<T>>;
+    findOne(where: RuleGroup<InstanceType<T>>, options?: FindOneOptions): Observable<InstanceType<T> | undefined>;
+    findOneOrFail(where: RuleGroup<InstanceType<T>>, options?: FindOneOrFailOptions): Observable<InstanceType<T>>;
+    find(where: RuleGroup<InstanceType<T>>, options?: FindOptions): Observable<InstanceType<T>[]>;
+    findAll(where: RuleGroup<InstanceType<T>>, options?: FindAllOptions): Observable<InstanceType<T>[]>;
+    findByCursor(where: RuleGroup<InstanceType<T>>, options?: FindByCursorOptions): Observable<InstanceType<T>[]>;
+    count(where: RuleGroup<InstanceType<T>>, options?: CountOptions): Observable<number>;
+    create(entity: InstanceType<T>): Promise<InstanceType<T>>;
+    update(entity: InstanceType<T>, patch: Partial<InstanceType<T>>): Promise<InstanceType<T>>;
+    remove(entity: InstanceType<T>): Promise<InstanceType<T>>;
+    /**
+     * 根据 type 计算主动更新缓存策略
+     */
+    merge_cache(type: MutationType, entities: InstanceType<T>[]): void;
+}

package/SqliteRepositoryBase.d.ts

@@ -0,0 +1,85 @@
+import { EntityMetadata, EntityType, MutationType, RepositoryBase, UUID } from '@aiao/rxdb';
+import { Observable, Subject } from 'rxjs';
+import { SqlResult } from './generate_query_find_sql';
+import { RxDBAdapterSqlite } from './RxDBAdapterSqlite';
+import { SqliteSuccessResult } from './sqlite.interface';
+import { ISqliteClient } from './SqliteClient';
+/**
+ * 查询任务
+ */
+export interface QueryTask {
+    /**
+     * 查询语句
+     */
+    sql: string;
+    /**
+     * 查询参数
+     */
+    params: any[];
+    /**
+     * 观察者数量
+     */
+    observerCount: number;
+    /**
+     * 用于强制刷新查询语句
+     */
+    refresh$: Observable<number>;
+    /**
+     * 查询结果
+     */
+    result$: Observable<SqliteSuccessResult>;
+    /**
+     * 查询结果的实体 id
+     */
+    resultEntityIds?: UUID[];
+    resultEntities?: InstanceType<any>[];
+    /**
+     * 查询被销毁
+     */
+    destroy$: Observable<void>;
+    /**
+     * 强制刷新
+     */
+    refresh: () => void;
+    /**
+     * 更新数据
+     */
+    next: (value: SqliteSuccessResult) => void;
+    /**
+     * 抛出错误
+     */
+    error: (value: Error) => void;
+}
+/**
+ * 操作 entity 仓库
+ */
+export declare class SqliteRepositoryBase<T extends EntityType> extends RepositoryBase<T> {
+    #private;
+    protected adapter: RxDBAdapterSqlite;
+    protected client$: Observable<ISqliteClient>;
+    protected metadata: EntityMetadata;
+    protected need_run_task: Subject<void>;
+    protected run_task$: Observable<void>;
+    protected cache_query_task_map: Map<string, QueryTask>;
+    protected cache_query_tasks: QueryTask[];
+    protected transaction_entities: {
+        type: MutationType;
+        entities: InstanceType<T>[];
+    }[];
+    protected transaction_pending: boolean;
+    constructor(adapter: RxDBAdapterSqlite, client$: Observable<ISqliteClient>, EntityType: T);
+    /**
+     * 根据 type 计算主动更新缓存策略
+     */
+    protected merge_cache(type: MutationType, entities: InstanceType<T>[]): void;
+    /**
+     * 添加缓存
+     * @param sqliteSuccessResult
+     * @param forcedUpdate 强制刷新，在数据有的情况下也会更新数据，在修改数据的情况下需要
+     */
+    protected add_query_cache(sqliteSuccessResult: SqliteSuccessResult, forcedUpdate?: boolean): InstanceType<T>[];
+    /**
+     * 创建查询任务
+     */
+    protected create_query_task(sqlResult: SqlResult): QueryTask;
+}

package/SqliteTreeRepository.d.ts

@@ -0,0 +1,17 @@
+import { EntityType, FindTreeOptions, ITreeRepository, MutationType, RuleGroup } from '@aiao/rxdb';
+import { Observable } from 'rxjs';
+import { SqliteRepository } from './SqliteRepository';
+/**
+ * tree entity 仓库
+ */
+export declare class SqliteTreeRepository<T extends EntityType> extends SqliteRepository<T> implements ITreeRepository<T> {
+    #private;
+    findDescendants(entity: InstanceType<T>, where: RuleGroup<T>, options?: FindTreeOptions): Observable<InstanceType<T>[]>;
+    countDescendants(entity: InstanceType<T>, where: RuleGroup<T>, options?: FindTreeOptions): Observable<number>;
+    findAncestors(entity: InstanceType<T>, where: RuleGroup<T>, options?: FindTreeOptions): Observable<InstanceType<T>[]>;
+    countAncestors(entity: InstanceType<T>, where: RuleGroup<T>, options?: FindTreeOptions): Observable<number>;
+    /**
+     * 根据 type 计算主动更新缓存策略
+     */
+    merge_cache(type: MutationType, entities: InstanceType<T>[]): void;
+}

package/execute_statement_helper.d.ts

@@ -0,0 +1,7 @@
+import { SQLiteAPI, SQLiteCompatibleType } from './wa-sqlite';
+export type TransactionCallback = (sqlite: SQLiteAPI, db: number) => Promise<any>;
+/**
+ * 执行单行 sql
+ */
+declare const _default: (sqlite3: SQLiteAPI, db: number, sql: string, bindings?: SQLiteCompatibleType[]) => Promise<import('./sqlite.interface').SqliteSuccessResult>;
+export default _default;

package/generate_entity_delete_sql.d.ts

@@ -0,0 +1,9 @@
+import { EntityMetadata, IEntity, IQueryContext } from '@aiao/rxdb';
+/**
+ * Entity remove SQL
+ */
+declare const _default: (metadata: EntityMetadata, entity: IEntity, context?: IQueryContext) => {
+    sql: string;
+    params: `${string}-${string}-${string}-${string}-${string}`[];
+};
+export default _default;

package/generate_entity_find_tree_sql.d.ts

@@ -0,0 +1,41 @@
+import { EntityMetadata, FindTreeOptions, RuleGroup, UUID } from '@aiao/rxdb';
+interface TreeOptions extends FindTreeOptions {
+    count?: boolean;
+    descendants: boolean;
+}
+/**
+ * 生成树查询
+ */
+export declare const generate_tree_base: (metadata: EntityMetadata, entityId: UUID, ruleGroup: RuleGroup<any>, options: TreeOptions) => {
+    sql: string;
+    params: `${string}-${string}-${string}-${string}-${string}`[];
+};
+/**
+ * 查询子孙节点
+ */
+export declare const generate_entity_find_descendants_sql: (metadata: EntityMetadata, entityId: UUID, where: RuleGroup<any>, options?: FindTreeOptions) => {
+    sql: string;
+    params: `${string}-${string}-${string}-${string}-${string}`[];
+};
+/**
+ * 查询祖先节点
+ */
+export declare const generate_entity_find_ancestors_sql: (metadata: EntityMetadata, entityId: UUID, where: RuleGroup<any>, options?: FindTreeOptions) => {
+    sql: string;
+    params: `${string}-${string}-${string}-${string}-${string}`[];
+};
+/**
+ * 查询子孙节点数量
+ */
+export declare const generate_entity_count_descendants_sql: (metadata: EntityMetadata, entityId: UUID, where: RuleGroup<any>, options?: FindTreeOptions) => {
+    sql: string;
+    params: `${string}-${string}-${string}-${string}-${string}`[];
+};
+/**
+ * 查询祖先节点数量
+ */
+export declare const generate_entity_count_ancestors_sql: (metadata: EntityMetadata, entityId: UUID, where: RuleGroup<any>, options?: FindTreeOptions) => {
+    sql: string;
+    params: `${string}-${string}-${string}-${string}-${string}`[];
+};
+export {};

package/generate_entity_insert_sql.d.ts

@@ -0,0 +1,9 @@
+import { EntityMetadata, IEntity, IQueryContext } from '@aiao/rxdb';
+/**
+ * Entity Create SQL
+ */
+declare const _default: (metadata: EntityMetadata, entity: IEntity, context?: IQueryContext) => {
+    sql: string;
+    params: unknown[];
+};
+export default _default;

package/generate_entity_soft_delete_sql.d.ts

@@ -0,0 +1,9 @@
+import { EntityMetadata, IEntity, IQueryContext } from '@aiao/rxdb';
+/**
+ * entity 软删除
+ */
+declare const _default: (metadata: EntityMetadata, entity: IEntity, context?: IQueryContext) => {
+    sql: string;
+    params: unknown[];
+};
+export default _default;

package/generate_entity_update_sql.d.ts

@@ -0,0 +1,9 @@
+import { EntityMetadata, IEntity, IQueryContext } from '@aiao/rxdb';
+/**
+ * 计算更新 entity 的 SQL
+ */
+declare const _default: (metadata: EntityMetadata, entity: IEntity, patch: Partial<IEntity>, context?: IQueryContext) => {
+    sql: string;
+    params: unknown[];
+};
+export default _default;

package/generate_query_find_sql.d.ts

@@ -0,0 +1,30 @@
+import { CountOptions, EntityMetadata, FindAllOptions, FindOneOrFailOptions, FindOptions, RuleGroup } from '@aiao/rxdb';
+import { RxDBAdapterSqlite } from './RxDBAdapterSqlite';
+import { SQLiteCompatibleType } from './wa-sqlite';
+export interface SqlResult {
+    sql: string;
+    params: SQLiteCompatibleType[];
+}
+/**
+ * 生成 ruleGroup sql 查询条件
+ * @param ruleGroup
+ * @param fieldAliasMap
+ * @returns
+ */
+export declare const buildRuleGroup: <RG extends RuleGroup<any, any, any>>(ruleGroup: RG, fieldAliasMap?: Map<string, string>) => string;
+/**
+ * 生成 find 查询
+ */
+export declare const generate_query_find_sql: (adapter: RxDBAdapterSqlite, metadata: EntityMetadata, ruleGroup: RuleGroup<any>, options?: FindOptions) => SqlResult;
+/**
+ * 生成 findAll 查询
+ */
+export declare const generate_query_find_all_sql: (adapter: RxDBAdapterSqlite, metadata: EntityMetadata, ruleGroup: RuleGroup<any>, options?: FindAllOptions) => SqlResult;
+/**
+ * 生成 count 查询
+ */
+export declare const generate_query_count_sql: (adapter: RxDBAdapterSqlite, metadata: EntityMetadata, ruleGroup: RuleGroup<any>, options?: CountOptions) => SqlResult;
+/**
+ * 生成 findOne 查询
+ */
+export declare const generate_query_find_one_sql: (adapter: RxDBAdapterSqlite, metadata: EntityMetadata, ruleGroup: RuleGroup<any>, options?: FindOneOrFailOptions) => SqlResult;

package/generate_table_create_sql.d.ts

@@ -0,0 +1,8 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { RxDBAdapterSqlite } from './RxDBAdapterSqlite';
+/**
+ * 计算创建表的 sql
+ * @param metadata 实体元数据
+ */
+declare const _default: (adapter: RxDBAdapterSqlite, metadata: EntityMetadata) => string;
+export default _default;

package/generate_table_trigger_sql.d.ts

@@ -0,0 +1,8 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { RxDBAdapterSqlite } from './RxDBAdapterSqlite';
+/**
+ * 计算表的触发器
+ * @param metadata 实体元数据
+ */
+declare const _default: (adapter: RxDBAdapterSqlite, entityMetadata: EntityMetadata) => string;
+export default _default;

package/index.d.ts

@@ -0,0 +1,5 @@
+export { RxDBAdapterSqlite } from './RxDBAdapterSqlite';
+export { WA_SQLITE_VFS_LIST, sqliteLoad } from './sqlite-load.utils';
+export type { SqliteOptions } from './sqlite.interface';
+export { RxdbAdapterSqliteError } from './sqlite.utils';
+export { SqliteClient } from './SqliteClient';