@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

package/react-native/src/sources/augment.ts

@@ -0,0 +1,101 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+// NOTE: proxy was originally written in pure JS rather than TypeScript. We'll
+// gradually port it to TypeScript and until done, we've renamed the pure JS
+// file to proxy.raw.js and introduced proxy.ts that'll contain all parts ported
+// to TypeScript or type declarations for the JS parts.
+
+// import * as proxyRaw from './proxy.raw'
+
+import * as FFI from './ffi'
+import { DocumentID } from './document-id'
+import { AttachmentToken } from './attachment-token'
+import { Attachment } from './attachment'
+import { Counter } from './counter'
+import { Register } from './register'
+
+// Takes an annotated JSON representation of a document (see CRDT's Document
+// class for more info about what an annotated representation is) and turns it
+// into a JavaScript-appropriate version. This means that counters get
+// represented by `Counter` objects and attachments get represented by
+// `Attachment` objects.
+export function augmentJSONValue(json, mutDoc, workingPath) {
+  if (json && typeof json === 'object') {
+    if (Array.isArray(json)) {
+      return json.map((v, idx) => augmentJSONValue(v, mutDoc, `${workingPath}[${idx}]`))
+    } else if (json[FFI.DittoCRDTTypeKey] === FFI.DittoCRDTType.counter) {
+      return Counter['@ditto.create'](mutDoc, workingPath, json[FFI.DittoCRDTValueKey])
+    } else if (json[FFI.DittoCRDTTypeKey] === FFI.DittoCRDTType.register) {
+      return Register['@ditto.create'](mutDoc, workingPath, json[FFI.DittoCRDTValueKey])
+    } else if (json[FFI.DittoCRDTTypeKey] === FFI.DittoCRDTType.attachment) {
+      return new AttachmentToken(json)
+    } else {
+      for (const [key, value] of Object.entries(json)) {
+        json[key] = augmentJSONValue(value, mutDoc, `${workingPath}['${key}']`)
+      }
+      return json
+    }
+  } else {
+    return json
+  }
+}
+
+/**
+ * Converts objects that may contain instances of classes of this SDK, i.e.
+ * `DocumentID`, `Counter`, `Register` and `Attachment`, into plain JS objects
+ * that can be passed to the FFI layer.
+ */
+export function desugarJSObject(jsObj: any, atRoot: boolean = false): any {
+  if (jsObj && typeof jsObj === 'object') {
+    if (Array.isArray(jsObj)) {
+      return jsObj.map((v, idx) => desugarJSObject(v, false))
+    } else if (jsObj instanceof DocumentID) {
+      return jsObj.value
+    } else if (jsObj instanceof Counter) {
+      const counterJSON = {}
+      counterJSON[FFI.DittoCRDTTypeKey] = FFI.DittoCRDTType.counter
+      counterJSON[FFI.DittoCRDTValueKey] = jsObj.value
+      return counterJSON
+    } else if (jsObj instanceof Register) {
+      const registerJSON = {}
+      registerJSON[FFI.DittoCRDTTypeKey] = FFI.DittoCRDTType.register
+      registerJSON[FFI.DittoCRDTValueKey] = jsObj.value
+      return registerJSON
+    } else if (jsObj instanceof Attachment) {
+      const attachmentJSON = {
+        _id: jsObj.token.id,
+        _len: jsObj.token.len,
+        _meta: jsObj.token.metadata,
+      }
+      attachmentJSON[FFI.DittoCRDTTypeKey] = FFI.DittoCRDTType.attachment
+      return attachmentJSON
+    } else {
+      for (const [key, value] of Object.entries(jsObj)) {
+        jsObj[key] = desugarJSObject(value, false)
+      }
+      return jsObj
+    }
+  } else {
+    checkForUnsupportedValues(jsObj)
+    return jsObj
+  }
+}
+
+/**
+ * Throws an error if input is a non-finite float value.
+ *
+ * Workaround while we don't have a reliable way of receiving error messages
+ * from `dittoCore.ditto_collection_insert_value()`.
+ *
+ * See https://github.com/getditto/ditto/issues/8657 for details.
+ *
+ * @param jsObj The object to check.
+ * @throws {Error} If `jsObj` is a non-finite float value.
+ */
+function checkForUnsupportedValues(jsObj: any): void {
+  if (Number.isNaN(jsObj) || jsObj === Infinity || jsObj === -Infinity) {
+    throw new Error('Non-finite float values are not supported')
+  }
+}

