@dittolive/ditto 4.5.0 → 4.5.1-experimental.aarch64-linux.1.aarch64

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

@@ -1,89 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-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'
-
-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

@@ -1,314 +0,0 @@
-//
-// 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

@@ -1,237 +0,0 @@
-//
-// 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)
-        }
-
-        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[] = []
-}