(feat) Implement Query offset and limit

Author: D34DPlayer

src/query.ts

@@ -1,4 +1,4 @@
-import type { Filter, ModelFieldKey, OrderBy } from './types'
+import type { Filter, ModelFieldKey, OrderBy, TransactionOrMode } from './types'
 import type { Model } from './models'
 import { _objectStore } from './transaction'
 
@@ -74,6 +74,28 @@ export class Query<T extends Model> {
     return this
   }
 
+  /**
+   * Add a limit to the query.
+   * This means that the query will only return a maximum of `limit` items.
+   * @param limit - The maximum amount of items to return
+   * @returns - The query itself, to allow chaining
+   */
+  public limit(limit: number): Query<T> {
+    this._limit = limit
+    return this
+  }
+
+  /**
+   * Add an offset to the query.
+   * This means that the query will skip the first `offset` items.
+   * @param offset - The amount of items to skip
+   * @returns - The query itself, to allow chaining
+   */
+  public offset(offset: number): Query<T> {
+    this._skip = offset
+    return this
+  }
+
   /**
    * Checks if the given instance fits the filters of the query.
    * @param instance - The instance to check
@@ -100,7 +122,7 @@ export class Query<T extends Model> {
    * Utility function to get the cursor of the query.
    * @returns
    */
