dexie 3.2.1-beta.1 → 4.0.0-alpha.1

package/README.md

@@ -44,7 +44,38 @@ Dexie provides a neat database API with a well thought-through API design, robus
  </head>
 </html>
 ```
-Yes, it's that simple.
+Yes, it's that simple. 
+
+An equivalent modern version (works in all modern browsers):
+
+```html
+<!doctype html>
+<html>
+ <head>
+  <script type="module">
+   import Dexie from "https://unpkg.com/dexie@latest/dist/modern/dexie.mjs";
+   //
+   // Declare Database
+   //
+   const db = new Dexie("FriendDatabase");
+   db.version(1).stores({
+     friends: "++id,name,age"
+   });
+
+   //
+   // Manipulate and Query Database
+   //
+   try {
+     await db.friends.add({name: "Josephine", age: 21});
+     const youngFriends = await db.friends.where("age").below(25).toArray();
+     alert (`My young friends: ${JSON.stringify(youngFriends)}`);
+   } catch (e) {
+     alert (`Error: ${e}`);
+   }
+  </script>
+ </head>
+</html>
+```
 
 [Tutorial](https://dexie.org/docs/Tutorial)
 
@@ -110,40 +141,10 @@ update(key: Key, changes: { [keyPath: string]: any }): Promise;
 ```
 This is a mix of methods from [WhereClause](https://dexie.org/docs/WhereClause/WhereClause), [Table](https://dexie.org/docs/Table/Table) and [Collection](https://dexie.org/docs/Collection/Collection). Dive into the [API reference](https://dexie.org/docs/API-Reference) to see the details.
 
-#### Hello World (ES2016 / ES7)
-```js
-import Dexie from 'dexie';
-
-//
-// Declare Database
-//
-const db = new Dexie("FriendDatabase");
-db.version(1).stores({ friends: "++id,name,age" });
-
-db.transaction('rw', db.friends, async() => {
-
-    // Make sure we have something in DB:
-    if ((await db.friends.where({name: 'Josephine'}).count()) === 0) {
-        const id = await db.friends.add({name: "Josephine", age: 21});
-        alert (`Addded friend with id ${id}`);
-    }
-
-    // Query:
-    const youngFriends = await db.friends.where("age").below(25).toArray();
-
-    // Show result:
-    alert ("My young friends: " + JSON.stringify(youngFriends));
-
-}).catch(e => {
-    alert(e.stack || e);
-});
-
-```
-
 #### Hello World (Typescript)
 
 ```js
-import Dexie from 'dexie';
+import Dexie, { Table } from 'dexie';
 
 interface Friend {
     id?: number;
@@ -155,14 +156,13 @@ interface Friend {
 // Declare Database
 //
 class FriendDatabase extends Dexie {
-    public friends: Dexie.Table<Friend, number>; // id is number in this case
+    public friends!: Table<Friend, number>; // id is number in this case
 
     public constructor() {
         super("FriendDatabase");
         this.version(1).stores({
             friends: "++id,name,age"
         });
-        this.friends = this.table("friends");
     }
 }
 
@@ -212,13 +212,21 @@ Download
 --------
 For those who don't like package managers, here's the download links:
 
-https://unpkg.com/dexie@latest/dist/dexie.js
+### Legacy:
+https://unpkg.com/dexie@latest/dist/dexie.min.js
 
-https://unpkg.com/dexie@latest/dist/dexie.js.map
+https://unpkg.com/dexie@latest/dist/dexie.min.js.map
 
+### Modern:
+https://unpkg.com/dexie@latest/dist/modern/dexie.min.mjs
+
+https://unpkg.com/dexie@latest/dist/modern/dexie.min.mjs.map
+
+### Typings:
 https://unpkg.com/dexie@latest/dist/dexie.d.ts
 
 
+
 Contributing
 ============
 Here is a little cheat-sheet for how to symlink your app's `node_modules/dexie` to a place where you can edit the source, version control your changes and create pull requests back to Dexie. Assuming you've already ran `npm install dexie --save` for the app your are developing.

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 3.2.1-beta.1, Fri Nov 19 2021
+ * Version 4.0.0-alpha.1, Sun Dec 19 2021
  *
  * https://dexie.org
  *
@@ -51,7 +51,78 @@ export interface DexieEventSet {
 		]);
 	}): DexieEvent;
 }
-export type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
+export interface TransactionEvents extends DexieEventSet {
+	(eventName: "complete", subscriber: () => any): void;
+	(eventName: "abort", subscriber: () => any): void;
+	(eventName: "error", subscriber: (error: any) => any): void;
+	complete: DexieEvent;
+	abort: DexieEvent;
+	error: DexieEvent;
+}
+export interface Transaction {
+	db: Dexie;
+	active: boolean;
+	mode: IDBTransactionMode;
+	//tables: { [type: string]: Table<any, any> }; Deprecated since 2.0. Obsolete from v3.0.
+	storeNames: Array<string>;
+	parent?: Transaction;
+	on: TransactionEvents;
+	abort(): void;
+	table(tableName: string): Table<any, any>;
+	table<T>(tableName: string): Table<T, any>;
+	table<T, Key>(tableName: string): Table<T, Key>;
+}
+export interface CreatingHookContext<T, Key> {
+	onsuccess?: (primKey: Key) => void;
+	onerror?: (err: any) => void;
+}
+export interface UpdatingHookContext<T, Key> {
+	onsuccess?: (updatedObj: T) => void;
+	onerror?: (err: any) => void;
+}
+export interface DeletingHookContext<T, Key> {
+	onsuccess?: () => void;
+	onerror?: (err: any) => void;
+}
+export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet {
+	(eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	(eventName: "reading", subscriber: (obj: T) => T | any): void;
+	(eventName: "updating", subscriber: (this: UpdatingHookContext<T, TKey>, modifications: Object, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	(eventName: "deleting", subscriber: (this: DeletingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	creating: DexieEvent;
+	reading: DexieEvent;
+	updating: DexieEvent;
+	deleting: DexieEvent;
+}
+export type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
+export interface WhereClause<T = any, TKey = IndexableType> {
+	above(key: any): Collection<T, TKey>;
+	aboveOrEqual(key: any): Collection<T, TKey>;
+	anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
+	anyOf(...keys: Array<IndexableType>): Collection<T, TKey>;
+	anyOfIgnoreCase(keys: string[]): Collection<T, TKey>;
+	anyOfIgnoreCase(...keys: string[]): Collection<T, TKey>;
+	below(key: any): Collection<T, TKey>;
+	belowOrEqual(key: any): Collection<T, TKey>;
+	between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey>;
+	equals(key: IndexableType): Collection<T, TKey>;
+	equalsIgnoreCase(key: string): Collection<T, TKey>;
+	inAnyRange(ranges: ReadonlyArray<{
+		0: any;
+		1: any;
+	}>, options?: {
+		includeLowers?: boolean;
+		includeUppers?: boolean;
+	}): Collection<T, TKey>;
+	startsWith(key: string): Collection<T, TKey>;
+	startsWithAnyOf(prefixes: string[]): Collection<T, TKey>;
+	startsWithAnyOf(...prefixes: string[]): Collection<T, TKey>;
+	startsWithIgnoreCase(key: string): Collection<T, TKey>;
+	startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey>;
+	startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey>;
+	noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
+	notEqual(key: IndexableType): Collection<T, TKey>;
+}
 export interface PromiseExtendedConstructor extends PromiseConstructor {
 	readonly prototype: PromiseExtended;
 	new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): PromiseExtended<T>;
@@ -285,9 +356,17 @@ export interface PromiseExtended<T = any> extends Promise<T> {
 	finally<U>(onFinally?: () => U | PromiseLike<U>): PromiseExtended<T>;
 	timeout(ms: number, msg?: string): PromiseExtended<T>;
 }
-export type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
+export type KeyPaths<T> = {
+	[P in keyof T]: P extends string ? T[P] extends any[] ? P : T[P] extends (...args: any[]) => any // Method
+	 ? never : T[P] extends object ? P | `${P}.${KeyPaths<T[P]>}` : P : never;
+}[keyof T];
+export type Extract<T, P> = P extends keyof T ? T[P] : void;
+export type KeyPathValue<T, PATH> = PATH extends `${infer R}.${infer S}` ? R extends keyof T ? Extract<T[R], S> : void : Extract<T, PATH>;
+export type UpdateSpec<T> = {
+	[KP in KeyPaths<T>]?: KeyPathValue<T, KP>;
+};
 export interface Collection<T = any, TKey = IndexableType> {
-	//db: Database;
+	db: Dexie;
 	and(filter: (x: T) => boolean): Collection<T, TKey>;
 	clone(props?: Object): Collection<T, TKey>;
 	count(): PromiseExtended<number>;
@@ -335,91 +414,7 @@ export interface Collection<T = any, TKey = IndexableType> {
 	modify(changeCallback: (obj: T, ctx: {
 		value: T;
 	}) => void | boolean): PromiseExtended<number>;
-	modify(changes: {
-		[keyPath: string]: any;
-	}): PromiseExtended<number>;
-}
-export interface WhereClause<T = any, TKey = IndexableType> {
-	above(key: any): Collection<T, TKey>;
-	aboveOrEqual(key: any): Collection<T, TKey>;
-	anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
-	anyOf(...keys: Array<IndexableType>): Collection<T, TKey>;
-	anyOfIgnoreCase(keys: string[]): Collection<T, TKey>;
-	anyOfIgnoreCase(...keys: string[]): Collection<T, TKey>;
-	below(key: any): Collection<T, TKey>;
-	belowOrEqual(key: any): Collection<T, TKey>;
-	between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey>;
-	equals(key: IndexableType): Collection<T, TKey>;
-	equalsIgnoreCase(key: string): Collection<T, TKey>;
-	inAnyRange(ranges: ReadonlyArray<{
-		0: any;
-		1: any;
-	}>, options?: {
-		includeLowers?: boolean;
-		includeUppers?: boolean;
-	}): Collection<T, TKey>;
-	startsWith(key: string): Collection<T, TKey>;
-	startsWithAnyOf(prefixes: string[]): Collection<T, TKey>;
-	startsWithAnyOf(...prefixes: string[]): Collection<T, TKey>;
-	startsWithIgnoreCase(key: string): Collection<T, TKey>;
-	startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey>;
-	startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey>;
-	noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
-	notEqual(key: IndexableType): Collection<T, TKey>;
-}
-export interface Database {
-	readonly name: string;
-	readonly tables: Table[];
-	table<T = any, TKey = any>(tableName: string): Table<T, TKey>;
-	transaction<U>(mode: TransactionMode, table: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, table5: Table, scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, tables: Table[], scope: () => PromiseLike<U> | U): PromiseExtended<U>;
-}
-export interface TransactionEvents extends DexieEventSet {
-	(eventName: "complete", subscriber: () => any): void;
-	(eventName: "abort", subscriber: () => any): void;
-	(eventName: "error", subscriber: (error: any) => any): void;
-	complete: DexieEvent;
-	abort: DexieEvent;
-	error: DexieEvent;
-}
-export interface Transaction {
-	db: Database;
-	active: boolean;
-	mode: IDBTransactionMode;
-	//tables: { [type: string]: Table<any, any> }; Deprecated since 2.0. Obsolete from v3.0.
-	storeNames: Array<string>;
-	parent?: Transaction;
-	on: TransactionEvents;
-	abort(): void;
-	table(tableName: string): Table<any, any>;
-	table<T>(tableName: string): Table<T, any>;
-	table<T, Key>(tableName: string): Table<T, Key>;
-}
-export interface CreatingHookContext<T, Key> {
-	onsuccess?: (primKey: Key) => void;
-	onerror?: (err: any) => void;
-}
-export interface UpdatingHookContext<T, Key> {
-	onsuccess?: (updatedObj: T) => void;
-	onerror?: (err: any) => void;
-}
-export interface DeletingHookContext<T, Key> {
-	onsuccess?: () => void;
-	onerror?: (err: any) => void;
-}
-export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet {
-	(eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
-	(eventName: "reading", subscriber: (obj: T) => T | any): void;
-	(eventName: "updating", subscriber: (this: UpdatingHookContext<T, TKey>, modifications: Object, primKey: TKey, obj: T, transaction: Transaction) => any): void;
-	(eventName: "deleting", subscriber: (this: DeletingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
-	creating: DexieEvent;
-	reading: DexieEvent;
-	updating: DexieEvent;
-	deleting: DexieEvent;
+	modify(changes: UpdateSpec<T>): PromiseExtended<number>;
 }
 export const enum DBCoreRangeType {
 	Equal = 1,
@@ -452,7 +447,7 @@ export interface DBCoreMutateResponse {
 export interface DBCoreAddRequest {
 	type: "add";
 	trans: DBCoreTransaction;
-	values: any[];
+	values: readonly any[];
 	keys?: any[];
 	/** @deprecated Will always get results since 3.1.0-alpha.5 */
 	wantResults?: boolean;
@@ -460,7 +455,7 @@ export interface DBCoreAddRequest {
 export interface DBCorePutRequest {
 	type: "put";
 	trans: DBCoreTransaction;
-	values: any[];
+	values: readonly any[];
 	keys?: any[];
 	criteria?: {
 		index: string | null;
@@ -586,66 +581,76 @@ export interface DBCoreTable {
 	openCursor(req: DBCoreOpenCursorRequest): Promise<DBCoreCursor | null>;
 	count(req: DBCoreCountRequest): Promise<number>;
 }
-export interface Table<T = any, TKey = IndexableType> {
-	db: Database;
+export type MethodProps<T> = {
+	[P in keyof T]: T[P] extends (...args: any[]) => any ? P : never;
+}[keyof T];
+export type InsertType<T, TOptionalProperties, TKeyPropNameOrKeyType> = string extends MethodProps<T> ? T : Omit<T, TOptionalProperties extends keyof T ? TKeyPropNameOrKeyType extends keyof T ? MethodProps<T> | TOptionalProperties | TKeyPropNameOrKeyType : MethodProps<T> | TOptionalProperties : MethodProps<T>> & (TOptionalProperties extends keyof T ? TKeyPropNameOrKeyType extends keyof T ? {
+	[P in (TOptionalProperties | TKeyPropNameOrKeyType)]?: T[P];
+} : {
+	[P in TOptionalProperties]?: T[P];
+} : {});
+export type IDType<T, TKey> = TKey extends keyof T ? T[TKey] : TKey;
+export interface Table<T = any, TKeyPropNameOrKeyType = IndexableType, TOpt = void> {
+	db: Dexie;
 	name: string;
 	schema: TableSchema;
-	hook: TableHooks<T, TKey>;
+	hook: TableHooks<T, IDType<T, TKeyPropNameOrKeyType>>;
 	core: DBCoreTable;
-	get(key: TKey): PromiseExtended<T | undefined>;
-	get<R>(key: TKey, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
+	get(key: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<T | undefined>;
+	get<R>(key: IDType<T, TKeyPropNameOrKeyType>, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
 	get(equalityCriterias: {
 		[key: string]: any;
 	}): PromiseExtended<T | undefined>;
 	get<R>(equalityCriterias: {
 		[key: string]: any;
 	}, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-	where(index: string | string[]): WhereClause<T, TKey>;
+	where(index: string | string[]): WhereClause<T, IDType<T, TKeyPropNameOrKeyType>>;
 	where(equalityCriterias: {
 		[key: string]: any;
-	}): Collection<T, TKey>;
-	filter(fn: (obj: T) => boolean): Collection<T, TKey>;
+	}): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	filter(fn: (obj: T) => boolean): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
 	count(): PromiseExtended<number>;
 	count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-	offset(n: number): Collection<T, TKey>;
-	limit(n: number): Collection<T, TKey>;
+	offset(n: number): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	limit(n: number): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
 	each(callback: (obj: T, cursor: {
 		key: any;
-		primaryKey: TKey;
+		primaryKey: IDType<T, TKeyPropNameOrKeyType>;
 	}) => any): PromiseExtended<void>;
 	toArray(): PromiseExtended<Array<T>>;
 	toArray<R>(thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
-	toCollection(): Collection<T, TKey>;
-	orderBy(index: string | string[]): Collection<T, TKey>;
-	reverse(): Collection<T, TKey>;
+	toCollection(): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	orderBy(index: string | string[]): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	reverse(): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
 	mapToClass(constructor: Function): Function;
-	add(item: T, key?: TKey): PromiseExtended<TKey>;
-	update(key: TKey | T, changes: {
-		[keyPath: string]: any;
-	}): PromiseExtended<number>;
-	put(item: T, key?: TKey): PromiseExtended<TKey>;
-	delete(key: TKey): PromiseExtended<void>;
+	add(item: InsertType<T, TOpt, TKeyPropNameOrKeyType>, key?: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	update(key: IDType<T, TKeyPropNameOrKeyType> | T, changes: UpdateSpec<T> | ((obj: T, ctx: {
+		value: any;
+		primKey: IndexableType;
+	}) => void | boolean)): PromiseExtended<number>;
+	put(item: InsertType<T, TOpt, TKeyPropNameOrKeyType>, key?: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	delete(key: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<void>;
 	clear(): PromiseExtended<void>;
-	bulkGet(keys: TKey[]): PromiseExtended<(T | undefined)[]>;
-	bulkAdd<B extends boolean>(items: readonly T[], keys: IndexableTypeArrayReadonly, options: {
+	bulkGet(keys: IDType<T, TKeyPropNameOrKeyType>[]): PromiseExtended<(T | undefined)[]>;
+	bulkAdd<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys: IndexableTypeArrayReadonly, options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkAdd<B extends boolean>(items: readonly T[], options: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkAdd<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkAdd(items: readonly T[], keys?: IndexableTypeArrayReadonly, options?: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkAdd(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys?: IndexableTypeArrayReadonly, options?: {
 		allKeys: boolean;
-	}): PromiseExtended<TKey>;
-	bulkPut<B extends boolean>(items: readonly T[], keys: IndexableTypeArrayReadonly, options: {
+	}): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	bulkPut<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys: IndexableTypeArrayReadonly, options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkPut<B extends boolean>(items: readonly T[], options: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkPut<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? TKey[] : TKey>;
-	bulkPut(items: readonly T[], keys?: IndexableTypeArrayReadonly, options?: {
+	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
+	bulkPut(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys?: IndexableTypeArrayReadonly, options?: {
 		allKeys: boolean;
-	}): PromiseExtended<TKey>;
-	bulkDelete(keys: TKey[]): PromiseExtended<void>;
+	}): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
+	bulkDelete(keys: IDType<T, TKeyPropNameOrKeyType>[]): PromiseExtended<void>;
 }
 export interface Version {
 	stores(schema: {
@@ -710,6 +715,7 @@ export interface GlobalDexieEvents extends DexieEventSet {
 	(eventName: "storagemutated", subscriber: (parts: ObservabilitySet) => any): void;
 	storagemutated: DexieOnStorageMutatedEvent;
 }
+export type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
 export type DbSchema = {
 	[tableName: string]: TableSchema;
 };
@@ -724,7 +730,20 @@ export interface Middleware<TStack extends {
 export interface DexieStacks {
 	dbcore: DBCore;
 }
-export interface Dexie extends Database {
+export type TableProp<DX extends Dexie> = {
+	[K in keyof DX]: DX[K] extends {
+		schema: any;
+		get: any;
+		put: any;
+		add: any;
+		where: any;
+	} ? K : never;
+}[keyof DX] & string;
+export type TXWithTables<DX extends Dexie> = Dexie extends DX ? Transaction // If not subclassed, just expect a Transaction without table props
+ : Transaction & {
+	[P in TableProp<DX>]: DX[P];
+};
+export interface Dexie {
 	readonly name: string;
 	readonly tables: Table[];
 	readonly verno: number;
@@ -734,23 +753,18 @@ export interface Dexie extends Database {
 	};
 	readonly core: DBCore;
 	_createTransaction: (this: Dexie, mode: IDBTransactionMode, storeNames: ArrayLike<string>, dbschema: DbSchema, parentTransaction?: Transaction | null) => Transaction;
+	readonly _novip: Dexie;
 	_dbSchema: DbSchema;
 	version(versionNumber: number): Version;
 	on: DbEvents;
 	open(): PromiseExtended<Dexie>;
 	table<T = any, TKey = IndexableType>(tableName: string): Table<T, TKey>;
-	transaction<U>(mode: TransactionMode, table: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, table3: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, table3: string, table4: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: Table, table2: Table, table3: Table, table4: Table, table5: Table, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, table: string, table2: string, table3: string, table4: string, table5: string, scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, tables: Table[], scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
-	transaction<U>(mode: TransactionMode, tables: string[], scope: (trans: Transaction) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, tables: readonly (string | Table)[], scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, table4: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
+	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, table5: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
 	close(): void;
 	delete(): PromiseExtended<void>;
 	isOpen(): boolean;
@@ -976,9 +990,9 @@ export interface DexieConstructor extends DexieExceptionClasses {
 	liveQuery<T>(fn: () => T | Promise<T>): Observable<T>;
 	extendObservabilitySet(target: ObservabilitySet, newSet: ObservabilitySet): ObservabilitySet;
 	override<F>(origFunc: F, overridedFactory: (fn: any) => any): F; // ?
-	getByKeyPath(obj: Object, keyPath: string): any;
-	setByKeyPath(obj: Object, keyPath: string, value: any): void;
-	delByKeyPath(obj: Object, keyPath: string): void;
+	getByKeyPath(obj: Object, keyPath: string | string[]): any;
+	setByKeyPath(obj: Object, keyPath: string | string[], value: any): void;
+	delByKeyPath(obj: Object, keyPath: string | string[]): void;
 	shallowClone<T>(obj: T): T;
 	deepClone<T>(obj: T): T;
 	asap(fn: Function): void; //?
@@ -995,6 +1009,11 @@ export interface DexieConstructor extends DexieExceptionClasses {
 	on: GlobalDexieEvents;
 	errnames: DexieErrors;
 }
+export class Entity<TDexieSubClass extends Dexie = Dexie> {
+	protected constructor();
+	protected readonly db: TDexieSubClass;
+	table(): TableProp<TDexieSubClass>;
+}
 export declare var Dexie: DexieConstructor;
 export interface _Table<T, TKey> extends Table<T, TKey> {
 }
@@ -1013,6 +1032,7 @@ export declare module Dexie {
 export function liveQuery<T>(querier: () => T | Promise<T>): Observable<T>;
 export function mergeRanges(target: IntervalTree, newSet: IntervalTree): void;
 export function rangesOverlap(rangeSet1: IntervalTree, rangeSet2: IntervalTree): boolean;
+export function cmp(a: any, b: any): number;
 /** Exporting 'Dexie' as the default export.
  **/
 export default Dexie;