idb-ts 3.14.0 → 3.16.0

package/lib/index.d.ts

@@ -88,10 +88,12 @@ declare class QueryBuilder<T> {
     limit(n: number): this;
     offset(n: number): this;
     useIndex(indexName: string): this;
-    range(start: any, end: any): this;
+    range(start: IDBValidKey | undefined, end: IDBValidKey | undefined): this;
     groupBy<K extends QueryFieldKey<T>>(field: K): QueryBuilder<T> & {
         count(): Promise<GroupCountResult<T, K>>;
     };
+    clone(): QueryBuilder<T>;
+    reset(): this;
     private loadCandidates;
     private createReadRequest;
     private matchesClause;
@@ -110,7 +112,7 @@ declare class QueryBuilder<T> {
 }
 interface KeyPathOptions {
     autoIncrement?: boolean;
-    generator?: 'uuid' | 'timestamp' | 'random' | ((item?: any) => string | number);
+    generator?: 'uuid' | 'uuidv4' | 'uuidv6' | 'timestamp' | 'random' | ((item?: any) => string | number);
 }
 interface RetentionPolicyOptions {
     seconds: number;
@@ -127,6 +129,9 @@ interface KeyPathMetadata {
     options?: KeyPathOptions;
 }
 declare class KeyGenerators {
+    private static getRandomValues;
+    static uuidV4(): string;
+    static uuidV6(): string;
     static uuid(): string;
     static timestamp(): number;
     static random(): string;
@@ -135,6 +140,7 @@ declare function KeyPath(options?: KeyPathOptions): PropertyDecorator;
 declare function CompositeKeyPath(fields: string[], options?: KeyPathOptions): ClassDecorator;
 declare function Index(options?: IDBIndexParameters): PropertyDecorator;
 declare function Validate<T = any>(predicate: (value: any, item: T) => boolean, message: string): PropertyDecorator;
+declare function Calculated<T = any>(compute: (item: T) => any): PropertyDecorator;
 declare function RetentionPolicy(options: RetentionPolicyOptions): ClassDecorator;
 interface DataClassOptions {
     version?: number;
@@ -151,10 +157,11 @@ interface EntityRepository<T> {
     deleteWhere(predicate: (query: QueryBuilder<T>) => QueryBuilder<T> | void): Promise<void>;
     list(): Promise<T[]>;
     listPaginated(page: number, pageSize: number): Promise<T[]>;
-    findByIndex(indexName: string, value: any): Promise<T[]>;
-    findOneByIndex(indexName: string, value: any): Promise<T | undefined>;
+    findByIndex(indexName: string, value: IDBValidKey): Promise<T[]>;
+    findOneByIndex(indexName: string, value: IDBValidKey): Promise<T | undefined>;
     count(): Promise<number>;
-    exists(key: string): Promise<boolean>;
+    getKeys(): Promise<IDBValidKey[]>;
+    exists(key: string | string[] | number): Promise<boolean>;
     clear(): Promise<void>;
     query(): QueryBuilder<T>;
 }
@@ -164,17 +171,27 @@ interface TransactionController {
 }
 type TransactionalDatabase<T extends Record<string, EntityRepository<any>>> = T & TransactionController;
 type DatabaseWithRepositories<T extends Record<string, any>> = Database & T;
+interface SyncAdapter {
+    push(entityName: string, records: unknown[]): Promise<void>;
+    pull(entityName: string): Promise<unknown[] | undefined>;
+}
 declare class Database {
     private dbName;
     private classes;
+    private schemas;
+    private migrator;
     private db;
     private entityRepositories;
     private dbVersion;
     private retentionTimer;
     private retentionCleanupRunning;
     private retentionPolicies;
+    private printEnabled;
+    private printDebug;
+    private printError;
     private constructor();
-    private calculateDatabaseVersion;
+    private readPersistedVersion;
+    private openConnection;
     static build<T extends Record<string, EntityRepository<any>>>(dbName: string, classes: Function[]): Promise<DatabaseWithRepositories<T>>;
     private initDB;
     private generateEntityRepositories;
@@ -187,11 +204,17 @@ declare class Database {
     private createTransactionHandle;
     beginTransaction(entityNames: string[], mode?: IDBTransactionMode): Promise<TransactionalDatabase<Record<string, EntityRepository<any>>>>;
     transaction<T>(callback: (tx: TransactionalDatabase<Record<string, EntityRepository<any>>>) => Promise<T> | T): Promise<T>;
+    exportDatabase(): Promise<Record<string, unknown[]>>;
+    importDatabase(dump: Record<string, unknown[]>, options?: {
+        clear?: boolean;
+    }): Promise<void>;
+    pushTo(adapter: SyncAdapter): Promise<void>;
+    pullFrom(adapter: SyncAdapter): Promise<void>;
     close(): void;
     getAvailableEntities(): string[];
     getDatabaseVersion(): number;
     getEntityVersions(): Map<string, number>;
     getEntityVersion(entityName: string): number | undefined;
 }
-export { Database, KeyPath, CompositeKeyPath, DataClass, Index, Validate, RetentionPolicy, EntityRepository, KeyGenerators, };
-export type { DatabaseWithRepositories, DataClassOptions, KeyPathOptions, KeyPathMetadata, RetentionPolicyOptions, RetentionPolicyMetadata, };
+export { Database, KeyPath, CompositeKeyPath, DataClass, Index, Validate, Calculated, RetentionPolicy, EntityRepository, KeyGenerators, };
+export type { DatabaseWithRepositories, DataClassOptions, KeyPathOptions, KeyPathMetadata, RetentionPolicyOptions, RetentionPolicyMetadata, SyncAdapter, };