dexie 3.2.1 → 4.0.0-alpha.3

package/README.md

@@ -1,7 +1,7 @@
 Dexie.js
 ========
 
-[![NPM Version][npm-image]][npm-url] [![Build Status](https://travis-ci.com/dfahlander/Dexie.js.svg?branch=master)](https://travis-ci.com/dfahlander/Dexie.js)[![Tested with Browserstack](https://dexie.org/assets/images/tested-with-browserstack2.png)](https://www.browserstack.com)
+[![NPM Version][npm-image]][npm-url] [![Build Status](https://travis-ci.com/dexie/Dexie.js.svg?branch=master)](https://travis-ci.com/dexie/Dexie.js)[![Tested with Browserstack](https://dexie.org/assets/images/tested-with-browserstack2.png)](https://www.browserstack.com)
 
 Dexie.js is a wrapper library for indexedDB - the standard database in the browser. https://dexie.org
 
@@ -191,7 +191,7 @@ Samples
 -------
 https://dexie.org/docs/Samples
 
-https://github.com/dfahlander/Dexie.js/tree/master/samples
+https://github.com/dexie/Dexie.js/tree/master/samples
 
 Knowledge Base
 -----

package/SECURITY.md

@@ -4,14 +4,15 @@
 
 | Version | Supported          | Branch
 | ------- | ------------------ | --------
-| 3.x     | :white_check_mark: | master
+| 4.x     | :white_check_mark: | master
+| 3.x     | :white_check_mark: | master-3
 | 2.0.x   | :thinking: | master-2
 | 1.5.x   | :x: | master-1
 | < 1.5.1 | :x:                |
 
 ## Reporting a Vulnerability
 
-To report a security vulnerability in Dexie.js, just file an issue in this repo.
+To report a security vulnerability in Dexie.js, please send an email to code@dexie.org describing the vulnerability and how to reproduce it.
 
 If we find an issue to be regarded as a security vulnerability, we will patch and release a new version in all the supported versions as soon as possible.
 Keep in mind though that this is an uncommercial open source project which means that sometimes you might have to be the one that

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 3.2.1, Wed Feb 16 2022
+ * Version 4.0.0-alpha.3, Wed Apr 27 2022
  *
  * 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: {
@@ -696,9 +701,34 @@ export interface DbEvents extends DexieEventSet {
 	versionchange: DexieVersionChangeEvent;
 	close: DexieCloseEvent;
 }
+/** Set of mutated parts of the database
+ */
 export type ObservabilitySet = {
-	// `idb:${dbName}/${tableName}/changedRowContents` - keys.
-	// `idb:${dbName}/${tableName}/changedIndexes/${indexName}` - indexes
+	/** Database part having been mutated.
+	 *
+	 * This structure is produced in observability-middleware.ts
+	 * and consumed in live-query.ts.
+	 *
+	 * Format of 'part':
+	 *
+	 *   `idb://${dbName}/${tableName}/${indexName}`
+	 *
+	 * * dbName is the database name
+	 * * tableName is the table name
+	 * * indexName is any of:
+	 *    1. An empty string - represents the primary keys of the affected objs
+	 *    2. ":dels" - represents primary keys of deleted objects in the table
+	 *    3. The keyPath of an index, such as "name", "age" or "address.city" -
+	 *       represents indexes that, if used in a query, might affect the
+	 *       result of that query.
+	 *
+	 * IntervalTree
+	 *    * See definition of IntervalTree type in rangeset.d.ts
+	 *    * See rangesOverlap() in rangeset.ts that can be used to compare two
+	 *      IntervalTrees and detect collissions.
+	 *    * See RangeSet class that can be used to create an IntervalTree and add
+	 *      ranges to it.
+	 */
 	[part: string]: IntervalTree;
 };
 export interface DexieOnStorageMutatedEvent {
@@ -710,6 +740,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 +755,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 +778,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 +1015,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 +1034,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 +1057,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;