package/react-native/src/sources/authenticator.ts

@@ -0,0 +1,314 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { Bridge } from './bridge'
+import { Logger } from './logger'
+import { Observer } from './observer'
+import { ObserverManager } from './observer-manager'
+
+import type { Ditto } from './ditto'
+import type { KeepAlive } from './keep-alive'
+
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Provides info about the authentication status.
+ */
+export type AuthenticationStatus = {
+  /**
+   * Returns `true` if authenticated, otherwise returns `false`.
+   */
+  isAuthenticated: boolean
+
+  /**
+   * If authenticated, returns the `userID` if one was provided by the
+   * authentication service. Otherwise returns `null`.
+   */
+  userID: string | null
+}
+
+/**
+ * Provides feedback to the developer about Ditto authentication status.
+ */
+export interface AuthenticationHandler {
+  /**
+   * There is no Ditto authentication token or it has expired. Sync will not
+   * work until there is a successful login using one of the login methods on
+   * {@link Authenticator}.
+   */
+  authenticationRequired: (authenticator: Authenticator) => void
+
+  /**
+   * Warns that the Ditto authentication token is getting old.
+   *
+   * Ditto will attempt to refresh tokens periodically, starting from halfway
+   * through the token's validity period. This reduces the risk of
+   * authentication expiring while the user is offline.
+   *
+   * The refresh will happen automatically if Ditto has a suitable refresh
+   * token. If new credentials are required, such as a third-party token or a
+   * username/password, then Ditto does not cache that information and you must
+   * submit it again using one of the `login` methods on {@link Authenticator}.
+   */
+  authenticationExpiringSoon: (authenticator: Authenticator, secondsRemaining: number) => void
+
+  /**
+   * Notifies the authentication handler that the authentication status did
+   * change. Use the `authenticator`s property `status` to query for the current
+   * authentication status.
+   *
+   * This method is **optional**.
+   */
+  authenticationStatusDidChange?: (authenticator: Authenticator) => void
+}
+
+// -----------------------------------------------------------------------------
+
+/**
+ * Log in to a remote authentication service, using an
+ * `OnlineWithAuthentication` or an `Online` identity.
+ */
+export class Authenticator {
+  /**
+   * Returns `true` if authentication is available and the login methods can be
+   * used, otherwise returns `false`. Currently, authentication is only
+   * available if Ditto was initialized with an identity of type
+   * {@link IdentityOnlineWithAuthentication | 'onlineWithAuthentication'}.
+   */
+  readonly loginSupported: boolean
+
+  /**
+   Returns the current authentication status.
+   */
+  get status(): AuthenticationStatus {
+    return this._status
+  }
+
+  /**
+   * Log in to Ditto with a third-party token. Throws if authentication is not
+   * available, which can be checked with {@link loginSupported}.
+   *
+   * @param token the authentication token required to log in.
+   * @param provider the name of the authentication provider.
+   */
+  loginWithToken(token: string, provider: string): Promise<void> {
+    throw new Error(`Authenticator.loginWithToken() is abstract and must be implemented by subclasses.`)
+  }
+
+  /**
+   * Log in to Ditto with a username and password. Throws if authentication is
+   * not available, which can be checked with {@link loginSupported}.
+   *
+   * @param username the username component of the credentials used for log in.
+   * @param password the password component of the credentials used for log in.
+   * @param provider the name of the authentication provider.
+   */
+  loginWithUsernameAndPassword(username: string, password: string, provider: string): Promise<void> {
+    throw new Error(`Authenticator.loginWithUsernameAndPassword() is abstract and must be implemented by subclasses.`)
+  }
+
+  /**
+   * Log out of Ditto.
+   *
+   * This will stop sync, shut down all replication sessions, and remove any
+   * cached authentication credentials. Note that this does not remove any data
+   * from the store. If you wish to delete data from the store then use the
+   * optional `cleanupFn` parameter to perform any required cleanup.
+   *
+   * @param cleanupFn An optional function that will be called with the relevant
+   * [Ditto] instance as the sole argument that allows you to perform any
+   * required cleanup of the store as part of the logout process.
+   */
+  logout(cleanupFn?: (ditto: Ditto) => void): Promise<void> {
+    throw new Error(`Authenticator.logout() is abstract and must be implemented by subclasses.`)
+  }
+
+  /*
+   * Registers a callback that is called whenever the authentication status
+   * changes. Returns an `Observer` object that needs to be retained as long as
+   * you want to receive the updates.
+   */
+  observeStatus(callback: (authenticationStatus: AuthenticationStatus) => void): Observer {
+    const token = this.observerManager.addObserver(callback)
+    return new Observer(this.observerManager, token, { stopsWhenFinalized: true })
+  }
+
+  /** @internal */
+  constructor(keepAlive: KeepAlive) {
+    this.keepAlive = keepAlive
+    this._status = { isAuthenticated: false, userID: null }
+    this.loginSupported = false
+    this.observerManager = new ObserverManager('AuthenticationStatusObservation', { keepAlive })
+  }
+
+  /** @internal */
+  '@ditto.authenticationExpiring'(number): void {
+    throw new Error(`Authenticator['@ditto.authenticationExpiring']() is abstract and must be implemented by subclasses.`)
+  }
+
+  /** @internal */
+  '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): void {
+    throw new Error(`Authenticator['@ditto.authClientValidityChanged']() is abstract and must be implemented by subclasses.`)
+  }
+
+  /** @internal */
+  close() {
+    this.observerManager.close()
+  }
+
+  /** @internal */
+  protected keepAlive: KeepAlive
+
+  /** @internal */
+  protected observerManager: ObserverManager
+
+  /** @internal */
+  protected _status: AuthenticationStatus
+}
+
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export class OnlineAuthenticator extends Authenticator {
+  readonly loginSupported: boolean = true
+
+  async loginWithToken(token: string, provider: string): Promise<void> {
+    const ditto = this.ditto.deref()
+    if (!ditto) {
+      return
+    }
+
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    const dittoPointer = dittoHandle.derefOrNull()
+    if (!dittoPointer) {
+      return
+    }
+
+    return ditto.deferCloseAsync(async () => {
+      await FFI.dittoAuthClientLoginWithToken(dittoPointer, token, provider)
+    })
+  }
+
+  async loginWithUsernameAndPassword(username: string, password: string, provider: string): Promise<void> {
+    const ditto = this.ditto.deref()
+    if (!ditto) {
+      return
+    }
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    const dittoPointer = dittoHandle.derefOrNull()
+
+    if (!dittoPointer) {
+      return
+    }
+
+    return ditto.deferCloseAsync(async () => {
+      await FFI.dittoAuthClientLoginWithUsernameAndPassword(dittoPointer, username, password, provider)
+    })
+  }
+
+  async logout(cleanupFn?: (ditto: Ditto) => void): Promise<void> {
+    const ditto = this.ditto.deref()
+    if (!ditto) {
+      return
+    }
+
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    const dittoPointer = dittoHandle.derefOrNull()
+
+    if (!dittoPointer) {
+      return
+    }
+
+    return ditto.deferCloseAsync(async () => {
+      await FFI.dittoAuthClientLogout(dittoPointer)
+      ditto.stopSync()
+      cleanupFn?.(ditto)
+    })
+  }
+
+  readonly authenticationHandler: AuthenticationHandler
+
+  private ditto: WeakRef<Ditto>
+
+  constructor(keepAlive: KeepAlive, ditto: Ditto, authenticationHandler: AuthenticationHandler) {
+    super(keepAlive)
+    this._status = { isAuthenticated: false, userID: null }
+    this.ditto = new WeakRef<Ditto>(ditto)
+    this.authenticationHandler = authenticationHandler
+    this.updateAndNotify(false)
+  }
+
+  '@ditto.authenticationExpiring'(secondsRemaining: number): void {
+    const authenticationHandler = this.authenticationHandler
+    if (secondsRemaining > 0) {
+      authenticationHandler.authenticationExpiringSoon(this, secondsRemaining)
+    } else {
+      authenticationHandler.authenticationRequired(this)
+    }
+  }
+
+  '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): void {
+    this.updateAndNotify(true)
+  }
+
+  private updateAndNotify(shouldNotify: boolean) {
+    const ditto = this.ditto.deref()
+    if (!ditto) {
+      Logger.debug('Unable to update auth status and notify, related Ditto object does not exist anymore.')
+      return
+    }
+
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    const dittoPointer = dittoHandle.derefOrNull()
+    if (!dittoPointer) {
+      Logger.debug('Unable to update auth status and notify, related Ditto object does not exist anymore.')
+      return
+    }
+
+    const wasAuthenticated = this.status.isAuthenticated
+    const previousUserID = this.status.userID
+
+    const isAuthenticated = FFI.dittoAuthClientIsWebValid(dittoPointer)
+    const userID = FFI.dittoAuthClientUserID(dittoPointer)
+    const status = { isAuthenticated, userID }
+
+    this._status = status
+
+    if (shouldNotify) {
+      const sameStatus = !!wasAuthenticated === !!isAuthenticated && previousUserID === userID
+      if (!sameStatus) {
+        this.authenticationHandler.authenticationStatusDidChange?.call(this.authenticationHandler, this)
+        this.observerManager.notify(status)
+      }
+    }
+  }
+}
+
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export class NotAvailableAuthenticator extends Authenticator {
+  async loginWithToken(token: string, provider: string): Promise<never> {
+    throw new Error(`Can't login, authentication is not supported for the identity in use, please use an onlineWithAuthentication identity.`)
+  }
+
+  async loginWithUsernameAndPassword(username: string, password: string, provider: string): Promise<never> {
+    throw new Error(`Can't login, authentication is not supported for the identity in use, please use an onlineWithAuthentication identity.`)
+  }
+
+  logout(cleanupFn?: (ditto: Ditto) => void): Promise<never> {
+    throw new Error(`Can't logout, authentication is not supported for the identity in use, please use an onlineWithAuthentication identity.`)
+  }
+
+  '@ditto.authenticationExpiring'(secondsRemaining: number): never {
+    throw new Error(`Internal inconsistency, authentication is not available, yet the @ditto.authenticationExpiring() was called on authenticator: ${this}`)
+  }
+
+  '@ditto.authClientValidityChanged'(isWebValid: boolean, isX509Valid: boolean): never {
+    throw new Error(`Internal inconsistency, authentication is not available, yet the @ditto.authClientValidityChanged() was called on authenticator: ${this}`)
+  }
+}