-  private _getCursor(transactionOrMode: IDBTransactionMode | IDBTransaction = 'readonly'): IDBRequest<IDBCursorWithValue | null> {
+  private _getCursor(transactionOrMode: TransactionOrMode = 'readonly'): IDBRequest<IDBCursorWithValue | null> {
     const store = _objectStore(this.TargetModel.name, transactionOrMode)
     if (this._orderBy) {
       const index = store.index(this._orderBy)
@@ -113,106 +135,107 @@ export class Query<T extends Model> {
   }
 
   /**
-   * Executes the query and returns the first result.
-   * @returns - The first result of the query, or null if no result was found
+   * Utility function to handle a cursor's cycle.
+   * This implement the limit, offset and filter.
+   * @param valueCallback - The callback to call for each value
+   * @param transactionOrMode - The transaction or mode to use
+   * @returns - A promise that resolves when the cursor is done
    */
-  async first(transaction?: IDBTransaction): Promise<T | null> {
-    const cursor = this._getCursor(transaction)
-    return new Promise<T | null>((resolve, reject) => {
-      cursor.onsuccess = () => {
-        if (!cursor.result) {
-          resolve(null)
+  private _cursorLogic(valueCallback: (value: IDBCursorWithValue) => void, transactionOrMode?: TransactionOrMode): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const request = this._getCursor(transactionOrMode)
+      let matches = 0
+      let skipped = 0
+
+      request.onsuccess = () => {
+        if (!request.result) {
+          resolve()
         }
         else {
-          if (this._fitsFilters(cursor.result.value as T)) {
-            const instance = new this.TargetModel()
-            Object.assign(instance, cursor.result.value)
-            resolve(instance)
+          // If we have a limit, we check if we have reached it
+          if ((matches - skipped) === this._limit) {
+            resolve()
+            return
+          }
+          // Apply the filters
+          if (this._fitsFilters(request.result.value as T)) {
+            // If we have an offset, we wait until we have reached it
+            if (!this._skip || matches >= this._skip)
+              valueCallback(request.result)
+            else
+              skipped += 1
+
+            matches += 1
           }
-          else { cursor.result.continue() }
+
+          request.result.continue()
         }
       }
-      cursor.onerror = (event) => {
+      request.onerror = (event) => {
         reject(event)
       }
     })
   }
 
+  /**
+   * Executes the query and returns the first result.
+   * @returns - The first result of the query, or null if no result was found
+   */
+  async first(transaction?: IDBTransaction): Promise<T | null> {
+    let result: T | null = null
+    this._limit = 1
+
+    await this._cursorLogic((cursor) => {
+      const instance = new this.TargetModel()
+      Object.assign(instance, cursor.value)
+      result = instance
+    }, transaction)
+
+    return result
+  }
+
   /**
    * Executes the query and returns all the results.
    * @returns - All the results of the query
    */
   async all(transaction?: IDBTransaction): Promise<T[]> {
-    const cursor = this._getCursor(transaction)
     const result: T[] = []
-    return new Promise<T[]>((resolve, reject) => {
-      cursor.onsuccess = () => {
-        if (!cursor.result) {
-          resolve(result)
-        }
-        else {
-          if (this._fitsFilters(cursor.result.value as T)) {
-            const instance = new this.TargetModel()
-            Object.assign(instance, cursor.result.value)
-            result.push(instance)
-          }
-          cursor.result.continue()
-        }
-      }
-      cursor.onerror = (event) => {
-        reject(event)
-      }
-    })
+
+    await this._cursorLogic((cursor) => {
+      const instance = new this.TargetModel()
+      Object.assign(instance, cursor.value)
+      result.push(instance)
+    }, transaction)
+
+    return result
   }
 
   /**
    * Executes the query and returns the number of results.
    * @returns - The amount of results of the query
    */
   async count(transaction?: IDBTransaction): Promise<number> {
-    const cursor = this._getCursor(transaction)
     let count = 0
-    return new Promise<number>((resolve, reject) => {
-      cursor.onsuccess = () => {
-        if (!cursor.result) {
-          resolve(count)
-        }
-        else {
-          if (this._fitsFilters(cursor.result.value as T))
-            count++
 
-          cursor.result.continue()
-        }
-      }
-      cursor.onerror = (event) => {
-        reject(event)
-      }
-    })
+    await this._cursorLogic(() => {
+      count += 1
+    }, transaction)
+
+    return count
   }
 
   /**
    * Executes the query and deletes all the results.
    * @returns - The amount of results deleted
    */
   async delete(transaction?: IDBTransaction): Promise<number> {
-    const cursor = this._getCursor(transaction || 'readwrite')
     let amount = 0
-    return new Promise<number>((resolve, reject) => {
-      cursor.onsuccess = () => {
-        if (!cursor.result) {
-          resolve(amount)
-        }
-        else {
-          if (this._fitsFilters(cursor.result.value as T)) {
-            amount += 1
-            cursor.result.delete()
-          }
-          cursor.result.continue()
-        }
-      }
-      cursor.onerror = (event) => {
-        reject(event)
-      }
-    })
+
+    await this._cursorLogic((cursor) => {
+      cursor.delete()
+      amount += 1
+    }, transaction || 'readwrite')
+
+    return amount
   }
 }

src/transaction.ts

@@ -1,4 +1,4 @@
-import type { TransactionCallback } from './types'
+import type { TransactionCallback, TransactionOrMode } from './types'
 import { db } from './connection'
 
 /**
@@ -10,8 +10,8 @@ import { db } from './connection'
  */
 export function _objectStore(storeName: string, transaction?: IDBTransaction): IDBObjectStore
 export function _objectStore(storeName: string, mode?: IDBTransactionMode): IDBObjectStore
-export function _objectStore(storeName: string, modeOrTransaction?: IDBTransactionMode | IDBTransaction): IDBObjectStore
-export function _objectStore(storeName: string, modeOrTransaction?: IDBTransactionMode | IDBTransaction): IDBObjectStore {
+export function _objectStore(storeName: string, modeOrTransaction?: TransactionOrMode): IDBObjectStore
+export function _objectStore(storeName: string, modeOrTransaction?: TransactionOrMode): IDBObjectStore {
   if (!db.connected)
     throw new Error('Database is not connected')
   if (modeOrTransaction instanceof IDBTransaction) {

src/types.ts

@@ -59,3 +59,5 @@ export type Filter<T extends Model> = {
 export type OrderBy<T extends Model> = (ModelFieldKey<T>) | `-${ModelFieldKey<T>}`
 
 export type TransactionCallback = (tx: IDBTransaction) => Promise<void>
+
+export type TransactionOrMode = IDBTransaction | IDBTransactionMode

test/query.spec.ts

@@ -276,4 +276,71 @@ describe('Query builder', () => {
     const obtainedTests = await Test.all()
     assert.sameDeepMembers(obtainedTests, [test3])
   })
+  it('should allow filtering with a limit', async () => {
+    class Test extends Model {
+      @Field({ primaryKey: true })
+      id!: number
+
+      @Field()
+      name!: string
+
+      @Field()
+      age!: number
+    }
+
+    await init('test', 1)
+
+    const test1 = await Test.create({ id: 1, name: 'test1', age: 10 })
+    const test2 = await Test.create({ id: 2, name: 'test1', age: 20 })
+    await Test.create({ id: 3, name: 'test3', age: 30 })
+    await Test.create({ id: 4, name: 'test4', age: 10 })
+
+    const obtainedTests = await Test.filter({ age: t => t < 25 }).orderBy('id').limit(2).all()
+    assert.sameDeepMembers(obtainedTests, [test1, test2])
+  })
+  it('should allow filtering with an offset', async () => {
+    class Test extends Model {
+      @Field({ primaryKey: true })
+      id!: number
+
+      @Field()
+      name!: string
+
+      @Field()
+      age!: number
+    }
+
+    await init('test', 1)
+
+    await Test.create({ id: 1, name: 'test1', age: 10 })
+    const test2 = await Test.create({ id: 2, name: 'test1', age: 20 })
+    await Test.create({ id: 3, name: 'test3', age: 30 })
+    const test4 = await Test.create({ id: 4, name: 'test4', age: 10 })
+
+    const obtainedTests = await Test.filter({ age: t => t < 25 }).orderBy('id').offset(1).all()
+    assert.sameDeepMembers(obtainedTests, [test2, test4])
+  })
+  it('should allow setting a limit and an offset', async () => {
+    class Test extends Model {
+      @Field({ primaryKey: true })
+      id!: number
+
+      @Field()
+      name!: string
+
+      @Field()
+      age!: number
+    }
+
+    await init('test', 1)
+
+    await Test.create({ id: 1, name: 'test1', age: 10 })
+    await Test.create({ id: 2, name: 'test1', age: 20 })
+    await Test.create({ id: 3, name: 'test3', age: 30 })
+    const test4 = await Test.create({ id: 4, name: 'test4', age: 10 })
+    await Test.create({ id: 5, name: 'test4', age: 10 })
+
+    const obtainedTests = await Test.orderBy('id').offset(3).limit(1).all()
+    assert.sameDeepMembers(obtainedTests, [test4])
+  })
 })