gs-idb-pro 0.1.4 → 1.0.0

package/lib/impl.d.ts

@@ -0,0 +1,265 @@
+import { StrOrNum } from 'gs-base/types';
+import { DbQuery } from 'gs-idb-basic/type';
+import { ArrayDbRecord, DataOperationSchema, DbRecord, DbRecordResult, DBSchema, FindFn, GetRowMapper, IChangeManyOption, IChangeRangeArg, ICursorArg, ICursorOption, ICursorResultArg, ICursorRow, IDataOperationSchema, IDataOperatorFactory, IDataOperators, IDataReader, IDataWriter, IDbIterator, IDbIteratorArg, IDbIteratorOption, IDbIteratorParser, IDbMap, IDbNoneKeyPathRecord, IDbQuery, IDbSchema, IDbVersionBounds, IDeleteOption, IDeleteRangeOption, IFilterArg, IFindArg, IFindMapArg, IForEachable, IForEachArg, IForEachResultArg, IGenerateOption, IGetAllArgs, IIDbPro, IInfoTarget, ImportUse, INativeOperationResult, IndexSchema, IPage, IPageArg, IPageInfo, IStoreSchema, IStoreUpgradeable, IUpgradeContext, IUpgradeContextArgs, IValidDataOperationSchema, NativeReader, NativeTarget, NativeWriter, OperationTarget, ReadCallFn, RequiredDbNoneKeyPathRecord, SaveRowMapper, StoreSchema, ValueCallFn, ValueModifyFn, VersionValidateFn, VoidCallFn, VoidModifyFn, WriteCallFn } from './type.d.ts';
+
+interface IOpenCursorArg extends ICursorOption {
+  fn: (cursor: IDBCursorWithValue) => void | false | Promise<void | false>;
+}
+declare class DataOperationBase implements IValidDataOperationSchema<any>, IForEachable {
+  #private;
+  readonly idbPro?: IIDbPro;
+  readonly target: any;
+  constructor(schema: IValidDataOperationSchema<any>, db?: IIDbPro);
+  get storeName(): string;
+  get storeSchema(): IStoreSchema;
+  get factory(): IDataOperatorFactory;
+  get nativeStore(): IDBObjectStore | undefined;
+  get keyPath(): string | string[] | null | undefined;
+  forEach<T = any>(fn: VoidCallFn<T> | IForEachArg<T>): Promise<void>;
+  forEach<R = DbRecordResult, T = any>(fn: ValueCallFn<T, R> | IForEachResultArg<T, R>, returns: true): Promise<R[]>;
+  protected tx(writable?: false): Promise<INativeOperationResult<NativeTarget>>;
+  protected tx(writable: true): Promise<INativeOperationResult<IDBObjectStore>>;
+  protected tx<T>(fn: ReadCallFn<T>): Promise<T>;
+  protected tx<T>(writable: false, fn?: ReadCallFn<T>): Promise<T>;
+  protected tx<T>(writable: true, fn?: WriteCallFn<T>, rollbackOnError?: boolean): Promise<T>;
+  protected openCursor(arg: IOpenCursorArg, writable?: boolean): Promise<void>;
+  protected cursorVoid({ query, direction, preSkip, startKey, startPrimaryKey, fn }: ICursorArg, writable: boolean): Promise<void>;
+  protected cursorResult({ query, direction, preSkip, startKey, startPrimaryKey, fn, mapper: mpr }: ICursorResultArg, writable: boolean): Promise<any>;
+}
+
+declare class DataOperators<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any> implements IDataOperators<S1, S2, S3, S4, S5> {
+  #private;
+  readonly idbPro: IIDbPro;
+  readonly schemas: IValidDataOperationSchema<IInfoTarget>[];
+  constructor(idbPro: IIDbPro, schemas: IValidDataOperationSchema<IInfoTarget>[]);
+  get storeNames(): string[];
+  read<Rtn = any>(fn: (s1: NativeReader<S1>, s2: NativeReader<S2>, s3: NativeReader<S3>, s4: NativeReader<S4>, s5: NativeReader<S5>, ...stores: NativeReader[]) => (Promise<Rtn> | Rtn)): Promise<Rtn>;
+  write<Rtn = any>(fn: (s1: NativeWriter<S1>, s2: NativeWriter<S2>, s3: NativeWriter<S3>, s4: NativeWriter<S4>, s5: NativeWriter<S5>, ...stores: NativeWriter[]) => (Promise<Rtn> | Rtn), rollbackOnError?: boolean): Promise<Rtn>;
+  export(): Promise<Record<string, any[]>>;
+  import(data: Record<string, any[]>, returns?: false, use?: ImportUse): Promise<void>;
+  import(data: Record<string, any[]>, returns?: true, use?: ImportUse): Promise<Record<string, any[]>>;
+  protected tx(method: keyof Pick<IDataOperatorFactory, 'newReader' | 'newWriter'>, fn: Function, writable?: boolean, rollbackOnError?: boolean): Promise<any>;
+}
+
+declare class DataReader<Row, Tar extends OperationTarget = OperationTarget> extends DataOperationBase implements IDataReader<Row, Tar> {
+  all(query?: IDbQuery, limit?: number): Promise<Row[]>;
+  all(args?: IGetAllArgs): Promise<Row[]>;
+  count(): Promise<number>;
+  count(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<number>;
+  count(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<number>;
+  count(arg: IFindArg<Row>): Promise<number>;
+  get(key: IDbQuery): Promise<Row | undefined>;
+  getMany(keys: IDbQuery[], excludeEmpty?: boolean): Promise<Row[]>;
+  getRange(query: IDbQuery, direction?: IDBCursorDirection): Promise<DbRecordResult<Row>[]>;
+  getRangeMany(keys: IDbQuery[], direction?: IDBCursorDirection): Promise<DbRecordResult<Row>[]>;
+  index(name: string): IDataReader<Row, Tar>;
+  index(name: string, writable: true): IDataWriter<Row, Tar>;
+  asStore(): IDataReader<Row, Tar>;
+  asStore(writable: true): IDataWriter<Row, Tar>;
+  batchRead<R = any>(fn: (reader: IDataReader<Row, NativeTarget>) => Promise<void | R>): Promise<R>;
+  iterator(query: IDbQuery, direction?: IDBCursorDirection): AsyncIterable<Row>;
+  iterator(arg: IDbIteratorArg): AsyncIterable<Row>;
+  filter(): Promise<Row[]>;
+  filter<R = ArrayDbRecord<Row>>(args: IFilterArg<R, Row>): Promise<R[]>;
+  filter(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row>[]>;
+  filter(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row>[]>;
+  filter(arg1?: IDbQuery | FindFn<Row> | IFilterArg<Row>, arg2?: IDBCursorDirection | FindFn<Row>, arg3?: IDBCursorDirection, limit?: number): Promise<ArrayDbRecord<Row>[]>;
+  find(): Promise<Row | undefined>;
+  find(query: IDbQuery | FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row> | undefined>;
+  find(query: IDbQuery, fn: FindFn<Row>, direction?: IDBCursorDirection): Promise<ArrayDbRecord<Row> | undefined>;
+  find<R = ArrayDbRecord<Row>>(args: IFindMapArg<R, Row>): Promise<Row | undefined>;
+  page<R = ArrayDbRecord<Row>>(): Promise<IPage<R, Row>>;
+  page<R = ArrayDbRecord<Row>>(arg: IPageArg<R, Row> | IPageInfo<R, Row>, page?: number): Promise<IPage<R, Row>>;
+  nextPage<R = Row>(info: IPageInfo<R, Row>): Promise<IPage<R, Row>>;
+  export<R = ArrayDbRecord<Row>>(): Promise<ArrayDbRecord<R>[]>;
+  export<R = ArrayDbRecord<Row>>(query: IDbQuery | FindFn<Row>): Promise<ArrayDbRecord<R>[]>;
+  export<R = ArrayDbRecord<Row>>(query: IDbQuery, fn: FindFn<Row>): Promise<ArrayDbRecord<R>[]>;
+  asMap<Key extends StrOrNum = StrOrNum>(): IDbMap<Key, Row, Tar>;
+  protected createOperator(target: OperationTarget, writable?: boolean): any;
+}
+
+declare class DataWriter<Row, Tar extends OperationTarget = OperationTarget> extends DataReader<Row, Tar> implements IDataWriter<Row, Tar> {
+  add(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
+  addMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
+  addMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
+  addOrSkip(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
+  addOrSkipMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
+  addOrSkipMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
+  replace(record: DbRecord<Row>): Promise<DbRecordResult<Row>>;
+  replaceMany(records: DbRecord<Row>[], returns?: false): Promise<void>;
+  replaceMany(records: DbRecord<Row>[], returns: true): Promise<DbRecordResult<Row>[]>;
+  change(record: DbRecord<Partial<Row>>, throwIfMissing?: boolean): Promise<DbRecordResult<Row> | undefined>;
+  changeMany(records: DbRecord<Partial<Row>>[], returns?: false): Promise<void>;
+  changeMany(records: DbRecord<Partial<Row>>[], returns: true): Promise<(DbRecordResult<Row> | undefined)[]>;
+  changeMany(records: DbRecord<Partial<Row>>[], option: IChangeManyOption<false | undefined>): Promise<void>;
+  changeMany(records: DbRecord<Partial<Row>>[], option: IChangeManyOption<true>): Promise<(DbRecordResult<Row> | undefined)[]>;
+  addOrChange(record: DbRecord<Partial<Row>>): Promise<DbRecordResult<Row> | undefined>;
+  addOrChangeMany(records: DbRecord<Partial<Row>>[], returns?: false): Promise<void>;
+  addOrChangeMany(records: DbRecord<Partial<Row>>[], returns: true): Promise<DbRecordResult<Row>[]>;
+  delete(key: IDbQuery, returns?: false): Promise<void>;
+  delete(key: IDbQuery, returns: true): Promise<DbRecordResult<Row>>;
+  delete(key: IDbQuery, option: IDeleteOption<false | undefined>): Promise<void>;
+  delete(key: IDbQuery, option: IDeleteOption<true>): Promise<DbRecordResult<Row>>;
+  deleteMany(keys: IDbQuery[], returns?: false): Promise<void>;
+  deleteMany(keys: IDbQuery[], returns: true): Promise<DbRecordResult<Row>[]>;
+  deleteMany(key: IDbQuery, option: IDeleteOption<false | undefined>): Promise<void>;
+  deleteMany(key: IDbQuery, option: IDeleteOption<true>): Promise<DbRecordResult<Row>[]>;
+  deleteRange(key: IDbQuery, returns?: false): Promise<void>;
+  deleteRange(key: IDbQuery, returns: true): Promise<DbRecordResult<Row>[]>;
+  deleteRange(key: IDbQuery, option: IDeleteRangeOption<false | undefined>): Promise<void>;
+  deleteRange(key: IDbQuery, option: IDeleteRangeOption<true>): Promise<DbRecordResult<Row>[]>;
+  deleteRangeMany(keys: IDbQuery[], returns?: false): Promise<void>;
+  deleteRangeMany(keys: IDbQuery[], returns: true): Promise<DbRecordResult<Row>[][]>;
+  deleteRangeMany(keys: IDbQuery[], option: IDeleteRangeOption<false | undefined>): Promise<void>;
+  deleteRangeMany(keys: IDbQuery[], option: IDeleteRangeOption<true>): Promise<DbRecordResult<Row>[][]>;
+  changeRange(arg: DbRecord<Partial<Row>> | IChangeRangeArg<Row>, returns?: false): Promise<void>;
+  changeRange(arg: DbRecord<Partial<Row>> | IChangeRangeArg<Row>, returns: true): Promise<DbRecordResult<Row>[]>;
+  changeRangeMany(args: DbRecord<Partial<Row>> | IChangeRangeArg<Row>[], returns?: false): Promise<void>;
+  changeRangeMany(args: DbRecord<Partial<Row>> | IChangeRangeArg<Row>[], returns: true): Promise<DbRecordResult<Row>[][]>;
+  cursor(option?: ICursorOption): AsyncIterable<ICursorRow>;
+  cursor<Val extends Row = Row>(fn: VoidModifyFn<Val> | ICursorArg<Val>): Promise<void>;
+  cursor<Rtn = DbRecordResult<Row>, Val extends Row = Row>(fn: ValueModifyFn<Val, Rtn> | ICursorResultArg<Val, Rtn>, returns: true): Promise<Rtn[]>;
+  batchWrite<R = any>(fn: (writer: IDataWriter<Row, NativeTarget>) => Promise<void | R>, rollbackOnError?: boolean): Promise<R>;
+  protected changeByPk({ pk, record, fn, requiredPk, getOld, requiredOld, saveMapper, getMapper }: {
+    pk?: IDbQuery;
+    record?: DbRecord<Partial<Row>>;
+    fn: (store: IDBObjectStore, pk: DbQuery, newValue: any, oldValue: any, keyPath?: string | string[]) => void | [Row, DbQuery?] | Promise<void | [Row, DbQuery?]>;
+    requiredPk?: boolean;
+    getOld?: boolean;
+    requiredOld?: boolean;
+    saveMapper?: SaveRowMapper<any, any>;
+    getMapper?: GetRowMapper<any, any>;
+  }): any;
+}
+
+declare class DbIterator<T> extends DataOperationBase implements IDbIterator<T> {
+  direction: IDBCursorDirection;
+  query: IDbQuery;
+  writable: boolean;
+  parser: IDbIteratorParser;
+  endsWithNull: boolean;
+  preSkip?: number;
+  startKey?: IDBValidKey;
+  startPrimaryKey?: IDBValidKey;
+  constructor(schema: IValidDataOperationSchema<any>, db?: IIDbPro, option?: IDbIteratorOption<T>);
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+declare class DbMap<K extends StrOrNum = StrOrNum, V = any, Tar extends OperationTarget = OperationTarget> extends DataOperationBase implements IDbMap<K, V, Tar> {
+  get size(): Promise<number>;
+  delete(key: K): Promise<void>;
+  batch<R = any, T extends V = V>(fn: (map: IDbMap<K, T, NativeTarget>) => (Promise<R> | R)): Promise<R>;
+  asStore(): IDataReader<V, Tar>;
+  asStore(writable: true): IDataWriter<V, Tar>;
+  entries<T extends V = V>(): AsyncIterable<[K, T]>;
+  get<T extends V = V>(key: K, defaultValue?: T): Promise<T | undefined>;
+  getMany<T extends V = V>(keys: K[]): Promise<(T | undefined)[]>;
+  has(key: K): Promise<boolean>;
+  keys(): AsyncIterable<K>;
+  set<T extends V = V>(key: K, value: T): Promise<void>;
+  setMany<T extends V = V>(values: [K, V][]): Promise<void>;
+  values<T extends V = V>(): AsyncIterable<T>;
+}
+
+declare function dbStore<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(schema: StoreSchema): RT;
+declare function dbStore<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(schema: IDataOperationSchema): RT;
+declare function dbStore<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema, index: IndexSchema): RT;
+declare function dbMap<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: RequiredDbNoneKeyPathRecord<V, K>[]): IDbMap<K, V, IInfoTarget>;
+declare function dbMap<K extends StrOrNum = StrOrNum, V = any>(defaultData?: RequiredDbNoneKeyPathRecord<V, K>[], storeName?: string): IDbMap<K, V, IInfoTarget>;
+declare function dbStores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): Rtn;
+/**
+ * 释放默认数据库实例（如果存在）
+ */
+declare function releaseDefaultDB(): void;
+
+declare class IDbPro implements IIDbPro {
+  #private;
+  constructor(schema: DBSchema, skipPreOpenValidation?: true);
+  /**
+   * 默认实例
+   */
+  static get defaultDb(): IIDbPro;
+  get initialized(): boolean;
+  get schema(): IDbSchema;
+  get storeNames(): string[];
+  get factory(): IDataOperatorFactory;
+  /**
+   * 释放默认数据库实例（如果存在）
+   */
+  static releaseDefaultDB(): void;
+  /**
+   * 从已经存在的`name`数据库中打开
+   * @warning 该方法仅用于不需要修改原有数据库结构的场景
+   * - 如果需要修改，请使用 `generateDbSchema()` 从现有数据库生成配置，且适当修改后重新打开
+   * @param name
+   */
+  static openExistDb(name: string): Promise<IIDbPro>;
+  static store<T = any, RT extends IDataWriter<T> = IDataWriter<T>>(store: StoreSchema): RT;
+  static store<T = any, RT extends IDataWriter<T> = IDataWriter<T>>(operation: IDataOperationSchema): RT;
+  static store<T = any, RT extends IDataWriter<T> = IDataWriter<T>>(store: StoreSchema, index: IndexSchema): RT;
+  static stores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): IDataOperators<Rtn>;
+  static map<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: (IDbNoneKeyPathRecord<V, K> | [V, K])[]): IDbMap<K, V, IInfoTarget>;
+  static map<K extends StrOrNum = StrOrNum, V = any>(defaultData?: (IDbNoneKeyPathRecord<V, K> | [V, K])[], storeName?: string): IDbMap<K, V, IInfoTarget>;
+  openNativeDb(): Promise<IDBDatabase>;
+  store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema): RT;
+  store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(operation: IDataOperationSchema): RT;
+  store<T = any, RT extends IDataWriter<T, IInfoTarget> = IDataWriter<T, IInfoTarget>>(store: StoreSchema, index: IndexSchema): RT;
+  stores<S1 = any, S2 = any, S3 = any, S4 = any, S5 = any, Rtn extends IDataOperators = IDataOperators<S1, S2, S3, S4, S5>>(schemas: DataOperationSchema[]): Rtn;
+  initSchema(): IDbSchema;
+  traceSchema(showFn?: boolean): Promise<void>;
+  map<K extends StrOrNum = StrOrNum, V = any>(storeName?: string, defaultData?: RequiredDbNoneKeyPathRecord<V, K>[]): IDbMap<K, V, IInfoTarget>;
+  map<K extends StrOrNum = StrOrNum, V = any>(defaultData?: RequiredDbNoneKeyPathRecord<V, K>[], storeName?: string): IDbMap<K, V, IInfoTarget>;
+  export(): Promise<Record<string, any[]>>;
+  import(data: Record<string, any[]>, returns?: false, use?: ImportUse): Promise<void>;
+  import(data: Record<string, any[]>, returns?: true, use?: ImportUse): Promise<Record<string, any[]>>;
+  getStoreSchema(name: string): IStoreSchema;
+}
+
+declare function parseIDbQuery(query: IDbQuery | IDBKeyRange | undefined | null): IDBValidKey | IDBKeyRange | null | undefined;
+declare function isIDbQuery(query: any): boolean;
+
+declare class StoreUpgradeable<T = any> implements IStoreUpgradeable<T> {
+  #private;
+  readonly upgradeContext: IUpgradeContext;
+  readonly storeSchema: IStoreSchema;
+  readonly nativeStore: IDBObjectStore;
+  constructor(upgradeContext: IUpgradeContext, storeSchema: IStoreSchema, nativeStore: IDBObjectStore);
+  get writer(): IDataWriter<T>;
+  add(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
+  add(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>>;
+  addOrChange(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
+  addOrChange(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>[]>;
+  call<R = any>(versionBounds: IDbVersionBounds, fn: (store: IDataWriter, upgradeContext?: IUpgradeContext) => (Promise<R> | R)): Promise<R>;
+  replace(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns?: false): Promise<void>;
+  replace(versionBounds: IDbVersionBounds, values: DbRecord<T>[], returns: true): Promise<DbRecord<T>[]>;
+}
+
+declare class UpgradeContext implements IUpgradeContext {
+  #private;
+  readonly database: IDBDatabase;
+  readonly newVersion: number;
+  readonly oldVersion: number;
+  readonly dbSchema: Readonly<IDbSchema>;
+  readonly transaction: IDBTransaction;
+  constructor(args: IUpgradeContextArgs);
+  deleteStoreIfExists(storeName: string): void;
+  destroy(): void;
+  store<T = any>(storeName: string): IStoreUpgradeable<T>;
+  versionIn({ oldMin, oldMax, newMax, newMin }: IDbVersionBounds): boolean;
+}
+
+declare const validateSchemaWithDefaults: IDbSchema['validateSchemaWithDefaults'];
+
+/**
+ * 版本差异验证器
+ * @param context
+ */
+declare const versionDiffValidate: VersionValidateFn;
+
+declare const versionSameValidate: VersionValidateFn;
+
+declare function generateDbSchema(db: string, option?: IGenerateOption<undefined | false>): Promise<IDbSchema>;
+declare function generateDbSchema(db: string, option: IGenerateOption<true | number>): Promise<string>;
+
+export { DataOperationBase, DataOperators, DataReader, DataWriter, DbIterator, DbMap, dbMap, dbStore, dbStores, generateDbSchema, IDbPro, isIDbQuery, parseIDbQuery, releaseDefaultDB, StoreUpgradeable, UpgradeContext, validateSchemaWithDefaults, versionDiffValidate, versionSameValidate };
+export type { IOpenCursorArg };

package/lib/{index.js → impl.mjs}

@@ -1,34 +1,13 @@
-import { isObject, copyFields, isFunction, deepFreeze, isNumber, asyncMap, isString, asyncForEach, isBoolean, destroyRecords, destroy, logJson, toJson, copyObject } from "gs-base";
-import { isDbQueryOrNull, requestDbResult, Bool, findExistDb, openDb, readTx, DefaultDbName, DefaultStorageStoreName } from "gs-idb-basic";
-const Save = Symbol("save"), Delete = Symbol("delete"), DbIteratorParsers = Object.freeze({
-  key: ({ primaryKey: value }) => ({ value }),
-  value: ({ value }) => ({ value }),
-  keyValue: ({ primaryKey: key, value }) => ({ value: [key, value] })
-});
-function parseDbNoneKeyPathRecord(record) {
-  if (Array.isArray(record))
-    return { key: record[1], value: record[0] };
-  if ("value" in record) {
-    const { key, value } = record;
-    return { key, value };
-  }
-  throw new Error(`not include value in invalid DBRecord：${JSON.stringify(record)}`);
-}
-const Break = Symbol("break"), Finished = Symbol("finished"), Continue = Symbol("continue"), ContinueKey = Symbol("continue key"), NextKey = Symbol("next key"), ContinuePrimaryKey = Symbol("continue primary key"), NextPrimaryKey = Symbol("next primary key");
-function isNativeTarget(target) {
-  return target instanceof IDBObjectStore || target instanceof IDBIndex;
-}
-const defaultStoreSchemaTemplate = Object.freeze({
-  keyPath: "id",
-  autoIncrement: !0,
-  addedTimeField: !0,
-  updatedTimeField: !0
-}), defaultSpecialFields = Object.freeze({
-  addedTimeField: "added_at",
-  softDeletedField: "deleted",
-  updatedCountField: "updated_count",
-  updatedTimeField: "updated_at"
-}), toNum = (v) => v instanceof Date ? v.getTime() : v;
+import { isNativeTarget, Save, Delete, ContinuePrimaryKey, ContinueKey, Break, Finished, NextKey, NextPrimaryKey, DbIteratorParsers, Continue, parseDbNoneKeyPathRecord, defaultStoreSchemaTemplate, defaultSpecialFields } from './type.mjs';
+import { isObject, isFunction, isNumber, isString, isBoolean } from 'gs-base/types';
+import { requestDbResult } from 'gs-idb-basic/store';
+import { isDbQueryOrNull, Bool } from 'gs-idb-basic/type';
+import { copyFields, deepFreeze, asyncMap, asyncForEach, destroyRecords, destroy, copyObject } from 'gs-base/basic';
+import { logJson, toJson } from 'gs-base/json';
+import { readTx } from 'gs-idb-basic/tx';
+import { findExistDb, openDb } from 'gs-idb-basic/db';
+import { DefaultDbName, DefaultStorageStoreName } from 'gs-idb-basic/storage';
+const toNum = (v) => v instanceof Date ? v.getTime() : v;
 function parseIDbQuery(query) {
   if (isDbQueryOrNull(query) || !isObject(query))
     return query;
@@ -1048,7 +1027,7 @@ async function upgradeDb(dbSchema, database, e, request) {
 function validateDataOperationSchema(schema, dbSchema) {
   return Object.isFrozen(dbSchema) ? frozenValidate(schema) : initValidate(schema, dbSchema);
 }
-function frozenValidate(schema, dbSchema) {
+function frozenValidate(schema) {
   let { store, index } = schema;
   const target = { store: isString(store) ? store : store.name };
   return index && (target.index = isString(index) ? index : index.name), {
@@ -1268,36 +1247,25 @@ function generateRoot(db, specialFields) {
     }
   });
 }
-var generateDbSchema$1 = /* @__PURE__ */ Object.freeze({ __proto__: null, generateDbSchema });
+var generateDbSchema$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  generateDbSchema
+});
 export {
-  Break,
-  Continue,
-  ContinueKey,
-  ContinuePrimaryKey,
   DataOperationBase,
   DataOperators,
   DataReader,
   DataWriter,
   DbIterator,
-  DbIteratorParsers,
   DbMap,
-  Delete,
-  Finished,
   IDbPro,
-  NextKey,
-  NextPrimaryKey,
-  Save,
   StoreUpgradeable,
   UpgradeContext,
   dbMap,
   dbStore,
   dbStores,
-  defaultSpecialFields,
-  defaultStoreSchemaTemplate,
   generateDbSchema,
   isIDbQuery,
-  isNativeTarget,
-  parseDbNoneKeyPathRecord,
   parseIDbQuery,
   releaseDefaultDB,
   validateSchemaWithDefaults,