idb-ts 3.10.0 → 3.12.0

package/lib/index.d.ts

@@ -1,9 +1,52 @@
 import 'reflect-metadata';
 type QueryDirection = 'asc' | 'desc';
+type QueryFieldKey<T> = Extract<keyof T, string>;
+type ComparableValue = string | number | bigint | Date;
+type ComparableFieldKey<T> = {
+    [K in QueryFieldKey<T>]-?: T[K] extends ComparableValue ? K : never;
+}[QueryFieldKey<T>];
+type NumericFieldKey<T> = {
+    [K in QueryFieldKey<T>]-?: T[K] extends number ? K : never;
+}[QueryFieldKey<T>];
+type StringFieldKey<T> = {
+    [K in QueryFieldKey<T>]-?: T[K] extends string ? K : never;
+}[QueryFieldKey<T>];
+type ArrayFieldKey<T> = {
+    [K in QueryFieldKey<T>]-?: T[K] extends readonly any[] ? K : never;
+}[QueryFieldKey<T>];
+type ArrayElement<T> = T extends readonly (infer U)[] ? U : never;
+type ContainsValue<T> = T extends string ? string : T extends readonly (infer U)[] ? U : never;
+type QueryOperator = 'equals' | 'gt' | 'gte' | 'lt' | 'lte' | 'startsWith' | 'endsWith' | 'contains' | 'matches' | 'between' | 'notBetween' | 'in' | 'notIn' | 'containsAny' | 'containsAll';
+type GroupCountResult<T, K extends Extract<keyof T, string>> = Array<Record<K, T[K]> & {
+    count: number;
+}>;
+declare class FieldQueryBuilder<T, K extends QueryFieldKey<T>> {
+    private parent;
+    private field;
+    constructor(parent: QueryBuilder<T>, field: K);
+    equals(value: T[K]): QueryBuilder<T>;
+    gt(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
+    gte(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
+    lt(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
+    lte(value: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
+    startsWith(this: FieldQueryBuilder<T, StringFieldKey<T>>, value: string): QueryBuilder<T>;
+    endsWith(this: FieldQueryBuilder<T, StringFieldKey<T>>, value: string): QueryBuilder<T>;
+    contains(this: FieldQueryBuilder<T, StringFieldKey<T>> | FieldQueryBuilder<T, ArrayFieldKey<T>>, value: ContainsValue<T[K]>): QueryBuilder<T>;
+    matches(this: FieldQueryBuilder<T, StringFieldKey<T>>, value: RegExp | string): QueryBuilder<T>;
+    between(start: T[K] extends ComparableValue ? T[K] : never, end: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
+    notBetween(start: T[K] extends ComparableValue ? T[K] : never, end: T[K] extends ComparableValue ? T[K] : never): QueryBuilder<T>;
+    in(values: Array<T[K]>): QueryBuilder<T>;
+    notIn(values: Array<T[K]>): QueryBuilder<T>;
+    containsAny(this: FieldQueryBuilder<T, ArrayFieldKey<T>>, values: Array<ArrayElement<T[K]>>): QueryBuilder<T>;
+    containsAll(this: FieldQueryBuilder<T, ArrayFieldKey<T>>, values: Array<ArrayElement<T[K]>>): QueryBuilder<T>;
+    and<K2 extends QueryFieldKey<T>>(field: K2): FieldQueryBuilder<T, K2>;
+    or(): QueryBuilder<T>;
+}
 declare class QueryBuilder<T> {
     private db;
     private storeName;
-    private conditions;
+    private transaction?;
+    private clauses;
     private orderField?;
     private orderDirection;
     private limitCount?;
@@ -12,25 +55,73 @@ declare class QueryBuilder<T> {
     private rangeStart?;
     private rangeEnd?;
     private currentField?;
-    constructor(db: IDBDatabase, storeName: string);
-    where(field: string): this;
-    and(field: string): this;
+    private groupField?;
+    private pendingConnector;
+    constructor(db: IDBDatabase, storeName: string, transaction?: IDBTransaction);
+    where<K extends QueryFieldKey<T>>(field: K): FieldQueryBuilder<T, K>;
+    where(builder: (query: QueryBuilder<T>) => QueryBuilder<T> | void): this;
+    and<K extends QueryFieldKey<T>>(field: K): FieldQueryBuilder<T, K>;
+    and(builder: (query: QueryBuilder<T>) => QueryBuilder<T> | void): this;
+    or(): this;
+    private addNestedGroup;
+    clearCurrentField(): void;
+    appendCondition(field: string, op: QueryOperator, value: any): void;
+    private appendClause;
+    private requireCurrentField;
+    private addCondition;
     equals(value: any): this;
     gt(value: any): this;
     gte(value: any): this;
     lt(value: any): this;
     lte(value: any): this;
-    orderBy(field: string, direction?: QueryDirection): this;
+    startsWith(value: string): this;
+    endsWith(value: string): this;
+    contains(value: any): this;
+    matches(value: RegExp | string): this;
+    between(start: any, end: any): this;
+    notBetween(start: any, end: any): this;
+    ['in'](values: any[]): this;
+    notIn(values: any[]): this;
+    containsAny(values: any[]): this;
+    containsAll(values: any[]): this;
+    orderBy(field: Extract<keyof T, string>, direction?: QueryDirection): this;
     limit(n: number): this;
     offset(n: number): this;
     useIndex(indexName: string): this;
     range(start: any, end: any): this;
+    groupBy<K extends QueryFieldKey<T>>(field: K): QueryBuilder<T> & {
+        count(): Promise<GroupCountResult<T, K>>;
+    };
+    private loadCandidates;
+    private createReadRequest;
+    private matchesClause;
+    private evaluateClauses;
+    private collectMatches;
+    private sortResults;
+    private applyPagination;
+    private aggregateValues;
+    private aggregateGroupedCount;
     execute(): Promise<T[]>;
+    count(): Promise<number | GroupCountResult<T, Extract<keyof T, string>>>;
+    sum(field: NumericFieldKey<T>): Promise<number>;
+    avg(field: NumericFieldKey<T>): Promise<number>;
+    min(field: ComparableFieldKey<T>): Promise<T[typeof field] | null>;
+    max(field: ComparableFieldKey<T>): Promise<T[typeof field] | null>;
 }
 interface KeyPathOptions {
     autoIncrement?: boolean;
     generator?: 'uuid' | 'timestamp' | 'random' | ((item?: any) => string | number);
 }
+interface RetentionPolicyOptions {
+    seconds: number;
+    enabled?: boolean;
+    field?: string;
+}
+interface RetentionPolicyMetadata {
+    seconds: number;
+    enabled: boolean;
+    field: string;
+}
 interface KeyPathMetadata {
     fields: string | string[];
     options?: KeyPathOptions;
@@ -42,16 +133,22 @@ declare class KeyGenerators {
 }
 declare function KeyPath(options?: KeyPathOptions): PropertyDecorator;
 declare function CompositeKeyPath(fields: string[], options?: KeyPathOptions): ClassDecorator;
-declare function Index(): PropertyDecorator;
+declare function Index(options?: IDBIndexParameters): PropertyDecorator;
+declare function Validate<T = any>(predicate: (value: any, item: T) => boolean, message: string): PropertyDecorator;
+declare function RetentionPolicy(options: RetentionPolicyOptions): ClassDecorator;
 interface DataClassOptions {
     version?: number;
 }
 declare function DataClass(options?: DataClassOptions): ClassDecorator;
 interface EntityRepository<T> {
     create(item: T): Promise<void>;
+    createMany(items: T[]): Promise<void>;
     read(key: string | string[] | number): Promise<T | undefined>;
     update(item: T): Promise<void>;
+    updateMany(items: T[]): Promise<void>;
     delete(key: string | string[] | number): Promise<void>;
+    deleteMany(keys: Array<string | string[] | number>): Promise<void>;
+    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[]>;
@@ -61,6 +158,11 @@ interface EntityRepository<T> {
     clear(): Promise<void>;
     query(): QueryBuilder<T>;
 }
+interface TransactionController {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+type TransactionalDatabase<T extends Record<string, EntityRepository<any>>> = T & TransactionController;
 type DatabaseWithRepositories<T extends Record<string, any>> = Database & T;
 declare class Database {
     private dbName;
@@ -68,17 +170,28 @@ declare class Database {
     private db;
     private entityRepositories;
     private dbVersion;
+    private retentionTimer;
+    private retentionCleanupRunning;
+    private retentionPolicies;
     private constructor();
     private calculateDatabaseVersion;
     static build<T extends Record<string, EntityRepository<any>>>(dbName: string, classes: Function[]): Promise<DatabaseWithRepositories<T>>;
     private initDB;
     private generateEntityRepositories;
+    private calculateRetentionCleanupIntervalMs;
+    private startRetentionCleanup;
+    private runRetentionCleanup;
+    private cleanupExpiredRecords;
     private createEntityRepository;
     private performOperation;
+    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>;
+    close(): void;
     getAvailableEntities(): string[];
     getDatabaseVersion(): number;
     getEntityVersions(): Map<string, number>;
     getEntityVersion(entityName: string): number | undefined;
 }
-export { Database, KeyPath, CompositeKeyPath, DataClass, Index, EntityRepository, KeyGenerators };
-export type { DatabaseWithRepositories, DataClassOptions, KeyPathOptions, KeyPathMetadata };
+export { Database, KeyPath, CompositeKeyPath, DataClass, Index, Validate, RetentionPolicy, EntityRepository, KeyGenerators, };
+export type { DatabaseWithRepositories, DataClassOptions, KeyPathOptions, KeyPathMetadata, RetentionPolicyOptions, RetentionPolicyMetadata, };