package/react-native/src/sources/base-pending-cursor-operation.ts

@@ -0,0 +1,239 @@
+//
+// Copyright © 2023 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { Document, MutableDocument } from './document'
+import { UpdateResultsMap } from './update-results-map'
+import { CBOR } from './cbor'
+import { validateQuery } from './internal'
+import { performAsyncToWorkaroundNonAsyncFFIAPI } from './internal'
+import { Bridge } from './bridge'
+
+import type { DocumentID } from './document-id'
+import type { QueryArguments, SortDirection } from './essentials'
+import type { UpdateResult } from './update-result'
+import type { CollectionInterface } from './collection-interface'
+
+export abstract class BasePendingCursorOperation implements PromiseLike<Document[]> {
+  /**
+   * Removes all documents that match the query generated by the preceding
+   * function chaining.
+   *
+   * @returns An array promise containing the IDs of the documents that were
+   * removed.
+   */
+  abstract remove(): Promise<DocumentID[]>
+
+  /**
+   * Evicts all documents that match the query generated by the preceding
+   * function chaining.
+   *
+   * @return An array promise containing the IDs of the documents that were
+   * evicted.
+   */
+  abstract evict(): Promise<DocumentID[]>
+
+  /**
+   * Updates documents that match the query generated by the preceding function
+   * chaining.
+   *
+   * @param closure A closure that gets called with all of the documents
+   * matching the query. The documents are instances of {@link MutableDocument}
+   * so you can call update-related functions on them.
+   *
+   * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
+   * of {@link UpdateResult | update results} that describe the updates that
+   * were performed for each document.
+   */
+  abstract update(closure: (documents: MutableDocument[]) => void): Promise<UpdateResultsMap>
+
+  // ----------------------------------------------------------- Public --------
+
+  /** The query the receiver is operating with. */
+  readonly query: string
+
+  /** The named arguments for the {@link query}. */
+  readonly queryArgs: QueryArguments | null
+
+  /** The collection the receiver is operating on. */
+  readonly collection: CollectionInterface
+
+  /**
+   * Sorts the documents that match the query provided in the preceding
+   * `find`-like function call.
+   *
+   * @param query The query specifies the logic to be used when sorting the
+   * matching documents.
+   *
+   * @param direction Specify whether you want the sorting order to be
+   * `Ascending` or `Descending`.
+   *
+   * @return A cursor that you can chain further function calls and then either
+   * get the matching documents immediately or get updates about them over time.
+   */
+  sort(propertyPath: string, direction: SortDirection = 'ascending'): BasePendingCursorOperation {
+    this.orderBys.push({
+      query: propertyPath,
+      direction: direction === 'ascending' ? 'Ascending' : 'Descending',
+    })
+    return this
+  }
+
+  /**
+   * Offsets the resulting set of matching documents.
+   *
+   * This is useful if you aren't interested in the first N matching documents
+   * for one reason or another. For example, you might already have queried the
+   * collection and obtained the first 20 matching documents and so you might
+   * want to run the same query as you did previously but ignore the first 20
+   * matching documents, and that is when you would use `offset`.
+   *
+   * @param offset The number of matching documents that you want the eventual
+   * resulting set of matching documents to be offset by (and thus not include).
+   *
+   * @return A cursor that you can chain further function calls and then either
+   * get the matching documents immediately or get updates about them over time.
+   */
+  offset(offset: number): BasePendingCursorOperation {
+    if (offset < 0) throw new Error(`Can't offset by '${offset}', offset must be >= 0`)
+    if (!Number.isFinite(offset)) throw new Error(`Can't offset by '${offset}', offset must be a finite number`)
+    if (Number.isNaN(offset)) throw new Error(`Can't offset by '${offset}', offset must be a valid number`)
+
+    const integerOffset = Math.round(offset)
+    if (offset !== integerOffset) throw new Error(`Can't offset by '${offset}', offset must be an integer number`)
+
+    this.currentOffset = offset
+    return this
+  }
+
+  /**
+   * Limits the number of documents that get returned when querying a collection
+   * for matching documents.
+   *
+   * @param limit The maximum number of documents that will be returned.
+   *
+   * @return A cursor that you can chain further function calls and then either
+   * get the matching documents immediately or get updates about them over time.
+   */
+  limit(limit: number): BasePendingCursorOperation {
+    if (limit < -1) throw new Error(`Can't limit to '${limit}', limit must be >= -1 (where -1 means unlimited)`)
+    if (!Number.isFinite(limit)) throw new Error(`Can't limit to '${limit}', limit must be a finite number`)
+    if (Number.isNaN(limit)) throw new Error(`Can't limit to '${limit}', limit must be a valid number`)
+
+    const integerLimit = Math.round(limit)
+    if (limit !== integerLimit) throw new Error(`Can't limit to '${limit}', limit must be an integer number`)
+
+    this.currentLimit = limit
+    return this
+  }
+
+  /**
+   * Executes the query generated by the preceding function chaining and return
+   * the list of matching documents.
+   *
+   * @returns An array promise containing {@link Document | documents} matching
+   * the query generated by the preceding function chaining.
+   */
+  async exec(): Promise<Document[]> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      const query = this.query
+
+      const documentPointers: FFI.Pointer<FFI.FFIDocument>[] = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => {
+        return await FFI.collectionExecQueryStr(dittoHandle.deref(), this.collection.name, null, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset)
+      })
+
+      return documentPointers.map((documentPointer) => {
+        return Bridge.document.bridge(documentPointer)
+      })
+    })
+  }
+
+  // ----------------------------------------------------------- Internal ------
+
+  /**
+   * Updates documents that match the query generated by the preceding function
+   * chaining.
+   *
+   * @param closure A closure that gets called with all of the documents
+   * matching the query. The documents are instances of {@link MutableDocument}
+   * so you can call update-related functions on them.
+   * @param writeTransactionX  a transaction to perform the operation in.
+   *
+   * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
+   * of {@link UpdateResult | update results} that describe the updates that
+   * were performed for each document.
+   * @internal
+   */
+  async updateWithTransaction(closure: (documents: MutableDocument[]) => void, writeTransactionX: FFI.Pointer<FFI.FFIWriteTransaction>): Promise<UpdateResultsMap> {
+    const ditto = this.collection.store.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return ditto.deferCloseAsync(async () => {
+      return await performAsyncToWorkaroundNonAsyncFFIAPI(async () => {
+        const query = this.query
+
+        const documentsX = await FFI.collectionExecQueryStr(dittoHandle.deref(), this.collection.name, writeTransactionX, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset)
+
+        const mutableDocuments: MutableDocument[] = documentsX.map((documentX) => {
+          return Bridge.mutableDocument.bridge(documentX, () => new MutableDocument())
+        })
+
+        closure(mutableDocuments)
+
+        const updateResultsDocumentIDs = []
+        const updateResultsByDocumentIDString: { [documentID: string]: UpdateResult[] } = {}
+
+        for (const mutableDocument of mutableDocuments) {
+          const documentID = mutableDocument.id
+          const documentIDString = documentID.toString()
+          const updateResults = mutableDocument['@ditto.updateResults']
+
+          if (updateResultsByDocumentIDString[documentIDString]) {
+            throw new Error(`Internal inconsistency, update results for document ID as string already exist: ${documentIDString}`)
+          }
+
+          updateResultsDocumentIDs.push(documentID)
+          updateResultsByDocumentIDString[documentIDString] = updateResults
+
+          Bridge.mutableDocument.unregister(mutableDocument)
+        }
+
+        // NOTE: ownership of documentsX (and contained documents)
+        // is transferred to Rust at this point.
+        await FFI.collectionUpdateMultiple(dittoHandle.deref(), this.collection.name, writeTransactionX, documentsX)
+
+        return new UpdateResultsMap(updateResultsDocumentIDs, updateResultsByDocumentIDString)
+      })
+    })
+  }
+
+  /** @internal */
+  constructor(query: string, queryArgs: QueryArguments | null, collection: CollectionInterface) {
+    this.query = validateQuery(query)
+    this.queryArgs = queryArgs ? Object.freeze({ ...queryArgs }) : null
+    this.collection = collection
+    this.queryArgsCBOR = queryArgs ? CBOR.encode(queryArgs) : null
+  }
+
+  /** @internal */
+  then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2> {
+    return this.exec().then(onfulfilled, onrejected)
+  }
+
+  // ---------------------------------------------------------- Protected ------
+
+  /** @internal */
+  protected queryArgsCBOR: Uint8Array | null
+
+  /** @internal */
+  protected currentLimit = -1
+
+  /** @internal */
+  protected currentOffset = 0
+
+  /** @internal */
+  protected orderBys: FFI.OrderBy[] = []
+}